@jskit-ai/assistant-core 0.2.37 → 0.2.39

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+- `createConversationStorage`'s `write` saves nothing when its callback called no write method: the adapter's `writeRecord` does not run, so file storage no longer rewrites and flushes the whole conversation file, or creates an empty one for a missing conversation, when a write only looked (a delivery check, a message already saved), and the saved record stays cached.
+- Checking or recovering one message's delivery (`inspectDelivery`, and a send that finds its message already saved) finds that message's turn by its id instead of reading and cloning every turn of the conversation to find it.
+- With completed envelopes, a streamed turn's saved completed-envelope marker is read once per turn instead of once per delta: the marker is written with the turn's authored message and never changes, and a reply's hundreds of deltas each opened a storage read. A turn not saved yet is read again until it is.
+- **Breaking.** `assistantContract`'s `conversationsList` items have no `metadata`: a list shows a conversation's title, status and times, and the runtime metadata, which held the system prompt, every tool's schema and a note per message ever written, made each history page grow with every message. `conversationMessagesList` still answers the conversation with its metadata. Upgrading: a client that read `metadata` from a list item reads it from the conversation's messages read.
+- A conversation handle's `wait(query)` takes the query `read(query)` does, and `wait({ turnId })` answers only that turn (an empty `conversationLog` when it has no messages, or is a hidden completed-envelope turn), reading that turn and the latest one instead of reading and cloning every turn of the conversation.
+- The API driver gives `runLoop` its model's own turn limits (`turnLimits`), so inside one long turn old action results give way before a smaller model's window overflows; they waited for the default limits, sized for a million-token window.
 - A Bash command that Claude steering moves to the background keeps its own time limit: its `timeout`, or Claude's two-minute default, counted from when it started. Moved by the `background_tasks` control (Ctrl+B) so a person's message reaches Claude, the command used to lose that limit, so a wait loop that never ended held the turn in its background phase (and the host's Save behind it) until it failed half an hour later. When its limit passes, the shared Claude turn stops its task with the `stop_task` control and publishes the `steered_command_limit` diagnostic (`steered_command_stop_failed` when Claude refuses it); Claude answers the task notification and the turn settles as after a foreground timeout. Commands Claude starts with `run_in_background`, and subagents, keep running as before.
 - Claude's model list is kept once per account in the server process instead of once per account-query owner, as plan usage already is: an owner the host creates again (a restarted service, a reopened project) answers `readCatalogue` from the list another owner read, without starting a tool-free Claude, while the account's credentials and Claude Code are unchanged. A credentials change (sign-in, sign-out, token refresh) or a Claude Code update still reads it again, and an owner's `invalidate()` drops the list of every account it used, for every owner.
 - Test fixture only: the responsive assistant fixture's avatar is drawn in the theme's `primary` and `on-primary` roles instead of a raw `#6750a4` and `white`, so it follows the dark scheme like the rest of the conversation. A package test runs `jskit check m3`'s raw-colour rule over the fixture, which the check itself skips with every `fixtures/` folder.

package/examples/conversation/package.json

@@ -8,14 +8,14 @@
     "build": "vite build"
   },
   "dependencies": {
-    "@jskit-ai/assistant-core": "0.2.37",
+    "@jskit-ai/assistant-core": "0.2.39",
     "@jskit-ai/http-runtime": "0.2.18",
     "@jskit-ai/kernel": "0.2.18",
     "@jskit-ai/material-web": "0.1.5",
     "vue": "^3.5.13",
     "vuetify": "^4.0.0",
-    "@jskit-ai/connectors-core": "0.2.23",
-    "@jskit-ai/connectors-catalog": "0.2.23"
+    "@jskit-ai/connectors-core": "0.2.25",
+    "@jskit-ai/connectors-catalog": "0.2.25"
   },
   "devDependencies": {
     "@vitejs/plugin-vue": "^6.0.7",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/assistant-core",
-  "version": "0.2.37",
+  "version": "0.2.39",
   "type": "module",
   "scripts": {
     "test": "jskit test"
@@ -51,7 +51,7 @@
     "@ai-sdk/perplexity": "^4.0.43",
     "@ai-sdk/togetherai": "^3.0.49",
     "@ai-sdk/xai": "^4.0.58",
-    "@jskit-ai/agent": "0.1.2",
+    "@jskit-ai/agent": "0.1.3",
     "@jskit-ai/resource-core": "0.1.209",
     "@openrouter/ai-sdk-provider": "^3.0.0",
     "ai": "^7.0.152",

package/src/server/conversation/conversationDelivery.js

@@ -181,8 +181,8 @@ function createConversationDelivery({ storage, transcript, events, entries, read
     if (entry.active && !allowActive) throw failure("Wait for the current submission before checking delivery.", "conversation_busy", 409, { messageCode: "assistant.conversation.waitForSubmission" });
     if (entry.storageFailure) throw entry.storageFailure;
     if (entry.executionFailure) throw entry.executionFailure;
-    const history = await reads.readTranscript(entry);
-    const existing = history.find(turn => submittedMessage(turn)?.messageId === messageId);
+    // The message's own turn, found by its id: never a read of every turn.
+    const existing = await reads.findSubmittedTurn(entry, messageId);
     const receipt = existing && { status: "accepted", messageId, turnId: existing.turnId, duplicate: true };
     // Turns written before the first runtime segment carry no runtime metadata.
     const existingRuntime = existing?.metadata?.runtime;
@@ -191,7 +191,7 @@ function createConversationDelivery({ storage, transcript, events, entries, read
     if (existing && (existingRuntime?.segmentId !== entry.segmentId || existingRuntime.supersededBy ||
         existingRuntime.status === "complete" && !goalRequest)) return receipt;
     if (goalMessageId && goalMessageId !== messageId) {
-      const owner = history.find(turn => submittedMessage(turn)?.messageId === goalMessageId);
+      const owner = await reads.findSubmittedTurn(entry, goalMessageId);
       const ownerRuntime = owner?.metadata?.runtime;
       if (ownerRuntime?.goalMessageId !== goalMessageId || ownerRuntime.segmentId !== entry.segmentId) throw new Error("The goal command for this native continuation is missing.");
       const result = await inspectDelivery(entry, context, goalMessageId);
@@ -227,8 +227,7 @@ function createConversationDelivery({ storage, transcript, events, entries, read
     if (!observation.accepted) return { ...(receipt || { status: "unknown", messageId }),
       ...(observation.recoveryLimitation ? { recoveryLimitation: observation.recoveryLimitation } : {}) };
     if (entry.driver.canonicalTranscript) {
-      const latest = await reads.readTranscript(entry);
-      const saved = latest.find(turn => submittedMessage(turn)?.messageId === messageId);
+      const saved = await reads.findSubmittedTurn(entry, messageId);
       if (!saved) throw new Error("The native receipt did not persist its authored message.");
       const state = saved.metadata?.runtime;
       if (state?.segmentId !== entry.segmentId) throw new Error("The native receipt belongs to another conversation segment.");
@@ -261,7 +260,7 @@ function createConversationDelivery({ storage, transcript, events, entries, read
       const native = { ...observation, messageId };
       const results = [];
       const id = messageId;
-      let turn = history.find(turn => submittedMessage(turn)?.messageId === id);
+      let turn = existing;
       if (turn?.metadata?.runtime?.supersededBy || turn && turn.metadata?.runtime?.segmentId !== entry.segmentId) {
         throw new Error("Native history refers to a turn outside the active conversation segment.");
       }
@@ -276,7 +275,6 @@ function createConversationDelivery({ storage, transcript, events, entries, read
               ...(input.completedEnvelope === true ? { completedEnvelope: true } : {}),
               ...(typeof input.nativeToolAttempt === "boolean" ? { nativeToolAttempt: input.nativeToolAttempt } : {}) } } });
           turn = await transaction.readTurn(turnId);
-          history.push(turn);
         }
         const runtime = turn.metadata.runtime;
         if (runtime.nativeTurnId && native.nativeTurnId && runtime.nativeTurnId !== native.nativeTurnId) throw new Error("Native history changed the accepted turn's identity.");
@@ -349,7 +347,7 @@ function createConversationDelivery({ storage, transcript, events, entries, read
         if (delivered?.notSent) return notSentDeliveryReceipt(messageId);
         if (!delivered?.delivered) throw deliveryFailure(delivered);
       }
-      const row = (await reads.readTranscript(entry)).find(turn => submittedMessage(turn)?.messageId === messageId);
+      const row = await reads.findSubmittedTurn(entry, messageId);
       if (row) return { status: "accepted", messageId, turnId: row.turnId, duplicate: true };
       const threadId = state.request?.messageId === messageId ? state.request.threadId : conversationNativeIdentity(state);
       if (!threadId) return { status: "unknown", messageId };

package/src/server/conversation/conversationEvents.js

@@ -29,6 +29,25 @@ function serial(entry, callback) {
  * @param {boolean} dependencies.completedEnvelope
  */
 function createConversationEvents({ authorize, isClosed, storage, streams, completedEnvelope }) {
+  // Each entry's last saved turn whose completed-envelope marker was read. A turn's marker is written with its authored
+  // message and never changes, so the hundreds of deltas of one reply read it once, not once each.
+  const envelopeMarks = new WeakMap();
+
+  /**
+   * Whether the saved turn carries the completed-envelope marker; false while it is not saved.
+   * @param {ConversationEntry} entry
+   * @param {string} turnId
+   */
+  async function savedEnvelopeMark(entry, turnId) {
+    const known = envelopeMarks.get(entry);
+    if (known?.turnId === turnId) return known.marked;
+    const turn = await storage.read(entry.id, transaction => transaction.readTurn(turnId));
+    if (!turn) return false;
+    const marked = isCompletedEnvelopeTurn(turn);
+    envelopeMarks.set(entry, { turnId, marked });
+    return marked;
+  }
+
   /**
    * Send and its immediate admission share one authorization. Dispatch, receipt admission and
    * every other operation authorize again.
@@ -99,7 +118,7 @@ function createConversationEvents({ authorize, isClosed, storage, streams, compl
       let marked = isCompletedEnvelopeTurn(payload.patch?.turn) ||
         request?.completedEnvelope === true && request.input.origin === "application";
       if (!marked && payload.turnId) {
-        try { marked = await storage.read(entry.id, async transaction => isCompletedEnvelopeTurn(await transaction.readTurn(payload.turnId))); }
+        try { marked = await savedEnvelopeMark(entry, payload.turnId); }
         catch { /* An unavailable receipt cannot establish presentation custody. */ }
       }
       if (!marked && payload.type === "message") marked =

package/src/server/conversation/conversationHandles.js

@@ -142,14 +142,16 @@ function createConversationHandles({ entries, storage, defaultHost, events, read
           return entry.provider.inspectAdmission({ messageId, threadId, context, representation });
         });
       },
-      async wait(input) {
+      // Waits for the conversation's work to settle and reads it as read(query) does: `{ turnId }`
+      // reads only that turn, so a caller that waits on its own turn never reads the whole transcript.
+      async wait(query) {
         await events.access(context, id, "read", entry);
         if (entry.conversation?.commands) throw failure("This conversation uses its original read and subscription operations.", "conversation_original_read_only", 400, { messageCode: "assistant.conversation.originalReadOnly" });
-        if (entry.conversation?.native?.scoped) return entry.provider.waitNative({ input, context });
+        if (entry.conversation?.native?.scoped) return entry.provider.waitNative({ input: query, context });
         await entry.pending;
         await entry.active?.done;
         await events.access(context, id, "read", entry);
-        return reads.snapshot(entry, await entries.readState(entry));
+        return reads.snapshot(entry, await entries.readState(entry), query);
       },
       // Cancel of one unsent or unconfirmed message always records it; an
       // application conversation supplies its own operation for that.

package/src/server/conversation/conversationReads.js

@@ -1,5 +1,6 @@
 import { codexAppServerTurnStateFromAgentRun } from "./codexTurn.js";
 import { failure, stateErrorFields } from "./conversationRefusals.js";
+import { hasMessages, isCompletedEnvelopeTurn } from "./transcript.js";
 
 /** @typedef {import("./conversationEntries.js").ConversationEntry} ConversationEntry */
 /** @typedef {import("./conversationEntries.js").ConversationState} ConversationState */
@@ -85,6 +86,17 @@ function createConversationReads({ storage, transcript, streams, attachmentsOffe
     return (await readTranscript(entry)).find(turn => turn.turnId === turnId) || null;
   }
 
+  /**
+   * One saved turn by its id, or null, without reading the rest of the transcript.
+   * @param {ConversationEntry} entry
+   * @param {string} turnId
+   */
+  async function readTurn(entry, turnId) {
+    if (entry.conversation) return readBoundTurn(entry, turnId);
+    const turn = await storage.read(entry.id, transaction => transaction.readTurn(turnId));
+    return hasMessages(turn) ? turn : null;
+  }
+
   /** @param {ConversationEntry} entry */
   async function lastTranscriptTurn(entry) {
     const page = entry.conversation && !offersPages(entry) ? null
@@ -143,20 +155,24 @@ function createConversationReads({ storage, transcript, streams, attachmentsOffe
   }
 
   /**
-   * What a reader sees of a conversation from its saved state: a page of its transcript, or all
-   * of it, with the current turn's status, phase, error and live stream.
+   * What a reader sees of a conversation from its saved state: a page of its transcript, one turn
+   * of it (`query.turnId`), or all of it, with the current turn's status, phase, error and live stream.
    * @param {ConversationEntry} entry
    * @param {ConversationState} state
    * @param {object} [query]
    */
   async function snapshot(entry, state, query) {
-    const page = query ? await readTranscriptPage(entry, query) : null;
+    const oneTurn = query?.turnId !== undefined;
+    const page = oneTurn ? { conversationLog: [await readTurn(entry, query.turnId)]
+      .filter(turn => turn && !(completedEnvelope && isCompletedEnvelopeTurn(turn))) }
+      : query ? await readTranscriptPage(entry, query) : null;
     const conversationLog = page ? page.conversationLog
       : completedEnvelope ? await transcript.readConversationLog(entry.id, { presentation: true }) : await readTranscript(entry);
-    // Browsing an older page does not change the current turn's control/error state.
-    const latest = completedEnvelope || query?.beforeTurnId
-      ? entry.conversation ? (await readTranscriptPage(entry, { limit: 1 })).conversationLog
-        : (await transcript.readConversationLogPage(entry.id, { limit: 1 })).conversationLog : conversationLog;
+    // Browsing an older page, or reading one turn, does not change the current turn's control/error state.
+    const latest = oneTurn ? [await lastTranscriptTurn(entry)].filter(Boolean)
+      : completedEnvelope || query?.beforeTurnId
+        ? entry.conversation ? (await readTranscriptPage(entry, { limit: 1 })).conversationLog
+          : (await transcript.readConversationLogPage(entry.id, { limit: 1 })).conversationLog : conversationLog;
     const last = latest.at(-1)?.metadata?.runtime;
     const savedRequest = state.request;
     const nativeTurn = state.nativeTurn || (entry.driver.canonicalTranscript && state.binding?.codexAppServerRun
@@ -182,7 +198,7 @@ function createConversationReads({ storage, transcript, streams, attachmentsOffe
       goal: entry.goal || null,
       pendingRequest,
       conversationLog: conversationLog.filter(turn => !turn.metadata?.runtime?.supersededBy),
-      ...(page ? { pagination: page.pagination } : {}),
+      ...(page?.pagination ? { pagination: page.pagination } : {}),
       streaming: completedEnvelope && !entry.conversation ? { ...streaming,
         messages: streaming.messages.filter(message => !(message.origin === "application" && message.completedEnvelope === true)) } : streaming
     };
@@ -195,6 +211,7 @@ function createConversationReads({ storage, transcript, streams, attachmentsOffe
     findSubmittedTurn,
     readBoundTurn,
     lastTranscriptTurn,
+    readTurn,
     readNativeResult,
     logicalSnapshot,
     snapshot

package/src/server/conversation/providers/api.js

@@ -264,6 +264,8 @@ export function createApiConversationDriver({ connections, apiClientFactory, fet
       const pass = async history => {
         const result = await runLoop({ model, name: NAME, instructions: configuration.systemPrompt, history, tools: engineTools,
           summary: earlier, state: stateNote(), maxSteps: maximumSteps, onText, onStep, signal: stopped, clean: text => stripNotes(unsaid(text)),
+          // A long turn's old results give way within this model's window, not the largest one's.
+          turnLimits: window.turn,
           // With nothing done yet, a failed call is the reply's error, not an account.
           throwIf: (_error, steps) => !step && !steps.length,
           // A configured effort reaches every provider the standard way.

package/src/server/conversation/storage.js

@@ -152,9 +152,12 @@ export function createConversationStorage({ readRecord, writeRecord, deleteRecor
   function transaction(saved) {
     const { index: _index, ...draft } = saved;
     const added = new Map();
+    // Whether any write method ran: a transaction that only read saves nothing.
+    let changed = false;
     let ownTurns = false;
     const owned = new Set();
     function ownTurn(id) {
+      changed = true;
       if (!ownTurns) {
         draft.turns = new Map(draft.turns);
         ownTurns = true;
@@ -203,9 +206,10 @@ export function createConversationStorage({ readRecord, writeRecord, deleteRecor
     }
     return {
       record,
+      changed: () => changed,
       view: {
         async readMetadata() { return structuredClone(draft.metadata); },
-        async writeMetadata(value) { draft.metadata = structuredClone(value); },
+        async writeMetadata(value) { changed = true; draft.metadata = structuredClone(value); },
         async updateTurnMetadata(id, patch) {
           if (!turns().get(id)) throw new Error("The conversation turn does not exist.");
           const turn = ownTurn(id);
@@ -229,6 +233,7 @@ export function createConversationStorage({ readRecord, writeRecord, deleteRecor
         async writeSummary({ text, throughTurnId }) {
           if (typeof text !== "string" || !text.trim()) throw new TypeError("A conversation summary requires text.");
           if (!turns().get(throughTurnId)) throw new Error("The conversation turn does not exist.");
+          changed = true;
           draft.summary = { text, throughTurnId };
         },
         async appendMessage(id, { turnMetadata, ...message }) {
@@ -261,6 +266,8 @@ export function createConversationStorage({ readRecord, writeRecord, deleteRecor
     const operation = previous.then(async () => {
       const draft = transaction(await readSaved(id));
       const result = await callback(draft.view);
+      // A write that changed nothing leaves the saved record, and its cache, as they are.
+      if (!remove && !draft.changed()) return result;
       // A failed or partial save leaves the cached record unknown.
       cache.delete(id);
       if (remove) await deleteRecord(id);

package/src/server/conversation/transcript.js

@@ -163,7 +163,7 @@ export function createConversationTranscript({ storage, clock = currentDate, app
   });
 }
 
-function hasMessages(turn) {
+export function hasMessages(turn) {
   return Boolean(turn && (turn.system || turn.user || turn.assistant || turn.commentary?.length || turn.thinking?.length));
 }
 

package/src/shared/assistantResource.js

@@ -74,7 +74,7 @@ const conversationsListQuerySchema = createSchema({
   }
 });
 
-const conversationRecordSchema = createSchema({
+const conversationRecordFields = {
   id: {
     type: "string",
     required: true,
@@ -146,7 +146,13 @@ const conversationRecordSchema = createSchema({
     required: true,
     minLength: 1
   }
-});
+};
+
+const conversationRecordSchema = createSchema(conversationRecordFields);
+
+// A list's conversation: the record without its runtime metadata, which only a read of the conversation needs.
+const { metadata: _metadata, ...conversationListItemFields } = conversationRecordFields;
+const conversationListItemSchema = createSchema(conversationListItemFields);
 
 const messageRecordSchema = createSchema({
   id: {
@@ -277,7 +283,7 @@ const assistantContract = defineApiContract({
     conversationsList: {
       method: "GET",
       query: conversationsListQuerySchema,
-      output: createCursorListValidator(createSchemaDefinition(conversationRecordSchema, "replace"))
+      output: createCursorListValidator(createSchemaDefinition(conversationListItemSchema, "replace"))
     },
     conversationMessagesList: {
       method: "GET",

package/test/apiConversationDriver.test.js

@@ -254,3 +254,17 @@ test("a short history is read whole with its stored summary, and nothing is save
   assert.match(f.requests[0].messages[0].content, /Summary of the earlier part of this conversation[^]*Earlier: hello\./u);
   assert.deepEqual(f.requests[0].messages.slice(1, -1).map(message => message.content), ["Hi", "Hello", "Next question"]);
 });
+
+// Inside one long turn, old action results give way to a note once the request nears the model's
+// own window, not the million-token one the engine's defaults are sized for: sized for that, a
+// smaller model's request overflowed long before anything was left out.
+test("a long turn's old action results give way within the model's window", async () => {
+  const f = fixture({ limits: { contextTokens: 10_000 },
+    reply: round => round <= 22 ? { call: "action_execute", input: { page: round } } : { text: "Read every page." },
+    execute: (_input, count) => ({ ok: true, result: { page: count, rows: "row ".repeat(1000) } }) });
+  await f.run("Read every page of the report.");
+  assert.equal(f.executions.length, 22);
+  const last = JSON.stringify(f.streamed.at(-1).messages);
+  assert.match(last, /was left out to save room/u);
+  assert.match(last, /\\"page\\":22/u, "the newest results stay");
+});

package/test/assistantResource.test.js

@@ -70,3 +70,18 @@ test("assistant conversation message params accept numeric path strings", async
   assert.equal(parsed.ok, true);
   assert.deepEqual(parsed.value, { conversationId: 2 });
 });
+
+// A list shows each conversation without its runtime metadata (the system prompt, every tool's
+// schema and a note per message), which grows with every message; a read of the conversation keeps it.
+test("a conversation list item carries no runtime metadata, and a read of the conversation does", async () => {
+  const item = { id: "1", workspaceId: null, title: "Trip", createdByUserId: "7", status: "active", provider: "openai",
+    model: "gpt-4.1", surfaceId: "home", startedAt: "2026-03-16T10:00:00.000Z", endedAt: null, messageCount: 2,
+    createdAt: "2026-03-16T10:00:00.000Z", updatedAt: "2026-03-16T10:01:00.000Z" };
+  const listed = await validateOperationSection({ operation: assistantContract.operations.conversationsList,
+    section: "output", value: { items: [item], nextCursor: null } });
+  assert.equal(listed.ok, true);
+  assert.equal(Object.hasOwn(listed.value.items[0], "metadata"), false);
+  const read = await validateOperationSection({ operation: assistantContract.operations.conversationMessagesList,
+    section: "output", value: { conversation: item, entries: [], page: 1, pageSize: 200, total: 0, totalPages: 1 } });
+  assert.equal(read.ok, false, "a conversation read still requires its metadata");
+});

package/test/conversationSession.test.js

@@ -1429,3 +1429,47 @@ test("native settings authorize their scope and reject replaced or closed host p
   await assert.rejects(runtime.updateNativeConversationSettings(request), { code: "conversation_handle_closed" });
   assert.deepEqual([acquisitions, updates], [1, 1]);
 });
+
+// A caller that waits on its own turn reads that turn, never every turn of the conversation: the
+// whole transcript was read and cloned at the end of every chat turn to keep one.
+test("waiting on one turn reads that turn, not the whole transcript", async t => {
+  const memory = createMemoryConversationStorage();
+  const turnReads = [];
+  const storage = { ...memory, read: (scope, operation) => memory.read(scope, transaction =>
+    operation({ ...transaction, readTurn: id => { turnReads.push(id); return transaction.readTurn(id); } })) };
+  const f = await fixture(t, { storage });
+  for (const [messageId, text] of [["m1", "First"], ["m2", "Second"], ["m3", "Third"]]) {
+    await f.conversation.send({ messageId, text });
+    await f.conversation.wait();
+  }
+  const { turnId } = await f.conversation.send({ messageId: "m4", text: "Fourth" });
+  await f.conversation.wait();
+  turnReads.length = 0;
+  const result = await f.conversation.wait({ turnId });
+  assert.deepEqual(result.conversationLog.map(turn => turn.turnId), [turnId]);
+  assert.equal(result.conversationLog[0].assistant.text, "Hello there.");
+  assert.equal(result.status, "ready");
+  assert.equal(result.pagination, undefined);
+  assert.deepEqual([...new Set(turnReads)], [turnId], "only the turn waited on, which is also the latest, is read");
+  assert.deepEqual((await f.conversation.wait({ turnId: "000001" })).conversationLog.map(turn => turn.user.text), ["First"]);
+  assert.deepEqual((await f.conversation.wait({ turnId: "999999" })).conversationLog, []);
+});
+
+// Checking one message's delivery finds that message's turn by its id; it read and cloned every
+// turn of the conversation to find it.
+test("checking one message's delivery reads that message's turn, not the whole transcript", async t => {
+  const memory = createMemoryConversationStorage();
+  const turnReads = [];
+  const storage = { ...memory, read: (scope, operation) => memory.read(scope, transaction =>
+    operation({ ...transaction, readTurn: id => { turnReads.push(id); return transaction.readTurn(id); } })) };
+  const f = await fixture(t, { storage });
+  for (const [messageId, text] of [["m1", "First"], ["m2", "Second"], ["m3", "Third"], ["m4", "Fourth"]]) {
+    await f.conversation.send({ messageId, text });
+    await f.conversation.wait();
+  }
+  turnReads.length = 0;
+  const receipt = await f.conversation.inspectDelivery({ messageId: "m2" });
+  assert.equal(receipt.status, "accepted");
+  assert.equal(receipt.turnId, "000002");
+  assert.deepEqual([...new Set(turnReads)], ["000002"]);
+});

package/test/conversationStreaming.test.js

@@ -4,6 +4,7 @@ import { createConversationStreams } from "../src/server/conversation/streams.js
 import { classifyCodexAppServerEvent } from "../src/server/conversation/codexEvents.js";
 import { createOpenCodeServerClient, openCodeAssistantMessageText } from "../src/server/conversation/openCodeClient.js";
 import { mergeConversationStream } from "../src/shared/conversation/streaming.js";
+import { createConversationEvents } from "../src/server/conversation/conversationEvents.js";
 
 test("Codex chunks retain whitespace and item identity; completed items reject late chunks", () => {
   const streams = createConversationStreams();
@@ -256,3 +257,27 @@ test("live message metadata retains its captured attribution across deltas witho
   const other = streams.update("two", { ...input, metadata: { model: { id: "other" } } });
   assert.equal(other.messages[0].metadata.model.id, "other");
 });
+
+// A completed-envelope runtime reads a streamed turn's saved marker once, not once for each of a
+// reply's hundreds of deltas: the marker is written with the turn's authored message and never changes.
+test("a reply's streamed deltas read their turn's completed-envelope marker once", async () => {
+  const reads = [];
+  const turns = new Map([["000001", { turnId: "000001", user: { text: "Hi" }, metadata: { runtime: { origin: "user" } } }],
+    ["000002", { turnId: "000002", system: { text: "Wake" }, metadata: { runtime: { origin: "application", completedEnvelope: true } } }]]);
+  const storage = { read: (_id, operation) => operation({ readTurn: async turnId => { reads.push(turnId); return structuredClone(turns.get(turnId) || null); } }) };
+  const events = createConversationEvents({ authorize: () => true, isClosed: () => false, storage, streams: null, completedEnvelope: true });
+  const heard = [];
+  const entry = { id: "chat", disposed: false, active: { requests: new Map() },
+    listeners: new Set([{ context: {}, authorizedAt: Date.now(), listener: event => { heard.push(event); } }]) };
+  const delta = (turnId, text) => ({ type: "message", role: "assistant", status: "inProgress", turnId, messageId: `reply-${turnId}`, text });
+  for (let index = 1; index <= 50; index++) await events.emit(entry, delta("000001", "word ".repeat(index)));
+  assert.deepEqual(reads, ["000001"]);
+  assert.equal(heard.length, 50);
+  assert.equal(heard.some(event => event.completedEnvelope), false);
+  for (let index = 1; index <= 5; index++) await events.emit(entry, delta("000002", "raw".repeat(index)));
+  assert.deepEqual(reads, ["000001", "000002"]);
+  assert.equal(heard.slice(50).every(event => event.completedEnvelope === true), true, "a marked turn's deltas stay marked");
+  await events.emit(entry, delta("000003", "unsaved"));
+  await events.emit(entry, delta("000003", "unsaved still"));
+  assert.deepEqual(reads, ["000001", "000002", "000003", "000003"], "a turn not saved yet is read again");
+});

package/test/fileConversationStorage.test.js

@@ -109,3 +109,15 @@ test("saved conversations are parsed once until they change and look messages up
   await f.storage.read("cached", transaction => transaction.appendMessage("000001", { role: "assistant", text: "Read only", at: "2026-01-01T00:00:03Z" }));
   assert.equal((await f.transcript.readConversationLog("cached"))[0].assistant, null);
 });
+
+test("a write that changes nothing leaves the saved file alone", async (t) => {
+  const f = await fixture(t);
+  await f.transcript.writeConversationUserMessage("unchanged", { text: "First", messageId: "first", at: "2026-01-01T00:00:00Z" });
+  const [file] = (await readdir(f.directory)).filter(name => name.endsWith(".json"));
+  const before = await stat(join(f.directory, file), { bigint: true });
+  assert.equal(await f.storage.write("unchanged", transaction => transaction.findMessageTurnId("first")), "000001");
+  const after = await stat(join(f.directory, file), { bigint: true });
+  assert.deepEqual([after.ino, after.mtimeNs], [before.ino, before.mtimeNs], "an unchanged conversation is not saved again");
+  assert.deepEqual(await f.storage.write("absent", transaction => transaction.listTurnIds()), []);
+  assert.deepEqual((await readdir(f.directory)).filter(name => name.endsWith(".json")), [file], "looking at a missing conversation does not create it");
+});