@inetafrica/open-claudia 2.14.8 → 3.0.0

package/test-provider-codex.js

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const path = require("path");
+const { validateInvocation, validateProvider } = require("./core/providers/contract");
+const { createCodexProvider } = require("./core/providers/codex");
+const { getProvider } = require("./core/providers");
+
+function deepFreeze(value) {
+  if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
+  for (const child of Object.values(value)) deepFreeze(child);
+  return Object.freeze(value);
+}
+
+const safeEnv = { PATH: "/fixture/bin", HOME: "/fixture/home", OPENAI_API_KEY: "fixture-not-a-real-key" };
+let authState = { state: "authenticated", reason: null, method: "fixture" };
+const provider = createCodexProvider({
+  hookTransport: false,
+  resolveExecutable: () => "/fixture/codex",
+  defaultModel: "gpt-5-codex",
+  buildEnv: () => ({ ...safeEnv }),
+  getAuthStatus: () => authState,
+  runCommand: (_binary, args) => {
+    if (args[0] === "--version") return { ok: true, output: "codex-cli 0.144.0", code: 0 };
+    if (args.join(" ") === "exec --help") return {
+      ok: true,
+      output: "--config --json --sandbox --image --model --skip-git-repo-check",
+      code: 0,
+    };
+    if (args.join(" ") === "exec resume --help") return {
+      ok: true,
+      output: "--config --json --image --model --skip-git-repo-check",
+      code: 0,
+    };
+    return { ok: false, output: "unexpected fixture command", code: 1 };
+  },
+});
+
+assert.strictEqual(validateProvider(provider), provider);
+assert.strictEqual(provider.id, "codex");
+assert.strictEqual(getProvider("codex").id, "codex", "built-in registry exposes Codex lazily");
+assert.strictEqual(provider.label, "OpenAI Codex");
+assert.strictEqual(provider.isAvailable(), true);
+assert.strictEqual(provider.executable(), "/fixture/codex");
+assert.strictEqual(provider.defaultModel(), "gpt-5-codex");
+assert.ok(provider.modelChoices().includes("gpt-5.4-mini"));
+assert.ok(!provider.modelChoices().includes("o4-mini"));
+assert.deepStrictEqual(provider.compatibilityStatus(), {
+  state: "compatible",
+  version: "0.144.0",
+  reason: null,
+});
+
+assert.strictEqual(provider.capabilities.resume.support, "native");
+assert.strictEqual(provider.capabilities.readOnlyMode.support, "native");
+assert.strictEqual(provider.capabilities.effort.support, "native");
+assert.strictEqual(provider.capabilities.imageFlag.support, "native");
+for (const key of ["budget", "worktree", "maxTurns"]) {
+  assert.strictEqual(provider.capabilities[key].support, "unsupported");
+  assert.ok(provider.capabilities[key].reason);
+}
+assert.strictEqual(provider.capabilities.partialStreaming.support, "unsupported");
+assert.strictEqual(provider.capabilities.persistentUtilityStream.support, "unsupported");
+assert.strictEqual(provider.capabilities.preToolHook.support, "native");
+
+const freshContext = deepFreeze({
+  coreInstructions: "STABLE CORE",
+  dynamicContext: "DYNAMIC CONTEXT",
+  userPrompt: "USER SENTINEL",
+  fresh: true,
+  sessionId: "ignored-thread",
+  providerSettings: {
+    model: "gpt-5-codex",
+    effort: "high",
+    permissionMode: "plan",
+    budget: null,
+    worktree: false,
+  },
+  imagePaths: ["/fixture/one.png", "/fixture/two.png"],
+});
+const before = JSON.stringify(freshContext);
+const fresh = validateInvocation(provider.buildMainInvocation(freshContext));
+assert.strictEqual(JSON.stringify(freshContext), before, "frozen run context must not be mutated");
+assert.deepStrictEqual(fresh.args, [
+  "exec",
+  "-c", `developer_instructions=${JSON.stringify("STABLE CORE")}`,
+  "-c", `model_reasoning_effort=${JSON.stringify("high")}`,
+  "--image", "/fixture/one.png", "/fixture/two.png",
+  "--json",
+  "--skip-git-repo-check",
+  "--sandbox", "read-only",
+  "--model", "gpt-5-codex",
+  "DYNAMIC CONTEXT\n\nUSER SENTINEL",
+]);
+assert.deepStrictEqual(fresh.env, safeEnv);
+assert.strictEqual(fresh.stdin, null);
+assert.ok(fresh.parserState.seenUsage instanceof Set);
+assert.ok(!Object.prototype.hasOwnProperty.call(fresh.env, "CLAUDE_CODE_OAUTH_TOKEN"));
+
+function simpleContext(overrides = {}) {
+  return deepFreeze({
+    coreInstructions: "CORE",
+    dynamicContext: "",
+    userPrompt: "PROMPT",
+    providerSettings: { budget: null, worktree: false },
+    ...overrides,
+  });
+}
+
+const resumed = provider.buildMainInvocation(simpleContext({
+  resumeSessionId: "thread-1",
+  providerSettings: { effort: "medium", permissionMode: "plan", budget: null, worktree: false },
+  imagePaths: ["/fixture/resume.png"],
+}));
+assert.deepStrictEqual(resumed.args, [
+  "exec", "resume",
+  "-c", `developer_instructions=${JSON.stringify("CORE")}`,
+  "-c", `model_reasoning_effort=${JSON.stringify("medium")}`,
+  "-c", `sandbox_mode=${JSON.stringify("read-only")}`,
+  "--image", "/fixture/resume.png",
+  "--json",
+  "--skip-git-repo-check",
+  "--model", "gpt-5-codex",
+  "thread-1",
+  "PROMPT",
+]);
+assert.ok(!resumed.args.includes("--sandbox"));
+assert.ok(resumed.args.indexOf("thread-1") > resumed.args.lastIndexOf("--model"));
+
+const directResume = provider.buildMainInvocation(simpleContext({ sessionId: "thread-direct" }));
+assert.ok(directResume.args.includes("--dangerously-bypass-approvals-and-sandbox"));
+assert.ok(directResume.args.indexOf("--dangerously-bypass-approvals-and-sandbox") < directResume.args.indexOf("thread-direct"));
+
+const continued = provider.buildMainInvocation(simpleContext({ continueSession: true, sessionId: "thread-continue" }));
+assert.strictEqual(continued.args[1], "resume");
+assert.ok(continued.args.includes("thread-continue"));
+
+const freshIgnoringSession = provider.buildMainInvocation(simpleContext({ fresh: true, sessionId: "old-thread" }));
+assert.strictEqual(freshIgnoringSession.args[1], "-c");
+assert.ok(!freshIgnoringSession.args.includes("old-thread"));
+
+assert.throws(
+  () => provider.buildMainInvocation(simpleContext({ continueSession: true })),
+  (error) => error && error.code === "INVALID_PROVIDER_CONTEXT",
+);
+for (const providerSettings of [
+  { budget: 1, worktree: false },
+  { budget: null, worktree: true },
+]) {
+  assert.throws(
+    () => provider.buildMainInvocation(simpleContext({ providerSettings })),
+    (error) => error && error.code === "UNSUPPORTED_PROVIDER_SETTING",
+  );
+}
+assert.throws(
+  () => provider.buildMainInvocation(simpleContext({ maxTurns: 2 })),
+  (error) => error && error.code === "UNSUPPORTED_PROVIDER_SETTING",
+);
+assert.throws(
+  () => provider.buildMainInvocation(simpleContext({ voiceStream: true })),
+  (error) => error && error.code === "UNSUPPORTED_PROVIDER_CAPABILITY",
+);
+assert.throws(
+  () => provider.buildMainInvocation(simpleContext({ providerSettings: { effort: "max", budget: null, worktree: false } })),
+  (error) => error && error.code === "UNSUPPORTED_PROVIDER_SETTING",
+);
+assert.throws(
+  () => provider.buildMainInvocation(deepFreeze({ dynamicContext: "only", userPrompt: "raw" })),
+  (error) => error && error.code === "MISSING_CORE_INSTRUCTIONS",
+);
+
+const utility = validateInvocation(provider.buildUtilityInvocation(deepFreeze({
+  coreInstructions: "UTILITY CORE",
+  userPrompt: "UTILITY PROMPT",
+  readOnly: true,
+  tier: "low",
+  outputSchemaPath: "/fixture/schema.json",
+})));
+assert.ok(utility.args.includes("--ephemeral"));
+assert.strictEqual(utility.args[utility.args.indexOf("--model") + 1], "gpt-5.4-mini");
+assert.strictEqual(utility.args[utility.args.indexOf("--output-schema") + 1], "/fixture/schema.json");
+assert.deepStrictEqual(
+  utility.args.slice(utility.args.indexOf("--sandbox"), utility.args.indexOf("--sandbox") + 2),
+  ["--sandbox", "read-only"],
+);
+assert.strictEqual(utility.args.at(-1), "-", "Codex utility invocation reads its protected prompt from stdin");
+assert.strictEqual(utility.stdin, "UTILITY PROMPT");
+assert.ok(!utility.args.includes("UTILITY PROMPT"));
+
+const decoder = provider.createEventDecoder();
+const raw = decoder.push(Buffer.from('{"type":"thread.started","thread_id":"bound-thread"}\n'));
+assert.deepStrictEqual(provider.normalizeEvent(raw[0], fresh.parserState), [{ type: "session", sessionId: "bound-thread" }]);
+
+assert.strictEqual(provider.authStatus().state, "authenticated");
+assert.strictEqual(provider.preflightAuth(), null);
+authState = { state: "unauthenticated", reason: "login required" };
+const authFailure = provider.preflightAuth();
+assert.strictEqual(authFailure.code, "PROVIDER_UNAUTHENTICATED");
+assert.match(authFailure.message, /Codex authentication/i);
+assert.match(provider.authHelp(), /codex_login/);
+
+const missing = createCodexProvider({ hookTransport: false, resolveExecutable: () => null, getAuthStatus: () => ({ state: "not_checked", reason: "missing" }) });
+assert.strictEqual(missing.isAvailable(), false);
+assert.throws(
+  () => missing.buildMainInvocation(simpleContext()),
+  (error) => error && error.code === "NO_AVAILABLE_PROVIDER",
+);
+
+const incompatible = createCodexProvider({
+  hookTransport: false,
+  resolveExecutable: () => "/fixture/old-codex",
+  buildEnv: () => ({ PATH: "/fixture" }),
+  getAuthStatus: () => ({ state: "unknown", reason: "not checked" }),
+  runCommand: (_binary, args) => {
+    if (args[0] === "--version") return { ok: true, output: "codex-cli 0.1.0", code: 0 };
+    if (args.join(" ") === "exec --help") return { ok: true, output: "--json", code: 0 };
+    return { ok: true, output: "--json", code: 0 };
+  },
+});
+assert.strictEqual(incompatible.compatibilityStatus().state, "incompatible");
+
+const source = fs.readFileSync(path.join(__dirname, "core", "providers", "codex.js"), "utf8");
+assert.ok(!source.includes('require("child_process")'), "provider adapter must return invocation data instead of spawning");
+
+console.log("Codex provider OK");

