fix(session): learn the live Claude conversation from the CLI's own hook

Which conversation a pane is on was re-derived by correlating
~/.claude/history.jsonl against Session.lastSubmitAt — and lastSubmitAt is
bumped only by input that flows through Codeman's own write path
(Session.write / writeViaMux). A user who attaches to the pane's tmux session
directly never set it, so resolveActiveClaudeSessionIdFromHistory() returned at
its first line for that pane's whole life and the response viewer stayed pinned
to the launch conversation, showing a pre-/clear transcript indefinitely.

A UserPromptSubmit hook reports the live conversation id from inside the CLI
process, delivered under the pane's own $CODEMAN_SESSION_ID. That binding is a
fact rather than a correlation: it never consults workingDir, so it cannot be
claimed by a sibling pane on the same folder, a closed tab, or a bare `claude`
in the user's terminal. A pane holding such an id skips the correlation
entirely, so the number of prompts eligible for cwd-based guessing goes DOWN,
never up — the naive alternative (relax the guard, or synthesize an anchor from
PTY activity) is the reverted bug the resolver's own comment describes.

The hook also stamps lastSubmitAt, so it finally means "a prompt was submitted"
rather than "typed into Codeman's web terminal". Conversations vouched for
first-hand — and only those — extend a persisted claudeSessionChain, whose tail
re-pins the conversation when a surviving tmux session is re-attached after a
restart. ⚠️ start() resets the id at THREE points and the last one runs
unconditionally after the mux branch, so the tail is applied there too; patching
only the mux branch looks right and silently does nothing.

⚠️ The hook's stdout is discarded with curl's own -o /dev/null. Claude Code
injects a UserPromptSubmit hook's stdout into the model's context ("Exit code 0
- stdout shown to Claude"), and a trailing >/dev/null does NOT work: curlCmd
already ends `... 2>/dev/null || true`, and in `pipeline || true >/dev/null` the
shell binds the redirection to `true`, which never runs on the success path. The
discard is opt-in so the five SSE-fed events keep byte-identical command text
and no workspace's settings file is rewritten for them. The staleness marker is
quote-free for the matching reason: hooksJson is JSON.stringify'd, so a quoted
needle never matches and the gate would rewrite every workspace on every spawn.

Existing workspaces heal on their next Claude spawn through the staleness sweep.

test/routes/hook-event-routes.test.ts

@@ -115,6 +115,75 @@ describe('hook-event-routes', () => {
       );
     });
 
