@jskit-ai/assistant-core 0.1.200 → 0.1.202

package/test/fixtures/codexHelperThreadLedger.js

@@ -0,0 +1,39 @@
+import {
+  CODEX_HELPER_THREAD_LEDGER_SCHEMA_VERSION,
+  CODEX_HELPER_THREAD_LIFECYCLES,
+  createCodexHelperThreadLedgerOwner
+} from "../../src/server/conversation/codexHelperThreadLedger.js";
+
+// This is the original test's resolved profile data, not application policy.
+// Public keeps and tests its original strict codec against its own catalogue.
+function helperProfile() {
+  return {
+    limits: { maxInputCharacters: 100_000, maxOutputCharacters: 32_000, timeoutMs: 180_000 },
+    model: "gpt-5.6-luna",
+    policy: { environmentAccess: false, networkAccess: false, repositoryWrite: false, tools: "none" },
+    profileId: "helper",
+    providerId: "codex",
+    request: { allowProviderModelFallback: false, reasoning: true, summary: false },
+    revision: "codex-helper-luna-low-v2",
+    thinking: "low",
+    workloadId: "source_explanation"
+  };
+}
+
+const {
+  codexHelperThreadRecordId,
+  createCodexHelperThreadLedger,
+  defineCodexHelperThreadRecord
+} = createCodexHelperThreadLedgerOwner({
+  executionProfile: value => structuredClone(value),
+  errorPrefix: "vibe64_codex_helper_"
+});
+
+export {
+  CODEX_HELPER_THREAD_LEDGER_SCHEMA_VERSION,
+  CODEX_HELPER_THREAD_LIFECYCLES,
+  codexHelperThreadRecordId,
+  createCodexHelperThreadLedger,
+  defineCodexHelperThreadRecord,
+  helperProfile
+};

package/test/localConversationExecution.test.js

