@inetafrica/open-claudia 2.15.0 → 3.0.0

package/test-provider-bootstrap.js

@@ -0,0 +1,158 @@
+#!/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");
+
+function statusProvider(id, overrides = {}) {
+  const { CAPABILITY_KEYS } = require("./core/providers/contract");
+  const capabilities = Object.fromEntries(CAPABILITY_KEYS.map((key) => [key, {
+    support: "unsupported",
+    reason: "fixture capability",
+    ...(key === "effort" ? { values: [] } : {}),
+  }]));
+  return {
+    id,
+    label: id === "claude" ? "Claude Code" : "OpenAI Codex",
+    isAvailable: () => true,
+    executable: () => `/fixture/${id}`,
+    defaultModel: () => null,
+    tierModel: (tier) => `${id}-${tier}`,
+    modelChoices: () => [],
+    compatibilityStatus: () => overrides.compatibility || { state: "compatible", version: "1.0.0", reason: null },
+    capabilities,
+    buildMainInvocation: () => ({ binary: `/fixture/${id}`, args: [], env: {}, stdin: null, parserState: {} }),
+    buildUtilityInvocation: () => ({ binary: `/fixture/${id}`, args: [], env: {}, stdin: null, parserState: {} }),
+    createEventDecoder: () => ({ push: () => [], end: () => [] }),
+    normalizeEvent: () => [],
+    authStatus: () => overrides.auth || { state: "authenticated", reason: null },
+    authHelp: () => "fixture auth help",
+  };
+}
+
+function childProbe() {
+  const configDirApi = require("./core/config-dir");
+  const config = require("./core/config");
+
+  // Setup and status helpers must be importable without starting setup,
+  // writing state, probing a provider, or exiting the process.
+  require("./setup");
+  require("./health");
+  require("./core/doctor");
+
+  const result = {
+    configDir: config.CONFIG_DIR,
+    resolvedConfigDir: configDirApi.resolveConfigDir(process.env),
+    workspace: config.WORKSPACE,
+    claudeConfigured: config.configuredProviderPath("claude"),
+    codexConfigured: config.configuredProviderPath("codex"),
+    claudeAvailability: config.providerExecutableStatus("claude"),
+    codexAvailability: config.providerExecutableStatus("codex"),
+  };
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+}
+
+if (process.argv[2] === "--probe") {
+  childProbe();
+} else {
+  const { resolveConfigDir } = require("./core/config-dir");
+  assert.strictEqual(
+    resolveConfigDir({ HOME: "/fixture/home", OPEN_CLAUDIA_CONFIG_DIR: "/fixture/config" }),
+    path.resolve("/fixture/config"),
+  );
+  assert.strictEqual(
+    resolveConfigDir({ HOME: "/fixture/home" }),
+    path.resolve("/fixture/home/.open-claudia"),
+  );
+
+  const cases = [
+    { name: "claude-only", claude: "present", codex: null, expected: ["available", "unconfigured"] },
+    { name: "codex-only", claude: null, codex: "present", expected: ["unconfigured", "available"] },
+    { name: "both", claude: "present", codex: "present", expected: ["available", "available"] },
+    { name: "neither", claude: null, codex: null, expected: ["unconfigured", "unconfigured"] },
+    { name: "missing-claude", claude: "missing", codex: null, expected: ["missing", "unconfigured"] },
+    { name: "missing-codex", claude: null, codex: "missing", expected: ["unconfigured", "missing"] },
+    { name: "path-only-claude", claude: "path-only", codex: null, expected: ["available", "unconfigured"] },
+    { name: "path-only-codex", claude: null, codex: "path-only", expected: ["unconfigured", "available"] },
+  ];
+
+  for (const testCase of cases) {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), `open-claudia-bootstrap-${testCase.name}-`));
+    const home = path.join(root, "home");
+    const configDir = path.join(root, "config");
+    const workspace = path.join(root, "workspace");
+    const binDir = path.join(root, "bin");
+    fs.mkdirSync(home);
+    fs.mkdirSync(binDir);
+
+    const configuredPath = (providerName, disposition) => {
+      if (!disposition) return undefined;
+      if (disposition === "missing") return path.join(binDir, `${providerName}-missing`);
+      const target = path.join(binDir, providerName);
+      fs.symlinkSync(process.execPath, target);
+      return disposition === "path-only" ? undefined : target;
+    };
+
+    const env = {
+      HOME: home,
+      PATH: binDir,
+      OPEN_CLAUDIA_CONFIG_DIR: configDir,
+      WORKSPACE: workspace,
+      CHANNELS: "",
+      OPEN_CLAUDIA_TEST: "1",
+      CLAUDE_PATH: configuredPath("claude", testCase.claude),
+      CODEX_PATH: configuredPath("codex", testCase.codex),
+    };
+    for (const key of Object.keys(env)) {
+      if (env[key] === undefined) delete env[key];
+    }
+
+    try {
+      const child = spawnSync(process.execPath, [__filename, "--probe"], {
+        cwd: __dirname,
+        env,
+        encoding: "utf8",
+        timeout: 10000,
+      });
+      assert.ifError(child.error);
+      assert.strictEqual(child.status, 0, child.stderr || `${testCase.name} import probe failed`);
+      const output = JSON.parse(child.stdout.trim());
+      assert.strictEqual(output.configDir, path.resolve(configDir));
+      assert.strictEqual(output.resolvedConfigDir, path.resolve(configDir));
+      assert.strictEqual(output.workspace, workspace);
+      assert.deepStrictEqual(
+        [output.claudeAvailability.state, output.codexAvailability.state],
+        testCase.expected,
+      );
+      assert.ok(!fs.existsSync(configDir), `${testCase.name} imports must not create the config directory`);
+      assert.ok(!fs.existsSync(workspace), `${testCase.name} imports must not create the workspace`);
+    } finally {
+      fs.rmSync(root, { recursive: true, force: true });
+    }
+  }
+
+  // Compatibility and auth are provider-owned typed states. They are kept
+  // separate so setup/status can explain an old CLI versus a logged-out CLI.
+  const { ProviderRegistry } = require("./core/providers");
+  const oldCli = new ProviderRegistry();
+  oldCli.registerProvider(statusProvider("claude", {
+    compatibility: { state: "incompatible", version: "0.0.1", reason: "too old" },
+  }));
+  assert.strictEqual(oldCli.providerStatus("claude").compatibility.state, "incompatible");
+
+  const loggedOut = new ProviderRegistry();
+  loggedOut.registerProvider(statusProvider("codex", {
+    auth: { state: "unauthenticated", reason: "login required" },
+  }));
+  assert.strictEqual(loggedOut.providerStatus("codex").auth.state, "unauthenticated");
+
+  const cliSource = fs.readFileSync(path.join(__dirname, "bin", "cli.js"), "utf8");
+  assert.match(cliSource, /case "setup":[\s\S]*setup\.js"\)\)\.main\(\)/, "CLI setup command must call the guarded setup entrypoint");
+  assert.match(cliSource, /Legacy:[\s\S]*setup\.js"\)\)\.main\(\)/, "legacy auth command must call the guarded setup entrypoint");
+
+  console.log("provider bootstrap OK");
+}

package/test-provider-capabilities.js

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const configDir = fs.mkdtempSync(path.join(os.tmpdir(), "open-claudia-capabilities-"));
+const workspace = path.join(configDir, "workspace");
+fs.mkdirSync(path.join(workspace, "alpha"), { recursive: true });
+process.env.OPEN_CLAUDIA_CONFIG_DIR = configDir;
+process.env.WORKSPACE = workspace;
+process.env.TELEGRAM_CHAT_ID = "fixture-chat";
+process.env.CHANNELS = "";
+process.env.OPEN_CLAUDIA_TEST = "1";
+process.env.CLAUDE_PATH = process.execPath;
+process.env.CODEX_PATH = process.execPath;
+
+const stateApi = require("./core/state");
+const handlers = require("./core/handlers");
+const commands = require("./core/commands");
+const providers = require("./core/providers");
+const { handleAction } = require("./core/actions");
+const { runInChat } = require("./core/context");
+
+const state = stateApi.currentState();
+state.currentSession = { name: "alpha", dir: path.join(workspace, "alpha") };
+state.settings.backend = "claude";
+
+function callbacks(rows) {
+  return rows.flat().map((button) => button.callback_data).filter(Boolean);
+}
+
+function pickerProbe() {
+  assert.strictEqual(typeof handlers.buildBackendPicker, "function");
+  assert.strictEqual(typeof handlers.buildModelPicker, "function");
+  const backend = handlers.buildBackendPicker({ state, registry: providers });
+  const expectedProviders = providers.listProviders().map((provider) => provider.id);
+  assert.deepStrictEqual(
+    callbacks(backend.rows).map((value) => value.slice("be:".length)),
+    expectedProviders,
+    "backend picker comes from registry order",
+  );
+
+  const model = handlers.buildModelPicker({ state, registry: providers });
+  const modelCallbacks = callbacks(model.rows).filter((value) => value.startsWith("mb:"));
+  for (const provider of providers.listProviders()) {
+    const choices = provider.modelChoices();
+    for (const choice of choices) {
+      assert.ok(modelCallbacks.includes(`mb:${provider.id}:${choice}`), `${provider.id} model choice ${choice}`);
+    }
+    assert.ok(modelCallbacks.includes(`mb:${provider.id}:default`), `${provider.id} default model control`);
+  }
+  assert.ok(!fs.readFileSync(path.join(__dirname, "core", "handlers.js"), "utf8").includes("DEFAULT_CLAUDE_MODEL"));
+}
+
+function mutationProbe() {
+  assert.strictEqual(typeof handlers.applyProviderSetting, "function");
+  const claudeSettings = stateApi.getProviderSettings(state, "claude");
+  const codexSettings = stateApi.getProviderSettings(state, "codex");
+  claudeSettings.effort = "low";
+  claudeSettings.budget = 2;
+  codexSettings.effort = null;
+  codexSettings.budget = null;
+  codexSettings.worktree = false;
+
+  state.settings.backend = "codex";
+  let result = handlers.applyProviderSetting(state, "codex", "effort", "xhigh", { registry: providers });
+  assert.strictEqual(result.ok, true);
+  assert.strictEqual(codexSettings.effort, "xhigh");
+  assert.strictEqual(claudeSettings.effort, "low", "provider setting stays isolated");
+
+  const beforeBudget = structuredClone(state.providerSettings);
+  result = handlers.applyProviderSetting(state, "codex", "budget", 5, { registry: providers });
+  assert.strictEqual(result.ok, false);
+  assert.strictEqual(result.code, "UNSUPPORTED_PROVIDER_CAPABILITY");
+  assert.match(result.message, /no per-run monetary budget/i);
+  assert.deepStrictEqual(state.providerSettings, beforeBudget, "unsupported budget cannot mutate state");
+
+  const beforeWorktree = structuredClone(state.providerSettings);
+  result = handlers.applyProviderSetting(state, "codex", "worktree", true, { registry: providers });
+  assert.strictEqual(result.ok, false);
+  assert.match(result.message, /worktree/i);
+  assert.deepStrictEqual(state.providerSettings, beforeWorktree, "unsupported worktree cannot mutate state");
+
+  const beforeInvalidEffort = structuredClone(state.providerSettings);
+  result = handlers.applyProviderSetting(state, "codex", "effort", "maximum-ish", { registry: providers });
+  assert.strictEqual(result.ok, false);
+  assert.deepStrictEqual(state.providerSettings, beforeInvalidEffort, "invalid effort cannot mutate state");
+
+  state.settings.backend = "claude";
+  result = handlers.applyProviderSetting(state, "claude", "budget", 4, { registry: providers });
+  assert.strictEqual(result.ok, true);
+  assert.strictEqual(claudeSettings.budget, 4);
+
+  const stale = structuredClone(state.providerSettings);
+  result = handlers.applyProviderSetting(state, "codex", "effort", "high", { registry: providers, requireActive: true });
+  assert.strictEqual(result.code, "STALE_PROVIDER_CONTROL");
+  assert.deepStrictEqual(state.providerSettings, stale, "stale provider control cannot mutate inactive settings");
+}
+
+async function inChat(fn, sent) {
+  return runInChat({
+    adapter: {
+      id: "fixture",
+      type: "fixture",
+      send: async (_channelId, text, options) => { sent.push({ text, options }); return true; },
+    },
+    channelId: "fixture-chat",
+    canonicalUserId: "telegram:fixture-chat",
+    userId: "fixture-chat",
+  }, fn);
+}
+
+async function commandProbe() {
+  const names = new Set(commands.list().map((command) => command.name));
+  assert.ok(names.has("ask"), "/ask is registered");
+  const sent = [];
+  const dispatch = (text) => inChat(() => commands.dispatch(text, {
+    adapter: { id: "fixture", type: "fixture" },
+    channelId: "fixture-chat",
+    canonicalUserId: "telegram:fixture-chat",
+    userId: "fixture-chat",
+  }), sent);
+
+  state.settings.backend = "codex";
+  stateApi.getProviderSettings(state, "codex").effort = null;
+  await dispatch("/effort high");
+  assert.strictEqual(stateApi.getProviderSettings(state, "codex").effort, "high", "Codex native effort is accepted");
+
+  const beforeBudget = structuredClone(state.providerSettings);
+  await dispatch("/budget 5");
+  assert.deepStrictEqual(state.providerSettings, beforeBudget);
+  assert.match(sent.at(-1).text, /no per-run monetary budget/i);
+
+  const beforeWorktree = structuredClone(state.providerSettings);
+  await dispatch("/worktree");
+  assert.deepStrictEqual(state.providerSettings, beforeWorktree);
+  assert.match(sent.at(-1).text, /worktree/i);
+
+  await dispatch("/plan");
+  assert.strictEqual(stateApi.getProviderSettings(state, "codex").permissionMode, "plan");
+  await dispatch("/ask");
+  assert.strictEqual(stateApi.getProviderSettings(state, "codex").permissionMode, "ask");
+
+  await dispatch("/status");
+  assert.match(sent.at(-1).text, /Provider: OpenAI Codex/);
+  assert.match(sent.at(-1).text, /Capabilities:/);
+  assert.match(sent.at(-1).text, /budget unsupported/i);
+
+  await dispatch("/backend");
+  assert.deepStrictEqual(
+    callbacks(sent.at(-1).options.keyboard.inline_keyboard).map((value) => value.slice(3)),
+    providers.listProviders().map((provider) => provider.id),
+  );
+
+  await dispatch("/model");
+  const modelControls = callbacks(sent.at(-1).options.keyboard.inline_keyboard);
+  assert.ok(modelControls.includes("mb:codex:gpt-5.4"));
+  assert.ok(modelControls.includes("mb:codex:gpt-5.4-mini"));
+  assert.ok(!modelControls.includes("mb:codex:o4-mini"));
+  assert.ok(modelControls.includes("mb:claude:claude-sonnet-4-6"));
+}
+
+async function callbackProbe() {
+  state.settings.backend = "codex";
+  stateApi.getProviderSettings(state, "codex").budget = null;
+  const before = structuredClone(state.providerSettings);
+  const sent = [];
+  await inChat(() => handleAction({
+    adapter: { id: "fixture", type: "fixture" },
+    channelId: "fixture-chat",
+    canonicalUserId: "telegram:fixture-chat",
+    userId: "fixture-chat",
+    action: { payload: "b:codex:5" },
+  }), sent);
+  assert.deepStrictEqual(state.providerSettings, before, "unsupported callback cannot mutate state");
+  assert.match(sent.at(-1).text, /no per-run monetary budget/i);
+
+  state.settings.backend = "claude";
+  const stale = structuredClone(state.providerSettings);
+  await inChat(() => handleAction({
+    adapter: { id: "fixture", type: "fixture" },
+    channelId: "fixture-chat",
+    canonicalUserId: "telegram:fixture-chat",
+    userId: "fixture-chat",
+    action: { payload: "e:codex:high" },
+  }), sent);
+  assert.deepStrictEqual(state.providerSettings, stale, "stale callback cannot mutate inactive provider");
+  assert.match(sent.at(-1).text, /stale/i);
+}
+
+async function adapterReadOnlyProbe() {
+  const { createClaudeProvider } = require("./core/providers/claude");
+  const { createCodexProvider } = require("./core/providers/codex");
+  const common = {
+    resolveExecutable: () => process.execPath,
+    buildEnv: () => ({}),
+    getAuthStatus: () => ({ state: "authenticated", reason: null }),
+    hookTransport: false,
+  };
+  const context = {
+    coreInstructions: "policy",
+    dynamicContext: "context",
+    userPrompt: "question",
+    providerSettings: { permissionMode: "ask" },
+    fresh: true,
+  };
+  const claude = createClaudeProvider(common).buildMainInvocation(context);
+  assert.deepStrictEqual(claude.args.slice(claude.args.indexOf("--permission-mode"), claude.args.indexOf("--permission-mode") + 2), ["--permission-mode", "plan"]);
+  const codex = createCodexProvider({ ...common, defaultModel: "gpt-fixture" }).buildMainInvocation(context);
+  assert.deepStrictEqual(codex.args.slice(codex.args.indexOf("--sandbox"), codex.args.indexOf("--sandbox") + 2), ["--sandbox", "read-only"]);
+  assert.ok(!codex.args.includes("--dangerously-bypass-approvals-and-sandbox"));
+}
+
+async function main() {
+  pickerProbe();
+  mutationProbe();
+  await commandProbe();
+  await callbackProbe();
+  await adapterReadOnlyProbe();
+  console.log("provider capabilities OK");
+}
+
+main().catch((error) => {
+  console.error(error.stack || error.message);
+  process.exitCode = 1;
+}).finally(() => {
+  fs.rmSync(configDir, { recursive: true, force: true });
+});

package/test-provider-claude.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const path = require("path");
+const { validateInvocation, validateProvider } = require("./core/providers/contract");
+const { createClaudeProvider } = require("./core/providers/claude");
+const { getProvider } = require("./core/providers");
+
+function deepFreeze(value) {
+  if (!value || typeof value !== "object" || Object.isFrozen(value)) return value;
+  for (const child of Object.values(value)) deepFreeze(child);
+  return Object.freeze(value);
+}
+
+const safeEnv = {
+  PATH: "/fixture/bin",
+  HOME: "/fixture/home",
+  CLAUDE_CODE_OAUTH_TOKEN: "fixture-present-not-a-real-token",
+};
+let authState = { state: "authenticated", reason: null, method: "fixture" };
+const provider = createClaudeProvider({
+  hookTransport: false,
+  resolveExecutable: () => "/fixture/claude",
+  defaultModel: "claude-default-fixture",
+  buildEnv: () => ({ ...safeEnv }),
+  getAuthStatus: () => authState,
+  runCommand: (_binary, args) => {
+    if (args[0] === "--version") return { ok: true, output: "2.1.150 (Claude Code)", code: 0 };
+    if (args[0] === "--help") return {
+      ok: true,
+      output: "--append-system-prompt --output-format --resume --permission-mode --settings",
+      code: 0,
+    };
+    return { ok: false, output: "unexpected fixture command", code: 1 };
+  },
+});
+
+assert.strictEqual(validateProvider(provider), provider);
+assert.strictEqual(provider.id, "claude");
+assert.strictEqual(getProvider("claude").id, "claude", "built-in registry exposes the adapter without probing it at import");
+assert.strictEqual(provider.label, "Claude Code");
+assert.strictEqual(provider.isAvailable(), true);
+assert.strictEqual(provider.executable(), "/fixture/claude");
+assert.strictEqual(provider.defaultModel(), "claude-default-fixture");
+assert.ok(provider.modelChoices().includes("claude-fable-5"));
+assert.ok(provider.modelChoices().includes("claude-sonnet-4-6"));
+assert.deepStrictEqual(provider.compatibilityStatus(), {
+  state: "compatible",
+  version: "2.1.150",
+  reason: null,
+});
+assert.strictEqual(provider.capabilities.resume.support, "native");
+assert.strictEqual(provider.capabilities.readOnlyMode.support, "native");
+assert.deepStrictEqual(provider.capabilities.effort.values, ["low", "medium", "high", "xhigh", "max"]);
+assert.strictEqual(provider.capabilities.budget.support, "native");
+assert.strictEqual(provider.capabilities.worktree.support, "native");
+assert.strictEqual(provider.capabilities.maxTurns.support, "native");
+assert.strictEqual(provider.capabilities.partialStreaming.support, "native");
+assert.strictEqual(provider.capabilities.persistentUtilityStream.support, "native");
+assert.strictEqual(provider.capabilities.preToolHook.support, "native");
+assert.strictEqual(provider.capabilities.imageFlag.support, "unsupported");
+
+const richContext = deepFreeze({
+  coreInstructions: "STABLE CORE",
+  dynamicContext: "DYNAMIC CONTEXT",
+  userPrompt: "USER SENTINEL",
+  fresh: true,
+  sessionId: "ignored-because-fresh",
+  providerSettings: {
+    model: "claude-sonnet-4-6",
+    effort: "high",
+    budget: 2.5,
+    permissionMode: "plan",
+    worktree: true,
+  },
+  maxTurns: 4,
+  transcriptDirectory: "/fixture/transcripts",
+  voiceStream: true,
+  toolHookSettings: "/fixture/deny-gate.json",
+});
+const before = JSON.stringify(richContext);
+const richInvocation = validateInvocation(provider.buildMainInvocation(richContext));
+assert.strictEqual(JSON.stringify(richContext), before, "frozen run context must not be mutated");
+assert.strictEqual(richInvocation.binary, "/fixture/claude");
+assert.deepStrictEqual(richInvocation.args, [
+  "-p",
+  "--verbose",
+  "--output-format", "stream-json",
+  "--append-system-prompt", "STABLE CORE",
+  "--settings", "/fixture/deny-gate.json",
+  "--add-dir", "/fixture/transcripts",
+  "--model", "claude-sonnet-4-6",
+  "--max-turns", "4",
+  "--effort", "high",
+  "--max-budget-usd", "2.5",
+  "--permission-mode", "plan",
+  "--worktree",
+  "--include-partial-messages",
+  "DYNAMIC CONTEXT\n\nUSER SENTINEL",
+]);
+assert.deepStrictEqual(richInvocation.env, safeEnv);
+assert.strictEqual(richInvocation.stdin, null);
+assert.ok(richInvocation.parserState.seenUsage instanceof Set);
+
+function simpleContext(overrides = {}) {
+  return deepFreeze({
+    coreInstructions: "CORE",
+    dynamicContext: "",
+    userPrompt: "PROMPT",
+    providerSettings: {},
+    ...overrides,
+  });
+}
+
+const fresh = provider.buildMainInvocation(simpleContext({ fresh: true, sessionId: "old" }));
+assert.ok(!fresh.args.includes("--resume"));
+assert.ok(!fresh.args.includes("--continue"));
+assert.ok(fresh.args.includes("--dangerously-skip-permissions"), "direct mode preserves current behavior");
+
+const resumed = provider.buildMainInvocation(simpleContext({ resumeSessionId: "resume-1" }));
+assert.deepStrictEqual(resumed.args.slice(6, 10), ["--resume", "resume-1", "--model", "claude-default-fixture"]);
+
+const implicitResume = provider.buildMainInvocation(simpleContext({ sessionId: "active-1" }));
+assert.ok(implicitResume.args.indexOf("--resume") >= 0);
+assert.strictEqual(implicitResume.args[implicitResume.args.indexOf("--resume") + 1], "active-1");
+
+const continued = provider.buildMainInvocation(simpleContext({ continueSession: true, sessionId: "active-1" }));
+assert.ok(continued.args.includes("--continue"));
+assert.ok(!continued.args.includes("--resume"));
+
+const readOnlyAsk = provider.buildMainInvocation(simpleContext({ providerSettings: { permissionMode: "ask" } }));
+assert.deepStrictEqual(readOnlyAsk.args.slice(readOnlyAsk.args.indexOf("--permission-mode"), -1), ["--permission-mode", "plan"]);
+
+assert.throws(
+  () => provider.buildMainInvocation(simpleContext({ resumeSessionId: "one", continueSession: true })),
+  (error) => error && error.code === "INVALID_PROVIDER_CONTEXT",
+);
+assert.throws(
+  () => provider.buildMainInvocation(simpleContext({ providerSettings: { effort: "extreme" } })),
+  (error) => error && error.code === "UNSUPPORTED_PROVIDER_SETTING",
+);
+assert.throws(
+  () => provider.buildMainInvocation(simpleContext({ providerSettings: { budget: -1 } })),
+  (error) => error && error.code === "INVALID_PROVIDER_CONTEXT",
+);
+assert.throws(
+  () => provider.buildMainInvocation(deepFreeze({ dynamicContext: "only", userPrompt: "raw" })),
+  (error) => error && error.code === "MISSING_CORE_INSTRUCTIONS",
+);
+
+const utility = validateInvocation(provider.buildUtilityInvocation(deepFreeze({
+  coreInstructions: "UTILITY CORE",
+  userPrompt: "UTILITY PROMPT",
+  readOnly: true,
+  allowedTools: ["Read", "Glob"],
+  disallowedTools: ["Write"],
+  outputSchema: { type: "object", required: ["ok"] },
+  tier: "low",
+  maxTurns: 2,
+  toolHookSettings: "/fixture/utility-hook.json",
+})));
+assert.ok(utility.args.includes("--no-session-persistence"));
+assert.deepStrictEqual(utility.args.slice(utility.args.indexOf("--allowedTools"), utility.args.indexOf("--allowedTools") + 2), ["--allowedTools", "Read,Glob"]);
+assert.deepStrictEqual(utility.args.slice(utility.args.indexOf("--permission-mode"), utility.args.indexOf("--permission-mode") + 2), ["--permission-mode", "plan"]);
+assert.strictEqual(utility.args[utility.args.indexOf("--model") + 1], "claude-haiku-4-5-20251001");
+assert.strictEqual(utility.args[utility.args.indexOf("--json-schema") + 1], JSON.stringify({ type: "object", required: ["ok"] }));
+assert.strictEqual(utility.stdin, "UTILITY PROMPT", "utility prompt uses protected stdin transport");
+assert.ok(!utility.args.includes("UTILITY PROMPT"), "utility prompt is absent from argv");
+
+const decoder = provider.createEventDecoder();
+const raw = decoder.push(Buffer.from('{"type":"system","subtype":"init","session_id":"bound-session"}\n'));
+assert.deepStrictEqual(provider.normalizeEvent(raw[0], richInvocation.parserState), [{ type: "session", sessionId: "bound-session" }]);
+
+assert.strictEqual(provider.authStatus().state, "authenticated");
+assert.strictEqual(provider.preflightAuth(), null);
+authState = { state: "unauthenticated", reason: "login required" };
+const authFailure = provider.preflightAuth();
+assert.strictEqual(authFailure.code, "PROVIDER_UNAUTHENTICATED");
+assert.match(authFailure.message, /Claude auth needs attention/);
+assert.match(provider.authHelp(), /setup_token/);
+
+const missing = createClaudeProvider({ hookTransport: false, resolveExecutable: () => null, getAuthStatus: () => ({ state: "not_checked", reason: "missing" }) });
+assert.strictEqual(missing.isAvailable(), false);
+assert.throws(
+  () => missing.buildMainInvocation(simpleContext()),
+  (error) => error && error.code === "NO_AVAILABLE_PROVIDER",
+);
+
+const incompatible = createClaudeProvider({
+  hookTransport: false,
+  resolveExecutable: () => "/fixture/old-claude",
+  buildEnv: () => ({ PATH: "/fixture" }),
+  getAuthStatus: () => ({ state: "unknown", reason: "not checked" }),
+  runCommand: (_binary, args) => args[0] === "--version"
+    ? { ok: true, output: "0.1.0", code: 0 }
+    : { ok: true, output: "--output-format", code: 0 },
+});
+assert.strictEqual(incompatible.compatibilityStatus().state, "incompatible");
+
+const source = fs.readFileSync(path.join(__dirname, "core", "providers", "claude.js"), "utf8");
+assert.ok(!source.includes('require("child_process")'), "provider adapter must return invocation data instead of spawning");
+
+console.log("Claude provider OK");