@inetafrica/open-claudia 2.15.0 → 3.0.0

package/test-provider-parity-e2e.js

@@ -0,0 +1,537 @@
+#!/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 repoRoot = __dirname;
+const fixture = path.join(repoRoot, "test-fixtures", "fake-agent-cli.js");
+
+const SUPPORT_SUITES = Object.freeze({
+  prompt: ["test-provider-core-prompt.js", "provider core prompt OK"],
+  lifecycle: ["test-provider-run-lifecycle.js", "provider run lifecycle OK"],
+  gateway: ["test-provider-gateway.js", "provider gateway OK"],
+  sessions: ["test-provider-session-commands.js", "provider session commands OK"],
+  history: ["test-provider-session-history.js", "provider session history OK"],
+  compaction: ["test-provider-compaction.js", "provider compaction OK"],
+  scheduler: ["test-provider-scheduler.js", "provider scheduler OK"],
+  sideChat: ["test-provider-side-chat.js", "provider side chat OK"],
+  recall: ["test-provider-recall.js", "provider recall OK"],
+  review: ["test-provider-pack-review.js", "provider pack review OK"],
+  mutationQueue: ["test-memory-mutation-queue.js", "memory mutation queue OK"],
+  dream: ["test-provider-dream.js", "provider dream OK"],
+  subagent: ["test-provider-subagent.js", "provider subagent OK"],
+  enforcer: ["test-provider-enforcer.js", "provider enforcer OK"],
+  environment: ["test-provider-env-isolation.js", "provider env isolation OK"],
+  hooks: ["test-provider-tool-hooks.js", "provider tool hooks OK"],
+  migration: ["test-provider-migration-backup.js", "provider migration backup OK"],
+  cursorRemoval: ["test-cursor-removal.js", "cursor removal OK"],
+  bootstrap: ["test-provider-boot-matrix.js", "provider boot matrix OK"],
+});
+
+const SCENARIOS = Object.freeze([
+  [1, "fresh prompt context and mandatory fail-closed construction", ["prompt"]],
+  [2, "split/coalesced JSONL and one terminal result", ["lifecycle"]],
+  [3, "tool progress and final delivery", ["gateway"]],
+  [4, "immutable admission across mutable switches", ["gateway"]],
+  [5, "terminal lifecycle and failure settlement", ["lifecycle"]],
+  [6, "fresh, resume, and continue", ["sessions"]],
+  [7, "project and provider switching", ["sessions"]],
+  [8, "restart state restoration", ["sessions"]],
+  [9, "new/end/sessions and callback rejection", ["sessions", "history"]],
+  [10, "compaction summary/seed rollback safety", ["compaction"]],
+  [11, "provider-pinned wakeups and recurring jobs", ["scheduler"]],
+  [12, "file/image/voice gateway ingress", ["gateway"]],
+  [13, "nonblocking side chat without main mutation", ["sideChat"]],
+  [14, "recall filter and discoverer", ["recall"]],
+  [15, "post-turn review and serialized memory writes", ["review", "mutationQueue"]],
+  [16, "dream and introspection", ["dream"]],
+  [17, "sub-agent timeout and process-tree cleanup", ["subagent"]],
+  [18, "external-person enforcer", ["enforcer"]],
+  [19, "provider auth failure and recovery", ["lifecycle"]],
+  [20, "credential environment isolation", ["environment"]],
+  [21, "mandatory tool-hook initialization", ["hooks"]],
+  [22, "verified migration, archival ordering, and rollback", ["migration", "cursorRemoval"]],
+  [23, "no-provider setup/status boot without model calls", ["bootstrap"]],
+].map(([id, name, evidence]) => Object.freeze({ id, name, evidence: Object.freeze(evidence) })));
+
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
+  return { promise, resolve, reject };
+}
+
+function timeoutAfter(promise, ms, label) {
+  let timer;
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(`timed out waiting for ${label}`)), ms);
+    }),
+  ]).finally(() => clearTimeout(timer));
+}
+
+async function assertPending(promise, label) {
+  let settled = false;
+  promise.then(() => { settled = true; }, () => { settled = true; });
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.strictEqual(settled, false, label);
+}
+
+function stageGate(name, calls, action = null) {
+  const entered = deferred();
+  const release = deferred();
+  return {
+    entered,
+    release,
+    async hook(...args) {
+      calls.push(name);
+      entered.resolve(args);
+      await release.promise;
+      if (action) return action(...args);
+      return undefined;
+    },
+  };
+}
+
+function providerFactory(kind, runtime) {
+  const ownCredentials = kind === "claude"
+    ? { ANTHROPIC_API_KEY: "fixture-anthropic-present", CLAUDE_CODE_OAUTH_TOKEN: "fixture-claude-present" }
+    : { OPENAI_API_KEY: "fixture-openai-present" };
+  const options = {
+    hookTransport: false,
+    resolveExecutable: () => fixture,
+    defaultModel: `${kind}-parity-model`,
+    buildEnv: () => ({
+      HOME: runtime.root,
+      PATH: process.env.PATH || path.dirname(process.execPath),
+      FAKE_AGENT_KIND: kind,
+      FAKE_AGENT_CAPTURE: runtime.capture,
+      FAKE_AGENT_SCENARIO: runtime.scenario || "success",
+      FAKE_AGENT_TEXT: "provider-neutral parity reply",
+      FAKE_AGENT_TOOL: runtime.tool === false ? "0" : "1",
+      FAKE_AGENT_CHUNK_MODE: runtime.chunkMode || "lines",
+      FAKE_AGENT_CHUNK_DELAY_MS: "5",
+      FAKE_AGENT_FINAL_NEWLINE: runtime.finalNewline === false ? "0" : "1",
+      FAKE_AGENT_LINE_ENDING: runtime.lineEnding || "lf",
+      FAKE_AGENT_DUPLICATE_TERMINAL: runtime.duplicateTerminal ? "1" : "0",
+      FAKE_AGENT_CLOSE_DELAY_MS: String(runtime.closeDelayMs || 0),
+      ...ownCredentials,
+    }),
+    getAuthStatus: () => ({ state: "authenticated", reason: null }),
+  };
+  if (kind === "claude") return require("./core/providers/claude").createClaudeProvider(options);
+  return require("./core/providers/codex").createCodexProvider(options);
+}
+
+function promptBundle(prompt, { runContext }) {
+  return {
+    coreInstructions: "OPEN CLAUDIA CORE POLICY SENTINEL",
+    dynamicContext: [
+      `DYNAMIC PROJECT ${runContext.project.name}`,
+      "MEMORY RECALL SENTINEL",
+      "SPEAKER AND DELIVERY SENTINEL",
+    ].join("\n"),
+    userPrompt: prompt,
+    transcriptPaths: { transcriptsDir: path.join(runContext.project.dir, ".transcripts") },
+    recallMetadata: { status: "included", omitted: false, packDirs: ["fixture-pack"] },
+  };
+}
+
+function captureRecord(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function invocationHasResume(kind, argv) {
+  return kind === "claude" ? argv.includes("--resume") : argv[0] === "exec" && argv[1] === "resume";
+}
+
+function invocationHasContinue(kind, argv) {
+  return kind === "claude" ? argv.includes("--continue") : argv[0] === "exec" && argv[1] === "resume";
+}
+
+async function runProviderWorkflow(kind) {
+  assert.ok(["claude", "codex"].includes(kind));
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), `open-claudia-parity-${kind}-`));
+  const projectA = path.join(root, "project-a");
+  const projectB = path.join(root, "project-b");
+  fs.mkdirSync(projectA);
+  fs.mkdirSync(projectB);
+  const runtime = {
+    root,
+    capture: path.join(root, "fresh.json"),
+    scenario: "success",
+    chunkMode: "split",
+    finalNewline: false,
+    duplicateTerminal: true,
+    closeDelayMs: 40,
+  };
+  const provider = providerFactory(kind, runtime);
+  const otherKind = kind === "claude" ? "codex" : "claude";
+  const state = {
+    userId: "fixture-user",
+    currentSession: { name: "project-a", dir: projectA },
+    settings: { backend: kind, model: `${kind}-parity-model`, permissionMode: "plan" },
+    activeSessions: { "project-a": { [kind]: `${kind}-existing-session` } },
+    providerSettings: {
+      [kind]: {
+        model: `${kind}-parity-model`,
+        effort: "medium",
+        budget: null,
+        permissionMode: "plan",
+        worktree: false,
+      },
+    },
+    lastInputWasVoice: false,
+  };
+  let wrongProviderLookups = 0;
+  const resolveProvider = (id) => {
+    if (id !== kind) {
+      wrongProviderLookups += 1;
+      throw Object.assign(new Error(`provider ${id} is not installed in ${kind}-only matrix`), { code: "UNKNOWN_PROVIDER" });
+    }
+    return provider;
+  };
+
+  const calls = [];
+  const normalizedEvents = [];
+  const deliveries = [];
+  const cleanup = stageGate("cleanup", calls);
+  const transcript = stageGate("transcript", calls);
+  const usage = stageGate("usage", calls);
+  const session = stageGate("session", calls, (result, runContext) => {
+    state.activeSessions[runContext.project.name] ||= {};
+    state.activeSessions[runContext.project.name][runContext.provider] = result.sessionId;
+  });
+  const delivery = stageGate("delivery", calls, (result) => {
+    deliveries.push({ ok: result.ok, text: result.text });
+    return { ok: true };
+  });
+  const service = require("./core/runner").createRunnerService({
+    getState: () => state,
+    getStore: () => ({ channelId: "fixture-channel", transport: "telegram" }),
+    resolveProvider,
+    buildTurnPrompt: promptBundle,
+    cleanup: cleanup.hook,
+    persistTranscript: transcript.hook,
+    persistUsage: usage.hook,
+    persistSession: session.hook,
+    deliver: delivery.hook,
+    onEvent: (event) => normalizedEvents.push(event.type),
+  });
+
+  const freshPromise = service.runAgent("FRESH USER SENTINEL", projectA, "message-1", {
+    fresh: true,
+    runId: `${kind}-fresh-run`,
+  });
+  await timeoutAfter(cleanup.entered.promise, 5000, `${kind} cleanup admission`);
+  await assertPending(freshPromise, `${kind}: RunResult waits for cleanup`);
+  cleanup.release.resolve();
+  await timeoutAfter(transcript.entered.promise, 2000, `${kind} transcript persistence`);
+  await assertPending(freshPromise, `${kind}: RunResult waits for transcript persistence`);
+  transcript.release.resolve();
+  await timeoutAfter(usage.entered.promise, 2000, `${kind} usage persistence`);
+  await assertPending(freshPromise, `${kind}: RunResult waits for usage persistence`);
+  usage.release.resolve();
+  await timeoutAfter(session.entered.promise, 2000, `${kind} session persistence`);
+  await assertPending(freshPromise, `${kind}: RunResult waits for session persistence`);
+  session.release.resolve();
+  await timeoutAfter(delivery.entered.promise, 2000, `${kind} delivery settlement`);
+  await assertPending(freshPromise, `${kind}: RunResult waits for required delivery`);
+  delivery.release.resolve();
+  const fresh = await timeoutAfter(freshPromise, 2000, `${kind} fresh terminal result`);
+
+  assert.strictEqual(fresh.ok, true);
+  assert.strictEqual(fresh.status, "succeeded");
+  assert.strictEqual(fresh.text, "provider-neutral parity reply");
+  assert.strictEqual(fresh.terminalSeen, true);
+  assert.strictEqual(fresh.stdoutEnded, true);
+  assert.strictEqual(normalizedEvents.filter((type) => type === "result").length, 1, `${kind}: duplicate terminal event is normalized once`);
+  assert.deepStrictEqual(normalizedEvents.filter((type) => type === "tool_start" || type === "tool_end"), ["tool_start", "tool_end"]);
+  assert.deepStrictEqual(calls, ["cleanup", "transcript", "usage", "session", "delivery"]);
+  assert.deepStrictEqual(deliveries, [{ ok: true, text: "provider-neutral parity reply" }]);
+
+  const freshCapture = captureRecord(runtime.capture);
+  const argvText = freshCapture.argv.join("\n");
+  assert.match(argvText, /OPEN CLAUDIA CORE POLICY SENTINEL/);
+  assert.match(argvText, /DYNAMIC PROJECT project-a/);
+  assert.match(argvText, /MEMORY RECALL SENTINEL/);
+  assert.match(argvText, /FRESH USER SENTINEL/);
+  assert.strictEqual(invocationHasResume(kind, freshCapture.argv), false);
+  const ownCredentialPresent = kind === "claude"
+    ? freshCapture.envPresence.ANTHROPIC_API_KEY && freshCapture.envPresence.CLAUDE_CODE_OAUTH_TOKEN
+    : freshCapture.envPresence.OPENAI_API_KEY;
+  const crossCredentialAbsent = kind === "claude"
+    ? !freshCapture.envPresence.OPENAI_API_KEY
+    : !freshCapture.envPresence.ANTHROPIC_API_KEY && !freshCapture.envPresence.CLAUDE_CODE_OAUTH_TOKEN;
+  assert.strictEqual(ownCredentialPresent, true);
+  assert.strictEqual(crossCredentialAbsent, true);
+  for (const key of ["TELEGRAM_BOT_TOKEN", "KAZEE_BOT_TOKEN", "BOT_CONTROL_TOKEN", "OC_SEND_TOKEN"]) {
+    assert.strictEqual(freshCapture.envPresence[key], false, `${kind}: ${key} must be absent`);
+  }
+
+  const captureEvents = [];
+  const captureService = require("./core/runner").createRunnerService({
+    getState: () => state,
+    getStore: () => ({ channelId: "fixture-channel", transport: "telegram" }),
+    resolveProvider,
+    buildTurnPrompt: promptBundle,
+    onEvent: (event) => captureEvents.push(event.type),
+  });
+
+  runtime.capture = path.join(root, "coalesced.json");
+  runtime.chunkMode = "coalesce";
+  runtime.lineEnding = "crlf";
+  runtime.finalNewline = false;
+  runtime.duplicateTerminal = false;
+  runtime.closeDelayMs = 0;
+  const coalesced = await captureService.runAgentCapture("COALESCED SENTINEL", projectA, { fresh: true });
+  assert.strictEqual(coalesced.ok, true);
+  assert.strictEqual(captureEvents.filter((type) => type === "result").length, 1);
+
+  runtime.capture = path.join(root, "resume.json");
+  runtime.chunkMode = "lines";
+  runtime.lineEnding = "lf";
+  const resume = await captureService.runAgentCapture("RESUME SENTINEL", projectA, {
+    resumeSessionId: fresh.sessionId,
+  });
+  assert.strictEqual(resume.ok, true);
+  assert.strictEqual(resume.sessionId, fresh.sessionId);
+  assert.strictEqual(invocationHasResume(kind, captureRecord(runtime.capture).argv), true);
+
+  runtime.capture = path.join(root, "continue.json");
+  const continued = await captureService.runAgentCapture("CONTINUE SENTINEL", projectA, {
+    continueSession: true,
+  });
+  assert.strictEqual(continued.ok, true);
+  assert.strictEqual(invocationHasContinue(kind, captureRecord(runtime.capture).argv), true);
+
+  runtime.capture = path.join(root, "race.json");
+  const promptEntered = deferred();
+  const promptRelease = deferred();
+  const raceService = require("./core/runner").createRunnerService({
+    getState: () => state,
+    getStore: () => ({ channelId: "fixture-channel", transport: "telegram" }),
+    resolveProvider,
+    async buildTurnPrompt(prompt, context) {
+      promptEntered.resolve(context.runContext);
+      await promptRelease.promise;
+      return promptBundle(prompt, context);
+    },
+  });
+  const expectedSession = state.activeSessions["project-a"][kind];
+  const racePromise = raceService.runAgentCapture("RACE SENTINEL", projectA);
+  const admitted = await timeoutAfter(promptEntered.promise, 2000, `${kind} immutable prompt wait`);
+  state.settings = { backend: otherKind, model: `${otherKind}-changed-model`, permissionMode: "plan" };
+  state.currentSession = { name: "project-b", dir: projectB };
+  state.activeSessions["project-a"][kind] = `${kind}-changed-after-admission`;
+  promptRelease.resolve();
+  const raced = await timeoutAfter(racePromise, 5000, `${kind} immutable race result`);
+  assert.strictEqual(raced.ok, true);
+  assert.strictEqual(raced.provider, kind);
+  assert.strictEqual(raced.project.name, "project-a");
+  assert.strictEqual(raced.admittedSessionId, expectedSession);
+  assert.strictEqual(admitted.providerSettings.model, `${kind}-parity-model`);
+  const raceArgv = captureRecord(runtime.capture).argv;
+  assert.ok(raceArgv.includes(expectedSession));
+  assert.ok(!raceArgv.includes(`${kind}-changed-after-admission`));
+  assert.strictEqual(wrongProviderLookups, 0);
+
+  state.settings = { backend: kind, model: `${kind}-parity-model`, permissionMode: "plan" };
+  state.currentSession = { name: "project-a", dir: projectA };
+  state.activeSessions["project-a"][kind] = expectedSession;
+
+  let mandatoryFailureSpawns = 0;
+  let mandatoryFailureDeliveries = 0;
+  const promptFailureService = require("./core/runner").createRunnerService({
+    getState: () => state,
+    resolveProvider,
+    buildTurnPrompt() {
+      throw Object.assign(new Error("mandatory prompt construction failed"), { code: "MANDATORY_PROMPT_FAILED" });
+    },
+    spawnProcess() { mandatoryFailureSpawns += 1; throw new Error("must not spawn"); },
+    deliver: async () => { mandatoryFailureDeliveries += 1; return { ok: true }; },
+  });
+  const promptFailure = await promptFailureService.runAgent("RAW USER FALLBACK MUST NOT RUN", projectA, null, { fresh: true });
+  assert.strictEqual(promptFailure.ok, false);
+  assert.strictEqual(promptFailure.error.code, "MANDATORY_PROMPT_FAILED");
+  assert.strictEqual(mandatoryFailureSpawns, 0);
+  assert.strictEqual(mandatoryFailureDeliveries, 1);
+
+  runtime.capture = path.join(root, "auth-failure.json");
+  runtime.scenario = "auth-failure";
+  const authFailure = await captureService.runAgentCapture("AUTH FAILURE SENTINEL", projectA, { fresh: true });
+  assert.strictEqual(authFailure.ok, false);
+  assert.strictEqual(authFailure.error.code, "PROVIDER_UNAUTHENTICATED");
+  assert.match(authFailure.diagnostic, /authentication failed/i);
+  runtime.scenario = "success";
+
+  let hookFailureSpawns = 0;
+  const hookFailureService = require("./core/runner").createRunnerService({
+    getState: () => state,
+    resolveProvider,
+    buildTurnPrompt: promptBundle,
+    buildInvocation() {
+      throw Object.assign(new Error("mandatory provider tool hook failed to initialize"), { code: "TOOL_HOOK_INIT_FAILED" });
+    },
+    spawnProcess() { hookFailureSpawns += 1; throw new Error("must not spawn"); },
+  });
+  const hookFailure = await hookFailureService.runAgentCapture("HOOK FAILURE SENTINEL", projectA, { fresh: true });
+  assert.strictEqual(hookFailure.ok, false);
+  assert.strictEqual(hookFailure.error.code, "TOOL_HOOK_INIT_FAILED");
+  assert.strictEqual(hookFailureSpawns, 0);
+
+  const semantic = {
+    promptPolicyInjected: true,
+    splitAndCoalesced: true,
+    normalizedTerminalResults: 1,
+    toolProgress: ["tool_start", "tool_end"],
+    finalDeliveries: deliveries.length,
+    immutableAdmission: true,
+    lifecycleOrder: calls,
+    freshResumeContinue: true,
+    promptFailureCode: promptFailure.error.code,
+    authFailureCode: authFailure.error.code,
+    credentialBoundary: true,
+    hookFailureCode: hookFailure.error.code,
+  };
+  const nativeDifferences = {
+    provider: kind,
+    sessionId: fresh.sessionId,
+    toolName: fresh.tools.find((event) => event.type === "tool_start")?.name || null,
+    budgetSupport: provider.capabilities.budget.support,
+    maxTurnsSupport: provider.capabilities.maxTurns.support,
+  };
+  fs.rmSync(root, { recursive: true, force: true });
+  return { provider: kind, scenarios: [1, 2, 3, 4, 5, 6, 19, 20, 21], semantic, nativeDifferences };
+}
+
+function isolatedEnv(root, provider = null) {
+  const env = {
+    PATH: process.env.PATH || path.dirname(process.execPath),
+    HOME: path.join(root, "home"),
+    TMPDIR: process.env.TMPDIR || os.tmpdir(),
+    LANG: process.env.LANG || "C.UTF-8",
+    LC_ALL: process.env.LC_ALL || "C.UTF-8",
+    OPEN_CLAUDIA_TEST: "1",
+    OPEN_CLAUDIA_CONFIG_DIR: path.join(root, "config"),
+    WORKSPACE: path.join(root, "workspace"),
+    CHANNELS: "",
+    TELEGRAM_CHAT_ID: "fixture",
+    CLAUDE_PATH: path.join(root, "unavailable-claude"),
+    CODEX_PATH: path.join(root, "unavailable-codex"),
+  };
+  if (provider === "claude") env.CLAUDE_PATH = fixture;
+  if (provider === "codex") env.CODEX_PATH = fixture;
+  if (provider) env.PARITY_PROVIDER_ONLY = provider;
+  return env;
+}
+
+function runProviderChild(kind) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), `open-claudia-parity-child-${kind}-`));
+  try {
+    fs.mkdirSync(path.join(root, "home"));
+    fs.mkdirSync(path.join(root, "workspace"));
+    const child = spawnSync(process.execPath, [__filename, "--provider", kind], {
+      cwd: repoRoot,
+      env: isolatedEnv(root, kind),
+      encoding: "utf8",
+      timeout: 20 * 60 * 1000,
+      maxBuffer: 4 * 1024 * 1024,
+    });
+    assert.ifError(child.error);
+    assert.strictEqual(child.status, 0, child.stderr || child.stdout);
+    const marker = child.stdout.split(/\r?\n/).find((line) => line.startsWith("PARITY_PROVIDER:"));
+    assert.ok(marker, `${kind}: provider ledger missing`);
+    return JSON.parse(marker.slice("PARITY_PROVIDER:".length));
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+function runSupportSuites(provider) {
+  assert.ok(["claude", "codex"].includes(provider));
+  const passed = new Set();
+  for (const [key, [script, marker]] of Object.entries(SUPPORT_SUITES)) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), `open-claudia-parity-suite-${key}-`));
+    try {
+      fs.mkdirSync(path.join(root, "home"));
+      fs.mkdirSync(path.join(root, "workspace"));
+      const result = spawnSync(process.execPath, [script], {
+        cwd: repoRoot,
+        env: isolatedEnv(root, provider),
+        encoding: "utf8",
+        timeout: 90000,
+        maxBuffer: 8 * 1024 * 1024,
+      });
+      assert.ifError(result.error);
+      assert.strictEqual(result.status, 0, `${script}\n${result.stderr || result.stdout}`);
+      assert.ok(`${result.stdout}\n${result.stderr}`.includes(marker), `${script}: missing ${marker}`);
+      passed.add(key);
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  }
+  return passed;
+}
+
+async function childMain(kind) {
+  const otherKind = kind === "claude" ? "codex" : "claude";
+  const { providerExecutableStatus } = require("./core/config");
+  const selectedStatus = providerExecutableStatus(kind);
+  const otherStatus = providerExecutableStatus(otherKind);
+  assert.strictEqual(selectedStatus.state, "available", `${kind} fixture must be the only discoverable provider`);
+  assert.strictEqual(otherStatus.state, "missing", `${otherKind} must be unavailable in the ${kind}-only matrix`);
+  const ledger = await runProviderWorkflow(kind);
+  const passed = runSupportSuites(kind);
+  for (const scenario of SCENARIOS) {
+    for (const evidence of scenario.evidence) {
+      assert.ok(passed.has(evidence), `${kind} scenario ${scenario.id} missing ${evidence} evidence`);
+    }
+  }
+  ledger.directScenarios = ledger.scenarios;
+  ledger.scenarios = SCENARIOS.map((scenario) => scenario.id);
+  ledger.supportEvidence = [...passed].sort();
+  ledger.discovery = { selected: selectedStatus.state, other: otherStatus.state };
+  process.stdout.write(`PARITY_PROVIDER:${JSON.stringify(ledger)}\n`);
+}
+
+function parentMain() {
+  assert.ok(fs.existsSync(fixture));
+  assert.deepStrictEqual(SCENARIOS.map((scenario) => scenario.id), Array.from({ length: 23 }, (_, index) => index + 1));
+  for (const scenario of SCENARIOS) {
+    assert.ok(scenario.evidence.length > 0, `scenario ${scenario.id} requires evidence`);
+    for (const key of scenario.evidence) assert.ok(SUPPORT_SUITES[key], `scenario ${scenario.id}: unknown evidence ${key}`);
+  }
+
+  const claude = runProviderChild("claude");
+  const codex = runProviderChild("codex");
+  assert.deepStrictEqual(claude.scenarios, SCENARIOS.map((scenario) => scenario.id));
+  assert.deepStrictEqual(claude.scenarios, codex.scenarios);
+  assert.deepStrictEqual(claude.directScenarios, codex.directScenarios);
+  assert.deepStrictEqual(claude.supportEvidence, codex.supportEvidence);
+  assert.deepStrictEqual(claude.discovery, { selected: "available", other: "missing" });
+  assert.deepStrictEqual(codex.discovery, { selected: "available", other: "missing" });
+  assert.deepStrictEqual(claude.semantic, codex.semantic, "provider-neutral foreground ledgers must match");
+  assert.notStrictEqual(claude.nativeDifferences.provider, codex.nativeDifferences.provider);
+  assert.notStrictEqual(claude.nativeDifferences.sessionId, codex.nativeDifferences.sessionId);
+  assert.notStrictEqual(claude.nativeDifferences.toolName, codex.nativeDifferences.toolName);
+  assert.strictEqual(claude.nativeDifferences.budgetSupport, "native");
+  assert.strictEqual(codex.nativeDifferences.budgetSupport, "unsupported");
+
+  console.log("provider parity e2e OK");
+}
+
+if (process.argv[2] === "--provider") {
+  childMain(process.argv[3]).catch((error) => {
+    console.error(error.stack || error.message);
+    process.exitCode = 1;
+  });
+} else {
+  parentMain();
+}

