PRs tab fixes: state-aware badges, expandable issue rows, composer pending-input lock

- prs: lane-scoped PR display falls back to merged/closed PRs; state-aware badge labels (`formatPrBadgeLabel`)
- prs: PrConvergencePanel issue rows are expandable with author/body/thread comment count, "show ignored" toggle, "Ignore comment" rename, manual-run round labels
- prs: dedupe Actions check entries; ignore/expand review items
- lanes: state-aware lane-list PR tag via `selectLanePrTag`
- chat: hard-lock composer + server-side gate while `pendingInput.blocking` is set; merged-PR display in PrDetailPane
- ios: WorkChatSessionView updates to match new chat lock contract
- docs: refresh chat/composer-and-ui, lanes/README, pull-requests/README

Author: arul28

apps/ade-cli/package-lock.json

@@ -9670,6 +9670,56 @@ describe("createAgentChatService", () => {
     expect(readPersistedChatState(session.id).awaitingInput).toBeUndefined();
   });
 
+  it("rejects normal chat sends while a pending input request is waiting", async () => {
+    const events: AgentChatEventEnvelope[] = [];
+    const { service } = createService({
+      onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+    });
+
+    const session = await service.createSession({
+      laneId: "lane-1",
+      provider: "codex",
+      model: "gpt-5.4",
+    });
+
+    const requestPromise = service.requestChatInput({
+      chatSessionId: session.id,
+      title: "Pending question",
+      body: "Which path should we take?",
+      questions: [{
+        id: "answer",
+        header: "Question 1",
+        question: "Which path should we take?",
+        allowsFreeform: true,
+      }],
+    });
+
+    const approvalEvent = await waitForEvent(
+      events,
+      (event): event is AgentChatEventEnvelope & {
+        event: Extract<AgentChatEventEnvelope["event"], { type: "approval_request" }>;
+      } => {
+        const detail = event.event.type === "approval_request"
+          ? (event.event.detail as { request?: { title?: string } } | undefined)
+          : undefined;
+        return event.event.type === "approval_request" && detail?.request?.title === "Pending question";
+      },
+    );
+
+    await expect(service.sendMessage({
+      sessionId: session.id,
+      text: "Treat this as the answer even though it came through chat.send.",
+    })).rejects.toThrow("Answer or decline the pending request before sending another message.");
+
+    await service.respondToInput({
+      sessionId: session.id,
+      itemId: approvalEvent.event.itemId,
+      decision: "decline",
+    });
+
+    await expect(requestPromise).resolves.toMatchObject({ decision: "decline" });
+  });
+
   it("maps freeform replies to the single pending question when only one answer is needed", async () => {
     const events: AgentChatEventEnvelope[] = [];
     const { service } = createService({

apps/desktop/src/main/services/chat/agentChatService.test.ts

@@ -855,9 +855,12 @@ function normalizeCodexAssistantDelta(
   return args.delta;
 }
 
+const PENDING_INPUT_SEND_BLOCKED_MESSAGE = "Answer or decline the pending request before sending another message.";
+
 function validateSessionReadyForTurn(managed: ManagedChatSession): { ready: true } | { ready: false; reason: string } {
   if (managed.closed) return { ready: false, reason: "Session is disposed" };
   if (!managed.runtime) return { ready: false, reason: "No runtime initialized" };
+  if (hasLivePendingInput(managed)) return { ready: false, reason: PENDING_INPUT_SEND_BLOCKED_MESSAGE };
   const rt = managed.runtime;
   if ((rt.kind === "opencode" || rt.kind === "claude" || rt.kind === "cursor" || rt.kind === "droid") && rt.busy) {
     return { ready: false, reason: "Turn already active" };
@@ -12266,6 +12269,9 @@ export function createAgentChatService(args: {
     const visibleText = displayText?.trim().length ? displayText.trim() : trimmed;
 
     const managed = ensureManagedSession(sessionId);
+    if (hasLivePendingInput(managed)) {
+      throw new Error(PENDING_INPUT_SEND_BLOCKED_MESSAGE);
+    }
     const executionContext = refreshManagedLaneLaunchContext(managed);
     const publicAttachments = attachments.map((attachment) => ({
       ...attachment,
@@ -15573,6 +15579,9 @@ export function createAgentChatService(args: {
     }
 
     const managed = ensureManagedSession(sessionId);
+    if (hasLivePendingInput(managed)) {
+      throw new Error(PENDING_INPUT_SEND_BLOCKED_MESSAGE);
+    }
 
     // OpenCode runtime steer
     if (managed.runtime?.kind === "opencode") {
@@ -15856,6 +15865,9 @@ export function createAgentChatService(args: {
     if (managed.session.provider === "codex") {
       throw new Error("dispatchSteer is not supported on Codex sessions.");
     }
+    if (hasLivePendingInput(managed)) {
+      throw new Error(PENDING_INPUT_SEND_BLOCKED_MESSAGE);
+    }
     const runtime = managed.runtime;
     if (!runtime) return { dispatchedAt: null };
     if (runtime.kind !== "claude") {

apps/desktop/src/main/services/chat/agentChatService.ts

@@ -277,7 +277,7 @@ describe("prService.getForLane", () => {
     expect(service.getForLane(lane.id)?.githubPrNumber).toBe(93);
   });
 
-  it("ignores terminal PR rows when resolving the current lane PR", () => {
+  it("surfaces a merged PR row when it still matches the current lane branch", () => {
     const lane = makeFakeLane({
       branchRef: "refs/heads/current-feature",
     });
@@ -289,6 +289,21 @@ describe("prService.getForLane", () => {
       }),
     ]);
 
+    expect(service.getForLane(lane.id)?.state).toBe("merged");
+  });
+
+  it("ignores terminal PR rows whose head branch no longer matches the lane branch", () => {
+    const lane = makeFakeLane({
+      branchRef: "refs/heads/current-feature",
+    });
+    const service = buildGetForLaneService(lane, [
+      makePrRow({
+        lane_id: lane.id,
+        state: "merged",
+        head_branch: "old-feature",
+      }),
+    ]);
+
     expect(service.getForLane(lane.id)).toBeNull();
   });
 

apps/desktop/src/main/services/prs/prService.test.ts

@@ -904,7 +904,10 @@ export function createPrService({
 
   const rowMatchesCurrentLaneBranch = (row: PullRequestRow, lane: LanePrLookupRow): boolean => {
     if (!isActivePrState(row.state)) return false;
+    return rowMatchesLaneBranchForDisplay(row, lane);
+  };
 
+  const rowMatchesLaneBranchForDisplay = (row: PullRequestRow, lane: LanePrLookupRow): boolean => {
     const laneBranch = normalizeBranchName(branchNameFromRef(lane.branch_ref ?? ""));
     const prHeadBranch = normalizeBranchName(row.head_branch);
     if (!laneBranch || !prHeadBranch || laneBranch !== prHeadBranch) return false;
@@ -917,6 +920,30 @@ export function createPrService({
     return true;
   };
 
+  const getDisplayRowForCurrentLaneBranch = (laneId: string): PullRequestRow | null => {
+    const lane = getLanePrLookupRow(laneId);
+    if (!lane || lane.archived_at) return null;
+
+    const rows = db.all<PullRequestRow>(
+      `
+        select ${PR_COLUMNS}
+          from pull_requests
+         where lane_id = ?
+           and project_id = ?
+         order by
+           case when state in ('open', 'draft') then 0 when state = 'merged' then 1 else 2 end,
+           updated_at desc,
+           created_at desc
+      `,
+      [laneId, projectId],
+    );
+
+    const laneBranch = normalizeBranchName(branchNameFromRef(lane.branch_ref ?? ""));
+    if (!laneBranch) return rows[0] ?? null;
+
+    return rows.find((row) => rowMatchesLaneBranchForDisplay(row, lane)) ?? null;
+  };
+
   const getActiveRowForCurrentLaneBranch = (laneId: string): PullRequestRow | null => {
     const lane = getLanePrLookupRow(laneId);
     if (!lane || lane.archived_at) return null;
@@ -5214,7 +5241,7 @@ export function createPrService({
     },
 
     getForLane(laneId: string): PrSummary | null {
-      const row = getActiveRowForCurrentLaneBranch(laneId);
+      const row = getDisplayRowForCurrentLaneBranch(laneId);
       return row ? rowToSummary(row) : null;
     },
 

apps/desktop/src/main/services/prs/prService.ts

@@ -303,10 +303,46 @@ describe("AgentChatComposer", () => {
       },
     });
 
-    expect(screen.getByText("Answer in the inline question card, or type below.")).toBeTruthy();
+    expect(screen.getByText("Answer in the inline question card, or decline.")).toBeTruthy();
     expect(screen.queryByText("Answer in the inline question card, or pick an option there.")).toBeNull();
   });
 
+  it("locks the prompt box while a pending question is waiting", () => {
+    const props = renderComposer({
+      pendingInput: {
+        requestId: "req-lock",
+        itemId: "item-lock",
+        source: "claude",
+        kind: "question",
+        title: "Input needed",
+        description: "What should we do next?",
+        questions: [{
+          id: "answer",
+          header: "Question 1",
+          question: "What should we do next?",
+          allowsFreeform: true,
+        }],
+        allowsFreeform: true,
+        blocking: true,
+        canProceedWithoutAnswer: false,
+        turnId: null,
+      },
+    });
+
+    const textbox = screen.getByRole("textbox") as HTMLTextAreaElement;
+    expect(textbox.disabled).toBe(true);
+    expect(textbox.placeholder).toBe("Answer the question card above, or decline it.");
+    expect(screen.queryByLabelText("Send steer message")).toBeNull();
+    expect((screen.getByLabelText("Open attachment picker") as HTMLButtonElement).disabled).toBe(true);
+    expect((screen.getByLabelText("Upload file from disk") as HTMLButtonElement).disabled).toBe(true);
+    expect((screen.getByLabelText("Open command picker") as HTMLButtonElement).disabled).toBe(true);
+
+    fireEvent.keyDown(textbox, { key: "Enter" });
+
+    expect(props.onApproval).not.toHaveBeenCalled();
+    expect(props.onSubmit).not.toHaveBeenCalled();
+  });
+
   it("keeps the option hint when a pending question includes selectable options", () => {
     renderComposer({
       pendingInput: {