@jskit-ai/assistant-core 0.1.225 → 0.1.227

package/test/codexConversationSession.test.js

@@ -1341,7 +1341,12 @@ test("Codex steering admits once and preserves original unfinished-reply groupin
   assert.equal(trace.filter(row => row.method === "turn/steer").length, 1);
   assert.equal(trace.find(row => row.method === "turn/steer").params.clientUserMessageId, "after");
   assert.equal((await f.conversation.send(steering)).duplicate, true);
-  await assert.rejects(f.conversation.send({ ...steering, messageId: "idle" }), { code: "conversation_not_steerable" });
+  await assert.rejects(f.conversation.send({ ...steering, messageId: "idle" }), { code: "conversation_steer_turn_finished", delivery: "not-sent" });
+  const next = { messageId: "idle", text: steering.text };
+  await f.conversation.send(next);
+  await f.conversation.wait();
+  assert.equal((await f.conversation.send(next)).duplicate, true);
+  assert.equal((await f.trace()).filter(row => row.method === "turn/start").length, 2);
 });
 
 test("Codex steering rejection leaves the active turn available and checks authorization before dispatch", async t => {
@@ -1718,6 +1723,9 @@ test("Codex cancellation drains owned work, and a deadline saves a failed turn",
   const f = await fixture(t, { limits: { timeoutMs: 2000 } });
   await f.conversation.send({ messageId: "cancel", text: "wait" });
   assert.deepEqual(await f.conversation.cancel(), { stopped: true });
+  await assert.rejects(f.conversation.send({ messageId: "late-after-stop", text: "Do more", steer: true }), {
+    code: "conversation_not_steerable", delivery: "not-sent"
+  });
   await f.conversation.send({ messageId: "timeout", text: "wait" });
   const state = await f.conversation.wait();
   assert.equal(state.conversationLog[0].metadata.runtime.status, "cancelled");

package/test/codexGoal.test.js

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { CodexAppServerAgentProvider } from "../src/server/conversation/codexProvider.js";
+import { createCodexGoalCommands } from "../src/server/conversation/codexGoalCommands.js";
 import { createCodexAppServerProviderOwner } from "../src/server/conversation/codexProviderOwner.js";
 
 test("cached goal reads retain the original session and interactive-provider boundary", async t => {
@@ -187,3 +188,49 @@ for (const pause of [false, true]) {
     assert.equal(requests.some(row => row.method === "turn/interrupt" || row.method === "turn/start"), false);
   });
 }
+
+for (const action of ["set", "resume"]) test(`cancelled Codex goal ${action} cannot dispatch after native goal read`, async () => {
+  const controller = new AbortController();
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  let writes = 0;
+  const goal = { status: "paused", objective: "Finish the checks", createdAt: 1 };
+  const owner = createCodexGoalCommands({ turnState: () => ({ status: "interrupted" }),
+    subscribeCodexAppServerEvents() {}, reconcileCodexAppServerGoalUpdated: async () => {}, publish: async () => {} });
+  const provider = {
+    async readGoal() { entered.resolve(); await release.promise; return { goal: action === "set" ? null : goal }; },
+    async setGoal() { writes++; return { goal }; }, async setGoalStatus() { writes++; return { goal }; }
+  };
+  const operation = owner.updateCodexAppServerGoal("session", { action, threadId: "native", ...goal },
+    { context: { threadId: "native", provider, session: {} }, signal: controller.signal });
+  void operation.catch(() => {});
+  await entered.promise;
+  controller.abort(new Error("Goal stopped"));
+  release.resolve();
+  await assert.rejects(operation, /Goal stopped/);
+  assert.equal(writes, 0);
+});
+
+for (const action of ["set", "resume"]) test(`Codex goal ${action} forwards cancellation through provider preparation`, async t => {
+  const controller = new AbortController();
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  const provider = new CodexAppServerAgentProvider({}, { credentials: { assertCurrent() {} } });
+  t.after(() => provider.close());
+  const goal = { status: "paused", objective: "Finish the checks", createdAt: 1 };
+  const writes = [];
+  provider.readGoal = async () => ({ goal: action === "set" ? null : goal });
+  provider.activeClient = async () => { entered.resolve(); await release.promise; return {
+    async request(method, input, { signal }) { signal.throwIfAborted(); writes.push({ method, input }); return { goal }; }
+  }; };
+  const owner = createCodexGoalCommands({ turnState: () => ({ status: "interrupted" }),
+    subscribeCodexAppServerEvents() {}, reconcileCodexAppServerGoalUpdated: async () => {}, publish: async () => {} });
+  const operation = owner.updateCodexAppServerGoal("session", { action, threadId: "native", ...goal },
+    { context: { threadId: "native", provider, session: {} }, signal: controller.signal });
+  void operation.catch(() => {});
+  await entered.promise;
+  controller.abort(new Error("Goal stopped"));
+  release.resolve();
+  await assert.rejects(operation, /Goal stopped/);
+  assert.deepEqual(writes, []);
+});

package/test/codexModelCatalog.test.js

@@ -360,3 +360,58 @@ test("catalog cancellation during shared acquisition still awaits startup and cl
   assert.equal(captures.stopRuntimes, 1);
   assert.equal(captures.closes, 1);
 });
+
+test("native context window uses the exact runtime model's normal window without extending it", async t => {
+  const { readCodexModelContextWindow } = await import("../src/server/conversation/codexConfiguration.js");
+  const first = await fixture(t, "");
+  const second = await fixture(t, "");
+  const catalogue = { models: [
+    { slug: "astra", context_window: 272000, max_context_window: 872000, effective_context_window_percent: 95 },
+    { slug: "sol", context_window: 500000, max_context_window: 872000, effective_context_window_percent: 95 }
+  ] };
+  const firstPath = path.join(first.runtimeDir, "models.json");
+  await writeFile(firstPath, JSON.stringify(catalogue));
+  await writeFile(path.join(second.runtimeDir, "models.json"), JSON.stringify({ models: [
+    { slug: "astra", context_window: 128000, max_context_window: 872000, effective_context_window_percent: 90 }
+  ] }));
+  const before = await readFile(firstPath, "utf8");
+  assert.deepEqual(await readCodexModelContextWindow({ runtimeDir: first.runtimeDir, model: "astra" }),
+    { model: "astra", windowTokens: 272000, effectiveWindowTokens: 258400 });
+  assert.deepEqual(await readCodexModelContextWindow({ runtimeDir: first.runtimeDir, model: "sol" }),
+    { model: "sol", windowTokens: 500000, effectiveWindowTokens: 475000 });
+  assert.deepEqual(await readCodexModelContextWindow({ runtimeDir: second.runtimeDir, model: "astra" }),
+    { model: "astra", windowTokens: 128000, effectiveWindowTokens: 115200 });
+  assert.equal(await readFile(firstPath, "utf8"), before);
+  catalogue.models[0].context_window = 200000;
+  await writeFile(firstPath, JSON.stringify(catalogue));
+  assert.equal((await readCodexModelContextWindow({ runtimeDir: first.runtimeDir, model: "astra" })).windowTokens, 200000,
+    "a new runtime catalogue is not hidden by an earlier read");
+});
+
+test("native context window refuses missing or invalid normal limits without leaking catalogue content", async t => {
+  const { readCodexModelContextWindow } = await import("../src/server/conversation/codexConfiguration.js");
+  const f = await fixture(t, "");
+  const valid = { slug: "astra", context_window: 272000, max_context_window: 872000, effective_context_window_percent: 95 };
+  const target = path.join(f.runtimeDir, "models.json");
+  for (const contents of [
+    "secret-provider-key", JSON.stringify({ models: [] }),
+    ...[
+      { ...valid, context_window: undefined }, { ...valid, context_window: "272000" },
+      { ...valid, context_window: 0 }, { ...valid, context_window: 1.5 },
+      { ...valid, effective_context_window_percent: 0 }, { ...valid, effective_context_window_percent: 101 },
+      { ...valid, effective_context_window_percent: undefined }, { ...valid, slug: "another-model" }
+    ].map(row => JSON.stringify({ models: [row], secret: "secret-provider-key" })),
+    JSON.stringify({ models: [valid, valid] })
+  ]) {
+    await writeFile(target, contents);
+    await assert.rejects(readCodexModelContextWindow({ runtimeDir: f.runtimeDir, model: "astra" }), error => {
+      assert.match(error.message, /normal context window/);
+      assert.doesNotMatch(error.message, /secret-provider-key/);
+      return true;
+    });
+  }
+  await rm(target);
+  await assert.rejects(readCodexModelContextWindow({ runtimeDir: f.runtimeDir, model: "astra" }), /normal context window/);
+  await assert.rejects(readCodexModelContextWindow({ runtimeDir: "", model: "astra" }), /runtime.*model/);
+  await assert.rejects(readCodexModelContextWindow({ runtimeDir: f.runtimeDir, model: "" }), /runtime.*model/);
+});

package/test/codexTurn.test.js

@@ -2686,6 +2686,36 @@ test("native failure detail grace rejects invalid duration", () => {
   }
 });
 
+for (const phase of ["final_answer", "", "commentary"]) {
+  test(`a provider usage limit remains visible after recovering ${phase || "unmarked"} assistant output`, async t => {
+    const notices = [];
+    const detail = "You've hit your usage limit. Try again at Oct 22nd, 2026 11:37 PM.";
+    const f = await receiptFixture({ failureDetailGraceMs: 0,
+      checkpoint: async (_id, input) => f.checkpoints.push(input),
+      outcomeNotice: async (_runtime, _id, _thread, _turn, outcome, error, options) =>
+        notices.push({ outcome, error, ...options })
+    });
+    t.after(() => f.owner.clearSessionRecoveryTimers(f.sessionId));
+    f.run.providerStatus = "failed";
+    f.history = [{ id: f.turnId, status: "failed", items: [outputItem("saved-output", "Work saved so far.", phase)] }];
+    f.observe();
+    const notification = { method: "turn/completed", params: { threadId: f.threadId,
+      turn: { id: f.turnId, status: "failed", error: { message: detail, codexErrorInfo: "usageLimitExceeded" } } } };
+    f.emit(notification);
+    await f.drain();
+    assert.deepEqual(notices, [{ outcome: "provider_failure", error: `${detail} usageLimitExceeded`, usageLimitExceeded: true }]);
+    assert.equal(f.run.state, "failed");
+    assert.match(f.run.error, /hit your usage limit/);
+    assert.equal(f.checkpoints.length, 1);
+    assert.equal(f.checkpoints[0].turnOutcome, "provider_failure");
+    assert.equal((await f.replies()).length, phase === "commentary" ? 0 : 1);
+    f.emit(notification);
+    await f.drain();
+    assert.equal(notices.length, 1, "Repeated terminal events do not duplicate the failure notice");
+    assert.equal(f.checkpoints.length, 1);
+  });
+}
+
 for (const change of ["detail", "expiry", "repeat", "cleanup", "successor", "foreign-error", "user-stop"]) {
   test(`native failure detail grace preserves the existing notification owner for ${change}`, { timeout: 2000 }, async t => {
     const settled = Promise.withResolvers();
@@ -3185,3 +3215,201 @@ test("completed envelope returning corrections remain full while the current bat
   assert.deepEqual(carried.removedMessageIds, ["removed"]);
   assert.deepEqual(value.engines.codex.seen, { "old-row": "edited", "current-row": "current" });
 });
+
+
+test("a provisional row retries only with the exact retained no-attempt evidence after reload", async () => {
+  const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
+  for (const proof of ["rejected", "attempted", "missing", "other-input"]) {
+    let saved = { lastEngine: "claude", engines: { claude: { seen: {}, ...(proof !== "missing" ? { pending: {
+      messageId: proof === "other-input" ? "other" : "followup", message: "Exact prepared input",
+      displayMessage: "Follow-up", displayAttachments: [], attachmentIds: [], seen: {}, attempted: proof === "attempted"
+    } } : {}) } } };
+    let sends = 0;
+    const changeover = createConversationChangeover({
+      state: { async read() { return structuredClone(saved); }, async write(value) { saved = structuredClone(value); } },
+      transcript: { async hasMessage() { return true; }, async writeUserMessage() { assert.fail("The existing authored row must not be copied"); } },
+      agent: {
+        async inspectMessageAdmission() { return { admission: "unknown" }; },
+        async sendMessage(input) {
+          sends += 1;
+          assert.equal(input.messageId, "followup");
+          assert.equal(input.message, "Exact prepared input");
+          await input.onPromptSending({ threadId: "retained-native" });
+          return { ok: true, delivered: true };
+        }
+      }
+    });
+    const result = await changeover.send({ engineId: "claude", messages: [{ id: "row", messageId: "followup",
+      role: "user", text: "Follow-up", receipt: false, version: "v1" }], input: { messageId: "followup", message: "Follow-up" } });
+    assert.equal(result.delivered, proof === "rejected");
+    assert.equal(sends, proof === "rejected" ? 1 : 0);
+    if (proof === "rejected") assert.equal(saved.engines.claude.pending, undefined);
+  }
+});
+
+
+test("ordinary same-engine input reserves the existing pending proof without adding context", async () => {
+  const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
+  let saved = { lastEngine: "claude", engines: { claude: { seen: {} } } };
+  const messages = [];
+  let sends = 0;
+  let failed = true;
+  const create = () => createConversationChangeover({
+    state: { async read() { return structuredClone(saved); }, async write(value) { saved = structuredClone(value); } },
+    transcript: { async hasMessage() { return messages.length > 0; } },
+    captureContext: true,
+    agent: {
+      async inspectMessageAdmission() { return { admission: "unknown" }; },
+      async sendMessage(input) {
+        sends++;
+        assert.equal(input.message, "Unchanged authored words");
+        assert.equal(input.contextText, undefined);
+        assert.equal(saved.engines.claude.pending.attempted, false);
+        await input.onPromptSending({ threadId: "exact-native" });
+        assert.equal(saved.engines.claude.pending.attempted, true);
+        if (failed) {
+          messages.push({ id: "provisional", messageId: "same", role: "user", receipt: false, text: input.message, version: "v1" });
+          await input.onPromptRejected();
+          throw Object.assign(new Error("Ended before write"), { delivery: "not-sent" });
+        }
+        return { ok: true, delivered: true };
+      }
+    }
+  });
+  const input = { messageId: "same", message: "Unchanged authored words" };
+  await assert.rejects(create().send({ engineId: "claude", messages, input }), { delivery: "not-sent" });
+  assert.equal(saved.engines.claude.pending.attempted, false);
+  failed = false;
+  assert.equal((await create().send({ engineId: "claude", messages, input })).delivered, true);
+  assert.equal(saved.engines.claude.pending, undefined);
+  assert.equal(sends, 2);
+  assert.equal(messages.length, 1);
+});
+
+test("native history byte budget carries all fitting messages and trims complete oldest messages", async () => {
+  const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
+  const messages = Array.from({ length: 80 }, (_, index) => ({
+    id: `history-${index}`, messageId: `authored-${index}`, role: index % 2 ? "assistant" : "user",
+    text: `${index}: 漢字 🐈 \\"\n`.repeat(20), version: `v-${index}`, engineId: "claude",
+    at: new Date(2026, 0, 1, 0, index).toISOString(), model: "original-model",
+    ...(index === 0 ? { attachments: [{ attachmentId: "old-file", name: "old.txt" }] } : {}),
+    ...(index === 79 ? { attachments: [{ attachmentId: "new-file", name: "new.txt" }] } : {})
+  }));
+  const original = structuredClone(messages);
+  const rows = messages.map(({ version, ...message }) => message);
+  const size = selected => Buffer.byteLength(JSON.stringify({ messages: selected, removedMessageIds: [] }));
+  const limits = [size(rows), size(rows.slice(40)), size(rows.slice(40)) - 1, size([])];
+  for (const maximumHistoryBytes of limits) {
+    let saved = { lastEngine: "claude", engines: { codex: { seen: {} } } };
+    let sent;
+    const changeover = createConversationChangeover({
+      maximumInitialMessages: Infinity, maximumHistoryBytes, captureContext: true,
+      state: { async read() { return saved; }, async write(value) { saved = structuredClone(value); } },
+      transcript: { async hasMessage() { return false; } },
+      agent: { async sendMessage(input) { sent = input; return { ok: true, delivered: true }; } }
+    });
+    await changeover.send({ engineId: "codex", messages, input: { messageId: "new-request", message: "My full current request." } });
+    const encoded = sent.contextText.split("\n").find(line => line.startsWith("{"));
+    const carried = JSON.parse(encoded);
+    const expected = maximumHistoryBytes === size(rows) ? rows : maximumHistoryBytes === size(rows.slice(40))
+      ? rows.slice(40) : maximumHistoryBytes === size([]) ? [] : rows.slice(41);
+    assert.deepEqual(carried.messages, expected);
+    assert.ok(Buffer.byteLength(encoded) <= maximumHistoryBytes);
+    assert.deepEqual(sent.contextAttachments, expected.flatMap(message => message.attachments || []));
+    assert.ok(sent.message.endsWith("My full current request."));
+    assert.deepEqual(saved.engines.codex.seen, Object.fromEntries(messages.map(message => [message.id, message.version])));
+    assert.deepEqual(messages, original);
+  }
+});
+
+test("native history byte budget bounds returning corrections and retains exact retry after reload", async () => {
+  const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
+  const messages = [
+    { id: "old", messageId: "old-input", role: "user", engineId: "claude", text: "Older correction", version: "edited-old" },
+    { id: "middle", messageId: "middle-input", role: "user", engineId: "claude", text: "Middle correction", version: "edited-middle" },
+    { id: "new", messageId: "new-reply", role: "assistant", engineId: "claude", text: "Latest missed reply", version: "new" }
+  ];
+  const expected = messages.slice(1).map(({ version, ...message }) => ({ ...message,
+    ...(message.id === "middle" ? { corrected: true } : {}) }));
+  const maximumHistoryBytes = Buffer.byteLength(JSON.stringify({ messages: expected, removedMessageIds: ["deleted"] }));
+  let saved = { lastEngine: "claude", engines: { codex: { seen: { old: "v0", middle: "v1", deleted: "v2" } } } };
+  const attempts = [];
+  const state = { async read() { return structuredClone(saved); }, async write(value) { saved = structuredClone(value); } };
+  const transcript = { async hasMessage() { return false; }, async writeUserMessage() {} };
+  const input = { messageId: "stable-input", message: "My request" };
+  const first = createConversationChangeover({ state, transcript, maximumHistoryBytes, captureContext: true,
+    agent: { async sendMessage(value) { attempts.push(value); return { ok: false, delivered: false }; } } });
+  await first.send({ engineId: "codex", messages, input });
+  const encoded = attempts[0].contextText.split("\n").find(line => line.startsWith("{"));
+  assert.deepEqual(JSON.parse(encoded), { messages: expected, removedMessageIds: ["deleted"] });
+  assert.equal(Buffer.byteLength(encoded), maximumHistoryBytes);
+  // A later budget or transcript change cannot rewrite a retained exact input.
+  const reloaded = createConversationChangeover({ state, transcript, maximumHistoryBytes: 1,
+    agent: { async sendMessage(value) { attempts.push(value); return { ok: true, delivered: true }; } } });
+  await reloaded.send({ engineId: "codex", messages: [], input });
+  assert.equal(attempts[1].message, attempts[0].message);
+  assert.equal(saved.engines.codex.pending, undefined);
+});
+
+test("native history byte budget rejects invalid bounds and an oversized removal envelope before dispatch", async () => {
+  const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
+  for (const maximumHistoryBytes of [0, -1, 1.5, "100", NaN]) {
+    assert.throws(() => createConversationChangeover({ maximumHistoryBytes }), /history.*byte.*limit/i);
+  }
+  assert.throws(() => createConversationChangeover({ maximumInitialMessages: Infinity }), /bounded.*history|history.*byte.*limit/i);
+  let writes = 0;
+  let sends = 0;
+  const changeover = createConversationChangeover({ maximumHistoryBytes: 10,
+    state: { async read() { return { lastEngine: "claude", engines: { codex: { seen: { removed: "v1" } } } }; },
+      async write() { writes++; } },
+    transcript: { async hasMessage() { return false; } },
+    agent: { async sendMessage() { sends++; } }
+  });
+  await assert.rejects(changeover.send({ engineId: "codex", messages: [], input: { messageId: "too-small", message: "Words" } }),
+    /history.*budget/i);
+  assert.equal(writes, 0);
+  assert.equal(sends, 0);
+});
+
+test("native history budget resolves only for new catch-up and preserves the retry's original budget", async () => {
+  const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
+  const message = { id: "retained", role: "user", text: "Original words", version: "v1", engineId: "claude" };
+  let saved = { lastEngine: "claude", engines: { codex: { seen: {} } } };
+  const state = { async read() { return structuredClone(saved); }, async write(value) { saved = structuredClone(value); } };
+  const sent = [];
+  const calls = [];
+  const input = { messageId: "bounded-input", message: "Current words" };
+  const create = maximumHistoryBytes => createConversationChangeover({
+    state, maximumInitialMessages: Infinity, maximumHistoryBytes,
+    transcript: { async hasMessage() { return false; } },
+    agent: { async sendMessage(value) { sent.push(value); return { ok: false, delivered: false }; } }
+  });
+  await create(async query => { calls.push(query); return 4096; }).send({ engineId: "codex", messages: [message], input });
+  assert.deepEqual(calls, [{ engineId: "codex", returning: false, input, handover: "" }]);
+  assert.match(sent[0].message, /Original words/);
+  await create(() => { throw new Error("A retry must not prepare another native budget"); })
+    .send({ engineId: "codex", messages: [], input });
+  assert.equal(sent[1].message, sent[0].message);
+  saved = { lastEngine: "codex", engines: { codex: { seen: { retained: "v1" } } } };
+  await create(() => { throw new Error("Ordinary input has no history to budget"); })
+    .send({ engineId: "codex", messages: [message], input: { messageId: "ordinary-input", message: "Just these words" } });
+  assert.equal(sent[2].message, "Just these words");
+});
+
+test("native history budget rejects unavailable dynamic limits before pending delivery", async () => {
+  const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
+  for (const budget of [0, -1, NaN, Infinity, "4096", undefined]) {
+    let writes = 0;
+    let sends = 0;
+    const changeover = createConversationChangeover({ maximumInitialMessages: Infinity,
+      maximumHistoryBytes: async () => budget,
+      state: { async read() { return { lastEngine: "claude", engines: {} }; }, async write() { writes++; } },
+      transcript: { async hasMessage() { return false; } },
+      agent: { async sendMessage() { sends++; } }
+    });
+    await assert.rejects(changeover.send({ engineId: "codex", messages: [], input: { messageId: "unavailable", message: "Words" } }),
+      /history.*byte.*limit/i);
+    assert.equal(writes, 0);
+    assert.equal(sends, 0);
+  }
+});

package/test/conversationAttachments.test.js

@@ -1,3 +1,4 @@
+import { useAssistantAttachments } from "../src/client/conversation/useAssistantAttachments.js";
 import assert from "node:assert/strict";
 import test from "node:test";
 import { createConversationRuntime, createMemoryConversationStorage } from "../src/server/conversation/index.js";
@@ -236,3 +237,19 @@ test("authorization revoked during file resolution prevents dispatch", async t =
   allowed = true;
   assert.equal((await f.conversation.read()).conversationLog.length, 0);
 });
+
+
+test("attachment validation displays the application's configured binary or decimal limit", async () => {
+  for (const [maxBytes, label] of [[500 * 1024 * 1024, "500 MiB"], [100_000_000, "100 MB"]]) {
+    let uploaded = false;
+    const attachments = useAssistantAttachments({ sessionId: "one", maxBytes,
+      uploadAttachment: async () => { uploaded = true; } });
+    try {
+      await attachments.uploadFiles([{ name: "oversized.bin", size: maxBytes + 1 }]);
+      assert.equal(uploaded, false);
+      assert.match(attachments.queueItems.value[0].error, new RegExp(label));
+    } finally {
+      await attachments.disposeAttachments();
+    }
+  }
+});

package/test/conversationRuntime.test.js

@@ -7,6 +7,46 @@ import { createConversationHookBridge, createConversationRuntime } from "../src/
 import { createClaudeConversationTurn } from "../src/server/conversation/claudeTurn.js";
 import { createCodexConversationAdapter } from "../src/server/conversation/providers/codex.js";
 import { createOpenCodeConversationAdapter } from "../src/server/conversation/providers/opencode.js";
+import { readPersistentConversation } from "../src/server/conversation/providers/scoped.js";
+import { createConversationTranscript, createMemoryConversationStorage } from "../src/server/conversation/index.js";
+
+test("scoped reads retain each request's output when an accepted steer interrupts the earlier reply", async () => {
+  const transcript = createConversationTranscript({ storage: createMemoryConversationStorage() });
+  const store = Object.fromEntries(Object.entries(transcript).map(([name, operation]) =>
+    [name, (scope, ...args) => operation(JSON.stringify([scope.sessionId, scope.conversationId]), ...args)]));
+  store.readConversationStream = () => ({ messages: [] });
+  const scope = { sessionId: "session", conversationId: "chat" };
+  await store.writeConversationUserMessage(scope, { messageId: "first", text: "First request" });
+  await store.writeConversationUserMessage(scope, { messageId: "second", text: "Second request" });
+  const record = { conversationId: "chat", providerConversationId: "native", messageId: "second", status: "completed" };
+  const observed = [];
+  const options = {
+    ...scope, record, context: {}, store,
+    operations: { async readConversation(_sessionId, input) {
+      observed.push(input.requestMessageIds);
+      return { status: "completed", messages: [
+        { id: "partial-first", requestMessageId: "first", role: "commentary", text: "FIRST-PARTIAL", complete: true },
+        { id: "answer-second", requestMessageId: "second", role: "assistant", text: "SECOND-OK", complete: true },
+        { id: "late-first", requestMessageId: "first", role: "commentary", text: "FIRST-TAIL", complete: true },
+        { id: "unmatched", requestMessageId: "", role: "assistant", text: "Unmatched native input", complete: true }
+      ] };
+    } },
+    records: { input: (record, input) => ({ ...record, ...input }), save: async (_context, record, patch) => ({ ...record, ...patch }) },
+    receipts: { persisted: () => true },
+    projection: { context: context => context, messageScope: (_context, scope) => scope,
+      message: message => message, messageMetadata: () => ({}), snapshot: value => value },
+    publish: async () => {}
+  };
+  await readPersistentConversation(options);
+  await readPersistentConversation(options);
+  const [first, second] = await store.readConversationLog(scope);
+  assert.deepEqual(first.commentary.map(message => message.text), ["FIRST-PARTIAL", "FIRST-TAIL"]);
+  assert.equal(first.assistant, null);
+  assert.equal(second.assistant.text, "SECOND-OK");
+  assert.deepEqual(second.commentary, []);
+  assert.equal((await store.readConversationLog(scope)).length, 2);
+  assert.deepEqual(observed, [["first", "second"], ["first", "second"]]);
+});
 
 function claudeHost() {
   let process = null;

package/test/conversationStreaming.test.js

@@ -238,3 +238,21 @@ test("completed-envelope completion keeps its captured scalar while resolving on
     messageId: "successor", turnId: "000002", origin: "application", completedEnvelope: true
   } }).completedMessages, undefined);
 });
