@inetafrica/open-claudia 2.15.0 → 3.0.1

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

package/test-provider-enforcer.js

@@ -0,0 +1,252 @@
+#!/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_ENFORCER_RESULT__";
+
+function isolate(label) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), `open-claudia-enforcer-${label}-`));
+  process.env.OPEN_CLAUDIA_TEST = "1";
+  process.env.OPEN_CLAUDIA_CONFIG_DIR = path.join(root, "config");
+  process.env.HOME = root;
+  process.env.WORKSPACE = root;
+  fs.mkdirSync(process.env.OPEN_CLAUDIA_CONFIG_DIR, { recursive: true });
+  return root;
+}
+
+function makeProvider(kind, root, controls) {
+  const fixture = path.join(__dirname, "test-fixtures", "fake-agent-cli.js");
+  const { createClaudeProvider } = require("./core/providers/claude");
+  const { createCodexProvider } = require("./core/providers/codex");
+  const createProvider = kind === "claude" ? createClaudeProvider : createCodexProvider;
+  const provider = createProvider({
+    hookTransport: false,
+    resolveExecutable: () => fixture,
+    defaultModel: `${kind}-default-fixture`,
+    buildEnv: () => ({ PATH: process.env.PATH || "", HOME: root, FAKE_AGENT_KIND: kind }),
+    getAuthStatus: () => ({ state: "authenticated", reason: null }),
+  });
+  const base = provider.buildUtilityInvocation;
+  const captures = [];
+  provider.buildUtilityInvocation = (context) => {
+    const invocation = base(context);
+    const control = controls.shift() || { FAKE_AGENT_TEXT: '{"decision":"allow","reason":"default fixture"}' };
+    const capture = path.join(root, `${kind}-${captures.length}-${context.purpose}.json`);
+    captures.push(capture);
+    Object.assign(invocation.env, control, { FAKE_AGENT_CAPTURE: capture });
+    return invocation;
+  };
+  return { provider, captures, fixture };
+}
+
+function registry(providerEntries, states = {}) {
+  const map = Object.fromEntries(providerEntries.map((entry) => [entry.provider.id, entry]));
+  return {
+    getProvider(id) {
+      if (!map[id]) throw Object.assign(new Error(`unknown provider ${id}`), { code: "UNKNOWN_PROVIDER" });
+      return map[id].provider;
+    },
+    listProviders: () => providerEntries.map((entry) => entry.provider),
+    providerStatus(id) {
+      if (!map[id]) throw Object.assign(new Error(`unknown provider ${id}`), { code: "UNKNOWN_PROVIDER" });
+      const state = states[id] || {};
+      return {
+        id,
+        availability: state.availability || { state: "available", executable: map[id].fixture, reason: null },
+        compatibility: state.compatibility || { state: "compatible", reason: null },
+        auth: state.auth || { state: "authenticated", reason: null },
+      };
+    },
+  };
+}
+
+function auditSink() {
+  const entries = [];
+  return { entries, log(kind, payload) { const entry = { kind, ...payload }; entries.push(entry); return entry; } };
+}
+
+async function providerProbe(kind) {
+  const root = isolate(kind);
+  const timeoutSignal = path.join(root, `${kind}-timeout-signal.json`);
+  const controls = [
+    { FAKE_AGENT_TEXT: '{"decision":"allow","reason":"inside mandate"}' },
+    { FAKE_AGENT_TEXT: '{"decision":"block","reason":"outside mandate"}' },
+    { FAKE_AGENT_TEXT: '{"decision":"escalate","reason":"owner must decide"}' },
+    { FAKE_AGENT_TEXT: "not-json" },
+    { FAKE_AGENT_SCENARIO: "forced-termination", FAKE_AGENT_SIGNAL_CAPTURE: timeoutSignal },
+  ];
+  const entry = makeProvider(kind, root, controls);
+  const model = `${kind}-enforcer-exact`;
+  const { createUtilityAgentService } = require("./core/utility-agent");
+  const utility = createUtilityAgentService({
+    registry: registry([entry]),
+    env: { ENFORCER_PROVIDER: kind, [`ENFORCER_MODEL_${kind.toUpperCase()}`]: model },
+    killGraceMs: 30,
+  });
+  const enforcer = require("./core/enforcer");
+  assert.strictEqual(typeof enforcer.createEnforcerService, "function", "enforcer exposes an injectable utility-provider service");
+  const audit = auditSink();
+  const service = enforcer.createEnforcerService({
+    spawnUtilityAgent: utility.spawnUtilityAgent,
+    audit,
+    timeoutMs: 2000,
+  });
+  const speaker = { name: "External Fixture", relationship: "external", mandate: "May discuss invoice status only." };
+  const secret = ["sk", "proj", "guard", "fixture", "private"].join("-");
+  const allow = await service.vetReply(speaker, `Invoice status is paid. ${secret}`);
+  const block = await service.vetReply(speaker, "Here are internal infrastructure details.");
+  const escalate = await service.vetAction(speaker, { command: "open-claudia tool run billing change-owner", tier: "write" });
+  const malformed = await service.vetReply(speaker, "malformed verdict fixture");
+  const timeoutService = enforcer.createEnforcerService({
+    spawnUtilityAgent: utility.spawnUtilityAgent,
+    audit,
+    timeoutMs: 140,
+  });
+  const timedOut = await timeoutService.vetReply(speaker, "timeout verdict fixture");
+
+  assert.strictEqual(allow.decision, "allow");
+  assert.strictEqual(block.decision, "block");
+  assert.strictEqual(escalate.decision, "escalate");
+  for (const verdict of [allow, block, escalate]) {
+    assert.strictEqual(verdict.provider, kind);
+    assert.strictEqual(verdict.model, model);
+    assert.strictEqual(verdict.fallbackUsed, false);
+    assert.strictEqual(verdict.status, "judged");
+  }
+  for (const failure of [malformed, timedOut]) {
+    assert.strictEqual(failure.decision, "escalate", "guard failures always fail closed");
+    assert.strictEqual(failure.provider, kind);
+    assert.strictEqual(failure.model, model);
+    assert.strictEqual(failure.status, "failed");
+    assert.match(failure.reason, /failing closed/);
+  }
+
+  assert.strictEqual(audit.entries.length, 5);
+  assert.ok(audit.entries.every((item) => item.kind === "enforcer.verdict"));
+  assert.ok(audit.entries.every((item) => item.provider === kind && item.model === model));
+  const serializedAudit = JSON.stringify(audit.entries);
+  assert.ok(!serializedAudit.includes(secret), "audit metadata never contains the judged prompt or payload");
+  assert.ok(!serializedAudit.includes("mandate"), "audit metadata never contains the private mandate");
+
+  assert.strictEqual(entry.captures.length, 5);
+  for (const capture of entry.captures) {
+    const raw = fs.readFileSync(capture, "utf8");
+    const record = JSON.parse(raw);
+    assert.ok(!raw.includes(secret), "fixture capture contains stdin metadata, never the guarded payload");
+    assert.strictEqual(record.stdin.present, true);
+    assert.ok(record.argv.includes(model));
+    assert.ok(record.argv.includes(kind === "claude" ? "plan" : "read-only"));
+    assert.ok(record.argv.includes(kind === "claude" ? "--json-schema" : "--output-schema"));
+  }
+  assert.strictEqual(JSON.parse(fs.readFileSync(timeoutSignal, "utf8")).signal, "SIGTERM");
+
+  return { kind, decisions: [allow.decision, block.decision, escalate.decision, malformed.decision, timedOut.decision] };
+}
+
+async function fallbackProbe() {
+  const root = isolate("fallback");
+  const claude = makeProvider("claude", root, [{ FAKE_AGENT_SCENARIO: "auth-failure" }]);
+  const codex = makeProvider("codex", root, [{ FAKE_AGENT_TEXT: '{"decision":"allow","reason":"fallback judged"}' }]);
+  const { createUtilityAgentService } = require("./core/utility-agent");
+  const fallbackUtility = createUtilityAgentService({
+    registry: registry([claude, codex]),
+    env: {
+      ENFORCER_PROVIDER: "claude",
+      PROVIDER_FALLBACKS: "codex",
+      ENFORCER_MODEL_CLAUDE: "claude-enforcer-exact",
+      ENFORCER_MODEL_CODEX: "codex-enforcer-exact",
+    },
+  });
+  const enforcer = require("./core/enforcer");
+  const fallbackAudit = auditSink();
+  const fallbackService = enforcer.createEnforcerService({ spawnUtilityAgent: fallbackUtility.spawnUtilityAgent, audit: fallbackAudit });
+  const speaker = { relationship: "external", mandate: "May discuss invoice status." };
+  const fallback = await fallbackService.vetReply(speaker, "fallback invoice fixture");
+  assert.strictEqual(fallback.decision, "allow");
+  assert.strictEqual(fallback.provider, "codex");
+  assert.strictEqual(fallback.model, "codex-enforcer-exact");
+  assert.strictEqual(fallback.preferredProvider, "claude");
+  assert.strictEqual(fallback.fallbackUsed, true);
+  assert.strictEqual(fallbackAudit.entries[0].provider, "codex");
+  assert.strictEqual(fallbackAudit.entries[0].fallbackUsed, true);
+  assert.strictEqual(claude.captures.length, 1, "preferred provider was attempted first");
+  assert.strictEqual(codex.captures.length, 1, "only the explicitly configured fallback judged after auth failure");
+
+  const noFallbackCodex = makeProvider("codex", root, []);
+  const noFallbackUtility = createUtilityAgentService({
+    registry: registry([claude, noFallbackCodex], {
+      claude: { availability: { state: "missing", executable: null, reason: "missing fixture" } },
+    }),
+    env: { ENFORCER_PROVIDER: "claude" },
+  });
+  const noFallbackService = enforcer.createEnforcerService({ spawnUtilityAgent: noFallbackUtility.spawnUtilityAgent, audit: auditSink() });
+  const noFallback = await noFallbackService.vetReply(speaker, "no implicit fallback fixture");
+  assert.strictEqual(noFallback.decision, "escalate");
+  assert.strictEqual(noFallback.status, "failed");
+  assert.strictEqual(noFallbackCodex.captures.length, 0, "enforcer never invents an unconfigured fallback");
+
+  const failedClaude = makeProvider("claude", root, []);
+  const failedCodex = makeProvider("codex", root, []);
+  const totalFailureUtility = createUtilityAgentService({
+    registry: registry([failedClaude, failedCodex], {
+      claude: { availability: { state: "missing", executable: null, reason: "missing Claude" } },
+      codex: { auth: { state: "unauthenticated", reason: "missing Codex auth" } },
+    }),
+    env: { ENFORCER_PROVIDER: "claude", PROVIDER_FALLBACKS: "codex" },
+  });
+  const totalAudit = auditSink();
+  const totalService = enforcer.createEnforcerService({ spawnUtilityAgent: totalFailureUtility.spawnUtilityAgent, audit: totalAudit });
+  const totalFailure = await totalService.vetAction(speaker, { command: "dangerous total failure fixture", tier: "destructive" });
+  assert.strictEqual(totalFailure.decision, "escalate");
+  assert.strictEqual(totalFailure.status, "failed");
+  assert.match(totalFailure.reason, /failing closed/);
+  assert.strictEqual(totalAudit.entries[0].decision, "escalate");
+  assert.strictEqual(totalAudit.entries[0].status, "failed");
+
+  return { fallbackProvider: fallback.provider, noFallback: noFallback.decision, totalFailure: totalFailure.decision };
+}
+
+function runChild(args) {
+  const child = spawnSync(process.execPath, [__filename, ...args], {
+    cwd: __dirname,
+    env: { ...process.env },
+    encoding: "utf8",
+    timeout: 30000,
+  });
+  if (child.status !== 0) throw new Error(`enforcer child ${args.join(" ")} 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(`enforcer child ${args.join(" ")} returned no result\n${child.stdout}\n${child.stderr}`);
+  return JSON.parse(line.slice(RESULT_PREFIX.length));
+}
+
+async function main() {
+  if (process.argv[2] === "--provider") {
+    const result = await providerProbe(process.argv[3]);
+    console.log(`${RESULT_PREFIX}${JSON.stringify(result)}`);
+    return;
+  }
+  if (process.argv[2] === "--fallback") {
+    const result = await fallbackProbe();
+    console.log(`${RESULT_PREFIX}${JSON.stringify(result)}`);
+    return;
+  }
+  const claude = runChild(["--provider", "claude"]);
+  const codex = runChild(["--provider", "codex"]);
+  assert.deepStrictEqual(claude.decisions, ["allow", "block", "escalate", "escalate", "escalate"]);
+  assert.deepStrictEqual(codex.decisions, claude.decisions);
+  assert.deepStrictEqual(runChild(["--fallback"]), { fallbackProvider: "codex", noFallback: "escalate", totalFailure: "escalate" });
+  const source = fs.readFileSync(path.join(__dirname, "core", "enforcer.js"), "utf8");
+  assert.ok(!source.includes("spawnSubagent"), "enforcer no longer uses the compatibility sub-agent transport");
+  console.log("provider enforcer OK");
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+});