fix(daemon): latch terminal run status against equal-length stale snapshots

The length-based freshness check only caught snapshots that SHRANK the
stored event list. But the daemon writes the terminal run_status in a
separate UPDATE (no event appended), so a web snapshot captured after the
final event but before that write has the SAME event count while still
carrying a non-terminal status — it previously flowed through and regressed
the stored status back to 'running', sticking conversations in a
nonterminal state (looper review on #6418).

Make terminal run status a daemon-owned latch: once the stored status is
terminal (succeeded/failed/canceled), a client PUT that carries any other
status is rejected for the daemon-owned fields. Combined with the existing
event-shrink rule, and preserving role/runId on both paths.

Adds a regression test: run completes (terminal status + events), then an
equal-length snapshot with 'running' is replayed and must not regress the
terminal status or ownership fields.

Author: YOMXXX

apps/daemon/src/routes/project/conversations.ts

@@ -3,6 +3,7 @@ import { type ChatSessionMode } from '@open-design/contracts';
 import { readAnalyticsContext } from '../../analytics.js';
 import { backfillBrandExtractionTranscriptForProject } from '../../brands/index.js';
 import type { RouteDeps } from '../../server-context.js';
+import { TERMINAL_RUN_STATUSES } from '../../runtimes/runs.js';
 import { registerProjectCommentRoutes } from './comments.js';
 import { cancelRunsOwnedBy } from './cancel-owned-runs.js';
 
@@ -199,33 +200,48 @@ export function registerProjectConversationRoutes(app: Express, ctx: RegisterPro
   // switch, then PUT after the daemon appended more events) must never regress
   // those fields — that's how the early `status:model` event got wiped.
   //
-  // The guard is a "no regression" rule, not a blanket write-ownership rule:
-  // run events are append-only, so a stale snapshot can only SHRINK the stored
-  // list. We preserve the stored events/content/last-run-event-id/run-status —
-  // plus the daemon-ownership marker (role + runId), since a snapshot captured
-  // before `/api/runs` assigned a run id can omit `runId` and would otherwise
-  // null `run_id` and drop the message back out of the protected path on the
-  // next stale PUT — only when the incoming snapshot would drop
-  // already-persisted events. A web write that carries at least as many events
-  // still flows through — which keeps mock-agent flows working (the daemon
-  // never persisted events there, so the web is the legitimate writer) and
-  // lets UI metadata (feedback, comment attachments, telemetry) land on every
-  // PUT.
+  // The guard is a "no regression" rule, not a blanket write-ownership rule,
+  // and it has two independent triggers:
+  //   1. Run events are append-only, so a stale snapshot can only SHRINK the
+  //      stored list — preserve stored events/content when the incoming
+  //      snapshot would drop already-persisted events.
+  //   2. Terminal run status is a daemon-owned latch: the daemon writes it
+  //      separately (no event appended), so a snapshot captured after the
+  //      final event but before that write has the SAME event count yet still
+  //      carries a non-terminal status. Never let it regress a terminal status.
+  // Both paths also preserve the daemon-ownership marker (role + runId), since
+  // a snapshot captured before `/api/runs` assigned a run id can omit `runId`
+  // and would otherwise null `run_id` and drop the message back out of the
+  // protected path on the next stale PUT.
+  //
+  // A web write that carries at least as many events and a non-regressing
+  // status still flows through — which keeps mock-agent flows working (the
+  // daemon never persisted events/status there, so the web is the legitimate
+  // writer) and lets UI metadata (feedback, comment attachments, telemetry)
+  // land on every PUT.
   const mergeMessageWriteForDaemonBacked = (
     messageId: string,
     incoming: Record<string, unknown>,
   ): Record<string, unknown> => {
     const stored = getMessage(db, messageId);
     if (!stored || stored.role !== 'assistant' || !stored.runId) return incoming;
     const incomingEvents = Array.isArray(incoming.events) ? incoming.events : [];
-    if (!stored.events || stored.events.length === 0 || incomingEvents.length >= stored.events.length) {
-      return incoming;
-    }
+    const shrinksEvents =
+      Boolean(stored.events) &&
+      stored.events!.length > 0 &&
+      incomingEvents.length < stored.events!.length;
+    const incomingStatus =
+      typeof incoming.runStatus === 'string' ? incoming.runStatus : null;
+    const regressesTerminalStatus =
+      stored.runStatus !== undefined &&
+      TERMINAL_RUN_STATUSES.has(stored.runStatus) &&
+      incomingStatus !== stored.runStatus;
+    if (!shrinksEvents && !regressesTerminalStatus) return incoming;
     return {
       ...incoming,
       role: stored.role,
       runId: stored.runId,
-      events: stored.events,
+      events: stored.events ?? [],
       content: stored.content ?? '',
       lastRunEventId: stored.lastRunEventId,
       runStatus: stored.runStatus,

apps/daemon/tests/stale-message-snapshot-preserves-daemon-events.test.ts

@@ -164,6 +164,76 @@ describe('stale web message snapshot does not wipe daemon-owned run events', ()
     expect(after?.feedback?.rating).toBe(1);
   });
 
+  it('does not regress a daemon-written terminal run status from an equal-length stale snapshot', async () => {
+    // The daemon writes the terminal run_status separately (no event appended),
+    // so a web snapshot captured after the final event but before that write has
+    // the SAME event count while still carrying a non-terminal status. It must
+    // not be able to regress the stored terminal status (#6396 / looper review).
+    binDir = await mkdtemp(path.join(os.tmpdir(), 'od-terminal-latch-bin-'));
+    const fakeClaude = await writeCleanClaude(binDir, 'claude-terminal-latch');
+
+    delete process.env.POSTHOG_KEY;
+    delete process.env.POSTHOG_HOST;
+    delete process.env.LANGFUSE_PUBLIC_KEY;
+    delete process.env.LANGFUSE_SECRET_KEY;
+    delete process.env.LANGFUSE_BASE_URL;
+    delete process.env.OPEN_DESIGN_TELEMETRY_RELAY_URL;
+
+    started = (await startServer({ port: 0, returnServer: true })) as StartedServer;
+    await putConfig(started.url, {
+      agentId: 'claude',
+      agentCliEnv: { claude: { CLAUDE_BIN: fakeClaude } },
+      telemetry: { metrics: true, content: false, artifactManifest: false },
+      privacyDecisionAt: Date.now(),
+    });
+
+    const { projectId, conversationId } = await createConversation(started.url);
+    const { assistantMessageId, status } = await sendRunAndWait(
+      started.url,
+      projectId,
+      conversationId,
+    );
+    expect(status.status).toBe('succeeded');
+
+    const before = await fetchAssistantMessage(
+      started.url,
+      projectId,
+      conversationId,
+      assistantMessageId,
+    );
+    expect(before?.runStatus).toBe('succeeded');
+    expect(before?.events?.length).toBeGreaterThan(0);
+
+    // Same event count, but the pre-finalize status — the exact shape that
+    // previously slipped through the length-based freshness check.
+    const equalLengthSnapshot = {
+      id: assistantMessageId,
+      role: 'assistant',
+      content: before?.content ?? '',
+      runId: before?.runId,
+      runStatus: 'running',
+      events: before?.events ?? [],
+    };
+    const putResponse = await fetch(
+      `${started.url}/api/projects/${encodeURIComponent(projectId)}/conversations/${encodeURIComponent(conversationId)}/messages/${encodeURIComponent(assistantMessageId)}`,
+      {
+        method: 'PUT',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(equalLengthSnapshot),
+      },
+    );
+    expect(putResponse.status).toBe(200);
+
+    const after = await fetchAssistantMessage(
+      started.url,
+      projectId,
+      conversationId,
+      assistantMessageId,
+    );
+    expect(after?.runStatus, 'terminal run status must not regress').toBe('succeeded');
+    expect(after?.runId).toBe(before?.runId);
+  });
+
   it('lets a mock-agent flow persist events/runStatus when the daemon never wrote any', async () => {
     // e2e Playwright suites mock the run SSE end-to-end, so the daemon never
     // persists events for the assistant message — the web client is the only