fix(interactions): refuse to resolve a card whose issue is already closed

`queueResolvedInteractionContinuationWakeup` drops the continuation wakeup
when the issue is `done`/`cancelled`. The `accept`, `reject`, `respond` and
`verdicts` routes never looked at the issue status, so a resolution there ran
all the way through: the card flipped to `accepted`/`rejected`/`answered`,
`logActivity` recorded it, the route answered 200 — and nobody was woken. The
card reads as answerable in the UI, someone answers it in good faith, and
nothing happens. No error, no hint.

Closing an issue expires its pending cards (#10251), so in the normal case
the `status !== "pending"` check already refuses these. What it does not cover
is the residue: rows that were filed before that expiry shipped are still
`pending` on issues that closed months ago. On the instance this was found on,
154 such cards sit on 145 closed issues, 146 of them carrying
`continuationPolicy: wake_assignee` — every one of them a trap that looks
answerable and is not. Three of them ask the reader in their prompt to reply.

So the guard is a second line rather than the first: it reads the issue status
after the pending check and answers 409 with the closed status in the error
details, which is the honest outcome for an answer that cannot travel. An
already-resolved card still reports "Interaction has already been resolved" —
that message is more specific, and the ordering keeps this change to the one
case that is currently silent.

`withdraw` and `cancel` are deliberately left alone. Retiring a stale card on a
closed issue is exactly the cleanup those routes exist for, and blocking them
would strand the residue this guard makes visible.

The status is read from the database inside the resolution path rather than
taken from the caller's issue object, so the plugin host's accept/reject path
is covered by the same check and not just the HTTP routes.

Co-Authored-By: Paperclip <noreply@paperclip.ing>
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: 3 people

server/src/services/issue-thread-interactions.test.ts

@@ -11,25 +11,35 @@ vi.mock("./issues.js", () => ({
 
 type SelectRow = Record<string, unknown>;
 
-function createSelectChain(rows: SelectRow[]) {
+function createWhereChain(rows: SelectRow[]) {
   return {
-    from() {
+    where() {
       return {
-        where() {
-          return {
-            then(callback: (rows: SelectRow[]) => unknown) {
-              return Promise.resolve(callback(rows));
-            },
-          };
+        then(callback: (rows: SelectRow[]) => unknown) {
+          return Promise.resolve(callback(rows));
         },
       };
     },
   };
 }
 
+function createSelectChain(rows: SelectRow[]) {
+  return {
+    from() {
+      return createWhereChain(rows);
+    },
+  };
+}
+
 function createFakeDb(args: {
   interactionRow: Record<string, unknown>;
   parentRows?: SelectRow[];
+  /**
+   * Rows the `issues` table answers with. Only consulted when set, so the
+   * call-ordered defaults above stay untouched for the tests that do not care
+   * about the issue's status.
+   */
+  issueRows?: SelectRow[];
 }) {
   let interactionRow = { ...args.interactionRow };
   const issueTouches: Array<Record<string, unknown>> = [];
@@ -38,10 +48,15 @@ function createFakeDb(args: {
   let selectCallCount = 0;
 
   const db: any = {
-    select: vi.fn(() => {
-      selectCallCount += 1;
-      return createSelectChain(selectCallCount === 1 ? [interactionRow] : (args.parentRows ?? []));
-    }),
+    select: vi.fn(() => ({
+      from(table: unknown) {
+        if (args.issueRows && getTableName(table as never) === "issues") {
+          return createWhereChain(args.issueRows);
+        }
+        selectCallCount += 1;
+        return createWhereChain(selectCallCount === 1 ? [interactionRow] : (args.parentRows ?? []));
+      },
+    })),
     update: vi.fn((table: unknown) => ({
       set(values: Record<string, unknown>) {
         return {
@@ -327,4 +342,112 @@ describe("issueThreadInteractionService", () => {
     expect(state.toolActionRequestUpdates).toHaveLength(1);
     expect(state.toolActionRequestUpdates[0]).toMatchObject({ status: "expired", resolvedByUserId: "local-board" });
   });
+
+  describe("resolving a card whose issue is already closed", () => {
+    const ISSUE_ID = "11111111-1111-4111-8111-111111111111";
+
+    function confirmationRow(overrides: Record<string, unknown> = {}) {
+      return {
+        id: "interaction-closed-carrier", companyId: "company-1", issueId: ISSUE_ID,
+        kind: "request_confirmation", status: "pending", continuationPolicy: "wake_assignee",
+        sourceCommentId: null, sourceRunId: null, title: null, summary: null,
+        createdByAgentId: "agent-1", createdByUserId: null, resolvedByAgentId: null, resolvedByUserId: null,
+        payload: { version: 1, prompt: "Proceed?" }, result: null, resolvedAt: null,
+        createdAt: new Date("2026-07-25T10:00:00.000Z"), updatedAt: new Date("2026-07-25T10:00:00.000Z"),
+        ...overrides,
+      };
+    }
+
+    function questionsRow() {
+      return confirmationRow({
+        id: "interaction-closed-questions",
+        kind: "ask_user_questions",
+        payload: {
+          version: 1,
+          questions: [{
+            id: "scope", prompt: "Pick one", selectionMode: "single",
+            options: [{ id: "a", label: "A" }],
+          }],
+        },
+      });
+    }
+
+    for (const issueStatus of ["done", "cancelled"] as const) {
+      it(`refuses to accept a confirmation on a ${issueStatus} issue`, async () => {
+        const { issueThreadInteractionService } = await import("./issue-thread-interactions.js");
+        const state = createFakeDb({ interactionRow: confirmationRow(), issueRows: [{ status: issueStatus }] });
+        const svc = issueThreadInteractionService(state.db as never);
+
+        await expect(svc.acceptInteraction(
+          { id: ISSUE_ID, companyId: "company-1", projectId: null, goalId: null },
+          "interaction-closed-carrier",
+          {},
+          { userId: "local-board" },
+        )).rejects.toMatchObject({ status: 409 });
+        // The silent failure this guards against is exactly a card that flips to
+        // "accepted" while no continuation wakeup fires, so the card must not move.
+        expect(state.interactionUpdates).toHaveLength(0);
+        expect(state.getInteractionRow().status).toBe("pending");
+      });
+    }
+
+    it("refuses to reject a confirmation on a closed issue", async () => {
+      const { issueThreadInteractionService } = await import("./issue-thread-interactions.js");
+      const state = createFakeDb({ interactionRow: confirmationRow(), issueRows: [{ status: "done" }] });
+      const svc = issueThreadInteractionService(state.db as never);
+
+      await expect(svc.rejectInteraction(
+        { id: ISSUE_ID, companyId: "company-1" },
+        "interaction-closed-carrier",
+        { reason: "No" },
+        { userId: "local-board" },
+      )).rejects.toMatchObject({ status: 409 });
+      expect(state.interactionUpdates).toHaveLength(0);
+    });
+
+    it("refuses to answer questions on a closed issue", async () => {
+      const { issueThreadInteractionService } = await import("./issue-thread-interactions.js");
+      const state = createFakeDb({ interactionRow: questionsRow(), issueRows: [{ status: "cancelled" }] });
+      const svc = issueThreadInteractionService(state.db as never);
+
+      await expect(svc.answerQuestions(
+        { id: ISSUE_ID, companyId: "company-1" },
+        "interaction-closed-questions",
+        { answers: [{ questionId: "scope", optionIds: ["a"] }] },
+        { userId: "local-board" },
+      )).rejects.toMatchObject({ status: 409 });
+      expect(state.interactionUpdates).toHaveLength(0);
+    });
+
+    it("still lets the creator withdraw a card whose issue is closed", async () => {
+      const { issueThreadInteractionService } = await import("./issue-thread-interactions.js");
+      const state = createFakeDb({ interactionRow: confirmationRow(), issueRows: [{ status: "done" }] });
+      const svc = issueThreadInteractionService(state.db as never);
+
+      const withdrawn = await svc.withdrawInteraction(
+        { id: ISSUE_ID, companyId: "company-1" },
+        "interaction-closed-carrier",
+        { reason: "Superseded" },
+        { agentId: "agent-1" },
+      );
+
+      expect(withdrawn.status).toBe("cancelled");
+    });
+
+    it("keeps reporting an already-resolved card as resolved rather than as a closed issue", async () => {
+      const { issueThreadInteractionService } = await import("./issue-thread-interactions.js");
+      const state = createFakeDb({
+        interactionRow: confirmationRow({ status: "expired" }),
+        issueRows: [{ status: "done" }],
+      });
+      const svc = issueThreadInteractionService(state.db as never);
+
+      await expect(svc.acceptInteraction(
+        { id: ISSUE_ID, companyId: "company-1", projectId: null, goalId: null },
+        "interaction-closed-carrier",
+        {},
+        { userId: "local-board" },
+      )).rejects.toMatchObject({ status: 409, message: "Interaction has already been resolved" });
+    });
+  });
 });

server/src/services/issue-thread-interactions.ts

@@ -78,6 +78,7 @@ type ResolvedInteractionResult = {
 
 type IssueThreadInteractionRow = typeof issueThreadInteractions.$inferSelect;
 type IssueTouchDb = Pick<Db, "update">;
+type IssueStatusReadDb = Pick<Db, "select">;
 
 type IssueResolutionContext = {
   id: string;
@@ -240,6 +241,40 @@ function isTerminalIssueStatus(status: string) {
   return status === "done" || status === "cancelled";
 }
 
+/**
+ * A resolution on a closed issue must not look like it worked.
+ *
+ * `queueResolvedInteractionContinuationWakeup` (`server/src/routes/issues.ts`)
+ * drops the continuation wakeup when the issue is `done`/`cancelled`, so an
+ * accept/reject/answer there sets the card to a resolved status, writes the
+ * activity entry, returns 200 — and wakes nobody. The card reads as answerable
+ * in the UI, someone answers it in good faith, and nothing happens: no error,
+ * no hint.
+ *
+ * Closing an issue expires its pending cards, so in the normal case the
+ * resolution routes already fail on the `status !== "pending"` check. This guard
+ * covers what that leaves: rows filed before auto-expiry-on-close shipped, and
+ * any path that put an issue into a terminal status without going through it.
+ *
+ * Deliberately not applied to the administrative resolutions (withdraw, cancel):
+ * retiring a stale card on a closed issue is exactly the cleanup those exist for.
+ */
+async function assertIssueOpenForInteractionResolution(
+  db: IssueStatusReadDb,
+  issue: { id: string; companyId: string },
+) {
+  const [row] = await db
+    .select({ status: issues.status })
+    .from(issues)
+    .where(and(eq(issues.id, issue.id), eq(issues.companyId, issue.companyId)));
+  if (!row || !isTerminalIssueStatus(row.status)) return;
+  throw conflict(
+    "Cannot resolve an interaction on a closed issue: the answer would not resume any work. "
+      + "Reopen the issue first, or withdraw the interaction.",
+    { issueId: issue.id, issueStatus: row.status },
+  );
+}
+
 function shouldReturnAcceptedConfirmationToCreatorAgent(args: {
   issue: IssueResolutionContext;
   current: IssueThreadInteractionRow;
@@ -1028,6 +1063,7 @@ export function issueThreadInteractionService(db: Db) {
     if (current.status !== "pending") {
       throw conflict("Interaction has already been resolved");
     }
+    await assertIssueOpenForInteractionResolution(db, args.issue);
     return current;
   }
 
@@ -1591,6 +1627,7 @@ export function issueThreadInteractionService(db: Db) {
           }
           throw conflict("Interaction has already been resolved");
         }
+        await assertIssueOpenForInteractionResolution(tx, issue);
 
         const expired = await expireStaleRequestConfirmationTarget(tx, {
           row: current,
@@ -2129,6 +2166,7 @@ export function issueThreadInteractionService(db: Db) {
       if (current.status !== "pending") {
         throw conflict("Interaction has already been resolved");
       }
+      await assertIssueOpenForInteractionResolution(db, issue);
 
       const interaction = hydrateInteraction(current) as AskUserQuestionsInteraction;
       const normalizedAnswers = normalizeQuestionAnswers({

skills/paperclip/references/api-reference.md

@@ -975,7 +975,7 @@ Resolved result (`RequestCheckboxConfirmationResult`):
 Other outcomes match `request_confirmation`:
 
 - `withdrawn` — `{ outcome: "withdrawn", reason }`. Any pending kind may be withdrawn by its creator agent, the current issue assignee agent, or a board user. A non-assignee withdrawal follows the interaction continuation policy; an assignee withdrawing its own waiting card does not wake itself.
-- `issue_closed` — `{ outcome: "issue_closed" }`. Transitioning the issue to `done` or `cancelled` expires all pending interactions without continuation wakes; listing a terminal issue also performs a catch-up sweep for historical residue.
+- `issue_closed` — `{ outcome: "issue_closed" }`. Transitioning the issue to `done` or `cancelled` expires all pending interactions without continuation wakes; listing a terminal issue also performs a catch-up sweep for historical residue. A card that is still `pending` on a closed issue (filed before that expiry shipped) cannot be resolved: `accept`, `reject`, `respond` and `verdicts` return **409** rather than recording an answer that wakes nobody. `withdraw` and `cancel` stay available so a stale card can still be retired.
 
 - `rejected` — `{ outcome: "rejected", reason, commentId }`. `selectedOptionIds` is absent.
 - `superseded_by_comment` — `{ outcome: "superseded_by_comment", commentId }`. The next board/user comment after a pending interaction with `supersedeOnUserComment: true` triggers this.