@inetafrica/open-claudia 2.15.0 → 3.0.1

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);
+});

package/test-provider-core-prompt.js

@@ -0,0 +1,264 @@
+#!/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");
+
+async function probe() {
+  const {
+    PromptConstructionError,
+    buildTurnPrompt,
+    createPromptBuilder,
+    promptDedupeIdentity,
+  } = require("./core/system-prompt");
+  const { getProvider } = require("./core/providers");
+  const { runInChat } = require("./core/context");
+  const { currentState } = require("./core/state");
+
+  assert.strictEqual(typeof buildTurnPrompt, "function");
+  assert.strictEqual(typeof createPromptBuilder, "function");
+  assert.strictEqual(typeof promptDedupeIdentity, "function");
+
+  const adapter = {
+    id: "telegram-fixture",
+    type: "telegram",
+    send: async () => "fixture-message",
+    typing: async () => {},
+  };
+
+  await runInChat({
+    adapter,
+    channelId: "fixture-channel",
+    canonicalUserId: "fixture-user",
+    userId: "fixture-channel",
+    transport: "telegram",
+    raw: null,
+  }, async () => {
+    const state = currentState();
+    state.currentSession = { name: "fixture-project", dir: process.env.WORKSPACE };
+    state.settings = { ...state.settings, backend: "claude" };
+    state.activeSessions["fixture-project"] = { claude: "claude-session", codex: "codex-session" };
+
+    let recallCalls = 0;
+    const promptBuilder = createPromptBuilder({
+      async buildRecallContext() {
+        recallCalls += 1;
+        return {
+          dynamicContext: [
+            "## Active Open Claudia skills / context packs",
+            "PACK CONTEXT SENTINEL",
+            "## Known entities",
+            "ENTITY CONTEXT SENTINEL",
+            "## Tools that may help here",
+            "TOOL CONTEXT SENTINEL",
+          ].join("\n"),
+          metadata: { status: "included", engine: "fixture", omitted: false },
+        };
+      },
+    });
+
+    const common = {
+      canonicalUserId: "fixture-user",
+      project: { name: "fixture-project", dir: process.env.WORKSPACE },
+      providerSettings: { model: null, effort: null, permissionMode: null },
+      channelId: "fixture-channel",
+      origin: { transport: "telegram", channelId: "fixture-channel" },
+    };
+    const claudeContext = { ...common, provider: "claude", sessionId: "claude-session" };
+    const codexContext = { ...common, provider: "codex", sessionId: "codex-session" };
+
+    const claude = await promptBuilder.buildTurnPrompt("FIRST USER SENTINEL", {
+      runContext: claudeContext,
+      provider: getProvider("claude"),
+    });
+    const codex = await promptBuilder.buildTurnPrompt("SECOND USER SENTINEL", {
+      runContext: codexContext,
+      provider: getProvider("codex"),
+    });
+
+    for (const bundle of [claude, codex]) {
+      assert.strictEqual(typeof bundle.coreInstructions, "string");
+      assert.strictEqual(typeof bundle.dynamicContext, "string");
+      assert.ok(bundle.coreInstructions.includes("SOUL POLICY SENTINEL"), "soul is mandatory core policy");
+      assert.ok(bundle.coreInstructions.includes("PERSONA SENTINEL"), "persona is included in core policy");
+      assert.ok(bundle.coreInstructions.includes("LESSON SENTINEL"), "lessons are included in core policy");
+      assert.ok(bundle.coreInstructions.includes("## Delivery"), "delivery guidance is mandatory");
+      assert.ok(bundle.coreInstructions.includes("## Background work"), "scheduler guidance is mandatory");
+      assert.ok(bundle.coreInstructions.includes("Persistent todo list"), "task guidance is mandatory");
+      assert.ok(bundle.coreInstructions.includes("## Tools are"), "tool guidance is mandatory");
+      assert.ok(bundle.coreInstructions.includes("channel context is already in the env"), "gateway guidance is mandatory");
+      assert.ok(bundle.dynamicContext.includes("## Runtime state (current turn)"));
+      assert.ok(bundle.dynamicContext.includes("## Project Transcript Memory"));
+      assert.ok(bundle.dynamicContext.includes("## Speaker"));
+      assert.ok(bundle.dynamicContext.includes("PACK CONTEXT SENTINEL"));
+      assert.ok(bundle.dynamicContext.includes("ENTITY CONTEXT SENTINEL"));
+      assert.ok(bundle.dynamicContext.includes("TOOL CONTEXT SENTINEL"));
+      assert.deepStrictEqual(bundle.recallMetadata, { status: "included", engine: "fixture", omitted: false });
+      assert.ok(bundle.transcriptPaths && bundle.transcriptPaths.transcriptPath);
+      assert.ok(!bundle.coreInstructions.includes("Claude Code harness"));
+      assert.ok(!bundle.dynamicContext.includes("Claude Code harness"));
+    }
+
+    assert.strictEqual(claude.coreInstructions, codex.coreInstructions, "provider-neutral core is byte-identical");
+    assert.notStrictEqual(claude.userPrompt, codex.userPrompt, "the user prompt remains per-turn data");
+    assert.ok(claude.dynamicContext.includes(getProvider("claude").nativeToolsNote));
+    assert.ok(codex.dynamicContext.includes(getProvider("codex").nativeToolsNote));
+    assert.ok(!claude.dynamicContext.includes(getProvider("codex").nativeToolsNote));
+    assert.strictEqual(recallCalls, 2);
+
+    const again = await promptBuilder.buildTurnPrompt("THIRD USER SENTINEL", {
+      runContext: claudeContext,
+      provider: getProvider("claude"),
+    });
+    assert.strictEqual(again.coreInstructions, claude.coreInstructions, "core instructions stay byte-stable within a session");
+
+    const identityA = promptDedupeIdentity({ runContext: claudeContext });
+    const identityB = promptDedupeIdentity({ runContext: { ...claudeContext, sessionId: "next-session" } });
+    const identityC = promptDedupeIdentity({ runContext: { ...claudeContext, provider: "codex" } });
+    const identityD = promptDedupeIdentity({ runContext: { ...claudeContext, project: { name: "other", dir: "/other" } } });
+    assert.notStrictEqual(identityA, identityB, "session participates in dedupe identity");
+    assert.notStrictEqual(identityA, identityC, "provider participates in dedupe identity");
+    assert.notStrictEqual(identityA, identityD, "project participates in dedupe identity");
+    assert.notStrictEqual(
+      promptDedupeIdentity({ runContext: { ...claudeContext, sessionId: null, runId: "new-run-1" } }),
+      promptDedupeIdentity({ runContext: { ...claudeContext, sessionId: null, runId: "new-run-2" } }),
+      "separate admitted runs cannot share the pre-session dedupe bucket",
+    );
+
+    const brokenMandatory = createPromptBuilder({
+      buildCoreInstructions() { throw new Error("fixture mandatory failure"); },
+    });
+    await assert.rejects(
+      () => brokenMandatory.buildTurnPrompt("RAW MUST NOT ESCAPE", {
+        runContext: claudeContext,
+        provider: getProvider("claude"),
+      }),
+      (error) => error instanceof PromptConstructionError
+        && error.code === "PROMPT_CONSTRUCTION_FAILED"
+        && error.stage === "coreInstructions"
+        && !String(error.bundle || "").includes("RAW MUST NOT ESCAPE"),
+    );
+
+    const brokenSpeaker = createPromptBuilder({
+      buildSpeakerContext() { throw new Error("fixture speaker failure"); },
+    });
+    await assert.rejects(
+      () => brokenSpeaker.buildTurnPrompt("RAW MUST NOT ESCAPE", {
+        runContext: claudeContext,
+        provider: getProvider("claude"),
+      }),
+      (error) => error instanceof PromptConstructionError && error.stage === "speakerContext",
+    );
+
+    const recallFailOpen = createPromptBuilder({
+      async buildRecallContext() { throw new Error("fixture optional recall failure"); },
+    });
+    const omitted = await recallFailOpen.buildTurnPrompt("RECALL FAILURE USER SENTINEL", {
+      runContext: claudeContext,
+      provider: getProvider("claude"),
+    });
+    assert.strictEqual(omitted.userPrompt, "RECALL FAILURE USER SENTINEL");
+    assert.strictEqual(omitted.recallMetadata.status, "omitted");
+    assert.strictEqual(omitted.recallMetadata.omitted, true);
+    assert.ok(omitted.coreInstructions.includes("## Delivery"));
+    assert.ok(omitted.dynamicContext.includes("## Runtime state"));
+
+    const concurrent = createPromptBuilder({
+      async buildRecallContext(prompt) {
+        await new Promise((resolve) => setTimeout(resolve, prompt.startsWith("SLOW") ? 20 : 1));
+        return {
+          dynamicContext: `RECALL ${prompt}`,
+          metadata: { status: "included", omitted: false, marker: prompt },
+        };
+      },
+    });
+    const [slow, fast] = await Promise.all([
+      concurrent.buildTurnPrompt("SLOW RECALL", { runContext: claudeContext, provider: getProvider("claude") }),
+      concurrent.buildTurnPrompt("FAST RECALL", { runContext: codexContext, provider: getProvider("codex") }),
+    ]);
+    assert.strictEqual(slow.recallMetadata.marker, "SLOW RECALL");
+    assert.strictEqual(fast.recallMetadata.marker, "FAST RECALL");
+    assert.ok(slow.dynamicContext.includes("RECALL SLOW RECALL"));
+    assert.ok(fast.dynamicContext.includes("RECALL FAST RECALL"));
+  });
+}
+
+if (process.argv[2] === "--probe") {
+  probe().then(() => console.log("provider core prompt OK")).catch((error) => {
+    console.error(error.stack || error.message);
+    process.exit(1);
+  });
+} else {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "open-claudia-core-prompt-"));
+  const configDir = path.join(root, "config");
+  const workspace = path.join(root, "workspace");
+  fs.mkdirSync(configDir, { recursive: true });
+  fs.mkdirSync(workspace, { recursive: true });
+  fs.writeFileSync(path.join(configDir, "soul.md"), "SOUL POLICY SENTINEL\n");
+  fs.writeFileSync(path.join(configDir, "persona.md"), "PERSONA SENTINEL — warm, direct, careful, and consistent across every supported provider.\n");
+  fs.writeFileSync(path.join(configDir, "lessons.md"), "- LESSON SENTINEL (src: fixture-pack)\n");
+  fs.writeFileSync(path.join(configDir, "people.json"), JSON.stringify([{
+    id: "fixture-person",
+    name: "Fixture Speaker",
+    isOwner: true,
+    bio: "Prompt parity tester",
+    handles: [{ adapter: "telegram", channelId: "fixture-channel", canonicalUserId: "fixture-user" }],
+    notes: [],
+    primaryChannel: { adapter: "telegram", channelId: "fixture-channel" },
+  }]));
+
+  const childEnv = {
+      HOME: root,
+      PATH: path.dirname(process.execPath),
+      TMPDIR: process.env.TMPDIR || os.tmpdir(),
+      TZ: "UTC",
+      OPEN_CLAUDIA_TEST: "1",
+      OPEN_CLAUDIA_CONFIG_DIR: configDir,
+      PROJECT_TRANSCRIPTS: "1",
+      RECALL_DEBUG: "0",
+      WORKSPACE: workspace,
+      CLAUDE_PATH: process.execPath,
+      CODEX_PATH: process.execPath,
+  };
+  const child = spawnSync(process.execPath, [__filename, "--probe"], {
+    cwd: __dirname,
+    env: childEnv,
+    encoding: "utf8",
+    timeout: 20000,
+    maxBuffer: 2 * 1024 * 1024,
+  });
+  try {
+    assert.ifError(child.error);
+    assert.strictEqual(child.status, 0, child.stderr || "provider core prompt probe failed");
+    assert.match(child.stdout, /provider core prompt OK/);
+    process.stdout.write(child.stdout);
+
+    const failureProbe = [
+      "const { createPromptBuilder } = require('./core/system-prompt');",
+      "const state = { userId: 'fixture-user', currentSession: { name: 'fixture', dir: process.cwd() }, settings: { backend: 'claude' }, activeSessions: {}, providerSettings: {} };",
+      "const runContext = { canonicalUserId: 'fixture-user', project: { name: 'fixture', dir: process.cwd() }, provider: 'claude', sessionId: null, runId: 'failure-probe' };",
+      "createPromptBuilder().buildTurnPrompt('RAW MUST NOT ESCAPE', { state, runContext, provider: { id: 'claude', nativeToolsNote: 'fixture' } }).then(() => process.exit(2), (error) => {",
+      "  if (error.code !== 'PROMPT_CONSTRUCTION_FAILED' || error.stage !== 'coreInstructions' || String(error.bundle || '').includes('RAW MUST NOT ESCAPE')) process.exit(3);",
+      "  process.stdout.write('mandatory soul failure closed\\n');",
+      "});",
+    ].join("\n");
+    for (const contents of [null, ""]) {
+      if (contents === null) fs.rmSync(path.join(configDir, "soul.md"), { force: true });
+      else fs.writeFileSync(path.join(configDir, "soul.md"), contents);
+      const failed = spawnSync(process.execPath, ["-e", failureProbe], {
+        cwd: __dirname,
+        env: childEnv,
+        encoding: "utf8",
+        timeout: 20000,
+      });
+      assert.strictEqual(failed.status, 0, failed.stderr || "missing/empty soul must fail closed");
+      assert.match(failed.stdout, /mandatory soul failure closed/);
+    }
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}