+
+test("live message metadata retains its captured attribution across deltas without sharing mutable reads", () => {
+  const streams = createConversationStreams();
+  const input = { turnId: "native-turn", messageId: "reply", text: "First", metadata: { model: { id: "original" } } };
+  streams.update("one", input);
+  input.metadata.model.id = "later composer choice";
+  streams.update("one", { ...input, delta: " chunk" });
+  const first = streams.read("one");
+  assert.equal(first.messages[0].metadata.model.id, "original");
+  first.messages[0].metadata.model.id = "read mutation";
+  const next = streams.update("one", { turnId: "native-turn", messageId: "reply", delta: " again" });
+  assert.equal(next.messages[0].metadata.model.id, "original");
+  assert.equal(mergeConversationStream([], next)[0].assistant.metadata.model.id, "original");
+  streams.complete("one", "reply");
+  assert.equal(streams.update("one", { ...input, delta: "late" }), null);
+  const other = streams.update("two", { ...input, metadata: { model: { id: "other" } } });
+  assert.equal(other.messages[0].metadata.model.id, "other");
+});

package/test/messageDelivery.browser.test.js

@@ -134,3 +134,33 @@ test("chronological messages and application Cancel work on phone and desktop",
     }
   } finally { await browser.close(); await stopProcess(vite); }
 });