+    /**
+     * The pane's live conversation id, reported by the CLI process itself. This
+     * is what lets the response viewer stop guessing from ~/.claude/history.jsonl
+     * — a guess that could never run at all for a pane the user drives by
+     * attaching to tmux, because `lastSubmitAt` only ever saw Codeman's own
+     * write path.
+     */
+    it('adopts the conversation id first-hand from a prompt_submitted hook', async () => {
+      const session = harness.ctx._session;
+      const before = session.lastSubmitAt;
+
+      const res = await harness.app.inject({
+        method: 'POST',
+        url: '/api/hook-event',
+        payload: {
+          event: 'prompt_submitted',
+          sessionId: harness.ctx._sessionId,
+          data: { hook_event_name: 'UserPromptSubmit', session_id: 'conv-1', source: 'user' },
+        },
+      });
+
+      expect(res.statusCode).toBe(200);
+      expect(session.claudeSessionId).toBe('conv-1');
+      expect(session.claudeSessionIdIsFirstHand).toBe(true);
+      expect(session.claudeSessionChain).toEqual(['conv-1']);
+      expect(session.lastSubmitAt).toBeGreaterThan(before);
+      expect(harness.ctx.persistSessionState).toHaveBeenCalledWith(session);
+    });
+
+    it('records a /clear successor in the chain and persists it, without duplicating a repeat', async () => {
+      const session = harness.ctx._session;
+      const submit = async (conversationId: string) =>
+        harness.app.inject({
+          method: 'POST',
+          url: '/api/hook-event',
+          payload: {
+            event: 'prompt_submitted',
+            sessionId: harness.ctx._sessionId,
+            data: { hook_event_name: 'UserPromptSubmit', session_id: conversationId },
+          },
+        });
+
+      await submit('conv-1');
+      await submit('conv-1'); // every prompt in a conversation reports the same id
+      await submit('conv-2'); // the user ran /clear
+
+      expect(session.claudeSessionChain).toEqual(['conv-1', 'conv-2']);
+      expect(session.claudeSessionId).toBe('conv-2');
+      // `/clear` emits no completion event, so the successor is lost on restart
+      // unless the hook itself persists it.
+      expect(harness.ctx.persistSessionState).toHaveBeenCalledTimes(2);
+    });
+
+    it('does not leak the prompt text into the broadcast', async () => {
+      await harness.app.inject({
+        method: 'POST',
+        url: '/api/hook-event',
+        payload: {
+          event: 'prompt_submitted',
+          sessionId: harness.ctx._sessionId,
+          data: { hook_event_name: 'UserPromptSubmit', session_id: 'conv-1', prompt: 'my secret prompt' },
+        },
+      });
+
+      const broadcast = JSON.stringify(harness.ctx.broadcast.mock.calls);
+      expect(broadcast).not.toContain('my secret prompt');
+      expect(broadcast).toContain('conv-1');
+    });
+
     it('returns 404 for unknown session', async () => {
       const res = await harness.app.inject({
         method: 'POST',

test/routes/session-routes-claude-last-response.test.ts

@@ -232,16 +232,18 @@ describe('GET /api/sessions/:id/last-response (claude conversation pinning)', ()
   }
 
   /** Replaces the pre-seeded mock session with a Claude pane in WORKDIR. */
-  function addPane(id: string, conversationId: string, lastSubmitAt: number) {
+  function addPane(id: string, conversationId: string, lastSubmitAt: number, firstHand = false) {
     const base = harness.ctx._session;
     const pane = Object.create(Object.getPrototypeOf(base)) as typeof base & {
       claudeSessionId: string;
       lastSubmitAt: number;
+      claudeSessionIdIsFirstHand: boolean;
       adoptClaudeSessionId: ReturnType<typeof vi.fn>;
     };
     Object.assign(pane, base, { id, mode: 'claude', workingDir: WORKDIR, docker: undefined });
     pane.claudeSessionId = conversationId;
     pane.lastSubmitAt = lastSubmitAt;
+    pane.claudeSessionIdIsFirstHand = firstHand;
     pane.adoptClaudeSessionId = vi.fn((newId: string) => {
       pane.claudeSessionId = newId;
     });
@@ -286,6 +288,41 @@ describe('GET /api/sessions/:id/last-response (claude conversation pinning)', ()
     expect(pane.adoptClaudeSessionId).not.toHaveBeenCalled();
   });
 
+  /**
+   * The whole point of the UserPromptSubmit hook: a pane driven by attaching to
+   * tmux directly never bumps `lastSubmitAt` (only Codeman's own write path
+   * does), so before this the correlation could not run at all for it and the
+   * viewer stayed pinned to the launch conversation for the pane's whole life.
+   */
+  it("trusts the pane's own hook over any history correlation", async () => {
+    const pane = addPane('pane-1', 'hook-conversation', 0, true);
+    writeTranscript('hook-conversation', 'the answer this pane gave', NOW - 60_000);
+    // A newer, closer entry that the correlation would otherwise have claimed.
+    writeTranscript('decoy-conversation', 'a stranger answer', NOW);
+    writeHistory([{ sessionId: 'decoy-conversation', timestamp: NOW }]);
+
+    expect(await getLastResponse('pane-1')).toEqual({
+      text: 'the answer this pane gave',
+      timestamp: expect.any(String),
+    });
+    expect(pane.adoptClaudeSessionId).not.toHaveBeenCalled();
+  });
+
+  it('never lets a correlation override a first-hand id, even a well-anchored one', async () => {
+    // Same shape as the /clear-following test above, which DOES adopt — the only
+    // difference is that this pane's id came from its own hook.
+    const pane = addPane('pane-1', 'before-clear', NOW, true);
+    writeTranscript('before-clear', 'answer before clear', NOW - 60_000);
+    writeTranscript('after-clear', 'answer after clear', NOW + 500);
+    writeHistory([{ sessionId: 'after-clear', timestamp: NOW + 120 }]);
+
+    expect(await getLastResponse('pane-1')).toEqual({
+      text: 'answer before clear',
+      timestamp: expect.any(String),
+    });
+    expect(pane.adoptClaudeSessionId).not.toHaveBeenCalled();
+  });
+
   it('credits a shared-cwd entry to the pane whose Enter is closest to it', async () => {
     const near = addPane('pane-near', 'near-conversation', NOW);
     const far = addPane('pane-far', 'far-conversation', NOW - 4_000);