fix(daemon): re-send a wake recorded unroutable once the seat's binding exists

packages/daemon/src/domain/queue-stuck-sweep.ts

@@ -637,6 +637,16 @@ export async function runStuckSweep(deps: StuckSweepDeps): Promise<StuckSweepRes
       // live release job is orphaned: both stay findings, with their own reason.
       const quiet = quietHoldCustody(deps.db, row.qitemId, now);
       if (quiet && (quiet.state === "held" || quiet.state === "released")) continue;
+      // A wake recorded unroutable because the seat's pane wasn't bound yet (#2151). Once its binding exists, deliver the
+      // row's own wake intent instead of reporting it: the intent is claimed and settled, so a startup drain doesn't send it
+      // again, and one already in flight or settled isn't sent twice. The next tick reads the new result, so a failed send
+      // is reported then. A row with a live retry ladder is left to the ladder.
+      if (!humanNotice && row.lastNudgeResult?.startsWith("unroutable:")
+        && !hasLiveLadder(deps.db, row.qitemId, now, suppressionMinutes)
+        && deps.queueRepo.classifyDestinationOf(row.destinationSession).class === "pane-bound") {
+        await deps.queueRepo.deliverWakeForSuccessor(row.qitemId, row.destinationSession, true, row.sourceSession);
+        if (!deps.queueRepo.getById(row.qitemId)?.lastNudgeResult?.startsWith("unroutable:")) continue;
+      }
       // The ladder check runs LAST, so only a row the ladder ALONE would have stopped counts
       // as ladder-suppressed (#1419). Agent wake retries do not own the separate notice to a
       // person: a human notice is never the ladder's to suppress.

packages/daemon/test/queue-stuck-sweep.test.ts

@@ -23,6 +23,7 @@ import { migrate } from "../src/db/migrate.js";
 import { ALL_MIGRATIONS } from "../src/db/all-migrations.js";
 import { QueueRepository, deriveCrossHostSuccessorId, type QueueItem } from "../src/domain/queue-repository.js";
 import { EventBus } from "../src/domain/event-bus.js";
+import { OutboxHandler } from "../src/domain/outbox-handler.js";
 import { SettingsStore } from "../src/domain/user-settings/settings-store.js";
 import { archiveAgedTerminalTransitions } from "../src/domain/queue-retention.js";
 import type { HumanFragment } from "../src/domain/gateway/human-registry.js";
@@ -387,6 +388,74 @@ describe("S02 standing stuck sweep — both halves, routed findings, quiet-but-o
     expect((await findingsFor(row.qitemId))[0]!.destinationSession).toBe("sender@r");
   });
 