package/test-provider-compaction.js

@@ -0,0 +1,371 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const root = __dirname;
+const configDir = fs.mkdtempSync(path.join(os.tmpdir(), "open-claudia-compaction-"));
+const workspace = path.join(configDir, "workspace");
+const alphaDir = path.join(workspace, "alpha");
+const betaDir = path.join(workspace, "beta");
+fs.mkdirSync(alphaDir, { recursive: true });
+fs.mkdirSync(betaDir, { recursive: true });
+process.env.OPEN_CLAUDIA_CONFIG_DIR = configDir;
+process.env.WORKSPACE = workspace;
+process.env.TELEGRAM_CHAT_ID = "fixture";
+process.env.OPEN_CLAUDIA_TEST = "1";
+process.env.CLAUDE_PATH = process.execPath;
+process.env.CODEX_PATH = process.execPath;
+
+const stateApi = require("./core/state");
+const runner = require("./core/runner");
+
+const state = stateApi.currentState();
+
+function result(overrides = {}) {
+  return {
+    ok: true,
+    status: "succeeded",
+    terminalSeen: true,
+    text: "Summary\n\n=== CONDENSED SEED ===\nA sufficiently detailed condensed continuation that is longer than eighty characters for the fixture to accept.",
+    sessionId: "new-session",
+    usage: { input_tokens: 40, cached_input_tokens: 10, output_tokens: 4 },
+    usageScope: "session_total",
+    ...overrides,
+  };
+}
+
+function resetFixture(provider = "claude") {
+  state.currentSession = { name: "alpha", dir: alphaDir };
+  state.settings.backend = provider;
+  state.activeSessions = {
+    alpha: { claude: "old-claude", codex: "old-codex" },
+    beta: { claude: "beta-claude", codex: "beta-codex" },
+  };
+  state.usageBySession = {
+    [`alpha\0${provider}\0old-${provider}`]: {
+      ...stateApi.freshUsage(),
+      turns: 7,
+      inputTokens: 700,
+      liveContextTokens: 900,
+    },
+  };
+  state.pendingCompaction = null;
+  state.completedCompactions = {};
+  state.lastCompactedAt = 0;
+  state.isCompacting = false;
+  state.runningProcess = null;
+  state.preparingRun = false;
+  state.isFirstMessage = false;
+  stateApi.replaceProjectSessions(state.userId, "alpha", [
+    {
+      id: `old-${provider}`,
+      provider,
+      project: "alpha",
+      title: "Old session",
+      created: "2026-01-01T00:00:00.000Z",
+      lastUsed: "2026-01-01T00:00:00.000Z",
+      selectable: true,
+    },
+  ], { strict: true });
+  stateApi.saveState({ strict: true });
+}
+
+function serviceWith(runCapture, extra = {}) {
+  return runner.createCompactionService({
+    getState: () => state,
+    captureRunContext: runner.admitRunContext,
+    runCapture,
+    commitCompaction: stateApi.commitProviderCompaction,
+    archiveBrief: () => null,
+    appendDaySeed: () => {},
+    collectRepoFacts: () => null,
+    collectRecentTurns: () => null,
+    ...extra,
+  });
+}
+
+async function immutableSuccessProbe() {
+  resetFixture("claude");
+  state.isCompacting = true;
+  assert.strictEqual(stateApi.acquireRunLock(state), false, "foreground admission stays closed between compaction stages");
+  state.isCompacting = false;
+  const contexts = [];
+  const service = serviceWith(async (_prompt, _cwd, options) => {
+    assert.strictEqual(options.persist, false, "compaction provider stages have no ordinary capture persistence");
+    contexts.push(options.runContext);
+    assert.strictEqual(stateApi.getProviderSession(state, "claude", "alpha"), "old-claude", "pointer stays old during both provider stages");
+    if (contexts.length === 1) {
+      state.currentSession = { name: "beta", dir: betaDir };
+      state.settings.backend = "codex";
+      state.isFirstMessage = true;
+      return result({ sessionId: "old-claude" });
+    }
+    return result({ sessionId: "new-claude" });
+  });
+  const compacted = await service.compact(alphaDir, { operationId: "compact-success" });
+  assert.strictEqual(compacted.compacted, true);
+  assert.strictEqual(contexts.length, 2);
+  assert.strictEqual(contexts[0].provider, "claude");
+  assert.strictEqual(contexts[0].project.name, "alpha");
+  assert.strictEqual(contexts[0].sessionId, "old-claude");
+  assert.ok(Number.isFinite(contexts[0].timeoutMs) && contexts[0].timeoutMs > 0);
+  assert.strictEqual(contexts[1].provider, "claude");
+  assert.strictEqual(contexts[1].project.name, "alpha");
+  assert.strictEqual(contexts[1].fresh, true);
+  assert.strictEqual(contexts[1].readOnly, true);
+  assert.strictEqual(contexts[1].permissionMode, "plan");
+  assert.strictEqual(contexts[1].maxTurns, 1);
+  assert.strictEqual(contexts[1].timeoutMs, contexts[0].timeoutMs);
+  const restrictedEnv = runner.decorateForegroundInvocation(
+    { env: { FIXTURE_SAFE: "1" } },
+    contexts[0],
+    { transcriptPaths: null },
+  ).env;
+  assert.strictEqual(restrictedEnv.OC_PROVIDER, "claude");
+  assert.ok(!Object.prototype.hasOwnProperty.call(restrictedEnv, "OC_SEND_URL"));
+  assert.ok(!Object.prototype.hasOwnProperty.call(restrictedEnv, "OC_CANONICAL_USER_ID"));
+  assert.ok(!Object.prototype.hasOwnProperty.call(restrictedEnv, "OC_LAST_SESSION_ID"));
+  assert.strictEqual(state.currentSession.name, "beta", "live project switch is preserved");
+  assert.strictEqual(state.settings.backend, "codex", "live provider switch is preserved");
+  assert.strictEqual(state.isFirstMessage, true, "the switched live tuple keeps its transient first-message state");
+  assert.strictEqual(stateApi.getProviderSession(state, "claude", "alpha"), "new-claude");
+  assert.strictEqual(stateApi.getProviderSession(state, "codex", "beta"), "beta-codex");
+  const history = stateApi.getProjectSessions(state.userId, "alpha", "claude");
+  assert.strictEqual(history.filter((entry) => entry.id === "new-claude").length, 1);
+  assert.deepStrictEqual(history[0].lineage, {
+    type: "compaction",
+    operationId: "compact-success",
+    previousSessionId: "old-claude",
+    newSessionId: "new-claude",
+  });
+  const usage = stateApi.getUsageForSession(state, "alpha", "claude", "new-claude");
+  assert.strictEqual(usage.turns, 0, "seed is not billed as a user turn");
+  assert.strictEqual(usage.compactionCheckpoint.previousSessionId, "old-claude");
+  assert.strictEqual(state.isCompacting, false);
+}
+
+async function failureProbe() {
+  resetFixture("claude");
+  state.runningProcess = { pid: 123 };
+  let busyCalls = 0;
+  const busy = await serviceWith(async () => { busyCalls += 1; return result(); }).compact(alphaDir);
+  assert.strictEqual(busy.compacted, false);
+  assert.strictEqual(busyCalls, 0, "manual compaction never overlaps an active provider run");
+  state.runningProcess = null;
+
+  resetFixture("claude");
+  let summaryCalls = 0;
+  const summaryFailure = serviceWith(async () => {
+    summaryCalls += 1;
+    return result({ ok: false, status: "failed", sessionId: "old-claude" });
+  });
+  const failedSummary = await summaryFailure.compact(alphaDir, { operationId: "compact-summary-failed" });
+  assert.strictEqual(failedSummary.compacted, false);
+  assert.strictEqual(summaryCalls, 1, "a failed summary never starts a seed");
+  assert.strictEqual(stateApi.getProviderSession(state, "claude", "alpha"), "old-claude");
+
+  for (const [label, seed] of [
+    ["failed", result({ ok: false, status: "failed", sessionId: "failed-new" })],
+    ["nonterminal", result({ terminalSeen: false, sessionId: "nonterminal-new" })],
+    ["missing-session", result({ sessionId: null })],
+  ]) {
+    resetFixture("claude");
+    let calls = 0;
+    const service = serviceWith(async () => (++calls === 1 ? result({ sessionId: "old-claude" }) : seed));
+    const compacted = await service.compact(alphaDir, { operationId: `compact-${label}` });
+    assert.strictEqual(compacted.compacted, false, label);
+    assert.strictEqual(stateApi.getProviderSession(state, "claude", "alpha"), "old-claude", label);
+    assert.strictEqual(stateApi.getProjectSessions(state.userId, "alpha", "claude").length, 1, label);
+  }
+
+  resetFixture("claude");
+  let calls = 0;
+  let stateWrites = 0;
+  const persistenceFailure = serviceWith(
+    async () => (++calls === 1 ? result({ sessionId: "old-claude" }) : result({ sessionId: "persist-failed-new" })),
+    {
+      commitCompaction: (target, transaction) => stateApi.commitProviderCompaction(target, transaction, {
+        persistState(options) {
+          stateWrites += 1;
+          if (stateWrites === 2) throw Object.assign(new Error("fixture persistence failure"), { code: "FIXTURE_PERSISTENCE" });
+          return stateApi.saveState(options);
+        },
+      }),
+    },
+  );
+  const failed = await persistenceFailure.compact(alphaDir, { operationId: "compact-persist-failure" });
+  assert.strictEqual(failed.compacted, false);
+  assert.strictEqual(stateApi.getProviderSession(state, "claude", "alpha"), "old-claude");
+  assert.strictEqual(stateApi.getProjectSessions(state.userId, "alpha", "claude").length, 1);
+
+  resetFixture("claude");
+  calls = 0;
+  const rejectedHistory = serviceWith(
+    async () => (++calls === 1 ? result({ sessionId: "old-claude" }) : result({ sessionId: "history-rejected-new" })),
+    {
+      commitCompaction: (target, transaction) => stateApi.commitProviderCompaction(target, transaction, {
+        recordHistory: () => false,
+      }),
+    },
+  );
+  const historyFailed = await rejectedHistory.compact(alphaDir, { operationId: "compact-history-rejected" });
+  assert.strictEqual(historyFailed.compacted, false);
+  assert.strictEqual(stateApi.getProviderSession(state, "claude", "alpha"), "old-claude");
+  assert.deepStrictEqual(stateApi.getProjectSessions(state.userId, "alpha", "claude").map((entry) => entry.id), ["old-claude"]);
+}
+
+async function codexRestrictionProbe() {
+  resetFixture("codex");
+  const contexts = [];
+  const service = serviceWith(async (_prompt, _cwd, options) => {
+    contexts.push(options.runContext);
+    return contexts.length === 1
+      ? result({ sessionId: "old-codex" })
+      : result({ sessionId: "new-codex", usage: { input_tokens: 90, cached_input_tokens: 50, output_tokens: 5 } });
+  });
+  const compacted = await service.compact(alphaDir, { operationId: "compact-codex" });
+  assert.strictEqual(compacted.compacted, true);
+  const seed = contexts[1];
+  assert.strictEqual(seed.provider, "codex");
+  assert.strictEqual(seed.readOnly, true);
+  assert.strictEqual(seed.permissionMode, "plan");
+  assert.strictEqual(seed.maxTurns, null, "Codex maxTurns is honestly unsupported");
+  assert.ok(seed.outputSchemaPath && fs.existsSync(seed.outputSchemaPath));
+  const usage = stateApi.getUsageForSession(state, "alpha", "codex", "new-codex");
+  assert.deepStrictEqual(usage.providerUsageSnapshot, {
+    input_tokens: 90,
+    cached_input_tokens: 50,
+    output_tokens: 5,
+  });
+
+  const codexProvider = require("./core/providers/codex").createCodexProvider({
+    hookTransport: false,
+    resolveExecutable: () => process.execPath,
+    buildEnv: () => ({}),
+    getAuthStatus: () => ({ state: "authenticated", reason: null }),
+  });
+  const codexInvocation = codexProvider.buildCompactionInvocation({
+    coreInstructions: "fixture policy",
+    userPrompt: "acknowledge",
+    providerSettings: { permissionMode: "plan", budget: null, worktree: false },
+    fresh: true,
+    readOnly: true,
+    maxTurns: null,
+    outputSchemaPath: seed.outputSchemaPath,
+    imagePaths: [],
+  });
+  assert.ok(codexInvocation.args.includes("read-only"));
+  assert.ok(codexInvocation.args.includes("--output-schema"));
+  assert.ok(!codexInvocation.args.includes("--ephemeral"), "persisted Codex seed is resumable");
+  assert.ok(!codexInvocation.args.includes("--dangerously-bypass-approvals-and-sandbox"));
+
+  const claudeProvider = require("./core/providers/claude").createClaudeProvider({
+    hookTransport: false,
+    resolveExecutable: () => process.execPath,
+    buildEnv: () => ({}),
+    getAuthStatus: () => ({ state: "authenticated", reason: null }),
+  });
+  const claudeInvocation = claudeProvider.buildCompactionInvocation({
+    coreInstructions: "fixture policy",
+    userPrompt: "acknowledge",
+    providerSettings: { permissionMode: "plan", budget: null, worktree: false },
+    fresh: true,
+    readOnly: true,
+    maxTurns: 1,
+    imagePaths: [],
+  });
+  assert.deepStrictEqual(claudeInvocation.args.slice(claudeInvocation.args.indexOf("--max-turns"), claudeInvocation.args.indexOf("--max-turns") + 2), ["--max-turns", "1"]);
+  assert.deepStrictEqual(claudeInvocation.args.slice(claudeInvocation.args.indexOf("--permission-mode"), claudeInvocation.args.indexOf("--permission-mode") + 2), ["--permission-mode", "plan"]);
+}
+
+function duplicateCommitProbe() {
+  resetFixture("claude");
+  const transaction = {
+    operationId: "compact-duplicate",
+    canonicalUserId: state.userId,
+    project: "alpha",
+    provider: "claude",
+    previousSessionId: "old-claude",
+    newSessionId: "duplicate-new",
+    title: "Compacted fixture",
+    seedUsage: null,
+  };
+  const first = stateApi.commitProviderCompaction(state, transaction);
+  const second = stateApi.commitProviderCompaction(state, transaction);
+  assert.strictEqual(first.committed, true);
+  assert.strictEqual(second.duplicate, true);
+  assert.strictEqual(stateApi.getProjectSessions(state.userId, "alpha", "claude").filter((entry) => entry.id === "duplicate-new").length, 1);
+}
+
+function restartRecoveryProbe() {
+  resetFixture("claude");
+  const childScript = [
+    "const stateApi = require('./core/state');",
+    "const state = stateApi.currentState();",
+    "stateApi.commitProviderCompaction(state, {",
+    "  operationId: 'compact-crash', canonicalUserId: state.userId, project: 'alpha', provider: 'claude',",
+    "  previousSessionId: 'old-claude', newSessionId: 'crash-new', title: 'Crash fixture', seedUsage: null,",
+    "}, { faultInjector(point) { if (point === 'after-compaction-history') process.exit(73); } });",
+  ].join("\n");
+  const crashed = spawnSync(process.execPath, ["-e", childScript], { cwd: root, env: process.env, encoding: "utf8" });
+  assert.strictEqual(crashed.status, 73, crashed.stderr || crashed.stdout);
+
+  const recovered = spawnSync(process.execPath, ["-e", [
+    "const s = require('./core/state');",
+    "const state = s.currentState();",
+    "process.stdout.write(JSON.stringify({ pointer: s.getProviderSession(state, 'claude', 'alpha'), history: s.getProjectSessions(state.userId, 'alpha', 'claude').map(x => x.id), pending: state.pendingCompaction || null }));",
+  ].join("\n")], { cwd: root, env: process.env, encoding: "utf8" });
+  assert.strictEqual(recovered.status, 0, recovered.stderr || recovered.stdout);
+  assert.deepStrictEqual(JSON.parse(recovered.stdout), {
+    pointer: "old-claude",
+    history: ["old-claude"],
+    pending: null,
+  });
+
+  resetFixture("claude");
+  const committedCrashScript = [
+    "const stateApi = require('./core/state');",
+    "const state = stateApi.currentState();",
+    "stateApi.commitProviderCompaction(state, {",
+    "  operationId: 'compact-committed-crash', canonicalUserId: state.userId, project: 'alpha', provider: 'claude',",
+    "  previousSessionId: 'old-claude', newSessionId: 'committed-crash-new', title: 'Committed crash fixture', seedUsage: null,",
+    "}, { faultInjector(point) { if (point === 'after-compaction-state-commit') process.exit(74); } });",
+  ].join("\n");
+  const committedCrash = spawnSync(process.execPath, ["-e", committedCrashScript], { cwd: root, env: process.env, encoding: "utf8" });
+  assert.strictEqual(committedCrash.status, 74, committedCrash.stderr || committedCrash.stdout);
+  const finalized = spawnSync(process.execPath, ["-e", [
+    "const s = require('./core/state');",
+    "const state = s.currentState();",
+    "process.stdout.write(JSON.stringify({ pointer: s.getProviderSession(state, 'claude', 'alpha'), history: s.getProjectSessions(state.userId, 'alpha', 'claude').map(x => x.id), pending: state.pendingCompaction || null }));",
+  ].join("\n")], { cwd: root, env: process.env, encoding: "utf8" });
+  assert.strictEqual(finalized.status, 0, finalized.stderr || finalized.stdout);
+  assert.deepStrictEqual(JSON.parse(finalized.stdout), {
+    pointer: "committed-crash-new",
+    history: ["committed-crash-new", "old-claude"],
+    pending: null,
+  });
+}
+
+(async () => {
+  try {
+    assert.strictEqual(typeof runner.createCompactionService, "function");
+    assert.strictEqual(typeof stateApi.commitProviderCompaction, "function");
+    await immutableSuccessProbe();
+    await failureProbe();
+    await codexRestrictionProbe();
+    duplicateCommitProbe();
+    restartRecoveryProbe();
+    console.log("provider compaction OK");
+  } finally {
+    fs.rmSync(configDir, { recursive: true, force: true });
+  }
+})().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});