fix(ui): preserve selected task blocker chains

Co-Authored-By: Paperclip <noreply@paperclip.ing>

Author: cryppadotta

packages/shared/src/types/issue.ts

@@ -396,6 +396,12 @@ export type IssueBlockerAttentionReason =
   | "attention_required"
   | null;
 
+export interface IssueBlockerAttentionIssueSummary {
+  id: string;
+  identifier: string | null;
+  title: string;
+}
+
 export interface IssueBlockerAttention {
   state: IssueBlockerAttentionState;
   reason: IssueBlockerAttentionReason;
@@ -408,8 +414,12 @@ export interface IssueBlockerAttention {
   sampleStalledBlockerIdentifier: string | null;
   /** True when a blocker or one of its open descendants is actively progressing. */
   blockingTreeLive?: boolean;
-  /** The sampled leaf blocker that requires action, rather than the blocked root. */
+  /** The direct blocker whose chain contains the sampled terminal blocker. */
+  directBlockerIssueId?: string | null;
+  /** The sampled blocker that requires action, rather than the blocked root. */
   terminalBlockerIssueId?: string | null;
+  /** Link-ready details for the sampled blocker, including non-terminal intermediate nodes. */
+  terminalBlocker?: IssueBlockerAttentionIssueSummary | null;
 }
 
 export type IssueReviewAttentionState = "none" | "covered" | "stalled";

server/src/__tests__/issue-blocker-attention.test.ts

@@ -447,6 +447,47 @@ describeEmbeddedPostgres("issue blocker attention", () => {
     });
   });
 
+  it("returns the direct path and link details when an intermediate blocker is selected", async () => {
+    const { companyId, agentId } = await createCompany("PBI");
+    const rootId = await insertIssue({ companyId, identifier: "PBI-1", title: "Root", status: "blocked" });
+    const directId = await insertIssue({
+      companyId,
+      identifier: "PBI-2",
+      title: "Direct blocker",
+      status: "blocked",
+    });
+    const intermediateId = await insertIssue({
+      companyId,
+      identifier: "PBI-3",
+      title: "Stalled intermediate review",
+      status: "in_review",
+      assigneeAgentId: agentId,
+    });
+    const leafId = await insertIssue({
+      companyId,
+      identifier: "PBI-4",
+      title: "Downstream leaf",
+      status: "todo",
+      assigneeAgentId: agentId,
+    });
+    await block({ companyId, blockerIssueId: directId, blockedIssueId: rootId });
+    await block({ companyId, blockerIssueId: intermediateId, blockedIssueId: directId });
+    await block({ companyId, blockerIssueId: leafId, blockedIssueId: intermediateId });
+
+    const root = (await svc.list(companyId, { status: "blocked" })).find((issue) => issue.id === rootId);
+
+    expect(root?.blockerAttention).toMatchObject({
+      state: "stalled",
+      directBlockerIssueId: directId,
+      terminalBlockerIssueId: intermediateId,
+      terminalBlocker: {
+        id: intermediateId,
+        identifier: "PBI-3",
+        title: "Stalled intermediate review",
+      },
+    });
+  });
+
   it("prefers needs_attention over stalled when the chain also has a hard attention case", async () => {
     const { companyId, agentId } = await createCompany("PBQ");
     const parentId = await insertIssue({ companyId, identifier: "PBQ-1", title: "Parent", status: "blocked" });

server/src/services/issues.ts

@@ -2094,7 +2094,9 @@ function createIssueBlockerAttention(input: Partial<IssueBlockerAttention> = {})
     sampleBlockerIdentifier: input.sampleBlockerIdentifier ?? null,
     sampleStalledBlockerIdentifier: input.sampleStalledBlockerIdentifier ?? null,
     blockingTreeLive: input.blockingTreeLive ?? false,
+    directBlockerIssueId: input.directBlockerIssueId ?? null,
     terminalBlockerIssueId: input.terminalBlockerIssueId ?? null,
+    terminalBlocker: input.terminalBlocker ?? null,
   };
 }
 