package/test-provider-prompt-parity.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const baselinePath = path.join(__dirname, "test-fixtures", "current-provider-parity.json");
+assert.ok(fs.existsSync(baselinePath), "current provider-parity baseline fixture must exist");
+const baseline = JSON.parse(fs.readFileSync(baselinePath, "utf8"));
+
+async function probe() {
+  const { buildTurnPrompt } = require("./core/system-prompt");
+  const { getProvider } = require("./core/providers");
+  const { currentState } = require("./core/state");
+  const state = currentState();
+  state.currentSession = { name: "parity-project", dir: process.env.WORKSPACE };
+  state.settings = { ...state.settings, backend: "codex" };
+  state.activeSessions["parity-project"] = { codex: "parity-thread" };
+  const bundle = await buildTurnPrompt(baseline.prompt.sentinel, {
+    provider: getProvider("codex"),
+    runContext: {
+      canonicalUserId: state.userId,
+      project: { ...state.currentSession },
+      provider: "codex",
+      providerSettings: { ...state.settings },
+      sessionId: state.activeSessions["parity-project"].codex,
+      channelId: "parity-channel",
+      origin: { transport: "telegram", channelId: "parity-channel" },
+    },
+  });
+  process.stdout.write(`${JSON.stringify({ bundle })}\n`);
+}
+
+if (process.argv[2] === "--probe") {
+  probe().catch((error) => {
+    console.error(error.stack || error.message);
+    process.exit(1);
+  });
+} else {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "open-claudia-prompt-parity-"));
+  const workspace = path.join(root, "workspace");
+  const configDir = path.join(root, "config");
+  fs.mkdirSync(workspace);
+  fs.mkdirSync(configDir);
+  fs.writeFileSync(path.join(configDir, "soul.md"), "# Soul\n\nOpen Claudia prompt parity fixture policy.\n");
+  const env = {
+    HOME: root,
+    PATH: path.dirname(process.execPath),
+    TMPDIR: process.env.TMPDIR || os.tmpdir(),
+    TZ: "UTC",
+    OPEN_CLAUDIA_TEST: "1",
+    OPEN_CLAUDIA_CONFIG_DIR: configDir,
+    RECALL_DEBUG: "0",
+    WORKSPACE: workspace,
+    CLAUDE_PATH: process.execPath,
+  };
+
+  try {
+    const child = spawnSync(process.execPath, [__filename, "--probe"], {
+      cwd: __dirname,
+      env,
+      encoding: "utf8",
+      timeout: 15000,
+      maxBuffer: 1024 * 1024,
+    });
+    assert.ifError(child.error);
+    assert.strictEqual(child.status, 0, child.stderr || "prompt probe failed");
+    const lines = child.stdout.trim().split("\n").filter(Boolean);
+    const observed = JSON.parse(lines.at(-1));
+
+    assert.strictEqual(baseline.prompt.invertInTask, 8);
+    assert.strictEqual(observed.bundle.userPrompt, baseline.prompt.sentinel);
+    assert.ok(observed.bundle.coreInstructions.includes("Open Claudia"));
+    assert.ok(observed.bundle.dynamicContext.includes("## Runtime state (current turn)"));
+    assert.ok(observed.bundle.dynamicContext.includes("## Project Transcript Memory"));
+    assert.ok(observed.bundle.dynamicContext.includes("Codex exposes its native exec tools"));
+    assert.ok(observed.bundle.recallMetadata);
+    assert.notStrictEqual(
+      `${observed.bundle.dynamicContext}\n\n${observed.bundle.userPrompt}`,
+      baseline.prompt.sentinel,
+      "Codex must receive the complete dynamic context, not only the raw user sentinel",
+    );
+    console.log("provider prompt parity OK");
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}