+
+test("accepted local messages precede later replies before their history page arrives", {
+  skip: process.env.JSKIT_ASSISTANT_CORE_BROWSER_INTEGRATION !== "1", timeout: 90_000
+}, async () => {
+  const vite = await startViteFixture({ fixtureRoot: fileURLToPath(new URL("../fixtures/responsive-assistant", import.meta.url)) });
+  const browser = await chromium.launch(createChromiumLaunchOptions());
+  try {
+    for (const width of [390, 1365]) {
+      const page = await browser.newPage({ viewport: { width, height: 900 } });
+      const errors = [];
+      page.on("pageerror", error => errors.push(error.message));
+      await page.goto(`${vite.baseURL}/?delivery=1&accepted-history=1`);
+      const rows = page.locator(".assistant-transcript__turn");
+      const checkOrder = async () => {
+        await expect(rows).toHaveCount(3);
+        for (const [index, text] of ["Earlier accepted message", "Later assistant reply", "Still queued"].entries()) {
+          await expect(rows.nth(index)).toContainText(text);
+        }
+        await expect(page.getByText("Pending", { exact: true })).toHaveCount(1);
+      };
+      await checkOrder();
+      await page.getByRole("button", { name: "Load accepted history", exact: true }).click();
+      await checkOrder();
+      await expect(page.getByText("Earlier accepted message", { exact: true })).toHaveCount(1);
+      await page.screenshot({ path: `/tmp/sas35-accepted-order-${width}.png` });
+      assert.deepEqual(errors, []);
+      await page.close();
+    }
+  } finally { await browser.close(); await stopProcess(vite); }
+});