claudish 7.7.0 → 7.7.2

package/dist/index.js

@@ -581,7 +581,135 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.7.0";
+var VERSION = "7.7.2";
+
+// src/providers/onepassword-wasm.ts
+var exports_onepassword_wasm = {};
+__export(exports_onepassword_wasm, {
+  verifyIntegrity: () => verifyIntegrity,
+  extractFileFromTarGz: () => extractFileFromTarGz,
+  ensureOpWasmAvailable: () => ensureOpWasmAvailable,
+  __resetOpWasmStateForTest: () => __resetOpWasmStateForTest,
+  SDK_CORE_VERSION: () => SDK_CORE_VERSION,
+  SDK_CORE_INTEGRITY: () => SDK_CORE_INTEGRITY
+});
+import { createHash } from "crypto";
+import { copyFileSync, existsSync as existsSync2, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { createRequire } from "module";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2 } from "path";
+import { gunzipSync } from "zlib";
+function tarballUrl() {
+  return `https://registry.npmjs.org/@1password/sdk-core/-/sdk-core-${SDK_CORE_VERSION}.tgz`;
+}
+function cacheWasmPath() {
+  return join2(homedir2(), ".claudish", "cache", "1password", WASM_FILENAME);
+}
+function verifyIntegrity(bytes) {
+  const [algo, expected] = SDK_CORE_INTEGRITY.split("-", 2);
+  const actual = createHash(algo).update(bytes).digest("base64");
+  if (actual !== expected) {
+    throw new Error(`1Password runtime integrity check failed (${algo}): expected ${expected}, got ${actual}`);
+  }
+}
+function extractFileFromTarGz(tgz, entrySuffix) {
+  const tar = gunzipSync(tgz);
+  let off = 0;
+  while (off + 512 <= tar.length) {
+    const header = tar.subarray(off, off + 512);
+    const name = header.subarray(0, 100).toString("utf8").replace(/\0.*$/, "");
+    if (name === "")
+      break;
+    const sizeStr = header.subarray(124, 136).toString("utf8").replace(/\0.*$/, "").trim();
+    const size = Number.parseInt(sizeStr, 8) || 0;
+    const dataStart = off + 512;
+    if (name.endsWith(entrySuffix)) {
+      return tar.subarray(dataStart, dataStart + size);
+    }
+    off = dataStart + Math.ceil(size / 512) * 512;
+  }
+  return null;
+}
+function installReadFileSyncIntercept() {
+  if (interceptInstalled)
+    return;
+  const require2 = createRequire(import.meta.url);
+  const fs = require2("node:fs");
+  const original = fs.readFileSync;
+  fs.readFileSync = (path, ...rest) => {
+    if (typeof path === "string" && path.endsWith(WASM_FILENAME)) {
+      const cached = cacheWasmPath();
+      if (existsSync2(cached)) {
+        return original(cached);
+      }
+      if (existsSync2(path)) {
+        try {
+          mkdirSync(dirname(cached), { recursive: true });
+          copyFileSync(path, cached);
+        } catch {}
+      }
+    }
+    return original(path, ...rest);
+  };
+  interceptInstalled = true;
+}
+async function downloadAndCacheWasm() {
+  const cached = cacheWasmPath();
+  process.stderr.write(`[claudish] fetching 1Password runtime (~10MB, one time)\u2026
+`);
+  const res = await fetch(tarballUrl());
+  if (!res.ok) {
+    throw new Error(`download failed: HTTP ${res.status} ${res.statusText} for ${tarballUrl()}`);
+  }
+  const tgz = Buffer.from(await res.arrayBuffer());
+  verifyIntegrity(tgz);
+  const wasm = extractFileFromTarGz(tgz, WASM_TARBALL_ENTRY);
+  if (!wasm) {
+    throw new Error(`1Password runtime archive did not contain ${WASM_TARBALL_ENTRY}`);
+  }
+  mkdirSync(dirname(cached), { recursive: true });
+  const tmp = `${cached}.tmp`;
+  writeFileSync2(tmp, wasm);
+  createRequire(import.meta.url)("node:fs").renameSync(tmp, cached);
+  process.stderr.write(`[claudish] 1Password runtime cached.
+`);
+}
+function ensureOpWasmAvailable() {
+  if (wasmReady)
+    return Promise.resolve();
+  if (ensured)
+    return ensured;
+  ensured = (async () => {
+    installReadFileSyncIntercept();
+    if (existsSync2(cacheWasmPath()))
+      return;
+    if (findRealWasmNearby())
+      return;
+    await downloadAndCacheWasm();
+  })();
+  ensured.then(() => {
+    wasmReady = true;
+  }, () => {
+    ensured = null;
+  });
+  return ensured;
+}
+function findRealWasmNearby() {
+  try {
+    const require2 = createRequire(import.meta.url);
+    const coreJs = require2.resolve("@1password/sdk-core/nodejs/core.js");
+    return existsSync2(join2(dirname(coreJs), WASM_FILENAME));
+  } catch {
+    return false;
+  }
+}
+function __resetOpWasmStateForTest() {
+  ensured = null;
+  interceptInstalled = false;
+  wasmReady = false;
+}
+var SDK_CORE_VERSION = "0.4.1-beta.1", SDK_CORE_INTEGRITY = "sha512-/otbg1JVhsEn6oUIeReoT9TmFr8J7KBwr9UuRVfJFwwGG3bHPF8ewT+LhRimQeJtypqQ69ZVuOYkxknD4iQHxw==", WASM_FILENAME = "core_bg.wasm", WASM_TARBALL_ENTRY = "nodejs/core_bg.wasm", interceptInstalled = false, ensured = null, wasmReady = false;
+var init_onepassword_wasm = () => {};
 
 // ../../node_modules/.bun/@1password+sdk-core@0.4.1-beta.1/node_modules/@1password/sdk-core/nodejs/core.js
 var require_core = __commonJS((exports, module) => {
@@ -3381,6 +3509,8 @@ var OP_REF_RE, ENV_VAR_NAME_RE, sdkClientCache, defaultSdkClientFactory = async
   if (cached)
     return cached;
   const build = (async () => {
+    const { ensureOpWasmAvailable: ensureOpWasmAvailable2 } = await Promise.resolve().then(() => (init_onepassword_wasm(), exports_onepassword_wasm));
+    await ensureOpWasmAvailable2();
     const { createClient, DesktopAuth } = await Promise.resolve().then(() => __toESM(require_sdk(), 1));
     const client = await createClient({
       auth: auth.kind === "token" ? auth.token : new DesktopAuth(auth.accountName),
@@ -25488,14 +25618,14 @@ __export(exports_team_orchestrator, {
 });
 import { spawn } from "child_process";
 import {
-  mkdirSync,
-  writeFileSync as writeFileSync2,
+  mkdirSync as mkdirSync2,
+  writeFileSync as writeFileSync3,
   readFileSync as readFileSync2,
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   readdirSync,
   createWriteStream
 } from "fs";
-import { join as join2, resolve } from "path";
+import { join as join3, resolve } from "path";
 function validateSessionPath(sessionPath) {
   const resolved = resolve(sessionPath);
   const cwd = process.cwd();
@@ -25516,18 +25646,18 @@ function setupSession(sessionPath, models, input) {
   if (models.length === 0) {
     throw new Error("At least one model is required");
   }
-  if (existsSync2(join2(sessionPath, "manifest.json"))) {
+  if (existsSync3(join3(sessionPath, "manifest.json"))) {
     throw new Error(`Session already exists at ${sessionPath}. ` + `Use a new directory path or delete the existing session first.`);
   }
   const sentinels = models.filter(isSentinelModel);
   if (sentinels.length > 0) {
     throw new Error(`Invalid model(s) for team run: ${sentinels.join(", ")}. ` + `These are Claude Code agent selectors, not external model IDs. ` + `Use real external models (e.g., "gemini-2.0-flash", "gpt-4o", "or@deepseek/deepseek-r1"). ` + `For Claude models, use a Task agent instead of the team tool.`);
   }
-  mkdirSync(join2(sessionPath, "work"), { recursive: true });
-  mkdirSync(join2(sessionPath, "errors"), { recursive: true });
+  mkdirSync2(join3(sessionPath, "work"), { recursive: true });
+  mkdirSync2(join3(sessionPath, "errors"), { recursive: true });
   if (input !== undefined) {
-    writeFileSync2(join2(sessionPath, "input.md"), input, "utf-8");
-  } else if (!existsSync2(join2(sessionPath, "input.md"))) {
+    writeFileSync3(join3(sessionPath, "input.md"), input, "utf-8");
+  } else if (!existsSync3(join3(sessionPath, "input.md"))) {
     throw new Error(`No input.md found at ${sessionPath} and no input provided`);
   }
   const ids = models.map((_, i) => String(i + 1).padStart(2, "0"));
@@ -25544,9 +25674,9 @@ function setupSession(sessionPath, models, input) {
       model: models[i],
       assignedAt: now
     };
-    mkdirSync(join2(sessionPath, "work", anonId), { recursive: true });
+    mkdirSync2(join3(sessionPath, "work", anonId), { recursive: true });
   }
-  writeFileSync2(join2(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+  writeFileSync3(join3(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
   const status = {
     startedAt: now,
     models: Object.fromEntries(Object.keys(manifest.models).map((id) => [
@@ -25560,19 +25690,19 @@ function setupSession(sessionPath, models, input) {
       }
     ]))
   };
-  writeFileSync2(join2(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
+  writeFileSync3(join3(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
   return manifest;
 }
 async function runModels(sessionPath, opts = {}) {
   const timeoutMs = (opts.timeout ?? 300) * 1000;
-  const manifest = JSON.parse(readFileSync2(join2(sessionPath, "manifest.json"), "utf-8"));
-  const statusPath = join2(sessionPath, "status.json");
-  const inputPath = join2(sessionPath, "input.md");
+  const manifest = JSON.parse(readFileSync2(join3(sessionPath, "manifest.json"), "utf-8"));
+  const statusPath = join3(sessionPath, "status.json");
+  const inputPath = join3(sessionPath, "input.md");
   const inputContent = readFileSync2(inputPath, "utf-8");
   const statusCache = JSON.parse(readFileSync2(statusPath, "utf-8"));
   function updateModelStatus(id, update) {
     statusCache.models[id] = { ...statusCache.models[id], ...update };
-    writeFileSync2(statusPath, JSON.stringify(statusCache, null, 2), "utf-8");
+    writeFileSync3(statusPath, JSON.stringify(statusCache, null, 2), "utf-8");
   }
   const processes = new Map;
   const sigintHandler = () => {
@@ -25585,8 +25715,8 @@ async function runModels(sessionPath, opts = {}) {
   process.on("SIGINT", sigintHandler);
   const completionPromises = [];
   for (const [anonId, entry] of Object.entries(manifest.models)) {
-    const outputPath = join2(sessionPath, `response-${anonId}.md`);
-    const errorLogPath = join2(sessionPath, "errors", `${anonId}.log`);
+    const outputPath = join3(sessionPath, `response-${anonId}.md`);
+    const errorLogPath = join3(sessionPath, "errors", `${anonId}.log`);
     const args = ["--model", entry.model, "-y", "--stdin", "--quiet", ...opts.claudeFlags ?? []];
     updateModelStatus(anonId, {
       state: "RUNNING",
@@ -25639,7 +25769,7 @@ async function runModels(sessionPath, opts = {}) {
           return;
         }
         if (stderr) {
-          writeFileSync2(errorLogPath, stderr, "utf-8");
+          writeFileSync3(errorLogPath, stderr, "utf-8");
         }
         exitCode = code;
         if (outputStream.destroyed) {
@@ -25684,23 +25814,23 @@ async function judgeResponses(sessionPath, opts = {}) {
   const responses = {};
   for (const file2 of responseFiles) {
     const id = file2.replace(/^response-/, "").replace(/\.md$/, "");
-    responses[id] = readFileSync2(join2(sessionPath, file2), "utf-8");
+    responses[id] = readFileSync2(join3(sessionPath, file2), "utf-8");
   }
-  const input = readFileSync2(join2(sessionPath, "input.md"), "utf-8");
+  const input = readFileSync2(join3(sessionPath, "input.md"), "utf-8");
   const judgePrompt = buildJudgePrompt(input, responses);
-  writeFileSync2(join2(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
+  writeFileSync3(join3(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
   const judgeModels = opts.judges ?? getDefaultJudgeModels(sessionPath);
-  const judgePath = join2(sessionPath, "judging");
-  mkdirSync(judgePath, { recursive: true });
+  const judgePath = join3(sessionPath, "judging");
+  mkdirSync2(judgePath, { recursive: true });
   setupSession(judgePath, judgeModels, judgePrompt);
   await runModels(judgePath, { claudeFlags: opts.claudeFlags });
   const votes = parseJudgeVotes(judgePath, Object.keys(responses));
   const verdict = aggregateVerdict(votes, Object.keys(responses));
-  writeFileSync2(join2(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
+  writeFileSync3(join3(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
   return verdict;
 }
 function getStatus(sessionPath) {
-  return JSON.parse(readFileSync2(join2(sessionPath, "status.json"), "utf-8"));
+  return JSON.parse(readFileSync2(join3(sessionPath, "status.json"), "utf-8"));
 }
 function fisherYatesShuffle(arr) {
   for (let i = arr.length - 1;i > 0; i--) {
@@ -25710,7 +25840,7 @@ function fisherYatesShuffle(arr) {
   return arr;
 }
 function getDefaultJudgeModels(sessionPath) {
-  const manifest = JSON.parse(readFileSync2(join2(sessionPath, "manifest.json"), "utf-8"));
+  const manifest = JSON.parse(readFileSync2(join3(sessionPath, "manifest.json"), "utf-8"));
   return Object.values(manifest.models).map((e) => e.model);
 }
 function buildJudgePrompt(input, responses) {
@@ -25773,7 +25903,7 @@ function parseJudgeVotes(judgePath, responseIds) {
     const judgeId = file2.replace(/^response-/, "").replace(/\.md$/, "");
     let content;
     try {
-      content = readFileSync2(join2(judgePath, file2), "utf-8");
+      content = readFileSync2(join3(judgePath, file2), "utf-8");
     } catch {
       continue;
     }
@@ -25825,7 +25955,7 @@ function aggregateVerdict(votes, responseIds) {
 function formatVerdict(verdict, sessionPath) {
   let manifest = null;
   try {
-    manifest = JSON.parse(readFileSync2(join2(sessionPath, "manifest.json"), "utf-8"));
+    manifest = JSON.parse(readFileSync2(join3(sessionPath, "manifest.json"), "utf-8"));
   } catch {}
   let output = `# Team Verdict
 
@@ -26058,9 +26188,9 @@ var init_signal_watcher = __esm(() => {
 
 // src/channel/session-manager.ts
 import { spawn as spawn2 } from "child_process";
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3, createWriteStream as createWriteStream2 } from "fs";
-import { join as join3 } from "path";
-import { homedir as homedir2 } from "os";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4, createWriteStream as createWriteStream2 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
 import { randomUUID } from "crypto";
 
 class SessionManager {
@@ -26081,10 +26211,10 @@ class SessionManager {
     const sessionId = randomUUID().slice(0, 8);
     const timeout = Math.min(opts.timeoutSeconds ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
     const startedAt = new Date().toISOString();
-    const sessionDir = join3(homedir2(), ".claudish", "sessions", sessionId);
-    mkdirSync2(sessionDir, { recursive: true });
+    const sessionDir = join4(homedir3(), ".claudish", "sessions", sessionId);
+    mkdirSync3(sessionDir, { recursive: true });
     if (opts.prompt) {
-      writeFileSync3(join3(sessionDir, "prompt.md"), opts.prompt, "utf-8");
+      writeFileSync4(join4(sessionDir, "prompt.md"), opts.prompt, "utf-8");
     }
     const args = ["--model", opts.model, "-y", "--stdin", "--quiet", ...opts.claudishFlags ?? []];
     const proc = spawn2("claudish", args, {
@@ -26111,7 +26241,7 @@ class SessionManager {
         });
       }
     });
-    const outputLogStream = createWriteStream2(join3(sessionDir, "output.log"));
+    const outputLogStream = createWriteStream2(join4(sessionDir, "output.log"));
     const entry = {
       info: {
         sessionId,
@@ -26158,9 +26288,9 @@ class SessionManager {
       watcher.processExited(code);
       outputLogStream.end();
       if (entry.stderr) {
-        writeFileSync3(join3(sessionDir, "stderr.log"), entry.stderr, "utf-8");
+        writeFileSync4(join4(sessionDir, "stderr.log"), entry.stderr, "utf-8");
       }
-      writeFileSync3(join3(sessionDir, "meta.json"), JSON.stringify(entry.info, null, 2), "utf-8");
+      writeFileSync4(join4(sessionDir, "meta.json"), JSON.stringify(entry.info, null, 2), "utf-8");
       this.cleanupSigint();
     });
     proc.on("error", (err) => {
@@ -28605,9 +28735,9 @@ __export(exports_logger, {
   getLogFilePath: () => getLogFilePath,
   getAlwaysOnLogPath: () => getAlwaysOnLogPath
 });
-import { writeFileSync as writeFileSync4, appendFile, existsSync as existsSync3, mkdirSync as mkdirSync3, readdirSync as readdirSync2, unlinkSync } from "fs";
-import { join as join4 } from "path";
-import { homedir as homedir3 } from "os";
+import { writeFileSync as writeFileSync5, appendFile, existsSync as existsSync4, mkdirSync as mkdirSync4, readdirSync as readdirSync2, unlinkSync } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
 function flushLogBuffer() {
   if (!logFilePath || logBuffer.length === 0)
     return;
@@ -28639,11 +28769,11 @@ function scheduleFlush() {
       flushTimer = null;
     }
     if (logFilePath && logBuffer.length > 0) {
-      writeFileSync4(logFilePath, logBuffer.join(""), { flag: "a" });
+      writeFileSync5(logFilePath, logBuffer.join(""), { flag: "a" });
       logBuffer = [];
     }
     if (alwaysOnLogPath && alwaysOnBuffer.length > 0) {
-      writeFileSync4(alwaysOnLogPath, alwaysOnBuffer.join(""), { flag: "a" });
+      writeFileSync5(alwaysOnLogPath, alwaysOnBuffer.join(""), { flag: "a" });
       alwaysOnBuffer = [];
     }
   });
@@ -28653,7 +28783,7 @@ function rotateOldLogs(dir, keep) {
     const files = readdirSync2(dir).filter((f) => f.startsWith("claudish_") && f.endsWith(".log")).sort().reverse();
     for (const file2 of files.slice(keep)) {
       try {
-        unlinkSync(join4(dir, file2));
+        unlinkSync(join5(dir, file2));
       } catch {}
     }
   } catch {}
@@ -28704,13 +28834,13 @@ function redactLogLine(message, timestamp) {
 }
 function initLogger(debugMode, level = "info", noLogs = false) {
   if (!noLogs) {
-    const logsDir = join4(homedir3(), ".claudish", "logs");
-    if (!existsSync3(logsDir)) {
-      mkdirSync3(logsDir, { recursive: true });
+    const logsDir = join5(homedir4(), ".claudish", "logs");
+    if (!existsSync4(logsDir)) {
+      mkdirSync4(logsDir, { recursive: true });
     }
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-").split("T").join("_").slice(0, -5);
-    alwaysOnLogPath = join4(logsDir, `claudish_${timestamp}.log`);
-    writeFileSync4(alwaysOnLogPath, `Claudish Session Log - ${new Date().toISOString()}
+    alwaysOnLogPath = join5(logsDir, `claudish_${timestamp}.log`);
+    writeFileSync5(alwaysOnLogPath, `Claudish Session Log - ${new Date().toISOString()}
 Mode: structural (content redacted)
 ${"=".repeat(60)}
 
@@ -28720,13 +28850,13 @@ ${"=".repeat(60)}
   }
   if (debugMode) {
     logLevel = level;
-    const logsDir = join4(process.cwd(), "logs");
-    if (!existsSync3(logsDir)) {
-      mkdirSync3(logsDir, { recursive: true });
+    const logsDir = join5(process.cwd(), "logs");
+    if (!existsSync4(logsDir)) {
+      mkdirSync4(logsDir, { recursive: true });
     }
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-").split("T").join("_").slice(0, -5);
-    logFilePath = join4(logsDir, `claudish_${timestamp}.log`);
-    writeFileSync4(logFilePath, `Claudish Debug Log - ${new Date().toISOString()}
+    logFilePath = join5(logsDir, `claudish_${timestamp}.log`);
+    writeFileSync5(logFilePath, `Claudish Debug Log - ${new Date().toISOString()}
 Log Level: ${level}
 ${"=".repeat(80)}
 
@@ -28937,17 +29067,17 @@ __export(exports_profile_config, {
   configExistsForScope: () => configExistsForScope,
   configExists: () => configExists
 });
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir4 } from "os";
-import { dirname, join as join5, parse as parse6 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync6 } from "fs";
+import { homedir as homedir5 } from "os";
+import { dirname as dirname2, join as join6, parse as parse6 } from "path";
 function ensureConfigDir() {
-  if (!existsSync4(CONFIG_DIR)) {
-    mkdirSync4(CONFIG_DIR, { recursive: true });
+  if (!existsSync5(CONFIG_DIR)) {
+    mkdirSync5(CONFIG_DIR, { recursive: true });
   }
 }
 function loadConfig() {
   ensureConfigDir();
-  if (!existsSync4(CONFIG_FILE)) {
+  if (!existsSync5(CONFIG_FILE)) {
     return { ...DEFAULT_CONFIG };
   }
   try {
@@ -29002,39 +29132,39 @@ function loadConfig() {
 }
 function saveConfig(config2) {
   ensureConfigDir();
-  writeFileSync5(CONFIG_FILE, JSON.stringify(config2, null, 2), "utf-8");
+  writeFileSync6(CONFIG_FILE, JSON.stringify(config2, null, 2), "utf-8");
 }
 function configExists() {
-  return existsSync4(CONFIG_FILE);
+  return existsSync5(CONFIG_FILE);
 }
 function getConfigPath() {
   return CONFIG_FILE;
 }
 function getLocalConfigPath() {
-  const home = homedir4();
+  const home = homedir5();
   let dir = process.cwd();
   const root = parse6(dir).root;
   while (dir !== root && dir !== home) {
-    const candidate = join5(dir, LOCAL_CONFIG_FILENAME);
-    if (existsSync4(candidate))
+    const candidate = join6(dir, LOCAL_CONFIG_FILENAME);
+    if (existsSync5(candidate))
       return candidate;
-    if (existsSync4(join5(dir, ".git"))) {
+    if (existsSync5(join6(dir, ".git"))) {
       return candidate;
     }
-    dir = dirname(dir);
+    dir = dirname2(dir);
   }
-  return join5(process.cwd(), LOCAL_CONFIG_FILENAME);
+  return join6(process.cwd(), LOCAL_CONFIG_FILENAME);
 }
 function localConfigExists() {
-  return existsSync4(getLocalConfigPath());
+  return existsSync5(getLocalConfigPath());
 }
 function isProjectDirectory() {
   const cwd = process.cwd();
-  return [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", ".claudish.json"].some((f) => existsSync4(join5(cwd, f)));
+  return [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", ".claudish.json"].some((f) => existsSync5(join6(cwd, f)));
 }
 function loadLocalConfig() {
   const localPath = getLocalConfigPath();
-  if (!existsSync4(localPath)) {
+  if (!existsSync5(localPath)) {
     return null;
   }
   try {
@@ -29056,7 +29186,7 @@ function saveLocalConfig(config2) {
   if (toWrite.routing !== undefined && Object.keys(toWrite.routing).length === 0) {
     delete toWrite.routing;
   }
-  writeFileSync5(getLocalConfigPath(), JSON.stringify(toWrite, null, 2), "utf-8");
+  writeFileSync6(getLocalConfigPath(), JSON.stringify(toWrite, null, 2), "utf-8");
 }
 function loadConfigForScope(scope) {
   if (scope === "local") {
@@ -29297,8 +29427,8 @@ function disableLocalProvider(providerName) {
 }
 var CONFIG_DIR, CONFIG_FILE, LOCAL_CONFIG_FILENAME = ".claudish.json", DEFAULT_CONFIG;
 var init_profile_config = __esm(() => {
-  CONFIG_DIR = join5(homedir4(), ".claudish");
-  CONFIG_FILE = join5(CONFIG_DIR, "config.json");
+  CONFIG_DIR = join6(homedir5(), ".claudish");
+  CONFIG_FILE = join6(CONFIG_DIR, "config.json");
   DEFAULT_CONFIG = {
     version: "1.0.0",
     defaultProfile: "default",
@@ -29315,9 +29445,9 @@ var init_profile_config = __esm(() => {
 });
 
 // src/providers/provider-definitions.ts
-import { existsSync as existsSync5 } from "fs";
-import { join as join6 } from "path";
-import { homedir as homedir5 } from "os";
+import { existsSync as existsSync6 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir6 } from "os";
 function ensureProviderByNameCache() {
   if (!_providerByNameCache) {
     _providerByNameCache = new Map;
@@ -29472,7 +29602,7 @@ function isProviderAvailable(def) {
   }
   if (def.oauthFallback) {
     try {
-      if (existsSync5(join6(homedir5(), ".claudish", def.oauthFallback)))
+      if (existsSync6(join7(homedir6(), ".claudish", def.oauthFallback)))
         return true;
     } catch {}
   }
@@ -30100,11 +30230,11 @@ var init_model_parser = __esm(() => {
 });
 
 // src/providers/all-models-cache.ts
-import { readFileSync as readFileSync4, existsSync as existsSync6, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5 } from "fs";
-import { join as join7, dirname as dirname2 } from "path";
-import { homedir as homedir6 } from "os";
+import { readFileSync as readFileSync4, existsSync as existsSync7, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6 } from "fs";
+import { join as join8, dirname as dirname3 } from "path";
+import { homedir as homedir7 } from "os";
 function readAllModelsCache(path = ALL_MODELS_CACHE_PATH) {
-  if (!existsSync6(path))
+  if (!existsSync7(path))
     return null;
   let raw2;
   try {
@@ -30133,12 +30263,12 @@ function writeAllModelsCache(data, path = ALL_MODELS_CACHE_PATH) {
     entries: data.entries ?? existing?.entries ?? [],
     models: data.models ?? existing?.models ?? []
   };
-  mkdirSync5(dirname2(path), { recursive: true });
-  writeFileSync6(path, JSON.stringify(merged), "utf-8");
+  mkdirSync6(dirname3(path), { recursive: true });
+  writeFileSync7(path, JSON.stringify(merged), "utf-8");
 }
 var ALL_MODELS_CACHE_PATH;
 var init_all_models_cache = __esm(() => {
-  ALL_MODELS_CACHE_PATH = join7(homedir6(), ".claudish", "all-models.json");
+  ALL_MODELS_CACHE_PATH = join8(homedir7(), ".claudish", "all-models.json");
 });
 
 // src/providers/catalog-resolvers/openrouter.ts
@@ -35013,9 +35143,9 @@ var init_middleware = __esm(() => {
 });
 
 // src/handlers/shared/token-tracker.ts
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync7 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join8 } from "path";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync8 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join9 } from "path";
 
 class TokenTracker {
   port;
@@ -35149,9 +35279,9 @@ class TokenTracker {
       if (this.quotaRemaining !== undefined) {
         data.quota_remaining = this.quotaRemaining;
       }
-      const claudishDir = join8(homedir7(), ".claudish");
-      mkdirSync6(claudishDir, { recursive: true });
-      writeFileSync7(join8(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
+      const claudishDir = join9(homedir8(), ".claudish");
+      mkdirSync7(claudishDir, { recursive: true });
+      writeFileSync8(join9(claudishDir, `tokens-${this.port}.json`), JSON.stringify(data), "utf-8");
     } catch (e) {
       log(`[TokenTracker] Error writing token file: ${e}`);
     }
@@ -36620,23 +36750,23 @@ var init_telemetry = __esm(() => {
 
 // src/stats-buffer.ts
 import {
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync7,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync8,
   readFileSync as readFileSync5,
   renameSync,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync9
 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join9 } from "path";
+import { homedir as homedir9 } from "os";
+import { join as join10 } from "path";
 function ensureDir() {
-  if (!existsSync7(CLAUDISH_DIR)) {
-    mkdirSync7(CLAUDISH_DIR, { recursive: true });
+  if (!existsSync8(CLAUDISH_DIR)) {
+    mkdirSync8(CLAUDISH_DIR, { recursive: true });
   }
 }
 function readFromDisk() {
   try {
-    if (!existsSync7(BUFFER_FILE))
+    if (!existsSync8(BUFFER_FILE))
       return [];
     const raw2 = readFileSync5(BUFFER_FILE, "utf-8");
     const parsed = JSON.parse(raw2);
@@ -36662,8 +36792,8 @@ function writeToDisk(events) {
     ensureDir();
     const trimmed = enforceSizeCap([...events]);
     const payload = { version: 1, events: trimmed };
-    const tmpFile = join9(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
-    writeFileSync8(tmpFile, JSON.stringify(payload, null, 2), "utf-8");
+    const tmpFile = join10(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
+    writeFileSync9(tmpFile, JSON.stringify(payload, null, 2), "utf-8");
     renameSync(tmpFile, BUFFER_FILE);
     memoryCache = trimmed;
   } catch {}
@@ -36707,7 +36837,7 @@ function clearBuffer() {
   try {
     memoryCache = [];
     eventsSinceLastFlush = 0;
-    if (existsSync7(BUFFER_FILE)) {
+    if (existsSync8(BUFFER_FILE)) {
       unlinkSync2(BUFFER_FILE);
     }
   } catch {}
@@ -36736,8 +36866,8 @@ function syncFlushOnExit() {
 var BUFFER_MAX_BYTES, CLAUDISH_DIR, BUFFER_FILE, memoryCache = null, eventsSinceLastFlush = 0, lastFlushTime, flushScheduled = false;
 var init_stats_buffer = __esm(() => {
   BUFFER_MAX_BYTES = 64 * 1024;
-  CLAUDISH_DIR = join9(homedir8(), ".claudish");
-  BUFFER_FILE = join9(CLAUDISH_DIR, "stats-buffer.json");
+  CLAUDISH_DIR = join10(homedir9(), ".claudish");
+  BUFFER_FILE = join10(CLAUDISH_DIR, "stats-buffer.json");
   lastFlushTime = Date.now();
   process.on("exit", syncFlushOnExit);
   process.on("SIGTERM", () => {
@@ -38014,9 +38144,9 @@ __export(exports_provider_resolver, {
   getMissingKeyResolutions: () => getMissingKeyResolutions,
   getMissingKeyError: () => getMissingKeyError
 });
-import { existsSync as existsSync8 } from "fs";
-import { homedir as homedir9 } from "os";
-import { join as join10 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { homedir as homedir10 } from "os";
+import { join as join11 } from "path";
 function getApiKeyInfoForProvider(providerName) {
   const lookupName = providerName === "gemini" ? "google" : providerName;
   const info = getApiKeyInfo(lookupName);
@@ -38051,8 +38181,8 @@ function isApiKeyAvailable(info) {
   }
   if (info.oauthFallback) {
     try {
-      const credPath = join10(homedir9(), ".claudish", info.oauthFallback);
-      if (existsSync8(credPath)) {
+      const credPath = join11(homedir10(), ".claudish", info.oauthFallback);
+      if (existsSync9(credPath)) {
         return true;
       }
     } catch {}
@@ -38315,9 +38445,9 @@ var init_provider_resolver = __esm(() => {
 });
 
 // src/services/pricing-cache.ts
-import { readFileSync as readFileSync6, existsSync as existsSync9, statSync as statSync2 } from "fs";
-import { homedir as homedir10 } from "os";
-import { join as join11 } from "path";
+import { readFileSync as readFileSync6, existsSync as existsSync10, statSync as statSync2 } from "fs";
+import { homedir as homedir11 } from "os";
+import { join as join12 } from "path";
 function prefixMatch(modelName) {
   for (const [key, pricing] of pricingMap) {
     if (modelName.startsWith(key))
@@ -38355,7 +38485,7 @@ async function warmPricingCache() {
 }
 function loadDiskCache() {
   try {
-    if (!existsSync9(CACHE_FILE))
+    if (!existsSync10(CACHE_FILE))
       return false;
     const stat = statSync2(CACHE_FILE);
     const age = Date.now() - stat.mtimeMs;
@@ -38376,8 +38506,8 @@ var init_pricing_cache = __esm(() => {
   init_remote_provider_types();
   init_catalog_query();
   pricingMap = new Map;
-  CACHE_DIR = join11(homedir10(), ".claudish");
-  CACHE_FILE = join11(CACHE_DIR, "pricing-cache.json");
+  CACHE_DIR = join12(homedir11(), ".claudish");
+  CACHE_FILE = join12(CACHE_DIR, "pricing-cache.json");
   CACHE_TTL_MS2 = 24 * 60 * 60 * 1000;
 });
 
@@ -38388,9 +38518,9 @@ var init_cache_ttl = __esm(() => {
 });
 
 // src/model-loader.ts
-import { readFileSync as readFileSync7, existsSync as existsSync10, writeFileSync as writeFileSync9, mkdirSync as mkdirSync8 } from "fs";
-import { join as join12 } from "path";
-import { homedir as homedir11 } from "os";
+import { readFileSync as readFileSync7, existsSync as existsSync11, writeFileSync as writeFileSync10, mkdirSync as mkdirSync9 } from "fs";
+import { join as join13 } from "path";
+import { homedir as homedir12 } from "os";
 function groupRecommendedModels(entries) {
   const byId = new Map;
   for (const entry of entries) {
@@ -38486,7 +38616,7 @@ async function getRecommendedModels(opts = {}) {
   if (!forceRefresh && _cachedRecommendedModels) {
     return _cachedRecommendedModels;
   }
-  if (!forceRefresh && existsSync10(RECOMMENDED_MODELS_CACHE_PATH)) {
+  if (!forceRefresh && existsSync11(RECOMMENDED_MODELS_CACHE_PATH)) {
     try {
       const cacheData = JSON.parse(readFileSync7(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
       if (cacheData.models && cacheData.models.length > 0 && isFreshEnough(cacheData)) {
@@ -38504,9 +38634,9 @@ async function getRecommendedModels(opts = {}) {
       if (data.models && data.models.length > 0) {
         _cachedRecommendedModels = data;
         try {
-          const cacheDir = join12(homedir11(), ".claudish");
-          mkdirSync8(cacheDir, { recursive: true });
-          writeFileSync9(RECOMMENDED_MODELS_CACHE_PATH, JSON.stringify(data), "utf-8");
+          const cacheDir = join13(homedir12(), ".claudish");
+          mkdirSync9(cacheDir, { recursive: true });
+          writeFileSync10(RECOMMENDED_MODELS_CACHE_PATH, JSON.stringify(data), "utf-8");
         } catch {}
         return data;
       }
@@ -38517,7 +38647,7 @@ async function getRecommendedModels(opts = {}) {
 function getRecommendedModelsSync() {
   if (_cachedRecommendedModels)
     return _cachedRecommendedModels;
-  if (existsSync10(RECOMMENDED_MODELS_CACHE_PATH)) {
+  if (existsSync11(RECOMMENDED_MODELS_CACHE_PATH)) {
     try {
       const cacheData = JSON.parse(readFileSync7(RECOMMENDED_MODELS_CACHE_PATH, "utf-8"));
       if (cacheData.models && cacheData.models.length > 0 && isFreshEnough(cacheData)) {
@@ -38643,7 +38773,7 @@ var _cachedModelInfo = null, _cachedModelIds = null, _cachedRecommendedModels =
 var init_model_loader = __esm(() => {
   init_cache_ttl();
   FIREBASE_RECOMMENDED_URL = `${FIREBASE_BASE_URL}?catalog=recommended`;
-  RECOMMENDED_MODELS_CACHE_PATH = join12(homedir11(), ".claudish", "recommended-models-cache.json");
+  RECOMMENDED_MODELS_CACHE_PATH = join13(homedir12(), ".claudish", "recommended-models-cache.json");
   FIREBASE_SLUG_TO_PROVIDER_NAME = {
     openai: "openai",
     google: "google",
@@ -38780,12 +38910,12 @@ var init_fallback_handler = __esm(() => {
 });
 
 // src/auth/oauth-registry.ts
-import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
-import { join as join13 } from "path";
-import { homedir as homedir12 } from "os";
+import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
+import { join as join14 } from "path";
+import { homedir as homedir13 } from "os";
 function hasValidOAuthCredentials(descriptor) {
-  const credPath = join13(homedir12(), ".claudish", descriptor.credentialFile);
-  if (!existsSync11(credPath))
+  const credPath = join14(homedir13(), ".claudish", descriptor.credentialFile);
+  if (!existsSync12(credPath))
     return false;
   if (descriptor.validationMode === "file-exists") {
     return true;
@@ -39263,10 +39393,10 @@ var init_gemini_apikey = __esm(() => {
 
 // src/auth/gemini-oauth.ts
 import { createServer } from "http";
-import { randomBytes as randomBytes2, createHash } from "crypto";
-import { readFileSync as readFileSync9, existsSync as existsSync12, unlinkSync as unlinkSync3, openSync, writeSync, closeSync } from "fs";
-import { homedir as homedir13 } from "os";
-import { join as join14 } from "path";
+import { randomBytes as randomBytes2, createHash as createHash2 } from "crypto";
+import { readFileSync as readFileSync9, existsSync as existsSync13, unlinkSync as unlinkSync3, openSync, writeSync, closeSync } from "fs";
+import { homedir as homedir14 } from "os";
+import { join as join15 } from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
 
@@ -39289,8 +39419,8 @@ class GeminiOAuth {
     return this.credentials !== null && !!this.credentials.refresh_token;
   }
   getCredentialsPath() {
-    const claudishDir = join14(homedir13(), ".claudish");
-    return join14(claudishDir, "gemini-oauth.json");
+    const claudishDir = join15(homedir14(), ".claudish");
+    return join15(claudishDir, "gemini-oauth.json");
   }
   async login() {
     log("[GeminiOAuth] Starting OAuth login flow");
@@ -39311,7 +39441,7 @@ class GeminiOAuth {
   }
   async logout() {
     const credPath = this.getCredentialsPath();
-    if (existsSync12(credPath)) {
+    if (existsSync13(credPath)) {
       unlinkSync3(credPath);
       log("[GeminiOAuth] Credentials deleted");
     }
@@ -39388,7 +39518,7 @@ Details: ${e.message}`);
   }
   loadCredentials() {
     const credPath = this.getCredentialsPath();
-    if (!existsSync12(credPath)) {
+    if (!existsSync13(credPath)) {
       return null;
     }
     try {
@@ -39407,10 +39537,10 @@ Details: ${e.message}`);
   }
   saveCredentials(credentials) {
     const credPath = this.getCredentialsPath();
-    const claudishDir = join14(homedir13(), ".claudish");
-    if (!existsSync12(claudishDir)) {
-      const { mkdirSync: mkdirSync9 } = __require("fs");
-      mkdirSync9(claudishDir, { recursive: true });
+    const claudishDir = join15(homedir14(), ".claudish");
+    if (!existsSync13(claudishDir)) {
+      const { mkdirSync: mkdirSync10 } = __require("fs");
+      mkdirSync10(claudishDir, { recursive: true });
     }
     const fd = openSync(credPath, "w", 384);
     try {
@@ -39425,7 +39555,7 @@ Details: ${e.message}`);
     return randomBytes2(64).toString("base64url");
   }
   async generateCodeChallenge(verifier) {
-    const hash2 = createHash("sha256").update(verifier).digest("base64url");
+    const hash2 = createHash2("sha256").update(verifier).digest("base64url");
     return hash2;
   }
   buildAuthUrl(codeChallenge, state, redirectUri) {
@@ -40115,11 +40245,11 @@ var init_openai = __esm(() => {
 
 // src/auth/codex-oauth.ts
 import { exec as exec2 } from "child_process";
-import { createHash as createHash2, randomBytes as randomBytes3 } from "crypto";
-import { closeSync as closeSync2, existsSync as existsSync13, openSync as openSync2, readFileSync as readFileSync10, unlinkSync as unlinkSync4, writeSync as writeSync2 } from "fs";
+import { createHash as createHash3, randomBytes as randomBytes3 } from "crypto";
+import { closeSync as closeSync2, existsSync as existsSync14, openSync as openSync2, readFileSync as readFileSync10, unlinkSync as unlinkSync4, writeSync as writeSync2 } from "fs";
 import { createServer as createServer2 } from "http";
-import { homedir as homedir14 } from "os";
-import { join as join15 } from "path";
+import { homedir as homedir15 } from "os";
+import { join as join16 } from "path";
 import { promisify as promisify2 } from "util";
 
 class CodexOAuth {
@@ -40141,8 +40271,8 @@ class CodexOAuth {
     return this.credentials !== null && !!this.credentials.refresh_token;
   }
   getCredentialsPath() {
-    const claudishDir = join15(homedir14(), ".claudish");
-    return join15(claudishDir, "codex-oauth.json");
+    const claudishDir = join16(homedir15(), ".claudish");
+    return join16(claudishDir, "codex-oauth.json");
   }
   async login() {
     log("[CodexOAuth] Starting OAuth login flow");
@@ -40168,7 +40298,7 @@ class CodexOAuth {
   }
   async logout() {
     const credPath = this.getCredentialsPath();
-    if (existsSync13(credPath)) {
+    if (existsSync14(credPath)) {
       unlinkSync4(credPath);
       log("[CodexOAuth] Credentials deleted");
     }
@@ -40246,7 +40376,7 @@ Details: ${e.message}`);
   }
   loadCredentials() {
     const credPath = this.getCredentialsPath();
-    if (!existsSync13(credPath)) {
+    if (!existsSync14(credPath)) {
       return null;
     }
     try {
@@ -40265,10 +40395,10 @@ Details: ${e.message}`);
   }
   saveCredentials(credentials) {
     const credPath = this.getCredentialsPath();
-    const claudishDir = join15(homedir14(), ".claudish");
-    if (!existsSync13(claudishDir)) {
-      const { mkdirSync: mkdirSync9 } = __require("fs");
-      mkdirSync9(claudishDir, { recursive: true });
+    const claudishDir = join16(homedir15(), ".claudish");
+    if (!existsSync14(claudishDir)) {
+      const { mkdirSync: mkdirSync10 } = __require("fs");
+      mkdirSync10(claudishDir, { recursive: true });
     }
     const fd = openSync2(credPath, "w", 384);
     try {
@@ -40283,7 +40413,7 @@ Details: ${e.message}`);
     return randomBytes3(64).toString("base64url");
   }
   async generateCodeChallenge(verifier) {
-    const hash2 = createHash2("sha256").update(verifier).digest("base64url");
+    const hash2 = createHash3("sha256").update(verifier).digest("base64url");
     return hash2;
   }
   extractAccountId(idToken) {
@@ -40481,9 +40611,9 @@ var init_codex_oauth = __esm(() => {
 });
 
 // src/providers/transport/openai-codex.ts
-import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
-import { homedir as homedir15 } from "os";
-import { join as join16 } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync11 } from "fs";
+import { homedir as homedir16 } from "os";
+import { join as join17 } from "path";
 function buildOAuthHeaders(token, accountId) {
   const headers = {
     Authorization: `Bearer ${token}`,
@@ -40512,8 +40642,8 @@ var init_openai_codex = __esm(() => {
       return super.getHeaders();
     }
     getEndpoint() {
-      const credPath = join16(homedir15(), ".claudish", "codex-oauth.json");
-      if (existsSync14(credPath)) {
+      const credPath = join17(homedir16(), ".claudish", "codex-oauth.json");
+      if (existsSync15(credPath)) {
         try {
           const creds = JSON.parse(readFileSync11(credPath, "utf-8"));
           if (creds.access_token && creds.refresh_token) {
@@ -40524,8 +40654,8 @@ var init_openai_codex = __esm(() => {
       return `${this.provider.baseUrl}${this.provider.apiPath}`;
     }
     async tryOAuthHeaders() {
-      const credPath = join16(homedir15(), ".claudish", "codex-oauth.json");
-      if (!existsSync14(credPath))
+      const credPath = join17(homedir16(), ".claudish", "codex-oauth.json");
+      if (!existsSync15(credPath))
         return null;
       try {
         const creds = JSON.parse(readFileSync11(credPath, "utf-8"));
@@ -40565,9 +40695,9 @@ var init_openai_codex = __esm(() => {
 
 // src/auth/kimi-oauth.ts
 import { randomBytes as randomBytes4 } from "crypto";
-import { readFileSync as readFileSync12, existsSync as existsSync15, unlinkSync as unlinkSync5, openSync as openSync3, writeSync as writeSync3, closeSync as closeSync3 } from "fs";
-import { homedir as homedir16, hostname as hostname3, platform, release } from "os";
-import { join as join17 } from "path";
+import { readFileSync as readFileSync12, existsSync as existsSync16, unlinkSync as unlinkSync5, openSync as openSync3, writeSync as writeSync3, closeSync as closeSync3 } from "fs";
+import { homedir as homedir17, hostname as hostname3, platform, release } from "os";
+import { join as join18 } from "path";
 import { exec as exec3 } from "child_process";
 import { promisify as promisify3 } from "util";
 
@@ -40592,21 +40722,21 @@ class KimiOAuth {
     return this.credentials !== null && !!this.credentials.refresh_token;
   }
   getCredentialsPath() {
-    const claudishDir = join17(homedir16(), ".claudish");
-    return join17(claudishDir, "kimi-oauth.json");
+    const claudishDir = join18(homedir17(), ".claudish");
+    return join18(claudishDir, "kimi-oauth.json");
   }
   getDeviceIdPath() {
-    const claudishDir = join17(homedir16(), ".claudish");
-    return join17(claudishDir, "kimi-device-id");
+    const claudishDir = join18(homedir17(), ".claudish");
+    return join18(claudishDir, "kimi-device-id");
   }
   loadOrCreateDeviceId() {
     const deviceIdPath = this.getDeviceIdPath();
-    const claudishDir = join17(homedir16(), ".claudish");
-    if (!existsSync15(claudishDir)) {
-      const { mkdirSync: mkdirSync9 } = __require("fs");
-      mkdirSync9(claudishDir, { recursive: true });
+    const claudishDir = join18(homedir17(), ".claudish");
+    if (!existsSync16(claudishDir)) {
+      const { mkdirSync: mkdirSync10 } = __require("fs");
+      mkdirSync10(claudishDir, { recursive: true });
     }
-    if (existsSync15(deviceIdPath)) {
+    if (existsSync16(deviceIdPath)) {
       try {
         const deviceId2 = readFileSync12(deviceIdPath, "utf-8").trim();
         if (deviceId2) {
@@ -40777,7 +40907,7 @@ Waiting for authorization...`);
   }
   async logout() {
     const credPath = this.getCredentialsPath();
-    if (existsSync15(credPath)) {
+    if (existsSync16(credPath)) {
       unlinkSync5(credPath);
       log("[KimiOAuth] Credentials deleted");
     }
@@ -40844,7 +40974,7 @@ Waiting for authorization...`);
     } catch (e) {
       log(`[KimiOAuth] Refresh failed: ${e.message}`);
       const credPath = this.getCredentialsPath();
-      if (existsSync15(credPath)) {
+      if (existsSync16(credPath)) {
         unlinkSync5(credPath);
       }
       this.credentials = null;
@@ -40861,7 +40991,7 @@ Waiting for authorization...`);
   }
   loadCredentials() {
     const credPath = this.getCredentialsPath();
-    if (!existsSync15(credPath)) {
+    if (!existsSync16(credPath)) {
       return null;
     }
     try {
@@ -40880,10 +41010,10 @@ Waiting for authorization...`);
   }
   saveCredentials(credentials) {
     const credPath = this.getCredentialsPath();
-    const claudishDir = join17(homedir16(), ".claudish");
-    if (!existsSync15(claudishDir)) {
-      const { mkdirSync: mkdirSync9 } = __require("fs");
-      mkdirSync9(claudishDir, { recursive: true });
+    const claudishDir = join18(homedir17(), ".claudish");
+    if (!existsSync16(claudishDir)) {
+      const { mkdirSync: mkdirSync10 } = __require("fs");
+      mkdirSync10(claudishDir, { recursive: true });
     }
     const fd = openSync3(credPath, "w", 384);
     try {
@@ -40908,9 +41038,9 @@ var init_kimi_oauth = __esm(() => {
 });
 
 // src/providers/transport/anthropic-compat.ts
-import { existsSync as existsSync16, readFileSync as readFileSync13 } from "fs";
-import { join as join18 } from "path";
-import { homedir as homedir17 } from "os";
+import { existsSync as existsSync17, readFileSync as readFileSync13 } from "fs";
+import { join as join19 } from "path";
+import { homedir as homedir18 } from "os";
 
 class AnthropicProviderTransport {
   name;
@@ -40941,8 +41071,8 @@ class AnthropicProviderTransport {
     }
     if (this.provider.name === "kimi-coding") {
       try {
-        const credPath = join18(homedir17(), ".claudish", "kimi-oauth.json");
-        if (existsSync16(credPath)) {
+        const credPath = join19(homedir18(), ".claudish", "kimi-oauth.json");
+        if (existsSync17(credPath)) {
           const data = JSON.parse(readFileSync13(credPath, "utf-8"));
           if (data.access_token && data.refresh_token) {
             const oauth = KimiOAuth.getInstance();
@@ -41368,9 +41498,9 @@ var init_litellm_api_format = __esm(() => {
 // src/auth/vertex-auth.ts
 import { exec as exec4 } from "child_process";
 import { promisify as promisify4 } from "util";
-import { existsSync as existsSync17 } from "fs";
-import { homedir as homedir18 } from "os";
-import { join as join19 } from "path";
+import { existsSync as existsSync18 } from "fs";
+import { homedir as homedir19 } from "os";
+import { join as join20 } from "path";
 
 class VertexAuthManager {
   cachedToken = null;
@@ -41424,8 +41554,8 @@ class VertexAuthManager {
   }
   async tryADC() {
     try {
-      const adcPath = join19(homedir18(), ".config/gcloud/application_default_credentials.json");
-      if (!existsSync17(adcPath)) {
+      const adcPath = join20(homedir19(), ".config/gcloud/application_default_credentials.json");
+      if (!existsSync18(adcPath)) {
         log("[VertexAuth] ADC credentials file not found");
         return null;
       }
@@ -41449,7 +41579,7 @@ class VertexAuthManager {
     if (!credPath) {
       return null;
     }
-    if (!existsSync17(credPath)) {
+    if (!existsSync18(credPath)) {
       throw new Error(`Service account file not found: ${credPath}
 
 Check GOOGLE_APPLICATION_CREDENTIALS path.`);
@@ -41488,8 +41618,8 @@ function validateVertexOAuthConfig() {
 ` + `  export VERTEX_PROJECT='your-gcp-project-id'
 ` + "  export VERTEX_LOCATION='us-central1'  # optional";
   }
-  const adcPath = join19(homedir18(), ".config/gcloud/application_default_credentials.json");
-  const hasADC = existsSync17(adcPath);
+  const adcPath = join20(homedir19(), ".config/gcloud/application_default_credentials.json");
+  const hasADC = existsSync18(adcPath);
   const hasServiceAccount = !!process.env.GOOGLE_APPLICATION_CREDENTIALS;
   if (!hasADC && !hasServiceAccount) {
     return `No Vertex AI credentials found.
@@ -41595,9 +41725,9 @@ var init_vertex_oauth = __esm(() => {
 });
 
 // src/providers/api-key-provenance.ts
-import { existsSync as existsSync18, readFileSync as readFileSync15 } from "fs";
-import { join as join20, resolve as resolve2 } from "path";
-import { homedir as homedir19 } from "os";
+import { existsSync as existsSync19, readFileSync as readFileSync15 } from "fs";
+import { join as join21, resolve as resolve2 } from "path";
+import { homedir as homedir20 } from "os";
 function maskKey(key) {
   if (!key)
     return null;
@@ -41668,7 +41798,7 @@ function formatProvenanceLog(p) {
 function readDotenvKey(envVars) {
   try {
     const dotenvPath = resolve2(".env");
-    if (!existsSync18(dotenvPath))
+    if (!existsSync19(dotenvPath))
       return null;
     const parsed = import_dotenv.parse(readFileSync15(dotenvPath, "utf-8"));
     for (const v of envVars) {
@@ -41682,8 +41812,8 @@ function readDotenvKey(envVars) {
 }
 function readConfigKey(envVar) {
   try {
-    const configPath = join20(homedir19(), ".claudish", "config.json");
-    if (!existsSync18(configPath))
+    const configPath = join21(homedir20(), ".claudish", "config.json");
+    if (!existsSync19(configPath))
       return null;
     const cfg = JSON.parse(readFileSync15(configPath, "utf-8"));
     return cfg.apiKeys?.[envVar] || null;
@@ -42624,12 +42754,12 @@ __export(exports_mcp_server, {
   runPromptViaProxy: () => runPromptViaProxy,
   parseAnthropicSse: () => parseAnthropicSse
 });
-import { readFileSync as readFileSync16, existsSync as existsSync19, writeFileSync as writeFileSync10, mkdirSync as mkdirSync9, readdirSync as readdirSync3 } from "fs";
-import { join as join21, dirname as dirname3 } from "path";
-import { homedir as homedir20 } from "os";
+import { readFileSync as readFileSync16, existsSync as existsSync20, writeFileSync as writeFileSync11, mkdirSync as mkdirSync10, readdirSync as readdirSync3 } from "fs";
+import { join as join22, dirname as dirname4 } from "path";
+import { homedir as homedir21 } from "os";
 import { fileURLToPath } from "url";
 async function loadAllModels(forceRefresh = false) {
-  if (!forceRefresh && existsSync19(ALL_MODELS_CACHE_PATH2)) {
+  if (!forceRefresh && existsSync20(ALL_MODELS_CACHE_PATH2)) {
     try {
       const cacheData = JSON.parse(readFileSync16(ALL_MODELS_CACHE_PATH2, "utf-8"));
       const lastUpdated = new Date(cacheData.lastUpdated);
@@ -42645,11 +42775,11 @@ async function loadAllModels(forceRefresh = false) {
       throw new Error(`API returned ${response.status}`);
     const data = await response.json();
     const models = data.data || [];
-    mkdirSync9(CLAUDISH_CACHE_DIR, { recursive: true });
-    writeFileSync10(ALL_MODELS_CACHE_PATH2, JSON.stringify({ lastUpdated: new Date().toISOString(), models }), "utf-8");
+    mkdirSync10(CLAUDISH_CACHE_DIR, { recursive: true });
+    writeFileSync11(ALL_MODELS_CACHE_PATH2, JSON.stringify({ lastUpdated: new Date().toISOString(), models }), "utf-8");
     return models;
   } catch {
-    if (existsSync19(ALL_MODELS_CACHE_PATH2)) {
+    if (existsSync20(ALL_MODELS_CACHE_PATH2)) {
       const cacheData = JSON.parse(readFileSync16(ALL_MODELS_CACHE_PATH2, "utf-8"));
       return cacheData.models || [];
     }
@@ -43222,16 +43352,16 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
         const sp = session_path;
         for (const file2 of ["status.json", "manifest.json", "input.md"]) {
           try {
-            sessionData[file2] = readFileSync16(join21(sp, file2), "utf-8");
+            sessionData[file2] = readFileSync16(join22(sp, file2), "utf-8");
           } catch {}
         }
         try {
-          const errorDir = join21(sp, "errors");
-          if (existsSync19(errorDir)) {
+          const errorDir = join22(sp, "errors");
+          if (existsSync20(errorDir)) {
             for (const f of readdirSync3(errorDir)) {
               if (f.endsWith(".log")) {
                 try {
-                  sessionData[`errors/${f}`] = readFileSync16(join21(errorDir, f), "utf-8");
+                  sessionData[`errors/${f}`] = readFileSync16(join22(errorDir, f), "utf-8");
                 } catch {}
               }
             }
@@ -43241,7 +43371,7 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
           for (const f of readdirSync3(sp)) {
             if (f.startsWith("response-") && f.endsWith(".md")) {
               try {
-                const content = readFileSync16(join21(sp, f), "utf-8");
+                const content = readFileSync16(join22(sp, f), "utf-8");
                 sessionData[f] = content.slice(0, 200) + (content.length > 200 ? "... (truncated)" : "");
               } catch {}
             }
@@ -43250,8 +43380,8 @@ Use with: run_prompt(model="${results[0].model.id}", prompt="your prompt")`;
       }
       let version2 = "unknown";
       try {
-        const pkgPath = join21(__dirname2, "../package.json");
-        if (existsSync19(pkgPath)) {
+        const pkgPath = join22(__dirname2, "../package.json");
+        if (existsSync20(pkgPath)) {
           version2 = JSON.parse(readFileSync16(pkgPath, "utf-8")).version;
         }
       } catch {}
@@ -43624,9 +43754,9 @@ var init_mcp_server = __esm(() => {
   import_dotenv2 = __toESM(require_main(), 1);
   import_dotenv2.config();
   __filename2 = fileURLToPath(import.meta.url);
-  __dirname2 = dirname3(__filename2);
-  CLAUDISH_CACHE_DIR = join21(homedir20(), ".claudish");
-  ALL_MODELS_CACHE_PATH2 = join21(CLAUDISH_CACHE_DIR, "all-models.json");
+  __dirname2 = dirname4(__filename2);
+  CLAUDISH_CACHE_DIR = join22(homedir21(), ".claudish");
+  ALL_MODELS_CACHE_PATH2 = join22(CLAUDISH_CACHE_DIR, "all-models.json");
   EVENT_TO_TASK_STATUS = new Map([
     ["starting", "working"],
     ["running", "working"],
@@ -43643,7 +43773,7 @@ var exports_serve_command = {};
 __export(exports_serve_command, {
   serveCommand: () => serveCommand
 });
-import { existsSync as existsSync20, readFileSync as readFileSync17 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync17 } from "fs";
 function parseServeArgs(args) {
   const out = {};
   for (let i = 0;i < args.length; i++) {
@@ -43662,7 +43792,7 @@ function parseServeArgs(args) {
   return out;
 }
 function loadModelMap(path) {
-  if (!existsSync20(path)) {
+  if (!existsSync21(path)) {
     throw new Error(`--models file not found: ${path}`);
   }
   let raw2;
@@ -55104,7 +55234,7 @@ var init_RemoveFileError = __esm(() => {
 
 // ../../node_modules/.bun/@inquirer+external-editor@2.0.1+04f2146be16c61ef/node_modules/@inquirer/external-editor/dist/index.js
 import { spawn as spawn3, spawnSync as spawnSync2 } from "child_process";
-import { readFileSync as readFileSync18, unlinkSync as unlinkSync6, writeFileSync as writeFileSync11 } from "fs";
+import { readFileSync as readFileSync18, unlinkSync as unlinkSync6, writeFileSync as writeFileSync12 } from "fs";
 import path from "path";
 import os from "os";
 import { randomUUID as randomUUID3 } from "crypto";
@@ -55213,7 +55343,7 @@ class ExternalEditor {
       if (Object.prototype.hasOwnProperty.call(this.fileOptions, "mode")) {
         opt.mode = this.fileOptions.mode;
       }
-      writeFileSync11(this.tempFile, this.text, opt);
+      writeFileSync12(this.tempFile, this.text, opt);
     } catch (createFileError) {
       throw new CreateFileError(createFileError);
     }
@@ -56410,11 +56540,11 @@ async function geminiQuotaHandler() {
   }
 }
 async function codexQuotaHandler() {
-  const { readFileSync: readFileSync19, existsSync: existsSync21 } = await import("fs");
-  const { join: join22 } = await import("path");
-  const { homedir: homedir21 } = await import("os");
-  const credPath = join22(homedir21(), ".claudish", "codex-oauth.json");
-  if (!existsSync21(credPath)) {
+  const { readFileSync: readFileSync19, existsSync: existsSync22 } = await import("fs");
+  const { join: join23 } = await import("path");
+  const { homedir: homedir22 } = await import("os");
+  const credPath = join23(homedir22(), ".claudish", "codex-oauth.json");
+  if (!existsSync22(credPath)) {
     console.error(`${RED}No Codex credentials found.${R} Run: ${B}claudish login codex${R}`);
     process.exit(1);
   }
@@ -56470,8 +56600,8 @@ async function codexQuotaHandler() {
   }
   let modelSlugs = [];
   try {
-    const modelsPath = join22(homedir21(), ".codex", "models_cache.json");
-    if (existsSync21(modelsPath)) {
+    const modelsPath = join23(homedir22(), ".codex", "models_cache.json");
+    if (existsSync22(modelsPath)) {
       const cache = JSON.parse(readFileSync19(modelsPath, "utf-8"));
       modelSlugs = (cache.models || []).map((m) => m.slug || m.id).filter(Boolean);
     }
@@ -60172,22 +60302,22 @@ __export(exports_cli, {
 });
 import {
   readFileSync as readFileSync19,
-  existsSync as existsSync21,
-  mkdirSync as mkdirSync10,
-  copyFileSync,
+  existsSync as existsSync22,
+  mkdirSync as mkdirSync11,
+  copyFileSync as copyFileSync2,
   readdirSync as readdirSync4,
   unlinkSync as unlinkSync7,
-  writeFileSync as writeFileSync12
+  writeFileSync as writeFileSync13
 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname4, join as join22 } from "path";
-import { homedir as homedir21 } from "os";
+import { dirname as dirname5, join as join23 } from "path";
+import { homedir as homedir22 } from "os";
 function getVersion3() {
   return VERSION;
 }
 function clearAllModelCaches() {
-  const cacheDir = join22(homedir21(), ".claudish");
-  if (!existsSync21(cacheDir))
+  const cacheDir = join23(homedir22(), ".claudish");
+  if (!existsSync22(cacheDir))
     return;
   const cachePatterns = ["pricing-cache.json", "recommended-models-cache.json"];
   let cleared = 0;
@@ -60195,7 +60325,7 @@ function clearAllModelCaches() {
     const files = readdirSync4(cacheDir);
     for (const file2 of files) {
       if (cachePatterns.includes(file2)) {
-        unlinkSync7(join22(cacheDir, file2));
+        unlinkSync7(join23(cacheDir, file2));
         cleared++;
       }
     }
@@ -60579,15 +60709,15 @@ Usage:  claudish --list-models --provider <slug>`);
     });
     config3.resolvedDefaultProvider = resolved;
     if (resolved.legacyAutoPromoted && !config3.quiet) {
-      const markerFile = join22(homedir21(), ".claudish", ".legacy-litellm-hint-shown");
-      if (!existsSync21(markerFile)) {
+      const markerFile = join23(homedir22(), ".claudish", ".legacy-litellm-hint-shown");
+      if (!existsSync22(markerFile)) {
         const hint = buildLegacyHint(resolved);
         if (hint) {
           console.error(hint);
         }
         try {
-          mkdirSync10(dirname4(markerFile), { recursive: true });
-          writeFileSync12(markerFile, new Date().toISOString(), "utf-8");
+          mkdirSync11(dirname5(markerFile), { recursive: true });
+          writeFileSync13(markerFile, new Date().toISOString(), "utf-8");
         } catch {}
       }
     }
@@ -61737,7 +61867,7 @@ MORE INFO:
 }
 function printAIAgentGuide() {
   try {
-    const guidePath = join22(__dirname3, "../AI_AGENT_GUIDE.md");
+    const guidePath = join23(__dirname3, "../AI_AGENT_GUIDE.md");
     const guideContent = readFileSync19(guidePath, "utf-8");
     console.log(guideContent);
   } catch (error46) {
@@ -61754,19 +61884,19 @@ async function initializeClaudishSkill() {
   console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
 `);
   const cwd = process.cwd();
-  const claudeDir = join22(cwd, ".claude");
-  const skillsDir = join22(claudeDir, "skills");
-  const claudishSkillDir = join22(skillsDir, "claudish-usage");
-  const skillFile = join22(claudishSkillDir, "SKILL.md");
-  if (existsSync21(skillFile)) {
+  const claudeDir = join23(cwd, ".claude");
+  const skillsDir = join23(claudeDir, "skills");
+  const claudishSkillDir = join23(skillsDir, "claudish-usage");
+  const skillFile = join23(claudishSkillDir, "SKILL.md");
+  if (existsSync22(skillFile)) {
     console.log("\u2705 Claudish skill already installed at:");
     console.log(`   ${skillFile}
 `);
     console.log("\uD83D\uDCA1 To reinstall, delete the file and run 'claudish --init' again.");
     return;
   }
-  const sourceSkillPath = join22(__dirname3, "../skills/claudish-usage/SKILL.md");
-  if (!existsSync21(sourceSkillPath)) {
+  const sourceSkillPath = join23(__dirname3, "../skills/claudish-usage/SKILL.md");
+  if (!existsSync22(sourceSkillPath)) {
     console.error("\u274C Error: Claudish skill file not found in installation.");
     console.error(`   Expected at: ${sourceSkillPath}`);
     console.error(`
@@ -61775,19 +61905,19 @@ async function initializeClaudishSkill() {
     process.exit(1);
   }
   try {
-    if (!existsSync21(claudeDir)) {
-      mkdirSync10(claudeDir, { recursive: true });
+    if (!existsSync22(claudeDir)) {
+      mkdirSync11(claudeDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/ directory");
     }
-    if (!existsSync21(skillsDir)) {
-      mkdirSync10(skillsDir, { recursive: true });
+    if (!existsSync22(skillsDir)) {
+      mkdirSync11(skillsDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
     }
-    if (!existsSync21(claudishSkillDir)) {
-      mkdirSync10(claudishSkillDir, { recursive: true });
+    if (!existsSync22(claudishSkillDir)) {
+      mkdirSync11(claudishSkillDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/claudish-usage/ directory");
     }
-    copyFileSync(sourceSkillPath, skillFile);
+    copyFileSync2(sourceSkillPath, skillFile);
     console.log("\u2705 Installed Claudish skill at:");
     console.log(`   ${skillFile}
 `);
@@ -61856,7 +61986,7 @@ var init_cli = __esm(() => {
   init_probe_results_printer();
   init_provider_resolver();
   __filename3 = fileURLToPath2(import.meta.url);
-  __dirname3 = dirname4(__filename3);
+  __dirname3 = dirname5(__filename3);
 });
 
 // src/update-checker.ts
@@ -61867,30 +61997,30 @@ __export(exports_update_checker, {
   clearCache: () => clearCache,
   checkForUpdates: () => checkForUpdates
 });
-import { existsSync as existsSync22, mkdirSync as mkdirSync11, readFileSync as readFileSync20, unlinkSync as unlinkSync8, writeFileSync as writeFileSync13 } from "fs";
-import { homedir as homedir22, platform as platform2, tmpdir } from "os";
-import { join as join23 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync20, unlinkSync as unlinkSync8, writeFileSync as writeFileSync14 } from "fs";
+import { homedir as homedir23, platform as platform2, tmpdir } from "os";
+import { join as join24 } from "path";
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows) {
-    const localAppData = process.env.LOCALAPPDATA || join23(homedir22(), "AppData", "Local");
-    cacheDir = join23(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join24(homedir23(), "AppData", "Local");
+    cacheDir = join24(localAppData, "claudish");
   } else {
-    cacheDir = join23(homedir22(), ".cache", "claudish");
+    cacheDir = join24(homedir23(), ".cache", "claudish");
   }
   try {
-    if (!existsSync22(cacheDir)) {
-      mkdirSync11(cacheDir, { recursive: true });
+    if (!existsSync23(cacheDir)) {
+      mkdirSync12(cacheDir, { recursive: true });
     }
-    return join23(cacheDir, "update-check.json");
+    return join24(cacheDir, "update-check.json");
   } catch {
-    return join23(tmpdir(), "claudish-update-check.json");
+    return join24(tmpdir(), "claudish-update-check.json");
   }
 }
 function readCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (!existsSync22(cachePath)) {
+    if (!existsSync23(cachePath)) {
       return null;
     }
     const data = JSON.parse(readFileSync20(cachePath, "utf-8"));
@@ -61906,7 +62036,7 @@ function writeCache(latestVersion) {
       lastCheck: Date.now(),
       latestVersion
     };
-    writeFileSync13(cachePath, JSON.stringify(data), "utf-8");
+    writeFileSync14(cachePath, JSON.stringify(data), "utf-8");
   } catch {}
 }
 function isCacheValid(cache) {
@@ -61916,7 +62046,7 @@ function isCacheValid(cache) {
 function clearCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (existsSync22(cachePath)) {
+    if (existsSync23(cachePath)) {
       unlinkSync8(cachePath);
     }
   } catch {}
@@ -62700,11 +62830,11 @@ var init_profile_commands = __esm(() => {
 });
 
 // src/providers/probe-catalog.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync21, writeFileSync as writeFileSync14 } from "fs";
-import { homedir as homedir23 } from "os";
-import { dirname as dirname5, join as join24 } from "path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync13, readFileSync as readFileSync21, writeFileSync as writeFileSync15 } from "fs";
+import { homedir as homedir24 } from "os";
+import { dirname as dirname6, join as join25 } from "path";
 function readProbeModelsCache(path2 = PROBE_MODELS_CACHE_PATH) {
-  if (!existsSync23(path2))
+  if (!existsSync24(path2))
     return null;
   let raw2;
   try {
@@ -62717,8 +62847,8 @@ function readProbeModelsCache(path2 = PROBE_MODELS_CACHE_PATH) {
   return raw2;
 }
 function writeProbeModelsCache(data, path2 = PROBE_MODELS_CACHE_PATH) {
-  mkdirSync12(dirname5(path2), { recursive: true });
-  writeFileSync14(path2, JSON.stringify(data), "utf-8");
+  mkdirSync13(dirname6(path2), { recursive: true });
+  writeFileSync15(path2, JSON.stringify(data), "utf-8");
 }
 function isCacheFresh(data, ttlMs = CACHE_TTL_MS3) {
   if (!data?.generatedAt)
@@ -62837,7 +62967,7 @@ function isValidResponse(raw2) {
 var PROBE_MODELS_URL = "https://us-central1-claudish-6da10.cloudfunctions.net/probeModels", CACHE_TTL_MS3, FETCH_TIMEOUT_MS2 = 15000, PROBE_MODELS_CACHE_PATH, _inFlight = null;
 var init_probe_catalog = __esm(() => {
   CACHE_TTL_MS3 = 60 * 60 * 1000;
-  PROBE_MODELS_CACHE_PATH = join24(homedir23(), ".claudish", "probe-models.json");
+  PROBE_MODELS_CACHE_PATH = join25(homedir24(), ".claudish", "probe-models.json");
 });
 
 // src/tui/probe-proxy.ts
@@ -68964,9 +69094,9 @@ __export(exports_claude_runner, {
   checkClaudeInstalled: () => checkClaudeInstalled
 });
 import { spawn as spawn4 } from "child_process";
-import { writeFileSync as writeFileSync15, unlinkSync as unlinkSync9, mkdirSync as mkdirSync13, existsSync as existsSync24, readFileSync as readFileSync22 } from "fs";
-import { tmpdir as tmpdir2, homedir as homedir24 } from "os";
-import { join as join25 } from "path";
+import { writeFileSync as writeFileSync16, unlinkSync as unlinkSync9, mkdirSync as mkdirSync14, existsSync as existsSync25, readFileSync as readFileSync22 } from "fs";
+import { tmpdir as tmpdir2, homedir as homedir25 } from "os";
+import { join as join26 } from "path";
 function hasNativeAnthropicMapping(config3) {
   const models = [
     config3.model,
@@ -68982,9 +69112,9 @@ function isWindows2() {
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join25(homeDir, ".claudish");
+  const claudishDir = join26(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join25(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join26(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const script = `
 const fs = require('fs');
@@ -69076,18 +69206,18 @@ process.stdin.on('end', () => {
   }
 });
 `;
-  writeFileSync15(scriptPath, script, "utf-8");
+  writeFileSync16(scriptPath, script, "utf-8");
   return scriptPath;
 }
 function createTempSettingsFile(modelDisplay, port) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join25(homeDir, ".claudish");
+  const claudishDir = join26(homeDir, ".claudish");
   try {
-    mkdirSync13(claudishDir, { recursive: true });
+    mkdirSync14(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join25(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join25(claudishDir, `tokens-${port}.json`);
+  const tempPath = join26(claudishDir, `settings-${timestamp}.json`);
+  const tokenFilePath = join26(claudishDir, `tokens-${port}.json`);
   let statusCommand;
   if (isWindows2()) {
     const scriptPath = createStatusLineScript(tokenFilePath);
@@ -69109,7 +69239,7 @@ function createTempSettingsFile(modelDisplay, port) {
     padding: 0
   };
   const settings = { statusLine };
-  writeFileSync15(tempPath, JSON.stringify(settings, null, 2), "utf-8");
+  writeFileSync16(tempPath, JSON.stringify(settings, null, 2), "utf-8");
   return { path: tempPath, statusLine };
 }
 function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine) {
@@ -69127,7 +69257,7 @@ function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine) {
       userSettings = JSON.parse(rawUserSettings);
     }
     userSettings.statusLine = statusLine;
-    writeFileSync15(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
+    writeFileSync16(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
   } catch {
     if (!config3.quiet) {
       console.warn(`[claudish] Warning: could not merge user settings: ${userSettingsValue}`);
@@ -69215,8 +69345,8 @@ async function runClaudeWithProxy(config3, proxyUrl, onCleanup) {
     console.error("Install it from: https://claude.com/claude-code");
     console.error(`
 Or set CLAUDE_PATH to your custom installation:`);
-    const home = homedir24();
-    const localPath = isWindows2() ? join25(home, ".claude", "local", "claude.exe") : join25(home, ".claude", "local", "claude");
+    const home = homedir25();
+    const localPath = isWindows2() ? join26(home, ".claude", "local", "claude.exe") : join26(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
@@ -69264,23 +69394,23 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
 async function findClaudeBinary() {
   const isWindows3 = process.platform === "win32";
   if (process.env.CLAUDE_PATH) {
-    if (existsSync24(process.env.CLAUDE_PATH)) {
+    if (existsSync25(process.env.CLAUDE_PATH)) {
       return process.env.CLAUDE_PATH;
     }
   }
-  const home = homedir24();
-  const localPath = isWindows3 ? join25(home, ".claude", "local", "claude.exe") : join25(home, ".claude", "local", "claude");
-  if (existsSync24(localPath)) {
+  const home = homedir25();
+  const localPath = isWindows3 ? join26(home, ".claude", "local", "claude.exe") : join26(home, ".claude", "local", "claude");
+  if (existsSync25(localPath)) {
     return localPath;
   }
   if (isWindows3) {
     const windowsPaths = [
-      join25(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join25(home, ".npm-global", "claude.cmd"),
-      join25(home, "node_modules", ".bin", "claude.cmd")
+      join26(home, "AppData", "Roaming", "npm", "claude.cmd"),
+      join26(home, ".npm-global", "claude.cmd"),
+      join26(home, "node_modules", ".bin", "claude.cmd")
     ];
     for (const path2 of windowsPaths) {
-      if (existsSync24(path2)) {
+      if (existsSync25(path2)) {
         return path2;
       }
     }
@@ -69288,14 +69418,14 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join25(home, ".npm-global/bin/claude"),
-      join25(home, ".local/bin/claude"),
-      join25(home, "node_modules/.bin/claude"),
+      join26(home, ".npm-global/bin/claude"),
+      join26(home, ".local/bin/claude"),
+      join26(home, "node_modules/.bin/claude"),
       "/data/data/com.termux/files/usr/bin/claude",
-      join25(home, "../usr/bin/claude")
+      join26(home, "../usr/bin/claude")
     ];
     for (const path2 of commonPaths) {
-      if (existsSync24(path2)) {
+      if (existsSync25(path2)) {
         return path2;
       }
     }
@@ -69345,18 +69475,18 @@ __export(exports_diag_output, {
   NullDiagOutput: () => NullDiagOutput,
   LogFileDiagOutput: () => LogFileDiagOutput
 });
-import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync14, writeFileSync as writeFileSync16, unlinkSync as unlinkSync10 } from "fs";
-import { homedir as homedir25 } from "os";
-import { join as join26 } from "path";
+import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync15, writeFileSync as writeFileSync17, unlinkSync as unlinkSync10 } from "fs";
+import { homedir as homedir26 } from "os";
+import { join as join27 } from "path";
 function getClaudishDir() {
-  const dir = join26(homedir25(), ".claudish");
+  const dir = join27(homedir26(), ".claudish");
   try {
-    mkdirSync14(dir, { recursive: true });
+    mkdirSync15(dir, { recursive: true });
   } catch {}
   return dir;
 }
 function getDiagLogPath() {
-  return join26(getClaudishDir(), `diag-${process.pid}.log`);
+  return join27(getClaudishDir(), `diag-${process.pid}.log`);
 }
 
 class LogFileDiagOutput {
@@ -69365,7 +69495,7 @@ class LogFileDiagOutput {
   constructor() {
     this.logPath = getDiagLogPath();
     try {
-      writeFileSync16(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
+      writeFileSync17(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
 `);
     } catch {}
     this.stream = createWriteStream3(this.logPath, { flags: "a" });
@@ -69567,11 +69697,11 @@ __export(exports_team_grid, {
 });
 import { spawn as spawn5 } from "child_process";
 import {
-  existsSync as existsSync25,
+  existsSync as existsSync26,
   readFileSync as readFileSync23,
-  writeFileSync as writeFileSync17
+  writeFileSync as writeFileSync18
 } from "fs";
-import { dirname as dirname6, join as join27 } from "path";
+import { dirname as dirname7, join as join28 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { execSync as execSync2 } from "child_process";
 import { connect as netConnect } from "net";
@@ -69666,21 +69796,21 @@ function buildPaneHeader(model, prompt, bg) {
 }
 function findMagmuxBinary() {
   const thisFile = fileURLToPath3(import.meta.url);
-  const thisDir = dirname6(thisFile);
-  const pkgRoot = join27(thisDir, "..");
+  const thisDir = dirname7(thisFile);
+  const pkgRoot = join28(thisDir, "..");
   const platform3 = process.platform;
   const arch = process.arch;
-  const bundledMagmux = join27(pkgRoot, "native", `magmux-${platform3}-${arch}`);
-  if (existsSync25(bundledMagmux))
+  const bundledMagmux = join28(pkgRoot, "native", `magmux-${platform3}-${arch}`);
+  if (existsSync26(bundledMagmux))
     return bundledMagmux;
   try {
     const pkgName = `@claudish/magmux-${platform3}-${arch}`;
     let searchDir = pkgRoot;
     for (let i = 0;i < 5; i++) {
-      const candidate = join27(searchDir, "node_modules", pkgName, "bin", "magmux");
-      if (existsSync25(candidate))
+      const candidate = join28(searchDir, "node_modules", pkgName, "bin", "magmux");
+      if (existsSync26(candidate))
         return candidate;
-      const parent = dirname6(searchDir);
+      const parent = dirname7(searchDir);
       if (parent === searchDir)
         break;
       searchDir = parent;
@@ -69697,7 +69827,7 @@ function findMagmuxBinary() {
 async function subscribeToMagmux(sockPath, onEvent) {
   let client = null;
   for (let attempt = 0;attempt < 40; attempt++) {
-    if (existsSync25(sockPath)) {
+    if (existsSync26(sockPath)) {
       try {
         client = await new Promise((resolve3, reject) => {
           const s = netConnect(sockPath);
@@ -69784,9 +69914,9 @@ async function runWithGrid(sessionPath, models, input, opts) {
   const keep = opts?.keep ?? false;
   const manifest = setupSession(sessionPath, models, input);
   const startedAt = new Date().toISOString();
-  const gridfilePath = join27(sessionPath, "gridfile.txt");
-  const prompt = readFileSync23(join27(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
-  const rawPrompt = readFileSync23(join27(sessionPath, "input.md"), "utf-8");
+  const gridfilePath = join28(sessionPath, "gridfile.txt");
+  const prompt = readFileSync23(join28(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
+  const rawPrompt = readFileSync23(join28(sessionPath, "input.md"), "utf-8");
   const usedBannerColors = new Set;
   const gridLines = Object.entries(manifest.models).map(([anonId]) => {
     const model = manifest.models[anonId].model;
@@ -69797,7 +69927,7 @@ async function runWithGrid(sessionPath, models, input, opts) {
     const header = buildPaneHeader(model, rawPrompt, bg);
     return `${header} claudish --model ${model} -y --quiet '${prompt}'`;
   });
-  writeFileSync17(gridfilePath, gridLines.join(`
+  writeFileSync18(gridfilePath, gridLines.join(`
 `) + `
 `, "utf-8");
   const magmuxPath = findMagmuxBinary();
@@ -69817,8 +69947,8 @@ async function runWithGrid(sessionPath, models, input, opts) {
   });
   const [{ results }] = await Promise.all([subscription, procExit]);
   const status = buildTeamStatus(manifest, startedAt, results?.panes ?? null);
-  const statusPath = join27(sessionPath, "status.json");
-  writeFileSync17(statusPath, JSON.stringify(status, null, 2), "utf-8");
+  const statusPath = join28(sessionPath, "status.json");
+  writeFileSync18(statusPath, JSON.stringify(status, null, 2), "utf-8");
   return status;
 }
 var BANNER_BG_COLORS;
@@ -69840,9 +69970,9 @@ var init_team_grid = __esm(() => {
 // src/index.ts
 init_onepassword_config();
 var import_dotenv3 = __toESM(require_main(), 1);
-import { existsSync as existsSync26, readFileSync as readFileSync24 } from "fs";
-import { homedir as homedir26 } from "os";
-import { join as join28 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync24 } from "fs";
+import { homedir as homedir27 } from "os";
+import { join as join29 } from "path";
 import_dotenv3.config({ quiet: true });
 function readConfiguredOnepasswordAccount() {
   return readOnepasswordAccount();
@@ -70014,8 +70144,8 @@ async function loadStoredApiKeys() {
   let globImports = [];
   let apiKeysForSeed;
   try {
-    const configPath = join28(homedir26(), ".claudish", "config.json");
-    if (!existsSync26(configPath))
+    const configPath = join29(homedir27(), ".claudish", "config.json");
+    if (!existsSync27(configPath))
       return;
     const raw2 = readFileSync24(configPath, "utf-8");
     const cfg = JSON.parse(raw2);
@@ -70055,7 +70185,10 @@ async function loadStoredApiKeys() {
     }
     for (const globPath of globImports) {
       try {
-        const resolved = await resolveGlobImport2(globPath, { auth });
+        const resolved = await resolveGlobImport2(globPath, {
+          auth,
+          warn: () => {}
+        });
         for (const [envVar, value] of Object.entries(resolved)) {
           if (!process.env[envVar]) {
             process.env[envVar] = value;
@@ -70075,8 +70208,8 @@ async function loadStoredApiKeys() {
 async function applyCustomEndpointOpKeys() {
   let refs = {};
   try {
-    const configPath = join28(homedir26(), ".claudish", "config.json");
-    if (!existsSync26(configPath))
+    const configPath = join29(homedir27(), ".claudish", "config.json");
+    if (!existsSync27(configPath))
       return;
     const cfg = JSON.parse(readFileSync24(configPath, "utf-8"));
     const endpoints = cfg.customEndpoints;
@@ -70112,10 +70245,16 @@ async function applyCustomEndpointOpKeys() {
     process.exit(1);
   }
 }
-await applyOpEnvironment();
-await applyOpImport();
-await loadStoredApiKeys();
-await applyCustomEndpointOpKeys();
+var earlyArgv = process.argv.slice(2);
+var hasExplicitOpFlag = earlyArgv.some((a) => a === "--op" || a === "--op-env" || a.startsWith("--op-env="));
+var earlyFirst = earlyArgv.find((a) => !a.startsWith("-"));
+var isNoSecretCommand = !hasExplicitOpFlag && (earlyArgv.includes("--help") || earlyArgv.includes("-h") || earlyArgv.includes("--help-ai") || earlyArgv.includes("--version") || earlyArgv.includes("-v") || earlyFirst === "help" || earlyFirst === "version");
+if (!isNoSecretCommand) {
+  await applyOpEnvironment();
+  await applyOpImport();
+  await loadStoredApiKeys();
+  await applyCustomEndpointOpKeys();
+}
 var isMcpMode = process.argv.includes("--mcp");
 function handlePromptExit(err) {
   if (err && typeof err === "object" && "name" in err && err.name === "ExitPromptError") {
@@ -70233,7 +70372,7 @@ async function runCli() {
         process.exit(1);
       }
       const mode = cliConfig.teamMode ?? "default";
-      const sessionPath = join28(process.cwd(), `.claudish-team-${Date.now()}`);
+      const sessionPath = join29(process.cwd(), `.claudish-team-${Date.now()}`);
       if (mode === "json") {
         const { setupSession: setupSession2, runModels: runModels2 } = await Promise.resolve().then(() => (init_team_orchestrator(), exports_team_orchestrator));
         setupSession2(sessionPath, cliConfig.team, prompt);
@@ -70243,7 +70382,7 @@ async function runCli() {
         });
         const result = { ...status2, responses: {} };
         for (const anonId of Object.keys(status2.models)) {
-          const responsePath = join28(sessionPath, `response-${anonId}.md`);
+          const responsePath = join29(sessionPath, `response-${anonId}.md`);
           try {
             const raw2 = readFileSync24(responsePath, "utf-8").trim();
             try {