helixevo 0.7.0 → 0.8.0

package/dist/cli.js

@@ -2075,28 +2075,93 @@ function ensureDir(dir) {
     mkdirSync(dir, { recursive: true });
   }
 }
+function providerConfigKey(provider) {
+  if (provider === "claude-code")
+    return "claudeCode";
+  if (provider === "codex")
+    return "codex";
+  return "ollama";
+}
+function uniqueProviders(providers) {
+  return [...new Set(providers.filter((provider) => provider === "claude-code" || provider === "codex" || provider === "ollama"))];
+}
+function syncTopLevelModels(config) {
+  const providerKey = providerConfigKey(config.llm.defaultProvider);
+  const providerConfig = config.llm.providers[providerKey];
+  return {
+    ...config,
+    model: providerConfig.model,
+    judgeModel: providerConfig.judgeModel
+  };
+}
+function normalizeConfig(raw) {
+  const input = raw ?? {};
+  const inputProviders = input.llm?.providers;
+  const claudeCode = {
+    ...DEFAULT_CONFIG.llm.providers.claudeCode,
+    ...inputProviders?.claudeCode ?? {},
+    model: inputProviders?.claudeCode?.model ?? input.model ?? DEFAULT_CONFIG.llm.providers.claudeCode.model,
+    judgeModel: inputProviders?.claudeCode?.judgeModel ?? input.judgeModel ?? DEFAULT_CONFIG.llm.providers.claudeCode.judgeModel
+  };
+  const codex = {
+    ...DEFAULT_CONFIG.llm.providers.codex,
+    ...inputProviders?.codex ?? {}
+  };
+  const ollama = {
+    ...DEFAULT_CONFIG.llm.providers.ollama,
+    ...inputProviders?.ollama ?? {}
+  };
+  const fallbackOrder = uniqueProviders(input.llm?.fallbackOrder ?? DEFAULT_CONFIG.llm.fallbackOrder);
+  const normalized = {
+    model: input.model ?? DEFAULT_CONFIG.model,
+    judgeModel: input.judgeModel ?? DEFAULT_CONFIG.judgeModel,
+    llm: {
+      defaultProvider: input.llm?.defaultProvider ?? DEFAULT_CONFIG.llm.defaultProvider,
+      fallbackPolicy: input.llm?.fallbackPolicy ?? DEFAULT_CONFIG.llm.fallbackPolicy,
+      fallbackOrder,
+      providers: {
+        claudeCode,
+        codex,
+        ollama
+      }
+    },
+    evolution: {
+      ...DEFAULT_CONFIG.evolution,
+      ...input.evolution ?? {}
+    },
+    quality: {
+      ...DEFAULT_CONFIG.quality,
+      ...input.quality ?? {}
+    },
+    reporting: {
+      ...DEFAULT_CONFIG.reporting,
+      ...input.reporting ?? {}
+    },
+    paths: {
+      ...DEFAULT_CONFIG.paths,
+      ...input.paths ?? {}
+    }
+  };
+  if (normalized.paths.data.includes(".skillgraph")) {
+    normalized.paths.data = HELIX_DIR;
+  }
+  if (normalized.paths.generalSkills.includes(".skillgraph")) {
+    normalized.paths.generalSkills = join(HELIX_DIR, "general");
+  }
+  normalized.llm.fallbackOrder = uniqueProviders(normalized.llm.fallbackOrder.filter((provider) => provider !== normalized.llm.defaultProvider));
+  return syncTopLevelModels(normalized);
+}
 function loadConfig() {
   if (_configCache)
     return _configCache;
-  let config;
-  if (!existsSync(CONFIG_PATH)) {
-    config = DEFAULT_CONFIG;
-  } else {
-    const raw = readFileSync(CONFIG_PATH, "utf-8");
-    config = { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
-  }
-  if (config.paths.data.includes(".skillgraph")) {
-    config.paths.data = HELIX_DIR;
-  }
-  if (config.paths.generalSkills.includes(".skillgraph")) {
-    config.paths.generalSkills = join(HELIX_DIR, "general");
-  }
+  const config = existsSync(CONFIG_PATH) ? normalizeConfig(JSON.parse(readFileSync(CONFIG_PATH, "utf-8"))) : normalizeConfig(undefined);
   _configCache = config;
   return config;
 }
 function saveConfig(config) {
   ensureDir(HELIX_DIR);
-  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+  writeFileSync(CONFIG_PATH, JSON.stringify(normalizeConfig(config), null, 2));
+  _configCache = null;
 }
 function getDataPath(filename) {
   const config = loadConfig();
@@ -2113,6 +2178,32 @@ var init_config = __esm(() => {
   DEFAULT_CONFIG = {
     model: "sonnet",
     judgeModel: "sonnet",
+    llm: {
+      defaultProvider: "claude-code",
+      fallbackPolicy: "disabled",
+      fallbackOrder: [],
+      providers: {
+        claudeCode: {
+          enabled: true,
+          command: "claude",
+          model: "sonnet",
+          judgeModel: "sonnet"
+        },
+        codex: {
+          enabled: false,
+          command: "codex",
+          model: "gpt-5-codex",
+          judgeModel: "gpt-5-codex"
+        },
+        ollama: {
+          enabled: false,
+          command: "ollama",
+          host: "http://127.0.0.1:11434",
+          model: "qwen3-coder:latest",
+          judgeModel: "qwen3-coder:latest"
+        }
+      }
+    },
     evolution: {
       schedule: "0 2 * * *",
       generalizationSchedule: "0 3 * * 5",
@@ -9647,6 +9738,68 @@ function loadGovernanceState() {
     return state;
   return { ...DEFAULT_GOVERNANCE_STATE, ...state, selectionMode: state.selectionMode === "manual" && state.manualMode ? "manual" : "auto" };
 }
+function providerSnapshotDefaults(provider) {
+  const config = loadConfig();
+  const providerConfig = provider === "claude-code" ? config.llm.providers.claudeCode : provider === "codex" ? config.llm.providers.codex : config.llm.providers.ollama;
+  return {
+    provider,
+    configured: providerConfig.enabled,
+    enabled: providerConfig.enabled,
+    installed: false,
+    available: false,
+    status: "unknown",
+    model: providerConfig.model,
+    judgeModel: providerConfig.judgeModel,
+    summary: providerConfig.enabled ? `No ${provider} execution has been recorded yet.` : `${provider} is installed as an optional provider but not enabled in config.`,
+    nextStep: providerConfig.enabled ? `Run a provider-backed command or refresh provider status to record live ${provider} health.` : `Enable ${provider} in ~/.helix/config.json before selecting it.`,
+    notices: []
+  };
+}
+function defaultLlmRuntimeState() {
+  const config = loadConfig();
+  return {
+    updatedAt: new Date(0).toISOString(),
+    defaultProvider: config.llm.defaultProvider,
+    fallbackPolicy: config.llm.fallbackPolicy,
+    fallbackOrder: [...config.llm.fallbackOrder],
+    providers: {
+      "claude-code": providerSnapshotDefaults("claude-code"),
+      codex: providerSnapshotDefaults("codex"),
+      ollama: providerSnapshotDefaults("ollama")
+    }
+  };
+}
+function loadLlmRuntimeState() {
+  const defaults = defaultLlmRuntimeState();
+  const stored = readJson("llm-runtime-state.json", defaults);
+  return {
+    ...defaults,
+    ...stored,
+    defaultProvider: loadConfig().llm.defaultProvider,
+    fallbackPolicy: loadConfig().llm.fallbackPolicy,
+    fallbackOrder: [...loadConfig().llm.fallbackOrder],
+    providers: {
+      "claude-code": {
+        ...defaults.providers["claude-code"],
+        ...stored.providers?.["claude-code"] ?? {}
+      },
+      codex: {
+        ...defaults.providers.codex,
+        ...stored.providers?.codex ?? {}
+      },
+      ollama: {
+        ...defaults.providers.ollama,
+        ...stored.providers?.ollama ?? {}
+      }
+    }
+  };
+}
+function saveLlmRuntimeState(state) {
+  writeJson("llm-runtime-state.json", state);
+}
+function saveTopologyOptimizeStatus(status) {
+  writeJson("topology-optimize-status.json", status);
+}
 function loadStoredTopologyReviewCandidates() {
   return readJson("topology-review-candidates.json", []).slice().sort((a, b) => b.lastObservedAt.localeCompare(a.lastObservedAt) || a.title.localeCompare(b.title));
 }
@@ -11559,6 +11712,40 @@ var init_data = __esm(() => {
 
 // src/utils/llm.ts
 import { spawn } from "node:child_process";
+import { existsSync as existsSync4, mkdtempSync, readFileSync as readFileSync4, rmSync } from "node:fs";
+import { join as join4 } from "node:path";
+import { tmpdir } from "node:os";
+function providerConfigKey2(provider) {
+  if (provider === "claude-code")
+    return "claudeCode";
+  if (provider === "codex")
+    return "codex";
+  return "ollama";
+}
+function providerLabel(provider) {
+  return PROVIDER_LABELS[provider];
+}
+function getProviderLabel(provider) {
+  return providerLabel(provider);
+}
+function getProviderConfig(config, provider) {
+  return config.llm.providers[providerConfigKey2(provider)];
+}
+function supportsCapability(provider, capability) {
+  return PROVIDER_CAPABILITIES[provider].includes(capability);
+}
+function capabilityScope(capability) {
+  return capability === "web-search" ? "claude-only" : "shared";
+}
+function buildSystemPrompt(system, prompt) {
+  if (!system)
+    return prompt;
+  return `System instructions:
+${system}
+
+User request:
+${prompt}`;
+}
 function buildClaudeEnv({ dropOauthToken }) {
   const env = { ...process.env };
   if (dropOauthToken) {
@@ -11566,22 +11753,71 @@ function buildClaudeEnv({ dropOauthToken }) {
   }
   return env;
 }
-function runClaudeOnce(prompt, args, env) {
+function classifyClaudeFailure(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (CLAUDE_AUTH_ERROR_PATTERNS.some((pattern) => message.includes(pattern)))
+    return "auth";
+  if (message.includes("timed out"))
+    return "timeout";
+  if (message.includes("Failed to spawn claude"))
+    return "spawn";
+  return "unknown";
+}
+function classifyCodexFailure(error) {
+  const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+  if (CODEX_AUTH_ERROR_PATTERNS.some((pattern) => message.includes(pattern.toLowerCase())))
+    return "auth";
+  if (message.includes("timed out"))
+    return "timeout";
+  if (message.includes("failed to spawn codex") || message.includes("enoent"))
+    return "spawn";
+  return "unknown";
+}
+function classifyOllamaFailure(error) {
+  const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+  if (OLLAMA_MODEL_MISSING_PATTERNS.some((pattern) => message.includes(pattern)))
+    return "model-missing";
+  if (message.includes("econnrefused") || message.includes("connect") || message.includes("network"))
+    return "network";
+  if (message.includes("timed out") || message.includes("aborterror"))
+    return "timeout";
+  return "unknown";
+}
+function hasBinary(command) {
+  return new Promise((resolve) => {
+    const proc = spawn(command, ["--help"], { stdio: "ignore" });
+    let settled = false;
+    proc.on("error", () => {
+      if (!settled) {
+        settled = true;
+        resolve(false);
+      }
+    });
+    proc.on("close", () => {
+      if (!settled) {
+        settled = true;
+        resolve(true);
+      }
+    });
+  });
+}
+function runProcess(command, args, options) {
   return new Promise((resolve, reject) => {
-    const proc = spawn("claude", args, {
+    const proc = spawn(command, args, {
       stdio: ["pipe", "pipe", "pipe"],
-      env
+      env: options?.env
     });
     let stdout = "";
     let stderr = "";
     let settled = false;
+    const timeoutMs = options?.timeoutMs ?? 180000;
     const timeout = setTimeout(() => {
       proc.kill();
       if (!settled) {
         settled = true;
-        reject(new Error("claude call timed out after 180s"));
+        reject(new Error(`${command} call timed out after ${Math.round(timeoutMs / 1000)}s`));
       }
-    }, 180000);
+    }, timeoutMs);
     proc.stdout.on("data", (data) => {
       stdout += data.toString();
     });
@@ -11594,10 +11830,10 @@ function runClaudeOnce(prompt, args, env) {
         return;
       settled = true;
       if (code !== 0) {
-        const output = (stderr || stdout).slice(0, 500);
-        reject(new Error(`claude exited with code ${code}: ${output}`));
+        const output = (stderr || stdout || `No output from ${command}`).slice(0, 1500);
+        reject(new Error(`${command} exited with code ${code}: ${output}`));
       } else {
-        resolve(stdout.trim());
+        resolve({ stdout: stdout.trim(), stderr: stderr.trim() });
       }
     });
     proc.on("error", (err) => {
@@ -11605,47 +11841,630 @@ function runClaudeOnce(prompt, args, env) {
       if (settled)
         return;
       settled = true;
-      reject(new Error(`Failed to spawn claude: ${err.message}`));
+      reject(new Error(`Failed to spawn ${command}: ${err.message}`));
     });
-    proc.stdin.write(prompt);
+    if (options?.stdin)
+      proc.stdin.write(options.stdin);
     proc.stdin.end();
   });
 }
-function isRetryableClaudeAuthError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  return CLAUDE_AUTH_ERROR_PATTERNS.some((pattern) => message.includes(pattern));
+async function readClaudeAuthStatus(command, env) {
+  try {
+    const result = await runProcess(command, ["auth", "status"], { env, timeoutMs: 1e4 });
+    const raw = (result.stdout || result.stderr).trim();
+    if (!raw)
+      return null;
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function summarizeAuthStatus(status) {
+  if (!status)
+    return "Unable to read `claude auth status` output.";
+  if (status.loggedIn) {
+    const method = status.authMethod ? ` via ${status.authMethod}` : "";
+    const plan = status.subscriptionType ? ` (${status.subscriptionType})` : "";
+    return `\`claude auth status\` reports logged in${method}${plan}, but live execution still returned unauthorized.`;
+  }
+  return "`claude auth status` does not report an active login.";
+}
+function buildClaudeAuthFailureMessage(params) {
+  const firstMessage = params.firstError instanceof Error ? params.firstError.message : String(params.firstError);
+  const finalMessage = params.finalError instanceof Error ? params.finalError.message : String(params.finalError);
+  const lines = [
+    "Claude execution failed because authentication is not healthy.",
+    params.hadOauthToken ? "Retry without inherited `CLAUDE_CODE_OAUTH_TOKEN` was attempted, but execution still failed." : "No inherited `CLAUDE_CODE_OAUTH_TOKEN` was available to strip before failure classification.",
+    summarizeAuthStatus(params.authStatus),
+    `Next step: run \`${params.command} auth login\` to refresh credentials, then retry the command.`
+  ];
+  if (params.hadOauthToken) {
+    lines.push("If you export `CLAUDE_CODE_OAUTH_TOKEN` in your shell, remove it so managed Claude auth can take over.");
+  }
+  lines.push("");
+  lines.push(`First failure: ${firstMessage.slice(0, 500)}`);
+  if (finalMessage !== firstMessage)
+    lines.push(`Final failure: ${finalMessage.slice(0, 500)}`);
+  return lines.join(`
+`);
+}
+function buildCodexFailureMessage(kind, error, command) {
+  const baseMessage = error instanceof Error ? error.message : String(error);
+  if (kind === "auth") {
+    return new ProviderCommandError({
+      provider: "codex",
+      kind,
+      message: [
+        "Codex execution failed because authentication is not healthy.",
+        `Next step: run \`${command} login\` to refresh Codex credentials, then retry the command.`,
+        "",
+        `Failure: ${baseMessage.slice(0, 500)}`
+      ].join(`
+`),
+      nextStep: `Run \`${command} login\` to refresh Codex credentials, then retry.`
+    });
+  }
+  if (kind === "spawn") {
+    return new ProviderCommandError({
+      provider: "codex",
+      kind,
+      message: `Codex execution could not start. Ensure the \`${command}\` CLI is installed and available in PATH.
+
+Failure: ${baseMessage.slice(0, 500)}`,
+      nextStep: `Install or fix the \`${command}\` CLI, then retry.`
+    });
+  }
+  return new ProviderCommandError({
+    provider: "codex",
+    kind,
+    message: `Codex execution failed.
+
+Failure: ${baseMessage.slice(0, 500)}`,
+    nextStep: "Review the Codex CLI error and retry after fixing the provider state."
+  });
+}
+function buildOllamaFailureMessage(kind, error, host, model) {
+  const baseMessage = error instanceof Error ? error.message : String(error);
+  if (kind === "model-missing") {
+    return new ProviderCommandError({
+      provider: "ollama",
+      kind,
+      message: `Ollama could not run model \`${model}\` because it is not available locally.
+
+Failure: ${baseMessage.slice(0, 500)}`,
+      nextStep: `Pull the model with \`ollama pull ${model}\` or change the configured Ollama model, then retry.`
+    });
+  }
+  if (kind === "network") {
+    return new ProviderCommandError({
+      provider: "ollama",
+      kind,
+      message: `Ollama is not reachable at ${host}.
+
+Failure: ${baseMessage.slice(0, 500)}`,
+      nextStep: "Start the Ollama daemon or verify the configured host before retrying."
+    });
+  }
+  return new ProviderCommandError({
+    provider: "ollama",
+    kind,
+    message: `Ollama execution failed.
+
+Failure: ${baseMessage.slice(0, 500)}`,
+    nextStep: "Review the Ollama error, verify the daemon/model, and retry."
+  });
+}
+async function runClaudeOnce(prompt, args, command, env) {
+  const result = await runProcess(command, args, { stdin: prompt, env });
+  return result.stdout.trim();
 }
-async function runClaude(prompt, args) {
+async function runClaudeWithRecovery(prompt, args, command) {
+  const inheritedEnv = buildClaudeEnv({ dropOauthToken: false });
   try {
-    return await runClaudeOnce(prompt, args, buildClaudeEnv({ dropOauthToken: false }));
+    return await runClaudeOnce(prompt, args, command, inheritedEnv);
   } catch (error) {
-    if (!process.env.CLAUDE_CODE_OAUTH_TOKEN || !isRetryableClaudeAuthError(error)) {
+    if (classifyClaudeFailure(error) !== "auth") {
       throw error;
     }
-    return runClaudeOnce(prompt, args, buildClaudeEnv({ dropOauthToken: true }));
+    const hadOauthToken = Boolean(process.env.CLAUDE_CODE_OAUTH_TOKEN);
+    const scrubbedEnv = buildClaudeEnv({ dropOauthToken: true });
+    if (!hadOauthToken) {
+      const authStatus = await readClaudeAuthStatus(command, scrubbedEnv);
+      throw new ProviderCommandError({
+        provider: "claude-code",
+        kind: "auth",
+        message: buildClaudeAuthFailureMessage({
+          command,
+          hadOauthToken,
+          authStatus,
+          firstError: error,
+          finalError: error
+        }),
+        nextStep: `Run \`${command} auth login\` to refresh credentials, then retry.`,
+        loggedIn: authStatus?.loggedIn,
+        authMethod: authStatus?.authMethod,
+        apiProvider: authStatus?.apiProvider
+      });
+    }
+    try {
+      return await runClaudeOnce(prompt, args, command, scrubbedEnv);
+    } catch (retryError) {
+      if (classifyClaudeFailure(retryError) !== "auth") {
+        throw retryError;
+      }
+      const authStatus = await readClaudeAuthStatus(command, scrubbedEnv);
+      throw new ProviderCommandError({
+        provider: "claude-code",
+        kind: "auth",
+        message: buildClaudeAuthFailureMessage({
+          command,
+          hadOauthToken,
+          authStatus,
+          firstError: error,
+          finalError: retryError
+        }),
+        nextStep: `Run \`${command} auth login\` to refresh credentials, then retry.`,
+        loggedIn: authStatus?.loggedIn,
+        authMethod: authStatus?.authMethod,
+        apiProvider: authStatus?.apiProvider
+      });
+    }
   }
 }
-async function chat(options) {
-  const config = loadConfig();
-  const model = options.model ?? config.model;
+async function runClaudeCapability(request, config) {
+  const providerConfig = config.llm.providers.claudeCode;
+  if (!providerConfig.enabled) {
+    throw new ProviderCommandError({
+      provider: "claude-code",
+      kind: "not-configured",
+      message: "Claude Code is disabled in ~/.helix/config.json.",
+      nextStep: "Enable Claude Code in the Helix config or choose another provider for shared capabilities."
+    });
+  }
+  const command = providerConfig.command;
+  const model = request.model ?? (request.capability === "judge" ? providerConfig.judgeModel : providerConfig.model);
+  if (request.capability === "web-search") {
+    const args2 = [
+      "--print",
+      "--allowedTools",
+      "WebSearch,WebFetch",
+      "--no-session-persistence",
+      "--dangerously-skip-permissions",
+      "--max-turns",
+      "8"
+    ];
+    if (model)
+      args2.push("--model", model);
+    return runClaudeWithRecovery(request.prompt, args2, command);
+  }
   const args = [
     "--print",
-    "--model",
-    model,
     "--output-format",
     "text",
     "--no-session-persistence"
   ];
-  if (options.system) {
-    args.push("--system-prompt", options.system);
+  if (model)
+    args.push("--model", model);
+  if (request.system)
+    args.push("--system-prompt", request.system);
+  return runClaudeWithRecovery(request.prompt, args, command);
+}
+async function runCodexCapability(request, config) {
+  const providerConfig = config.llm.providers.codex;
+  if (!providerConfig.enabled) {
+    throw new ProviderCommandError({
+      provider: "codex",
+      kind: "not-configured",
+      message: "Codex is disabled in ~/.helix/config.json.",
+      nextStep: "Enable Codex in the Helix config before selecting it."
+    });
+  }
+  const tempDir = mkdtempSync(join4(tmpdir(), "helix-codex-"));
+  const outputPath = join4(tempDir, "last-message.txt");
+  const model = request.model ?? (request.capability === "judge" ? providerConfig.judgeModel : providerConfig.model);
+  const prompt = buildSystemPrompt(request.system, request.prompt);
+  const args = [
+    "exec",
+    "-c",
+    'model_reasoning_effort="high"',
+    "--skip-git-repo-check",
+    "--sandbox",
+    "read-only",
+    "--output-last-message",
+    outputPath,
+    "--color",
+    "never"
+  ];
+  if (model)
+    args.push("--model", model);
+  args.push(prompt);
+  try {
+    await runProcess(providerConfig.command, args, { timeoutMs: 180000 });
+    if (!existsSync4(outputPath)) {
+      throw new Error("codex finished without writing an output file");
+    }
+    return readFileSync4(outputPath, "utf-8").trim();
+  } catch (error) {
+    throw buildCodexFailureMessage(classifyCodexFailure(error), error, providerConfig.command);
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+async function runOllamaCapability(request, config) {
+  const providerConfig = config.llm.providers.ollama;
+  if (!providerConfig.enabled) {
+    throw new ProviderCommandError({
+      provider: "ollama",
+      kind: "not-configured",
+      message: "Ollama is disabled in ~/.helix/config.json.",
+      nextStep: "Enable Ollama in the Helix config before selecting it."
+    });
+  }
+  const model = request.model ?? (request.capability === "judge" ? providerConfig.judgeModel : providerConfig.model);
+  const prompt = buildSystemPrompt(request.system, request.prompt);
+  try {
+    const response = await fetch(`${providerConfig.host.replace(/\/$/, "")}/api/generate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model,
+        prompt,
+        stream: false
+      }),
+      signal: AbortSignal.timeout(180000)
+    });
+    const raw = await response.text();
+    if (!response.ok) {
+      throw new Error(raw || `ollama request failed with status ${response.status}`);
+    }
+    const parsed = JSON.parse(raw);
+    if (parsed.error)
+      throw new Error(parsed.error);
+    return (parsed.response ?? "").trim();
+  } catch (error) {
+    throw buildOllamaFailureMessage(classifyOllamaFailure(error), error, providerConfig.host, model);
+  }
+}
+function initializeSnapshot(state, provider, config) {
+  const providerConfig = getProviderConfig(config, provider);
+  return {
+    ...state.providers[provider],
+    provider,
+    configured: providerConfig.enabled,
+    enabled: providerConfig.enabled,
+    model: providerConfig.model,
+    judgeModel: providerConfig.judgeModel,
+    notices: state.providers[provider]?.notices ?? []
+  };
+}
+function saveRuntimeMutation(mutator) {
+  const state = loadLlmRuntimeState();
+  mutator(state);
+  state.updatedAt = new Date().toISOString();
+  saveLlmRuntimeState(state);
+  return state;
+}
+function updateSnapshotOnFailure(params) {
+  saveRuntimeMutation((state) => {
+    const ranAt = new Date().toISOString();
+    const snapshot = initializeSnapshot(state, params.provider, params.config);
+    snapshot.installed = params.error.kind !== "spawn" && params.error.kind !== "not-installed" ? true : snapshot.installed;
+    snapshot.available = false;
+    snapshot.status = params.error.kind === "not-configured" ? "unavailable" : "degraded";
+    snapshot.summary = params.error.warning ?? params.error.message.split(`
+`)[0] ?? `${providerLabel(params.provider)} failed.`;
+    snapshot.nextStep = params.error.nextStep;
+    snapshot.failureKind = params.error.kind;
+    snapshot.warning = params.error.warning;
+    snapshot.lastCheckedAt = ranAt;
+    snapshot.lastSelectedAt = ranAt;
+    snapshot.lastFailedAt = ranAt;
+    snapshot.lastFailureMessage = params.error.message.slice(0, 600);
+    snapshot.notices = [...params.error.notices];
+    if (params.error.loggedIn !== undefined)
+      snapshot.loggedIn = params.error.loggedIn;
+    if (params.error.authMethod)
+      snapshot.authMethod = params.error.authMethod;
+    if (params.error.apiProvider)
+      snapshot.apiProvider = params.error.apiProvider;
+    state.providers[params.provider] = snapshot;
+  });
+}
+function updateSnapshotOnSuccess(params) {
+  saveRuntimeMutation((state) => {
+    const ranAt = new Date().toISOString();
+    const snapshot = initializeSnapshot(state, params.provider, params.config);
+    snapshot.installed = true;
+    snapshot.available = true;
+    snapshot.status = params.warning ? "degraded" : "healthy";
+    snapshot.summary = params.summary;
+    snapshot.warning = params.warning;
+    snapshot.failureKind = undefined;
+    snapshot.nextStep = undefined;
+    snapshot.lastCheckedAt = ranAt;
+    snapshot.lastSelectedAt = ranAt;
+    snapshot.lastUsedAt = ranAt;
+    snapshot.lastSucceededAt = ranAt;
+    snapshot.lastFailureMessage = undefined;
+    snapshot.notices = params.warning ? [params.warning] : [];
+    state.providers[params.provider] = snapshot;
+  });
+}
+function recordExecution(params) {
+  saveRuntimeMutation((state) => {
+    state.defaultProvider = params.config.llm.defaultProvider;
+    state.fallbackPolicy = params.config.llm.fallbackPolicy;
+    state.fallbackOrder = [...params.config.llm.fallbackOrder];
+    state.lastExecution = {
+      capability: params.capability,
+      scope: params.scope,
+      selectionMode: params.selectionMode,
+      selectedProvider: params.selectedProvider,
+      attemptedProviders: [...params.attemptedProviders],
+      usedProvider: params.usedProvider,
+      fallbackUsed: params.fallbackUsed,
+      success: params.success,
+      ranAt: new Date().toISOString(),
+      summary: params.summary,
+      nextStep: params.nextStep,
+      failureKind: params.failureKind,
+      warning: params.warning
+    };
+  });
+}
+async function executeProvider(provider, request, config) {
+  if (!supportsCapability(provider, request.capability)) {
+    throw new ProviderCommandError({
+      provider,
+      kind: "unknown",
+      message: `${providerLabel(provider)} does not support the ${request.capability} capability in HelixEvo yet.`,
+      nextStep: request.capability === "web-search" ? "Use Claude Code for Claude-scoped web-search and research operations." : "Select a provider that supports this capability or keep Claude Code as the default."
+    });
+  }
+  const providerConfig = getProviderConfig(config, provider);
+  const binaryRequired = provider !== "ollama";
+  if (binaryRequired && !await hasBinary(providerConfig.command)) {
+    throw new ProviderCommandError({
+      provider,
+      kind: "not-installed",
+      message: `${providerLabel(provider)} is not available because the \`${providerConfig.command}\` command could not be found.`,
+      nextStep: `Install or fix the ${providerLabel(provider)} CLI, then retry.`
+    });
+  }
+  const text = provider === "claude-code" ? await runClaudeCapability(request, config) : provider === "codex" ? await runCodexCapability(request, config) : await runOllamaCapability(request, config);
+  return { text, provider };
+}
+function buildProviderSummary(params) {
+  const capability = params.capability === "web-search" ? "Claude-scoped web search" : params.capability;
+  if (params.fallbackUsed) {
+    return `${capability} used fallback provider ${providerLabel(params.provider)} after ${providerLabel(params.selectedProvider)} degraded.`;
+  }
+  return `${capability} used ${providerLabel(params.provider)} successfully.`;
+}
+async function runWithProviderControl(request) {
+  const config = loadConfig();
+  const scope = capabilityScope(request.capability);
+  const selectedProvider = scope === "claude-only" ? "claude-code" : request.provider ?? config.llm.defaultProvider;
+  const selectionMode = request.provider ? "explicit" : "default";
+  const allowFallback = scope === "shared" && request.allowFallback !== false && config.llm.fallbackPolicy === "on-failure";
+  const attemptedProviders = [selectedProvider];
+  if (allowFallback) {
+    for (const provider of config.llm.fallbackOrder) {
+      if (provider !== selectedProvider && supportsCapability(provider, request.capability))
+        attemptedProviders.push(provider);
+    }
+  }
+  let lastError = null;
+  for (const provider of attemptedProviders) {
+    try {
+      const result = await executeProvider(provider, request, config);
+      const fallbackUsed = provider !== selectedProvider;
+      const summary2 = buildProviderSummary({
+        provider,
+        capability: request.capability,
+        selectedProvider,
+        fallbackUsed,
+        attemptedProviders
+      });
+      updateSnapshotOnSuccess({
+        provider,
+        config,
+        summary: summary2,
+        warning: fallbackUsed ? `Fallback used after ${providerLabel(selectedProvider)} degraded.` : undefined
+      });
+      recordExecution({
+        config,
+        capability: request.capability,
+        scope,
+        selectionMode,
+        selectedProvider,
+        attemptedProviders,
+        usedProvider: provider,
+        fallbackUsed,
+        success: true,
+        summary: summary2,
+        warning: fallbackUsed ? `Fallback used after ${providerLabel(selectedProvider)} degraded.` : undefined
+      });
+      return result.text;
+    } catch (error) {
+      const providerError = error instanceof ProviderCommandError ? error : new ProviderCommandError({
+        provider,
+        kind: provider === "claude-code" ? classifyClaudeFailure(error) : provider === "codex" ? classifyCodexFailure(error) : classifyOllamaFailure(error),
+        message: error instanceof Error ? error.message : String(error)
+      });
+      updateSnapshotOnFailure({ provider, config, error: providerError });
+      lastError = providerError;
+    }
+  }
+  const failure = lastError ?? new ProviderCommandError({
+    provider: selectedProvider,
+    kind: "unknown",
+    message: `${providerLabel(selectedProvider)} failed without a classified provider error.`
+  });
+  const fallbackAttempted = attemptedProviders.length > 1;
+  const summary = failure.kind === "not-configured" ? `${providerLabel(selectedProvider)} is not enabled for this HelixEvo capability.` : fallbackAttempted ? `${providerLabel(selectedProvider)} degraded and no configured fallback succeeded.` : `${providerLabel(selectedProvider)} degraded and no fallback was used.`;
+  recordExecution({
+    config,
+    capability: request.capability,
+    scope,
+    selectionMode,
+    selectedProvider,
+    attemptedProviders,
+    fallbackUsed: false,
+    success: false,
+    summary,
+    nextStep: failure.nextStep,
+    failureKind: failure.kind,
+    warning: failure.warning
+  });
+  throw failure;
+}
+async function probeClaudeProvider(config) {
+  const providerConfig = config.llm.providers.claudeCode;
+  const installed = await hasBinary(providerConfig.command);
+  if (!installed) {
+    return {
+      provider: "claude-code",
+      configured: providerConfig.enabled,
+      enabled: providerConfig.enabled,
+      installed: false,
+      available: false,
+      status: "unavailable",
+      model: providerConfig.model,
+      judgeModel: providerConfig.judgeModel,
+      summary: `Claude Code is unavailable because the \`${providerConfig.command}\` CLI is missing.`,
+      nextStep: `Install or restore the \`${providerConfig.command}\` CLI.`,
+      failureKind: "not-installed",
+      notices: [],
+      lastCheckedAt: new Date().toISOString()
+    };
+  }
+  const authStatus = await readClaudeAuthStatus(providerConfig.command, buildClaudeEnv({ dropOauthToken: true }));
+  const runtime = loadLlmRuntimeState();
+  const previous = runtime.providers["claude-code"];
+  const hasHealthyExecution = previous.lastSucceededAt && (!previous.lastFailedAt || previous.lastSucceededAt >= previous.lastFailedAt);
+  const status = hasHealthyExecution ? "healthy" : authStatus?.loggedIn ? "unknown" : "degraded";
+  return {
+    ...previous,
+    provider: "claude-code",
+    configured: providerConfig.enabled,
+    enabled: providerConfig.enabled,
+    installed: true,
+    available: Boolean(authStatus?.loggedIn),
+    loggedIn: authStatus?.loggedIn,
+    authMethod: authStatus?.authMethod,
+    apiProvider: authStatus?.apiProvider,
+    status,
+    model: providerConfig.model,
+    judgeModel: providerConfig.judgeModel,
+    summary: hasHealthyExecution ? previous.summary : authStatus?.loggedIn ? "Claude Code is installed and logged in, but no healthy live execution has been recorded yet." : "Claude Code is installed, but login/auth health is not currently confirmed.",
+    nextStep: hasHealthyExecution ? previous.nextStep : authStatus?.loggedIn ? "Run a Claude-backed command to confirm live execution health." : `Run \`${providerConfig.command} auth login\` to refresh Claude auth, then retry.`,
+    lastCheckedAt: new Date().toISOString(),
+    notices: previous.notices ?? []
+  };
+}
+async function probeCodexProvider(config) {
+  const providerConfig = config.llm.providers.codex;
+  const installed = await hasBinary(providerConfig.command);
+  const runtime = loadLlmRuntimeState();
+  const previous = runtime.providers.codex;
+  return {
+    ...previous,
+    provider: "codex",
+    configured: providerConfig.enabled,
+    enabled: providerConfig.enabled,
+    installed,
+    available: installed && providerConfig.enabled,
+    status: !providerConfig.enabled ? "unknown" : installed ? previous.status === "healthy" || previous.status === "degraded" ? previous.status : "unknown" : "unavailable",
+    model: providerConfig.model,
+    judgeModel: providerConfig.judgeModel,
+    summary: !providerConfig.enabled ? "GPT Codex is configured as an optional provider but currently disabled." : installed ? previous.summary || "GPT Codex is installed. No live Codex execution has been recorded yet." : `GPT Codex is unavailable because the \`${providerConfig.command}\` CLI is missing.`,
+    nextStep: !providerConfig.enabled ? "Enable Codex in ~/.helix/config.json before selecting it." : installed ? previous.nextStep || "Run a Codex-backed command to record live execution health." : `Install or restore the \`${providerConfig.command}\` CLI.`,
+    failureKind: installed ? previous.failureKind : "not-installed",
+    lastCheckedAt: new Date().toISOString(),
+    notices: previous.notices ?? []
+  };
+}
+async function probeOllamaProvider(config) {
+  const providerConfig = config.llm.providers.ollama;
+  const runtime = loadLlmRuntimeState();
+  const previous = runtime.providers.ollama;
+  let available = false;
+  let summary = previous.summary || "Ollama has not been probed yet.";
+  let nextStep = previous.nextStep;
+  let failureKind = previous.failureKind;
+  let status = previous.status;
+  const notices = [...previous.notices ?? []];
+  try {
+    const response = await fetch(`${providerConfig.host.replace(/\/$/, "")}/api/tags`, {
+      signal: AbortSignal.timeout(8000)
+    });
+    available = response.ok;
+    status = available ? previous.status === "healthy" || previous.status === "degraded" ? previous.status : "unknown" : "degraded";
+    summary = available ? previous.summary || "Ollama is reachable. No live Ollama execution has been recorded yet." : `Ollama responded from ${providerConfig.host} but did not report a healthy tags endpoint.`;
+    nextStep = available ? previous.nextStep || "Run an Ollama-backed command to record live execution health." : "Check the Ollama daemon and configured host before retrying.";
+    failureKind = available ? previous.failureKind : "network";
+  } catch (error) {
+    available = false;
+    status = providerConfig.enabled ? "degraded" : "unknown";
+    summary = `Ollama is not reachable at ${providerConfig.host}.`;
+    nextStep = "Start the Ollama daemon or correct the configured host, then retry.";
+    failureKind = classifyOllamaFailure(error);
+    notices.push(error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200));
   }
-  return runClaude(options.prompt, args);
+  return {
+    ...previous,
+    provider: "ollama",
+    configured: providerConfig.enabled,
+    enabled: providerConfig.enabled,
+    installed: true,
+    available,
+    status,
+    model: providerConfig.model,
+    judgeModel: providerConfig.judgeModel,
+    summary: !providerConfig.enabled ? "Ollama is configured as an optional provider but currently disabled." : summary,
+    nextStep: !providerConfig.enabled ? "Enable Ollama in ~/.helix/config.json before selecting it." : nextStep,
+    failureKind: !providerConfig.enabled ? undefined : failureKind,
+    lastCheckedAt: new Date().toISOString(),
+    notices
+  };
+}
+async function refreshLlmRuntimeState() {
+  const config = loadConfig();
+  const claude = await probeClaudeProvider(config);
+  const codex = await probeCodexProvider(config);
+  const ollama = await probeOllamaProvider(config);
+  return saveRuntimeMutation((state) => {
+    state.defaultProvider = config.llm.defaultProvider;
+    state.fallbackPolicy = config.llm.fallbackPolicy;
+    state.fallbackOrder = [...config.llm.fallbackOrder];
+    state.providers["claude-code"] = claude;
+    state.providers.codex = codex;
+    state.providers.ollama = ollama;
+  });
+}
+function formatClaudeCommandFailure(context, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return `${context}
+${message}`;
+}
+async function chat(options) {
+  return runWithProviderControl({
+    ...options,
+    capability: "chat",
+    allowFallback: options.allowFallback
+  });
 }
 async function chatJson(options) {
   const enrichedPrompt = options.prompt + `
 
 Respond with valid JSON only. No markdown, no explanation, just the JSON object.`;
-  const text = await chat({ ...options, prompt: enrichedPrompt });
+  const text = await runWithProviderControl({
+    ...options,
+    prompt: enrichedPrompt,
+    capability: options.provider ? "json" : options.model ? "judge" : "json",
+    allowFallback: options.allowFallback
+  });
   const candidates = [
     text.trim(),
     text.match(/^```(?:json)?\s*\n([\s\S]*)\n```\s*$/m)?.[1]?.trim(),
@@ -11665,24 +12484,69 @@ Respond with valid JSON only. No markdown, no explanation, just the JSON object.
 ${text.slice(0, 500)}`);
 }
 async function searchWeb(query) {
-  const args = [
-    "--print",
-    "--allowedTools",
-    "WebSearch,WebFetch",
-    "--no-session-persistence",
-    "--dangerously-skip-permissions",
-    "--max-turns",
-    "8"
-  ];
-  return runClaude(query, args);
+  return runWithProviderControl({
+    prompt: query,
+    capability: "web-search",
+    provider: "claude-code",
+    allowFallback: false
+  });
 }
-var CLAUDE_AUTH_ERROR_PATTERNS;
+var ProviderCommandError, PROVIDER_LABELS, PROVIDER_CAPABILITIES, CLAUDE_AUTH_ERROR_PATTERNS, CODEX_AUTH_ERROR_PATTERNS, OLLAMA_MODEL_MISSING_PATTERNS;
 var init_llm = __esm(() => {
   init_config();
+  init_data();
+  ProviderCommandError = class ProviderCommandError extends Error {
+    provider;
+    kind;
+    nextStep;
+    warning;
+    notices;
+    loggedIn;
+    authMethod;
+    apiProvider;
+    constructor(params) {
+      super(params.message);
+      this.name = "ProviderCommandError";
+      this.provider = params.provider;
+      this.kind = params.kind;
+      this.nextStep = params.nextStep;
+      this.warning = params.warning;
+      this.notices = params.notices ?? [];
+      this.loggedIn = params.loggedIn;
+      this.authMethod = params.authMethod;
+      this.apiProvider = params.apiProvider;
+    }
+  };
+  PROVIDER_LABELS = {
+    "claude-code": "Claude Code",
+    codex: "GPT Codex",
+    ollama: "Ollama"
+  };
+  PROVIDER_CAPABILITIES = {
+    "claude-code": ["chat", "json", "judge", "web-search"],
+    codex: ["chat", "json", "judge"],
+    ollama: ["chat", "json", "judge"]
+  };
   CLAUDE_AUTH_ERROR_PATTERNS = [
     "OAuth token has expired",
     "authentication_error",
-    "Failed to authenticate"
+    "Failed to authenticate",
+    "Invalid authentication credentials",
+    "Not logged in",
+    "Please run /login"
+  ];
+  CODEX_AUTH_ERROR_PATTERNS = [
+    "Please run `codex login`",
+    "Please run codex login",
+    "authentication",
+    "unauthorized",
+    "401",
+    "login"
+  ];
+  OLLAMA_MODEL_MISSING_PATTERNS = [
+    "model not found",
+    "pull model",
+    "not found, try pulling it first"
   ];
 });
 
@@ -11924,9 +12788,9 @@ init_config();
 init_skills();
 init_data();
 init_llm();
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 import { homedir as homedir2 } from "node:os";
-import { existsSync as existsSync4, cpSync } from "node:fs";
+import { existsSync as existsSync5, cpSync } from "node:fs";
 
 // src/prompts/test-gen.ts
 function buildTestGenPrompt(skill) {
@@ -11955,10 +12819,10 @@ Return JSON:
 
 // src/version.ts
 import { createRequire as createRequire2 } from "node:module";
-import { join as join4, dirname as dirname2 } from "node:path";
+import { join as join5, dirname as dirname2 } from "node:path";
 import { fileURLToPath } from "node:url";
 var require2 = createRequire2(import.meta.url);
-var pkg = require2(join4(dirname2(fileURLToPath(import.meta.url)), "..", "package.json"));
+var pkg = require2(join5(dirname2(fileURLToPath(import.meta.url)), "..", "package.json"));
 var VERSION = pkg.version;
 
 // src/commands/init.ts
@@ -11969,26 +12833,26 @@ async function initCommand(options) {
   const generalDir = getGeneralSkillsPath();
   ensureDir(sgDir);
   ensureDir(generalDir);
-  if (!existsSync4(join5(sgDir, "config.json"))) {
+  if (!existsSync5(join6(sgDir, "config.json"))) {
     saveConfig(DEFAULT_CONFIG);
     console.log("  ✓ Created config.json");
   }
   const defaultPaths = [
-    join5(homedir2(), ".agents", "skills"),
-    join5(homedir2(), ".craft-agent", "workspaces")
+    join6(homedir2(), ".agents", "skills"),
+    join6(homedir2(), ".craft-agent", "workspaces")
   ];
   const scanPaths = options.skillsPaths ?? defaultPaths;
   const expandedPaths = [];
   for (const p of scanPaths) {
-    if (p.includes("workspaces") && existsSync4(p)) {
+    if (p.includes("workspaces") && existsSync5(p)) {
       const { readdirSync: readdirSync3 } = await import("node:fs");
       const workspaces = readdirSync3(p, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith("."));
       for (const ws of workspaces) {
-        const skillsDir = join5(p, ws.name, "skills");
-        if (existsSync4(skillsDir))
+        const skillsDir = join6(p, ws.name, "skills");
+        if (existsSync5(skillsDir))
           expandedPaths.push(skillsDir);
       }
-    } else if (existsSync4(p)) {
+    } else if (existsSync5(p)) {
       expandedPaths.push(p);
     }
   }
@@ -11997,8 +12861,8 @@ async function initCommand(options) {
 `);
   let imported = 0;
   for (const skill of existingSkills) {
-    const targetDir = join5(generalDir, skill.slug);
-    if (existsSync4(targetDir)) {
+    const targetDir = join6(generalDir, skill.slug);
+    if (existsSync5(targetDir)) {
       console.log(`    → ${skill.slug}: already exists, skipping`);
       continue;
     }
@@ -12074,14 +12938,14 @@ async function initCommand(options) {
 // src/commands/capture.ts
 init_data();
 init_llm();
-import { readFileSync as readFileSync4, existsSync as existsSync5 } from "node:fs";
+import { readFileSync as readFileSync5, existsSync as existsSync6 } from "node:fs";
 import { basename as basename2 } from "node:path";
 async function captureCommand(sessionPath, options) {
-  if (!existsSync5(sessionPath)) {
+  if (!existsSync6(sessionPath)) {
     console.error(`Session file not found: ${sessionPath}`);
     process.exit(1);
   }
-  const sessionContent = readFileSync4(sessionPath, "utf-8");
+  const sessionContent = readFileSync5(sessionPath, "utf-8");
   const sessionId = basename2(sessionPath, ".json");
   const maxLength = 50000;
   const content = sessionContent.length > maxLength ? sessionContent.slice(-maxLength) : sessionContent;
@@ -12191,7 +13055,7 @@ init_config();
 init_data();
 init_skills();
 init_llm();
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 
 // src/prompts/cluster.ts
 function buildClusterPrompt(failures, skills, graph) {
@@ -12601,26 +13465,26 @@ Return JSON: { "score": <number>, "reason": "<one sentence>" }`;
 
 // src/core/canary.ts
 init_config();
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync6, cpSync as cpSync2, rmSync } from "node:fs";
-import { join as join6 } from "node:path";
-var CANARY_DIR = join6(getHelixDir(), "canary");
-var BACKUPS_DIR = join6(getHelixDir(), "backups");
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync7, cpSync as cpSync2, rmSync as rmSync2 } from "node:fs";
+import { join as join7 } from "node:path";
+var CANARY_DIR = join7(getHelixDir(), "canary");
+var BACKUPS_DIR = join7(getHelixDir(), "backups");
 function getRegistryPath() {
-  return join6(getHelixDir(), "canary-registry.json");
+  return join7(getHelixDir(), "canary-registry.json");
 }
 function loadRegistry() {
   const path = getRegistryPath();
-  if (!existsSync6(path))
+  if (!existsSync7(path))
     return { entries: [] };
-  return JSON.parse(readFileSync5(path, "utf-8"));
+  return JSON.parse(readFileSync6(path, "utf-8"));
 }
 function saveRegistry(registry) {
   writeFileSync4(getRegistryPath(), JSON.stringify(registry, null, 2));
 }
 function backupSkill(skillPath, slug, version) {
   ensureDir(BACKUPS_DIR);
-  const backupPath = join6(BACKUPS_DIR, `${slug}_${version}_${Date.now()}`);
-  if (existsSync6(skillPath)) {
+  const backupPath = join7(BACKUPS_DIR, `${slug}_${version}_${Date.now()}`);
+  if (existsSync7(skillPath)) {
     cpSync2(skillPath, backupPath, { recursive: true });
   }
   return backupPath;
@@ -12701,7 +13565,7 @@ init_config();
 init_skills();
 init_data();
 init_llm();
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 async function autoGeneralize(candidates, verbose = false, dryRun = false) {
   const created = [];
   const skipped = [];
@@ -12770,7 +13634,7 @@ Keep it focused and actionable. No filler.`
       meta.lastEvolved = new Date().toISOString();
       meta.tags = [...meta.tags ?? [], "auto-generalized"];
       meta.enhances = candidate.sourceSkills;
-      const skillDir = join7(getGeneralSkillsPath(), candidate.suggestedName);
+      const skillDir = join8(getGeneralSkillsPath(), candidate.suggestedName);
       writeSkill(skillDir, meta, content);
       created.push(candidate.suggestedName);
       console.log(`  ✓ Created: ${candidate.suggestedName} (domain layer)`);
@@ -13038,7 +13902,7 @@ async function evolveCommand(options) {
     if (finalAccepted && !dryRun) {
       const { meta, content } = parseSkillMd(proposalOutput.proposedSkillMd);
       const skillSlug2 = proposalOutput.targetSkill ?? proposal.targetSkill;
-      const skillDir = join8(getGeneralSkillsPath(), skillSlug2);
+      const skillDir = join9(getGeneralSkillsPath(), skillSlug2);
       meta.generation = generation;
       meta.score = avgScore;
       meta.lastEvolved = new Date().toISOString();
@@ -13159,16 +14023,16 @@ init_skills();
 
 // src/core/knowledge-buffer.ts
 init_config();
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, existsSync as existsSync7 } from "node:fs";
-import { join as join9 } from "node:path";
-var BUFFER_PATH = () => join9(getHelixDir(), "knowledge-buffer.json");
-var DRAFTS_DIR = () => join9(getHelixDir(), "drafts");
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync8 } from "node:fs";
+import { join as join10 } from "node:path";
+var BUFFER_PATH = () => join10(getHelixDir(), "knowledge-buffer.json");
+var DRAFTS_DIR = () => join10(getHelixDir(), "drafts");
 var MAX_DISCOVERIES = 50;
 var MAX_DRAFTS = 10;
 var DECAY_RATE = 0.1;
 function loadBuffer() {
   const path = BUFFER_PATH();
-  if (!existsSync7(path)) {
+  if (!existsSync8(path)) {
     return {
       discoveries: [],
       drafts: [],
@@ -13177,7 +14041,7 @@ function loadBuffer() {
       decayRate: DECAY_RATE
     };
   }
-  return JSON.parse(readFileSync6(path, "utf-8"));
+  return JSON.parse(readFileSync7(path, "utf-8"));
 }
 function saveBuffer(buffer) {
   writeFileSync5(BUFFER_PATH(), JSON.stringify(buffer, null, 2));
@@ -13219,9 +14083,9 @@ function saveDraft(draft) {
       existing.avgScore = draft.avgScore;
       existing.iteration++;
       existing.lastIterated = new Date().toISOString();
-      const draftDir = join9(DRAFTS_DIR(), draft.skillName);
+      const draftDir = join10(DRAFTS_DIR(), draft.skillName);
       ensureDir(draftDir);
-      writeFileSync5(join9(draftDir, "SKILL.md"), draft.skillMd);
+      writeFileSync5(join10(draftDir, "SKILL.md"), draft.skillMd);
     }
   } else {
     buffer.drafts.push({
@@ -13235,9 +14099,9 @@ function saveDraft(draft) {
       iteration: 1,
       lastIterated: new Date().toISOString()
     });
-    const draftDir = join9(DRAFTS_DIR(), draft.skillName);
+    const draftDir = join10(DRAFTS_DIR(), draft.skillName);
     ensureDir(draftDir);
-    writeFileSync5(join9(draftDir, "SKILL.md"), draft.skillMd);
+    writeFileSync5(join10(draftDir, "SKILL.md"), draft.skillMd);
   }
   trimAndSave(buffer);
 }
@@ -13285,6 +14149,16 @@ function getBufferStats() {
 }
 
 // src/commands/status.ts
+init_llm();
+function providerStatusBadge(status) {
+  if (status === "healthy")
+    return "healthy";
+  if (status === "degraded")
+    return "degraded";
+  if (status === "unavailable")
+    return "unavailable";
+  return "unknown";
+}
 async function statusCommand() {
   const failures = loadFailures();
   const unresolved = failures.filter((f) => !f.resolved);
@@ -13293,6 +14167,7 @@ async function statusCommand() {
   const skillTests = loadSkillTests();
   const stagnation = getStagnationCount();
   const recentIter = getRecentIterations(7);
+  const llmRuntime = await refreshLlmRuntimeState();
   console.log(`\uD83E\uDDEC HelixEvo Status
 `);
   console.log(`  Skills: ${skills.length}`);
@@ -13317,6 +14192,29 @@ async function statusCommand() {
   console.log(`    Drafts: ${buffer.drafts}/${buffer.maxDrafts}`);
   if (buffer.topDraft)
     console.log(`    Top draft: ${buffer.topDraft}`);
+  console.log(`
+  Provider control:`);
+  console.log(`    Default provider: ${getProviderLabel(llmRuntime.defaultProvider)}`);
+  console.log(`    Fallback policy: ${llmRuntime.fallbackPolicy}${llmRuntime.fallbackOrder.length > 0 ? ` (${llmRuntime.fallbackOrder.map((provider) => getProviderLabel(provider)).join(" → ")})` : ""}`);
+  for (const provider of ["claude-code", "codex", "ollama"]) {
+    const snapshot = llmRuntime.providers[provider];
+    const state = providerStatusBadge(snapshot.status);
+    const login = snapshot.loggedIn === undefined ? "" : snapshot.loggedIn ? " • logged in" : " • logged out";
+    const availability = snapshot.available ? "available" : snapshot.installed ? "installed" : "missing";
+    console.log(`    ${getProviderLabel(provider)}: ${state} • ${availability}${login}`);
+    console.log(`      ${snapshot.summary}`);
+    if (snapshot.nextStep)
+      console.log(`      Next: ${snapshot.nextStep}`);
+  }
+  if (llmRuntime.lastExecution) {
+    const execution = llmRuntime.lastExecution;
+    console.log(`    Last execution: ${execution.success ? "success" : "failure"} • ${getProviderLabel(execution.selectedProvider)} selected${execution.usedProvider ? ` • ${getProviderLabel(execution.usedProvider)} used` : ""}`);
+    console.log(`      ${execution.summary}`);
+    if (execution.nextStep)
+      console.log(`      Next: ${execution.nextStep}`);
+  } else {
+    console.log("    Last execution: none recorded yet");
+  }
   const accepted = recentIter.flatMap((i) => i.proposals).filter((p) => p.outcome === "accepted").length;
   const rejected = recentIter.flatMap((i) => i.proposals).filter((p) => p.outcome === "rejected").length;
   console.log(`
@@ -13338,7 +14236,7 @@ async function statusCommand() {
 init_data();
 init_skills();
 import { writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 init_config();
 async function reportCommand(options) {
   const days = parseInt(options.days ?? "1");
@@ -13428,8 +14326,8 @@ async function reportCommand(options) {
 `;
   report += `- Run **helixevo proof --status** to inspect outcome attribution across interventions, topology, ontology, and evolution evidence.
 `;
-  const outputPath = options.output ?? join10(getHelixDir(), "reports", `${date}.md`);
-  ensureDir(join10(getHelixDir(), "reports"));
+  const outputPath = options.output ?? join11(getHelixDir(), "reports", `${date}.md`);
+  ensureDir(join11(getHelixDir(), "reports"));
   writeFileSync6(outputPath, report);
   console.log(report);
   console.log(`
@@ -13441,7 +14339,7 @@ init_config();
 init_skills();
 init_data();
 init_llm();
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 async function generalizeCommand(options) {
   const verbose = options.verbose ?? false;
   const dryRun = options.dryRun ?? false;
@@ -13456,7 +14354,12 @@ async function generalizeCommand(options) {
     return;
   }
   console.log("  Step 1: Detecting cross-skill patterns...");
-  const candidates = await detectGeneralizationCandidates(skills);
+  let candidates;
+  try {
+    candidates = await detectGeneralizationCandidates(skills);
+  } catch (error) {
+    throw new Error(formatClaudeCommandFailure("Generalize could not detect cross-skill patterns.", error));
+  }
   if (candidates.length === 0) {
     console.log("  No generalization candidates found.");
     return;
@@ -13480,7 +14383,12 @@ async function generalizeCommand(options) {
     }
     console.log("    Generating generalized skill...");
     const sourceSkills = skills.filter((s) => candidate.skills.includes(s.slug));
-    const generalized = await generateGeneralizedSkill(sourceSkills, candidate);
+    let generalized;
+    try {
+      generalized = await generateGeneralizedSkill(sourceSkills, candidate);
+    } catch (error) {
+      throw new Error(formatClaudeCommandFailure(`Generalize detected candidate "${candidate.suggestedName}" but could not materialize the generalized skill.`, error));
+    }
     if (verbose) {
       console.log(`    Name: ${generalized.name}`);
       console.log(`    Content preview: ${generalized.skillMd.slice(0, 200)}...
@@ -13516,7 +14424,7 @@ async function generalizeCommand(options) {
       meta.generation = 1;
       meta.score = candidate.confidence;
       meta.lastEvolved = completedAt;
-      const skillDir = join11(getGeneralSkillsPath(), candidate.suggestedName);
+      const skillDir = join12(getGeneralSkillsPath(), candidate.suggestedName);
       writeSkill(skillDir, meta, content);
       console.log(`    ✓ Created: ${candidate.suggestedName} (${candidate.suggestedLayer} layer)
 `);
@@ -13687,7 +14595,7 @@ Return JSON:
 init_data();
 init_skills();
 init_llm();
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 async function specializeCommand(options) {
   const verbose = options.verbose ?? false;
   const dryRun = options.dryRun ?? false;
@@ -13792,8 +14700,8 @@ async function specializeCommand(options) {
       meta.generation = 1;
       meta.score = candidate.confidence;
       meta.lastEvolved = new Date().toISOString();
-      const projectSkillsDir = join12(process.cwd(), ".helix", "skills");
-      const skillDir = join12(projectSkillsDir, candidate.suggestedName);
+      const projectSkillsDir = join13(process.cwd(), ".helix", "skills");
+      const skillDir = join13(projectSkillsDir, candidate.suggestedName);
       writeSkill(skillDir, meta, content);
       console.log(`    ✓ Created: ${candidate.suggestedName} (project layer, parent: ${candidate.domainSkill})
 `);
@@ -13897,8 +14805,8 @@ Return JSON:
 // src/commands/graph.ts
 import { writeFileSync as writeFileSync8 } from "node:fs";
 import { execSync } from "node:child_process";
-import { join as join14 } from "node:path";
-import { tmpdir } from "node:os";
+import { join as join15 } from "node:path";
+import { tmpdir as tmpdir2 } from "node:os";
 
 // src/core/network.ts
 init_ontology();
@@ -14174,16 +15082,46 @@ async function optimizeNetwork(verbose = false) {
   const result = {
     merged: preview.merged.map((candidate) => candidate.slugs),
     split: preview.split.map((candidate) => candidate.slug),
-    conflictsResolved: []
+    conflictsResolved: [],
+    conflictsAttempted: 0,
+    conflictsSkipped: 0,
+    conflictFailures: [],
+    degraded: false
   };
   const conflicts = graph.edges.filter((edge) => edge.type === "conflicts");
-  if (conflicts.length > 0) {
-    if (verbose)
-      console.log(`  Resolving ${conflicts.length} conflict(s)...`);
-    for (const conflict of conflicts) {
+  let authBlockedFurtherConflictAnalysis = false;
+  if (conflicts.length > 0 && verbose) {
+    console.log(`  Resolving ${conflicts.length} conflict(s)...`);
+  }
+  for (const conflict of conflicts) {
+    if (authBlockedFurtherConflictAnalysis) {
+      result.conflictsSkipped += 1;
+      continue;
+    }
+    result.conflictsAttempted += 1;
+    try {
       const resolved = await resolveConflict(conflict, skills);
       if (resolved)
         result.conflictsResolved.push([conflict.from, conflict.to]);
+    } catch (error) {
+      const failureKind = classifyClaudeFailure(error);
+      result.degraded = true;
+      result.failureKind = result.failureKind ?? (failureKind === "unknown" ? "llm" : failureKind);
+      result.conflictFailures.push({
+        pair: [conflict.from, conflict.to],
+        kind: failureKind === "unknown" ? "llm" : failureKind,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      if (failureKind === "auth") {
+        authBlockedFurtherConflictAnalysis = true;
+        result.conflictsSkipped += Math.max(0, conflicts.length - result.conflictsAttempted);
+        result.warning = "Conflict enrichment degraded because Claude authentication failed.";
+      } else if (!result.warning) {
+        result.warning = "Conflict enrichment degraded before all conflict analysis completed.";
+      }
+      if (verbose) {
+        console.log(`  ! Conflict analysis degraded for ${conflict.from} ↔ ${conflict.to}`);
+      }
     }
   }
   if (verbose) {
@@ -14238,29 +15176,29 @@ Return JSON:
 init_data();
 init_skills();
 import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync3 } from "node:fs";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 function syncToObsidian(vaultPath, verbose = false) {
   const graph = loadSkillGraph();
   const skills = loadAllGeneralSkills();
-  const skillsDir = join13(vaultPath, "Skills");
-  const reportsDir = join13(vaultPath, "Reports");
+  const skillsDir = join14(vaultPath, "Skills");
+  const reportsDir = join14(vaultPath, "Reports");
   mkdirSync3(skillsDir, { recursive: true });
   mkdirSync3(reportsDir, { recursive: true });
   for (const node of graph.nodes) {
     const skill = skills.find((s) => s.slug === node.id);
     const note = generateSkillNote(node, graph.edges, skill ?? undefined);
-    const notePath = join13(skillsDir, `${node.id}.md`);
+    const notePath = join14(skillsDir, `${node.id}.md`);
     writeFileSync7(notePath, note);
     if (verbose)
       console.log(`  ✓ ${node.id}.md`);
   }
   const indexNote = generateIndexNote(graph);
-  writeFileSync7(join13(vaultPath, "HelixEvo Index.md"), indexNote);
+  writeFileSync7(join14(vaultPath, "HelixEvo Index.md"), indexNote);
   const recent = getRecentIterations(7);
   if (recent.length > 0) {
     const report = generateEvolutionReport(recent);
     const date = new Date().toISOString().slice(0, 10);
-    writeFileSync7(join13(reportsDir, `Evolution ${date}.md`), report);
+    writeFileSync7(join14(reportsDir, `Evolution ${date}.md`), report);
   }
   console.log(`  ✓ Synced ${graph.nodes.length} skills to ${vaultPath}`);
 }
@@ -14412,7 +15350,57 @@ async function graphCommand(options) {
     console.log(`
 ${C.bold}  Network Optimization${C.reset}`);
     console.log(`  ${"─".repeat(40)}`);
-    const result = await optimizeNetwork(verbose);
+    let topology;
+    try {
+      topology = refreshTopologyReviewCandidates();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      saveTopologyOptimizeStatus({
+        command: "graph-optimize",
+        status: "failed",
+        ranAt: new Date().toISOString(),
+        summary: "Topology review queue refresh failed before optimization could complete.",
+        nextStep: "Inspect the optimize error and retry after fixing the queue-refresh failure.",
+        notices: [message],
+        queue: { total: 0, open: 0, created: 0, updated: 0 },
+        enrichment: { attempted: 0, resolved: 0, failed: 0, skipped: 0, degraded: false, failureKind: "unknown", warning: message }
+      });
+      throw new Error(`graph --optimize could not refresh the topology review queue.
+${message}`);
+    }
+    console.log(`  ${C.blue}↺${C.reset} Topology review queue refreshed: ${topology.total} total • ${topology.open} open`);
+    console.log(`  ${C.dim}    ${topology.created} created • ${topology.updated} updated${C.reset}`);
+    let result;
+    try {
+      result = await optimizeNetwork(verbose);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      saveTopologyOptimizeStatus({
+        command: "graph-optimize",
+        status: "failed",
+        ranAt: new Date().toISOString(),
+        summary: "Topology review queue refreshed, but optimization failed before enrichment completed.",
+        nextStep: "Review the optimize error, then retry once the underlying execution issue is fixed.",
+        notices: [message],
+        queue: {
+          total: topology.total,
+          open: topology.open,
+          created: topology.created,
+          updated: topology.updated
+        },
+        enrichment: {
+          attempted: 0,
+          resolved: 0,
+          failed: 1,
+          skipped: 0,
+          degraded: true,
+          failureKind: "unknown",
+          warning: message
+        }
+      });
+      throw new Error(`graph --optimize refreshed the queue but failed during enrichment.
+${message}`);
+    }
     if (result.merged.length > 0) {
       for (const [a, b] of result.merged)
         console.log(`  ${C.yellow}⊕${C.reset} Merge: ${a} + ${b}`);
@@ -14424,12 +15412,42 @@ ${C.bold}  Network Optimization${C.reset}`);
     if (result.conflictsResolved.length > 0) {
       console.log(`  ${C.green}✓${C.reset} Conflicts analyzed: ${result.conflictsResolved.length}`);
     }
-    if (result.merged.length === 0 && result.split.length === 0 && result.conflictsResolved.length === 0) {
+    if (result.merged.length === 0 && result.split.length === 0 && result.conflictsResolved.length === 0 && !result.degraded) {
       console.log(`  ${C.green}✓${C.reset} Network is healthy`);
     }
-    const topology = refreshTopologyReviewCandidates();
-    console.log(`  ${C.blue}↺${C.reset} Topology review queue refreshed: ${topology.total} total • ${topology.open} open`);
-    console.log(`  ${C.dim}    ${topology.created} created • ${topology.updated} updated${C.reset}`);
+    const optimizeStatus = {
+      command: "graph-optimize",
+      status: result.degraded ? "partial" : "healthy",
+      ranAt: new Date().toISOString(),
+      summary: result.degraded ? "Topology review queue refreshed, but conflict enrichment only completed partially." : "Topology review queue refreshed and conflict enrichment completed successfully.",
+      nextStep: result.degraded ? "Review the queue in topology control. If the warning mentions authentication, refresh Claude auth before retrying full enrichment." : topology.open > 0 ? "Review open topology candidates and decide which ones to accept, defer, or reject." : "No structural backlog is waiting right now. Re-run optimize after more pressure or graph changes appear.",
+      notices: result.degraded ? [
+        "Deterministic queue refresh succeeded even though enrichment degraded.",
+        result.warning ?? "Conflict enrichment did not complete fully."
+      ] : ["Queue refresh and enrichment completed without degraded-mode warnings."],
+      queue: {
+        total: topology.total,
+        open: topology.open,
+        created: topology.created,
+        updated: topology.updated
+      },
+      enrichment: {
+        attempted: result.conflictsAttempted,
+        resolved: result.conflictsResolved.length,
+        failed: result.conflictFailures.length,
+        skipped: result.conflictsSkipped,
+        degraded: result.degraded,
+        failureKind: result.failureKind,
+        warning: result.warning
+      }
+    };
+    saveTopologyOptimizeStatus(optimizeStatus);
+    if (result.degraded) {
+      console.log(`  ${C.yellow}!${C.reset} Optimize finished in partial mode`);
+      console.log(`  ${C.dim}    Queue refresh succeeded, but conflict enrichment degraded.${C.reset}`);
+      if (result.warning)
+        console.log(`  ${C.dim}    ${result.warning}${C.reset}`);
+    }
   }
   if (options.obsidian) {
     console.log(`
@@ -14622,7 +15640,7 @@ ${mermaidCode}
   });
 </script>
 </body></html>`;
-  const htmlPath = join14(tmpdir(), "helix-network.html");
+  const htmlPath = join15(tmpdir2(), "helix-network.html");
   writeFileSync8(htmlPath, html);
   execSync(`open "${htmlPath}"`);
   console.log(`  ✓ Opened in browser`);
@@ -14687,8 +15705,8 @@ function renderScoreBar(score) {
 init_config();
 init_skills();
 init_llm();
-import { isAbsolute, join as join15, resolve } from "node:path";
-import { readFileSync as readFileSync7, existsSync as existsSync9 } from "node:fs";
+import { isAbsolute, join as join16, resolve } from "node:path";
+import { readFileSync as readFileSync8, existsSync as existsSync10 } from "node:fs";
 init_data();
 async function researchCommand(options) {
   const verbose = options.verbose ?? false;
@@ -14835,7 +15853,7 @@ Only include discoveries that are NOT already covered by current skills.`
       meta.score = result.avgScore / 10;
       meta.lastEvolved = new Date().toISOString();
       meta.tags = [...meta.tags ?? [], "research-discovered"];
-      const skillDir = join15(getGeneralSkillsPath(), hypothesis.skillName);
+      const skillDir = join16(getGeneralSkillsPath(), hypothesis.skillName);
       writeSkill(skillDir, meta, content);
       console.log(`    ✓ Created: ${hypothesis.skillName} (from research)
 `);
@@ -14891,9 +15909,9 @@ async function understandGoals(projectPath, skills) {
   const paths = projectPath ? [projectPath] : [process.cwd()];
   for (const p of paths) {
     for (const file of ["README.md", "CLAUDE.md", "package.json", ".agents/AGENTS.md"]) {
-      const fullPath = join15(p, file);
-      if (existsSync9(fullPath)) {
-        const content = readFileSync7(fullPath, "utf-8").slice(0, 2000);
+      const fullPath = join16(p, file);
+      if (existsSync10(fullPath)) {
+        const content = readFileSync8(fullPath, "utf-8").slice(0, 2000);
         context.push(`## ${file}
 ${content}`);
       }
@@ -15053,8 +16071,8 @@ ${replay.slice(0, 800)}`
 
 // src/commands/dashboard.ts
 import { execSync as execSync2, spawn as spawn2 } from "node:child_process";
-import { join as join17, dirname as dirname3 } from "node:path";
-import { existsSync as existsSync11, cpSync as cpSync3, mkdirSync as mkdirSync5, openSync, readdirSync as readdirSync3, readFileSync as readFileSync9, rmSync as rmSync2, writeFileSync as writeFileSync10 } from "node:fs";
+import { join as join18, dirname as dirname3 } from "node:path";
+import { existsSync as existsSync12, cpSync as cpSync3, mkdirSync as mkdirSync5, openSync, readdirSync as readdirSync3, readFileSync as readFileSync10, rmSync as rmSync3, writeFileSync as writeFileSync10 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { homedir as homedir4 } from "node:os";
 import { createServer } from "node:net";
@@ -15062,25 +16080,25 @@ init_skills();
 init_data();
 
 // src/utils/update-check.ts
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync9, existsSync as existsSync10, mkdirSync as mkdirSync4 } from "node:fs";
-import { join as join16 } from "node:path";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync9, existsSync as existsSync11, mkdirSync as mkdirSync4 } from "node:fs";
+import { join as join17 } from "node:path";
 import { homedir as homedir3 } from "node:os";
-var HELIX_DIR2 = join16(homedir3(), ".helix");
-var CACHE_PATH = join16(HELIX_DIR2, "update-check.json");
+var HELIX_DIR2 = join17(homedir3(), ".helix");
+var CACHE_PATH = join17(HELIX_DIR2, "update-check.json");
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 var REGISTRY_URL = "https://registry.npmjs.org/helixevo/latest";
 function readCache() {
   try {
-    if (!existsSync10(CACHE_PATH))
+    if (!existsSync11(CACHE_PATH))
       return null;
-    return JSON.parse(readFileSync8(CACHE_PATH, "utf-8"));
+    return JSON.parse(readFileSync9(CACHE_PATH, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeCache(cache) {
   try {
-    if (!existsSync10(HELIX_DIR2))
+    if (!existsSync11(HELIX_DIR2))
       mkdirSync4(HELIX_DIR2, { recursive: true });
     writeFileSync9(CACHE_PATH, JSON.stringify(cache));
   } catch {}
@@ -15166,11 +16184,11 @@ function printUpdateBanner(currentVersion, latestVersion) {
 
 // src/commands/dashboard.ts
 var __filename = "/Users/tianchichen/Documents/GitHub/helixevo/src/commands/dashboard.ts";
-var HELIX_HOME_DIR = join17(homedir4(), ".helix");
-var HELIX_DASHBOARD_DIR = join17(HELIX_HOME_DIR, "dashboard");
-var DASHBOARD_LOG_FILE = join17(HELIX_HOME_DIR, "dashboard.log");
-var DASHBOARD_PID_FILE = join17(HELIX_HOME_DIR, "dashboard.pid");
-var DASHBOARD_STATE_FILE = join17(HELIX_HOME_DIR, "dashboard-state.json");
+var HELIX_HOME_DIR = join18(homedir4(), ".helix");
+var HELIX_DASHBOARD_DIR = join18(HELIX_HOME_DIR, "dashboard");
+var DASHBOARD_LOG_FILE = join18(HELIX_HOME_DIR, "dashboard.log");
+var DASHBOARD_PID_FILE = join18(HELIX_HOME_DIR, "dashboard.pid");
+var DASHBOARD_STATE_FILE = join18(HELIX_HOME_DIR, "dashboard-state.json");
 var DASHBOARD_SKIP_AUTO_UPDATE_ENV = "HELIXEVO_DASHBOARD_SKIP_AUTO_UPDATE";
 var DEFAULT_DASHBOARD_PORT = 3847;
 var MAX_PORT_SCAN_ATTEMPTS = 25;
@@ -15195,7 +16213,7 @@ async function dashboardCommand(options) {
     console.error(`    cd helixevo/dashboard && npm install && npx next dev --port ${preferredPort}`);
     process.exit(1);
   }
-  if (!existsSync11(join17(dir, "node_modules"))) {
+  if (!existsSync12(join18(dir, "node_modules"))) {
     console.log("  Installing dashboard dependencies...");
     try {
       execSync2("npm install --no-audit --no-fund", { cwd: dir, stdio: "inherit" });
@@ -15328,10 +16346,10 @@ function launchDashboard(dir, openBrowser, port) {
   \uD83D\uDD04 Restarting dashboard after update on ${getDashboardUrl(port)}...
 `);
       setTimeout(() => {
-        const nextCache = join17(dir, ".next");
-        if (existsSync11(nextCache)) {
+        const nextCache = join18(dir, ".next");
+        if (existsSync12(nextCache)) {
           try {
-            rmSync2(nextCache, { recursive: true });
+            rmSync3(nextCache, { recursive: true });
           } catch {}
         }
         ensureSkillGraph();
@@ -15402,17 +16420,17 @@ function writeDashboardState(state) {
 }
 function readDashboardState() {
   let state = null;
-  if (existsSync11(DASHBOARD_STATE_FILE)) {
+  if (existsSync12(DASHBOARD_STATE_FILE)) {
     try {
-      const parsed = JSON.parse(readFileSync9(DASHBOARD_STATE_FILE, "utf-8"));
+      const parsed = JSON.parse(readFileSync10(DASHBOARD_STATE_FILE, "utf-8"));
       if (Number.isInteger(parsed.pid) && Number.isInteger(parsed.port)) {
         state = parsed;
       }
     } catch {}
   }
-  if (!state && existsSync11(DASHBOARD_PID_FILE)) {
+  if (!state && existsSync12(DASHBOARD_PID_FILE)) {
     try {
-      const pid = Number.parseInt(readFileSync9(DASHBOARD_PID_FILE, "utf-8").trim(), 10);
+      const pid = Number.parseInt(readFileSync10(DASHBOARD_PID_FILE, "utf-8").trim(), 10);
       if (Number.isInteger(pid)) {
         state = {
           pid,
@@ -15433,10 +16451,10 @@ function readDashboardState() {
 }
 function clearDashboardState() {
   try {
-    rmSync2(DASHBOARD_PID_FILE, { force: true });
+    rmSync3(DASHBOARD_PID_FILE, { force: true });
   } catch {}
   try {
-    rmSync2(DASHBOARD_STATE_FILE, { force: true });
+    rmSync3(DASHBOARD_STATE_FILE, { force: true });
   } catch {}
 }
 function isProcessAlive(pid) {
@@ -15474,20 +16492,20 @@ function prepareDashboard() {
   const npmSource = findNpmDashboard();
   if (npmSource)
     return copyToHelix(npmSource);
-  if (existsSync11(join17(HELIX_DASHBOARD_DIR, "package.json"))) {
+  if (existsSync12(join18(HELIX_DASHBOARD_DIR, "package.json"))) {
     return HELIX_DASHBOARD_DIR;
   }
   return null;
 }
 function findDevDashboard() {
   const candidates = [
-    join17(process.cwd(), "dashboard")
+    join18(process.cwd(), "dashboard")
   ];
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  candidates.push(join17(home, "Documents", "GitHub", "helixevo", "dashboard"));
-  candidates.push(join17(home, "Documents", "GitHub", "skillgraph", "dashboard"));
+  candidates.push(join18(home, "Documents", "GitHub", "helixevo", "dashboard"));
+  candidates.push(join18(home, "Documents", "GitHub", "skillgraph", "dashboard"));
   for (const dir of candidates) {
-    if (existsSync11(join17(dir, "package.json")) && !dir.includes("node_modules")) {
+    if (existsSync12(join18(dir, "package.json")) && !dir.includes("node_modules")) {
       return dir;
     }
   }
@@ -15498,15 +16516,15 @@ function findNpmDashboard() {
   try {
     const thisFile = typeof __filename !== "undefined" ? __filename : fileURLToPath2(import.meta.url);
     const pkgRoot = dirname3(dirname3(thisFile));
-    candidates.push(join17(pkgRoot, "dashboard"));
+    candidates.push(join18(pkgRoot, "dashboard"));
   } catch {}
   try {
     const globalPrefix = execSync2("npm prefix -g", { encoding: "utf-8" }).trim();
-    candidates.push(join17(globalPrefix, "lib", "node_modules", "helixevo", "dashboard"));
-    candidates.push(join17(globalPrefix, "node_modules", "helixevo", "dashboard"));
+    candidates.push(join18(globalPrefix, "lib", "node_modules", "helixevo", "dashboard"));
+    candidates.push(join18(globalPrefix, "node_modules", "helixevo", "dashboard"));
   } catch {}
   for (const dir of candidates) {
-    if (existsSync11(join17(dir, "package.json"))) {
+    if (existsSync12(join18(dir, "package.json"))) {
       return dir;
     }
   }
@@ -15514,10 +16532,10 @@ function findNpmDashboard() {
 }
 function getInstalledDashboardVersion() {
   try {
-    const versionFile = join17(HELIX_DASHBOARD_DIR, ".helixevo-version");
-    if (!existsSync11(versionFile))
+    const versionFile = join18(HELIX_DASHBOARD_DIR, ".helixevo-version");
+    if (!existsSync12(versionFile))
       return null;
-    return readFileSync9(versionFile, "utf-8").trim();
+    return readFileSync10(versionFile, "utf-8").trim();
   } catch {
     return null;
   }
@@ -15525,8 +16543,8 @@ function getInstalledDashboardVersion() {
 function copyToHelix(sourceDir) {
   let sourceVersion = VERSION;
   try {
-    const srcRoot = join17(sourceDir, "..", "package.json");
-    const pkg2 = JSON.parse(readFileSync9(srcRoot, "utf-8"));
+    const srcRoot = join18(sourceDir, "..", "package.json");
+    const pkg2 = JSON.parse(readFileSync10(srcRoot, "utf-8"));
     if (pkg2.name === "helixevo" && pkg2.version)
       sourceVersion = pkg2.version;
   } catch {}
@@ -15542,8 +16560,8 @@ function copyToHelix(sourceDir) {
   mkdirSync5(HELIX_DASHBOARD_DIR, { recursive: true });
   let depsChanged = true;
   try {
-    const srcDeps = readFileSync9(join17(sourceDir, "package.json"), "utf-8");
-    const dstDeps = readFileSync9(join17(HELIX_DASHBOARD_DIR, "package.json"), "utf-8");
+    const srcDeps = readFileSync10(join18(sourceDir, "package.json"), "utf-8");
+    const dstDeps = readFileSync10(join18(HELIX_DASHBOARD_DIR, "package.json"), "utf-8");
     const srcPkg = JSON.parse(srcDeps);
     const dstPkg = JSON.parse(dstDeps);
     depsChanged = JSON.stringify(srcPkg.dependencies) !== JSON.stringify(dstPkg.dependencies) || JSON.stringify(srcPkg.devDependencies) !== JSON.stringify(dstPkg.devDependencies);
@@ -15554,22 +16572,22 @@ function copyToHelix(sourceDir) {
   for (const item of items) {
     if (item.name === "node_modules" || item.name === ".next" || item.name === "package-lock.json" || item.name === ".env.local")
       continue;
-    const src = join17(sourceDir, item.name);
-    const dest = join17(HELIX_DASHBOARD_DIR, item.name);
+    const src = join18(sourceDir, item.name);
+    const dest = join18(HELIX_DASHBOARD_DIR, item.name);
     cpSync3(src, dest, { recursive: true });
   }
   if (depsChanged) {
-    const oldModules = join17(HELIX_DASHBOARD_DIR, "node_modules");
-    if (existsSync11(oldModules))
-      rmSync2(oldModules, { recursive: true });
-    const oldLock = join17(HELIX_DASHBOARD_DIR, "package-lock.json");
-    if (existsSync11(oldLock))
-      rmSync2(oldLock);
-  }
-  const nextCache = join17(HELIX_DASHBOARD_DIR, ".next");
-  if (existsSync11(nextCache))
-    rmSync2(nextCache, { recursive: true });
-  writeFileSync10(join17(HELIX_DASHBOARD_DIR, ".helixevo-version"), sourceVersion);
+    const oldModules = join18(HELIX_DASHBOARD_DIR, "node_modules");
+    if (existsSync12(oldModules))
+      rmSync3(oldModules, { recursive: true });
+    const oldLock = join18(HELIX_DASHBOARD_DIR, "package-lock.json");
+    if (existsSync12(oldLock))
+      rmSync3(oldLock);
+  }
+  const nextCache = join18(HELIX_DASHBOARD_DIR, ".next");
+  if (existsSync12(nextCache))
+    rmSync3(nextCache, { recursive: true });
+  writeFileSync10(join18(HELIX_DASHBOARD_DIR, ".helixevo-version"), sourceVersion);
   return HELIX_DASHBOARD_DIR;
 }
 function ensureSkillGraph() {
@@ -15611,13 +16629,13 @@ function ensureSkillGraph() {
 }
 
 // src/commands/watch.ts
-import { join as join19 } from "node:path";
-import { existsSync as existsSync14 } from "node:fs";
+import { join as join20 } from "node:path";
+import { existsSync as existsSync15 } from "node:fs";
 
 // src/core/auto-capture.ts
 init_data();
 init_llm();
-import { readFileSync as readFileSync10, existsSync as existsSync12, statSync as statSync2 } from "node:fs";
+import { readFileSync as readFileSync11, existsSync as existsSync13, statSync as statSync2 } from "node:fs";
 var CORRECTION_SIGNALS = [
   /\bno[, ]+(?:that's|thats|that is)\s+(?:wrong|incorrect|not right)/i,
   /\bdon'?t\s+do\s+(?:that|it\s+like\s+that)/i,
@@ -15705,17 +16723,17 @@ If no corrections found, return: { "corrections": [] }`
 }
 function watchEvents(options) {
   const { eventsPath, project, onCapture, onError, pollIntervalMs = 5000 } = options;
-  let lastSize = existsSync12(eventsPath) ? statSync2(eventsPath).size : 0;
+  let lastSize = existsSync13(eventsPath) ? statSync2(eventsPath).size : 0;
   let messageBuffer = [];
   let pendingExtraction = false;
   const interval = setInterval(async () => {
     try {
-      if (!existsSync12(eventsPath))
+      if (!existsSync13(eventsPath))
         return;
       const currentSize = statSync2(eventsPath).size;
       if (currentSize <= lastSize)
         return;
-      const content = readFileSync10(eventsPath, "utf-8");
+      const content = readFileSync11(eventsPath, "utf-8");
       const lines = content.trim().split(`
 `).filter(Boolean);
       const newLines = lines.slice(messageBuffer.length);
@@ -15757,17 +16775,17 @@ init_data();
 // src/core/metrics.ts
 init_config();
 init_data();
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync11, existsSync as existsSync13 } from "node:fs";
-import { join as join18 } from "node:path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync11, existsSync as existsSync14 } from "node:fs";
+import { join as join19 } from "node:path";
 function getMetricsPath() {
-  return join18(getHelixDir(), "metrics.json");
+  return join19(getHelixDir(), "metrics.json");
 }
 function loadMetrics() {
   const path = getMetricsPath();
-  if (!existsSync13(path)) {
+  if (!existsSync14(path)) {
     return { updated: new Date().toISOString(), skills: [], globalCorrectionRate: [], evolutionImpact: [] };
   }
-  return JSON.parse(readFileSync11(path, "utf-8"));
+  return JSON.parse(readFileSync12(path, "utf-8"));
 }
 function saveMetrics(store) {
   ensureDir(getHelixDir());
@@ -15947,14 +16965,14 @@ async function watchCommand(options) {
   const verbose = options.verbose ?? false;
   const autoEvolve = options.evolve !== false;
   const project = options.project ?? null;
-  const eventsPath = options.events ?? join19(process.cwd(), "events.jsonl");
+  const eventsPath = options.events ?? join20(process.cwd(), "events.jsonl");
   console.log(`\uD83E\uDDEC HelixEvo Watch Mode — Always-On Learning
 `);
   console.log(`  Events:      ${eventsPath}`);
   console.log(`  Project:     ${project ?? "(auto-detect)"}`);
   console.log(`  Auto-evolve: ${autoEvolve ? "ON" : "OFF"}`);
   console.log();
-  if (!existsSync14(eventsPath)) {
+  if (!existsSync15(eventsPath)) {
     console.log(`  ⚠ Events file not found yet. Will start watching when it appears.`);
     console.log(`  Expected at: ${eventsPath}
 `);
@@ -16107,8 +17125,8 @@ async function metricsCommand(options) {
 init_data();
 init_skills();
 init_llm();
-import { isAbsolute as isAbsolute2, join as join20, normalize, resolve as resolve2 } from "node:path";
-import { existsSync as existsSync15, readFileSync as readFileSync12, writeFileSync as writeFileSync12, mkdirSync as mkdirSync6, readdirSync as readdirSync4 } from "node:fs";
+import { isAbsolute as isAbsolute2, join as join21, normalize, resolve as resolve2 } from "node:path";
+import { existsSync as existsSync16, readFileSync as readFileSync13, writeFileSync as writeFileSync12, mkdirSync as mkdirSync6, readdirSync as readdirSync4 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 
 // src/prompts/project-analysis.ts
@@ -16182,7 +17200,7 @@ function expandHomePath(path) {
   if (path === "~")
     return homedir5();
   if (path.startsWith("~/"))
-    return join20(homedir5(), path.slice(2));
+    return join21(homedir5(), path.slice(2));
   return path;
 }
 function normalizeProjectPath(projectPath) {
@@ -16207,10 +17225,10 @@ function readProjectContext(projectPath) {
     "Dockerfile"
   ];
   for (const f of filesToRead) {
-    const p = join20(projectPath, f);
-    if (existsSync15(p)) {
+    const p = join21(projectPath, f);
+    if (existsSync16(p)) {
       try {
-        const content = readFileSync12(p, "utf-8");
+        const content = readFileSync13(p, "utf-8");
         contextFiles.push({ name: f, content: content.slice(0, 2000) });
       } catch {}
     }
@@ -16222,8 +17240,8 @@ function readProjectContext(projectPath) {
 `);
   } catch {}
   let srcStructure = "";
-  const srcDir = join20(projectPath, "src");
-  if (existsSync15(srcDir)) {
+  const srcDir = join21(projectPath, "src");
+  if (existsSync16(srcDir)) {
     try {
       const scanDir = (dir, prefix, depth) => {
         if (depth > 2)
@@ -16233,7 +17251,7 @@ function readProjectContext(projectPath) {
         for (const item of items) {
           lines.push(`${prefix}${item.isDirectory() ? "\uD83D\uDCC1" : "\uD83D\uDCC4"} ${item.name}`);
           if (item.isDirectory()) {
-            lines.push(...scanDir(join20(dir, item.name), prefix + "  ", depth + 1));
+            lines.push(...scanDir(join21(dir, item.name), prefix + "  ", depth + 1));
           }
         }
         return lines;
@@ -16267,18 +17285,18 @@ ${f.content}
   return context;
 }
 function getProjectsDir() {
-  return join20(getHelixDir(), "projects");
+  return join21(getHelixDir(), "projects");
 }
 function saveProjectProfile(profile) {
-  const dir = join20(getProjectsDir(), profile.name);
+  const dir = join21(getProjectsDir(), profile.name);
   mkdirSync6(dir, { recursive: true });
-  writeFileSync12(join20(dir, "profile.json"), JSON.stringify(profile, null, 2));
+  writeFileSync12(join21(dir, "profile.json"), JSON.stringify(profile, null, 2));
 }
 async function projectSetupCommand(projectPath, options) {
   const verbose = options.verbose ?? false;
   const dryRun = options.dryRun ?? false;
   const resolvedPath = normalizeProjectPath(projectPath);
-  if (!existsSync15(resolvedPath)) {
+  if (!existsSync16(resolvedPath)) {
     console.error(`  ✗ Path not found: ${resolvedPath}`);
     process.exit(1);
   }
@@ -16408,8 +17426,8 @@ init_data();
 // src/core/topology-apply.ts
 init_config();
 init_data();
-import { copyFileSync, existsSync as existsSync16, mkdirSync as mkdirSync7, readFileSync as readFileSync13, writeFileSync as writeFileSync13 } from "node:fs";
-import { join as join21 } from "node:path";
+import { copyFileSync, existsSync as existsSync17, mkdirSync as mkdirSync7, readFileSync as readFileSync14, writeFileSync as writeFileSync13 } from "node:fs";
+import { join as join22 } from "node:path";
 function uniqueStrings2(values) {
   return [...new Set(values.filter((value) => Boolean(value && value.trim())))];
 }
@@ -16435,24 +17453,24 @@ function snapshotId(prefix) {
   return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`.replace(/[^a-zA-Z0-9_-]/g, "-");
 }
 function readSkillRaw(slug) {
-  const path = join21(getGeneralSkillsPath(), slug, "SKILL.md");
-  if (!existsSync16(path))
+  const path = join22(getGeneralSkillsPath(), slug, "SKILL.md");
+  if (!existsSync17(path))
     return null;
-  return { path, raw: readFileSync13(path, "utf-8") };
+  return { path, raw: readFileSync14(path, "utf-8") };
 }
 function createSnapshot(params) {
   const id = snapshotId("topology_snapshot");
-  const snapshotDir = join21(getHelixDir(), "topology-snapshots", id);
+  const snapshotDir = join22(getHelixDir(), "topology-snapshots", id);
   mkdirSync7(snapshotDir, { recursive: true });
-  const graphPath = join21(snapshotDir, "skill-graph.json");
-  const overridesPath = join21(snapshotDir, "topology-overrides.json");
+  const graphPath = join22(snapshotDir, "skill-graph.json");
+  const overridesPath = join22(snapshotDir, "topology-overrides.json");
   writeFileSync13(graphPath, JSON.stringify(loadSkillGraph(), null, 2));
   writeFileSync13(overridesPath, JSON.stringify(loadTopologyOverrides(), null, 2));
   const skillFileSnapshots = uniqueStrings2(params.skillSlugs ?? []).flatMap((slug) => {
     const skill = readSkillRaw(slug);
     if (!skill)
       return [];
-    const snapshotPath = join21(snapshotDir, `${slug}.SKILL.md`);
+    const snapshotPath = join22(snapshotDir, `${slug}.SKILL.md`);
     copyFileSync(skill.path, snapshotPath);
     return [{ slug, path: skill.path, snapshotPath }];
   });
@@ -16693,10 +17711,10 @@ function rollbackAppliedTopologyPlan(planId) {
     throw new Error(`Topology plan ${planId} must be applied before rollback`);
   }
   const beforeSnapshot = loadTopologySnapshots().find((snapshot) => snapshot.id === plan.beforeSnapshotId);
-  if (!beforeSnapshot || !existsSync16(beforeSnapshot.overridesPath)) {
+  if (!beforeSnapshot || !existsSync17(beforeSnapshot.overridesPath)) {
     throw new Error(`Before-apply snapshot for ${planId} is missing or incomplete`);
   }
-  const restoredOverrides = JSON.parse(readFileSync13(beforeSnapshot.overridesPath, "utf-8"));
+  const restoredOverrides = JSON.parse(readFileSync14(beforeSnapshot.overridesPath, "utf-8"));
   saveTopologyOverrides({
     ...restoredOverrides,
     updatedAt: new Date().toISOString()
@@ -16972,14 +17990,14 @@ async function ontologyCommand(options) {
 }
 
 // src/core/proof.ts
-import { existsSync as existsSync17, readFileSync as readFileSync14 } from "node:fs";
-import { join as join22 } from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync15 } from "node:fs";
+import { join as join23 } from "node:path";
 init_config();
 init_data();
 var PROOF_REVIEW_FILE = "proof-reviews.jsonl";
 var MEASURING_WINDOW_DAYS = 2;
 function proofPath() {
-  return join22(getHelixDir(), PROOF_REVIEW_FILE);
+  return join23(getHelixDir(), PROOF_REVIEW_FILE);
 }
 function uniqueStrings3(values) {
   return [...new Set(values.filter((value) => Boolean(value && value.trim())))];
@@ -16998,9 +18016,9 @@ function buildRecordId(targetType, targetId) {
 }
 function readProofReviews() {
   const path = proofPath();
-  if (!existsSync17(path))
+  if (!existsSync18(path))
     return [];
-  const raw = readFileSync14(path, "utf-8").trim();
+  const raw = readFileSync15(path, "utf-8").trim();
   if (!raw)
     return [];
   return raw.split(`
@@ -17476,7 +18494,7 @@ Examples:
   $ helixevo graph --mermaid               Open graph in browser
   $ helixevo graph --obsidian ~/vault      Sync to Obsidian vault
   $ helixevo graph --rebuild               Re-infer relationships (LLM call)
-  $ helixevo graph --optimize              Detect structural candidates + refresh topology review queue
+  $ helixevo graph --optimize              Refresh topology review queue first, then report full vs partial enrichment
   $ helixevo topology --status             Show reviewed topology execution state
   $ helixevo topology --prepare <id>       Prepare an accepted topology candidate
   $ helixevo topology --apply <planId>     Apply a safe prepared topology plan
@@ -17495,12 +18513,12 @@ program2.command("capture").description("Capture failures from a Craft Agent ses
 program2.command("evolve").description("Evolve skills from failures [--dry-run] [--verbose] [--max-proposals <n>]").option("--dry-run", "Show proposals without applying").option("--verbose", "Show detailed LLM interactions").option("--max-proposals <n>", "Max proposals per run", "5").action(evolveCommand);
 program2.command("generalize").description("Promote cross-skill patterns to higher layer ↑ [--dry-run] [--verbose]").option("--dry-run", "Show candidates without applying").option("--verbose", "Show detailed analysis").action(generalizeCommand);
 program2.command("specialize").description("Create project-specific skills ↓ --project <name> [--dry-run] [--verbose]").requiredOption("--project <name>", "Project name").option("--dry-run", "Show candidates without applying").option("--verbose", "Show detailed analysis").action(specializeCommand);
-program2.command("graph").description("Skill network [--mermaid] [--obsidian <path>] [--rebuild] [--optimize refreshes topology review]").option("--mermaid", "Render as Mermaid diagram in browser").option("--rebuild", "Force rebuild (re-infer relationships via LLM)").option("--obsidian <path>", "Sync to Obsidian vault at path").option("--optimize", "Run network optimization (merge/split/conflict detection)").option("--verbose", "Show detailed analysis").action(graphCommand);
+program2.command("graph").description("Skill network [--mermaid] [--obsidian <path>] [--rebuild] [--optimize refreshes topology review and reports full vs partial enrichment]").option("--mermaid", "Render as Mermaid diagram in browser").option("--rebuild", "Force rebuild (re-infer relationships via LLM)").option("--obsidian <path>", "Sync to Obsidian vault at path").option("--optimize", "Run network optimization (merge/split/conflict detection)").option("--verbose", "Show detailed analysis").action(graphCommand);
 program2.command("research").description("Proactive research via web [--project <path>] [--dry-run] [--verbose]").option("--project <path>", "Project path for goal extraction").option("--dry-run", "Show discoveries without creating skills").option("--verbose", "Show detailed research steps").option("--max-hypotheses <n>", "Max hypotheses to test", "3").action(researchCommand);
 program2.command("dashboard").description("Open web dashboard (default: http://localhost:3847, falls forward if occupied)").option("--background", "Run in background (detach from terminal)").option("--stop", "Stop a background dashboard").option("--port <port>", "Preferred port to try first (default: 3847)").option("--no-auto-update", "Skip automatic update check before launching the dashboard").action(async (options) => {
   await dashboardCommand(options);
 });
-program2.command("status").description("Show frontier, skills, failures, and network health").action(statusCommand);
+program2.command("status").description("Show frontier, skills, failures, network health, and provider control truth").action(statusCommand);
 program2.command("report").description("Evolution report [--days <n>] [--output <path>]").option("--days <n>", "Report period in days", "1").option("--output <path>", "Output path for report").action(reportCommand);
 program2.command("watch").description("Always-on learning: auto-capture corrections + auto-evolve").option("--project <name>", "Project name for captured failures").option("--events <path>", "Path to events.jsonl (default: ./events.jsonl)").option("--verbose", "Show detailed capture and metrics").option("--no-evolve", "Disable auto-evolution (capture only)").action(watchCommand);
 program2.command("health").description("Assess network health: cohesion, coverage, balance, cross-project transfer").option("--verbose", "Show detailed analysis").action(async (options) => {
@@ -17516,4 +18534,10 @@ program2.command("ontology").description("Governed ontology frontier and semanti
 program2.hook("postAction", () => {
   checkForUpdates().catch(() => {});
 });
-program2.parse();
+try {
+  await program2.parseAsync(process.argv);
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(message);
+  process.exit(1);
+}