claudish 7.33.0 → 7.35.0

package/dist/index.js

@@ -651,7 +651,7 @@ var init_onepassword_config = __esm(() => {
 });
 
 // src/version.ts
-var VERSION = "7.33.0";
+var VERSION = "7.35.0";
 
 // src/logger.ts
 var exports_logger = {};
@@ -27783,7 +27783,7 @@ var init_provider_definitions = __esm(() => {
       apiKeyEnvVar: "",
       apiKeyDescription: "Antigravity (shared OAuth token)",
       apiKeyUrl: "https://antigravity.google/",
-      oauthLoginSlug: "gemini",
+      oauthLoginSlug: "antigravity",
       shortcuts: ["ag", "antigravity", "go"],
       shortestPrefix: "ag",
       legacyPrefixes: [
@@ -28373,31 +28373,25 @@ function locateAgyBinary() {
   const fallback = join8(homedir8(), ".local", "bin", "agy");
   return existsSync6(fallback) ? fallback : null;
 }
-function defaultExtractCreds() {
+function defaultDeleteStore() {
+  if (process.platform !== "darwin")
+    return;
+  try {
+    execFileSync("security", ["delete-generic-password", "-s", KC_SERVICE, "-a", KC_ACCOUNT], {
+      stdio: ["ignore", "ignore", "ignore"]
+    });
+  } catch {}
+}
+function defaultRunAgyRefresh() {
   const agy = locateAgyBinary();
-  if (!agy) {
-    logStderr("[Antigravity] Could not locate the `agy` binary \u2014 self-refresh is unavailable.");
-    return [];
-  }
-  let dump;
+  if (!agy)
+    return;
   try {
-    dump = execFileSync("strings", [agy], {
-      encoding: "utf8",
-      maxBuffer: 128 * 1024 * 1024
+    execFileSync(agy, ["models"], {
+      stdio: ["ignore", "ignore", "ignore"],
+      timeout: AGY_REFRESH_TIMEOUT_MS
     });
-  } catch {
-    logStderr("[Antigravity] `strings` failed on the agy binary \u2014 self-refresh is unavailable.");
-    return [];
-  }
-  const clientIds = Array.from(new Set(dump.match(/[0-9]{6,}-[a-z0-9]+\.apps\.googleusercontent\.com/g) ?? []));
-  const secrets = Array.from(new Set(dump.match(/GOCSPX-[A-Za-z0-9_-]{20,}/g) ?? []));
-  const combos = [];
-  for (const clientId of clientIds) {
-    for (const clientSecret of secrets) {
-      combos.push({ clientId, clientSecret });
-    }
-  }
-  return combos;
+  } catch {}
 }
 function parseRecord(raw) {
   if (!raw)
@@ -28417,9 +28411,6 @@ function parseRecord(raw) {
     return null;
   }
 }
-function encodeRecord(rec) {
-  return PREFIX + Buffer.from(JSON.stringify(rec), "utf8").toString("base64");
-}
 function readSharedAntigravityToken(deps = defaultDeps) {
   const rec = parseRecord(deps.readStore());
   return rec ? rec.token : null;
@@ -28437,14 +28428,9 @@ function hasSharedAntigravityToken(deps = defaultDeps) {
   cachedHasToken = { at: now, value };
   return value;
 }
-function writeSharedAntigravityToken(tok, deps = defaultDeps) {
-  const existing = parseRecord(deps.readStore());
-  const base = existing ?? { token: tok };
-  const merged = {
-    ...base,
-    token: { ...base.token, ...tok }
-  };
-  deps.writeStore(encodeRecord(merged));
+function deleteSharedAntigravityToken(deps = defaultDeps) {
+  (deps.deleteStore ?? defaultDeleteStore)();
+  _resetAntigravityTokenState();
 }
 function needsRefresh(tok, now) {
   const expMs = Date.parse(tok.expiry);
@@ -28452,57 +28438,25 @@ function needsRefresh(tok, now) {
     return true;
   return now >= expMs - EXPIRY_SKEW_MS;
 }
-async function refreshToken(tok, deps) {
-  const combos = cachedCred ? [cachedCred] : deps.extractCreds();
-  if (combos.length === 0) {
-    throw new Error("[Antigravity] Access token expired and no OAuth client credentials could be extracted " + "from the `agy` binary to refresh it. Re-run the Antigravity CLI to refresh your session, " + "or use g@<model> with GEMINI_API_KEY.");
-  }
-  let lastStatus = 0;
-  let lastBody = "";
-  for (const cred of combos) {
-    const res = await deps.fetch(REFRESH_ENDPOINT, {
-      method: "POST",
-      headers: { "Content-Type": "application/x-www-form-urlencoded" },
-      body: new URLSearchParams({
-        client_id: cred.clientId,
-        client_secret: cred.clientSecret,
-        refresh_token: tok.refresh_token,
-        grant_type: "refresh_token"
-      })
-    });
-    if (res.ok) {
-      cachedCred = cred;
-      const j = await res.json();
-      const expiry = new Date(deps.now() + j.expires_in * 1000).toISOString();
-      return {
-        access_token: j.access_token,
-        token_type: tok.token_type || "Bearer",
-        refresh_token: j.refresh_token || tok.refresh_token,
-        expiry
-      };
-    }
-    lastStatus = res.status;
-    lastBody = await res.text().catch(() => "");
-  }
-  throw new Error(`[Antigravity] Token refresh failed for all ${combos.length} client-cred combo(s) ` + `(last HTTP ${lastStatus}${lastBody ? `: ${lastBody.slice(0, 200)}` : ""}). ` + "Re-run the Antigravity CLI to refresh your session, or use g@<model> with GEMINI_API_KEY.");
-}
 async function resolveValidToken(deps) {
   if (process.platform !== "darwin") {
     throw new Error("[Antigravity] The shared Antigravity token store is macOS-only for now. " + "Use g@<model> with GEMINI_API_KEY on this platform.");
   }
   const rec = parseRecord(deps.readStore());
   if (!rec) {
-    throw new Error("[Antigravity] No Antigravity session found. Install Antigravity and sign in " + "(the `agy` CLI), or use g@<model> with GEMINI_API_KEY " + "(get one at https://aistudio.google.com/app/apikey).");
+    throw new Error("[Antigravity] No Antigravity session found. Sign in with `claudish login antigravity`, " + "or use g@<model> with GEMINI_API_KEY " + "(get one at https://aistudio.google.com/app/apikey).");
+  }
+  if (!needsRefresh(rec.token, deps.now())) {
+    return rec.token.access_token;
   }
-  const tok = rec.token;
-  if (!needsRefresh(tok, deps.now())) {
-    return tok.access_token;
+  log("[Antigravity] Access token expired/near-expiry \u2014 asking the Antigravity CLI to refresh.");
+  deps.runAgyRefresh();
+  const refreshedRec = parseRecord(deps.readStore());
+  if (refreshedRec && !needsRefresh(refreshedRec.token, deps.now())) {
+    log("[Antigravity] Shared token refreshed by the Antigravity CLI.");
+    return refreshedRec.token.access_token;
   }
-  log("[Antigravity] Access token expired/near-expiry \u2014 refreshing.");
-  const refreshed = await refreshToken(tok, deps);
-  writeSharedAntigravityToken(refreshed, deps);
-  log("[Antigravity] Token refreshed and written back to the shared store.");
-  return refreshed.access_token;
+  throw new Error("[Antigravity] Antigravity session expired and couldn't be refreshed. " + "Run `claudish login antigravity` (installs/authenticates the Antigravity CLI).");
 }
 function getValidAntigravityAccessToken(deps = defaultDeps) {
   if (inFlight)
@@ -28512,14 +28466,18 @@ function getValidAntigravityAccessToken(deps = defaultDeps) {
   });
   return inFlight;
 }
-var KC_SERVICE = "gemini", KC_ACCOUNT = "antigravity", PREFIX = "go-keyring-base64:", REFRESH_ENDPOINT = "https://oauth2.googleapis.com/token", EXPIRY_SKEW_MS = 120000, defaultDeps, cachedHasToken = null, HAS_TOKEN_TTL_MS = 5000, cachedCred = null, inFlight = null;
+function _resetAntigravityTokenState() {
+  inFlight = null;
+  cachedHasToken = null;
+}
+var KC_SERVICE = "gemini", KC_ACCOUNT = "antigravity", PREFIX = "go-keyring-base64:", EXPIRY_SKEW_MS = 120000, AGY_REFRESH_TIMEOUT_MS = 40000, defaultDeps, cachedHasToken = null, HAS_TOKEN_TTL_MS = 5000, inFlight = null;
 var init_antigravity_token = __esm(() => {
   init_logger();
   defaultDeps = {
     readStore: defaultReadStore,
     writeStore: defaultWriteStore,
-    extractCreds: defaultExtractCreds,
-    fetch: (input, init) => fetch(input, init),
+    deleteStore: defaultDeleteStore,
+    runAgyRefresh: defaultRunAgyRefresh,
     now: () => Date.now()
   };
 });
@@ -31574,6 +31532,7 @@ var init_routing_hints = __esm(() => {
     kimi: { loginFlag: "login kimi", apiKeyEnvVar: "MOONSHOT_API_KEY" },
     google: { loginFlag: "login gemini", apiKeyEnvVar: "GEMINI_API_KEY" },
     "gemini-codeassist": { loginFlag: "login gemini", apiKeyEnvVar: "GEMINI_API_KEY" },
+    antigravity: { loginFlag: "login antigravity" },
     openai: { apiKeyEnvVar: "OPENAI_API_KEY" },
     "openai-codex": { loginFlag: "login codex", apiKeyEnvVar: "OPENAI_CODEX_API_KEY" },
     minimax: { apiKeyEnvVar: "MINIMAX_API_KEY" },
@@ -38442,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, {
@@ -38633,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 {
@@ -38650,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;
@@ -38754,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;
@@ -38882,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,
@@ -38891,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,
@@ -38985,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) ?? [];
@@ -39032,6 +39257,7 @@ var init_engine = __esm(() => {
   init_config();
   init_harness();
   init_journal();
+  init_aggregate();
   MAX_OBSERVED_CHARS = 64 * 1024;
 });
 
@@ -39165,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;
@@ -39246,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 };
@@ -39307,6 +39533,8 @@ var init_behavior = __esm(() => {
   init_digest();
   init_client();
   init_corpus();
+  init_aggregate();
+  init_upload();
   BUILTIN_RULES = [...PLAN_MODE_RULES];
   hookRules = [];
 });
@@ -39877,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() {
@@ -39919,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;
@@ -39992,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 {
@@ -40130,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;
 }
@@ -40398,7 +40626,7 @@ function initTelemetry(_config) {
   } catch {
     consentEnabled = false;
   }
-  sessionId = randomBytes4(8).toString("hex");
+  sessionId = randomBytes5(8).toString("hex");
   claudishVersion = getVersion();
   installMethod = detectInstallMethod();
 }
@@ -40708,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;
@@ -40721,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 {
@@ -42376,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);
@@ -42530,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}`);
@@ -43047,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 };
@@ -43399,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,
@@ -43454,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) {
@@ -45211,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";
@@ -46092,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) {
@@ -46782,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))
@@ -46842,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;
 });
 
@@ -47339,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);
@@ -47499,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 {}
 }
@@ -47526,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);
@@ -47592,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"));
@@ -47620,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) => [
@@ -47636,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"));
@@ -47652,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 = () => {
@@ -47665,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",
@@ -47855,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--) {
@@ -47881,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) {
@@ -47944,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;
     }
@@ -47996,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
 
@@ -48051,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)) {
@@ -48072,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 {
@@ -48667,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 {}
               }
             }
@@ -48686,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 {}
             }
@@ -48695,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;
         }
@@ -48924,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 }) }]
       };
     }
   });
@@ -49095,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",
@@ -49223,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);
@@ -49316,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");
@@ -49327,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);
   }
@@ -60747,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";
@@ -60856,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 {
@@ -61842,6 +62139,163 @@ var init_dist16 = __esm(() => {
   init_dist15();
 });
 
+// src/auth/antigravity-oauth.ts
+import { spawnSync as spawnSync3 } from "child_process";
+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();
+    if (!tok)
+      return "<model>";
+    const { projectId } = await setupAntigravityUser(tok.access_token);
+    const { servedIds, defaultId } = await getServedAntigravityModels(tok.access_token, projectId);
+    return defaultId || servedIds[0] || "<model>";
+  } catch {
+    return "<model>";
+  }
+}
+function printManualInstall() {
+  console.log("\nInstall the Antigravity CLI, then retry `claudish login antigravity`:");
+  console.log(`  ${INSTALL_CMD}`);
+  console.log(`  Docs: ${INSTALL_DOCS}`);
+}
+async function defaultConfirmInstall() {
+  const { confirm } = await Promise.resolve().then(() => (init_dist16(), exports_dist));
+  return confirm({
+    message: `Install the Antigravity CLI now? (runs: ${INSTALL_CMD})`,
+    default: true
+  });
+}
+function defaultRunInstall() {
+  const res = spawnSync3("bash", ["-c", INSTALL_CMD], { stdio: "inherit" });
+  return !res.error && res.status === 0;
+}
+function defaultRunAgyAuth(agyPath, interactive) {
+  if (interactive) {
+    spawnSync3(agyPath, [], { stdio: "inherit" });
+  } else {
+    spawnSync3(agyPath, ["-p", "hello", "--print-timeout", "3m"], { stdio: "inherit" });
+  }
+}
+async function pollForToken(deps) {
+  const deadline = deps.now() + deps.timing.graceMs;
+  for (;; ) {
+    const tok = deps.readToken();
+    if (tok)
+      return tok;
+    if (deps.now() >= deadline)
+      return null;
+    const remaining = deadline - deps.now();
+    await deps.sleep(Math.min(deps.timing.intervalMs, Math.max(0, remaining)));
+  }
+}
+
+class AntigravityOAuth {
+  static instance = null;
+  static getInstance() {
+    if (!AntigravityOAuth.instance) {
+      AntigravityOAuth.instance = new AntigravityOAuth;
+    }
+    return AntigravityOAuth.instance;
+  }
+  constructor() {}
+  async login(depsOverride = {}) {
+    const deps = { ...defaultLoginDeps, ...depsOverride };
+    log("[AntigravityOAuth] Starting agy-delegated login");
+    if (deps.hasToken()) {
+      console.log(`\u2705 Already authenticated with Antigravity. Use: claudish --model ag@${await (deps.suggestModel ?? defaultSuggestModel)()}`);
+      return deps.exit(0);
+    }
+    let agyPath = deps.locateAgy();
+    if (!agyPath) {
+      console.log("\nThe Antigravity CLI (`agy`) is required to sign in to Antigravity.");
+      console.log(`claudish delegates Antigravity sign-in to agy \u2014 agy holds the current OAuth secret
+` + "and writes the session to the shared keychain store that claudish reads.");
+      if (!deps.isInteractive()) {
+        printManualInstall();
+        return deps.exit(0);
+      }
+      const proceed = await deps.confirmInstall();
+      if (!proceed) {
+        printManualInstall();
+        return deps.exit(0);
+      }
+      console.log(`
+Installing the Antigravity CLI\u2026
+`);
+      if (!deps.runInstall()) {
+        console.log(`
+\u274C Antigravity CLI installation failed.`);
+        printManualInstall();
+        return deps.exit(0);
+      }
+      agyPath = deps.locateAgy();
+      if (!agyPath) {
+        console.log(`
+\u274C Antigravity CLI still not found after install.`);
+        printManualInstall();
+        return deps.exit(0);
+      }
+    }
+    console.log(`
+Launching the Antigravity CLI to sign in \u2014 complete the sign-in in your browser.
+` + `claudish will detect the session automatically.
+`);
+    deps.runAgyAuth(agyPath, false);
+    let token = await pollForToken(deps);
+    if (!token) {
+      console.log(`
+No session detected yet. Starting the Antigravity CLI interactively \u2014
+` + "sign in, then exit agy (its `/quit` command or Ctrl-C) to return here.\n");
+      deps.runAgyAuth(agyPath, true);
+      token = await pollForToken(deps);
+    }
+    if (token) {
+      deps.onAuthenticated();
+      console.log(`
+\u2705 Authenticated with Antigravity. Use: claudish --model ag@${await (deps.suggestModel ?? defaultSuggestModel)()}`);
+      return deps.exit(0);
+    }
+    console.log("\nNo Antigravity session detected. Run `agy` and sign in, then retry `claudish login antigravity`.");
+    return deps.exit(0);
+  }
+  async logout(deps) {
+    deleteSharedAntigravityToken(deps);
+    try {
+      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)");
+  }
+}
+var INSTALL_CMD = "curl -fsSL https://antigravity.google/cli/install.sh | bash", INSTALL_DOCS = "https://antigravity.google/docs/cli/install", defaultLoginDeps;
+var init_antigravity_oauth = __esm(() => {
+  init_logger();
+  init_antigravity_token();
+  init_gemini_oauth();
+  defaultLoginDeps = {
+    locateAgy: locateAgyBinary,
+    hasToken: () => readSharedAntigravityToken() != null,
+    readToken: () => {
+      _resetAntigravityTokenState();
+      return readSharedAntigravityToken();
+    },
+    suggestModel: defaultSuggestModel,
+    confirmInstall: defaultConfirmInstall,
+    runInstall: defaultRunInstall,
+    runAgyAuth: defaultRunAgyAuth,
+    onAuthenticated: () => _resetAntigravityTokenState(),
+    isInteractive: () => Boolean(process.stdin.isTTY),
+    now: () => Date.now(),
+    sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+    exit: (code) => process.exit(code),
+    timing: { graceMs: 1e4, intervalMs: 500 }
+  };
+});
+
 // src/auth/auth-commands.ts
 var exports_auth_commands = {};
 __export(exports_auth_commands, {
@@ -61849,7 +62303,7 @@ __export(exports_auth_commands, {
   loginCommand: () => loginCommand
 });
 function getAuthStatus(provider) {
-  const hasCredentials = provider.registryKeys.some((k) => hasOAuthCredentials(k));
+  const hasCredentials = provider.registryKeys.some((k) => hasOAuthCredentials(k)) || provider.name === "antigravity" && hasSharedAntigravityToken();
   return hasCredentials ? "logged in" : "not logged in";
 }
 async function selectProvider(action) {
@@ -61906,11 +62360,20 @@ async function logoutCommand(providerArg) {
 var AUTH_PROVIDERS;
 var init_auth_commands = __esm(() => {
   init_dist16();
+  init_antigravity_oauth();
+  init_antigravity_token();
   init_codex_oauth();
   init_gemini_oauth();
   init_kimi_oauth();
   init_oauth_registry();
   AUTH_PROVIDERS = [
+    {
+      name: "antigravity",
+      displayName: "Antigravity",
+      prefix: "ag@, antigravity@",
+      getInstance: () => AntigravityOAuth.getInstance(),
+      registryKeys: ["antigravity"]
+    },
     {
       name: "gemini",
       displayName: "Gemini Code Assist",
@@ -62059,15 +62522,15 @@ async function geminiQuotaHandler() {
   }
 }
 async function codexQuotaHandler() {
-  const { readFileSync: readFileSync21, existsSync: existsSync22 } = await import("fs");
-  const { join: join28 } = await import("path");
-  const { homedir: homedir26 } = await import("os");
-  const credPath = join28(homedir26(), ".claudish", "codex-oauth.json");
-  if (!existsSync22(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(".");
@@ -62119,9 +62582,9 @@ async function codexQuotaHandler() {
   }
   let modelSlugs = [];
   try {
-    const modelsPath = join28(homedir26(), ".codex", "models_cache.json");
-    if (existsSync22(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 {}
@@ -63407,7 +63870,7 @@ function annotateOAuthHint(result, provider, isOAuth) {
     return result;
   if (result.state === "live")
     return result;
-  const loginCommand2 = provider === "gemini-codeassist" ? "claudish login gemini" : provider === "vertex" ? "gcloud auth application-default login" : undefined;
+  const loginCommand2 = provider === "gemini-codeassist" ? "claudish login gemini" : provider === "antigravity" ? "claudish login antigravity" : provider === "vertex" ? "gcloud auth application-default login" : undefined;
   if (!loginCommand2)
     return result;
   if (result.httpStatus === 403)
@@ -63873,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" },
@@ -66009,22 +66472,22 @@ __export(exports_cli, {
 });
 import {
   copyFileSync as copyFileSync2,
-  existsSync as existsSync22,
-  mkdirSync as mkdirSync13,
-  readFileSync as readFileSync21,
+  existsSync as existsSync24,
+  mkdirSync as mkdirSync14,
+  readFileSync as readFileSync22,
   readdirSync as readdirSync5,
-  unlinkSync as unlinkSync7,
-  writeFileSync as writeFileSync15
+  unlinkSync as unlinkSync8,
+  writeFileSync as writeFileSync16
 } from "fs";
-import { homedir as homedir26 } from "os";
-import { dirname as dirname9, join as join28 } 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 = join28(homedir26(), ".claudish");
-  if (!existsSync22(cacheDir))
+  const cacheDir = join30(homedir28(), ".claudish");
+  if (!existsSync24(cacheDir))
     return;
   const cachePatterns = ["pricing-cache.json", "recommended-models-cache.json"];
   let cleared = 0;
@@ -66032,7 +66495,7 @@ function clearAllModelCaches() {
     const files = readdirSync5(cacheDir);
     for (const file2 of files) {
       if (cachePatterns.includes(file2)) {
-        unlinkSync7(join28(cacheDir, file2));
+        unlinkSync8(join30(cacheDir, file2));
         cleared++;
       }
     }
@@ -66442,15 +66905,15 @@ Usage:  claudish --models --provider <slug>`);
     });
     config3.resolvedDefaultProvider = resolved;
     if (resolved.legacyAutoPromoted && !config3.quiet) {
-      const markerFile = join28(homedir26(), ".claudish", ".legacy-litellm-hint-shown");
-      if (!existsSync22(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 {}
       }
     }
@@ -67517,8 +67980,8 @@ ${h("MORE INFO")}
 }
 function printAIAgentGuide() {
   try {
-    const guidePath = join28(__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:");
@@ -67534,19 +67997,19 @@ async function initializeClaudishSkill() {
   console.log(`\uD83D\uDD27 Initializing Claudish skill in current project...
 `);
   const cwd = process.cwd();
-  const claudeDir = join28(cwd, ".claude");
-  const skillsDir = join28(claudeDir, "skills");
-  const claudishSkillDir = join28(skillsDir, "claudish-usage");
-  const skillFile = join28(claudishSkillDir, "SKILL.md");
-  if (existsSync22(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 = join28(__dirname3, "../skills/claudish-usage/SKILL.md");
-  if (!existsSync22(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(`
@@ -67555,16 +68018,16 @@ async function initializeClaudishSkill() {
     process.exit(1);
   }
   try {
-    if (!existsSync22(claudeDir)) {
-      mkdirSync13(claudeDir, { recursive: true });
+    if (!existsSync24(claudeDir)) {
+      mkdirSync14(claudeDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/ directory");
     }
-    if (!existsSync22(skillsDir)) {
-      mkdirSync13(skillsDir, { recursive: true });
+    if (!existsSync24(skillsDir)) {
+      mkdirSync14(skillsDir, { recursive: true });
       console.log("\uD83D\uDCC1 Created .claude/skills/ directory");
     }
-    if (!existsSync22(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);
@@ -67636,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
@@ -67648,33 +68111,33 @@ __export(exports_update_checker, {
   clearCache: () => clearCache,
   checkForUpdates: () => checkForUpdates
 });
-import { existsSync as existsSync23, mkdirSync as mkdirSync14, readFileSync as readFileSync22, unlinkSync as unlinkSync8, writeFileSync as writeFileSync16 } from "fs";
-import { homedir as homedir27, platform as platform2, tmpdir } from "os";
-import { join as join29 } 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 || join29(homedir27(), "AppData", "Local");
-    cacheDir = join29(localAppData, "claudish");
+    const localAppData = process.env.LOCALAPPDATA || join31(homedir29(), "AppData", "Local");
+    cacheDir = join31(localAppData, "claudish");
   } else {
-    cacheDir = join29(homedir27(), ".cache", "claudish");
+    cacheDir = join31(homedir29(), ".cache", "claudish");
   }
   try {
-    if (!existsSync23(cacheDir)) {
-      mkdirSync14(cacheDir, { recursive: true });
+    if (!existsSync25(cacheDir)) {
+      mkdirSync15(cacheDir, { recursive: true });
     }
-    return join29(cacheDir, "update-check.json");
+    return join31(cacheDir, "update-check.json");
   } catch {
-    return join29(tmpdir(), "claudish-update-check.json");
+    return join31(tmpdir(), "claudish-update-check.json");
   }
 }
 function readCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (!existsSync23(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;
@@ -67687,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) {
@@ -67697,8 +68160,8 @@ function isCacheValid(cache2) {
 function clearCache() {
   try {
     const cachePath = getCacheFilePath();
-    if (existsSync23(cachePath)) {
-      unlinkSync8(cachePath);
+    if (existsSync25(cachePath)) {
+      unlinkSync9(cachePath);
     }
   } catch {}
 }
@@ -68582,15 +69045,15 @@ var init_local_liveness = __esm(() => {
 });
 
 // src/providers/probe-catalog.ts
-import { existsSync as existsSync24, mkdirSync as mkdirSync15, readFileSync as readFileSync23, writeFileSync as writeFileSync17 } from "fs";
-import { homedir as homedir28 } from "os";
-import { dirname as dirname10, join as join30 } 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 (!existsSync24(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;
   }
@@ -68599,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)
@@ -68719,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 = join30(homedir28(), ".claudish", "probe-models.json");
+  PROBE_MODELS_CACHE_PATH = join32(homedir30(), ".claudish", "probe-models.json");
 });
 
 // src/tui/constants.ts
@@ -71407,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";
@@ -74917,13 +75380,15 @@ var exports_tui = {};
 __export(exports_tui, {
   startConfigTui: () => startConfigTui
 });
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync as spawnSync4 } from "child_process";
 import { createCliRenderer as createCliRenderer2 } from "@opentui/core";
 import { createRoot as createRoot2 } from "@opentui/react";
 import { jsxDEV as jsxDEV17 } from "@opentui/react/jsx-dev-runtime";
 async function startConfigTui() {
   setStderrQuiet(true);
-  const loginRequest = { slug: null };
+  const loginRequest = {
+    slug: null
+  };
   const requestLogin = (slug) => {
     loginRequest.slug = slug;
   };
@@ -74943,7 +75408,7 @@ async function startConfigTui() {
     console.log(`
 Launching: claudish login ${slug}
 `);
-    const result = spawnSync3(process.argv[0], [process.argv[1], "login", slug], {
+    const result = spawnSync4(process.argv[0], [process.argv[1], "login", slug], {
       stdio: "inherit"
     });
     if (result.error) {
@@ -74955,7 +75420,10 @@ Launching: claudish login ${slug}
 \u274C Login exited with status ${result.status}
 `);
     } else {
-      if (slug === "gemini") {
+      if (slug === "antigravity") {
+        _resetAntigravityTokenState();
+        invalidateProbeProxyHandlers("antigravity");
+      } else if (slug === "gemini") {
         reloadGeminiCredentials();
         invalidateProbeProxyHandlers("google");
         invalidateProbeProxyHandlers("gemini-codeassist");
@@ -74976,6 +75444,7 @@ Returning to config\u2026
 }
 var isDirectRun = false;
 var init_tui = __esm(() => {
+  init_antigravity_token();
   init_codex_oauth();
   init_gemini_oauth();
   init_kimi_oauth();
@@ -75064,17 +75533,17 @@ __export(exports_claude_runner, {
 import { spawn as spawn4 } from "child_process";
 import {
   closeSync as closeSync5,
-  existsSync as existsSync25,
-  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 unlinkSync9,
-  writeFileSync as writeFileSync18
+  unlinkSync as unlinkSync10,
+  writeFileSync as writeFileSync19
 } from "fs";
-import { homedir as homedir29, tmpdir as tmpdir2 } from "os";
-import { dirname as dirname11, join as join31 } 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)
@@ -75109,16 +75578,16 @@ function isProxyAuthMode(config3) {
 }
 function managedSettingsPath() {
   if (isWindows2()) {
-    return join31(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 {
@@ -75130,9 +75599,9 @@ function isWindows2() {
 }
 function createStatusLineScript(tokenFilePath) {
   const homeDir = process.env.HOME || process.env.USERPROFILE || tmpdir2();
-  const claudishDir = join31(homeDir, ".claudish");
+  const claudishDir = join33(homeDir, ".claudish");
   const timestamp = Date.now();
-  const scriptPath = join31(claudishDir, `status-${timestamp}.js`);
+  const scriptPath = join33(claudishDir, `status-${timestamp}.js`);
   const escapedTokenPath = tokenFilePath.replace(/\\/g, "\\\\");
   const script = `
 const fs = require('fs');
@@ -75250,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,
@@ -75287,11 +75756,11 @@ function cleanupStaleTokenFiles(dir, now = Date.now(), maxAgeMs = STALE_TOKEN_FI
     if (!name.startsWith("tokens-") || !name.endsWith(".json"))
       continue;
     scanned++;
-    const full = join31(dir, name);
+    const full = join33(dir, name);
     try {
       if (statSync5(full).mtimeMs >= cutoff)
         continue;
-      unlinkSync9(full);
+      unlinkSync10(full);
       removed++;
     } catch {}
   }
@@ -75304,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 {
@@ -75316,13 +75785,13 @@ function parseSettingsArgSafe(value) {
 }
 function userSettingsFileCandidates(cwd) {
   return [
-    join31(homedir29(), ".claude", "settings.json"),
-    join31(cwd, ".claude", "settings.json"),
-    join31(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) => existsSync25(file2));
+  const sources = userSettingsFileCandidates(cwd).filter((file2) => existsSync27(file2));
   const idx = claudeArgs.indexOf("--settings");
   const settingsArg = idx === -1 ? undefined : claudeArgs[idx + 1];
   if (settingsArg)
@@ -75359,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 = join31(homeDir, ".claudish");
+  const claudishDir = join33(homeDir, ".claudish");
   try {
-    mkdirSync16(claudishDir, { recursive: true });
+    mkdirSync17(claudishDir, { recursive: true });
   } catch {}
   const timestamp = Date.now();
-  const tempPath = join31(claudishDir, `settings-${timestamp}.json`);
-  const tokenFilePath = join31(claudishDir, `tokens-${port}.json`);
+  const tempPath = join33(claudishDir, `settings-${timestamp}.json`);
+  const tokenFilePath = join33(claudishDir, `tokens-${port}.json`);
   cleanupStaleTokenFiles(claudishDir);
   initializeTokenFile(tokenFilePath);
   let statusCommand;
@@ -75396,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) {
@@ -75421,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}`);
@@ -75632,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 = homedir29();
-    const localPath = isWindows2() ? join31(home, ".claude", "local", "claude.exe") : join31(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);
   }
@@ -75684,7 +76153,7 @@ Or set CLAUDE_PATH to your custom installation:`);
   });
   releaseTerminalIsolation();
   try {
-    unlinkSync9(tempSettingsPath);
+    unlinkSync10(tempSettingsPath);
   } catch {}
   return exitCode;
 }
@@ -75704,7 +76173,7 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
         } catch {}
       }
       try {
-        unlinkSync9(tempSettingsPath);
+        unlinkSync10(tempSettingsPath);
       } catch {}
       process.exit(0);
     });
@@ -75713,23 +76182,23 @@ function setupSignalHandlers(proc, tempSettingsPath, quiet, onCleanup) {
 async function findClaudeBinary() {
   const isWindows3 = process.platform === "win32";
   if (process.env.CLAUDE_PATH) {
-    if (existsSync25(process.env.CLAUDE_PATH)) {
+    if (existsSync27(process.env.CLAUDE_PATH)) {
       return process.env.CLAUDE_PATH;
     }
   }
-  const home = homedir29();
-  const localPath = isWindows3 ? join31(home, ".claude", "local", "claude.exe") : join31(home, ".claude", "local", "claude");
-  if (existsSync25(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 = [
-      join31(home, "AppData", "Roaming", "npm", "claude.cmd"),
-      join31(home, ".npm-global", "claude.cmd"),
-      join31(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 (existsSync25(path2)) {
+      if (existsSync27(path2)) {
         return path2;
       }
     }
@@ -75737,14 +76206,14 @@ async function findClaudeBinary() {
     const commonPaths = [
       "/usr/local/bin/claude",
       "/opt/homebrew/bin/claude",
-      join31(home, ".npm-global/bin/claude"),
-      join31(home, ".local/bin/claude"),
-      join31(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",
-      join31(home, "../usr/bin/claude")
+      join33(home, "../usr/bin/claude")
     ];
     for (const path2 of commonPaths) {
-      if (existsSync25(path2)) {
+      if (existsSync27(path2)) {
         return path2;
       }
     }
@@ -75804,18 +76273,18 @@ __export(exports_diag_output, {
   NullDiagOutput: () => NullDiagOutput,
   LogFileDiagOutput: () => LogFileDiagOutput
 });
-import { createWriteStream as createWriteStream3, mkdirSync as mkdirSync17, unlinkSync as unlinkSync10, writeFileSync as writeFileSync19 } from "fs";
-import { homedir as homedir30 } from "os";
-import { join as join32 } 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 = join32(homedir30(), ".claudish");
+  const dir = join34(homedir32(), ".claudish");
   try {
-    mkdirSync17(dir, { recursive: true });
+    mkdirSync18(dir, { recursive: true });
   } catch {}
   return dir;
 }
 function getDiagLogPath() {
-  return join32(getClaudishDir(), `diag-${process.pid}.log`);
+  return join34(getClaudishDir(), `diag-${process.pid}.log`);
 }
 
 class LogFileDiagOutput {
@@ -75824,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" });
@@ -75843,7 +76312,7 @@ class LogFileDiagOutput {
       this.stream.end();
     } catch {}
     try {
-      unlinkSync10(this.logPath);
+      unlinkSync11(this.logPath);
     } catch {}
   }
   getLogPath() {
@@ -76026,9 +76495,9 @@ __export(exports_team_grid, {
 });
 import { spawn as spawn5 } from "child_process";
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync26, 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 join33 } 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) {
@@ -76121,21 +76590,21 @@ function buildPaneHeader(model, prompt, bg) {
 }
 function findMagmuxBinary() {
   const thisFile = fileURLToPath3(import.meta.url);
-  const thisDir = dirname12(thisFile);
-  const pkgRoot = join33(thisDir, "..");
+  const thisDir = dirname13(thisFile);
+  const pkgRoot = join35(thisDir, "..");
   const platform3 = process.platform;
   const arch = process.arch;
-  const bundledMagmux = join33(pkgRoot, "native", `magmux-${platform3}-${arch}`);
-  if (existsSync26(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 = join33(searchDir, "node_modules", pkgName, "bin", "magmux");
-      if (existsSync26(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;
@@ -76152,7 +76621,7 @@ function findMagmuxBinary() {
 async function subscribeToMagmux(sockPath, onEvent) {
   let client = null;
   for (let attempt = 0;attempt < 40; attempt++) {
-    if (existsSync26(sockPath)) {
+    if (existsSync28(sockPath)) {
       try {
         client = await new Promise((resolve4, reject) => {
           const s = netConnect(sockPath);
@@ -76239,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 = join33(sessionPath, "gridfile.txt");
-  const prompt = readFileSync25(join33(sessionPath, "input.md"), "utf-8").replace(/'/g, "'\\''").replace(/\n/g, " ");
-  const rawPrompt = readFileSync25(join33(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;
@@ -76252,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();
@@ -76272,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 = join33(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;
@@ -76296,8 +76765,8 @@ var init_team_grid = __esm(() => {
 init_op_source();
 init_startup_trace();
 var import_dotenv3 = __toESM(require_main(), 1);
-import { existsSync as existsSync27, readFileSync as readFileSync26 } from "fs";
-import { join as join34, 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);
@@ -76396,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: existsSync27
+    exists: existsSync29
   });
   if (plan.kind === "none")
     return;
@@ -76544,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 = join34(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);
@@ -76561,9 +77030,9 @@ async function runCli() {
         });
         const result = { ...status2, responses: {} };
         for (const anonId of Object.keys(status2.models)) {
-          const responsePath = join34(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 {