@vellumai/assistant 0.10.3-dev.202606252046.9075fd5 → 0.10.3-dev.202606252138.db46320

package/openapi.yaml

@@ -17462,6 +17462,14 @@ paths:
                     anyOf:
                       - type: number
                       - type: "null"
+                  processing:
+                    description:
+                      "Whether the agent is currently mid-turn for this conversation, sourced authoritatively from the persisted
+                      `processing_started_at` column. `true` means a turn is in flight; `false` means the conversation
+                      is idle. Clients use this to recover from a dropped SSE stream: if a turn appears to be running
+                      locally but the server reports `processing: false`, the turn has ended (or died) and the UI should
+                      stop waiting rather than spin indefinitely. Absent on older daemons that predate this field."
+                    type: boolean
                 required:
                   - messages
                 additionalProperties: false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.3-dev.202606252046.9075fd5",
+  "version": "0.10.3-dev.202606252138.db46320",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/assistant-stream-state.test.ts

@@ -12,9 +12,7 @@ import {
   _resetStreamStateForTesting,
   _simulateRestartForTesting,
   getCurrentSeq,
-  getPersistedSeq,
   getReplayWindow,
-  recordPersistedSeq,
   stampAndBuffer,
 } from "../runtime/assistant-stream-state.js";
 
@@ -571,80 +569,9 @@ describe("assistant-stream-state", () => {
     });
   });
 