@@ -2758,6 +2760,11 @@ async function listIssueBlockerAttentionMap(
     const sampledTerminalIdentifier = sampleEntry?.result.stalled
       ? sampleEntry.result.sampleStalledBlockerIdentifier ?? sampleEntry.result.sampleBlockerIdentifier
       : sampleEntry?.result.sampleBlockerIdentifier ?? blockerSampleIdentifier(sampleNode);
+    const terminalBlockerIssueId =
+      sampleEntry?.result.terminalBlockerIssueId ?? issueIdForSample(sampledTerminalIdentifier);
+    const terminalBlockerNode = terminalBlockerIssueId
+      ? nodesById.get(terminalBlockerIssueId) ?? null
+      : null;
 
     let state: IssueBlockerAttention["state"];
     let reason: IssueBlockerAttention["reason"];
@@ -2788,8 +2795,15 @@ async function listIssueBlockerAttentionMap(
       sampleStalledBlockerIdentifier:
         stalledEntry?.result.sampleStalledBlockerIdentifier ?? sampleStalledFromChain ?? null,
       blockingTreeLive: topLevelEdges.some((edge) => pathHasLiveWork(edge.blockerIssueId, new Set([root.id]))),
-      terminalBlockerIssueId:
-        sampleEntry?.result.terminalBlockerIssueId ?? issueIdForSample(sampledTerminalIdentifier),
+      directBlockerIssueId: sampleEntry?.edge.blockerIssueId ?? null,
+      terminalBlockerIssueId,
+      terminalBlocker: terminalBlockerNode
+        ? {
+            id: terminalBlockerNode.id,
+            identifier: terminalBlockerNode.identifier,
+            title: terminalBlockerNode.title,
+          }
+        : null,
     }));
   }
 

ui/src/components/TaskChatThread.test.tsx

@@ -58,6 +58,22 @@ function render(ui: ReactElement) {
   flushSync(() => root!.render(<ThemeProvider>{ui}</ThemeProvider>));
 }
 