+  // #2151: a row created before its seat's pane was bound records an unroutable wake. Once the binding exists, the sweep
+  // sends that wake instead of reporting it.
+  it("re-sends a wake recorded unroutable once the seat's terminal binding exists, and raises no finding for it", async () => {
+    // Real topology, so the repository's pre-topology transport shortcut doesn't apply.
+    db.prepare("INSERT INTO rigs(id,name) VALUES ('fixture-rig','r')").run();
+    db.prepare("INSERT INTO nodes(id,rig_id,logical_id,runtime,profile) VALUES ('late-node','fixture-rig','late','codex','none')").run();
+    const sent: string[] = [];
+    repo = new QueueRepository(db, new EventBus(db), {
+      validateRig: () => true,
+      loadHumanRegistry: () => ({ ok: true, entities: [] }),
+      transport: { send: async (destination) => { sent.push(destination); return { ok: true, verified: true }; } },
+    });
+    const row = await repo.create({ sourceSession: "sender@r", destinationSession: "late@r", body: "work" });
+    expect(row.lastNudgeResult).toMatch(/^unroutable:/);
+    expect(sent).toEqual([]);
+    // The seat's pane comes up: its tmux binding is written.
+    db.prepare("INSERT INTO bindings(id,node_id,tmux_session) VALUES ('late-binding','late-node','late@r')").run();
+    await runSweep();
+    expect(sent).toEqual(["late@r"]);
+    expect(repo.getById(row.qitemId)!.lastNudgeResult).not.toMatch(/^unroutable:/);
+    expect(await findingsFor(row.qitemId)).toHaveLength(0);
+  });
+
+  // With the durable wake intents in place (the production path), the re-send goes through the row's own intent: it's
+  // claimed and settled, so a later startup drain doesn't wake the seat a second time.
+  async function lateSeatWithOutbox() {
+    db.prepare("INSERT INTO rigs(id,name) VALUES ('fixture-rig','r')").run();
+    db.prepare("INSERT INTO nodes(id,rig_id,logical_id,runtime,profile) VALUES ('late-node','fixture-rig','late','codex','none')").run();
+    const sent: string[] = [];
+    repo = new QueueRepository(db, new EventBus(db), {
+      validateRig: () => true,
+      loadHumanRegistry: () => ({ ok: true, entities: [] }),
+      transport: { send: async (destination) => { sent.push(destination); return { ok: true, verified: true }; } },
+    });
+    const outbox = new OutboxHandler(db);
+    repo.attachOutbox(outbox);
+    const created = await repo.create({ sourceSession: "sender@r", destinationSession: "late@r", body: "work" });
+    // With an outbox, the create's wake runs after its commit: read the row back once that wake has settled.
+    await vi.waitFor(() => expect(outbox.getById(`wake-intent-${created.qitemId}`)?.deliveryState).not.toMatch(/^(pending|sending)$/));
+    const row = repo.getById(created.qitemId)!;
+    expect(row.lastNudgeResult).toMatch(/^unroutable:/);
+    expect(outbox.getById(`wake-intent-${row.qitemId}`)?.deliveryState).toBe("failed");
+    expect(sent).toEqual([]);
+    db.prepare("INSERT INTO bindings(id,node_id,tmux_session) VALUES ('late-binding','late-node','late@r')").run();
+    return { sent, outbox, row };
+  }
+
+  it("re-sends through the row's wake intent: the intent reads delivered, and a later drain sends nothing", async () => {
+    const { sent, outbox, row } = await lateSeatWithOutbox();
+    await runSweep();
+    expect(sent).toEqual(["late@r"]);
+    expect(outbox.getById(`wake-intent-${row.qitemId}`)?.deliveryState).toBe("delivered");
+    expect(repo.getById(row.qitemId)!.lastNudgeResult).not.toMatch(/^unroutable:/);
+    expect(await findingsFor(row.qitemId)).toHaveLength(0);
+    await repo.drainPendingWakeIntents();
+    expect(sent).toEqual(["late@r"]);
+  });
+
+  // The row still raises the sweep's finding here; it goes to the orchestrator, so only the row's own wake could reach the seat.
+  it.each(["sending", "delivered"])("doesn't send again when the row's wake intent is already %s", async (state) => {
+    const { sent, outbox, row } = await lateSeatWithOutbox();
+    db.prepare("UPDATE outbox_entries SET delivery_state = ? WHERE outbox_id = ?").run(state, `wake-intent-${row.qitemId}`);
+    await runSweep({ resolveOrchestrator: () => "orch@r" });
+    expect(sent).not.toContain("late@r");
+    expect(outbox.getById(`wake-intent-${row.qitemId}`)?.deliveryState).toBe(state);
+    expect(repo.getById(row.qitemId)!.lastNudgeAttempt).toBe(row.lastNudgeAttempt);
+  });
+
   // With no live recovery seat, the finding is still created (it's owed work) to the missing session, and says so.
   it("a dead seat's own row with no operator agent or seat stays with it, and its why says no live recovery seat is available", async () => {
     const row = await repo.create({ sourceSession: "worker@r", destinationSession: "worker@r", body: "work" });