fix(dashboard-agent): fail a watch investigation whose card refuses to close

Only a deleted chat is swallowed now. A refused close left the card in_progress while the
action reported success, so the panel span forever with nothing to retry it.

Author: kathiekiwi

internal-packages/dashboard-agent/src/watch-actions.test.ts

@@ -921,6 +921,68 @@ describe("watch investigation", () => {
     ).toEqual([]);
   });
 
+  /** A store whose atomic close refuses rather than throws, with the reason it refuses for. */
+  function refusingStore(error: "not_found" | "context_mismatch" | "chat_missing") {
+    const { store, calls } = fakeStore({
+      openInvestigation: { id: "inv_seeded", projectRef: "proj_abc", environmentRef: "env_abc" },
+    });
+    const wrapped: DashboardAgentStore = {
+      ...store,
+      settleInvestigationCard: async (args) => {
+        calls.settleInvestigationCard.push(args);
+        return { ok: false as const, error };
+      },
+    };
+    return { store: wrapped, calls };
+  }
+
+  async function investigateAgainst(store: DashboardAgentStore, chatId: string) {
+    const { model } = recordingModel([
+      renderStep(inProgress, "inv_seeded", "tc_open"),
+      textStep("still looking"),
+    ]);
+    harness = mockChatAgent(dashboardAgent, {
+      chatId,
+      clientData: CLIENT_DATA_WITH_TOKEN,
+      setupLocals: ({ set }) => {
+        set(dashboardAgentStoreKey, store);
+        set(dashboardAgentModelKey, model);
+      },
+    });
+    return harness.sendAction(INVESTIGATE);
+  }
+
+  function erroredWith(turn: { chunks: unknown[] }, pattern: RegExp) {
+    return turn.chunks.some(
+      (chunk) =>
+        (chunk as { type?: string }).type === "error" &&
+        pattern.test((chunk as { errorText?: string }).errorText ?? "")
+    );
+  }
+
+  /**
+   * A refused close is the same failure as a thrown one: the card never landed, so the
+   * panel spins until the action is retried, and only a thrown error gets it retried.
+   */
+  it.each(["not_found", "context_mismatch"] as const)(
+    "fails the action when the close is refused with %s",
+    async (error) => {
+      const { store, calls } = refusingStore(error);
+      const turn = await investigateAgainst(store, `chat_investigate_refused_${error}`);
+
+      expect(calls.settleInvestigationCard).toHaveLength(1);
+      expect(erroredWith(turn, new RegExp(error))).toBe(true);
+    }
+  );
+
+  it("reports success when the close is refused because the chat is gone", async () => {
+    const { store, calls } = refusingStore("chat_missing");
+    const turn = await investigateAgainst(store, "chat_investigate_refused_chat_missing");
+
+    expect(calls.settleInvestigationCard).toHaveLength(1);
+    expect(erroredWith(turn, /chat_missing|couldn't close/)).toBe(false);
+  });
+
   it("says nothing when the kick carries no tenancy to scope a card with", async () => {
     const { store, calls } = fakeStore();
     harness = mockChatAgent(dashboardAgent, {

internal-packages/dashboard-agent/src/watch-actions.ts

@@ -602,8 +602,8 @@ async function resolveInvestigationId(args: {
  * Close the card this lane opened: its terminal revision and the closing card in one
  * transaction, so a terminal row whose card never landed cannot exist.
  *
- * Nothing is caught. The row settles only if the card lands, and the failure has to
- * reach the action for the task's retry to be a real retry.
+ * Only a deleted chat is swallowed. The row settles only if the card lands, and every other
+ * failure has to reach the action for the task's retry to be a real retry.
  */
 async function closeCardInTranscript(args: {
   store: DashboardAgentStore;
@@ -633,13 +633,16 @@ async function closeCardInTranscript(args: {
     messageId: args.messageId,
   });
   if (!result.ok) {
-    // A chat deleted mid-investigation is a race, not a fault: nothing settled, and
-    // there is no transcript left to close the card in.
     const message = "dashboard-agent watch investigation couldn't close its card";
     const details = { chatId, investigationId, error: result.error };
-    if (result.error === "chat_missing") logger.warn(message, details);
-    else logger.error(message, details);
-    return;
+    // A chat deleted mid-investigation is a race, not a fault: nothing settled, and there
+    // is no transcript left to close the card in.
+    if (result.error === "chat_missing") {
+      logger.warn(message, details);
+      return;
+    }
+    logger.error(message, details);
+    throw new Error(`${message}: ${result.error}`);
   }
 
   chat.history.set([...uiMessages, result.card as UIMessage]);