claudish 7.34.0 → 7.35.0

package/dist/index.js

@@ -651,7 +651,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.34.0";
+var VERSION = "7.35.0";
 
 // src/logger.ts
 var exports_logger = {};
@@ -38401,6 +38401,145 @@ var init_journal = __esm(() => {
   PRUNE_TO_BYTES = Math.floor(MAX_JOURNAL_BYTES * 0.6);
 });
 
+// src/behavior/telemetry/aggregate.ts
+import { createHash as createHash4, randomBytes as randomBytes4 } from "crypto";
+import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync9 } from "fs";
+import { homedir as homedir19 } from "os";
+import { dirname as dirname7, join as join19 } from "path";
+function contextBucket(inputTokens) {
+  if (inputTokens < 50000)
+    return "0-50k";
+  if (inputTokens < 1e5)
+    return "50-100k";
+  if (inputTokens < 150000)
+    return "100-150k";
+  if (inputTokens < 200000)
+    return "150-200k";
+  return "200k+";
+}
+function hashSessionId(rawSessionId, model) {
+  return createHash4("sha256").update(`${SESSION_SALT}:${rawSessionId}:${model}`).digest("hex");
+}
+function setTelemetryConsent(value) {
+  consent = value;
+}
+function enabled() {
+  return consent;
+}
+function stateFor(rawSessionId, model, provider) {
+  const key = `${rawSessionId}|${model}`;
+  let state = sessions.get(key);
+  if (!state) {
+    while (sessions.size >= MAX_TRACKED_SESSIONS) {
+      const oldest = sessions.keys().next().value;
+      if (oldest === undefined)
+        break;
+      sessions.delete(oldest);
+    }
+    const now = new Date().toISOString();
+    state = {
+      sessionId: hashSessionId(rawSessionId, model),
+      model,
+      provider,
+      startedAt: now,
+      endedAt: now,
+      turns: 0,
+      maxInputTokens: 0,
+      decisions: new Map
+    };
+    sessions.set(key, state);
+  }
+  return state;
+}
+function recordTelemetryTurn(p) {
+  if (!enabled() || !p.sessionId)
+    return;
+  const state = stateFor(p.sessionId, p.model, p.provider);
+  if (!state)
+    return;
+  state.turns++;
+  state.endedAt = new Date().toISOString();
+  if (typeof p.inputTokens === "number" && p.inputTokens > state.maxInputTokens) {
+    state.maxInputTokens = p.inputTokens;
+  }
+}
+function recordTelemetryDecision(p) {
+  if (!enabled() || !p.sessionId)
+    return;
+  const state = stateFor(p.sessionId, p.model, p.provider);
+  if (!state)
+    return;
+  const key = `${p.ruleId ?? ""}|${p.surface}|${p.toolName ?? ""}`;
+  let agg = state.decisions.get(key);
+  if (!agg) {
+    if (state.decisions.size >= MAX_DECISION_KEYS)
+      return;
+    agg = {
+      rule_id: p.ruleId,
+      surface: p.surface,
+      tool_name: p.toolName,
+      counts: {},
+      path_relations: {}
+    };
+    state.decisions.set(key, agg);
+  }
+  agg.counts[p.decision] = (agg.counts[p.decision] ?? 0) + 1;
+  if (p.pathRelation) {
+    agg.path_relations[p.pathRelation] = (agg.path_relations[p.pathRelation] ?? 0) + 1;
+  }
+  state.endedAt = new Date().toISOString();
+}
+function toReport(state) {
+  return {
+    schema_version: TELEMETRY_SCHEMA_VERSION,
+    session_id: state.sessionId,
+    started_at: state.startedAt,
+    ended_at: state.endedAt,
+    claudish_version: VERSION,
+    platform: process.platform,
+    model_id: state.model,
+    provider_name: state.provider,
+    context_bucket: contextBucket(state.maxInputTokens),
+    turns: state.turns,
+    decisions: [...state.decisions.values()]
+  };
+}
+function pendingReports() {
+  return [...sessions.values()].map(toReport);
+}
+function outboxPath() {
+  return join19(homedir19(), ".claudish", "behavior-outbox.jsonl");
+}
+function spoolPendingSync(path = outboxPath()) {
+  if (sessions.size === 0)
+    return 0;
+  const reports = pendingReports().filter((r) => r.turns > 0 || r.decisions.length > 0);
+  sessions.clear();
+  if (reports.length === 0)
+    return 0;
+  try {
+    mkdirSync9(dirname7(path), { recursive: true });
+    appendFileSync3(path, `${reports.map((r) => JSON.stringify(r)).join(`
+`)}
+`);
+    return reports.length;
+  } catch (err) {
+    log(`[behavior:telemetry] could not spool: ${err}`);
+    return 0;
+  }
+}
+var TELEMETRY_SCHEMA_VERSION = 1, SESSION_SALT, MAX_TRACKED_SESSIONS = 32, MAX_DECISION_KEYS = 200, sessions, consent = false;
+var init_aggregate = __esm(() => {
+  init_logger();
+  SESSION_SALT = randomBytes4(32).toString("hex");
+  sessions = new Map;
+  process.on("exit", () => {
+    try {
+      spoolPendingSync();
+    } catch {}
+  });
+});
+
 // src/behavior/observer/digest.ts
 var exports_digest = {};
 __export(exports_digest, {
@@ -38592,10 +38731,10 @@ __export(exports_live_log, {
   recordLiveDivergence: () => recordLiveDivergence
 });
 import { appendFile as appendFile3 } from "fs/promises";
-import { homedir as homedir19 } from "os";
-import { join as join19 } from "path";
+import { homedir as homedir20 } from "os";
+import { join as join20 } from "path";
 function defaultPath() {
-  return join19(homedir19(), ".claudish", "behavior-divergences.jsonl");
+  return join20(homedir20(), ".claudish", "behavior-divergences.jsonl");
 }
 async function recordLiveDivergence(entry, path = defaultPath()) {
   try {
@@ -38609,6 +38748,109 @@ var init_live_log = __esm(() => {
   init_logger();
 });
 
+// src/behavior/telemetry/upload.ts
+var exports_upload = {};
+__export(exports_upload, {
+  resetDrainState: () => resetDrainState,
+  drainOutbox: () => drainOutbox
+});
+import { readFile as readFile2, rename as rename2, unlink, writeFile as writeFile2 } from "fs/promises";
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function post(report) {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    const res = await fetch(ENDPOINT, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(report),
+      signal: controller.signal
+    });
+    if (res.status === 202)
+      return "sent";
+    if (res.status === 400) {
+      log("[behavior:telemetry] rejected as malformed (400), dropping");
+      return "drop";
+    }
+    if (res.status === 429) {
+      log("[behavior:telemetry] rate limited, deferring to next run");
+      return "retry";
+    }
+    return res.status >= 500 ? "retry" : "drop";
+  } catch {
+    return "retry";
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function parseOutbox(content) {
+  const out = [];
+  for (const line of content.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (parsed && typeof parsed.session_id === "string")
+        out.push(parsed);
+    } catch {}
+  }
+  return out;
+}
+async function persistRemaining(path, remaining) {
+  if (remaining.length === 0) {
+    await unlink(path).catch(() => {});
+    return;
+  }
+  const kept = remaining.slice(-MAX_OUTBOX_ENTRIES);
+  const tmp = `${path}.draining`;
+  await writeFile2(tmp, `${kept.map((r) => JSON.stringify(r)).join(`
+`)}
+`);
+  await rename2(tmp, path);
+}
+async function drainOutbox(path = outboxPath()) {
+  if (drained)
+    return { sent: 0, kept: 0 };
+  drained = true;
+  try {
+    const content = await readFile2(path, "utf8").catch(() => "");
+    const reports = parseOutbox(content);
+    if (reports.length === 0)
+      return { sent: 0, kept: 0 };
+    const batch = reports.slice(-MAX_DRAIN_PER_RUN).reverse();
+    const older = reports.slice(0, Math.max(0, reports.length - MAX_DRAIN_PER_RUN));
+    const keep = [];
+    let sent = 0;
+    for (let i = 0;i < batch.length; i++) {
+      if (i > 0)
+        await sleep2(SEND_INTERVAL_MS);
+      const outcome = await post(batch[i]);
+      if (outcome === "sent")
+        sent++;
+      else if (outcome === "retry")
+        keep.push(batch[i]);
+    }
+    await persistRemaining(path, [...older, ...keep]);
+    if (sent > 0)
+      log(`[behavior:telemetry] delivered ${sent} session report(s)`);
+    return { sent, kept: keep.length };
+  } catch (err) {
+    log(`[behavior:telemetry] drain failed: ${err}`);
+    return { sent: 0, kept: 0 };
+  }
+}
+function resetDrainState() {
+  drained = false;
+}
+var ENDPOINT = "https://claudish.com/v1/behavior", REQUEST_TIMEOUT_MS = 15000, SEND_INTERVAL_MS = 1100, MAX_DRAIN_PER_RUN = 50, MAX_OUTBOX_ENTRIES = 200, drained = false;
+var init_upload = __esm(() => {
+  init_logger();
+  init_aggregate();
+});
+
 // src/behavior/engine.ts
 class BehaviorSession {
   active;
@@ -38713,6 +38955,14 @@ class BehaviorSession {
   interceptsTool(toolName) {
     return this.bufferedTools.has(toolName);
   }
+  noteTurnComplete(inputTokens) {
+    recordTelemetryTurn({
+      sessionId: this.sessionId,
+      model: this.modelId,
+      provider: this.providerName,
+      inputTokens
+    });
+  }
   observeText(text, kind = "text") {
     if (!this.watchesOutput || !text)
       return;
@@ -38841,6 +39091,17 @@ class BehaviorSession {
     return changed ? JSON.stringify(args) : null;
   }
   journal(surface, decision, detail) {
+    const pathRelation = classifyPath(detail.observedPath, detail.expectedPath);
+    recordTelemetryDecision({
+      sessionId: this.sessionId,
+      model: this.modelId,
+      provider: this.providerName,
+      surface,
+      decision,
+      ruleId: detail.ruleId,
+      toolName: detail.toolName,
+      pathRelation
+    });
     recordDecision({
       ts: new Date().toISOString(),
       model: this.modelId,
@@ -38850,7 +39111,7 @@ class BehaviorSession {
       ruleId: detail.ruleId,
       toolName: detail.toolName,
       argKeys: detail.argKeys,
-      pathRelation: classifyPath(detail.observedPath, detail.expectedPath),
+      pathRelation,
       local: {
         observedPath: detail.observedPath,
         expectedPath: detail.expectedPath,
@@ -38944,6 +39205,11 @@ class BehaviorEngine {
   constructor(config2, rules) {
     this.config = config2;
     this.rules = rules;
+    const optedIn = config2.telemetry?.enabled === true;
+    setTelemetryConsent(optedIn);
+    if (optedIn) {
+      Promise.resolve().then(() => (init_upload(), exports_upload)).then((m) => m.drainOutbox()).catch((err) => log(`[behavior:telemetry] drain unavailable: ${err}`));
+    }
   }
   queueCorrection(key, text) {
     const list = this.corrections.get(key) ?? [];
@@ -38991,6 +39257,7 @@ var init_engine = __esm(() => {
   init_config();
   init_harness();
   init_journal();
+  init_aggregate();
   MAX_OBSERVED_CHARS = 64 * 1024;
 });
 
@@ -39124,9 +39391,9 @@ var init_hooks = __esm(() => {
 });
 
 // src/behavior/observer/corpus.ts
-import { appendFileSync as appendFileSync3, readFileSync as readFileSync12, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { homedir as homedir20 } from "os";
-import { join as join20 } from "path";
+import { appendFileSync as appendFileSync4, readFileSync as readFileSync12, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { homedir as homedir21 } from "os";
+import { join as join21 } from "path";
 function directoryOf2(filePath) {
   const slash = filePath.lastIndexOf("/");
   return slash > 0 ? filePath.slice(0, slash) : undefined;
@@ -39205,28 +39472,28 @@ function listTranscripts(root) {
     return files;
   }
   for (const project of projects) {
-    const dir = join20(root, project);
+    const dir = join21(root, project);
     try {
       if (!statSync2(dir).isDirectory())
         continue;
       for (const f of readdirSync2(dir)) {
         if (f.endsWith(".jsonl"))
-          files.push(join20(dir, f));
+          files.push(join21(dir, f));
       }
     } catch {}
   }
   return files;
 }
 function buildCorpus(options = {}) {
-  const root = options.projectsRoot ?? join20(homedir20(), ".claude", "projects");
+  const root = options.projectsRoot ?? join21(homedir21(), ".claude", "projects");
   const files = listTranscripts(root);
   const records = [];
   for (const f of files)
     records.push(...replayTranscript(f));
   if (options.write && records.length > 0) {
-    const outputPath = options.outputPath ?? join20(homedir20(), ".claudish", "behavior-divergences.jsonl");
+    const outputPath = options.outputPath ?? join21(homedir21(), ".claudish", "behavior-divergences.jsonl");
     try {
-      appendFileSync3(outputPath, `${records.map((r) => JSON.stringify(r)).join(`
+      appendFileSync4(outputPath, `${records.map((r) => JSON.stringify(r)).join(`
 `)}
 `);
       return { scanned: files.length, records, outputPath };
@@ -39266,6 +39533,8 @@ var init_behavior = __esm(() => {
   init_digest();
   init_client();
   init_corpus();
+  init_aggregate();
+  init_upload();
   BUILTIN_RULES = [...PLAN_MODE_RULES];
   hookRules = [];
 });
@@ -39836,17 +40105,17 @@ var init_vision_proxy = __esm(() => {
 // src/stats-buffer.ts
 import {
   existsSync as existsSync15,
-  mkdirSync as mkdirSync9,
+  mkdirSync as mkdirSync10,
   readFileSync as readFileSync13,
   renameSync,
   unlinkSync as unlinkSync5,
   writeFileSync as writeFileSync9
 } from "fs";
-import { homedir as homedir21 } from "os";
-import { join as join21 } from "path";
+import { homedir as homedir22 } from "os";
+import { join as join22 } from "path";
 function ensureDir() {
   if (!existsSync15(CLAUDISH_DIR)) {
-    mkdirSync9(CLAUDISH_DIR, { recursive: true });
+    mkdirSync10(CLAUDISH_DIR, { recursive: true });
   }
 }
 function readFromDisk() {
@@ -39878,7 +40147,7 @@ function writeToDisk(events) {
     ensureDir();
     const trimmed = enforceSizeCap([...events]);
     const payload = { version: 1, events: trimmed };
-    const tmpFile = join21(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
+    const tmpFile = join22(CLAUDISH_DIR, `stats-buffer.tmp.${process.pid}.json`);
     writeFileSync9(tmpFile, JSON.stringify(payload, null, 2), "utf-8");
     renameSync(tmpFile, BUFFER_FILE);
     memoryCache = trimmed;
@@ -39951,8 +40220,8 @@ function syncFlushOnExit() {
 var BUFFER_MAX_BYTES, CLAUDISH_DIR, BUFFER_FILE, memoryCache = null, eventsSinceLastFlush = 0, flushScheduled = false;
 var init_stats_buffer = __esm(() => {
   BUFFER_MAX_BYTES = 64 * 1024;
-  CLAUDISH_DIR = join21(homedir21(), ".claudish");
-  BUFFER_FILE = join21(CLAUDISH_DIR, "stats-buffer.json");
+  CLAUDISH_DIR = join22(homedir22(), ".claudish");
+  BUFFER_FILE = join22(CLAUDISH_DIR, "stats-buffer.json");
   process.on("exit", syncFlushOnExit);
   process.on("SIGTERM", () => {
     try {
@@ -40089,7 +40358,7 @@ __export(exports_telemetry, {
   classifyError: () => classifyError,
   buildReport: () => buildReport
 });
-import { randomBytes as randomBytes4 } from "crypto";
+import { randomBytes as randomBytes5 } from "crypto";
 function getVersion() {
   return VERSION;
 }
@@ -40357,7 +40626,7 @@ function initTelemetry(_config) {
   } catch {
     consentEnabled = false;
   }
-  sessionId = randomBytes4(8).toString("hex");
+  sessionId = randomBytes5(8).toString("hex");
   claudishVersion = getVersion();
   installMethod = detectInstallMethod();
 }
@@ -40667,11 +40936,11 @@ function showMonthlyBanner() {
     if (isStatsDisabledByEnv())
       return;
     const profileConfig = loadConfig();
-    const consent = profileConfig.stats;
+    const consent2 = profileConfig.stats;
     const now = Date.now();
-    const lastPrompt = consent?.lastMonthlyPrompt ? new Date(consent.lastMonthlyPrompt).getTime() : 0;
+    const lastPrompt = consent2?.lastMonthlyPrompt ? new Date(consent2.lastMonthlyPrompt).getTime() : 0;
     const timeSincePrompt = now - lastPrompt;
-    const isFirstRun = !consent?.lastMonthlyPrompt;
+    const isFirstRun = !consent2?.lastMonthlyPrompt;
     const isMonthlyInterval = timeSincePrompt >= MONTHLY_INTERVAL_MS;
     if (!isFirstRun && !isMonthlyInterval)
       return;
@@ -40680,7 +40949,7 @@ function showMonthlyBanner() {
 ` + `           No prompts, API keys, or personal data \u2014 just model, latency, and token counts.
 ` + `           Enable: claudish stats on | Docs: claudish stats status
 `);
-    } else if (consent?.enabled) {
+    } else if (consent2?.enabled) {
       process.stderr.write(`[claudish] Usage stats are ON \u2014 thank you for helping improve claudish!
 `);
     } else {
@@ -42335,9 +42604,9 @@ var init_openai_responses_sse = __esm(() => {
 });
 
 // src/handlers/shared/token-tracker.ts
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
-import { homedir as homedir22 } from "os";
-import { dirname as dirname7, join as join22 } from "path";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync10 } from "fs";
+import { homedir as homedir23 } from "os";
+import { dirname as dirname8, join as join23 } from "path";
 function stripProviderPrefix(name) {
   const at = name.indexOf("@");
   return at === -1 ? name : name.slice(at + 1);
@@ -42489,8 +42758,8 @@ class TokenTracker {
         data.quota_remaining = this.quotaRemaining;
       }
       const override = process.env.CLAUDISH_TOKEN_FILE;
-      const outPath = override || join22(homedir22(), ".claudish", `tokens-${this.port}.json`);
-      mkdirSync10(dirname7(outPath), { recursive: true });
+      const outPath = override || join23(homedir23(), ".claudish", `tokens-${this.port}.json`);
+      mkdirSync11(dirname8(outPath), { recursive: true });
       writeFileSync10(outPath, JSON.stringify(data), "utf-8");
     } catch (e) {
       log(`[TokenTracker] Error writing token file: ${e}`);
@@ -43006,6 +43275,9 @@ class ComposedHandler {
           invocation_mode: this.options.invocationMode ?? "auto-route"
         });
       } catch {}
+      try {
+        behaviorSession?.noteTurnComplete(this.tokenTracker.getInputTokens());
+      } catch {}
     };
     return this.handleStream(c, response, adapter, claudeRequest, toolNameMap, onStreamComplete, (code, message) => {
       streamApiError = { code, message };
@@ -43358,7 +43630,7 @@ var init_fallback_handler = __esm(() => {
 });
 
 // src/handlers/native-handler-advisor.ts
-import { appendFileSync as appendFileSync4 } from "fs";
+import { appendFileSync as appendFileSync5 } from "fs";
 function loadAdvisorSwapConfig(cliModels, cliCollector) {
   return {
     enabled: process.env.CLAUDISH_SWAP_ADVISOR === "1" || (cliModels?.length ?? 0) > 0,
@@ -43413,7 +43685,7 @@ function logAdvisorEvent(cfg, event) {
   const line = `${JSON.stringify({ ts: new Date().toISOString(), ...event })}
 `;
   try {
-    appendFileSync4(cfg.logPath, line);
+    appendFileSync5(cfg.logPath, line);
   } catch {}
 }
 function recordAdvisorEventsFromChunk(cfg, chunkText) {
@@ -45170,10 +45442,10 @@ var init_ollama_api_format = __esm(() => {
 
 // src/providers/api-key-provenance.ts
 import { existsSync as existsSync16, readFileSync as readFileSync14 } from "fs";
-import { homedir as homedir23 } from "os";
-import { join as join23, resolve as resolve2 } from "path";
+import { homedir as homedir24 } from "os";
+import { join as join24, resolve as resolve2 } from "path";
 function activeConfigPath() {
-  return activeGlobalConfigFile(join23(homedir23(), ".claudish", "config.json"));
+  return activeGlobalConfigFile(join24(homedir24(), ".claudish", "config.json"));
 }
 function configLayerLabel() {
   return getConfigFileOverride() ? activeConfigPath() : "~/.claudish/config.json";
@@ -46051,10 +46323,10 @@ class LocalModelQueue {
     return LocalModelQueue.instance;
   }
   static isEnabled() {
-    const enabled = process.env.CLAUDISH_LOCAL_QUEUE_ENABLED;
-    if (enabled === undefined || enabled === "")
+    const enabled2 = process.env.CLAUDISH_LOCAL_QUEUE_ENABLED;
+    if (enabled2 === undefined || enabled2 === "")
       return true;
-    return enabled !== "false" && enabled !== "0";
+    return enabled2 !== "false" && enabled2 !== "0";
   }
   async enqueue(fetchFn, providerId, concurrencyOverride) {
     if (concurrencyOverride !== undefined) {
@@ -46741,8 +47013,8 @@ var init_poe = __esm(() => {
 
 // src/services/pricing-cache.ts
 import { existsSync as existsSync17, readFileSync as readFileSync15, statSync as statSync4 } from "fs";
-import { homedir as homedir24 } from "os";
-import { join as join24 } from "path";
+import { homedir as homedir25 } from "os";
+import { join as join25 } from "path";
 function prefixMatch(modelName) {
   for (const [key, pricing] of pricingMap) {
     if (modelName.startsWith(key))
@@ -46801,8 +47073,8 @@ var init_pricing_cache = __esm(() => {
   init_logger();
   init_catalog_query();
   pricingMap = new Map;
-  CACHE_DIR = join24(homedir24(), ".claudish");
-  CACHE_FILE = join24(CACHE_DIR, "pricing-cache.json");
+  CACHE_DIR = join25(homedir25(), ".claudish");
+  CACHE_FILE = join25(CACHE_DIR, "pricing-cache.json");
   CACHE_TTL_MS3 = 24 * 60 * 60 * 1000;
 });
 
@@ -47298,12 +47570,12 @@ var init_redact = __esm(() => {
 
 // src/team-stats.ts
 import { existsSync as existsSync18, readFileSync as readFileSync16, writeFileSync as writeFileSync11 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 function statsDir(sessionPath) {
-  return join25(sessionPath, "stats");
+  return join26(sessionPath, "stats");
 }
 function tokenFileFor(sessionPath, anonId) {
-  return join25(statsDir(sessionPath), `${anonId}.json`);
+  return join26(statsDir(sessionPath), `${anonId}.json`);
 }
 function readTokenStats(sessionPath, anonId) {
   const path = tokenFileFor(sessionPath, anonId);
@@ -47458,7 +47730,7 @@ ${segs.join(" \xB7 ")}`;
 }
 function writeStatusFile(sessionPath, manifest, status, opts) {
   try {
-    writeFileSync11(join25(sessionPath, "status.txt"), `${renderTeamStats(sessionPath, manifest, status, opts)}
+    writeFileSync11(join26(sessionPath, "status.txt"), `${renderTeamStats(sessionPath, manifest, status, opts)}
 `, "utf-8");
   } catch {}
 }
@@ -47485,12 +47757,12 @@ import { spawn as spawn2 } from "child_process";
 import {
   createWriteStream as createWriteStream2,
   existsSync as existsSync19,
-  mkdirSync as mkdirSync11,
+  mkdirSync as mkdirSync12,
   readFileSync as readFileSync17,
   readdirSync as readdirSync3,
   writeFileSync as writeFileSync12
 } from "fs";
-import { join as join26, resolve as resolve3 } from "path";
+import { join as join27, resolve as resolve3 } from "path";
 function classifyRunOutput(opts) {
   const { outputSize, stdoutTail, stderr, minOutputBytes } = opts;
   const apiError = API_ERROR_RE.exec(stdoutTail);
@@ -47551,18 +47823,18 @@ function setupSession(sessionPath, models, input) {
   if (models.length === 0) {
     throw new Error("At least one model is required");
   }
-  if (existsSync19(join26(sessionPath, "manifest.json"))) {
+  if (existsSync19(join27(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.`);
   }
-  mkdirSync11(join26(sessionPath, "work"), { recursive: true });
-  mkdirSync11(join26(sessionPath, "errors"), { recursive: true });
+  mkdirSync12(join27(sessionPath, "work"), { recursive: true });
+  mkdirSync12(join27(sessionPath, "errors"), { recursive: true });
   if (input !== undefined) {
-    writeFileSync12(join26(sessionPath, "input.md"), input, "utf-8");
-  } else if (!existsSync19(join26(sessionPath, "input.md"))) {
+    writeFileSync12(join27(sessionPath, "input.md"), input, "utf-8");
+  } else if (!existsSync19(join27(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"));
@@ -47579,9 +47851,9 @@ function setupSession(sessionPath, models, input) {
       model: models[i],
       assignedAt: now
     };
-    mkdirSync11(join26(sessionPath, "work", anonId), { recursive: true });
+    mkdirSync12(join27(sessionPath, "work", anonId), { recursive: true });
   }
-  writeFileSync12(join26(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+  writeFileSync12(join27(sessionPath, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
   const status = {
     startedAt: now,
     models: Object.fromEntries(Object.keys(manifest.models).map((id) => [
@@ -47595,14 +47867,14 @@ function setupSession(sessionPath, models, input) {
       }
     ]))
   };
-  writeFileSync12(join26(sessionPath, "status.json"), JSON.stringify(status, null, 2), "utf-8");
+  writeFileSync12(join27(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(readFileSync17(join26(sessionPath, "manifest.json"), "utf-8"));
-  const statusPath = join26(sessionPath, "status.json");
-  const inputPath = join26(sessionPath, "input.md");
+  const manifest = JSON.parse(readFileSync17(join27(sessionPath, "manifest.json"), "utf-8"));
+  const statusPath = join27(sessionPath, "status.json");
+  const inputPath = join27(sessionPath, "input.md");
   const inputContent = readFileSync17(inputPath, "utf-8");
   await prehydrateCredentialsForSpawn(Object.values(manifest.models).map((m) => m.model));
   const statusCache = JSON.parse(readFileSync17(statusPath, "utf-8"));
@@ -47611,7 +47883,7 @@ async function runModels(sessionPath, opts = {}) {
     writeFileSync12(statusPath, JSON.stringify(statusCache, null, 2), "utf-8");
   }
   const minOutputBytes = opts.minOutputBytes ?? DEFAULT_MIN_OUTPUT_BYTES;
-  mkdirSync11(statsDir(sessionPath), { recursive: true });
+  mkdirSync12(statsDir(sessionPath), { recursive: true });
   const processes = new Map;
   const runtimes = new Map;
   const sigintHandler = () => {
@@ -47624,8 +47896,8 @@ async function runModels(sessionPath, opts = {}) {
   process.on("SIGINT", sigintHandler);
   const completionPromises = [];
   for (const [anonId, entry] of Object.entries(manifest.models)) {
-    const outputPath = join26(sessionPath, `response-${anonId}.md`);
-    const errorLogPath = join26(sessionPath, "errors", `${anonId}.log`);
+    const outputPath = join27(sessionPath, `response-${anonId}.md`);
+    const errorLogPath = join27(sessionPath, "errors", `${anonId}.log`);
     const args = ["--model", entry.model, "-y", "--stdin", "--quiet", ...opts.claudeFlags ?? []];
     updateModelStatus(anonId, {
       state: "RUNNING",
@@ -47814,23 +48086,23 @@ async function judgeResponses(sessionPath, opts = {}) {
   const responses = {};
   for (const file2 of responseFiles) {
     const id = file2.replace(/^response-/, "").replace(/\.md$/, "");
-    responses[id] = readFileSync17(join26(sessionPath, file2), "utf-8");
+    responses[id] = readFileSync17(join27(sessionPath, file2), "utf-8");
   }
-  const input = readFileSync17(join26(sessionPath, "input.md"), "utf-8");
+  const input = readFileSync17(join27(sessionPath, "input.md"), "utf-8");
   const judgePrompt = buildJudgePrompt(input, responses);
-  writeFileSync12(join26(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
+  writeFileSync12(join27(sessionPath, "judge-prompt.md"), judgePrompt, "utf-8");
   const judgeModels = opts.judges ?? getDefaultJudgeModels(sessionPath);
-  const judgePath = join26(sessionPath, "judging");
-  mkdirSync11(judgePath, { recursive: true });
+  const judgePath = join27(sessionPath, "judging");
+  mkdirSync12(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));
-  writeFileSync12(join26(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
+  writeFileSync12(join27(sessionPath, "verdict.md"), formatVerdict(verdict, sessionPath), "utf-8");
   return verdict;
 }
 function getStatus(sessionPath) {
-  return JSON.parse(readFileSync17(join26(sessionPath, "status.json"), "utf-8"));
+  return JSON.parse(readFileSync17(join27(sessionPath, "status.json"), "utf-8"));
 }
 function fisherYatesShuffle(arr) {
   for (let i = arr.length - 1;i > 0; i--) {
@@ -47840,7 +48112,7 @@ function fisherYatesShuffle(arr) {
   return arr;
 }
 function getDefaultJudgeModels(sessionPath) {
-  const manifest = JSON.parse(readFileSync17(join26(sessionPath, "manifest.json"), "utf-8"));
+  const manifest = JSON.parse(readFileSync17(join27(sessionPath, "manifest.json"), "utf-8"));
   return Object.values(manifest.models).map((e) => e.model);
 }
 function buildJudgePrompt(input, responses) {
@@ -47903,7 +48175,7 @@ function parseJudgeVotes(judgePath, responseIds) {
     const judgeId = file2.replace(/^response-/, "").replace(/\.md$/, "");
     let content;
     try {
-      content = readFileSync17(join26(judgePath, file2), "utf-8");
+      content = readFileSync17(join27(judgePath, file2), "utf-8");
     } catch {
       continue;
     }
@@ -47955,7 +48227,7 @@ function aggregateVerdict(votes, responseIds) {
 function formatVerdict(verdict, sessionPath) {
   let manifest = null;
   try {
-    manifest = JSON.parse(readFileSync17(join26(sessionPath, "manifest.json"), "utf-8"));
+    manifest = JSON.parse(readFileSync17(join27(sessionPath, "manifest.json"), "utf-8"));
   } catch {}
   let output = `# Team Verdict
 
@@ -48010,9 +48282,9 @@ __export(exports_mcp_server, {
   parseAnthropicSse: () => parseAnthropicSse,
   formatTeamResult: () => formatTeamResult
 });
-import { existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync18, readdirSync as readdirSync4, writeFileSync as writeFileSync13 } from "fs";
-import { homedir as homedir25 } from "os";
-import { dirname as dirname8, join as join27 } from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync13, readFileSync as readFileSync18, readdirSync as readdirSync4, writeFileSync as writeFileSync13 } from "fs";
+import { homedir as homedir26 } from "os";
+import { dirname as dirname9, join as join28 } from "path";
 import { fileURLToPath } from "url";
 async function loadAllModels(forceRefresh = false) {
   if (!forceRefresh && existsSync20(ALL_MODELS_CACHE_PATH2)) {
@@ -48031,7 +48303,7 @@ async function loadAllModels(forceRefresh = false) {
       throw new Error(`API returned ${response.status}`);
     const data = await response.json();
     const models = data.data || [];
-    mkdirSync12(CLAUDISH_CACHE_DIR, { recursive: true });
+    mkdirSync13(CLAUDISH_CACHE_DIR, { recursive: true });
     writeFileSync13(ALL_MODELS_CACHE_PATH2, JSON.stringify({ lastUpdated: new Date().toISOString(), models }), "utf-8");
     return models;
   } catch {
@@ -48626,16 +48898,16 @@ Use with: run_prompt(model="${results2[0].model.id}", prompt="your prompt")`;
         const sp = session_path;
         for (const file2 of ["status.json", "manifest.json", "input.md"]) {
           try {
-            sessionData[file2] = readFileSync18(join27(sp, file2), "utf-8");
+            sessionData[file2] = readFileSync18(join28(sp, file2), "utf-8");
           } catch {}
         }
         try {
-          const errorDir = join27(sp, "errors");
+          const errorDir = join28(sp, "errors");
           if (existsSync20(errorDir)) {
             for (const f of readdirSync4(errorDir)) {
               if (f.endsWith(".log")) {
                 try {
-                  sessionData[`errors/${f}`] = readFileSync18(join27(errorDir, f), "utf-8");
+                  sessionData[`errors/${f}`] = readFileSync18(join28(errorDir, f), "utf-8");
                 } catch {}
               }
             }
@@ -48645,7 +48917,7 @@ Use with: run_prompt(model="${results2[0].model.id}", prompt="your prompt")`;
           for (const f of readdirSync4(sp)) {
             if (f.startsWith("response-") && f.endsWith(".md")) {
               try {
-                const content = readFileSync18(join27(sp, f), "utf-8");
+                const content = readFileSync18(join28(sp, f), "utf-8");
                 sessionData[f] = content.slice(0, 200) + (content.length > 200 ? "... (truncated)" : "");
               } catch {}
             }
@@ -48654,7 +48926,7 @@ Use with: run_prompt(model="${results2[0].model.id}", prompt="your prompt")`;
       }
       let version2 = "unknown";
       try {
-        const pkgPath = join27(__dirname2, "../package.json");
+        const pkgPath = join28(__dirname2, "../package.json");
         if (existsSync20(pkgPath)) {
           version2 = JSON.parse(readFileSync18(pkgPath, "utf-8")).version;
         }
@@ -48883,9 +49155,9 @@ Report manually at https://github.com/anthropics/claudish/issues${autoSendHint}`
     },
     group: "channel",
     handler: async (args) => {
-      const sessions = sessionManager.listSessions(args.include_completed);
+      const sessions2 = sessionManager.listSessions(args.include_completed);
       return {
-        content: [{ type: "text", text: JSON.stringify({ sessions }) }]
+        content: [{ type: "text", text: JSON.stringify({ sessions: sessions2 }) }]
       };
     }
   });
@@ -49054,9 +49326,9 @@ var init_mcp_server = __esm(() => {
   import_dotenv2 = __toESM(require_main(), 1);
   import_dotenv2.config({ quiet: true });
   __filename2 = fileURLToPath(import.meta.url);
-  __dirname2 = dirname8(__filename2);
-  CLAUDISH_CACHE_DIR = join27(homedir25(), ".claudish");
-  ALL_MODELS_CACHE_PATH2 = join27(CLAUDISH_CACHE_DIR, "all-models.json");
+  __dirname2 = dirname9(__filename2);
+  CLAUDISH_CACHE_DIR = join28(homedir26(), ".claudish");
+  ALL_MODELS_CACHE_PATH2 = join28(CLAUDISH_CACHE_DIR, "all-models.json");
   NEXT_STEP = {
     nonzero_exit: "read the evidence log, then retry or drop the model",
     timeout: "raise `timeout`, or pick a faster model",
@@ -49182,6 +49454,7 @@ var exports_behavior_command = {};
 __export(exports_behavior_command, {
   behaviorCommand: () => behaviorCommand
 });
+import { existsSync as existsSync22, readFileSync as readFileSync20, writeFileSync as writeFileSync14 } from "fs";
 function severityColor(sev) {
   if (sev === "fix")
     return green(sev);
@@ -49275,6 +49548,67 @@ Behavior divergence corpus
 `));
   }
 }
+function setTelemetryEnabled(value) {
+  const path = getConfigPath();
+  let cfg = {};
+  try {
+    if (existsSync22(path)) {
+      const parsed = JSON.parse(readFileSync20(path, "utf-8"));
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        cfg = parsed;
+      }
+    }
+  } catch {}
+  const behavior = cfg.behavior && typeof cfg.behavior === "object" && !Array.isArray(cfg.behavior) ? { ...cfg.behavior } : {};
+  behavior.telemetry = { enabled: value };
+  cfg.behavior = behavior;
+  writeFileSync14(path, `${JSON.stringify(cfg, null, 2)}
+`, "utf-8");
+}
+function showTelemetry(action, json2) {
+  if (action !== "status") {
+    setTelemetryEnabled(action === "enable");
+  }
+  const config3 = parseBehaviorConfig(loadConfig().behavior);
+  const on = config3.telemetry?.enabled === true;
+  let pending = 0;
+  try {
+    const path = outboxPath();
+    if (existsSync22(path)) {
+      pending = readFileSync20(path, "utf8").split(`
+`).filter(Boolean).length;
+    }
+  } catch {}
+  if (json2) {
+    console.log(JSON.stringify({ enabled: on, pendingReports: pending }, null, 2));
+    return;
+  }
+  console.log(bold2(`
+Behavior telemetry
+`));
+  console.log(`  status  : ${on ? green("enabled") : dim2("disabled")}`);
+  console.log(`  pending : ${pending} session report(s) awaiting delivery
+`);
+  if (!on) {
+    console.log("  Opting in shares which models violate Claude Code conventions,");
+    console.log(`  so rules can be written for models we cannot test ourselves.
+`);
+    console.log(dim2("  Sent    : model, provider, rule id, tool name, decision counts,"));
+    console.log(dim2("            a coarse context bucket, and categorical path relations"));
+    console.log(dim2("  Never   : file paths, argument values, prompts, code, model output,"));
+    console.log(dim2("            credentials, or repo/branch/project names"));
+    console.log(dim2("  Session : identified by a salted hash, unlinkable across sessions"));
+    console.log(dim2(`  Kept    : 12 months, then non-identifying weekly aggregates only
+`));
+    console.log(`  Enable with ${bold2("claudish behavior telemetry --enable")}
+`);
+    return;
+  }
+  console.log(dim2(`  Local journalling is always on and unaffected by this setting.
+`));
+  console.log(`  Disable with ${bold2("claudish behavior telemetry --disable")}
+`);
+}
 async function behaviorCommand(argv) {
   const json2 = argv.includes("--json");
   const write = argv.includes("--write");
@@ -49286,12 +49620,16 @@ async function behaviorCommand(argv) {
     case "corpus":
       showCorpus(write, json2);
       return;
+    case "telemetry":
+      showTelemetry(argv.includes("--enable") ? "enable" : argv.includes("--disable") ? "disable" : "status", json2);
+      return;
     default:
       console.error(`Unknown action "${action}".
 
 Usage:
-  claudish behavior rules  [--json]
-  claudish behavior corpus [--write] [--json]
+  claudish behavior rules     [--json]
+  claudish behavior corpus    [--write] [--json]
+  claudish behavior telemetry [--enable | --disable] [--json]
 `);
       process.exit(1);
   }
@@ -60706,7 +61044,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 readFileSync20, unlinkSync as unlinkSync6, writeFileSync as writeFileSync14 } from "fs";
+import { readFileSync as readFileSync21, unlinkSync as unlinkSync6, writeFileSync as writeFileSync15 } from "fs";
 import path from "path";
 import os from "os";
 import { randomUUID as randomUUID6 } from "crypto";
@@ -60815,14 +61153,14 @@ class ExternalEditor {
       if (Object.prototype.hasOwnProperty.call(this.fileOptions, "mode")) {
         opt.mode = this.fileOptions.mode;
       }
-      writeFileSync14(this.tempFile, this.text, opt);
+      writeFileSync15(this.tempFile, this.text, opt);
     } catch (createFileError) {
       throw new CreateFileError(createFileError);
     }
   }
   readTemporaryFile() {
     try {
-      const tempFileBuffer = readFileSync20(this.tempFile);
+      const tempFileBuffer = readFileSync21(this.tempFile);
       if (tempFileBuffer.length === 0) {
         this.text = "";
       } else {
@@ -61803,9 +62141,9 @@ var init_dist16 = __esm(() => {
 
 // src/auth/antigravity-oauth.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync22, unlinkSync as unlinkSync7 } from "fs";
-import { homedir as homedir26 } from "os";
-import { join as join28 } from "path";
+import { existsSync as existsSync23, unlinkSync as unlinkSync7 } from "fs";
+import { homedir as homedir27 } from "os";
+import { join as join29 } from "path";
 async function defaultSuggestModel() {
   try {
     const tok = readSharedAntigravityToken();
@@ -61926,8 +62264,8 @@ No session detected yet. Starting the Antigravity CLI interactively \u2014
   async logout(deps) {
     deleteSharedAntigravityToken(deps);
     try {
-      const tokenFile = join28(homedir26(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
-      if (existsSync22(tokenFile))
+      const tokenFile = join29(homedir27(), ".gemini", "antigravity-cli", "antigravity-oauth-token");
+      if (existsSync23(tokenFile))
         unlinkSync7(tokenFile);
     } catch {}
     log("[AntigravityOAuth] Antigravity session cleared (keychain + agy token file)");
@@ -62184,15 +62522,15 @@ async function geminiQuotaHandler() {
   }
 }
 async function codexQuotaHandler() {
-  const { readFileSync: readFileSync21, existsSync: existsSync23 } = await import("fs");
-  const { join: join29 } = await import("path");
-  const { homedir: homedir27 } = await import("os");
-  const credPath = join29(homedir27(), ".claudish", "codex-oauth.json");
-  if (!existsSync23(credPath)) {
+  const { readFileSync: readFileSync22, existsSync: existsSync24 } = await import("fs");
+  const { join: join30 } = await import("path");
+  const { homedir: homedir28 } = await import("os");
+  const credPath = join30(homedir28(), ".claudish", "codex-oauth.json");
+  if (!existsSync24(credPath)) {
     console.error(`${RED}No Codex credentials found.${R} Run: ${B}claudish login codex${R}`);
     process.exit(1);
   }
-  const creds = JSON.parse(readFileSync21(credPath, "utf-8"));
+  const creds = JSON.parse(readFileSync22(credPath, "utf-8"));
   let email3 = "";
   try {
     const parts = creds.access_token.split(".");
@@ -62244,9 +62582,9 @@ async function codexQuotaHandler() {
   }
   let modelSlugs = [];
   try {
-    const modelsPath = join29(homedir27(), ".codex", "models_cache.json");
-    if (existsSync23(modelsPath)) {
-      const cache2 = JSON.parse(readFileSync21(modelsPath, "utf-8"));
+    const modelsPath = join30(homedir28(), ".codex", "models_cache.json");
+    if (existsSync24(modelsPath)) {
+      const cache2 = JSON.parse(readFileSync22(modelsPath, "utf-8"));
       modelSlugs = (cache2.models || []).map((m) => m.slug || m.id).filter(Boolean);
     }
   } catch {}
@@ -63998,7 +64336,7 @@ var init_theme2 = __esm(() => {
   bold3 = createTextAttributes({ bold: true });
   A = {
     bold: bold3,
-    boldIf: (enabled) => enabled ? bold3 : undefined
+    boldIf: (enabled2) => enabled2 ? bold3 : undefined
   };
   LATENCY_BUCKETS = [
     { maxMs: 500, hex: "#1f8f3b" },
@@ -66134,22 +66472,22 @@ __export(exports_cli, {
 });
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync23,
-  mkdirSync as mkdirSync13,
-  readFileSync as readFileSync21,
+  existsSync as existsSync24,
+  mkdirSync as mkdirSync14,
+  readFileSync as readFileSync22,
   readdirSync as readdirSync5,
   unlinkSync as unlinkSync8,
-  writeFileSync as writeFileSync15
+  writeFileSync as writeFileSync16
 } from "fs";
-import { homedir as homedir27 } from "os";
-import { dirname as dirname9, join as join29 } from "path";
+import { homedir as homedir28 } from "os";
+import { dirname as dirname10, join as join30 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function getVersion3() {
   return VERSION;
 }
 function clearAllModelCaches() {
-  const cacheDir = join29(homedir27(), ".claudish");
-  if (!existsSync23(cacheDir))
+  const cacheDir = join30(homedir28(), ".claudish");
+  if (!existsSync24(cacheDir))
     return;
   const cachePatterns = ["pricing-cache.json", "recommended-models-cache.json"];
   let cleared = 0;
@@ -66157,7 +66495,7 @@ function clearAllModelCaches() {
     const files = readdirSync5(cacheDir);
     for (const file2 of files) {
       if (cachePatterns.includes(file2)) {
-        unlinkSync8(join29(cacheDir, file2));
+        unlinkSync8(join30(cacheDir, file2));
         cleared++;
       }
     }
@@ -66567,15 +66905,15 @@ Usage:  claudish --models --provider <slug>`);
     });
     config3.resolvedDefaultProvider = resolved;
     if (resolved.legacyAutoPromoted && !config3.quiet) {
-      const markerFile = join29(homedir27(), ".claudish", ".legacy-litellm-hint-shown");
-      if (!existsSync23(markerFile)) {
+      const markerFile = join30(homedir28(), ".claudish", ".legacy-litellm-hint-shown");
+      if (!existsSync24(markerFile)) {
         const hint = buildLegacyHint(resolved);
         if (hint) {
           console.error(hint);
         }
         try {
-          mkdirSync13(dirname9(markerFile), { recursive: true });
-          writeFileSync15(markerFile, new Date().toISOString(), "utf-8");
+          mkdirSync14(dirname10(markerFile), { recursive: true });
+          writeFileSync16(markerFile, new Date().toISOString(), "utf-8");
         } catch {}
       }
     }
@@ -67642,8 +67980,8 @@ ${h("MORE INFO")}
 }
 function printAIAgentGuide() {
   try {
-    const guidePath = join29(__dirname3, "../AI_AGENT_GUIDE.md");
-    const guideContent = readFileSync21(guidePath, "utf-8");
+    const guidePath = join30(__dirname3, "../AI_AGENT_GUIDE.md");
+    const guideContent = readFileSync22(guidePath, "utf-8");
     console.log(guideContent);
   } catch (error46) {
     console.error("Error reading AI Agent Guide:");
@@ -67659,19 +67997,19 @@ async function initializeClaudishSkill() {
   console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
 `);
   const cwd = process.cwd();
-  const claudeDir = join29(cwd, ".claude");
-  const skillsDir = join29(claudeDir, "skills");
-  const claudishSkillDir = join29(skillsDir, "claudish-usage");
-  const skillFile = join29(claudishSkillDir, "SKILL.md");
-  if (existsSync23(skillFile)) {
+  const claudeDir = join30(cwd, ".claude");
+  const skillsDir = join30(claudeDir, "skills");
+  const claudishSkillDir = join30(skillsDir, "claudish-usage");
+  const skillFile = join30(claudishSkillDir, "SKILL.md");
+  if (existsSync24(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 = join29(__dirname3, "../skills/claudish-usage/SKILL.md");
-  if (!existsSync23(sourceSkillPath)) {
+  const sourceSkillPath = join30(__dirname3, "../skills/claudish-usage/SKILL.md");
+  if (!existsSync24(sourceSkillPath)) {
     console.error("\u274C Error: Claudish skill file not found in installation.");
     console.error(`   Expected at: ${sourceSkillPath}`);
     console.error(`
@@ -67680,16 +68018,16 @@ async function initializeClaudishSkill() {
     process.exit(1);
   }
   try {
-    if (!existsSync23(claudeDir)) {
-      mkdirSync13(claudeDir, { recursive: true });
+    if (!existsSync24(claudeDir)) {
+      mkdirSync14(claudeDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/ directory");
     }
-    if (!existsSync23(skillsDir)) {
-      mkdirSync13(skillsDir, { recursive: true });
+    if (!existsSync24(skillsDir)) {
+      mkdirSync14(skillsDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
     }
-    if (!existsSync23(claudishSkillDir)) {
-      mkdirSync13(claudishSkillDir, { recursive: true });
+    if (!existsSync24(claudishSkillDir)) {
+      mkdirSync14(claudishSkillDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/claudish-usage/ directory");
     }
     copyFileSync2(sourceSkillPath, skillFile);
@@ -67761,7 +68099,7 @@ var init_cli = __esm(() => {
   init_routing_rules();
   init_provider_resolver();
   __filename3 = fileURLToPath2(import.meta.url);
-  __dirname3 = dirname9(__filename3);
+  __dirname3 = dirname10(__filename3);
 });
 
 // src/update-checker.ts
@@ -67773,33 +68111,33 @@ __export(exports_update_checker, {
   clearCache: () => clearCache,
   checkForUpdates: () => checkForUpdates
 });
-import { existsSync as existsSync24, mkdirSync as mkdirSync14, readFileSync as readFileSync22, unlinkSync as unlinkSync9, writeFileSync as writeFileSync16 } from "fs";
-import { homedir as homedir28, platform as platform2, tmpdir } from "os";
-import { join as join30 } from "path";
+import { existsSync as existsSync25, mkdirSync as mkdirSync15, readFileSync as readFileSync23, unlinkSync as unlinkSync9, writeFileSync as writeFileSync17 } from "fs";
+import { homedir as homedir29, platform as platform2, tmpdir } from "os";
+import { join as join31 } from "path";
 function getCacheFilePath() {
   let cacheDir;
   if (isWindows) {
-    const localAppData = process.env.LOCALAPPDATA || join30(homedir28(), "AppData", "Local");
-    cacheDir = join30(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join31(homedir29(), "AppData", "Local");
+    cacheDir = join31(localAppData, "claudish");
   } else {
-    cacheDir = join30(homedir28(), ".cache", "claudish");
+    cacheDir = join31(homedir29(), ".cache", "claudish");
   }
   try {
-    if (!existsSync24(cacheDir)) {
-      mkdirSync14(cacheDir, { recursive: true });
+    if (!existsSync25(cacheDir)) {
+      mkdirSync15(cacheDir, { recursive: true });
     }
-    return join30(cacheDir, "update-check.json");
+    return join31(cacheDir, "update-check.json");
   } catch {
-    return join30(tmpdir(), "claudish-update-check.json");
+    return join31(tmpdir(), "claudish-update-check.json");
   }
 }
 function readCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (!existsSync24(cachePath)) {
+    if (!existsSync25(cachePath)) {
       return null;
     }
-    const data = JSON.parse(readFileSync22(cachePath, "utf-8"));
+    const data = JSON.parse(readFileSync23(cachePath, "utf-8"));
     return data;
   } catch {
     return null;
@@ -67812,7 +68150,7 @@ function writeCache(latestVersion) {
       lastCheck: Date.now(),
       latestVersion
     };
-    writeFileSync16(cachePath, JSON.stringify(data), "utf-8");
+    writeFileSync17(cachePath, JSON.stringify(data), "utf-8");
   } catch {}
 }
 function isCacheValid(cache2) {
@@ -67822,7 +68160,7 @@ function isCacheValid(cache2) {
 function clearCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (existsSync24(cachePath)) {
+    if (existsSync25(cachePath)) {
       unlinkSync9(cachePath);
     }
   } catch {}
@@ -68707,15 +69045,15 @@ var init_local_liveness = __esm(() => {
 });
 
 // src/providers/probe-catalog.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync15, readFileSync as readFileSync23, writeFileSync as writeFileSync17 } from "fs";
-import { homedir as homedir29 } from "os";
-import { dirname as dirname10, join as join31 } from "path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync16, readFileSync as readFileSync24, writeFileSync as writeFileSync18 } from "fs";
+import { homedir as homedir30 } from "os";
+import { dirname as dirname11, join as join32 } from "path";
 function readProbeModelsCache(path2 = PROBE_MODELS_CACHE_PATH) {
-  if (!existsSync25(path2))
+  if (!existsSync26(path2))
     return null;
   let raw2;
   try {
-    raw2 = JSON.parse(readFileSync23(path2, "utf-8"));
+    raw2 = JSON.parse(readFileSync24(path2, "utf-8"));
   } catch {
     return null;
   }
@@ -68724,8 +69062,8 @@ function readProbeModelsCache(path2 = PROBE_MODELS_CACHE_PATH) {
   return raw2;
 }
 function writeProbeModelsCache(data, path2 = PROBE_MODELS_CACHE_PATH) {
-  mkdirSync15(dirname10(path2), { recursive: true });
-  writeFileSync17(path2, JSON.stringify(data), "utf-8");
+  mkdirSync16(dirname11(path2), { recursive: true });
+  writeFileSync18(path2, JSON.stringify(data), "utf-8");
 }
 function isCacheFresh(data, ttlMs = CACHE_TTL_MS4) {
   if (!data?.generatedAt)
@@ -68844,7 +69182,7 @@ function isValidResponse(raw2) {
 var PROBE_MODELS_URL = "https://us-central1-claudish-6da10.cloudfunctions.net/probeModels", CACHE_TTL_MS4, FETCH_TIMEOUT_MS3 = 15000, PROBE_MODELS_CACHE_PATH, _inFlight = null;
 var init_probe_catalog = __esm(() => {
   CACHE_TTL_MS4 = 60 * 60 * 1000;
-  PROBE_MODELS_CACHE_PATH = join31(homedir29(), ".claudish", "probe-models.json");
+  PROBE_MODELS_CACHE_PATH = join32(homedir30(), ".claudish", "probe-models.json");
 });
 
 // src/tui/constants.ts
@@ -71532,8 +71870,8 @@ function ProvidersContent({
     let statusText = p.isLocal ? isReady ? "enabled" : "disabled" : isReady ? "ready" : "not set";
     if (p.isLocal) {
       const live = localLiveness[p.catalogName];
-      const enabled = providerAuthSource(p, config3) !== null;
-      if (enabled) {
+      const enabled2 = providerAuthSource(p, config3) !== null;
+      if (enabled2) {
         if (live === "running") {
           statusFg = C.green;
           statusText = "running";
@@ -75195,17 +75533,17 @@ __export(exports_claude_runner, {
 import { spawn as spawn4 } from "child_process";
 import {
   closeSync as closeSync5,
-  existsSync as existsSync26,
-  mkdirSync as mkdirSync16,
+  existsSync as existsSync27,
+  mkdirSync as mkdirSync17,
   openSync as openSync5,
-  readFileSync as readFileSync24,
+  readFileSync as readFileSync25,
   readdirSync as readdirSync6,
   statSync as statSync5,
   unlinkSync as unlinkSync10,
-  writeFileSync as writeFileSync18
+  writeFileSync as writeFileSync19
 } from "fs";
-import { homedir as homedir30, tmpdir as tmpdir2 } from "os";
-import { dirname as dirname11, join as join32 } from "path";
+import { homedir as homedir31, tmpdir as tmpdir2 } from "os";
+import { dirname as dirname12, join as join33 } from "path";
 import { isatty } from "tty";
 function releaseTerminalIsolation() {
   if (!restoreTerminal)
@@ -75240,16 +75578,16 @@ function isProxyAuthMode(config3) {
 }
 function managedSettingsPath() {
   if (isWindows2()) {
-    return join32(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
+    return join33(process.env.PROGRAMDATA || "C:\\ProgramData", "ClaudeCode", "managed-settings.json");
   }
   if (process.platform === "darwin") {
     return "/Library/Application Support/ClaudeCode/managed-settings.json";
   }
   return "/etc/claude-code/managed-settings.json";
 }
-function managedSettingsForcesClaudeAi(readFile2 = readFileSync24) {
+function managedSettingsForcesClaudeAi(readFile3 = readFileSync25) {
   try {
-    const raw2 = readFile2(managedSettingsPath(), "utf-8");
+    const raw2 = readFile3(managedSettingsPath(), "utf-8");
     const parsed = JSON.parse(raw2);
     return parsed.forceLoginMethod === "claudeai";
   } catch {
@@ -75261,9 +75599,9 @@ function isWindows2() {
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join32(homeDir, ".claudish");
+  const claudishDir = join33(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join32(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join33(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const script = `
 const fs = require('fs');
@@ -75381,13 +75719,13 @@ process.stdin.on('end', () => {
   }
 });
 `;
-  writeFileSync18(scriptPath, script, "utf-8");
+  writeFileSync19(scriptPath, script, "utf-8");
   return scriptPath;
 }
 function initializeTokenFile(tokenFilePath) {
   try {
-    mkdirSync16(dirname11(tokenFilePath), { recursive: true });
-    writeFileSync18(tokenFilePath, JSON.stringify({
+    mkdirSync17(dirname12(tokenFilePath), { recursive: true });
+    writeFileSync19(tokenFilePath, JSON.stringify({
       input_tokens: 0,
       output_tokens: 0,
       total_tokens: 0,
@@ -75418,7 +75756,7 @@ function cleanupStaleTokenFiles(dir, now = Date.now(), maxAgeMs = STALE_TOKEN_FI
     if (!name.startsWith("tokens-") || !name.endsWith(".json"))
       continue;
     scanned++;
-    const full = join32(dir, name);
+    const full = join33(dir, name);
     try {
       if (statSync5(full).mtimeMs >= cutoff)
         continue;
@@ -75435,7 +75773,7 @@ function parseSettingsArg(value) {
   if (value.trimStart().startsWith("{")) {
     return JSON.parse(value);
   }
-  return JSON.parse(readFileSync24(value, "utf-8"));
+  return JSON.parse(readFileSync25(value, "utf-8"));
 }
 function parseSettingsArgSafe(value) {
   try {
@@ -75447,13 +75785,13 @@ function parseSettingsArgSafe(value) {
 }
 function userSettingsFileCandidates(cwd) {
   return [
-    join32(homedir30(), ".claude", "settings.json"),
-    join32(cwd, ".claude", "settings.json"),
-    join32(cwd, ".claude", "settings.local.json")
+    join33(homedir31(), ".claude", "settings.json"),
+    join33(cwd, ".claude", "settings.json"),
+    join33(cwd, ".claude", "settings.local.json")
   ];
 }
 function discoverUserStatusLineCommand(claudeArgs = [], cwd = process.cwd()) {
-  const sources = userSettingsFileCandidates(cwd).filter((file2) => existsSync26(file2));
+  const sources = userSettingsFileCandidates(cwd).filter((file2) => existsSync27(file2));
   const idx = claudeArgs.indexOf("--settings");
   const settingsArg = idx === -1 ? undefined : claudeArgs[idx + 1];
   if (settingsArg)
@@ -75490,13 +75828,13 @@ function buildChainedStatusCommand(userCommand, claudishBody, claudishSegment) {
 }
 function createTempSettingsFile(_modelDisplay, port, proxyAuthMode, userStatusLineCommand) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join32(homeDir, ".claudish");
+  const claudishDir = join33(homeDir, ".claudish");
   try {
-    mkdirSync16(claudishDir, { recursive: true });
+    mkdirSync17(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join32(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join32(claudishDir, `tokens-${port}.json`);
+  const tempPath = join33(claudishDir, `settings-${timestamp}.json`);
+  const tokenFilePath = join33(claudishDir, `tokens-${port}.json`);
   cleanupStaleTokenFiles(claudishDir);
   initializeTokenFile(tokenFilePath);
   let statusCommand;
@@ -75527,7 +75865,7 @@ function createTempSettingsFile(_modelDisplay, port, proxyAuthMode, userStatusLi
     padding: 0
   };
   const settings = buildClaudishSettingsOverlay(statusLine, proxyAuthMode);
-  writeFileSync18(tempPath, JSON.stringify(settings, null, 2), "utf-8");
+  writeFileSync19(tempPath, JSON.stringify(settings, null, 2), "utf-8");
   return { path: tempPath, statusLine, tokenFilePath };
 }
 function buildClaudishSettingsOverlay(statusLine, proxyAuthMode) {
@@ -75552,7 +75890,7 @@ function mergeUserSettingsIfPresent(config3, tempSettingsPath, statusLine, proxy
     if (proxyAuthMode && !("forceLoginMethod" in userSettings)) {
       userSettings.forceLoginMethod = "console";
     }
-    writeFileSync18(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
+    writeFileSync19(tempSettingsPath, JSON.stringify(userSettings, null, 2), "utf-8");
   } catch {
     if (!config3.quiet) {
       console.warn(`[claudish] Warning: could not merge user settings: ${userSettingsValue}`);
@@ -75763,8 +76101,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 = homedir30();
-    const localPath = isWindows2() ? join32(home, ".claude", "local", "claude.exe") : join32(home, ".claude", "local", "claude");
+    const home = homedir31();
+    const localPath = isWindows2() ? join33(home, ".claude", "local", "claude.exe") : join33(home, ".claude", "local", "claude");
     console.error(`  export CLAUDE_PATH=${localPath}`);
     process.exit(1);
   }
@@ -75844,23 +76182,23 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
 async function findClaudeBinary() {
   const isWindows3 = process.platform === "win32";
   if (process.env.CLAUDE_PATH) {
-    if (existsSync26(process.env.CLAUDE_PATH)) {
+    if (existsSync27(process.env.CLAUDE_PATH)) {
       return process.env.CLAUDE_PATH;
     }
   }
-  const home = homedir30();
-  const localPath = isWindows3 ? join32(home, ".claude", "local", "claude.exe") : join32(home, ".claude", "local", "claude");
-  if (existsSync26(localPath)) {
+  const home = homedir31();
+  const localPath = isWindows3 ? join33(home, ".claude", "local", "claude.exe") : join33(home, ".claude", "local", "claude");
+  if (existsSync27(localPath)) {
     return localPath;
   }
   if (isWindows3) {
     const windowsPaths = [
-      join32(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join32(home, ".npm-global", "claude.cmd"),
-      join32(home, "node_modules", ".bin", "claude.cmd")
+      join33(home, "AppData", "Roaming", "npm", "claude.cmd"),
+      join33(home, ".npm-global", "claude.cmd"),
+      join33(home, "node_modules", ".bin", "claude.cmd")
     ];
     for (const path2 of windowsPaths) {
-      if (existsSync26(path2)) {
+      if (existsSync27(path2)) {
         return path2;
       }
     }
@@ -75868,14 +76206,14 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join32(home, ".npm-global/bin/claude"),
-      join32(home, ".local/bin/claude"),
-      join32(home, "node_modules/.bin/claude"),
+      join33(home, ".npm-global/bin/claude"),
+      join33(home, ".local/bin/claude"),
+      join33(home, "node_modules/.bin/claude"),
       "/data/data/com.termux/files/usr/bin/claude",
-      join32(home, "../usr/bin/claude")
+      join33(home, "../usr/bin/claude")
     ];
     for (const path2 of commonPaths) {
-      if (existsSync26(path2)) {
+      if (existsSync27(path2)) {
         return path2;
       }
     }
@@ -75935,18 +76273,18 @@ __export(exports_diag_output, {
   NullDiagOutput: () => NullDiagOutput,
   LogFileDiagOutput: () => LogFileDiagOutput
 });
-import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync17, unlinkSync as unlinkSync11, writeFileSync as writeFileSync19 } from "fs";
-import { homedir as homedir31 } from "os";
-import { join as join33 } from "path";
+import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync18, unlinkSync as unlinkSync11, writeFileSync as writeFileSync20 } from "fs";
+import { homedir as homedir32 } from "os";
+import { join as join34 } from "path";
 function getClaudishDir() {
-  const dir = join33(homedir31(), ".claudish");
+  const dir = join34(homedir32(), ".claudish");
   try {
-    mkdirSync17(dir, { recursive: true });
+    mkdirSync18(dir, { recursive: true });
   } catch {}
   return dir;
 }
 function getDiagLogPath() {
-  return join33(getClaudishDir(), `diag-${process.pid}.log`);
+  return join34(getClaudishDir(), `diag-${process.pid}.log`);
 }
 
 class LogFileDiagOutput {
@@ -75955,7 +76293,7 @@ class LogFileDiagOutput {
   constructor() {
     this.logPath = getDiagLogPath();
     try {
-      writeFileSync19(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
+      writeFileSync20(this.logPath, `--- claudish diag session ${new Date().toISOString()} ---
 `);
     } catch {}
     this.stream = createWriteStream3(this.logPath, { flags: "a" });
@@ -76157,9 +76495,9 @@ __export(exports_team_grid, {
 });
 import { spawn as spawn5 } from "child_process";
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync27, readFileSync as readFileSync25, writeFileSync as writeFileSync20 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync26, writeFileSync as writeFileSync21 } from "fs";
 import { connect as netConnect } from "net";
-import { dirname as dirname12, join as join34 } from "path";
+import { dirname as dirname13, join as join35 } from "path";
 import { setTimeout as wait } from "timers/promises";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function resolveRouteInfo(modelId) {
@@ -76252,21 +76590,21 @@ function buildPaneHeader(model, prompt, bg) {
 }
 function findMagmuxBinary() {
   const thisFile = fileURLToPath3(import.meta.url);
-  const thisDir = dirname12(thisFile);
-  const pkgRoot = join34(thisDir, "..");
+  const thisDir = dirname13(thisFile);
+  const pkgRoot = join35(thisDir, "..");
   const platform3 = process.platform;
   const arch = process.arch;
-  const bundledMagmux = join34(pkgRoot, "native", `magmux-${platform3}-${arch}`);
-  if (existsSync27(bundledMagmux))
+  const bundledMagmux = join35(pkgRoot, "native", `magmux-${platform3}-${arch}`);
+  if (existsSync28(bundledMagmux))
     return bundledMagmux;
   try {
     const pkgName = `@claudish/magmux-${platform3}-${arch}`;
     let searchDir = pkgRoot;
     for (let i = 0;i < 5; i++) {
-      const candidate = join34(searchDir, "node_modules", pkgName, "bin", "magmux");
-      if (existsSync27(candidate))
+      const candidate = join35(searchDir, "node_modules", pkgName, "bin", "magmux");
+      if (existsSync28(candidate))
         return candidate;
-      const parent = dirname12(searchDir);
+      const parent = dirname13(searchDir);
       if (parent === searchDir)
         break;
       searchDir = parent;
@@ -76283,7 +76621,7 @@ function findMagmuxBinary() {
 async function subscribeToMagmux(sockPath, onEvent) {
   let client = null;
   for (let attempt = 0;attempt < 40; attempt++) {
-    if (existsSync27(sockPath)) {
+    if (existsSync28(sockPath)) {
       try {
         client = await new Promise((resolve4, reject) => {
           const s = netConnect(sockPath);
@@ -76370,9 +76708,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 = join34(sessionPath, "gridfile.txt");
-  const prompt = readFileSync25(join34(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
-  const rawPrompt = readFileSync25(join34(sessionPath, "input.md"), "utf-8");
+  const gridfilePath = join35(sessionPath, "gridfile.txt");
+  const prompt = readFileSync26(join35(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
+  const rawPrompt = readFileSync26(join35(sessionPath, "input.md"), "utf-8");
   const usedBannerColors = new Set;
   const gridLines = Object.entries(manifest.models).map(([anonId]) => {
     const model = manifest.models[anonId].model;
@@ -76383,7 +76721,7 @@ async function runWithGrid(sessionPath, models, input, opts) {
     const header = buildPaneHeader(model, rawPrompt, bg);
     return `${header} claudish --model ${model} -y --quiet '${prompt}'`;
   });
-  writeFileSync20(gridfilePath, `${gridLines.join(`
+  writeFileSync21(gridfilePath, `${gridLines.join(`
 `)}
 `, "utf-8");
   const magmuxPath = findMagmuxBinary();
@@ -76403,8 +76741,8 @@ async function runWithGrid(sessionPath, models, input, opts) {
   });
   const [{ results: results2 }] = await Promise.all([subscription, procExit]);
   const status = buildTeamStatus(manifest, startedAt, results2?.panes ?? null);
-  const statusPath = join34(sessionPath, "status.json");
-  writeFileSync20(statusPath, JSON.stringify(status, null, 2), "utf-8");
+  const statusPath = join35(sessionPath, "status.json");
+  writeFileSync21(statusPath, JSON.stringify(status, null, 2), "utf-8");
   return status;
 }
 var BANNER_BG_COLORS;
@@ -76427,8 +76765,8 @@ var init_team_grid = __esm(() => {
 init_op_source();
 init_startup_trace();
 var import_dotenv3 = __toESM(require_main(), 1);
-import { existsSync as existsSync28, readFileSync as readFileSync26 } from "fs";
-import { join as join35, resolve as resolve4 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync27 } from "fs";
+import { join as join36, resolve as resolve4 } from "path";
 import_dotenv3.config({ quiet: true });
 function classifyStartupKind() {
   const argv = process.argv.slice(2);
@@ -76527,7 +76865,7 @@ async function applyConfigOverride() {
   const { planConfigOverride: planConfigOverride2, setConfigFileOverride: setConfigFileOverride2 } = await Promise.resolve().then(() => exports_config_override);
   const plan = planConfigOverride2(process.argv.slice(2), process.env, {
     resolve: resolve4,
-    exists: existsSync28
+    exists: existsSync29
   });
   if (plan.kind === "none")
     return;
@@ -76675,14 +77013,14 @@ async function runCli() {
     if (cliConfig.team && cliConfig.team.length > 0) {
       let prompt = cliConfig.claudeArgs.join(" ");
       if (cliConfig.inputFile) {
-        prompt = readFileSync26(cliConfig.inputFile, "utf-8");
+        prompt = readFileSync27(cliConfig.inputFile, "utf-8");
       }
       if (!prompt.trim()) {
         console.error("Error: --team requires a prompt (positional args or -f <file>)");
         process.exit(1);
       }
       const mode = cliConfig.teamMode ?? "default";
-      const sessionPath = join35(process.cwd(), `.claudish-team-${Date.now()}`);
+      const sessionPath = join36(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);
@@ -76692,9 +77030,9 @@ async function runCli() {
         });
         const result = { ...status2, responses: {} };
         for (const anonId of Object.keys(status2.models)) {
-          const responsePath = join35(sessionPath, `response-${anonId}.md`);
+          const responsePath = join36(sessionPath, `response-${anonId}.md`);
           try {
-            const raw2 = readFileSync26(responsePath, "utf-8").trim();
+            const raw2 = readFileSync27(responsePath, "utf-8").trim();
             try {
               result.responses[anonId] = JSON.parse(raw2);
             } catch {