@inetafrica/open-claudia 2.15.0 → 3.0.0

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

package/test-provider-coupling-audit.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const path = require("path");
+
+const root = __dirname;
+
+function read(relativePath) {
+  return fs.readFileSync(path.join(root, relativePath), "utf8");
+}
+
+function sourceFiles(relativePath) {
+  const absolute = path.join(root, relativePath);
+  if (!fs.statSync(absolute).isDirectory()) return [relativePath];
+  return fs.readdirSync(absolute, { withFileTypes: true }).flatMap((entry) => {
+    const child = path.join(relativePath, entry.name);
+    if (entry.isDirectory()) return sourceFiles(child);
+    return entry.isFile() && child.endsWith(".js") ? [child] : [];
+  });
+}
+
+const activeFiles = [
+  ...sourceFiles("core"),
+  ...sourceFiles("bin"),
+  ...sourceFiles("channels"),
+  "bot.js",
+  "bot-agent.js",
+  "health.js",
+  "setup.js",
+  "web.js",
+];
+const activeSource = Object.fromEntries(activeFiles.map((file) => [file, read(file)]));
+
+function matches(pattern, allow = new Set()) {
+  return Object.entries(activeSource)
+    .filter(([file, source]) => !allow.has(file) && pattern.test(source))
+    .map(([file]) => file);
+}
+
+assert.deepStrictEqual(matches(/\brunClaude(?:Capture|Silent)?\b/), [], "deprecated runner names must be removed");
+assert.deepStrictEqual(matches(/\bbuildClaudeArgs\b/), [], "provider argv construction belongs only in adapters");
+assert.deepStrictEqual(matches(/\brunLegacy(?:Capture|Foreground|Silent)\b/), [], "the dead legacy runner must be deleted");
+assert.deepStrictEqual(matches(/\bDEFAULT_CLAUDE_MODEL\b/), [], "Claude's default model belongs inside its adapter");
+assert.deepStrictEqual(
+  matches(/\bspawnSubagent\b/, new Set(["core/subagent.js"])),
+  [],
+  "direct utility callers must not bypass the provider-neutral utility service",
+);
+
+const claudePathAllowlist = new Set([
+  "core/auth-flow.js",
+  "core/config.js",
+  "core/provider-status.js",
+  "core/providers/claude.js",
+  "setup.js",
+  "web.js",
+]);
+assert.deepStrictEqual(matches(/\bCLAUDE_PATH\b/, claudePathAllowlist), [], "CLAUDE_PATH leaked outside Claude auth/setup scope");
+
+for (const file of ["core/runner.js", "core/run-context.js", "core/system-prompt.js", "core/handlers.js", "core/actions.js"]) {
+  assert.doesNotMatch(
+    activeSource[file],
+    /\b(?:lastSessionId|codexSessionId|cursorSessionId)\b/,
+    `${file} must use provider/project session helpers`,
+  );
+}
+assert.doesNotMatch(
+  activeSource["core/state.js"],
+  /Object\.defineProperty\(state,\s*legacyKey/,
+  "migration aliases must not become live runtime accessors",
+);
+assert.doesNotMatch(activeSource["core/run-context.js"], /\bsessionKey\b/, "run admission stores provider identity, not a legacy pointer key");
+
+assert.doesNotMatch(activeSource["core/state.js"], /function normalizeProviderId\(providerId, fallback = ["']claude["']\)/);
+assert.doesNotMatch(activeSource["core/state.js"], /:\s*["']claude["'];\s*\n\s*if \(!Object\.prototype\.hasOwnProperty\.call\(settings, ["']compactWindow["']\)/);
+assert.doesNotMatch(activeSource["core/system-prompt.js"], /state\.settings\?\.backend \|\| ["']claude["']/);
+assert.doesNotMatch(activeSource["setup.js"], /providerId \|\| ["']claude["']/);
+
+const packageJson = JSON.parse(read("package.json"));
+assert.doesNotMatch(packageJson.scripts.test, /\bCLAUDE_PATH=node\b/, "the legacy suite cannot require Claude globally");
+
+const runner = require("./core/runner");
+for (const name of ["runClaude", "runClaudeCapture", "runClaudeSilent"]) {
+  assert.strictEqual(Object.prototype.hasOwnProperty.call(runner, name), false, `${name} export must be removed`);
+}
+
+console.log("provider coupling audit OK");

package/test-provider-dream.js

@@ -0,0 +1,312 @@
+#!/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 RESULT_PREFIX = "__PROVIDER_DREAM_RESULT__";
+
+function isolate(kind) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), `open-claudia-dream-${kind}-`));
+  process.env.OPEN_CLAUDIA_TEST = "1";
+  process.env.OPEN_CLAUDIA_CONFIG_DIR = path.join(root, "config");
+  process.env.PACKS_DIR = path.join(root, "packs");
+  process.env.ENTITIES_DIR = path.join(root, "entities");
+  process.env.LESSONS_FILE = path.join(root, "lessons.md");
+  process.env.PERSONA_FILE = path.join(root, "persona.md");
+  process.env.IDEAS_FILE = path.join(root, "ideas.md");
+  process.env.RECALL_GRAPH_DB = path.join(root, "recall-graph.db");
+  process.env.TRANSCRIPTS_DIR = path.join(root, "transcripts");
+  process.env.HOME = root;
+  process.env.WORKSPACE = root;
+  process.env.RECALL_METRICS = "on";
+  process.env.DREAM_INTROSPECT = "on";
+  process.env.DREAM_SELF_APPLY = "on";
+  process.env.DREAM_EFFORT = "max";
+  process.env.DREAM_TIER = "high";
+  fs.mkdirSync(process.env.OPEN_CLAUDIA_CONFIG_DIR, { recursive: true });
+  return root;
+}
+
+function registryFor(provider) {
+  return {
+    getProvider(id) {
+      if (id !== provider.id) throw Object.assign(new Error(`unknown provider ${id}`), { code: "UNKNOWN_PROVIDER" });
+      return provider;
+    },
+    listProviders: () => [provider],
+    providerStatus(id) {
+      if (id !== provider.id) throw Object.assign(new Error(`unknown provider ${id}`), { code: "UNKNOWN_PROVIDER" });
+      return {
+        id,
+        availability: { state: "available", executable: provider.executable(), reason: null },
+        compatibility: { state: "compatible", reason: null },
+        auth: { state: "authenticated", reason: null },
+      };
+    },
+  };
+}
+
+function packSemantics(pack) {
+  return {
+    dir: pack.dir,
+    name: pack.name,
+    description: pack.description,
+    tags: pack.tags,
+    kind: pack.kind,
+    skill: pack.skill,
+    sections: pack.sections,
+  };
+}
+
+function entitySemantics(entity) {
+  return {
+    slug: entity.slug,
+    name: entity.name,
+    type: entity.type,
+    description: entity.description,
+    relationship: entity.relationship,
+    sections: entity.sections,
+  };
+}
+
+async function providerProbe(kind) {
+  const root = isolate(kind);
+  const fixture = path.join(__dirname, "test-fixtures", "fake-agent-cli.js");
+  const dreamDecision = {
+    merges: [],
+    umbrellas: [],
+    parents: [],
+    retag: [{ pack: "project", description: "Provider-neutral dream consolidation fixture", tags: ["dream", "provider", "memory"] }],
+    entity_merges: [],
+    entity_notes: [{ entity: "parity-harness", notes: "Runs the same deterministic dream decisions through either provider." }],
+    archive: [],
+    lessons: [],
+    persona: "too short",
+    tuning: null,
+    report: "I tidied the provider-parity memory and kept the durable pieces aligned. 💤",
+  };
+  const introspectionDecision = {
+    lessons_add: [{ text: "Always record the provider and model used for a dream.", src: "project", trigger: "again, tell me which provider dreamed" }],
+    doc_edits: [{ pack: "project", section: "State", to: "Dream and introspection both completed through the selected utility provider.", why: "provider parity was verified" }],
+    entity_edits: [{ entity: "parity-harness", notes: "Verifies consolidation and introspection through Claude and Codex." }],
+    ideas: [{ scope: "oc", text: "Show dream provider metadata in the morning summary." }],
+    persona: null,
+    report: "I checked my own memory loop and left a clear provider audit trail. 🪞",
+  };
+
+  const { createClaudeProvider } = require("./core/providers/claude");
+  const { createCodexProvider } = require("./core/providers/codex");
+  const createProvider = kind === "claude" ? createClaudeProvider : createCodexProvider;
+  const provider = createProvider({
+    resolveExecutable: () => fixture,
+    defaultModel: `${kind}-high-fixture`,
+    buildEnv: () => ({ PATH: process.env.PATH || "", HOME: root, FAKE_AGENT_KIND: kind }),
+    getAuthStatus: () => ({ state: "authenticated", reason: null }),
+  });
+  const originalBuildUtilityInvocation = provider.buildUtilityInvocation;
+  const captures = [];
+  provider.buildUtilityInvocation = (context) => {
+    const invocation = originalBuildUtilityInvocation(context);
+    const index = captures.length;
+    const capture = path.join(root, `${String(index).padStart(2, "0")}-${context.purpose}.json`);
+    captures.push({ capture, purpose: context.purpose });
+    invocation.env.FAKE_AGENT_CAPTURE = capture;
+    invocation.env.FAKE_AGENT_TEXT = JSON.stringify(context.purpose === "introspection" ? introspectionDecision : dreamDecision);
+    return invocation;
+  };
+
+  const model = `${kind}-dream-exact`;
+  const { createUtilityAgentService } = require("./core/utility-agent");
+  const utility = createUtilityAgentService({
+    registry: registryFor(provider),
+    env: {
+      UTILITY_PROVIDER: "active",
+      DEFAULT_PROVIDER: kind,
+      [`DREAM_MODEL_${kind.toUpperCase()}`]: model,
+    },
+  });
+  const { MemoryMutationQueue } = require("./core/memory-mutation-queue");
+  const queue = new MemoryMutationQueue({
+    lockDir: path.join(root, "dream.lock"),
+    journalFile: path.join(root, "dream-intents.jsonl"),
+    lockPollMs: 5,
+  });
+  const calls = [];
+  const runUtility = (prompt, options) => {
+    calls.push({
+      purpose: options.purpose,
+      provider: options.provider || null,
+      tier: options.tier,
+      readOnly: options.readOnly,
+      hasSchema: !!options.outputSchema,
+      effort: options.effort,
+      promptBytes: Buffer.byteLength(prompt),
+    });
+    return utility.spawnUtilityAgent(prompt, options);
+  };
+
+  const dream = require("./core/dream");
+  assert.strictEqual(typeof dream.createDreamService, "function", "dream exposes an injectable provider service");
+  const service = dream.createDreamService({ spawnUtilityAgent: runUtility, mutationQueue: queue });
+  const packs = require("./core/packs");
+  const entities = require("./core/entities");
+  const lessons = require("./core/lessons");
+  const ideas = require("./core/ideas");
+  const persona = require("./core/persona");
+  dream.writeDreamState({ legacyField: "preserved" });
+  packs.createPack({
+    dir: "project",
+    name: "Project",
+    description: "dream provider parity project",
+    stance: "Keep provider-neutral memory durable.",
+    procedure: "Use deterministic provider fixtures.",
+    state: "Dream provider parity is pending.",
+  });
+  entities.upsertEntity({ name: "Parity Harness", type: "system", description: "dream fixture", notes: "Initial fixture notes." });
+  const originalPersona = `Open Claudia stays direct, warm, and precise while testing memory. ${"She preserves durable facts and speaks with calm confidence. ".repeat(2)}`.trim();
+  persona.savePersona(originalPersona);
+
+  const beforePreview = packSemantics(packs.readPack("project"));
+  const preview = await service.previewDream();
+  assert.strictEqual(preview.provider, kind);
+  assert.strictEqual(preview.model, model);
+  assert.deepStrictEqual(preview.decision, dream.parseDream(JSON.stringify(dreamDecision)));
+  assert.deepStrictEqual(packSemantics(packs.readPack("project")), beforePreview, "dry-run preview never applies its decision");
+
+  const result = await service.runDream({ trigger: "cron" });
+  assert.strictEqual(result.provider, kind);
+  assert.strictEqual(result.model, model);
+  assert.strictEqual(result.introspectionProvider, kind);
+  assert.strictEqual(result.introspectionModel, model);
+  assert.strictEqual(result.trigger, "cron");
+  assert.match(result.message, new RegExp(`${kind}.*${model}`), "morning summary names the provider and model");
+  assert.match(result.message, /provider audit trail/i, "introspection narrative remains in the summary");
+
+  assert.deepStrictEqual(calls.map((call) => call.purpose), ["dream", "dream", "introspection"]);
+  for (const call of calls) {
+    assert.strictEqual(call.provider, null, "global dream selection is resolved by DEFAULT_PROVIDER when no chat is active");
+    assert.strictEqual(call.tier, "high");
+    assert.strictEqual(call.readOnly, true);
+    assert.strictEqual(call.hasSchema, true);
+    assert.strictEqual(call.effort, "max");
+    assert.ok(call.promptBytes > 100);
+  }
+
+  const project = packs.readPack("project");
+  const entity = entities.findEntity("Parity Harness");
+  assert.strictEqual(project.description, "Provider-neutral dream consolidation fixture");
+  assert.deepStrictEqual(project.tags, ["dream", "provider", "memory"]);
+  assert.strictEqual(project.sections.State, "Dream and introspection both completed through the selected utility provider.");
+  assert.strictEqual(entity.sections.Notes, "Verifies consolidation and introspection through Claude and Codex.");
+  assert.strictEqual(lessons.listLessons()[0].text, "Always record the provider and model used for a dream.");
+  assert.strictEqual(ideas.listIdeas()[0].text, "Show dream provider metadata in the morning summary.");
+  assert.strictEqual(persona.loadPersona(), originalPersona, "persona bounds still reject an undersized model proposal");
+
+  const state = dream.readDreamState();
+  assert.strictEqual(state.provider, kind);
+  assert.strictEqual(state.model, model);
+  assert.strictEqual(state.introspection.provider, kind);
+  assert.strictEqual(state.introspection.model, model);
+  assert.strictEqual(state.lastRunStatus, "succeeded");
+  assert.strictEqual(state.legacyField, "preserved", "provider metadata is an additive, backward-compatible dream-state migration");
+
+  assert.ok(result.reportPath && fs.existsSync(result.reportPath));
+  const report = fs.readFileSync(result.reportPath, "utf8");
+  assert.match(report, new RegExp(`Provider: ${kind}`));
+  assert.match(report, new RegExp(`Model: ${model}`));
+  assert.match(report, new RegExp(`Introspection: ${kind}.*${model}`));
+  const snapshots = require("./core/recall/metrics").readKpi();
+  const snapshot = snapshots.at(-1);
+  assert.strictEqual(snapshot.providers.dream, kind);
+  assert.strictEqual(snapshot.providers.introspection, kind);
+  assert.strictEqual(snapshot.models.dream, model);
+  assert.strictEqual(snapshot.models.introspection, model);
+
+  assert.ok(fs.existsSync(path.join(process.env.PACKS_DIR, "project", "PACK.md.bak")), "dream updates retain last-good backups");
+  assert.ok(fs.existsSync(`${process.env.PERSONA_FILE}.bak`) || fs.existsSync(path.join(root, "config", "backup")),
+    "persona proposal handling retains recovery data without bypassing bounds");
+  for (const { capture, purpose } of captures) {
+    const record = JSON.parse(fs.readFileSync(capture, "utf8"));
+    assert.strictEqual(record.stdin.present, true, `${purpose} prompt uses protected stdin`);
+    assert.ok(record.argv.includes(model));
+    assert.ok(record.argv.includes(kind === "claude" ? "plan" : "read-only"));
+    if (kind === "claude") {
+      assert.ok(record.argv.includes("--json-schema"));
+      assert.ok(record.argv.includes("max"), "Claude retains maximum dream effort");
+    } else {
+      assert.ok(record.argv.includes("--output-schema"));
+      assert.ok(record.argv.some((arg) => /model_reasoning_effort=.*xhigh/.test(arg)), "generic max effort maps to Codex's strongest supported value");
+    }
+  }
+
+  // Provider/model failure still leaves the load-bearing deterministic phases
+  // running, and preserves the attempted provider/model in the result.
+  packs.createPack({ dir: "family", name: "Family", description: "prefix parent fixture" });
+  packs.createPack({ dir: "family-child", name: "Family Child", description: "prefix child fixture" });
+  process.env.DREAM_INTROSPECT = "off";
+  const failingService = dream.createDreamService({
+    mutationQueue: queue,
+    spawnUtilityAgent: async () => {
+      const error = Object.assign(new Error("provider failure fixture"), {
+        code: "UTILITY_PROVIDER_ERROR",
+        result: { provider: kind, model, effort: kind === "claude" ? "max" : "xhigh", fallbackUsed: false },
+      });
+      throw error;
+    },
+  });
+  const failed = await failingService.runDream({ trigger: "failure-fixture" });
+  process.env.DREAM_INTROSPECT = "on";
+  assert.strictEqual(failed.provider, kind);
+  assert.strictEqual(failed.model, model);
+  assert.match(failed.report, /skipped the AI-led merges/i);
+  assert.strictEqual(packs.readPack("family-child").parent, "family", "deterministic filing survives provider failure");
+
+  return {
+    provider: kind,
+    mutations: {
+      pack: packSemantics(project),
+      entity: entitySemantics(entity),
+      lessons: lessons.listLessons().map(({ text, src }) => ({ text, src })),
+      ideas: ideas.listIdeas().map(({ scope, text }) => ({ scope, text })),
+      persona: persona.loadPersona(),
+    },
+  };
+}
+
+function runChild(kind) {
+  const child = spawnSync(process.execPath, [__filename, "--probe", kind], {
+    cwd: __dirname,
+    env: { ...process.env },
+    encoding: "utf8",
+    timeout: 60000,
+  });
+  if (child.status !== 0) throw new Error(`${kind} dream probe failed (${child.status})\n${child.stdout}\n${child.stderr}`);
+  const line = child.stdout.split("\n").find((entry) => entry.startsWith(RESULT_PREFIX));
+  if (!line) throw new Error(`${kind} dream probe returned no result\n${child.stdout}\n${child.stderr}`);
+  return JSON.parse(line.slice(RESULT_PREFIX.length));
+}
+
+async function main() {
+  if (process.argv[2] === "--probe") {
+    const result = await providerProbe(process.argv[3]);
+    console.log(`${RESULT_PREFIX}${JSON.stringify(result)}`);
+    return;
+  }
+  const claude = runChild("claude");
+  const codex = runChild("codex");
+  assert.deepStrictEqual(codex.mutations, claude.mutations, "Claude and Codex dream decisions produce identical durable mutations");
+  const cliSource = fs.readFileSync(path.join(__dirname, "bin", "dream.js"), "utf8");
+  assert.ok(!cliSource.includes("spawnSubagent"), "manual dry-run no longer bypasses utility-provider selection");
+  assert.match(cliSource, /previewDream/);
+  console.log("provider dream OK");
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});