-  describe("persisted seq", () => {
-    test("getPersistedSeq is null for an unknown conversation", () => {
-      expect(getPersistedSeq("conv_unknown")).toBeNull();
-    });
-
-    test("records and retrieves a per-conversation value", () => {
-      recordPersistedSeq("conv_a", 7);
-      expect(getPersistedSeq("conv_a")).toBe(7);
-      expect(getPersistedSeq("conv_b")).toBeNull();
-    });
-
-    test("tracks conversations independently", () => {
-      recordPersistedSeq("conv_a", 3);
-      recordPersistedSeq("conv_b", 9);
-      expect(getPersistedSeq("conv_a")).toBe(3);
-      expect(getPersistedSeq("conv_b")).toBe(9);
-    });
-
-    test("advances monotonically and never regresses", () => {
-      recordPersistedSeq("conv_a", 5);
-      recordPersistedSeq("conv_a", 12);
-      expect(getPersistedSeq("conv_a")).toBe(12);
-
-      // A lower seq (e.g. an out-of-order async commit) is clamped.
-      recordPersistedSeq("conv_a", 8);
-      expect(getPersistedSeq("conv_a")).toBe(12);
-    });
-
-    test("ignores non-positive and non-finite seq values", () => {
-      recordPersistedSeq("conv_a", 0);
-      recordPersistedSeq("conv_a", -3);
-      recordPersistedSeq("conv_a", Number.NaN);
-      recordPersistedSeq("conv_a", Number.POSITIVE_INFINITY);
-      expect(getPersistedSeq("conv_a")).toBeNull();
-    });
-
-    test("is cleared by reset", () => {
-      recordPersistedSeq("conv_a", 4);
-      _resetStreamStateForTesting();
-      expect(getPersistedSeq("conv_a")).toBeNull();
-    });
-
-    test("evicts the least-recently-recorded conversation past the cap", () => {
-      // The map is LRU-bounded at 1024 conversations. Fill to the cap,
-      // then one more insert evicts the oldest key.
-      const CAP = 1024;
-      for (let i = 0; i < CAP; i++) {
-        recordPersistedSeq(`conv_${i}`, i + 1);
-      }
-      // All present at the cap.
-      expect(getPersistedSeq("conv_0")).toBe(1);
-      expect(getPersistedSeq(`conv_${CAP - 1}`)).toBe(CAP);
-
-      // One more distinct conversation evicts the oldest (conv_0).
-      recordPersistedSeq("conv_overflow", 9999);
-      expect(getPersistedSeq("conv_0")).toBeNull();
-      expect(getPersistedSeq("conv_1")).toBe(2);
-      expect(getPersistedSeq("conv_overflow")).toBe(9999);
-    });
-
-    test("re-recording refreshes recency so a kept key is not evicted first", () => {
-      const CAP = 1024;
-      for (let i = 0; i < CAP; i++) {
-        recordPersistedSeq(`conv_${i}`, i + 1);
-      }
-      // Touch the oldest key so it moves to the most-recent end.
-      recordPersistedSeq("conv_0", 5000);
-
-      // The next insert now evicts conv_1 (the new oldest), not conv_0.
-      recordPersistedSeq("conv_overflow", 9999);
-      expect(getPersistedSeq("conv_0")).toBe(5000);
-      expect(getPersistedSeq("conv_1")).toBeNull();
-    });
-  });
+  // Per-conversation persisted seq now lives on the `conversations.seq`
+  // column (see conversation-crud `getConversationPersistedSeq` /
+  // `recordConversationPersistedSeq`); its tests live with that module.
 
   describe("seq persistence across restarts", () => {
     test("counter resumes above the persisted reservation after a restart", () => {

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -100,8 +100,10 @@ mock.module("../daemon/process-message.js", () => ({
 
 const createdConversations: Array<{ conversationType: string }> = [];
 mock.module("../memory/conversation-crud.js", () => ({
-    setConversationProcessingStartedAt: () => {},
-    isConversationProcessing: () => false,
+  setConversationProcessingStartedAt: () => {},
+  isConversationProcessing: () => false,
+  recordConversationPersistedSeq: () => {},
+  getConversationPersistedSeq: () => null,
   addMessage: mock(() => ({ id: "msg-1" })),
   archiveConversation: mock(() => true),
   batchSetDisplayOrders: mock(() => {}),

package/src/__tests__/conversation-agent-loop-overflow.test.ts

@@ -257,8 +257,8 @@ mock.module("../plugins/defaults/compaction/overflow-policy.js", () => ({
 }));
 
 mock.module("../memory/conversation-crud.js", () => ({
-    setConversationProcessingStartedAt: () => {},
-    isConversationProcessing: () => false,
+  setConversationProcessingStartedAt: () => {},
+  isConversationProcessing: () => false,
   setConversationOriginChannelIfUnset: () => {},
   setConversationHistoryStrippedAt: () => {},
   updateConversationUsage: () => {},
@@ -289,6 +289,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   getLastUserTimestampBefore: () => 0,
   resolveOverrideProfile: () => undefined,
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+  recordConversationPersistedSeq: () => {},
+  getConversationPersistedSeq: () => null,
 }));
 
 afterAll(() => {

package/src/__tests__/conversation-agent-loop.test.ts

@@ -303,6 +303,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   getLastUserTimestampBefore: () => 0,
   reserveMessage: reserveMessageMock,
   updateMessageContent: updateMessageContentMock,
+  recordConversationPersistedSeq: () => {},
+  getConversationPersistedSeq: () => null,
   // The real schema is a Zod object; tests don't exercise validation,
   // so a passthrough is sufficient — the production code at
   // `handleMessageComplete` only branches on `success` and reads two

package/src/__tests__/list-messages-page-latest.test.ts

@@ -37,14 +37,20 @@ mock.module("../daemon/identity-helpers.js", () => ({
   getAssistantName: () => mockAssistantName,
 }));
 
-import { createConversation } from "../memory/conversation-crud.js";
+import {
+  createConversation,
+  recordConversationPersistedSeq,
+  setConversationProcessingStartedAt,
+} from "../memory/conversation-crud.js";
 import { getDb } from "../memory/db-connection.js";
 import { initializeDb } from "../memory/db-init.js";
 import { messages } from "../memory/schema.js";
 import { writeSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
+import type { AssistantEvent } from "../runtime/assistant-event.js";
 import {
   _resetStreamStateForTesting,
-  recordPersistedSeq,
+  getCurrentSeq,
+  stampAndBuffer,
 } from "../runtime/assistant-stream-state.js";
 import { handleListMessages } from "../runtime/routes/conversation-routes.js";
 import { BadRequestError } from "../runtime/routes/errors.js";
@@ -112,6 +118,28 @@ interface ListResponse {
   oldestTimestamp?: number | null;
   oldestMessageId?: string | null;
   seq?: number | null;
+  processing?: boolean;
+}
+
+/**
+ * Stamp `count` conversation-scoped events to advance the global `seq`
+ * counter, mirroring `mkEvent` in assistant-stream-state.test.ts. The
+ * conversationId is irrelevant — `getCurrentSeq()` is process-global — so
+ * any value works for nudging the high-water mark before a creation.
+ */
+function advanceGlobalSeq(count: number): void {
+  for (let i = 0; i < count; i++) {
+    stampAndBuffer({
+      id: `seq-bump-${i}`,
+      conversationId: "seq-bump-conv",
+      emittedAt: new Date().toISOString(),
+      message: {
+        type: "assistant_text_delta",
+        conversationId: "seq-bump-conv",
+        text: "x",
+      },
+    } as AssistantEvent);
+  }
 }
 
 function callList(query: Record<string, string>): ListResponse {
@@ -138,7 +166,7 @@ describe("handleListMessages page=latest", () => {
       const conv = createConversation();
       seedMessages(conv.id, 3);
       // AND the daemon has recorded a persisted seq for it
-      recordPersistedSeq(conv.id, 42);
+      recordConversationPersistedSeq(conv.id, 42);
 
       // WHEN the snapshot is fetched
       const body = callList({ conversationId: conv.id, page: "latest" });
@@ -171,7 +199,7 @@ describe("handleListMessages page=latest", () => {
       // GIVEN a conversation with a recorded persisted seq
       const conv = createConversation();
       seedMessages(conv.id, 2);
-      recordPersistedSeq(conv.id, 7);
+      recordConversationPersistedSeq(conv.id, 7);
 
       // WHEN fetched with no pagination params
       const body = callList({ conversationId: conv.id });
@@ -179,6 +207,138 @@ describe("handleListMessages page=latest", () => {
       // THEN the seq still rides along
       expect(body.seq).toBe(7);
     });
+
+    test("recording advances the seq monotonically and never regresses", () => {
+      /**
+       * Out-of-order async commits must not lower the high-water mark — the
+       * `WHERE seq < ?` guard on the persist UPDATE keeps it monotonic.
+       */
+
+      // GIVEN a conversation whose persisted seq has been recorded
+      const conv = createConversation();
+      recordConversationPersistedSeq(conv.id, 12);
+
+      // WHEN a lower seq is recorded (a late, out-of-order commit)
+      recordConversationPersistedSeq(conv.id, 8);
+
+      // THEN the high-water seq is unchanged
+      expect(callList({ conversationId: conv.id }).seq).toBe(12);
+
+      // AND a higher seq still advances it
+      recordConversationPersistedSeq(conv.id, 20);
+      expect(callList({ conversationId: conv.id }).seq).toBe(20);
+    });
+
+    test("recording ignores non-positive and non-finite seq values", () => {
+      // GIVEN a freshly created conversation (no stream activity → null seed)
+      const conv = createConversation();
+
+      // WHEN non-positive / non-finite seqs are recorded
+      recordConversationPersistedSeq(conv.id, 0);
+      recordConversationPersistedSeq(conv.id, -3);
+      recordConversationPersistedSeq(conv.id, Number.NaN);
+      recordConversationPersistedSeq(conv.id, Number.POSITIVE_INFINITY);
+
+      // THEN none take effect and seq stays null
+      expect(callList({ conversationId: conv.id }).seq).toBeNull();
+    });
+
+    test("a freshly created conversation is anchored to the current global seq", () => {
+      /**
+       * Conversations created after some stream activity must not report a
+       * null `seq` — that would force the client to cold-start with no
+       * alignment baseline. They inherit the current high-water global seq
+       * at creation time so the first snapshot can align with the stream.
+       */
+
+      // GIVEN the global stream has already advanced past seq 0
+      advanceGlobalSeq(5);
+      expect(getCurrentSeq()).toBe(5);
+
+      // WHEN a brand-new conversation is created and its snapshot fetched
+      const conv = createConversation();
+      const body = callList({ conversationId: conv.id, page: "latest" });
+
+      // THEN the snapshot is anchored to the global seq at creation time
+      expect(body.seq).toBe(5);
+    });
+
+    test("a conversation created before any stream activity stays null", () => {
+      /**
+       * With nothing stamped this process, `getCurrentSeq()` is 0 and the
+       * creation seed stores NULL (non-positive seqs aren't recorded), so the
+       * snapshot legitimately reports null and the client cold-starts.
+       */
+
+      // GIVEN no events have been stamped (stream reset in beforeEach)
+      expect(getCurrentSeq()).toBe(0);
+
+      // WHEN a conversation is created and its snapshot fetched
+      const conv = createConversation();
+      const body = callList({ conversationId: conv.id, page: "latest" });
+
+      // THEN seq remains null
+      expect(body.seq).toBeNull();
+    });
+  });
+
+  describe("processing state", () => {
+    test("reports processing=true while the conversation is mid-turn", () => {
+      /**
+       * The authoritative processing flag lets a client recover from a
+       * dropped stream: it can ask the server whether a turn is still
+       * running rather than spinning forever.
+       */
+
+      // GIVEN a conversation marked as processing
+      const conv = createConversation();
+      seedMessages(conv.id, 1);
+      setConversationProcessingStartedAt(conv.id, Date.now());
+
+      // WHEN the snapshot is fetched
+      const body = callList({ conversationId: conv.id, page: "latest" });
+
+      // THEN it reports the conversation is processing
+      expect(body.processing).toBe(true);
+    });
+
+    test("reports processing=false when the conversation is idle", () => {
+      // GIVEN an idle conversation (processing_started_at is null)
+      const conv = createConversation();
+      seedMessages(conv.id, 2);
+
+      // WHEN the snapshot is fetched
+      const body = callList({ conversationId: conv.id, page: "latest" });
+
+      // THEN it reports the conversation is not processing
+      expect(body.processing).toBe(false);
+    });
+
+    test("the no-pagination path also reports processing state", () => {
+      /** `processing` is present on every resolved-conversation shape. */
+
+      // GIVEN a processing conversation
+      const conv = createConversation();
+      seedMessages(conv.id, 1);
+      setConversationProcessingStartedAt(conv.id, Date.now());
+
+      // WHEN fetched with no pagination params
+      const body = callList({ conversationId: conv.id });
+
+      // THEN processing rides along
+      expect(body.processing).toBe(true);
+    });
+
+    test("an unresolved conversationKey reports processing=false (page=latest)", () => {
+      // WHEN a never-created key is fetched with the stable contract
+      const body = callList({
+        conversationKey: "no-such-key",
+        page: "latest",
+      });
+
+      // THEN it cannot be processing
+      expect(body.processing).toBe(false);
+    });
   });
 
   test("page=latest with no limit returns all messages chronologically", () => {

package/src/__tests__/tool-preview-lifecycle.test.ts

@@ -59,14 +59,27 @@ const reserveMessageMock = mock(
 );
 const updateMessageContentMock = mock((_id: string, _content: string) => {});
 
+// Stand-in for the `conversations.seq` column. The DB-backed
+// `recordConversationPersistedSeq` / `getConversationPersistedSeq` are mocked
+// over this map with the same monotonic, ignore-non-positive semantics so the
+// handler's persisted-seq writes are observable without a real database.
+const persistedSeqByConversation = new Map<string, number>();
+
 mock.module("../memory/conversation-crud.js", () => ({
-    setConversationProcessingStartedAt: () => {},
-    isConversationProcessing: () => false,
+  setConversationProcessingStartedAt: () => {},
+  isConversationProcessing: () => false,
   getConversation: () => null,
   getMessageById: () => null,
   updateMessageContent: updateMessageContentMock,
   provenanceFromTrustContext: () => ({}),
   reserveMessage: reserveMessageMock,
+  recordConversationPersistedSeq: (id: string, seq: number) => {
+    if (!Number.isFinite(seq) || seq <= 0) return;
+    const prev = persistedSeqByConversation.get(id);
+    if (prev == null || prev < seq) persistedSeqByConversation.set(id, seq);
+  },
+  getConversationPersistedSeq: (id: string) =>
+    persistedSeqByConversation.get(id) ?? null,
 }));
 
 mock.module("../memory/conversation-disk-view.js", () => ({
@@ -102,11 +115,11 @@ import {
   handleToolUsePreviewStart,
 } from "../daemon/conversation-agent-loop-handlers.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
+import { getConversationPersistedSeq } from "../memory/conversation-crud.js";
 import type { AssistantEvent } from "../runtime/assistant-event.js";
 import {
   _resetStreamStateForTesting,
   getCurrentSeq,
-  getPersistedSeq,
   stampAndBuffer,
 } from "../runtime/assistant-stream-state.js";
 
@@ -324,6 +337,7 @@ describe("tool preview lifecycle", () => {
   describe("persisted seq advances on tool_use_start", () => {
     beforeEach(() => {
       _resetStreamStateForTesting();
+      persistedSeqByConversation.clear();
     });
 
     test("advances the conversation's persisted seq to the tool_use_start seq", () => {
@@ -374,8 +388,8 @@ describe("tool preview lifecycle", () => {
         (e) => e.type === "tool_use_start",
       );
       expect(toolUseStart).toBeDefined();
-      expect(getPersistedSeq(conversationId)).toBe(getCurrentSeq());
-      expect(getPersistedSeq(conversationId)).toBe(
+      expect(getConversationPersistedSeq(conversationId)).toBe(getCurrentSeq());
+      expect(getConversationPersistedSeq(conversationId)).toBe(
         (toolUseStart as unknown as AssistantEvent).seq ?? null,
       );
     });
@@ -386,6 +400,7 @@ describe("tool preview lifecycle", () => {
 
     beforeEach(() => {
       _resetStreamStateForTesting();
+      persistedSeqByConversation.clear();
     });
 
     /** onEvent that stamps conversation-scoped events like the runtime hub. */
@@ -474,8 +489,8 @@ describe("tool preview lifecycle", () => {
         (e) => e.type === "assistant_thinking_delta",
       );
       expect(thinkingDelta).toBeDefined();
-      expect(getPersistedSeq(conversationId)).toBe(getCurrentSeq());
-      expect(getPersistedSeq(conversationId)).toBe(
+      expect(getConversationPersistedSeq(conversationId)).toBe(getCurrentSeq());
+      expect(getConversationPersistedSeq(conversationId)).toBe(
         (thinkingDelta as unknown as AssistantEvent).seq ?? null,
       );
     });
@@ -505,8 +520,8 @@ describe("tool preview lifecycle", () => {
       // THEN the persisted seq equals the just-stamped tool_result seq
       const toolResult = events.find((e) => e.type === "tool_result");
       expect(toolResult).toBeDefined();
-      expect(getPersistedSeq(conversationId)).toBe(getCurrentSeq());
-      expect(getPersistedSeq(conversationId)).toBe(
+      expect(getConversationPersistedSeq(conversationId)).toBe(getCurrentSeq());
+      expect(getConversationPersistedSeq(conversationId)).toBe(
         (toolResult as unknown as AssistantEvent).seq ?? null,
       );
     });
@@ -539,7 +554,7 @@ describe("tool preview lifecycle", () => {
         events.find((e) => e.type === "assistant_thinking_delta"),
       ).toBeUndefined();
       expect(state.lastPersistedContentSeq).toBeUndefined();
-      expect(getPersistedSeq(conversationId)).toBeNull();
+      expect(getConversationPersistedSeq(conversationId)).toBeNull();
     });
   });
 
@@ -548,6 +563,7 @@ describe("tool preview lifecycle", () => {
 
     beforeEach(() => {
       _resetStreamStateForTesting();
+      persistedSeqByConversation.clear();
       reserveMessageMock.mockClear();
       updateMessageContentMock.mockClear();
     });

package/src/__tests__/tool-start-timestamp.test.ts

@@ -43,8 +43,8 @@ let mockedRowContent = "";
 const updates: Array<{ id: string; content: string }> = [];
 
 mock.module("../memory/conversation-crud.js", () => ({
-    setConversationProcessingStartedAt: () => {},
-    isConversationProcessing: () => false,
+  setConversationProcessingStartedAt: () => {},
+  isConversationProcessing: () => false,
   addMessage: () => ({ id: "mock-msg-id" }),
   getMessageById: (id: string) =>
     mockedRowContent ? { id, content: mockedRowContent } : null,
@@ -53,6 +53,8 @@ mock.module("../memory/conversation-crud.js", () => ({
   },
   provenanceFromTrustContext: () => ({}),
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
+  recordConversationPersistedSeq: () => {},
+  getConversationPersistedSeq: () => null,
 }));
 
 mock.module("../memory/llm-request-log-store.js", () => ({
@@ -62,7 +64,6 @@ mock.module("../memory/llm-request-log-store.js", () => ({
 
 mock.module("../runtime/assistant-stream-state.js", () => ({
   getCurrentSeq: () => 0,
-  recordPersistedSeq: () => {},
 }));
 
 // ── Imports (after mocks) ─────────────────────────────────────────────────────

package/src/daemon/conversation-agent-loop-handlers.ts

@@ -29,6 +29,7 @@ import {
   getMessageById,
   messageMetadataSchema,
   provenanceFromTrustContext,
+  recordConversationPersistedSeq,
   reserveMessage,
   setConversationHistoryStrippedAt,
   setLastNotifiedInferenceProfile,
@@ -57,10 +58,7 @@ import type {
   ImageContent,
   Message,
 } from "../providers/types.js";
-import {
-  getCurrentSeq,
-  recordPersistedSeq,
-} from "../runtime/assistant-stream-state.js";
+import { getCurrentSeq } from "../runtime/assistant-stream-state.js";
 import { publishSyncInvalidation } from "../runtime/sync/sync-publisher.js";
 import { redactSecrets } from "../security/secret-scanner.js";
 import { extractDomain } from "../tools/network/domain-normalize.js";
@@ -530,7 +528,7 @@ async function flushAccumulatedContent(
     // Record only after the write commits, so the snapshot seq never
     // claims content that is not yet durable.
     if (flushedSeq != null) {
-      recordPersistedSeq(deps.ctx.conversationId, flushedSeq);
+      recordConversationPersistedSeq(deps.ctx.conversationId, flushedSeq);
     }
   } catch (err) {
     deps.rlog.warn(
@@ -918,7 +916,7 @@ export function handleToolUse(
   // persisted seq to it. Without this the snapshot would advertise a seq below
   // an event it already incorporates, and a client applying `seq > snapshot.seq`
   // would replay this tool start.
-  recordPersistedSeq(deps.ctx.conversationId, getCurrentSeq());
+  recordConversationPersistedSeq(deps.ctx.conversationId, getCurrentSeq());
 }
 
 export function handleToolUsePreviewStart(
@@ -1136,7 +1134,7 @@ async function persistPendingToolResultRow(
     rowId,
     JSON.stringify(buildToolResultBlocks(state.pendingToolResults)),
   );
-  recordPersistedSeq(deps.ctx.conversationId, seq);
+  recordConversationPersistedSeq(deps.ctx.conversationId, seq);
   const conv = getConversation(deps.ctx.conversationId);
   if (conv != null) {
     syncMessageToDisk(deps.ctx.conversationId, rowId, conv.createdAt);
@@ -1816,10 +1814,14 @@ export async function handleMessageComplete(
   // delta's seq -- the highest stamped content event this row reflects -- so
   // recording it is honest. A drained tool result was stamped earlier in the
   // turn, so this seq already covers it; a call that streams no content (a
-  // pure tool call) advances instead via `tool_use_start`. `recordPersistedSeq`
-  // clamps monotonically, so a lower value here never regresses the seq.
+  // pure tool call) advances instead via `tool_use_start`.
+  // `recordConversationPersistedSeq` clamps monotonically, so a lower value
+  // here never regresses the seq.
   if (state.lastPersistedContentSeq != null) {
-    recordPersistedSeq(deps.ctx.conversationId, state.lastPersistedContentSeq);
+    recordConversationPersistedSeq(
+      deps.ctx.conversationId,
+      state.lastPersistedContentSeq,
+    );
   }
   // Reset the partial-persist mirror so subsequent calls in this turn
   // start with an empty running view.

package/src/memory/conversation-crud.ts

@@ -34,6 +34,7 @@ import {
   MEMORY_V3_INJECTED_BLOCK_METADATA_KEY,
   seedEverInjectedFromSlugs,
 } from "../plugins/defaults/memory-v3-shadow/ever-injected-store.js";
+import { getCurrentSeq } from "../runtime/assistant-stream-state.js";
 import { publishSyncInvalidation } from "../runtime/sync/sync-publisher.js";
 import { UserError } from "../util/errors.js";
 import { safeParseRecord } from "../util/json.js";
@@ -596,6 +597,7 @@ export function createConversation(
 ) {
   const db = getDb();
   const now = Date.now();
+  const initialSeq = getCurrentSeq();
   const opts =
     typeof titleOrOpts === "string"
       ? { title: titleOrOpts }
@@ -634,6 +636,10 @@ export function createConversation(
     memoryScopeId,
     scheduleJobId: opts.scheduleJobId ?? null,
     forkParentConversationId: opts.forkParentConversationId ?? null,
+    // Snapshot↔stream alignment baseline, captured at the creation instant.
+    // 0 (nothing stamped yet this process) is stored as NULL so `/messages`
+    // reports null and the client cold-starts rather than aligning to seq 0.
+    seq: initialSeq > 0 ? initialSeq : null,
   };
 
   // Retry on SQLITE_BUSY and SQLITE_IOERR — transient disk I/O errors or WAL
@@ -2248,6 +2254,45 @@ export function isConversationProcessing(id: string): boolean {
   return row?.processing_started_at != null;
 }
 
+/**
+ * Highest stream `seq` whose content is durably persisted to this
+ * conversation's message rows, read from the `conversations.seq` column. This
+ * is the snapshot↔stream alignment baseline `/messages` returns so a client
+ * applies only stream events with a higher `seq`. `null` when none was
+ * recorded (created before any stream activity, row predates the column, or
+ * the conversation row is absent), in which case the client cold-starts.
+ *
+ * Seeded at creation with the global high-water seq and advanced on each
+ * persistence flush by {@link recordConversationPersistedSeq}.
+ */
+export function getConversationPersistedSeq(id: string): number | null {
+  const row = rawGet<{ seq: number | null }>(
+    "SELECT seq FROM conversations WHERE id = ?",
+    id,
+  );
+  return row?.seq ?? null;
+}
+
+/**
+ * Record that conversation `id` has durably persisted all of its events
+ * through `seq`, writing the `conversations.seq` column. Called at each
+ * persistence flush with the `seq` of the last event whose content the write
+ * committed.
+ *
+ * Monotonic: the `WHERE seq IS NULL OR seq < ?` guard makes the update raise
+ * the high-water mark only, so out-of-order async commits never regress it.
+ * Non-positive or non-finite `seq` values are ignored.
+ */
+export function recordConversationPersistedSeq(id: string, seq: number): void {
+  if (!Number.isFinite(seq) || seq <= 0) return;
+  rawRun(
+    "UPDATE conversations SET seq = ? WHERE id = ? AND (seq IS NULL OR seq < ?)",
+    seq,
+    id,
+    seq,
+  );
+}
+
 /**
  * Set or clear the `surfaced_at` promotion marker for a conversation.
  *

package/src/memory/migrations/303-add-conversation-creation-seq.ts

@@ -0,0 +1,33 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { tableHasColumn } from "./schema-introspection.js";
+
+const COLUMN_NAME = "seq";
+const COLUMN_DEFINITION = "seq INTEGER";
+
+/**
+ * Add the `seq` column to the `conversations` table.
+ *
+ * The column holds the highest stream `seq` whose content is durably persisted
+ * to the conversation's message rows: seeded with the global high-water seq
+ * when the row is inserted and advanced on each persistence flush. It is the
+ * durable snapshot↔stream alignment baseline returned by `/messages` — a
+ * client aligns its snapshot with the `/events` stream by applying only events
+ * with a higher `seq`.
+ *
+ * Nullable: NULL means the conversation was created before any stream activity
+ * (global seq was 0) or predates this column, in which case the client
+ * cold-starts.
+ *
+ * No backfill is needed — existing rows default to NULL, which correctly maps
+ * to "no recorded baseline, cold-start".
+ *
+ * Idempotent: guarded with `tableHasColumn` so a crash between the `ALTER
+ * TABLE` and the checkpoint write doesn't cause a duplicate-column error on
+ * the next boot.
+ */
+export function migrateAddConversationCreationSeq(database: DrizzleDb): void {
+  if (tableHasColumn(database, "conversations", COLUMN_NAME)) {
+    return;
+  }
+  database.run(`ALTER TABLE conversations ADD COLUMN ${COLUMN_DEFINITION}`);
+}

package/src/memory/schema/conversations.ts

@@ -61,6 +61,17 @@ export const conversations = sqliteTable(
      * callers read this column directly.
      */
     processingStartedAt: integer("processing_started_at"),
+    /**
+     * Highest stream `seq` whose content is durably persisted to this
+     * conversation's message rows. Seeded with the global high-water seq when
+     * the row is inserted and advanced on each persistence flush
+     * (`recordConversationPersistedSeq`). Returned by `/messages` as the
+     * snapshot↔stream alignment baseline so a client applies only stream
+     * events with a higher `seq`. NULL means the conversation was created
+     * before any stream activity (global seq 0) or predates this column — the
+     * client cold-starts in that case.
+     */
+    seq: integer("seq"),
   },
   (table) => [
     index("idx_conversations_updated_at").on(table.updatedAt),

package/src/memory/steps.ts

@@ -410,6 +410,7 @@ import { migrateCanonicalGuardianDeliveriesConversationIndex } from "./migration
 import { migrateAddProcessingStartedAt } from "./migrations/300-add-processing-started-at.js";
 import { createWatchdogEventsTable } from "./migrations/301-create-watchdog-events.js";
 import { migrateCreateCompactionEvents } from "./migrations/302-create-compaction-events.js";
+import { migrateAddConversationCreationSeq } from "./migrations/303-add-conversation-creation-seq.js";
 import type { MigrationStep } from "./migrations/run-migrations.js";
 
 export const migrationSteps: MigrationStep[] = [
@@ -1291,4 +1292,5 @@ export const migrationSteps: MigrationStep[] = [
   migrateAddProcessingStartedAt,
   createWatchdogEventsTable,
   migrateCreateCompactionEvents,
+  migrateAddConversationCreationSeq,
 ];

package/src/runtime/assistant-stream-state.ts

@@ -31,20 +31,18 @@
  * sized generously enough that a typical refresh round-trip (~1-3s)
  * is well within window.
  *
- * Persisted-seq map: alongside the live counter and ring, this module
- * tracks, per conversation, the `seq` of the last event whose content is
- * durably committed to the message rows (`persistedSeqByConversation`).
- * The `/messages` snapshot returns this value so a client can align the
- * snapshot with the stream: "these rows reflect all of this
- * conversation's events through `seq = S`." It is recorded at each
- * persistence flush (assistant rows persist incrementally, debounced, so
- * the snapshot can lag the live counter) -- never the live counter
- * itself, which would over-claim events that have streamed but not yet
- * been written. The map is in-memory and clears on restart; because the
- * counter resumes above the persisted reservation, a value recorded by
- * a previous process could only ever be lower than any seq the new
- * process assigns -- never ambiguous against it. The map is LRU-bounded; an
- * evicted conversation reports no seq and the client cold-starts.
+ * Persisted seq: alongside the live counter and ring, the `seq` of the last
+ * event whose content is durably committed to a conversation's message rows
+ * is stored on the `conversations.seq` column (see `conversation-crud`). The
+ * `/messages` snapshot returns it so a client can align the snapshot with the
+ * stream: "these rows reflect all of this conversation's events through
+ * `seq = S`." It is written at each persistence flush (assistant rows persist
+ * incrementally, debounced, so the snapshot can lag the live counter) -- never
+ * the live counter itself, which would over-claim events that have streamed
+ * but not yet been written. Because it lives in the database it survives a
+ * restart; and because the counter resumes above the persisted reservation, a
+ * value written by a previous process could only ever be lower than any seq
+ * the new process assigns -- never ambiguous against it.
  */
 
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
@@ -66,16 +64,6 @@ const RING_COUNT_LIMIT = SSE_REPLAY_RING_COUNT_LIMIT;
 const RING_SIZE_LIMIT_BYTES = 256 * 1024;
 const RING_AGE_LIMIT_MS = SSE_REPLAY_RING_AGE_LIMIT_MS;
 
-/**
- * Cap on how many conversations retain a persisted-seq entry. Unlike the
- * ring (which the live stream needs only briefly), the persisted-seq map
- * grows with the number of conversations that have ever streamed in this
- * process. Bound it LRU so it can't grow without limit; an evicted
- * conversation simply reports no seq on its next `/messages` and the
- * client cold-starts, which is harmless.
- */
-const PERSISTED_SEQ_CONVERSATION_LIMIT = 1024;
-
 /**
  * How many seq values are reserved per persisted write. The counter can
  * hand out seqs up to the persisted ceiling without touching disk, so
@@ -141,13 +129,6 @@ interface AssistantStreamState {
   firstStampedSeq: number;
   ring: RingEntry[];
   totalSizeBytes: number;
-  /**
-   * Per-conversation `seq` of the last event durably committed to the
-   * message rows. Insertion order is maintained as an LRU recency list:
-   * the oldest key is evicted first once the map exceeds
-   * {@link PERSISTED_SEQ_CONVERSATION_LIMIT}.
-   */
-  persistedSeqByConversation: Map<string, number>;
 }
 
 // ── State ────────────────────────────────────────────────────────────
@@ -159,7 +140,6 @@ const state: AssistantStreamState = {
   firstStampedSeq: 0,
   ring: [],
   totalSizeBytes: 0,
-  persistedSeqByConversation: new Map(),
 };
 
 // ── Public API ───────────────────────────────────────────────────────
@@ -270,46 +250,6 @@ export function getCurrentSeq(): number {
   return state.nextSeq - 1;
 }
 
-/**
- * Record that conversation `conversationId` has durably persisted all of
- * its events through `seq`. Called at each persistence flush with the
- * `seq` of the last event whose content the write committed.
- *
- * Monotonic: a lower `seq` never regresses a higher one (out-of-order
- * async commits are clamped). LRU-bounded by
- * {@link PERSISTED_SEQ_CONVERSATION_LIMIT}: re-recording refreshes
- * recency, and the oldest conversation is evicted once the cap is
- * exceeded. Non-positive or non-finite `seq` values are ignored.
- */
-export function recordPersistedSeq(conversationId: string, seq: number): void {
-  if (!Number.isFinite(seq) || seq <= 0) return;
-
-  const map = state.persistedSeqByConversation;
-  const prev = map.get(conversationId);
-  if (prev !== undefined) {
-    // Re-insert to move this key to the most-recently-used end.
-    map.delete(conversationId);
-    map.set(conversationId, Math.max(prev, seq));
-    return;
-  }
-
-  map.set(conversationId, seq);
-  if (map.size > PERSISTED_SEQ_CONVERSATION_LIMIT) {
-    const oldestKey = map.keys().next().value;
-    if (oldestKey !== undefined) map.delete(oldestKey);
-  }
-}
-
-/**
- * Highest `seq` durably persisted for `conversationId`, or `null` when
- * none has been recorded in this process (cold conversation, or evicted
- * from the LRU map). Returned by `/messages` so a client can align the
- * snapshot with the live stream.
- */
-export function getPersistedSeq(conversationId: string): number | null {
-  return state.persistedSeqByConversation.get(conversationId) ?? null;
-}
-
 /**
  * Reset all stream state. Test-only.
  */
@@ -323,7 +263,6 @@ export function _resetStreamStateForTesting(): void {
   state.firstStampedSeq = 0;
   state.ring = [];
   state.totalSizeBytes = 0;
-  state.persistedSeqByConversation.clear();
 }
 
 /**
@@ -337,7 +276,6 @@ export function _simulateRestartForTesting(): void {
   state.firstStampedSeq = 0;
   state.ring = [];
   state.totalSizeBytes = 0;
-  state.persistedSeqByConversation.clear();
 }
 
 /**

package/src/runtime/routes/conversation-routes.ts

@@ -90,9 +90,11 @@ import {
   addMessage,
   extractImageSourcePaths,
   getConversation,
+  getConversationPersistedSeq,
   getMessages,
   getMessagesPaginated,
   hasMessages,
+  isConversationProcessing,
   type MessageRow,
   provenanceFromTrustContext,
   setConversationInferenceProfile,
@@ -122,7 +124,6 @@ import {
 } from "../../util/platform.js";
 import { silentlyWithLog } from "../../util/silently.js";
 import { assistantEventHub, broadcastMessage } from "../assistant-event-hub.js";
-import { getPersistedSeq } from "../assistant-stream-state.js";
 import { ACTOR_PRINCIPALS } from "../auth/route-policy.js";
 import {
   type GuardianPendingScope,
@@ -657,6 +658,7 @@ export function handleListMessages({
         oldestTimestamp: null,
         oldestMessageId: null,
         seq: null,
+        processing: false,
       };
     }
     return { messages: [] };
@@ -1006,11 +1008,19 @@ export function handleListMessages({
   });
 
   // Snapshot↔stream alignment token: the `seq` of the last event whose
-  // content is durably persisted for this conversation in the current
-  // daemon process. Returned on every resolved-conversation response so a
-  // client can apply only stream events with a higher `seq`. Null when
-  // nothing has been persisted in-process (cold/aged-out/post-restart).
-  const persistedSeq = getPersistedSeq(resolvedConversationId);
+  // content is durably persisted for this conversation, read from the
+  // `conversations.seq` column. Returned on every resolved-conversation
+  // response so a client can apply only stream events with a higher `seq`.
+  // Null when nothing has been persisted (the conversation was created before
+  // any stream activity, or predates the column) -- the client cold-starts.
+  const persistedSeq = getConversationPersistedSeq(resolvedConversationId);
+
+  // Authoritative "is the agent mid-turn?" signal, sourced from the
+  // `processing_started_at` column (persisted, survives daemon restarts).
+  // Clients use this to distinguish a live turn still in flight from a
+  // turn that silently died — without it, a dropped SSE stream leaves the
+  // UI spinning forever with no way to learn the server is actually idle.
+  const processing = isConversationProcessing(resolvedConversationId);
 
   if (isPaginated) {
     // Prefer the page's oldest visible row (the documented cursor semantic).
@@ -1034,6 +1044,7 @@ export function handleListMessages({
         oldestTimestamp: oldestTimestamp ?? null,
         oldestMessageId: oldestMessageId ?? null,
         seq: persistedSeq,
+        processing,
       };
     }
 
@@ -1043,10 +1054,11 @@ export function handleListMessages({
       ...(oldestTimestamp != null ? { oldestTimestamp } : {}),
       ...(oldestMessageId != null ? { oldestMessageId } : {}),
       seq: persistedSeq,
+      processing,
     };
   }
 
-  return { messages, seq: persistedSeq };
+  return { messages, seq: persistedSeq, processing };
 }
 
 /**
@@ -2688,6 +2700,12 @@ export const ROUTES: RouteDefinition[] = [
         .describe(
           "Global SSE `seq` of the last event whose content is durably persisted for this conversation in the current daemon process. A client can align this snapshot with the `/events` stream by applying only events with `seq` greater than this value. Null when no events have been persisted in this process (cold conversation, after a daemon restart, or when the conversation has aged out of the in-memory map) — clients should cold-start in that case. Absent on older daemons that predate this field.",
         ),
+      processing: z
+        .boolean()
+        .optional()
+        .describe(
+          "Whether the agent is currently mid-turn for this conversation, sourced authoritatively from the persisted `processing_started_at` column. `true` means a turn is in flight; `false` means the conversation is idle. Clients use this to recover from a dropped SSE stream: if a turn appears to be running locally but the server reports `processing: false`, the turn has ended (or died) and the UI should stop waiting rather than spin indefinitely. Absent on older daemons that predate this field.",
+        ),
     }),
     handler: (args) => handleListMessages(args),
   },