@@ -0,0 +1,90 @@
+import assert from "node:assert/strict";
+import { once } from "node:events";
+import { test } from "node:test";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createLocalConversationExecution } from "../src/server/conversation/localExecution.js";
+
+const options = { skip: process.platform === "win32" };
+function host(t) {
+  const execution = createLocalConversationExecution();
+  t.after(() => execution.close());
+  return execution;
+}
+const spec = (code) => ({ command: process.execPath, args: ["-e", code], cwd: process.cwd(), stream: true });
+
+test("the supplied execution host carries native protocol bytes and proves owned cleanup", options, async (t) => {
+  const execution = host(t);
+  const child = await execution.start(spec('process.stdin.on("data", data => process.stdout.write(data));'));
+  const response = once(child.stdout, "data");
+  child.stdin.write("protocol bytes\n");
+  assert.equal(String((await response)[0]), "protocol bytes\n");
+  assert.equal(child.running, true);
+  assert.deepEqual(await execution.stop(child.id), { scopeEmpty: true });
+  assert.equal(child.running, false);
+  await child.exited;
+});
+
+test("stopping one owned execution cannot stop another and rejects unknown ownership", options, async (t) => {
+  const execution = host(t);
+  const first = await execution.start(spec('setInterval(() => {}, 1000);'));
+  const second = await execution.start(spec('setInterval(() => {}, 1000);'));
+  await assert.rejects(execution.stop("another-host"), /does not own/);
+  await execution.stop(first.id);
+  assert.equal(second.running, true);
+  await execution.close();
+  assert.equal(second.running, false);
+  await assert.rejects(execution.start(spec("")), /closed/);
+});
+
+test("native startup failures retain their cause and unsupported limits are explicit", options, async (t) => {
+  const execution = host(t);
+  await assert.rejects(execution.start({ ...spec(""), command: "/does-not-exist/jskit-native" }),
+    (error) => error.cause?.code === "ENOENT" && /Check the executable/.test(error.message));
+  await assert.rejects(execution.start({ ...spec(""), limits: { memoryBytes: 1024 } }), /cannot enforce resource limits/);
+});
+
+test("shutdown racing with startup releases the child instead of handing out a live process", options, async (t) => {
+  const execution = host(t);
+  const starting = execution.start(spec('setInterval(() => {}, 1000);'));
+  const rejected = assert.rejects(starting, /closed during startup/);
+  await execution.close();
+  await rejected;
+});
+
+test("native command requests use the same execution owner and retain bounded capture and detached logs", options, async (t) => {
+  const execution = host(t);
+  const directory = await mkdtemp(join(tmpdir(), "jskit-execution-log-"));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const captured = await execution.run({ command: process.execPath,
+    args: ["-e", 'process.stdout.write("x".repeat(70000)); process.stderr.write("finished");'],
+    cwd: directory, mode: "capture" });
+  assert.equal(captured.ok, true);
+  assert.equal(Buffer.byteLength(captured.output), 64 * 1024);
+  assert.ok(captured.output.endsWith("finished"));
+  const logPath = join(directory, "detached.log");
+  const child = await execution.run({ command: process.execPath,
+    args: ["-e", 'process.stderr.write("ready"); setInterval(() => {}, 1000);'],
+    cwd: directory, mode: "detached", logPath });
+  assert.equal(child.ok, true);
+  assert.ok(Number.isSafeInteger(child.pid) && child.pid > 0);
+  const deadline = Date.now() + 3000;
+  while (!(await readFile(logPath, "utf8")).includes("ready") && Date.now() < deadline) {
+    await new Promise(resolve => setTimeout(resolve, 10));
+  }
+  assert.equal(await readFile(logPath, "utf8"), "ready");
+  assert.deepEqual(await execution.stop(child.execution.id), { scopeEmpty: true });
+  assert.deepEqual(await execution.stop(child.execution.id, { allowMissingRecordScopeRecovery: true }),
+    { ok: false, scopeEmpty: false });
+});
+
+test("native capture timeout drains its execution before returning", options, async (t) => {
+  const execution = host(t);
+  const result = await execution.run({ command: process.execPath,
+    args: ["-e", 'process.stdout.write(String(process.pid)); setInterval(() => {}, 1000);'],
+    cwd: process.cwd(), mode: "capture", timeout: 500 });
+  assert.equal(result.ok, false);
+  assert.equal(result.timedOut, true);
+  assert.throws(() => process.kill(Number(result.output), 0), { code: "ESRCH" });
+});

package/test/messageDelivery.test.js