+function fakeScrollGeometry(
+  element: HTMLElement,
+  { scrollHeight = 1000, clientHeight = 400, scrollTop = 600 } = {},
+) {
+  let currentScrollTop = scrollTop;
+  Object.defineProperty(element, "scrollHeight", { value: scrollHeight, configurable: true });
+  Object.defineProperty(element, "clientHeight", { value: clientHeight, configurable: true });
+  Object.defineProperty(element, "scrollTop", {
+    get: () => currentScrollTop,
+    set: (value: number) => {
+      currentScrollTop = value;
+    },
+    configurable: true,
+  });
+}
+
 describe("TaskChatThread draft pass-through", () => {
   it("keeps the composer dock aligned with the thread's horizontal padding", () => {
     render(
@@ -203,6 +219,110 @@ describe("TaskChatThread blocker links", () => {
     expect(container.textContent).not.toContain("Ultimately blocked by");
   });
 
+  it("keeps a server-selected intermediate blocker on its direct chain", () => {
+    const selectedIntermediate = {
+      id: "intermediate-2",
+      identifier: "PAP-650",
+      title: "Stalled intermediate review",
+    };
+    const selectedDirect = {
+      id: "direct-2",
+      identifier: "PAP-600",
+      title: "Selected dependency",
+      status: "blocked" as const,
+      priority: "medium" as const,
+      assigneeAgentId: "agent-1",
+      assigneeUserId: null,
+      terminalBlockers: [{
+        id: "leaf-2",
+        identifier: "PAP-700",
+        title: "Deeper structural leaf",
+        status: "todo" as const,
+        priority: "medium" as const,
+        assigneeAgentId: "agent-2",
+        assigneeUserId: null,
+      }],
+    };
+
+    render(
+      <TaskChatThread
+        comments={[]}
+        onAdd={async () => {}}
+        issueStatus="blocked"
+        blockedBy={[
+          {
+            id: "direct-1",
+            identifier: "PAP-500",
+            title: "Unrelated dependency",
+            status: "todo",
+            priority: "low",
+            assigneeAgentId: null,
+            assigneeUserId: null,
+          },
+          selectedDirect,
+        ]}
+        blockerAttention={{
+          state: "stalled",
+          reason: "stalled_review",
+          unresolvedBlockerCount: 2,
+          coveredBlockerCount: 0,
+          stalledBlockerCount: 1,
+          attentionBlockerCount: 1,
+          sampleBlockerIdentifier: "PAP-650",
+          sampleStalledBlockerIdentifier: "PAP-650",
+          directBlockerIssueId: selectedDirect.id,
+          terminalBlockerIssueId: selectedIntermediate.id,
+          terminalBlocker: selectedIntermediate,
+        }}
+      />,
+    );
+
+    for (const notice of container.querySelectorAll('[data-testid="task-chat-blocker-links"]')) {
+      expect(notice.textContent).toContain("Blocked byPAP-600Selected dependency");
+      expect(notice.textContent).toContain("Ultimately blocked byPAP-650Stalled intermediate review");
+    }
+    expect(container.textContent).not.toContain("Unrelated dependency");
+    expect(container.textContent).not.toContain("Deeper structural leaf");
+  });
+
+  it("auto-follows the new bottom blocker row when a pinned thread becomes blocked", () => {
+    const comment = {
+      id: "comment-1",
+      companyId: "company-1",
+      issueId: "issue-1",
+      authorType: "user" as const,
+      authorAgentId: null,
+      authorUserId: "user-1",
+      body: "Waiting for the dependency.",
+      presentation: null,
+      metadata: null,
+      createdAt: new Date("2026-08-15T12:00:00.000Z"),
+      updatedAt: new Date("2026-08-15T12:00:00.000Z"),
+    };
+    const directBlocker = {
+      id: "direct-1",
+      identifier: "PAP-500",
+      title: "Direct dependency",
+      status: "in_progress" as const,
+      priority: "medium" as const,
+      assigneeAgentId: "agent-1",
+      assigneeUserId: null,
+    };
+    const baseProps = {
+      comments: [comment],
+      onAdd: async () => {},
+      blockedBy: [directBlocker],
+    };
+
+    render(<TaskChatThread {...baseProps} issueStatus="in_progress" />);
+    const scroller = container.querySelector<HTMLElement>('[data-testid="task-chat-scroller"]')!;
+    fakeScrollGeometry(scroller);
+
+    render(<TaskChatThread {...baseProps} issueStatus="blocked" />);
+
+    expect(scroller.scrollTop).toBe(scroller.scrollHeight);
+  });
+
   it("does not show blocker rows outside the blocked state", () => {
     render(
       <TaskChatThread

ui/src/components/TaskChatThread.tsx

@@ -136,9 +136,20 @@ export function TaskChatThread(props: TaskChatThreadProps) {
 
   const blockerLinks = useMemo(
     () => issueStatus === "blocked"
-      ? resolveTaskChatBlockers(blockedBy, blockerAttention?.terminalBlockerIssueId)
+      ? resolveTaskChatBlockers(
+          blockedBy,
+          blockerAttention?.terminalBlockerIssueId,
+          blockerAttention?.directBlockerIssueId,
+          blockerAttention?.terminalBlocker,
+        )
       : null,
-    [blockedBy, blockerAttention?.terminalBlockerIssueId, issueStatus],
+    [
+      blockedBy,
+      blockerAttention?.directBlockerIssueId,
+      blockerAttention?.terminalBlocker,
+      blockerAttention?.terminalBlockerIssueId,
+      issueStatus,
+    ],
   );
 
   const threadHeaderWithBlockers = threadHeader || blockerLinks ? (
@@ -470,7 +481,10 @@ export function TaskChatThread(props: TaskChatThreadProps) {
     if ("content" in entry) return total + entry.content.length;
     return total + entry.kind.length;
   }, tailEntries.length);
-  const threadContentKey = taskChatContentKey(items) + tailContentKey;
+  const blockerContentKey = blockerLinks
+    ? `${blockerLinks.directBlocker.id}:${blockerLinks.ultimateBlocker?.id ?? ""}`
+    : "";
+  const threadContentKey = `${taskChatContentKey(items)}:${tailContentKey}:${blockerContentKey}`;
 
   // Status-pill inputs for the tail (PAP-461, A1): the run's start, its finish
   // (once terminal), and the "called N tools" summary. Memoized on the

ui/src/components/task-chat/TaskChatBlockerLinks.tsx

@@ -1,4 +1,7 @@
-import type { IssueRelationIssueSummary } from "@paperclipai/shared";
+import type {
+  IssueBlockerAttentionIssueSummary,
+  IssueRelationIssueSummary,
+} from "@paperclipai/shared";
 import { createIssueDetailPath } from "@/lib/issueDetailBreadcrumb";
 import { Link } from "@/lib/router";
 
@@ -9,23 +12,41 @@ function isUnresolved(blocker: IssueRelationIssueSummary): boolean {
 export function resolveTaskChatBlockers(
   blockers: IssueRelationIssueSummary[],
   terminalBlockerIssueId?: string | null,
+  directBlockerIssueId?: string | null,
+  terminalBlocker?: IssueBlockerAttentionIssueSummary | null,
 ): {
-  directBlocker: IssueRelationIssueSummary;
-  ultimateBlocker: IssueRelationIssueSummary | null;
+  directBlocker: IssueRelationIssueSummary | IssueBlockerAttentionIssueSummary;
+  ultimateBlocker: IssueRelationIssueSummary | IssueBlockerAttentionIssueSummary | null;
 } | null {
   const unresolvedBlockers = blockers.filter(isUnresolved);
   if (unresolvedBlockers.length === 0) return null;
 
-  const directBlocker = terminalBlockerIssueId
-    ? unresolvedBlockers.find((blocker) => (
-        blocker.id === terminalBlockerIssueId
-        || blocker.terminalBlockers?.some((terminal) => terminal.id === terminalBlockerIssueId)
-      )) ?? unresolvedBlockers[0]
-    : unresolvedBlockers[0];
+  const directBlocker = directBlockerIssueId
+    ? unresolvedBlockers.find((blocker) => blocker.id === directBlockerIssueId)
+    : terminalBlockerIssueId
+      ? unresolvedBlockers.find((blocker) => (
+          blocker.id === terminalBlockerIssueId
+          || blocker.terminalBlockers?.some((terminal) => terminal.id === terminalBlockerIssueId)
+        ))
+      : unresolvedBlockers[0];
+
+  // A selected intermediate blocker is not part of `terminalBlockers`, which
+  // intentionally contains only structural leaves. If its direct path is not
+  // in this payload (for example a child-derived attention path), show the
+  // selected task itself instead of falling back to an unrelated blocker.
+  if (!directBlocker) {
+    if (!terminalBlocker) return null;
+    return {
+      directBlocker: terminalBlocker,
+      ultimateBlocker: null,
+    };
+  }
 
   const terminalBlockers = directBlocker.terminalBlockers?.filter(isUnresolved) ?? [];
   const ultimateBlocker = terminalBlockerIssueId
-    ? terminalBlockers.find((blocker) => blocker.id === terminalBlockerIssueId) ?? null
+    ? terminalBlocker?.id === terminalBlockerIssueId
+      ? terminalBlocker
+      : terminalBlockers.find((blocker) => blocker.id === terminalBlockerIssueId) ?? null
     : terminalBlockers[0] ?? null;
 
   return {
@@ -39,7 +60,7 @@ function BlockerRow({
   blocker,
 }: {
   label: string;
-  blocker: IssueRelationIssueSummary;
+  blocker: IssueRelationIssueSummary | IssueBlockerAttentionIssueSummary;
 }) {
   const issuePathId = blocker.identifier ?? blocker.id;
 
@@ -63,8 +84,8 @@ export function TaskChatBlockerLinks({
   ultimateBlocker,
   placement,
 }: {
-  directBlocker: IssueRelationIssueSummary;
-  ultimateBlocker: IssueRelationIssueSummary | null;
+  directBlocker: IssueRelationIssueSummary | IssueBlockerAttentionIssueSummary;
+  ultimateBlocker: IssueRelationIssueSummary | IssueBlockerAttentionIssueSummary | null;
   placement: "top" | "bottom";
 }) {
   return (