@jskit-ai/assistant-core 0.1.213 → 0.1.214

package/test/codexHistoryAdapter.test.js

@@ -1,12 +1,13 @@
 import assert from "node:assert/strict";
 import { randomUUID } from "node:crypto";
-import { appendFile, mkdir, mkdtemp, readFile, rm, stat, symlink, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, mkdtemp, open, readFile, rm, stat, symlink, writeFile } from "node:fs/promises";
 import { request } from "node:http";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
 import { gzipSync, zstdCompressSync } from "node:zlib";
 import { startCodexHistoryAdapter, translateCodexHistory, prepareCodexHistory } from "../src/server/conversation/codexHistoryAdapter.js";
+import { readCodexHistoryRows, readCodexNativeGoal } from "../src/server/hosts/codexProvider.js";
 import { nativeAiProvider } from "../src/shared/nativeProviders.js";
 
 const foreign = { type: "reasoning", id: "foreign-id", encrypted_content: "foreign-opaque-state",
@@ -748,3 +749,75 @@ test("DeepSeek exact numeric context rejection exposes native recovery code with
   }
   assert.equal(attempts, cases.length + 2, "exactly one upstream admission per request");
 });
+
+test("the original fixed-snapshot rollout reader keeps tolerant recovery and supports strict offline inspection", async t => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "jskit-offline-rollout-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const history = path.join(root, "rollout.jsonl");
+  const row = { type: "response_item", payload: { type: "message", role: "assistant",
+    content: [{ type: "output_text", text: "😀".repeat(20_000) }] } };
+  const complete = Buffer.from(`${JSON.stringify(row)}\n`);
+  await writeFile(history, complete);
+  const file = await open(history, "r");
+  t.after(() => file.close());
+  const read = async (end, options, signal = new AbortController().signal) => {
+    const rows = [];
+    for await (const entry of readCodexHistoryRows(file, 0, end, signal, options)) rows.push(entry);
+    return rows;
+  };
+  assert.deepEqual(await read(complete.length, { strictComplete: true }), [{ row, offset: 0 }]);
+  await appendFile(history, '{"type":');
+  assert.deepEqual(await read(complete.length, { strictComplete: true }), [{ row, offset: 0 }],
+    "inspection reads only the captured snapshot, not later appends");
+  assert.deepEqual(await read((await file.stat()).size), [{ row, offset: 0 }],
+    "original compaction recovery still ignores an unfinished native append");
+  await assert.rejects(read((await file.stat()).size, { strictComplete: true }), /incomplete final record/);
+  await writeFile(history, Buffer.from('{"text":"\xff"}\n', "latin1"));
+  await assert.rejects(read((await file.stat()).size, { strictComplete: true }), /invalid UTF-8/);
+  await writeFile(history, 'malformed saved record\n');
+  await assert.rejects(read((await file.stat()).size, { strictComplete: true }), SyntaxError);
+  const aborted = AbortSignal.abort(new Error("offline inspection cancelled"));
+  await assert.rejects(read((await file.stat()).size, { strictComplete: true }, aborted), /offline inspection cancelled/);
+  const { DatabaseSync } = await import("node:sqlite");
+  const goals = path.join(root, "goals_1.sqlite");
+  const threadId = randomUUID(), goalId = randomUUID();
+  const db = new DatabaseSync(goals);
+  db.exec(`CREATE TABLE thread_goals (thread_id TEXT PRIMARY KEY, goal_id TEXT NOT NULL,
+    objective TEXT NOT NULL, status TEXT NOT NULL, token_budget INTEGER,
+    tokens_used INTEGER NOT NULL, time_used_seconds INTEGER NOT NULL,
+    created_at_ms INTEGER NOT NULL, updated_at_ms INTEGER NOT NULL)`);
+  db.close();
+  assert.equal(await readCodexNativeGoal(goals, { threadId }), null);
+  for (const status of ["active", "paused", "blocked", "usage_limited", "budget_limited", "complete"]) {
+    const db = new DatabaseSync(goals);
+    try { db.prepare(`INSERT OR REPLACE INTO thread_goals VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+      .run(threadId, goalId, "Original native objective", status, 500, 30, 2, 1000, 2000); }
+    finally { db.close(); }
+    const before = await readFile(goals);
+    const goal = await readCodexNativeGoal(goals, { threadId });
+    assert.equal(goal.thread_id, threadId);
+    assert.equal(goal.goal_id, goalId);
+    assert.equal(goal.status, status, "unfinished goals are retained, never projected as absent");
+    assert.equal(goal.objective, "Original native objective");
+    assert.equal(goal.token_budget, 500);
+    assert.equal(goal.tokens_used, 30);
+    assert.equal(goal.time_used_seconds, 2);
+    assert.equal(goal.created_at_ms, 1000);
+    assert.equal(goal.updated_at_ms, 2000);
+    assert.deepEqual(await readFile(goals), before, "offline goal inspection never writes native storage");
+  }
+  const invalid = new DatabaseSync(goals);
+  try { invalid.prepare("UPDATE thread_goals SET status = ?").run("unsupported"); }
+  finally { invalid.close(); }
+  await assert.rejects(readCodexNativeGoal(goals, { threadId }), /unsupported or ambiguous/);
+  const unknownSchema = new DatabaseSync(goals);
+  try { unknownSchema.exec("DROP TABLE thread_goals; CREATE TABLE thread_goals (thread_id TEXT)"); }
+  finally { unknownSchema.close(); }
+  await assert.rejects(readCodexNativeGoal(goals, { threadId }), /schema is unsupported/);
+  await writeFile(`${goals}-wal`, "An original owner still has a journal.");
+  await assert.rejects(readCodexNativeGoal(goals, { threadId }), /journal sidecar/);
+  await rm(`${goals}-wal`);
+  await rm(goals);
+  await assert.rejects(readCodexNativeGoal(goals, { threadId }), { code: "ENOENT" });
+
+});

package/test/codexTurn.test.js

@@ -1,3 +1,4 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import assert from "node:assert/strict";
 import { mkdtemp, readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -538,6 +539,54 @@ test("native notification draining follows same-scope successors while another s
   assert.equal(owner.tasks.size, 0);
 });
 
+test("captured native notification drain retains exact scope after admission expiry", { timeout: 3_000 }, async () => {
+  const scopes = new AsyncLocalStorage();
+  const expiry = Object.assign(new Error("The original admission expired"), { code: "scope_expired" });
+  const namespace = id => {
+    const scope = scopes.getStore();
+    if (!scope?.active) throw expiry;
+    return `${scope.project}:${id}`;
+  };
+  const owner = createCodexAppServerNotificationQueue({ namespace,
+    runInContext: (context, operation) => scopes.run(context, operation) });
+  const alpha = { project: "alpha", active: true, access: "write" };
+  const beta = { project: "beta", active: true, access: "write" };
+  const entered = Promise.withResolvers(), release = Promise.withResolvers();
+  const betaEntered = Promise.withResolvers(), betaRelease = Promise.withResolvers();
+  const output = [];
+  let drainAlpha;
+  scopes.run(alpha, () => {
+    drainAlpha = owner.captureDrain("shared-session");
+    const context = { sessionId: "shared-session", projectContext: { ...alpha, access: "control" } };
+    owner.run(context, async () => {
+      entered.resolve();
+      await release.promise;
+      assert.equal(scopes.getStore().access, "control", "waiting retains no write admission");
+      output.push("alpha");
+      owner.run(context, () => { output.push("alpha-successor"); });
+    });
+  });
+  scopes.run(beta, () => owner.run({ sessionId: "shared-session", projectContext: { ...beta, access: "control" } },
+    async () => { betaEntered.resolve(); await betaRelease.promise; output.push("beta"); }));
+  await Promise.all([entered.promise, betaEntered.promise]);
+  alpha.active = false;
+  try {
+    await scopes.run(alpha, () => assert.rejects(owner.drain("shared-session"), error => error === expiry));
+    scopes.run(alpha, () => assert.throws(() => owner.captureDrain("shared-session"), error => error === expiry));
+    const draining = scopes.run(alpha, () => drainAlpha());
+    release.resolve();
+    await draining;
+    assert.deepEqual(output, ["alpha", "alpha-successor"], "captured alpha follows its successor without waiting for beta");
+    assert.equal(owner.tasks.has("alpha:shared-session"), false);
+    assert.equal(owner.tasks.has("beta:shared-session"), true, "equal session IDs retain independent scope ownership");
+  } finally {
+    release.resolve(); betaRelease.resolve();
+    await scopes.run(beta, () => owner.drain("shared-session"));
+  }
+  assert.deepEqual(output, ["alpha", "alpha-successor", "beta"]);
+  assert.equal(owner.tasks.size, 0);
+});
+
 test("closing prevents new native notification batches while previously admitted queue work drains", async () => {
   let closing = false;
   const owner = createCodexAppServerNotificationQueue({ isClosing: () => closing });
@@ -558,7 +607,7 @@ test("closing prevents new native notification batches while previously admitted
 // Native output assertions are carried from the original public lifecycle cases.
 // The existing shared transcript/stream implementations replace only the public
 // filesystem fixture; public tests retain subscription, Stop and restart coverage.
-async function outputFixture() {
+async function outputFixture({ persistCommentary } = {}) {
   const sessionId = "session-1";
   const threadId = "thread-1";
   const turnId = "turn-1";
@@ -610,6 +659,7 @@ async function outputFixture() {
   f.store = store;
   f.provider = provider;
   f.createOwner = () => createCodexAppServerRunOwner({
+    persistCommentary,
     createRuntime: async () => { f.hydrations += 1; return runtime; },
     createStore: async id => { assert.equal(id, sessionId); return store; },
     async acquireProvider(input) {
@@ -2899,3 +2949,234 @@ test("native changeover retries retain original application data including its a
     assert.deepEqual(sent.data, data);
   }
 });
+
+test("initial native seed limits preserve generic history, full returning corrections and delivery ownership", async () => {
+  const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
+  const attachment = { attachmentId: "retained-file", name: "retained.txt" };
+  const messages = Array.from({ length: 31 }, (_, index) => ({
+    id: `stored-${index}`, messageId: `authored-${index}`, role: index % 2 ? "assistant" : "user",
+    text: `${index}:` + "x".repeat(2_100), version: `version-${index}`, engineId: "claude",
+    ...(index === 30 ? { attachments: [attachment] } : {})
+  }));
+  const original = structuredClone(messages);
+  const words = "My current words remain complete: " + "y".repeat(2_100);
+  const input = { messageId: "current-input", message: words, displayAttachments: [attachment], data: { reference: "current" } };
+  for (const scenario of ["generic", "one-current", "two-current", "wake", "empty", "returning"]) {
+    const allowance = scenario === "two-current" ? 22 : scenario === "wake" ? 24 : scenario === "empty" ? 0 : 23;
+    let value = { lastEngine: "claude", engines: { codex: { seen: scenario === "returning"
+      ? { "stored-0": "old-version", removed: "removed-version" } : {} } } };
+    let sent;
+    const changeover = createConversationChangeover({
+      state: { async read() { return value; }, async write(next) { value = next; } },
+      transcript: { async hasMessage() { return false; } },
+      agent: { async sendMessage(actual) { sent = actual; return { ok: true, delivered: true }; } },
+      captureContext: true,
+      ...(scenario !== "generic" ? { maximumInitialMessages: allowance, maximumInitialMessageCharacters: 2_000 } : {})
+    });
+    assert.equal((await changeover.send({ engineId: "codex", messages, input })).delivered, true);
+    const carried = sent.contextText.split("\n").filter(line => line.startsWith("{")).map(JSON.parse)[0];
+    const selected = scenario === "returning" ? messages : scenario === "empty" ? []
+      : messages.slice(scenario === "generic" ? -30 : -allowance);
+    assert.deepEqual(carried.messages.map(message => [message.id, message.text]), selected.map(message => [message.id,
+      scenario !== "generic" && scenario !== "returning" ? message.text.slice(0, 2_000) : message.text]));
+    assert.equal(carried.messages.some(message => message.messageId === input.messageId), false);
+    if (scenario !== "empty") assert.deepEqual(carried.messages.at(-1).attachments, [attachment]);
+    assert.deepEqual(sent.contextAttachments, scenario === "empty" ? [] : [attachment]);
+    assert.deepEqual(sent.displayAttachments, input.displayAttachments);
+    assert.deepEqual(sent.data, input.data);
+    assert.ok(sent.message.endsWith(words));
+    assert.deepEqual(carried.removedMessageIds, scenario === "returning" ? ["removed"] : []);
+    if (scenario === "returning") assert.equal(carried.messages[0].corrected, true);
+    assert.deepEqual(value.engines.codex.seen, Object.fromEntries(messages.map(message => [message.id, message.version])));
+    assert.equal(value.engines.codex.pending, undefined);
+    assert.equal(value.lastEngine, "codex");
+    assert.deepEqual(messages, original, "clipping a fresh seed must not edit stored history or its fingerprints");
+  }
+});
+
+test("initial native seed options refuse invalid limits before delivery", async () => {
+  const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
+  for (const name of ["maximumInitialMessages", "maximumInitialMessageCharacters"]) {
+    for (const value of [...(name === "maximumInitialMessageCharacters" ? [0] : []), -1, 1.5, "24", NaN]) {
+      assert.throws(() => createConversationChangeover({ [name]: value }), /non-negative message limit and a positive text limit/);
+    }
+  }
+});
+
+// Original Colleague first-progress test261 requires transient intent even
+// while the application effect waits. Other consumers keep default persistence.
+test("original output owner can publish transient commentary without losing native deduplication", async () => {
+  const f = await outputFixture({ persistCommentary: false });
+  const { owner, sessionId, threadId, turnId, store } = f;
+  const progress = "Checking the source.";
+  await owner.writeStream(sessionId, { threadId, turnId, itemId: "transient-progress", role: "commentary", delta: progress });
+  const complete = itemId => owner.writeLiveProgress(sessionId, threadId, { method: "item/completed", params: {
+    threadId, turnId, item: outputItem(itemId, progress, "commentary")
+  } });
+  await complete("transient-progress");
+  assert.deepEqual((await store.readConversationLog(sessionId)).flatMap(row => row.commentary || []), []);
+  assert.deepEqual(store.readConversationStream(sessionId).messages, []);
+  assert.equal(f.publications.at(-1).reason, "codex-app-server-commentary");
+  assert.ok(f.publications.at(-1).payload.conversationStream);
+  assert.equal(f.publications.at(-1).payload.conversationLogPatch, undefined);
+  assert.equal(owner.liveProgressItems.size, 1);
+  assert.equal(owner.liveProgressFingerprints.size, 1);
+  await complete("transient-progress");
+  await complete("same-progress-another-item");
+  assert.equal(owner.liveProgressItems.size, 1, "repeated completed item and matching text do not lose their native deduplication");
+  assert.equal(owner.liveProgressFingerprints.size, 1);
+  assert.deepEqual((await store.readConversationLog(sessionId)).flatMap(row => row.commentary || []), []);
+  f.history = [{ id: turnId, status: "completed", items: [
+    outputItem("transient-progress", progress, "commentary"), outputItem("final-answer", "Checked.")
+  ] }];
+  await f.final("final-answer", "Checked.");
+  assert.deepEqual((await f.replies()).map(row => row.assistant.text), ["Checked."]);
+  assert.deepEqual((await store.readConversationLog(sessionId)).flatMap(row => row.commentary || []), []);
+  assert.equal(f.history[0].items[0].text, progress, "canonical policy does not change native history");
+});
+
+test("completed envelope carriers stay raw while native history versions and API briefings use product rows", async () => {
+  const { conversationNativeMessages, conversationHistoryVersions, conversationContinuity } = await import("../src/server/conversation/continuity.js");
+  const storage = createMemoryConversationStorage();
+  const transcript = createConversationTranscript({ storage });
+  await storage.write("projection", async tx => {
+    await tx.appendMessage("000001", { role: "user", messageId: "actual-user", text: "My visible words", at: "2026-10-10" });
+    await tx.appendMessage("000001", { role: "assistant", messageId: "actual-reply", text: "My plain answer", at: "2026-10-10" });
+    await tx.appendMessage("000002", { role: "system", messageId: "internal-native-input", text: "Private generated prompt", at: "2026-10-10",
+      turnMetadata: { runtime: { engine: "codex", origin: "application", completedEnvelope: true, status: "complete" },
+        applicationTools: [{ id: "internal-native-input:operation", status: "unknown" }] } });
+    await tx.appendMessage("000002", { role: "assistant", messageId: "internal-final", text: '{"kind":"tool","arguments":"private"}', at: "2026-10-10" });
+    await tx.appendMessage("000003", { role: "user", messageId: "authored-json", text: '{"completedEnvelope":true}',
+      data: { completedEnvelope: true }, at: "2026-10-10" });
+  });
+  const raw = await transcript.readConversationLog("projection");
+  const before = structuredClone(raw);
+  assert.deepEqual(conversationNativeMessages(raw).map(row => row.messageId), ["actual-user", "actual-reply", "authored-json"]);
+  assert.deepEqual(Object.keys(conversationHistoryVersions(raw)), ["000001/user/", "000001/assistant/", "000003/user/"]);
+  const briefing = conversationContinuity({ history: raw }).text;
+  assert.match(briefing, /My visible words/);
+  assert.match(briefing, /My plain answer/);
+  assert.equal(briefing.includes("Private generated prompt"), false);
+  assert.equal(briefing.includes("internal-final"), false);
+  assert.deepEqual(raw, before);
+  assert.deepEqual(await transcript.readConversationLog("projection"), before, "Private native carriers and durable outcome custody are never rewritten");
+});
+
+test("completed envelope native seed slices the original 24 rows before excluding the current batch and commits seen only after admission", async () => {
+  const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
+  const messages = Array.from({ length: 30 }, (_, index) => ({ id: `stored-${index}`, messageId: `authored-${index}`,
+    role: "user", text: `${index}:` + "x".repeat(2100), version: `version-${index}`, engineId: "claude" }));
+  const before = structuredClone(messages);
+  let value = { lastEngine: "", engines: { codex: { seen: {} } } };
+  const entered = Promise.withResolvers();
+  const admitted = Promise.withResolvers();
+  const sent = [];
+  const changeover = createConversationChangeover({
+    state: { async read() { return value; }, async write(next) { value = next; } },
+    transcript: { async hasMessage() { return false; } }, captureContext: true,
+    maximumInitialMessages: 24, maximumInitialMessageCharacters: 2000,
+    agent: { async sendMessage(input) {
+      sent.push(input);
+      if (sent.length === 1) {
+        await input.onPromptSending({ threadId: "same-native-thread" });
+        entered.resolve();
+        await admitted.promise;
+      }
+      return { ok: true, delivered: true };
+    } }
+  });
+  const sending = changeover.send({ engineId: "codex", messages, completedEnvelope: true,
+    excludedMessageIds: ["authored-28", "authored-29"],
+    input: { messageId: "internal-1", message: JSON.stringify({ userMessages: ["authored-28", "authored-29"] }) } });
+  await entered.promise;
+  const carried = sent[0].contextText.split("\n").filter(line => line.startsWith("{")).map(JSON.parse)[0];
+  assert.deepEqual(carried.messages.map(row => row.messageId), messages.slice(-24).slice(0, -2).map(row => row.messageId));
+  assert.equal(carried.messages.length, 22, "The original 24-row window is not expanded to 24 older rows plus the batch");
+  assert.equal(carried.messages[0].text.length, 2000);
+  assert.equal(sent[0].message.split("authored-28").length - 1, 1);
+  assert.equal(sent[0].message.split("authored-29").length - 1, 1);
+  assert.deepEqual(value.engines.codex.seen, {}, "Prepared history does not claim delivery before the actual native ACK");
+  const snapshot = Object.fromEntries(messages.map(row => [row.id, row.version]));
+  assert.deepEqual(value.engines.codex.pending.seen, snapshot);
+  admitted.resolve();
+  assert.equal((await sending).delivered, true);
+  assert.deepEqual(value.engines.codex.seen, snapshot, "The genuinely admitted internal prompt consumed the product batch history");
+  await changeover.send({ engineId: "codex", messages, input: { messageId: "internal-2", message: "Continue from the saved operation result" } });
+  assert.equal(sent[1].contextText, undefined, "The next native response does not replay the already included B/C batch as catch-up");
+  assert.equal(sent[1].message, "Continue from the saved operation result");
+  assert.deepEqual(sent.map(input => input.messageId), ["internal-1", "internal-2"], "Only real internal inputs have native receipts");
+  assert.deepEqual(messages, before);
+});
+
+test("completed envelope native retries preserve the exact prepared history snapshot without recapture", async () => {
+  const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
+  let value = { lastEngine: "", engines: { codex: { seen: {} } } };
+  let accepted = false;
+  let dispatches = 0;
+  const original = [{ id: "row-B", messageId: "authored-B", role: "user", text: "Original B", version: "original-B" }];
+  const changeover = createConversationChangeover({
+    state: { async read() { return value; }, async write(next) { value = next; } },
+    captureContext: true, maximumInitialMessages: 24, maximumInitialMessageCharacters: 2000,
+    transcript: { async hasMessage() { return false; }, async writeUserMessage() {} },
+    agent: { async sendMessage(input) { dispatches++; await input.onPromptSending({ threadId: "exact-thread" }); return { ok: false, delivered: false }; },
+      async inspectMessageAdmission() { return { admission: accepted ? "accepted" : "unknown", threadId: "exact-thread" }; } }
+  });
+  const input = { messageId: "internal-retry", message: "Generated original B prompt" };
+  await changeover.send({ engineId: "codex", messages: original, input, completedEnvelope: true, excludedMessageIds: ["authored-B"] });
+  const pending = structuredClone(value.engines.codex.pending);
+  const updated = [{ ...original[0], text: "Changed B", version: "changed-B" }];
+  const unknown = await changeover.send({ engineId: "codex", messages: updated, input,
+    completedEnvelope: true, excludedMessageIds: ["different-new-batch"] });
+  assert.equal(unknown.delivered, false);
+  assert.deepEqual(value.engines.codex.pending, pending);
+  assert.deepEqual(value.engines.codex.seen, {});
+  accepted = true;
+  assert.equal((await changeover.send({ engineId: "codex", messages: updated, input,
+    completedEnvelope: true, excludedMessageIds: [] })).delivered, true);
+  assert.deepEqual(value.engines.codex.seen, pending.seen);
+  assert.equal(value.engines.codex.pending, undefined);
+  assert.equal(dispatches, 1, "Inspecting the same native input never resubmits or substitutes its batch/history snapshot");
+});
+
+test("completed envelope history exclusions require explicit tracked input and exact nonduplicate authored IDs", async () => {
+  const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
+  let reads = 0;
+  let sent;
+  const messages = [{ id: "row-B", messageId: "authored-B", role: "user", text: "Visible B", version: "version-B" }];
+  const changeover = createConversationChangeover({
+    state: { async read() { reads++; return { lastEngine: "", engines: { codex: { seen: {} } } }; }, async write() {} },
+    captureContext: true,
+    transcript: { async hasMessage() { return false; } },
+    agent: { async sendMessage(input) { sent = input; return { ok: true, delivered: true }; } }
+  });
+  const input = { messageId: "internal-input", message: "Current generated prompt", data: { completedEnvelope: true, excludedMessageIds: ["authored-B"] } };
+  for (const excludedMessageIds of [["authored-B", "authored-B"], [""], ["  "], ["x".repeat(129)], [1], "authored-B"]) {
+    await assert.rejects(changeover.send({ engineId: "codex", messages, input, completedEnvelope: true, excludedMessageIds }), /tracked completed envelope and exact message IDs/);
+  }
+  await assert.rejects(changeover.send({ engineId: "codex", messages, input, excludedMessageIds: ["authored-B"] }), /tracked completed envelope/);
+  assert.equal(reads, 0, "Invalid exclusions cannot enter existing state or delivery owners");
+  await changeover.send({ engineId: "codex", messages, input });
+  const carried = sent.contextText.split("\n").filter(line => line.startsWith("{")).map(JSON.parse)[0];
+  assert.deepEqual(carried.messages.map(row => row.messageId), ["authored-B"], "Caller data is never a history-exclusion grant");
+  assert.deepEqual(sent.data, input.data);
+});
+
+test("completed envelope returning corrections remain full while the current batch is excluded only from rendering", async () => {
+  const { createConversationChangeover } = await import("../src/server/conversation/continuity.js");
+  const messages = [{ id: "old-row", messageId: "old-authored", role: "user", text: "Edited " + "x".repeat(2100), version: "edited" },
+    { id: "current-row", messageId: "current-authored", role: "user", text: "Current B", version: "current" }];
+  let value = { lastEngine: "codex", engines: { codex: { seen: { "old-row": "before-edit", removed: "removed-version" } } } };
+  let sent;
+  const changeover = createConversationChangeover({
+    state: { async read() { return value; }, async write(next) { value = next; } },
+    maximumInitialMessages: 24, maximumInitialMessageCharacters: 2000, captureContext: true,
+    transcript: { async hasMessage() { return false; } },
+    agent: { async sendMessage(input) { sent = input; return { ok: true, delivered: true }; } }
+  });
+  await changeover.send({ engineId: "codex", messages, input: { messageId: "internal-correction", message: "Current B prompt" },
+    completedEnvelope: true, excludedMessageIds: ["current-authored"] });
+  const carried = sent.contextText.split("\n").filter(line => line.startsWith("{")).map(JSON.parse)[0];
+  assert.deepEqual(carried.messages.map(row => [row.messageId, row.text, row.corrected]), [["old-authored", messages[0].text, true]]);
+  assert.deepEqual(carried.removedMessageIds, ["removed"]);
+  assert.deepEqual(value.engines.codex.seen, { "old-row": "edited", "current-row": "current" });
+});

package/test/conversation.test.js

@@ -165,3 +165,86 @@ test("application transcript opt-in opens only authored application system turns
     assert.equal((await transcript.writeConversationAssistantMessage("one", { text: "Answer" })).turnId, authored.turnId);
   }
 });
+
+async function completedEnvelopeTranscriptRows(storage) {
+  await storage.write("projected", async transaction => {
+    for (let index = 1; index <= 9; index++) {
+      const internal = index % 3 !== 1;
+      const turnId = String(index).padStart(6, "0");
+      await transaction.appendMessage(turnId, { role: internal ? "system" : "user", messageId: `authored-${index}`,
+        text: internal ? `Private prompt ${index}` : `Visible question ${index}`, at: "2026-10-10",
+        ...(internal ? { origin: "application" } : { attachments: [{ attachmentId: "retained" }] }),
+        turnMetadata: { runtime: { origin: internal ? "application" : "user", status: "complete",
+          ...(internal ? { completedEnvelope: true } : {}) } } });
+      await transaction.appendMessage(turnId, { role: "assistant", messageId: `answer-${index}`,
+        text: internal ? '{"kind":"reply","text":"private raw carrier"}' : `Visible answer ${index}`, at: "2026-10-10" });
+      if (internal) await transaction.updateTurnMetadata(turnId, { applicationTools: [{ id: `effect-${index}`, status: "unknown" }] });
+      else await transaction.appendMessage(turnId, { role: "commentary", messageId: `progress-${index}`, text: "Checking.", at: "2026-10-10" });
+    }
+  });
+}
+
+test("completed envelope presentation reads retain raw canonical receipts and visible message identity", async () => {
+  const storage = createMemoryConversationStorage();
+  const transcript = createConversationTranscript({ storage });
+  await completedEnvelopeTranscriptRows(storage);
+  const before = await transcript.readConversationLog("projected");
+  const visible = await transcript.readConversationLog("projected", { presentation: true });
+  assert.deepEqual(visible.map(turn => turn.turnId), ["000001", "000004", "000007"]);
+  assert.deepEqual(visible, before.filter((_, index) => index % 3 === 0));
+  assert.deepEqual(visible[0].user.attachments, [{ attachmentId: "retained" }]);
+  assert.equal(visible[0].commentary[0].messageId, "progress-1");
+  assert.equal(visible[0].assistant.messageId, "answer-1");
+  const reopened = createConversationTranscript({ storage });
+  assert.deepEqual(await reopened.readConversationLog("projected", { presentation: true }), visible);
+  assert.deepEqual(await transcript.readConversationLog("projected"), before, "Presentation never changes stored carriers or unknown effect receipts");
+  assert.equal(await transcript.conversationMessageIdExists("projected", "authored-2"), true);
+  assert.deepEqual(before[1].metadata.applicationTools, [{ id: "effect-2", status: "unknown" }]);
+});
+
+test("completed envelope presentation pagination counts visible turns before selecting a page", async () => {
+  const storage = createMemoryConversationStorage();
+  const transcript = createConversationTranscript({ storage });
+  await completedEnvelopeTranscriptRows(storage);
+  const newest = await transcript.readConversationLogPage("projected", { limit: 2, presentation: true });
+  assert.deepEqual(newest.conversationLog.map(turn => turn.turnId), ["000004", "000007"]);
+  assert.deepEqual(newest.pagination, { beforeTurnId: "", count: 2, hasMoreBefore: true, limit: 2,
+    newestTurnId: "000007", nextBeforeTurnId: "000004", oldestTurnId: "000004", totalTurnCount: 3 });
+  const older = await transcript.readConversationLogPage("projected", {
+    beforeTurnId: newest.pagination.nextBeforeTurnId, limit: 2, presentation: true
+  });
+  assert.deepEqual(older.conversationLog.map(turn => turn.turnId), ["000001"]);
+  assert.deepEqual(older.pagination, { beforeTurnId: "000004", count: 1, hasMoreBefore: false, limit: 2,
+    newestTurnId: "000001", nextBeforeTurnId: "", oldestTurnId: "000001", totalTurnCount: 3 });
+  const raw = await transcript.readConversationLogPage("projected", { limit: 2 });
+  assert.deepEqual(raw.conversationLog.map(turn => turn.turnId), ["000008", "000009"]);
+  assert.equal(raw.pagination.totalTurnCount, 9);
+});
+
+test("completed envelope presentation requires the trusted application marker rather than data or reply content", async () => {
+  const storage = createMemoryConversationStorage();
+  const transcript = createConversationTranscript({ storage });
+  await storage.write("markers", async transaction => {
+    for (const [index, runtime] of [undefined, { origin: "application" }, { origin: "user", completedEnvelope: true },
+      { origin: "application", completedEnvelope: "true" }, { origin: "application", completedEnvelope: true }].entries()) {
+      await transaction.appendMessage(String(index), { role: "user", messageId: `identity-${index}`, text: '{"kind":"reply","text":"plain authored JSON"}',
+        data: { completedEnvelope: true }, at: "2026-10-10", ...(runtime ? { turnMetadata: { runtime } } : {}) });
+    }
+  });
+  assert.deepEqual((await transcript.readConversationLog("markers", { presentation: true })).map(turn => turn.turnId), ["0", "1", "2", "3"]);
+  assert.equal((await transcript.readConversationLog("markers")).length, 5);
+  await assert.rejects(transcript.readConversationLog("markers", { presentation: "true" }), /explicit boolean/);
+  await assert.rejects(transcript.readConversationLogPage("markers", { presentation: 1 }), /explicit boolean/);
+});
+
+test("completed envelope presentation has an honest empty page when all canonical turns are internal", async () => {
+  const storage = createMemoryConversationStorage();
+  const transcript = createConversationTranscript({ storage });
+  await storage.write("empty", tx => tx.appendMessage("000001", { role: "system", text: "Private response input", at: "2026-10-10",
+    turnMetadata: { runtime: { origin: "application", completedEnvelope: true } } }));
+  const page = await transcript.readConversationLogPage("empty", { presentation: true, limit: 50 });
+  assert.deepEqual(page.conversationLog, []);
+  assert.deepEqual(page.pagination, { beforeTurnId: "", count: 0, hasMoreBefore: false, limit: 50,
+    newestTurnId: "", nextBeforeTurnId: "", oldestTurnId: "", totalTurnCount: 0 });
+  assert.equal((await transcript.readConversationLog("empty")).length, 1);
+});