@@ -1,6 +1,8 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { createAssistantMessageDelivery } from "../src/client/conversation/messageDelivery.js";
+import { nextTick, ref } from "vue";
+import { createAssistantMessageDelivery, unmatchedOptimisticMessages } from "../src/client/conversation/messageDelivery.js";
+import { normalizeConversationTurn } from "../src/shared/conversation/patches.js";
 
 test("sending immediately renders the message and reconciles only its authoritative receipt", async () => {
   const request = Promise.withResolvers();
@@ -146,3 +148,234 @@ test("reset discards queued delivery without waiting for the old transport", asy
   assert.deepEqual(await next, { ok: true });
   assert.equal(delivery.state.sending, false);
 });
+
+test("a canonical receipt settles the retained send before its HTTP response", async () => {
+  const request = Promise.withResolvers();
+  const receipts = ref([]);
+  const delivery = createAssistantMessageDelivery();
+  const sending = delivery.send({ message: "Hello" }, {
+    messageId: "one", deliver: () => request.promise, receiptTurns: receipts, uncertainOnError: true
+  });
+  receipts.value = [{ user: { messageId: "one", text: "Hello" } }];
+  await nextTick();
+  assert.deepEqual(await sending, { ok: true });
+  assert.equal(delivery.find("one").status, "accepted");
+  request.reject(new Error("The old HTTP connection closed."));
+  await nextTick();
+  assert.equal(delivery.find("one").error, "");
+  delivery.reconcile(receipts.value);
+  assert.deepEqual(delivery.turns(receipts.value), receipts.value);
+});
+
+test("provisional authored rows remain visible without settling delivery or restored retries", async () => {
+  const request = Promise.withResolvers();
+  const receipts = ref([]);
+  const payload = { message: "Original", displayAttachments: [{ attachmentId: "original" }] };
+  let acknowledgements = 0;
+  let submissions = 0;
+  let settled = false;
+  const delivery = createAssistantMessageDelivery();
+  const sending = delivery.send(payload, {
+    messageId: "one", receiptTurns: receipts,
+    deliver() { submissions += 1; return request.promise; },
+    onAccepted() { acknowledgements += 1; }
+  });
+  void sending.then(() => { settled = true; }, () => { settled = true; });
+  const turn = normalizeConversationTurn({ turnId: "saved", user: {
+    role: "user", messageId: "one", text: "Original", receipt: false, attachments: payload.displayAttachments
+  } });
+  receipts.value = [turn];
+  delivery.reconcile(receipts.value);
+  await nextTick();
+  assert.equal(settled, false);
+  assert.equal(acknowledgements, 0);
+  assert.equal(delivery.turns(receipts.value).length, 1);
+  assert.equal(delivery.turns(receipts.value)[0].optimistic.status, "pending");
+  assert.equal(delivery.turns(receipts.value)[0].user.receipt, false);
+  const rejected = assert.rejects(sending, /Native history unavailable/);
+  request.reject(Object.assign(new Error("Native history unavailable"), { status: "uncertain" }));
+  await rejected;
+  delivery.reconcile(receipts.value);
+  assert.equal(delivery.find("one").status, "uncertain");
+  assert.equal(delivery.turns(receipts.value)[0].system.delivery.messageId, "one");
+  assert.equal(delivery.resend("one"), false);
+  assert.equal(await delivery.send(payload, { messageId: "one" }), false);
+  assert.equal(submissions, 1);
+  assert.deepEqual(delivery.find("one").payload, payload);
+  assert.equal(unmatchedOptimisticMessages(receipts.value, delivery.state.messages, { receiptsOnly: true }).length, 1);
+  const restored = createAssistantMessageDelivery();
+  assert.equal(restored.restoreUncertain({ messageId: "one", text: "Original", attachments: payload.displayAttachments }, receipts.value), true);
+  assert.equal(restored.turns(receipts.value).length, 1);
+  assert.equal(restored.turns(receipts.value)[0].optimistic.status, "uncertain");
+  const admitted = { ...turn, user: { ...turn.user } };
+  delete admitted.user.receipt;
+  delivery.reconcile([admitted]);
+  delivery.reconcile([admitted]);
+  assert.equal(acknowledgements, 1);
+  assert.equal(delivery.state.messages.length, 0);
+  assert.equal(submissions, 1);
+});
+
+test("an exact HTTP admission can retire its still provisional displayed row", async () => {
+  let acknowledgements = 0;
+  const delivery = createAssistantMessageDelivery({ deliver: async () => ({ ok: true, delivered: true }) });
+  await delivery.send({ message: "Accepted" }, { messageId: "one", onAccepted() { acknowledgements += 1; } });
+  const provisional = { turnId: "saved", user: { messageId: "one", text: "Accepted", receipt: false } };
+  delivery.reconcile([provisional]);
+  assert.deepEqual(delivery.turns([provisional]), [provisional]);
+  assert.equal(delivery.state.messages.length, 0);
+  assert.equal(acknowledgements, 1);
+});
+
+test("a late canonical receipt acknowledges captured attachments once after an uncertain HTTP response", async () => {
+  let ready = ["original"];
+  let acknowledgements = 0;
+  const delivery = createAssistantMessageDelivery({ deliver: async () => { throw new Error("Receipt lost."); } });
+  const payload = { message: "", displayAttachments: [{ attachmentId: "original" }] };
+  await assert.rejects(delivery.send(payload, {
+    messageId: "one", uncertainOnError: true,
+    onAccepted() { acknowledgements += 1; ready = ready.filter(id => id !== "original"); }
+  }), /Receipt lost/);
+  ready.push("newer");
+  assert.equal(acknowledgements, 0);
+  assert.equal(Object.values(delivery.find("one")).some(value => typeof value === "function"), false);
+  assert.deepEqual(delivery.find("one").payload, payload);
+  delivery.reconcile([{ user: { messageId: "another", text: "" } }]);
+  assert.equal(acknowledgements, 0);
+  const receipt = { user: { messageId: "one", text: "", attachments: payload.displayAttachments } };
+  delivery.reconcile([receipt]);
+  delivery.accept("one");
+  delivery.reconcile([receipt]);
+  assert.deepEqual(ready, ["newer"]);
+  assert.equal(acknowledgements, 1);
+  assert.deepEqual(delivery.state.messages, []);
+});
+
+test("a canonical receipt acknowledges attachments before HTTP completes and late failure cannot repeat it", async () => {
+  const request = Promise.withResolvers();
+  const receipts = ref([]);
+  const delivery = createAssistantMessageDelivery();
+  let acknowledgements = 0;
+  const sending = delivery.send({ message: "See the file", displayAttachments: [{ attachmentId: "original" }] }, {
+    messageId: "one", deliver: () => request.promise, receiptTurns: receipts, uncertainOnError: true,
+    onAccepted() { acknowledgements += 1; }
+  });
+  receipts.value = [{ user: { messageId: "one", text: "See the file" } }];
+  delivery.reconcile(receipts.value);
+  assert.equal(acknowledgements, 1);
+  assert.deepEqual(await sending, { ok: true });
+  request.reject(new Error("Late HTTP failure."));
+  await nextTick();
+  delivery.accept("one");
+  assert.equal(acknowledgements, 1);
+  assert.equal(delivery.state.sending, false);
+});
+
+test("retry preserves the original attachment owner and inspection can acknowledge an uncertain entry", async () => {
+  const sent = [];
+  const owners = [];
+  const delivery = createAssistantMessageDelivery({ deliver: async payload => {
+    sent.push(payload);
+    return sent.length === 1 ? { ok: false, error: "Rejected before admission." } : { ok: true };
+  } });
+  const payload = { message: "Retry this file", displayAttachments: [{ attachmentId: "original" }] };
+  await delivery.send(payload, { messageId: "one", onAccepted: () => owners.push("original") });
+  await delivery.send(payload, { messageId: "one", onAccepted: () => owners.push("newer") });
+  assert.deepEqual(sent[0], sent[1]);
+  assert.deepEqual(owners, ["original"]);
+  delivery.accept("one");
+  assert.deepEqual(owners, ["original"]);
+
+  await assert.rejects(delivery.send({ message: "Check receipt" }, {
+    messageId: "uncertain", uncertainOnError: true, deliver: async () => { throw new Error("Offline"); },
+    onAccepted: () => owners.push("inspected")
+  }), /Offline/);
+  delivery.accept("uncertain");
+  delivery.accept("uncertain");
+  assert.deepEqual(owners, ["original", "inspected"]);
+});
+
+test("unconfirmed delivery preserves its authored payload for inspection without replay or edit controls", async () => {
+  const sent = [];
+  const delivery = createAssistantMessageDelivery({ deliver: async payload => {
+    sent.push(payload);
+    throw new Error("Connection closed.");
+  } });
+  const payload = { message: "Hello", displayAttachments: [{ attachmentId: "file", name: "Original" }] };
+  await assert.rejects(delivery.send(payload, { messageId: "one", uncertainOnError: true }), /Connection closed/);
+  payload.displayAttachments[0].name = "Changed";
+  const [turn] = delivery.turns();
+  assert.equal(turn.optimistic.status, "uncertain");
+  assert.equal(turn.user.attachments[0].name, "Original");
+  assert.deepEqual(turn.system.delivery, { messageId: "one", error: "Connection closed.", checking: false });
+  assert.equal(delivery.cancel("one"), false);
+  assert.equal(delivery.edit("one", "New draft"), null);
+  assert.equal(delivery.resend("one"), false);
+  assert.equal(await delivery.send({ message: "Hello" }, { messageId: "one" }), false);
+  assert.equal(sent.length, 1);
+  delivery.accept("one");
+  assert.equal(delivery.find("one").status, "accepted");
+  assert.equal(delivery.find("one").error, "");
+  assert.equal(delivery.restoreUncertain({ messageId: "one", text: "Hello", error: "Stale error" }), false);
+  assert.equal(delivery.turns()[0].system, undefined);
+});
+
+test("reconnect restores one uncertain request and ends its HTTP wait without dispatching again", async () => {
+  const request = Promise.withResolvers();
+  const receipts = ref([]);
+  let sends = 0;
+  const delivery = createAssistantMessageDelivery();
+  const sending = delivery.send({ message: "Hello" }, {
+    messageId: "one", receiptTurns: receipts, uncertainOnError: true,
+    deliver: () => { sends += 1; return request.promise; }
+  });
+  const pendingRequest = { messageId: "one", text: "Hello", error: "Delivery is unconfirmed." };
+  assert.equal(delivery.restoreUncertain(pendingRequest), true);
+  assert.deepEqual(await sending, { ok: false, status: "uncertain", error: pendingRequest.error });
+  delivery.restoreUncertain(pendingRequest);
+  assert.equal(delivery.state.messages.length, 1);
+  assert.equal(delivery.state.sending, false);
+  assert.equal(sends, 1);
+  request.reject(new Error("Late transport failure"));
+  await nextTick();
+  assert.equal(delivery.find("one").error, pendingRequest.error);
+  const receipt = { user: { messageId: "one", text: "Hello" } };
+  delivery.reconcile([receipt]);
+  assert.equal(delivery.restoreUncertain(pendingRequest, [receipt]), false);
+  assert.deepEqual(delivery.turns([receipt]), [receipt]);
+});
+
+test("an uncertain predecessor leaves queued guidance unsent and safely retryable", async () => {
+  const request = Promise.withResolvers();
+  const sent = [];
+  const delivery = createAssistantMessageDelivery({ deliver: payload => {
+    sent.push(payload.messageId);
+    return request.promise;
+  } });
+  const first = delivery.send({ message: "First" }, { messageId: "one", uncertainOnError: true });
+  const second = delivery.send({ message: "Second" }, { messageId: "two", uncertainOnError: true, queue: true });
+  const rejected = assert.rejects(first, /Connection lost/);
+  request.reject(new Error("Connection lost"));
+  await rejected;
+  assert.equal(await second, false);
+  assert.deepEqual(sent, ["one"]);
+  assert.equal(delivery.find("one").status, "uncertain");
+  assert.equal(delivery.find("two").status, "failed");
+  assert.match(delivery.find("two").error, /Check the previous message/);
+});
+
+test("restored application requests retain their origin and attachment-only user messages remain empty", async () => {
+  const delivery = createAssistantMessageDelivery();
+  delivery.restoreUncertain({ messageId: "wake", origin: "application", text: "Continue the goal.", at: "2026-01-01T00:00:00Z" });
+  const [restored] = delivery.turns();
+  assert.equal(restored.user, undefined);
+  assert.equal(restored.system.messageId, "wake");
+  assert.match(restored.system.text, /Continue the goal/);
+  delivery.reconcile([{ system: { messageId: "wake", text: "Continue the goal." } }]);
+  assert.equal(delivery.state.messages.length, 0);
+  await delivery.send({ message: "", displayAttachments: [{ attachmentId: "image" }] }, {
+    messageId: "image-only", deliver: async () => ({ status: "accepted" })
+  });
+  assert.equal(delivery.turns()[0].user.text, "");
+  assert.deepEqual(delivery.turns()[0].user.attachments, [{ attachmentId: "image" }]);
+});

package/test/nativeConversationRetirement.test.js

@@ -0,0 +1,215 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, rm, stat, symlink, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { retireNativeConversation } from "../src/server/conversation/nativeHistoryExport.js";
+import { listClaudeConversationStorage, retireClaudeConversationHistory } from "../src/server/conversation/claudeHistory.js";
+import { createConversationRuntime } from "../src/server/conversation/runtime.js";
+import { createClaudeConversationOwner } from "../src/server/conversation/claudeTurn.js";
+
+const binding = { engineId: "codex", conversationId: "parent", workdir: "/saved/source" };
+const proof = async () => ({ preserved: true, exclusive: true });
+
+test("native retirement requires every complete export and rechecks exact content even when metadata is unchanged", async () => {
+  let revision = "a".repeat(64);
+  let deleted = false;
+  const input = { binding, inspect: async () => [{ conversationId: "parent" }],
+    remove: async () => { deleted = true; }, exportConversation: async (_id, emit) => { await emit({ type: "item" }); return { revision }; } };
+  await assert.rejects(retireNativeConversation({ ...input, beforeDelete: proof }), /complete native export/);
+  await assert.rejects(retireNativeConversation({ ...input, beforeDelete: async ({ exportConversation }) => {
+    await assert.rejects(exportConversation("foreign", async () => {}), /outside/);
+    await exportConversation("parent", async () => {});
+    revision = "b".repeat(64);
+    return proof();
+  } }), /changed during preservation/);
+  assert.equal(deleted, false);
+});
+
+test("native retirement preserves the complete scope before removal and verifies absence", async () => {
+  let rows = [{ conversationId: "parent", modified: 1 }, { conversationId: "child", modified: 2 }];
+  const calls = [];
+  const input = { binding, inspect: async () => { calls.push("inspect"); return rows; },
+    beforeDelete: async (inventory) => {
+      calls.push("preserve");
+      assert.deepEqual(inventory.conversations, rows);
+      inventory.conversations.length = 0; // The host cannot change deletion's snapshot.
+      return proof();
+    }, remove: async (scope) => { calls.push("delete"); assert.equal(scope.length, 2); rows = []; } };
+  assert.deepEqual(await retireNativeConversation(input), { ok: true, alreadyAbsent: false, conversationIds: ["parent", "child"] });
+  assert.deepEqual(calls, ["inspect", "preserve", "inspect", "delete", "inspect"]);
+  calls.length = 0;
+  assert.equal((await retireNativeConversation(input)).alreadyAbsent, true);
+  assert.deepEqual(calls, ["inspect"]);
+});
+
+test("native retirement refuses missing proofs, changing history and unconfirmed deletion", async () => {
+  let deleted = 0;
+  const input = { binding, inspect: async () => [{ conversationId: "parent", modified: 1 }], remove: async () => deleted++ };
+  await assert.rejects(retireNativeConversation(input), /callback/);
+  for (const result of [undefined, {}, { preserved: true }, { exclusive: true }]) {
+    await assert.rejects(retireNativeConversation({ ...input, beforeDelete: async () => result }), /did not confirm/);
+  }
+  let revision = 0;
+  await assert.rejects(retireNativeConversation({ ...input, beforeDelete: proof,
+    inspect: async () => [{ conversationId: "parent", modified: ++revision }] }), /changed/);
+  assert.equal(deleted, 0);
+  await assert.rejects(retireNativeConversation({ ...input, beforeDelete: proof }), /not confirmed/);
+  assert.equal(deleted, 1);
+});
+
+async function claudeFixture(t) {
+  const root = await mkdtemp(path.join(os.tmpdir(), "vibe64-native-retirement-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  const configRoot = path.join(root, "claude");
+  const workdir = path.join(root, "removed-source");
+  const id = "12345678-1234-4234-8234-123456789abc";
+  const project = path.join(configRoot, "projects", workdir.replace(/[^a-zA-Z0-9]/gu, "-"));
+  const write = async (name) => { await mkdir(path.dirname(name), { recursive: true }); await writeFile(name, "preserved native bytes"); };
+  const targets = [path.join(project, `${id}.jsonl`), path.join(project, id, "subagents/agent.jsonl"),
+    path.join(configRoot, "file-history", id, "checkpoint"), path.join(configRoot, "uploads", id, "image.png")];
+  for (const name of targets) await write(name);
+  await writeFile(targets[0], [
+    { type: "user", uuid: "question", timestamp: "2026-09-25T00:00:00Z", message: { content: [
+      { type: "text", text: "Keep the question" }, { type: "image", source: { data: "attachment payload" } }
+    ] } },
+    { type: "assistant", uuid: "answer", parentUuid: "question", message: { model: "claude-model", content: [{ type: "text", text: "Keep the answer" }] } }
+  ].map(JSON.stringify).join("\n") + "\n");
+  await writeFile(targets[1], JSON.stringify({ type: "assistant", uuid: "child-answer", isSidechain: true, parent_tool_use_id: "call",
+    message: { content: [{ type: "text", text: "Keep the child answer" }] } }) + "\n");
+  const originals = new Map(await Promise.all(targets.map(async (file) => [file, await readFile(file, "utf8")])));
+  const protectedFiles = [path.join(configRoot, "settings.json"), path.join(project, "memory/MEMORY.md"), path.join(project, "another.jsonl")];
+  for (const name of protectedFiles) await write(name);
+  return { root, project, configRoot, targets, protectedFiles, originals, binding: { engineId: "claude", conversationId: id, workdir },
+    requireIdle: async () => {}, beforeDelete: proof };
+}
+
+test("Claude retirement works after source removal, preserves shared files and is idempotent", async (t) => {
+  const f = await claudeFixture(t);
+  let preserved = 0;
+  f.beforeDelete = async ({ conversations, exportConversation }) => {
+    assert.equal(conversations.length, 1);
+    assert.equal(conversations[0].files.filter((file) => !file.directory).length, 4);
+    preserved++;
+    for (const target of f.targets) assert.equal(await readFile(target, "utf8"), f.originals.get(target));
+    const entries = [];
+    await exportConversation(f.binding.conversationId, async (record) => entries.push(...record.text));
+    assert.deepEqual(entries.map((entry) => entry.text).sort(), ["Keep the answer", "Keep the child answer", "Keep the question"]);
+    assert.equal(new Set(entries.map((entry) => entry.branchId)).size, 2);
+    assert.equal(entries.find((entry) => entry.messageId === "question").createdAt, "2026-09-25T00:00:00Z");
+    assert.equal(entries.find((entry) => entry.messageId === "answer").modelId, "claude-model");
+    return proof();
+  };
+  assert.equal((await retireClaudeConversationHistory(f)).ok, true);
+  for (const target of f.targets) await assert.rejects(stat(target), { code: "ENOENT" });
+  for (const file of f.protectedFiles) assert.equal(await readFile(file, "utf8"), "preserved native bytes");
+  assert.equal((await retireClaudeConversationHistory(f)).alreadyAbsent, true);
+  assert.equal(preserved, 1);
+});
+
+test("Claude inventory discovers additional native roots without silently claiming ownership", async (t) => {
+  const f = await claudeFixture(t);
+  const other = "23456789-1234-4234-8234-123456789abc";
+  await writeFile(path.join(f.project, `${other}.jsonl`), "native fork");
+  assert.deepEqual((await listClaudeConversationStorage(f)).map((row) => row.conversationId), [f.binding.conversationId, other]);
+  assert.equal(await readFile(path.join(f.project, `${other}.jsonl`), "utf8"), "native fork");
+});
+
+test("Claude retirement rejects writers, symlinks and changed files without deleting history", async (t) => {
+  const f = await claudeFixture(t);
+  await assert.rejects(retireClaudeConversationHistory({ ...f, requireIdle: async () => { throw new Error("busy"); } }), /busy/);
+  const link = path.join(f.project, f.binding.conversationId, "outside");
+  await symlink(f.protectedFiles[0], link);
+  await assert.rejects(retireClaudeConversationHistory(f), /unsafe paths/);
+  await rm(link);
+  await assert.rejects(retireClaudeConversationHistory({ ...f, beforeDelete: async ({ exportConversation }) => {
+    await exportConversation(f.binding.conversationId, async () => {});
+    await writeFile(f.targets[0], f.originals.get(f.targets[0]).replace("Keep the answer", "changed after inventory")); return proof();
+  } }), /changed/);
+  assert.match(await readFile(f.targets[0], "utf8"), /changed after inventory/);
+});
+
+
+test("configured Claude retirement preserves saved, native and terminal gates before asynchronous history preservation", { timeout: 10000 }, async t => {
+  const f = await claudeFixture(t);
+  const context = { key: "retained-parent", sessionId: "retained-parent", workdir: f.binding.workdir };
+  const owner = createClaudeConversationOwner({
+    configRoot: f.configRoot, preparation: {},
+    process: { create() { assert.fail("Historical retirement must not start a native process."); } },
+    store: {
+      select() { assert.fail("Restoring the saved native entry must not select Main."); },
+      read() { return JSON.stringify({ turnId: "saved-turn", state: "active" }); },
+      async save() {}
+    }
+  });
+  const reads = [];
+  let saved = { executionId: "saved-managed-execution" };
+  let terminalRunning = false;
+  let preservations = 0;
+  const entered = Promise.withResolvers();
+  const release = Promise.withResolvers();
+  const releaseOnAbort = () => release.resolve();
+  t.signal.addEventListener("abort", releaseOnAbort, { once: true });
+  const beforeDelete = async ({ exportConversation }) => {
+    preservations++;
+    await exportConversation(f.binding.conversationId, async () => {});
+    entered.resolve();
+    await release.promise;
+    return proof();
+  };
+  const application = {
+    get saved() { reads.push("saved"); return saved; },
+    get terminalRunning() { reads.push("terminal"); return terminalRunning; }
+  };
+  const runtime = createConversationRuntime({
+    authorize() { assert.fail("Saved-history cleanup must not authorize inference."); },
+    storage: {
+      read() { assert.fail("Retirement must not open Main."); },
+      write() { assert.fail("Retirement must not allocate a binding."); }
+    },
+    host: { conversation(request) {
+      assert.deepEqual(request, { id: context.sessionId, context, input: f.binding, operation: "retireConversationHistory" });
+      return { sessionId: request.id, engine: "claude", binding: f.binding, context,
+        native: { owner, preparation: { retirement(binding, current) {
+          assert.equal(binding, f.binding);
+          assert.equal(current, context);
+          return { configRoot: f.configRoot, binding, beforeDelete, application };
+        } } } };
+    } }
+  });
+  t.after(async () => { release.resolve(); t.signal.removeEventListener("abort", releaseOnAbort); await runtime.close(); owner.forget(context.key); });
+  const retire = () => runtime.retireNativeConversationHistory({ id: context.sessionId, context, binding: f.binding });
+  const blocked = /Stop the saved Claude process and its terminal before retiring native history/;
+
+  await assert.rejects(retire(), blocked);
+  assert.deepEqual(reads, ["saved"], "Saved execution blocks without querying the PTY.");
+  saved = {};
+  await owner.open(context, { conversationId: f.binding.conversationId, create: true });
+  reads.length = 0;
+  await assert.rejects(retire(), blocked);
+  assert.deepEqual(reads, ["saved"], "The restored native active turn blocks before the PTY read.");
+  owner.forget(context.key);
+  terminalRunning = true;
+  reads.length = 0;
+  await assert.rejects(retire(), blocked);
+  assert.deepEqual(reads, ["saved", "terminal"]);
+  assert.equal(preservations, 0);
+  for (const target of f.targets) assert.equal(await readFile(target, "utf8"), f.originals.get(target));
+
+  terminalRunning = false;
+  let settled = false;
+  const retiring = retire().finally(() => { settled = true; });
+  try {
+    await Promise.race([entered.promise, retiring.then(() => assert.fail("Retirement must await preservation."))]);
+    assert.equal(settled, false);
+    for (const target of f.targets) assert.equal(await readFile(target, "utf8"), f.originals.get(target));
+    release.resolve();
+    assert.deepEqual(await retiring, { ok: true, alreadyAbsent: false, conversationIds: [f.binding.conversationId] });
+  } finally {
+    release.resolve();
+    await retiring.catch(() => {});
+  }
+  assert.equal(preservations, 1);
+  for (const target of f.targets) await assert.rejects(stat(target), { code: "ENOENT" });
+  for (const file of f.protectedFiles) assert.equal(await readFile(file, "utf8"), "preserved native bytes");
+});