open-walnut 0.4.2 → 0.4.3

package/dist/web/server.js

@@ -2018,10 +2018,155 @@ var init_model_catalog = __esm({
   }
 });
 
-// src/core/ssh-config-scanner.ts
-import fs3 from "fs/promises";
-import path3 from "path";
+// src/core/claude-cli-detect.ts
+var claude_cli_detect_exports = {};
+__export(claude_cli_detect_exports, {
+  _CLAUDE_CREDENTIALS_HOME: () => _CLAUDE_CREDENTIALS_HOME,
+  describeClaudeCliAuth: () => describeClaudeCliAuth,
+  detectClaudeCli: () => detectClaudeCli,
+  hasClaudeSubscriptionAuth: () => hasClaudeSubscriptionAuth,
+  isClaudeCliInstalled: () => isClaudeCliInstalled,
+  resolveClaudeCliExecutable: () => resolveClaudeCliExecutable
+});
+import { execFileSync } from "child_process";
+import fs3 from "fs";
 import os2 from "os";
+import path3 from "path";
+function resolveClaudeCliExecutable(env3 = process.env) {
+  const home = env3.HOME || os2.homedir();
+  const pathDirs = (env3.PATH ?? "").split(path3.delimiter).filter(Boolean);
+  const fallbackDirs = [
+    path3.join(home, ".toolbox", "bin"),
+    path3.join(home, ".local", "bin"),
+    path3.join(home, ".npm-global", "bin"),
+    path3.join(home, ".bun", "bin"),
+    "/usr/local/bin",
+    "/opt/homebrew/bin",
+    "/usr/bin",
+    "/bin"
+  ];
+  for (const dir2 of [.../* @__PURE__ */ new Set([...pathDirs, ...fallbackDirs])]) {
+    const candidate = path3.join(dir2, "claude");
+    try {
+      fs3.accessSync(candidate, fs3.constants.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function isClaudeCliInstalled() {
+  return resolveClaudeCliExecutable() !== null;
+}
+function hasClaudeSubscriptionAuth() {
+  if (process.platform === "darwin") {
+    try {
+      execFileSync("security", ["find-generic-password", "-s", KEYCHAIN_OAUTH_SERVICE], {
+        stdio: "ignore"
+      });
+      return true;
+    } catch {
+    }
+  }
+  return fileCredentialExists();
+}
+function fileCredentialExists() {
+  try {
+    return fs3.existsSync(CLAUDE_CREDENTIALS_FILE);
+  } catch {
+    return false;
+  }
+}
+function detectClaudeCli() {
+  const installed2 = isClaudeCliInstalled();
+  const subscriptionAuth = installed2 && hasClaudeSubscriptionAuth();
+  return {
+    installed: installed2,
+    subscriptionAuth,
+    subscriptionReady: installed2 && subscriptionAuth,
+    ready: installed2,
+    auth: installed2 ? describeClaudeCliAuth() : { mode: "unknown", label: "not installed" }
+  };
+}
+function describeClaudeCliAuth(env3 = process.env, settingsEnv = readClaudeSettingsEnv()) {
+  const merged = { ...env3, ...settingsEnv };
+  const truthy = (v3) => !!v3 && v3 !== "0" && v3.toLowerCase() !== "false";
+  if (truthy(merged.CLAUDE_CODE_USE_BEDROCK)) {
+    const region = merged.AWS_REGION || merged.AWS_DEFAULT_REGION;
+    return { mode: "bedrock", label: region ? `Bedrock (${region})` : "Bedrock" };
+  }
+  if (truthy(merged.CLAUDE_CODE_USE_VERTEX)) return { mode: "vertex", label: "Vertex AI" };
+  if (merged.ANTHROPIC_API_KEY || merged.ANTHROPIC_AUTH_TOKEN) return { mode: "api-key", label: "an Anthropic API key" };
+  if (hasClaudeSubscriptionAuth()) return { mode: "subscription", label: "your Claude subscription" };
+  return { mode: "unknown", label: "its own login" };
+}
+function readClaudeSettingsEnv() {
+  try {
+    const raw = fs3.readFileSync(path3.join(os2.homedir(), ".claude", "settings.json"), "utf8");
+    const env3 = JSON.parse(raw).env ?? {};
+    return Object.fromEntries(Object.entries(env3).filter(([, v3]) => typeof v3 === "string"));
+  } catch {
+    return {};
+  }
+}
+var KEYCHAIN_OAUTH_SERVICE, _CLAUDE_CREDENTIALS_HOME;
+var init_claude_cli_detect = __esm({
+  "src/core/claude-cli-detect.ts"() {
+    "use strict";
+    init_constants();
+    KEYCHAIN_OAUTH_SERVICE = "Claude Code-credentials";
+    _CLAUDE_CREDENTIALS_HOME = os2.homedir();
+  }
+});
+
+// src/agent/providers/default-provider.ts
+var default_provider_exports = {};
+__export(default_provider_exports, {
+  CLAUDE_CLI_PROVIDER: () => CLAUDE_CLI_PROVIDER,
+  LEGACY_DEFAULT_PROVIDER: () => LEGACY_DEFAULT_PROVIDER,
+  _resetDefaultProviderCacheForTesting: () => _resetDefaultProviderCacheForTesting,
+  hasExplicitBedrockConfig: () => hasExplicitBedrockConfig,
+  mainProviderIsImplicit: () => mainProviderIsImplicit,
+  resolveMainProviderName: () => resolveMainProviderName
+});
+function claudeCliInstalledCached() {
+  const now = Date.now();
+  if (!cliProbe || now - cliProbe.at > CLI_PROBE_TTL_MS) {
+    cliProbe = { at: now, installed: isClaudeCliInstalled() };
+  }
+  return cliProbe.installed;
+}
+function _resetDefaultProviderCacheForTesting() {
+  cliProbe = void 0;
+}
+function hasExplicitBedrockConfig(config) {
+  const b8 = config.providers?.bedrock;
+  if (b8 && (b8.bearer_token || b8.aws_access_key_id || b8.aws_profile || b8.aws_credential_export)) return true;
+  return !!config.provider?.bedrock_bearer_token;
+}
+function resolveMainProviderName(config, claudeInstalled = claudeCliInstalledCached()) {
+  if (config.agent?.main_provider) return config.agent.main_provider;
+  if (claudeInstalled) return CLAUDE_CLI_PROVIDER;
+  return LEGACY_DEFAULT_PROVIDER;
+}
+function mainProviderIsImplicit(config) {
+  return !config.agent?.main_provider;
+}
+var LEGACY_DEFAULT_PROVIDER, CLAUDE_CLI_PROVIDER, CLI_PROBE_TTL_MS, cliProbe;
+var init_default_provider = __esm({
+  "src/agent/providers/default-provider.ts"() {
+    "use strict";
+    init_claude_cli_detect();
+    LEGACY_DEFAULT_PROVIDER = "bedrock";
+    CLAUDE_CLI_PROVIDER = "claude_cli";
+    CLI_PROBE_TTL_MS = 6e4;
+  }
+});
+
+// src/core/ssh-config-scanner.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+import os3 from "os";
 function isGitServerHost(h8) {
   if (h8.user === "git") return true;
   const gitPrefix = /^(git|github|gitlab|bitbucket|codecommit|ssh\.github)\./i;
@@ -2037,10 +2182,10 @@ function shortLabelForFqdn(hostname) {
   return `${first.slice(0, 12)}\u2026${first.slice(-8)}`;
 }
 async function scanSshConfig(configPath) {
-  const sshConfigPath = configPath ?? path3.join(os2.homedir(), ".ssh", "config");
+  const sshConfigPath = configPath ?? path4.join(os3.homedir(), ".ssh", "config");
   let mtimeMs2;
   try {
-    mtimeMs2 = (await fs3.stat(sshConfigPath)).mtimeMs;
+    mtimeMs2 = (await fs4.stat(sshConfigPath)).mtimeMs;
   } catch {
     return /* @__PURE__ */ new Map();
   }
@@ -2053,7 +2198,7 @@ async function scanSshConfig(configPath) {
 async function parseSshConfigFile(sshConfigPath) {
   const discovered = /* @__PURE__ */ new Map();
   try {
-    const content = await fs3.readFile(sshConfigPath, "utf-8");
+    const content = await fs4.readFile(sshConfigPath, "utf-8");
     const lines = content.split("\n");
     let currentHost = null;
     for (const rawLine of lines) {
@@ -2154,23 +2299,24 @@ __export(config_manager_exports, {
   updatePushTokens: () => updatePushTokens,
   writeFileAtomic: () => writeFileAtomic
 });
-import fs4 from "fs/promises";
+import fs5 from "fs/promises";
 import yaml from "js-yaml";
-function resolveAgentEngineProvider(config) {
+function resolveAgentEngineProvider(config, claudeInstalled) {
   if (CLOUD_MODE) return "walnut-agent";
   const raw = config.agent?.provider;
   if (typeof raw === "string" && VALID_AGENT_ENGINE_PROVIDERS.has(raw)) {
     return raw;
   }
-  if (raw !== void 0) {
-    log.session.warn("config-manager: agent.provider is not a known engine \u2014 using the default", {
-      value: typeof raw === "string" ? raw : `<${typeof raw}>`,
-      using: FALLBACK_AGENT_ENGINE_PROVIDER,
-      valid: [...VALID_AGENT_ENGINE_PROVIDERS].join(", ")
-    });
-    return FALLBACK_AGENT_ENGINE_PROVIDER;
+  if (raw === void 0) {
+    const main = claudeInstalled === void 0 ? resolveMainProviderName(config) : resolveMainProviderName(config, claudeInstalled);
+    return main === CLAUDE_CLI_PROVIDER ? "claude-code" : "walnut-agent";
   }
-  return DEFAULT_AGENT_ENGINE_PROVIDER;
+  log.session.warn("config-manager: agent.provider is not a known engine \u2014 using the fallback", {
+    value: typeof raw === "string" ? raw : `<${typeof raw}>`,
+    using: FALLBACK_AGENT_ENGINE_PROVIDER,
+    valid: [...VALID_AGENT_ENGINE_PROVIDERS].join(", ")
+  });
+  return FALLBACK_AGENT_ENGINE_PROVIDER;
 }
 function migrateConfigToProjectOnly(config) {
   let changed = false;
@@ -2243,13 +2389,13 @@ function migrateConfigToProjectOnly(config) {
 }
 async function readRawConfigContent() {
   try {
-    const primary = await fs4.readFile(CONFIG_FILE, "utf-8");
+    const primary = await fs5.readFile(CONFIG_FILE, "utf-8");
     if (primary.trim()) return primary;
     throw new Error("config.yaml is empty");
   } catch (primaryErr) {
     let backup;
     try {
-      backup = await fs4.readFile(CONFIG_BACKUP_FILE, "utf-8");
+      backup = await fs5.readFile(CONFIG_BACKUP_FILE, "utf-8");
     } catch {
       return null;
     }
@@ -2259,7 +2405,7 @@ async function readRawConfigContent() {
       backup: CONFIG_BACKUP_FILE
     });
     try {
-      await fs4.writeFile(CONFIG_FILE, backup, "utf-8");
+      await fs5.writeFile(CONFIG_FILE, backup, "utf-8");
     } catch {
     }
     return backup;
@@ -2268,10 +2414,10 @@ async function readRawConfigContent() {
 async function writeFileAtomic(filePath, content) {
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now().toString(36)}`;
   try {
-    await fs4.writeFile(tmp, content, "utf-8");
-    await fs4.rename(tmp, filePath);
+    await fs5.writeFile(tmp, content, "utf-8");
+    await fs5.rename(tmp, filePath);
   } catch (err2) {
-    await fs4.rm(tmp, { force: true }).catch(() => {
+    await fs5.rm(tmp, { force: true }).catch(() => {
     });
     throw err2;
   }
@@ -2469,7 +2615,7 @@ async function seedConfigDefaults() {
   const config = await getConfig();
   let needsWrite = false;
   try {
-    const raw = await fs4.readFile(CONFIG_FILE, "utf-8");
+    const raw = await fs5.readFile(CONFIG_FILE, "utf-8");
     if (!raw.includes("available_models")) {
       needsWrite = true;
     }
@@ -2497,6 +2643,7 @@ var init_config_manager = __esm({
     init_constants();
     init_types();
     init_model_catalog();
+    init_default_provider();
     init_ssh_config_scanner();
     DEFAULT_CONFIG = {
       version: 1,
@@ -2508,12 +2655,12 @@ var init_config_manager = __esm({
       // so this never re-routes an established setup.
       defaults: { priority: "none", platform: "local" },
       provider: { type: "claude-code" },
-      // Which ENGINE answers a Personal AI chat turn. 'walnut-agent' = today's in-process
-      // agent loop; 'claude-code' routes the turn into a lane-bound `claude` session.
-      // NOTE: getConfig() spreads the parsed file OVER these defaults at the TOP
-      // level, so a config.yaml with any `agent:` section replaces this whole object
-      // — resolveAgentEngineProvider() (below) is what actually applies the default.
-      agent: { provider: DEFAULT_AGENT_ENGINE_PROVIDER }
+      // Which ENGINE answers a Personal AI chat turn is NOT defaulted here: it follows
+      // the AI provider (Settings → AI Provider) — see resolveAgentEngineProvider().
+      // getConfig() spreads the parsed file OVER these defaults at the TOP level, so
+      // anything put in this object is dropped by any config.yaml with an `agent:`
+      // section; the resolver is what actually applies the rule.
+      agent: {}
     };
     CONFIG_BACKUP_FILE = `${CONFIG_FILE}.bak`;
     writeLock = Promise.resolve();
@@ -2521,14 +2668,14 @@ var init_config_manager = __esm({
 });
 
 // src/utils/file-lock.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import fsp2 from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 function lockDir(filePath) {
   return filePath + ".lock";
 }
 function pidFile(lock) {
-  return path4.join(lock, "pid");
+  return path5.join(lock, "pid");
 }
 function isPidAlive(pid) {
   try {
@@ -2541,7 +2688,7 @@ function isPidAlive(pid) {
 async function withFileLock(filePath, fn) {
   const lock = lockDir(filePath);
   const deadline4 = Date.now() + TIMEOUT_MS;
-  await fsp2.mkdir(path4.dirname(lock), { recursive: true });
+  await fsp2.mkdir(path5.dirname(lock), { recursive: true });
   while (true) {
     try {
       await fsp2.mkdir(lock);
@@ -2616,10 +2763,10 @@ __export(device_auth_exports, {
   verifyDeviceToken: () => verifyDeviceToken
 });
 import crypto2 from "crypto";
-import fs6 from "fs/promises";
-import path5 from "path";
+import fs7 from "fs/promises";
+import path6 from "path";
 function authFilePath() {
-  return path5.join(WALNUT_HOME, "auth.json");
+  return path6.join(WALNUT_HOME, "auth.json");
 }
 function sha256Hex(input) {
   return crypto2.createHash("sha256").update(input, "utf-8").digest("hex");
@@ -2634,7 +2781,7 @@ async function loadAuth() {
   const file = authFilePath();
   let raw;
   try {
-    raw = await fs6.readFile(file, "utf-8");
+    raw = await fs7.readFile(file, "utf-8");
   } catch {
     const recovered = await readAuthBackup();
     if (recovered) {
@@ -2667,7 +2814,7 @@ function authBackupPath() {
 }
 async function readAuthBackup() {
   try {
-    const raw = await fs6.readFile(authBackupPath(), "utf-8");
+    const raw = await fs7.readFile(authBackupPath(), "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.devices)) return null;
     const devices = parsed.devices.filter((d8) => d8 && typeof d8.name === "string" && typeof d8.tokenHash === "string");
@@ -2678,14 +2825,14 @@ async function readAuthBackup() {
 }
 async function saveAuth(auth) {
   const file = authFilePath();
-  await fs6.mkdir(path5.dirname(file), { recursive: true });
+  await fs7.mkdir(path6.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}`;
-  await fs6.writeFile(tmp, JSON.stringify(auth, null, 2) + "\n", { mode: 384 });
-  await fs6.rename(tmp, file);
+  await fs7.writeFile(tmp, JSON.stringify(auth, null, 2) + "\n", { mode: 384 });
+  await fs7.rename(tmp, file);
   try {
     const btmp = `${authBackupPath()}.tmp-${process.pid}`;
-    await fs6.writeFile(btmp, JSON.stringify(auth, null, 2) + "\n", { mode: 384 });
-    await fs6.rename(btmp, authBackupPath());
+    await fs7.writeFile(btmp, JSON.stringify(auth, null, 2) + "\n", { mode: 384 });
+    await fs7.rename(btmp, authBackupPath());
   } catch (err2) {
     log.web.warn("failed to update auth.json.bak", { error: err2 instanceof Error ? err2.message : String(err2) });
   }
@@ -2813,7 +2960,7 @@ async function readProvisionedSetupToken() {
     if (file) {
       source = "file";
       try {
-        candidate = await fs6.readFile(file, "utf-8");
+        candidate = await fs7.readFile(file, "utf-8");
       } catch (err2) {
         const code = err2.code;
         if (code !== "ENOENT") {
@@ -2904,7 +3051,7 @@ async function claimInstance(candidateToken, deviceName) {
   const tokenFile = process.env.WALNUT_SETUP_TOKEN_FILE;
   if (tokenFile) {
     try {
-      await fs6.unlink(tokenFile);
+      await fs7.unlink(tokenFile);
     } catch {
     }
   }
@@ -4893,8 +5040,8 @@ var init_format = __esm({
 
 // src/utils/json-conflict-recovery.ts
 import fsp3 from "fs/promises";
-import path6 from "path";
-import os3 from "os";
+import path7 from "path";
+import os4 from "os";
 import crypto5 from "crypto";
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -4974,12 +5121,12 @@ function jsonCandidatesFromPorcelain(lines) {
   return [...out];
 }
 function resolveWalnutDataDir() {
-  return process.env.OPEN_WALNUT_HOME || path6.join(os3.homedir(), ".open-walnut");
+  return process.env.OPEN_WALNUT_HOME || path7.join(os4.homedir(), ".open-walnut");
 }
 function isInsideWalnutDataDir(filePath) {
-  const dataDir2 = path6.resolve(resolveWalnutDataDir());
-  const abs = path6.resolve(filePath);
-  return abs === dataDir2 || abs.startsWith(dataDir2 + path6.sep);
+  const dataDir2 = path7.resolve(resolveWalnutDataDir());
+  const abs = path7.resolve(filePath);
+  return abs === dataDir2 || abs.startsWith(dataDir2 + path7.sep);
 }
 async function gitRead(repoDir, args) {
   try {
@@ -5014,17 +5161,17 @@ async function findLastValidJsonVersion(repoDir, relPath, depth = HISTORY_DEPTH)
   return null;
 }
 async function findRepoRootUpward(startDir, boundaryDir) {
-  const boundary = path6.resolve(boundaryDir);
-  let dir2 = path6.resolve(startDir);
-  if (dir2 !== boundary && !dir2.startsWith(boundary + path6.sep)) return null;
+  const boundary = path7.resolve(boundaryDir);
+  let dir2 = path7.resolve(startDir);
+  if (dir2 !== boundary && !dir2.startsWith(boundary + path7.sep)) return null;
   for (; ; ) {
     try {
-      await fsp3.stat(path6.join(dir2, ".git"));
+      await fsp3.stat(path7.join(dir2, ".git"));
       return dir2;
     } catch {
     }
     if (dir2 === boundary) return null;
-    const parent = path6.dirname(dir2);
+    const parent = path7.dirname(dir2);
     if (parent === dir2) return null;
     dir2 = parent;
   }
@@ -5055,8 +5202,8 @@ function sidecarPath(filePath, label) {
   return `${filePath}.${label}-${stamp}`;
 }
 async function writeFileAtomic2(filePath, content) {
-  const dir2 = path6.dirname(filePath);
-  const tmp = path6.join(dir2, `.open-walnut-${crypto5.randomBytes(8).toString("hex")}.tmp`);
+  const dir2 = path7.dirname(filePath);
+  const tmp = path7.join(dir2, `.open-walnut-${crypto5.randomBytes(8).toString("hex")}.tmp`);
   try {
     await fsp3.writeFile(tmp, content, "utf-8");
     await fsp3.rename(tmp, filePath);
@@ -5067,7 +5214,7 @@ async function writeFileAtomic2(filePath, content) {
   }
 }
 async function healJsonFileFromHistory(opts) {
-  const relPath = (opts.relPath ?? path6.relative(opts.repoDir, opts.filePath)).split(path6.sep).join("/");
+  const relPath = (opts.relPath ?? path7.relative(opts.repoDir, opts.filePath)).split(path7.sep).join("/");
   if (relPath.startsWith("..")) return { action: "skipped", error: "file is outside repoDir" };
   const valid = await findLastValidJsonVersion(opts.repoDir, relPath, opts.depth);
   const parked = sidecarPath(opts.filePath, opts.label);
@@ -5094,7 +5241,7 @@ async function healJsonFileFromHistory(opts) {
   return { action: "restored", restoredFrom: valid.rev, movedTo, content: valid.content };
 }
 async function selfHealDataDirJson(filePath) {
-  const abs = path6.resolve(filePath);
+  const abs = path7.resolve(filePath);
   if (!isInsideWalnutDataDir(abs)) return null;
   const failedAt = selfHealFailedAt.get(abs);
   if (failedAt !== void 0 && Date.now() - failedAt < SELF_HEAL_FAILURE_MEMO_MS) return null;
@@ -5102,7 +5249,7 @@ async function selfHealDataDirJson(filePath) {
   if (existing) return existing;
   const work = (async () => {
     const dataDir2 = resolveWalnutDataDir();
-    const repoRoot = await findRepoRootUpward(path6.dirname(abs), dataDir2);
+    const repoRoot = await findRepoRootUpward(path7.dirname(abs), dataDir2);
     if (!repoRoot) return null;
     const result = await healJsonFileFromHistory({
       repoDir: repoRoot,
@@ -5145,25 +5292,25 @@ var init_json_conflict_recovery = __esm({
 });
 
 // src/utils/fs.ts
-import fs7 from "fs/promises";
-import path7 from "path";
+import fs8 from "fs/promises";
+import path8 from "path";
 import crypto6 from "crypto";
 async function writeJsonFile(filePath, data, options = {}) {
-  const dir2 = path7.dirname(filePath);
-  await fs7.mkdir(dir2, { recursive: true });
-  const tmpFile = path7.join(
+  const dir2 = path8.dirname(filePath);
+  await fs8.mkdir(dir2, { recursive: true });
+  const tmpFile = path8.join(
     dir2,
     `.open-walnut-${crypto6.randomBytes(8).toString("hex")}.tmp`
   );
   try {
-    await fs7.writeFile(tmpFile, JSON.stringify(data, null, 2) + "\n", {
+    await fs8.writeFile(tmpFile, JSON.stringify(data, null, 2) + "\n", {
       encoding: "utf-8",
       ...options.mode === void 0 ? {} : { mode: options.mode }
     });
-    await fs7.rename(tmpFile, filePath);
-    if (options.mode !== void 0) await fs7.chmod(filePath, options.mode);
+    await fs8.rename(tmpFile, filePath);
+    if (options.mode !== void 0) await fs8.chmod(filePath, options.mode);
   } catch (err2) {
-    await fs7.rm(tmpFile, { force: true }).catch(() => {
+    await fs8.rm(tmpFile, { force: true }).catch(() => {
     });
     throw err2;
   }
@@ -5171,7 +5318,7 @@ async function writeJsonFile(filePath, data, options = {}) {
 async function readJsonFile(filePath, fallback) {
   let content;
   try {
-    content = await fs7.readFile(filePath, "utf-8");
+    content = await fs8.readFile(filePath, "utf-8");
   } catch (err2) {
     if (err2 && typeof err2 === "object" && "code" in err2 && err2.code === "ENOENT") {
       return fallback;
@@ -5213,7 +5360,7 @@ async function updateJsonFile(filePath, fallback, mutate2, options = {}) {
   });
 }
 async function ensureDir(dirPath) {
-  await fs7.mkdir(dirPath, { recursive: true });
+  await fs8.mkdir(dirPath, { recursive: true });
 }
 var init_fs = __esm({
   "src/utils/fs.ts"() {
@@ -5238,7 +5385,7 @@ __export(file_ops_exports, {
 });
 import crypto7 from "crypto";
 import fsp4 from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 function computeContentHash(content) {
   return crypto7.createHash("sha256").update(content).digest("hex").slice(0, 12);
 }
@@ -5314,7 +5461,7 @@ async function editFileContent(filePath, oldContent, newContent, opts) {
   });
 }
 async function writeFileChecked(filePath, content, opts) {
-  await fsp4.mkdir(path8.dirname(filePath), { recursive: true });
+  await fsp4.mkdir(path9.dirname(filePath), { recursive: true });
   return withFileLock(filePath, async () => {
     if (opts?.expectedHash != null) {
       let raw;
@@ -5386,16 +5533,16 @@ __export(memory_file_exports, {
   getMemoryFile: () => getMemoryFile,
   updateMemoryFile: () => updateMemoryFile
 });
-import fs8 from "fs";
-import path9 from "path";
+import fs9 from "fs";
+import path10 from "path";
 function resolveMemoryPath(agentId) {
   if (!agentId || agentId === "general") return MEMORY_FILE;
-  return path9.join(agentMemoryDir(agentId), "MEMORY.md");
+  return path10.join(agentMemoryDir(agentId), "MEMORY.md");
 }
 function getMemoryFile(agentId) {
   const filePath = resolveMemoryPath(agentId);
   try {
-    const content = fs8.readFileSync(filePath, "utf-8");
+    const content = fs9.readFileSync(filePath, "utf-8");
     return { content, contentHash: computeContentHash(content) };
   } catch (err2) {
     log.memory.debug("memory-file: MEMORY.md not found or unreadable", {
@@ -5406,7 +5553,7 @@ function getMemoryFile(agentId) {
 }
 async function updateMemoryFile(content, expectedHash, agentId) {
   const filePath = resolveMemoryPath(agentId);
-  fs8.mkdirSync(path9.dirname(filePath), { recursive: true });
+  fs9.mkdirSync(path10.dirname(filePath), { recursive: true });
   const result = await writeFileChecked(filePath, content, {
     expectedHash
   });
@@ -5421,9 +5568,9 @@ async function editMemoryFile(oldContent, newContent, expectedHash, replaceAll,
 }
 function ensureMemoryFile(agentId) {
   const filePath = resolveMemoryPath(agentId);
-  if (fs8.existsSync(filePath)) return;
-  fs8.mkdirSync(path9.dirname(filePath), { recursive: true });
-  fs8.writeFileSync(filePath, DEFAULT_TEMPLATE, "utf-8");
+  if (fs9.existsSync(filePath)) return;
+  fs9.mkdirSync(path10.dirname(filePath), { recursive: true });
+  fs9.writeFileSync(filePath, DEFAULT_TEMPLATE, "utf-8");
 }
 var DEFAULT_TEMPLATE;
 var init_memory_file = __esm({
@@ -5443,15 +5590,15 @@ description: >
 
 // src/core/tmp-sweep.ts
 import fsp5 from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 function sweepDirs() {
   return [
     WALNUT_HOME,
     SYNC_DIR,
-    path10.join(WALNUT_HOME, "sessions"),
-    path10.join(WALNUT_HOME, "sessions", "transcripts"),
+    path11.join(WALNUT_HOME, "sessions"),
+    path11.join(WALNUT_HOME, "sessions", "transcripts"),
     TASKS_DIR,
-    path10.join(TASKS_DIR, "outbox"),
+    path11.join(TASKS_DIR, "outbox"),
     CONVERSATIONS_DIR,
     MEMORY_DIR,
     DAILY_DIR,
@@ -5472,7 +5619,7 @@ async function sweepOrphanAtomicTmpFiles() {
       const entries = await fsp5.readdir(dir2, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isFile() || !ORPHAN_RE.test(entry.name)) continue;
-        const full = path10.join(dir2, entry.name);
+        const full = path11.join(dir2, entry.name);
         try {
           const st = await fsp5.stat(full);
           if (st.mtimeMs > cutoff) continue;
@@ -5509,10 +5656,10 @@ __export(init_exports, {
   initDirectories: () => initDirectories
 });
 import fsp6 from "fs/promises";
-import fs9 from "fs";
+import fs10 from "fs";
 async function migrateLegacyMemoryFile() {
   try {
-    if (fs9.existsSync(LEGACY_MEMORY_FILE) && !fs9.existsSync(MEMORY_FILE)) {
+    if (fs10.existsSync(LEGACY_MEMORY_FILE) && !fs10.existsSync(MEMORY_FILE)) {
       await fsp6.rename(LEGACY_MEMORY_FILE, MEMORY_FILE);
       log.memory.info("Migrated MEMORY.md into memory/ folder", { from: LEGACY_MEMORY_FILE, to: MEMORY_FILE });
     }
@@ -6057,15 +6204,15 @@ __export(task_db_exports, {
   transaction: () => transaction
 });
 import Database from "better-sqlite3";
-import fs10 from "fs";
-import path11 from "path";
+import fs11 from "fs";
+import path12 from "path";
 import yaml2 from "js-yaml";
 function getDb() {
   if (db) return db;
   if (initAttempted) throw initError;
   initAttempted = true;
   try {
-    fs10.mkdirSync(path11.dirname(TASK_DB_PATH), { recursive: true });
+    fs11.mkdirSync(path12.dirname(TASK_DB_PATH), { recursive: true });
     const handle2 = new Database(TASK_DB_PATH);
     handle2.pragma("journal_mode = WAL");
     handle2.pragma("busy_timeout = 5000");
@@ -6295,8 +6442,8 @@ function migrateToProjectOnly(handle2) {
   }
   try {
     handle2.pragma("wal_checkpoint(TRUNCATE)");
-    if (!fs10.existsSync(TASK_DB_PRE_V5_BACKUP_PATH)) {
-      fs10.copyFileSync(TASK_DB_PATH, TASK_DB_PRE_V5_BACKUP_PATH);
+    if (!fs11.existsSync(TASK_DB_PRE_V5_BACKUP_PATH)) {
+      fs11.copyFileSync(TASK_DB_PATH, TASK_DB_PRE_V5_BACKUP_PATH);
       log.task.info("task-db v5: wrote pre-migration backup", { path: TASK_DB_PRE_V5_BACKUP_PATH });
     }
   } catch (err2) {
@@ -6806,7 +6953,7 @@ var init_task_db = __esm({
     init_constants();
     init_logging();
     init_phase2();
-    TASK_DB_PATH = path11.join(TASKS_DIR, "tasks.sqlite");
+    TASK_DB_PATH = path12.join(TASKS_DIR, "tasks.sqlite");
     EXPLICIT_TASK_COLUMNS = [
       "id",
       "title",
@@ -6969,8 +7116,8 @@ var init_task_db = __esm({
 });
 
 // src/core/task-db-migration.ts
-import fs11 from "fs";
-import path12 from "path";
+import fs12 from "fs";
+import path13 from "path";
 import yaml3 from "js-yaml";
 async function runMigrationIfNeeded() {
   const db5 = getDb();
@@ -6981,7 +7128,7 @@ async function runMigrationIfNeeded() {
   if (existing.n > 0) {
     return { migrated: false, count: existing.n };
   }
-  if (!fs11.existsSync(TASKS_FILE)) {
+  if (!fs12.existsSync(TASKS_FILE)) {
     return { migrated: false, count: 0 };
   }
   const store3 = await readJsonFile(TASKS_FILE, { version: 1, tasks: [] });
@@ -7138,9 +7285,9 @@ async function runMigrationIfNeeded() {
   }
   const after = db5.prepare("SELECT COUNT(*) AS n FROM tasks").get();
   const count2 = after.n;
-  const backupPath = path12.join(path12.dirname(TASKS_FILE), "tasks.json.migrated-from-json.backup");
+  const backupPath = path13.join(path13.dirname(TASKS_FILE), "tasks.json.migrated-from-json.backup");
   try {
-    fs11.copyFileSync(TASKS_FILE, backupPath);
+    fs12.copyFileSync(TASKS_FILE, backupPath);
   } catch (err2) {
     log.task.warn("task-db migration: backup copy failed (non-fatal)", {
       path: backupPath,
@@ -7164,9 +7311,9 @@ var init_task_db_migration = __esm({
 });
 
 // src/core/memory-dir-migration.ts
-import fs12 from "fs";
+import fs13 from "fs";
 import fsp7 from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 function bodyOf(content) {
   const fm = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
   return fm ? content.slice(fm[0].length) : content;
@@ -7184,7 +7331,7 @@ ${legacyBody}
 }
 function mtimeMs(file) {
   try {
-    return fs12.statSync(file).mtimeMs;
+    return fs13.statSync(file).mtimeMs;
   } catch {
     return 0;
   }
@@ -7193,24 +7340,24 @@ function findCandidates(root6) {
   const out = [];
   let level1;
   try {
-    level1 = fs12.readdirSync(root6, { withFileTypes: true });
+    level1 = fs13.readdirSync(root6, { withFileTypes: true });
   } catch {
     return out;
   }
   for (const cat of level1) {
     if (!cat.isDirectory()) continue;
-    const catDir = path13.join(root6, cat.name);
-    if (fs12.existsSync(path13.join(catDir, MEMORY_FILE_NAME))) continue;
+    const catDir = path14.join(root6, cat.name);
+    if (fs13.existsSync(path14.join(catDir, MEMORY_FILE_NAME))) continue;
     let level2;
     try {
-      level2 = fs12.readdirSync(catDir, { withFileTypes: true });
+      level2 = fs13.readdirSync(catDir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const proj of level2) {
       if (!proj.isDirectory()) continue;
-      const sourceDir = path13.join(catDir, proj.name);
-      if (!fs12.existsSync(path13.join(sourceDir, MEMORY_FILE_NAME))) continue;
+      const sourceDir = path14.join(catDir, proj.name);
+      if (!fs13.existsSync(path14.join(sourceDir, MEMORY_FILE_NAME))) continue;
       out.push({ category: cat.name, project: proj.name, sourceDir });
     }
   }
@@ -7224,11 +7371,11 @@ async function drainDir(from, to) {
     return;
   }
   for (const name of entries) {
-    const target = path13.join(to, name);
-    if (fs12.existsSync(target)) continue;
-    await fsp7.rename(path13.join(from, name), target).catch((err2) => {
+    const target = path14.join(to, name);
+    if (fs13.existsSync(target)) continue;
+    await fsp7.rename(path14.join(from, name), target).catch((err2) => {
       log.memory.warn("memory-dir migration: entry move failed", {
-        from: path13.join(from, name),
+        from: path14.join(from, name),
         to: target,
         error: String(err2)
       });
@@ -7240,23 +7387,23 @@ async function drainDir(from, to) {
 async function migrateProjectMemoryDirs() {
   const result = { ran: false, moved: 0, merged: 0 };
   try {
-    if (!fs12.existsSync(PROJECTS_MEMORY_DIR)) return result;
-    if (fs12.existsSync(MEMORY_DIR_MIGRATION_MARKER)) return result;
+    if (!fs13.existsSync(PROJECTS_MEMORY_DIR)) return result;
+    if (fs13.existsSync(MEMORY_DIR_MIGRATION_MARKER)) return result;
     result.ran = true;
     const candidates = findCandidates(PROJECTS_MEMORY_DIR);
     const touchedCategories = new Set(candidates.map((c8) => c8.category));
     for (const c8 of candidates) {
-      const targetDir = path13.join(PROJECTS_MEMORY_DIR, c8.project);
+      const targetDir = path14.join(PROJECTS_MEMORY_DIR, c8.project);
       const label = `${c8.category}/${c8.project}`;
       try {
-        if (!fs12.existsSync(targetDir)) {
+        if (!fs13.existsSync(targetDir)) {
           await fsp7.rename(c8.sourceDir, targetDir);
           result.moved += 1;
           continue;
         }
-        const sourceMem = path13.join(c8.sourceDir, MEMORY_FILE_NAME);
-        const targetMem = path13.join(targetDir, MEMORY_FILE_NAME);
-        if (!fs12.existsSync(targetMem)) {
+        const sourceMem = path14.join(c8.sourceDir, MEMORY_FILE_NAME);
+        const targetMem = path14.join(targetDir, MEMORY_FILE_NAME);
+        if (!fs13.existsSync(targetMem)) {
           await fsp7.rename(sourceMem, targetMem);
           await drainDir(c8.sourceDir, targetDir);
           result.moved += 1;
@@ -7278,7 +7425,7 @@ async function migrateProjectMemoryDirs() {
       }
     }
     for (const cat of touchedCategories) {
-      await fsp7.rmdir(path13.join(PROJECTS_MEMORY_DIR, cat)).catch(() => {
+      await fsp7.rmdir(path14.join(PROJECTS_MEMORY_DIR, cat)).catch(() => {
       });
     }
     await fsp7.writeFile(
@@ -7306,7 +7453,7 @@ var init_memory_dir_migration = __esm({
     "use strict";
     init_constants();
     init_logging();
-    MEMORY_DIR_MIGRATION_MARKER = path13.join(PROJECTS_MEMORY_DIR, ".migrated-project-only");
+    MEMORY_DIR_MIGRATION_MARKER = path14.join(PROJECTS_MEMORY_DIR, ".migrated-project-only");
     MEMORY_FILE_NAME = "MEMORY.md";
   }
 });
@@ -7522,7 +7669,7 @@ __export(microsoft_todo_exports, {
 });
 import * as msal from "@azure/msal-node";
 import https from "https";
-import path14 from "path";
+import path15 from "path";
 function getMsTodoConfig(config) {
   return config.plugins?.["ms-todo"];
 }
@@ -8741,8 +8888,8 @@ var init_microsoft_todo = __esm({
     init_format();
     init_task_manager();
     init_task_remote_links();
-    TOKENS_FILE = path14.join(SYNC_DIR, "ms-todo-tokens.json");
-    DELTA_FILE = path14.join(SYNC_DIR, "ms-todo-delta.json");
+    TOKENS_FILE = path15.join(SYNC_DIR, "ms-todo-tokens.json");
+    DELTA_FILE = path15.join(SYNC_DIR, "ms-todo-delta.json");
     GRAPH_BASE = "https://graph.microsoft.com/v1.0";
     SCOPES = ["Tasks.ReadWrite"];
     PRIORITY_TO_IMPORTANCE = {
@@ -8860,8 +9007,8 @@ var init_daemon_capabilities = __esm({
 
 // src/providers/daemon-version-check.ts
 import { createHash } from "crypto";
-import fs13 from "fs";
-import path15 from "path";
+import fs14 from "fs";
+import path16 from "path";
 import { spawnSync } from "child_process";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function computeExpectedDaemonVersion() {
@@ -8870,11 +9017,11 @@ function computeExpectedDaemonVersion() {
   const hash = createHash("sha256");
   const NUL = Buffer.from([0]);
   for (const rel of DAEMON_SOURCE_FILES) {
-    const abs = path15.join(repoRoot, rel);
+    const abs = path16.join(repoRoot, rel);
     try {
       hash.update(Buffer.from(rel));
       hash.update(NUL);
-      hash.update(fs13.readFileSync(abs));
+      hash.update(fs14.readFileSync(abs));
       hash.update(NUL);
     } catch {
       return null;
@@ -8883,12 +9030,12 @@ function computeExpectedDaemonVersion() {
   return "walnut-daemon-" + hash.digest("hex").slice(0, 12);
 }
 function findRepoRoot() {
-  let dir2 = path15.dirname(fileURLToPath2(import.meta.url));
+  let dir2 = path16.dirname(fileURLToPath2(import.meta.url));
   for (let i8 = 0; i8 < 10; i8++) {
-    if (fs13.existsSync(path15.join(dir2, "package.json")) && fs13.existsSync(path15.join(dir2, "src", "providers", "daemon-standalone.ts"))) {
+    if (fs14.existsSync(path16.join(dir2, "package.json")) && fs14.existsSync(path16.join(dir2, "src", "providers", "daemon-standalone.ts"))) {
       return dir2;
     }
-    const parent = path15.dirname(dir2);
+    const parent = path16.dirname(dir2);
     if (parent === dir2) break;
     dir2 = parent;
   }
@@ -9233,12 +9380,12 @@ var init_daemon_fold = __esm({
 });
 
 // src/providers/daemon-source.ts
-import fs14 from "fs";
-import path16 from "path";
+import fs15 from "fs";
+import path17 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function resolveDaemonSourceVersion() {
   const here = fileURLToPath3(import.meta.url);
-  const bundled = here.split(path16.sep).includes("dist");
+  const bundled = here.split(path17.sep).includes("dist");
   if (bundled) {
     const sidecar = readSidecarDaemonVersion(here);
     if (sidecar) return sidecar;
@@ -9246,32 +9393,32 @@ function resolveDaemonSourceVersion() {
   const computed = computeExpectedDaemonVersion();
   if (computed) return computed;
   if (process.env.DAEMON_VERSION) return process.env.DAEMON_VERSION;
-  let dir2 = path16.dirname(fileURLToPath3(import.meta.url));
+  let dir2 = path17.dirname(fileURLToPath3(import.meta.url));
   for (let i8 = 0; i8 < 10; i8++) {
     try {
-      const pkg = JSON.parse(fs14.readFileSync(path16.join(dir2, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs15.readFileSync(path17.join(dir2, "package.json"), "utf-8"));
       if (pkg.name === "open-walnut" && pkg.version) return `walnut-daemon-pkg-${pkg.version}`;
     } catch {
     }
-    const parent = path16.dirname(dir2);
+    const parent = path17.dirname(dir2);
     if (parent === dir2) break;
     dir2 = parent;
   }
   return "dev-source";
 }
 function readSidecarDaemonVersion(fromPath) {
-  let dir2 = path16.dirname(fromPath);
+  let dir2 = path17.dirname(fromPath);
   for (let i8 = 0; i8 < 5; i8++) {
-    const binDir = path16.join(dir2, "daemon-binaries");
+    const binDir = path17.join(dir2, "daemon-binaries");
     try {
-      for (const name of fs14.readdirSync(binDir)) {
+      for (const name of fs15.readdirSync(binDir)) {
         if (!name.endsWith(".version")) continue;
-        const v3 = fs14.readFileSync(path16.join(binDir, name), "utf-8").trim();
+        const v3 = fs15.readFileSync(path17.join(binDir, name), "utf-8").trim();
         if (v3) return v3;
       }
     } catch {
     }
-    const parent = path16.dirname(dir2);
+    const parent = path17.dirname(dir2);
     if (parent === dir2) break;
     dir2 = parent;
   }
@@ -16385,7 +16532,7 @@ if (action === '--start') {
 });
 
 // src/core/jsonl-tailer.ts
-import fs15 from "fs";
+import fs16 from "fs";
 var init_jsonl_tailer = __esm({
   "src/core/jsonl-tailer.ts"() {
     "use strict";
@@ -16394,10 +16541,10 @@ var init_jsonl_tailer = __esm({
 });
 
 // src/providers/session-io.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import fsp8 from "fs/promises";
-import path17 from "path";
-import { execFileSync } from "child_process";
+import path18 from "path";
+import { execFileSync as execFileSync2 } from "child_process";
 function shellQuote(s4) {
   return "'" + s4.replace(/'/g, "'\\''") + "'";
 }
@@ -16442,7 +16589,7 @@ function findRelativeImageNames(text, opts) {
 function findLocalImagePaths(text) {
   return findImagePaths(text).filter((p6) => {
     try {
-      return fs16.statSync(p6).isFile();
+      return fs17.statSync(p6).isFile();
     } catch {
       return false;
     }
@@ -17487,107 +17634,6 @@ var init_daemon_core = __esm({
   }
 });
 
-// src/core/claude-cli-detect.ts
-var claude_cli_detect_exports = {};
-__export(claude_cli_detect_exports, {
-  _CLAUDE_CREDENTIALS_HOME: () => _CLAUDE_CREDENTIALS_HOME,
-  describeClaudeCliAuth: () => describeClaudeCliAuth,
-  detectClaudeCli: () => detectClaudeCli,
-  hasClaudeSubscriptionAuth: () => hasClaudeSubscriptionAuth,
-  isClaudeCliInstalled: () => isClaudeCliInstalled,
-  resolveClaudeCliExecutable: () => resolveClaudeCliExecutable
-});
-import { execFileSync as execFileSync2 } from "child_process";
-import fs17 from "fs";
-import os4 from "os";
-import path18 from "path";
-function resolveClaudeCliExecutable(env3 = process.env) {
-  const home = env3.HOME || os4.homedir();
-  const pathDirs = (env3.PATH ?? "").split(path18.delimiter).filter(Boolean);
-  const fallbackDirs = [
-    path18.join(home, ".toolbox", "bin"),
-    path18.join(home, ".local", "bin"),
-    path18.join(home, ".npm-global", "bin"),
-    path18.join(home, ".bun", "bin"),
-    "/usr/local/bin",
-    "/opt/homebrew/bin",
-    "/usr/bin",
-    "/bin"
-  ];
-  for (const dir2 of [.../* @__PURE__ */ new Set([...pathDirs, ...fallbackDirs])]) {
-    const candidate = path18.join(dir2, "claude");
-    try {
-      fs17.accessSync(candidate, fs17.constants.X_OK);
-      return candidate;
-    } catch {
-    }
-  }
-  return null;
-}
-function isClaudeCliInstalled() {
-  return resolveClaudeCliExecutable() !== null;
-}
-function hasClaudeSubscriptionAuth() {
-  if (process.platform === "darwin") {
-    try {
-      execFileSync2("security", ["find-generic-password", "-s", KEYCHAIN_OAUTH_SERVICE], {
-        stdio: "ignore"
-      });
-      return true;
-    } catch {
-    }
-  }
-  return fileCredentialExists();
-}
-function fileCredentialExists() {
-  try {
-    return fs17.existsSync(CLAUDE_CREDENTIALS_FILE);
-  } catch {
-    return false;
-  }
-}
-function detectClaudeCli() {
-  const installed2 = isClaudeCliInstalled();
-  const subscriptionAuth = installed2 && hasClaudeSubscriptionAuth();
-  return {
-    installed: installed2,
-    subscriptionAuth,
-    subscriptionReady: installed2 && subscriptionAuth,
-    ready: installed2,
-    auth: installed2 ? describeClaudeCliAuth() : { mode: "unknown", label: "not installed" }
-  };
-}
-function describeClaudeCliAuth(env3 = process.env, settingsEnv = readClaudeSettingsEnv()) {
-  const merged = { ...env3, ...settingsEnv };
-  const truthy = (v3) => !!v3 && v3 !== "0" && v3.toLowerCase() !== "false";
-  if (truthy(merged.CLAUDE_CODE_USE_BEDROCK)) {
-    const region = merged.AWS_REGION || merged.AWS_DEFAULT_REGION;
-    return { mode: "bedrock", label: region ? `Bedrock (${region})` : "Bedrock" };
-  }
-  if (truthy(merged.CLAUDE_CODE_USE_VERTEX)) return { mode: "vertex", label: "Vertex AI" };
-  if (merged.ANTHROPIC_API_KEY || merged.ANTHROPIC_AUTH_TOKEN) return { mode: "api-key", label: "an Anthropic API key" };
-  if (hasClaudeSubscriptionAuth()) return { mode: "subscription", label: "your Claude subscription" };
-  return { mode: "unknown", label: "its own login" };
-}
-function readClaudeSettingsEnv() {
-  try {
-    const raw = fs17.readFileSync(path18.join(os4.homedir(), ".claude", "settings.json"), "utf8");
-    const env3 = JSON.parse(raw).env ?? {};
-    return Object.fromEntries(Object.entries(env3).filter(([, v3]) => typeof v3 === "string"));
-  } catch {
-    return {};
-  }
-}
-var KEYCHAIN_OAUTH_SERVICE, _CLAUDE_CREDENTIALS_HOME;
-var init_claude_cli_detect = __esm({
-  "src/core/claude-cli-detect.ts"() {
-    "use strict";
-    init_constants();
-    KEYCHAIN_OAUTH_SERVICE = "Claude Code-credentials";
-    _CLAUDE_CREDENTIALS_HOME = os4.homedir();
-  }
-});
-
 // src/providers/daemon-ownership.ts
 import fs18 from "fs";
 import os5 from "os";
@@ -68258,50 +68304,6 @@ var init_registry = __esm({
   }
 });
 
-// src/agent/providers/default-provider.ts
-var default_provider_exports = {};
-__export(default_provider_exports, {
-  CLAUDE_CLI_PROVIDER: () => CLAUDE_CLI_PROVIDER,
-  LEGACY_DEFAULT_PROVIDER: () => LEGACY_DEFAULT_PROVIDER,
-  _resetDefaultProviderCacheForTesting: () => _resetDefaultProviderCacheForTesting,
-  hasExplicitBedrockConfig: () => hasExplicitBedrockConfig,
-  mainProviderIsImplicit: () => mainProviderIsImplicit,
-  resolveMainProviderName: () => resolveMainProviderName
-});
-function claudeCliInstalledCached() {
-  const now = Date.now();
-  if (!cliProbe || now - cliProbe.at > CLI_PROBE_TTL_MS) {
-    cliProbe = { at: now, installed: isClaudeCliInstalled() };
-  }
-  return cliProbe.installed;
-}
-function _resetDefaultProviderCacheForTesting() {
-  cliProbe = void 0;
-}
-function hasExplicitBedrockConfig(config) {
-  const b8 = config.providers?.bedrock;
-  if (b8 && (b8.bearer_token || b8.aws_access_key_id || b8.aws_profile || b8.aws_credential_export)) return true;
-  return !!config.provider?.bedrock_bearer_token;
-}
-function resolveMainProviderName(config, claudeInstalled = claudeCliInstalledCached()) {
-  if (config.agent?.main_provider) return config.agent.main_provider;
-  if (claudeInstalled) return CLAUDE_CLI_PROVIDER;
-  return LEGACY_DEFAULT_PROVIDER;
-}
-function mainProviderIsImplicit(config) {
-  return !config.agent?.main_provider;
-}
-var LEGACY_DEFAULT_PROVIDER, CLAUDE_CLI_PROVIDER, CLI_PROBE_TTL_MS, cliProbe;
-var init_default_provider = __esm({
-  "src/agent/providers/default-provider.ts"() {
-    "use strict";
-    init_claude_cli_detect();
-    LEGACY_DEFAULT_PROVIDER = "bedrock";
-    CLAUDE_CLI_PROVIDER = "claude_cli";
-    CLI_PROBE_TTL_MS = 6e4;
-  }
-});
-
 // src/agent/model.ts
 var model_exports = {};
 __export(model_exports, {