fleetlens 0.15.3 → 0.15.4

package/dist/daemon-worker.js

@@ -8,40 +8,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/usage/storage.ts
-import { appendFileSync, mkdirSync, readFileSync as readFileSync2, existsSync } from "node:fs";
-import { dirname } from "node:path";
-function appendSnapshot(filePath, snapshot) {
-  mkdirSync(dirname(filePath), { recursive: true });
-  appendFileSync(filePath, JSON.stringify(snapshot) + "\n", "utf8");
-}
-function readSnapshots(filePath) {
-  if (!existsSync(filePath)) return [];
-  const content = readFileSync2(filePath, "utf8");
-  const snapshots = [];
-  for (const line of content.split("\n")) {
-    if (!line.trim()) continue;
-    try {
-      snapshots.push(JSON.parse(line));
-    } catch {
-    }
-  }
-  return snapshots;
-}
-function latestClaudeCodeSnapshot(filePath) {
-  const all = readSnapshots(filePath);
-  for (let i = all.length - 1; i >= 0; i--) {
-    const s = all[i];
-    if (!s.agent || s.agent === "claude-code") return s;
-  }
-  return null;
-}
-var init_storage = __esm({
-  "src/usage/storage.ts"() {
-    "use strict";
-  }
-});
-
 // ../parser/dist/analytics.js
 function toLocalDay(ms) {
   const d = new Date(ms);
@@ -641,7 +607,7 @@ function getAgentMetadata(kind) {
 function isAgentKind(s) {
   return typeof s === "string" && KNOWN_AGENT_KINDS.has(s);
 }
-var CLAUDE_CODE_METADATA, CODEX_METADATA, GEMINI_METADATA, ANTIGRAVITY_METADATA, COWORK_METADATA, agentMetadata, KNOWN_AGENT_KINDS;
+var CLAUDE_CODE_METADATA, CODEX_METADATA, GEMINI_METADATA, ANTIGRAVITY_METADATA, COWORK_METADATA, ZAI_METADATA, agentMetadata, KNOWN_AGENT_KINDS;
 var init_agent_metadata = __esm({
   "../parser/dist/agent-metadata.js"() {
     "use strict";
@@ -680,12 +646,20 @@ var init_agent_metadata = __esm({
       accentColor: "rgb(217, 119, 87)",
       iconChar: "\u2318"
     };
+    ZAI_METADATA = {
+      kind: "zai",
+      displayName: "Z.ai",
+      shortLabel: "Z.ai",
+      accentColor: "rgb(59, 130, 246)",
+      iconChar: "Z"
+    };
     agentMetadata = [
       CLAUDE_CODE_METADATA,
       CODEX_METADATA,
       GEMINI_METADATA,
       ANTIGRAVITY_METADATA,
-      COWORK_METADATA
+      COWORK_METADATA,
+      ZAI_METADATA
     ];
     KNOWN_AGENT_KINDS = new Set(agentMetadata.map((m) => m.kind));
   }
@@ -1427,9 +1401,9 @@ var init_parser = __esm({
 });
 
 // ../parser/dist/git-project.js
-import { existsSync as existsSync2, readFileSync as readFileSync3, realpathSync, statSync } from "node:fs";
+import { existsSync, readFileSync as readFileSync2, realpathSync, statSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { basename, dirname as dirname2, isAbsolute, join as join2, resolve } from "node:path";
+import { basename, dirname, isAbsolute, join as join2, resolve } from "node:path";
 function resolveGitDir(root, dotGitText) {
   const m = dotGitText.match(/^gitdir:\s*(.+)\s*$/m);
   if (!m)
@@ -1439,9 +1413,9 @@ function resolveGitDir(root, dotGitText) {
 }
 function resolveCommonDir(gitDir) {
   const file = join2(gitDir, "commondir");
-  if (!existsSync2(file))
+  if (!existsSync(file))
     return void 0;
-  const common = readFileSync3(file, "utf8").trim();
+  const common = readFileSync2(file, "utf8").trim();
   if (!common)
     return void 0;
   return isAbsolute(common) ? common : resolve(gitDir, common);
@@ -1453,7 +1427,7 @@ function dotGitInfoFor(root) {
     return null;
   if (st.isDirectory())
     return { root, gitDir: dotGit, commonDir: dotGit };
-  const gitDir = resolveGitDir(root, readFileSync3(dotGit, "utf8"));
+  const gitDir = resolveGitDir(root, readFileSync2(dotGit, "utf8"));
   if (!gitDir)
     return { root };
   return { root, gitDir, commonDir: resolveCommonDir(gitDir) };
@@ -1466,13 +1440,13 @@ function nearestDotGit(start) {
   if (!start || !isAbsolute(start))
     return null;
   const boundary = walkBoundary(start);
-  for (let dir = start.replace(/\/+$/, "") || start; ; dir = dirname2(dir)) {
+  for (let dir = start.replace(/\/+$/, "") || start; ; dir = dirname(dir)) {
     if (dir === boundary)
       return null;
     const info = dotGitInfoFor(dir);
     if (info)
       return info;
-    const parent = dirname2(dir);
+    const parent = dirname(dir);
     if (parent === dir)
       return null;
   }
@@ -1510,18 +1484,18 @@ function remoteFor(git) {
   if (!dir)
     return void 0;
   const config = join2(dir, "config");
-  if (!existsSync2(config))
+  if (!existsSync(config))
     return void 0;
-  const url = originUrl(readFileSync3(config, "utf8"));
+  const url = originUrl(readFileSync2(config, "utf8"));
   return url ? parseRemote(url) : void 0;
 }
 function headBranch(gitDir) {
   if (!gitDir)
     return void 0;
   const head = join2(gitDir, "HEAD");
-  if (!existsSync2(head))
+  if (!existsSync(head))
     return void 0;
-  const t = readFileSync3(head, "utf8").trim();
+  const t = readFileSync2(head, "utf8").trim();
   const m = t.match(/^ref:\s*refs\/heads\/(.+)$/);
   return m ? m[1] : `detached @ ${t.slice(0, 7)}`;
 }
@@ -1529,21 +1503,21 @@ function defaultBranch(commonDir) {
   if (!commonDir)
     return void 0;
   const head = join2(commonDir, "refs", "remotes", "origin", "HEAD");
-  if (existsSync2(head)) {
-    const m = readFileSync3(head, "utf8").trim().match(/refs\/remotes\/origin\/(.+)$/);
+  if (existsSync(head)) {
+    const m = readFileSync2(head, "utf8").trim().match(/refs\/remotes\/origin\/(.+)$/);
     if (m)
       return m[1];
   }
   const packed = join2(commonDir, "packed-refs");
-  if (existsSync2(packed)) {
-    const m = readFileSync3(packed, "utf8").match(/refs\/remotes\/origin\/(\S+)/);
+  if (existsSync(packed)) {
+    const m = readFileSync2(packed, "utf8").match(/refs\/remotes\/origin\/(\S+)/);
     if (m && m[1] !== "HEAD")
       return m[1];
   }
   return void 0;
 }
 function readGitFolder(path7) {
-  if (!existsSync2(path7))
+  if (!existsSync(path7))
     return { exists: false, isWorktree: false };
   try {
     const git = nearestDotGit(realpathOrSelf(path7));
@@ -1565,7 +1539,7 @@ function readGitFolder(path7) {
 function projectRootFromCommonDir(commonDir) {
   if (!commonDir)
     return void 0;
-  return basename(commonDir) === ".git" ? dirname2(commonDir) : void 0;
+  return basename(commonDir) === ".git" ? dirname(commonDir) : void 0;
 }
 function realpathOrSelf(p) {
   try {
@@ -3138,13 +3112,16 @@ async function getLatestCodexUsage(opts = {}) {
       const fiveResetUnix = numberOf(primary?.resets_at);
       const sevenResetUnix = numberOf(secondary?.resets_at);
       const planType = typeof rl.plan_type === "string" ? rl.plan_type : null;
+      const nowMs = Date.now();
+      const fiveExpired = fiveResetUnix !== void 0 && nowMs > fiveResetUnix * 1e3;
+      const sevenExpired = sevenResetUnix !== void 0 && nowMs > sevenResetUnix * 1e3;
       return {
         five_hour: {
-          utilization: fivePct ?? null,
+          utilization: fiveExpired ? 0 : fivePct ?? null,
           resets_at: fiveResetUnix !== void 0 ? new Date(fiveResetUnix * 1e3).toISOString() : null
         },
         seven_day: {
-          utilization: sevenPct ?? null,
+          utilization: sevenExpired ? 0 : sevenPct ?? null,
           resets_at: sevenResetUnix !== void 0 ? new Date(sevenResetUnix * 1e3).toISOString() : null
         },
         plan_type: planType,
@@ -4420,7 +4397,7 @@ var init_cowork = __esm({
 });
 
 // ../parser/dist/team-config.js
-import { readFileSync as readFileSync4, writeFileSync, unlinkSync, mkdirSync as mkdirSync2, renameSync } from "node:fs";
+import { readFileSync as readFileSync3, writeFileSync, unlinkSync, mkdirSync, renameSync } from "node:fs";
 import { join as join3 } from "node:path";
 function shouldSyncProject(projectKey2, sp) {
   if (!sp)
@@ -4434,14 +4411,14 @@ function shouldSyncProject(projectKey2, sp) {
 function readTeamConfig(dir) {
   const d = dir ?? cclensHome();
   try {
-    return JSON.parse(readFileSync4(join3(d, CONFIG_FILE), "utf8"));
+    return JSON.parse(readFileSync3(join3(d, CONFIG_FILE), "utf8"));
   } catch {
     return null;
   }
 }
 function writeTeamConfig(config, dir) {
   const d = dir ?? cclensHome();
-  mkdirSync2(d, { recursive: true });
+  mkdirSync(d, { recursive: true });
   const tmp = join3(d, `${CONFIG_FILE}.${process.pid}.tmp`);
   writeFileSync(tmp, JSON.stringify(config, null, 2), { mode: 384 });
   renameSync(tmp, join3(d, CONFIG_FILE));
@@ -4482,6 +4459,7 @@ __export(fs_exports, {
   RICH_ROLLUP_SCHEMA_VERSION: () => RICH_ROLLUP_SCHEMA_VERSION,
   agentSources: () => agentSources,
   antigravitySessionLocalDay: () => antigravitySessionLocalDay,
+  appendUsageSnapshot: () => appendUsageSnapshot,
   buildCalibrationCurve: () => buildCalibrationCurve,
   cacheStats: () => cacheStats,
   cclensHome: () => cclensHome,
@@ -4515,6 +4493,7 @@ __export(fs_exports, {
   loadTeamForSession: () => loadTeamForSession,
   loadUsageByDay: () => loadUsageByDay,
   loadWorkflowAgentDetail: () => loadWorkflowAgentDetail,
+  pruneUsageAgent: () => pruneUsageAgent,
   readGitFolder: () => readGitFolder,
   readJsonlFile: () => readJsonlFile,
   readTeamConfig: () => readTeamConfig,
@@ -4524,7 +4503,7 @@ __export(fs_exports, {
   walkJsonlFiles: () => walkJsonlFiles,
   writeTeamConfig: () => writeTeamConfig
 });
-import { promises as fs6 } from "node:fs";
+import { promises as fs6, existsSync as existsSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2, appendFileSync, mkdirSync as mkdirSync2 } from "node:fs";
 import os6 from "node:os";
 import path6 from "node:path";
 function cclensHome() {
@@ -4570,6 +4549,27 @@ async function getAnySession(id) {
 function usageLogPath() {
   return cclensPath("usage.jsonl");
 }
+function appendUsageSnapshot(snapshot) {
+  const p = usageLogPath();
+  mkdirSync2(path6.dirname(p), { recursive: true });
+  appendFileSync(p, JSON.stringify(snapshot) + "\n", "utf8");
+}
+function pruneUsageAgent(agent) {
+  const p = usageLogPath();
+  if (!existsSync2(p))
+    return;
+  const kept = readFileSync4(p, "utf8").split("\n").filter((line) => {
+    if (!line.trim())
+      return false;
+    try {
+      return JSON.parse(line).agent !== agent;
+    } catch {
+      return true;
+    }
+  });
+  mkdirSync2(path6.dirname(p), { recursive: true });
+  writeFileSync2(p, kept.join("\n") + (kept.length ? "\n" : ""), "utf8");
+}
 async function loadUsageByDay(start, end) {
   let raw;
   try {
@@ -4862,6 +4862,53 @@ var init_fs = __esm({
   }
 });
 
+// src/usage/storage.ts
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync3, existsSync as existsSync4 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+function appendSnapshot(filePath, snapshot) {
+  mkdirSync3(dirname2(filePath), { recursive: true });
+  appendFileSync2(filePath, JSON.stringify(snapshot) + "\n", "utf8");
+}
+function readSnapshots(filePath) {
+  if (!existsSync4(filePath)) return [];
+  const content = readFileSync6(filePath, "utf8");
+  const snapshots = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      snapshots.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return snapshots;
+}
+function pruneAgent(filePath, agent) {
+  if (!existsSync4(filePath)) return;
+  const kept = readFileSync6(filePath, "utf8").split("\n").filter((line) => {
+    if (!line.trim()) return false;
+    try {
+      return JSON.parse(line).agent !== agent;
+    } catch {
+      return true;
+    }
+  });
+  mkdirSync3(dirname2(filePath), { recursive: true });
+  writeFileSync3(filePath, kept.join("\n") + (kept.length ? "\n" : ""), "utf8");
+}
+function latestClaudeCodeSnapshot(filePath) {
+  const all = readSnapshots(filePath);
+  for (let i = all.length - 1; i >= 0; i--) {
+    const s = all[i];
+    if (!s.agent || s.agent === "claude-code") return s;
+  }
+  return null;
+}
+var init_storage = __esm({
+  "src/usage/storage.ts"() {
+    "use strict";
+  }
+});
+
 // ../parser/dist/types.js
 var init_types = __esm({
   "../parser/dist/types.js"() {
@@ -5279,6 +5326,7 @@ __export(dist_exports, {
   RATE_PER_PCT: () => RATE_PER_PCT,
   RATE_PER_PCT_5H: () => RATE_PER_PCT_5H,
   RATE_PER_PCT_7D: () => RATE_PER_PCT_7D,
+  ZAI_METADATA: () => ZAI_METADATA,
   agentMetadata: () => agentMetadata,
   aggregateConcurrency: () => aggregateConcurrency,
   buildGanttDay: () => buildGanttDay,
@@ -5347,7 +5395,7 @@ __export(file_probe_exports, {
   probeArtifactSignals: () => probeArtifactSignals
 });
 import { createHash } from "node:crypto";
-import { existsSync as existsSync7, readdirSync as readdirSync3, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync9, readdirSync as readdirSync3, statSync as statSync5 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { join as join8, relative, resolve as resolve3, sep } from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
@@ -5357,15 +5405,15 @@ function pathHash(relPath) {
 function defaultScanRoots(extraRoots = []) {
   const roots = [];
   const home = join8(homedir3(), ".claude");
-  if (existsSync7(home)) roots.push({ root: home, label: "user" });
+  if (existsSync9(home)) roots.push({ root: home, label: "user" });
   for (const e of extraRoots) {
     const r = resolve3(e, ".claude");
-    if (existsSync7(r) && r !== home) roots.push({ root: r, label: "project" });
+    if (existsSync9(r) && r !== home) roots.push({ root: r, label: "project" });
   }
   return roots;
 }
 function listMarkdownFiles(dir) {
-  if (!existsSync7(dir)) return [];
+  if (!existsSync9(dir)) return [];
   const out = [];
   let entries;
   try {
@@ -5435,7 +5483,7 @@ function scanAuthored(roots, subdir, day) {
   const out = [];
   for (const r of roots) {
     const dir = join8(r.root, subdir);
-    if (!existsSync7(dir)) continue;
+    if (!existsSync9(dir)) continue;
     for (const f of listMarkdownFiles(dir)) {
       const firstSeen = firstSeenDateOf(f);
       if (firstSeen !== day) continue;
@@ -5449,7 +5497,7 @@ function scanEdited(roots, day) {
   const out = [];
   for (const r of roots) {
     const dir = join8(r.root, "skills");
-    if (!existsSync7(dir)) continue;
+    if (!existsSync9(dir)) continue;
     for (const f of listMarkdownFiles(dir)) {
       const firstSeen = firstSeenDateOf(f);
       if (firstSeen === day) continue;
@@ -5472,10 +5520,10 @@ function claudemdLineDelta(extraRoots, authorEmail, day) {
   const candidates = [];
   for (const e of extraRoots) {
     const f = resolve3(e, "CLAUDE.md");
-    if (existsSync7(f)) candidates.push(f);
+    if (existsSync9(f)) candidates.push(f);
   }
   const homeClaudeMd = join8(homedir3(), "CLAUDE.md");
-  if (existsSync7(homeClaudeMd)) candidates.push(homeClaudeMd);
+  if (existsSync9(homeClaudeMd)) candidates.push(homeClaudeMd);
   for (const file of candidates) {
     try {
       const out = execFileSync2(
@@ -5532,7 +5580,7 @@ var init_file_probe = __esm({
 
 // src/daemon-worker.ts
 import { spawn as spawn2 } from "node:child_process";
-import { closeSync, existsSync as existsSync14, mkdirSync as mkdirSync13, openSync, readFileSync as readFileSync17, writeFileSync as writeFileSync12 } from "node:fs";
+import { closeSync, existsSync as existsSync16, mkdirSync as mkdirSync14, openSync, readFileSync as readFileSync19, writeFileSync as writeFileSync14 } from "node:fs";
 import { dirname as dirname11, join as join12 } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -5674,16 +5722,120 @@ function normalizeExtra(raw) {
   };
 }
 
+// src/usage/zai.ts
+init_fs();
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "node:fs";
+var ZAI_QUOTA_ENDPOINT = "https://api.z.ai/api/monitor/usage/quota/limit";
+var ZAI_SUBSCRIPTION_ENDPOINT = "https://api.z.ai/api/biz/subscription/list";
+var ZaiApiError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+};
+function resolveApiKey() {
+  try {
+    const p = cclensPath("credentials.json");
+    if (existsSync3(p)) {
+      const store = JSON.parse(readFileSync5(p, "utf8"));
+      return store.zai?.apiKey ?? null;
+    }
+  } catch {
+  }
+  return null;
+}
+function epochMsToIso(ms) {
+  if (typeof ms !== "number" || Number.isNaN(ms)) return null;
+  return new Date(ms).toISOString();
+}
+function windowFromLimit(limit) {
+  return {
+    utilization: typeof limit.percentage === "number" ? limit.percentage : null,
+    resets_at: epochMsToIso(limit.nextResetTime)
+  };
+}
+function zaiHeaders(key) {
+  return { Authorization: key, "Accept-Language": "en-US,en" };
+}
+async function fetchZaiUsage() {
+  const key = resolveApiKey();
+  if (!key) {
+    throw new ZaiApiError(
+      "No Z.ai API key found. Set ZAI_API_KEY (or GLM_API_KEY), or write ~/.config/zai/key.json.",
+      "no_key"
+    );
+  }
+  let res;
+  try {
+    res = await fetch(ZAI_QUOTA_ENDPOINT, { headers: zaiHeaders(key) });
+  } catch (err) {
+    throw new ZaiApiError(`Network error reaching Z.ai: ${err.message}`, "network");
+  }
+  if (!res.ok) {
+    throw new ZaiApiError(`Z.ai quota endpoint returned ${res.status} ${res.statusText}`, "http");
+  }
+  let body;
+  try {
+    body = await res.json();
+  } catch (err) {
+    throw new ZaiApiError(`Failed to parse Z.ai quota response: ${err.message}`, "parse");
+  }
+  const b = body;
+  const limits = b.data?.limits ?? [];
+  let fiveHour = null;
+  let sevenDay = null;
+  let webSearch = null;
+  for (const limit of limits) {
+    if (limit.type === "TIME_LIMIT") {
+      const percentage = typeof limit.percentage === "number" ? limit.percentage : null;
+      webSearch = {
+        used: percentage,
+        limit: percentage !== null ? 100 : null
+      };
+      continue;
+    }
+    const window = windowFromLimit(limit);
+    if (limit.unit === 6) {
+      sevenDay = sevenDay ?? window;
+    } else {
+      fiveHour = fiveHour ?? window;
+    }
+  }
+  let planType = null;
+  try {
+    const subRes = await fetch(ZAI_SUBSCRIPTION_ENDPOINT, { headers: zaiHeaders(key) });
+    if (subRes.ok) {
+      const sub = await subRes.json();
+      const entry = sub.data?.[0];
+      planType = entry?.productName || entry?.planName || entry?.name || null;
+    }
+  } catch {
+  }
+  return {
+    captured_at: (/* @__PURE__ */ new Date()).toISOString(),
+    agent: "zai",
+    five_hour: fiveHour ?? { utilization: null, resets_at: null },
+    seven_day: sevenDay ?? { utilization: null, resets_at: null },
+    seven_day_opus: null,
+    seven_day_sonnet: null,
+    seven_day_oauth_apps: null,
+    seven_day_cowork: null,
+    extra_usage: null,
+    plan_type: planType,
+    web_search_quota: webSearch ?? null
+  };
+}
+
 // src/daemon-worker.ts
 init_storage();
 init_fs();
 
 // src/daemon-log.ts
 init_fs();
-import { appendFileSync as appendFileSync2 } from "node:fs";
+import { appendFileSync as appendFileSync3 } from "node:fs";
 function appendDaemonLogLine(level, msg) {
   try {
-    appendFileSync2(
+    appendFileSync3(
       cclensPath("daemon.log"),
       `${(/* @__PURE__ */ new Date()).toISOString()} ${level.toUpperCase()} ${msg}
 `,
@@ -5715,7 +5867,7 @@ import { randomUUID } from "node:crypto";
 
 // ../entries/dist/fs.js
 init_fs();
-import { readFileSync as readFileSync6, readdirSync as readdirSync2, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, renameSync as renameSync3, existsSync as existsSync4 } from "node:fs";
+import { readFileSync as readFileSync8, readdirSync as readdirSync2, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, renameSync as renameSync3, existsSync as existsSync6 } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { join as join5 } from "node:path";
 
@@ -5790,12 +5942,12 @@ var PROMPT_FRAME_ORIGIN = {
 
 // ../entries/dist/digest-fs.js
 init_fs();
-import { readFileSync as readFileSync5, readdirSync, writeFileSync as writeFileSync2, renameSync as renameSync2, chmodSync, mkdirSync as mkdirSync3, existsSync as existsSync3 } from "node:fs";
+import { readFileSync as readFileSync7, readdirSync, writeFileSync as writeFileSync4, renameSync as renameSync2, chmodSync, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "node:fs";
 import { dirname as dirname3, join as join4 } from "node:path";
 var digestsDirCached = null;
 function parseDigestFile(path7, expectedVersion) {
   try {
-    const parsed = JSON.parse(readFileSync5(path7, "utf8"));
+    const parsed = JSON.parse(readFileSync7(path7, "utf8"));
     if (!parsed || typeof parsed !== "object")
       return null;
     if (parsed.version !== expectedVersion)
@@ -5822,9 +5974,9 @@ function weekDigestPath(monday) {
 }
 function writeDayDigest(digest) {
   const final = dayDigestPath(digest.key);
-  mkdirSync3(dirname3(final), { recursive: true });
+  mkdirSync4(dirname3(final), { recursive: true });
   const tmp = `${final}.tmp`;
-  writeFileSync2(tmp, JSON.stringify(digest, null, 2), "utf8");
+  writeFileSync4(tmp, JSON.stringify(digest, null, 2), "utf8");
   if (process.platform !== "win32") {
     try {
       chmodSync(tmp, 384);
@@ -5835,7 +5987,7 @@ function writeDayDigest(digest) {
 }
 function readDayDigest(date) {
   const p = dayDigestPath(date);
-  if (!existsSync3(p))
+  if (!existsSync5(p))
     return null;
   return parseDigestFile(p, CURRENT_DAY_DIGEST_SCHEMA_VERSION);
 }
@@ -5855,9 +6007,9 @@ function setTodayDigestInCache(date, digest, nowMs) {
 }
 function writeWeekDigest(digest) {
   const final = weekDigestPath(digest.key);
-  mkdirSync3(dirname3(final), { recursive: true });
+  mkdirSync4(dirname3(final), { recursive: true });
   const tmp = `${final}.tmp`;
-  writeFileSync2(tmp, JSON.stringify(digest, null, 2), "utf8");
+  writeFileSync4(tmp, JSON.stringify(digest, null, 2), "utf8");
   if (process.platform !== "win32") {
     try {
       chmodSync(tmp, 384);
@@ -5868,7 +6020,7 @@ function writeWeekDigest(digest) {
 }
 function readWeekDigest(monday) {
   const p = weekDigestPath(monday);
-  if (!existsSync3(p))
+  if (!existsSync5(p))
     return null;
   return parseDigestFile(p, CURRENT_WEEK_DIGEST_SCHEMA_VERSION);
 }
@@ -5905,11 +6057,11 @@ function tmpPathFor(final) {
 }
 function writeEntry(entry) {
   const dir = entriesDir();
-  mkdirSync4(dir, { recursive: true });
+  mkdirSync5(dir, { recursive: true });
   const final = pathFor(entry.session_id, entry.local_day);
   const tmp = tmpPathFor(final);
   const json = JSON.stringify(entry, null, 2);
-  writeFileSync3(tmp, json, { encoding: "utf8" });
+  writeFileSync5(tmp, json, { encoding: "utf8" });
   renameSync3(tmp, final);
 }
 var PRESERVABLE_STATUSES = /* @__PURE__ */ new Set([
@@ -5933,7 +6085,7 @@ function enrichmentInputHash(e) {
 }
 function writeEntryPreservingEnrichment(fresh) {
   const dir = entriesDir();
-  mkdirSync4(dir, { recursive: true });
+  mkdirSync5(dir, { recursive: true });
   const final = pathFor(fresh.session_id, fresh.local_day);
   const existing = readEntry(fresh.session_id, fresh.local_day);
   let toWrite = fresh;
@@ -5941,22 +6093,22 @@ function writeEntryPreservingEnrichment(fresh) {
     toWrite = { ...fresh, enrichment: existing.enrichment };
   }
   const tmp = tmpPathFor(final);
-  writeFileSync3(tmp, JSON.stringify(toWrite, null, 2), { encoding: "utf8" });
+  writeFileSync5(tmp, JSON.stringify(toWrite, null, 2), { encoding: "utf8" });
   renameSync3(tmp, final);
 }
 function readEntry(sessionId, localDay2) {
   const p = pathFor(sessionId, localDay2);
-  if (!existsSync4(p))
+  if (!existsSync6(p))
     return null;
-  const raw = readFileSync6(p, "utf8");
+  const raw = readFileSync8(p, "utf8");
   return JSON.parse(raw);
 }
 function entryExists(sessionId, localDay2) {
-  return existsSync4(pathFor(sessionId, localDay2));
+  return existsSync6(pathFor(sessionId, localDay2));
 }
 function listEntryKeys() {
   const dir = entriesDir();
-  if (!existsSync4(dir))
+  if (!existsSync6(dir))
     return [];
   return readdirSync2(dir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
 }
@@ -5975,7 +6127,7 @@ function listEntriesForDay(localDay2) {
 
 // src/perception/build-entries.ts
 init_dist();
-import { statSync as statSync2, readFileSync as readFileSync7 } from "node:fs";
+import { statSync as statSync2, readFileSync as readFileSync9 } from "node:fs";
 import { basename as basename2, dirname as dirname4 } from "node:path";
 
 // ../entries/dist/signals.js
@@ -6715,7 +6867,7 @@ function decodeProjectDirName(projectDir) {
 }
 function buildEntriesForFile(filePath) {
   const stat = statSync2(filePath);
-  const raw = readFileSync7(filePath, "utf8");
+  const raw = readFileSync9(filePath, "utf8");
   const rawLines = raw.split("\n").filter(Boolean).map((l) => {
     try {
       return JSON.parse(l);
@@ -6976,7 +7128,7 @@ function buildIngestPayload(inputs) {
   return {
     ingestId: randomUUID(),
     observedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    cliVersion: "0.15.3",
+    cliVersion: "0.15.4",
     ...richRollup || inputs.enrichedExtras || inputs.artifactSignals ? { schemaVersion: RICH_ROLLUP_SCHEMA_VERSION } : {},
     ...inputs.rollup ? { dailyRollup: inputs.rollup } : {},
     ...richRollup ? { richRollup } : {},
@@ -7003,7 +7155,7 @@ async function pushToTeamServer(config, payload) {
 }
 
 // src/team/git-remote.ts
-import { existsSync as existsSync5, readFileSync as readFileSync8, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync7, readFileSync as readFileSync10, statSync as statSync3 } from "node:fs";
 import { dirname as dirname5, isAbsolute as isAbsolute2, join as join6, resolve as resolve2 } from "node:path";
 var GITHUB_URL_RE = /github\.com[:/]([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git)?$/;
 function parseGithubRemote(url) {
@@ -7029,12 +7181,12 @@ function gitConfigPathFor(dir) {
   const st = statSync3(dotGit, { throwIfNoEntry: false });
   if (!st) return null;
   if (st.isDirectory()) return join6(dotGit, "config");
-  const m = readFileSync8(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
+  const m = readFileSync10(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
   if (!m) return null;
   const gd = isAbsolute2(m[1]) ? m[1] : resolve2(dir, m[1]);
   const commondirFile = join6(gd, "commondir");
-  if (existsSync5(commondirFile)) {
-    const common = readFileSync8(commondirFile, "utf8").trim();
+  if (existsSync7(commondirFile)) {
+    const common = readFileSync10(commondirFile, "utf8").trim();
     return join6(isAbsolute2(common) ? common : resolve2(gd, common), "config");
   }
   return join6(gd, "config");
@@ -7049,8 +7201,8 @@ function createRepoResolver() {
     try {
       for (let d = dir; ; d = dirname5(d)) {
         const config = gitConfigPathFor(d);
-        if (config && existsSync5(config)) {
-          const url = originUrl2(readFileSync8(config, "utf8"));
+        if (config && existsSync7(config)) {
+          const url = originUrl2(readFileSync10(config, "utf8"));
           repo = url ? parseGithubRemote(url) : null;
           break;
         }
@@ -7066,15 +7218,15 @@ function createRepoResolver() {
 
 // src/team/queue.ts
 init_fs();
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync4, appendFileSync as appendFileSync3, statSync as statSync4, mkdirSync as mkdirSync5 } from "node:fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync6, appendFileSync as appendFileSync4, statSync as statSync4, mkdirSync as mkdirSync6 } from "node:fs";
 import { dirname as dirname6 } from "node:path";
 var QUEUE_PATH = cclensPath("ingest-queue.jsonl");
 var MAX_SIZE_BYTES = 10 * 1024 * 1024;
 var MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
 function enqueuePayload(payload, queuePath = QUEUE_PATH) {
-  mkdirSync5(dirname6(queuePath), { recursive: true });
+  mkdirSync6(dirname6(queuePath), { recursive: true });
   const entry = { payload, enqueuedAt: (/* @__PURE__ */ new Date()).toISOString() };
-  appendFileSync3(queuePath, JSON.stringify(entry) + "\n", "utf8");
+  appendFileSync4(queuePath, JSON.stringify(entry) + "\n", "utf8");
   try {
     const { size } = statSync4(queuePath);
     if (size > MAX_SIZE_BYTES) {
@@ -7086,7 +7238,7 @@ function enqueuePayload(payload, queuePath = QUEUE_PATH) {
 function dequeuePayloads(queuePath = QUEUE_PATH) {
   let lines;
   try {
-    lines = readFileSync9(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync11(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return [];
   }
@@ -7101,18 +7253,18 @@ function dequeuePayloads(queuePath = QUEUE_PATH) {
     } catch {
     }
   }
-  writeFileSync4(queuePath, "", "utf8");
+  writeFileSync6(queuePath, "", "utf8");
   return valid.map((e) => e.payload);
 }
 function pruneOldest(queuePath) {
   let lines;
   try {
-    lines = readFileSync9(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync11(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return;
   }
   const keep = lines.slice(Math.floor(lines.length / 2));
-  writeFileSync4(queuePath, keep.join("\n") + "\n", "utf8");
+  writeFileSync6(queuePath, keep.join("\n") + "\n", "utf8");
 }
 
 // src/team/backfill.ts
@@ -7120,7 +7272,7 @@ init_storage();
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/usage/profile.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "node:fs";
 import { dirname as dirname7 } from "node:path";
 var PROFILE_ENDPOINT = "https://api.anthropic.com/api/oauth/profile";
 var BETA_HEADER2 = "oauth-2025-04-20";
@@ -7164,9 +7316,9 @@ async function fetchProfile(nowMs = Date.now()) {
   };
 }
 function readCachedProfile(cachePath) {
-  if (!existsSync6(cachePath)) return null;
+  if (!existsSync8(cachePath)) return null;
   try {
-    const raw = JSON.parse(readFileSync10(cachePath, "utf8"));
+    const raw = JSON.parse(readFileSync12(cachePath, "utf8"));
     if (typeof raw.fetchedAtMs !== "number" || !raw.profile) return null;
     return raw;
   } catch {
@@ -7174,8 +7326,8 @@ function readCachedProfile(cachePath) {
   }
 }
 function writeCachedProfile(cachePath, profile, nowMs = Date.now()) {
-  mkdirSync6(dirname7(cachePath), { recursive: true });
-  writeFileSync5(
+  mkdirSync7(dirname7(cachePath), { recursive: true });
+  writeFileSync7(
     cachePath,
     JSON.stringify({ fetchedAtMs: nowMs, profile }, null, 2),
     { mode: 384 }
@@ -7335,13 +7487,13 @@ async function runTeamBackfill(log3 = noopLog, filePath = USAGE_LOG, configOverr
 
 // src/team/sync-log.ts
 init_fs();
-import { readFileSync as readFileSync11 } from "node:fs";
+import { readFileSync as readFileSync13 } from "node:fs";
 var MAX_LINES = 300;
 var MAX_MSG_CHARS = 1900;
 function readPendingSyncLog(watermark) {
   let raw;
   try {
-    raw = readFileSync11(cclensPath("daemon.log"), "utf8");
+    raw = readFileSync13(cclensPath("daemon.log"), "utf8");
   } catch {
     return { lines: [] };
   }
@@ -7361,13 +7513,13 @@ function readPendingSyncLog(watermark) {
 
 // src/team/last-push.ts
 init_fs();
-import { writeFileSync as writeFileSync6, unlinkSync as unlinkSync2, mkdirSync as mkdirSync7 } from "node:fs";
+import { writeFileSync as writeFileSync8, unlinkSync as unlinkSync2, mkdirSync as mkdirSync8 } from "node:fs";
 import { join as join7 } from "node:path";
 var LAST_PUSH_FILE = "team-last-push.json";
 function write(record, dir) {
   const d = dir ?? cclensHome();
-  mkdirSync7(d, { recursive: true });
-  writeFileSync6(join7(d, LAST_PUSH_FILE), JSON.stringify(record, null, 2), { mode: 384 });
+  mkdirSync8(d, { recursive: true });
+  writeFileSync8(join7(d, LAST_PUSH_FILE), JSON.stringify(record, null, 2), { mode: 384 });
 }
 function writeLastPushSuccess(payload, dir) {
   write({ pushedAt: (/* @__PURE__ */ new Date()).toISOString(), ok: true, payload }, dir);
@@ -7951,7 +8103,7 @@ init_fs();
 
 // src/perception/state.ts
 init_fs();
-import { existsSync as existsSync8, readFileSync as readFileSync12, writeFileSync as writeFileSync7, mkdirSync as mkdirSync8, renameSync as renameSync4 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync14, writeFileSync as writeFileSync9, mkdirSync as mkdirSync9, renameSync as renameSync4 } from "node:fs";
 import { dirname as dirname9 } from "node:path";
 var STALE_MS = 15 * 60 * 1e3;
 var pathCached = null;
@@ -7962,7 +8114,7 @@ function statePath() {
 }
 function readState() {
   const p = statePath();
-  if (!existsSync8(p)) {
+  if (!existsSync10(p)) {
     return {
       sweep_in_progress: false,
       last_sweep_started_at: null,
@@ -7970,14 +8122,14 @@ function readState() {
       file_checkpoints: {}
     };
   }
-  const raw = readFileSync12(p, "utf8");
+  const raw = readFileSync14(p, "utf8");
   return JSON.parse(raw);
 }
 function writeState(s) {
   const p = statePath();
-  mkdirSync8(dirname9(p), { recursive: true });
+  mkdirSync9(dirname9(p), { recursive: true });
   const tmp = `${p}.tmp`;
-  writeFileSync7(tmp, JSON.stringify(s, null, 2), "utf8");
+  writeFileSync9(tmp, JSON.stringify(s, null, 2), "utf8");
   renameSync4(tmp, p);
 }
 function markSweepStart() {
@@ -12233,12 +12385,12 @@ var ENRICHMENT_SYSTEM_PROMPT = SYSTEM_PROMPT;
 // ../entries/dist/llm-runner.js
 init_fs();
 import { spawn } from "node:child_process";
-import { mkdirSync as mkdirSync10, appendFileSync as appendFileSync4, writeFileSync as writeFileSync9, existsSync as existsSync10 } from "node:fs";
+import { mkdirSync as mkdirSync11, appendFileSync as appendFileSync5, writeFileSync as writeFileSync11, existsSync as existsSync12 } from "node:fs";
 import { join as join11 } from "node:path";
 import { randomUUID as randomUUID4 } from "node:crypto";
 
 // ../entries/dist/tmux-runner.js
-import { mkdirSync as mkdirSync9, writeFileSync as writeFileSync8, existsSync as existsSync9, readdirSync as readdirSync5, realpathSync as realpathSync2, readFileSync as readFileSync13, unlinkSync as unlinkSync3, renameSync as renameSync5 } from "node:fs";
+import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync10, existsSync as existsSync11, readdirSync as readdirSync5, realpathSync as realpathSync2, readFileSync as readFileSync15, unlinkSync as unlinkSync3, renameSync as renameSync5 } from "node:fs";
 import { join as join10 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 import { spawnSync } from "node:child_process";
@@ -12269,15 +12421,15 @@ function tmuxRunnerAvailable() {
 }
 function runtimeCwd() {
   const dir = join10(homedir5(), ".cclens", "runtime");
-  if (!existsSync9(dir))
-    mkdirSync9(dir, { recursive: true });
+  if (!existsSync11(dir))
+    mkdirSync10(dir, { recursive: true });
   return realpathSync2(dir);
 }
 function ensureRuntimeCwdTrusted(cwd) {
   const cfgPath = join10(homedir5(), ".claude.json");
   let cfg;
   try {
-    cfg = JSON.parse(readFileSync13(cfgPath, "utf8"));
+    cfg = JSON.parse(readFileSync15(cfgPath, "utf8"));
   } catch {
     return;
   }
@@ -12292,7 +12444,7 @@ function ensureRuntimeCwdTrusted(cwd) {
   cfg.projects = projects;
   const tmp = `${cfgPath}.cclens-tmp-${process.pid}`;
   try {
-    writeFileSync8(tmp, JSON.stringify(cfg, null, 2));
+    writeFileSync10(tmp, JSON.stringify(cfg, null, 2));
     renameSync5(tmp, cfgPath);
   } catch {
     try {
@@ -12323,13 +12475,13 @@ async function runClaudeUnderTmuxImpl(args) {
   const systemFile = join10(cwd, `system-${runId}.txt`);
   const userFile = join10(cwd, `user-${runId}.txt`);
   const wrapper = join10(cwd, `run-${runId}.sh`);
-  writeFileSync8(systemFile, args.systemPrompt);
-  writeFileSync8(userFile, args.reminder ? `${args.userPrompt}
+  writeFileSync10(systemFile, args.systemPrompt);
+  writeFileSync10(userFile, args.reminder ? `${args.userPrompt}
 
 ---
 
 ${args.reminder}` : args.userPrompt);
-  writeFileSync8(wrapper, `#!/bin/bash
+  writeFileSync10(wrapper, `#!/bin/bash
 SYS="$(cat ${shellEscape(systemFile)})"
 USR="$(cat ${shellEscape(userFile)})"
 exec ${shellEscape(claudeBin)} \\
@@ -12429,7 +12581,7 @@ function snapshotAllTranscripts() {
 function readJsonlCwd(path7, maxLines = 8) {
   let raw;
   try {
-    raw = readFileSync13(path7, "utf8");
+    raw = readFileSync15(path7, "utf8");
   } catch {
     return void 0;
   }
@@ -12486,7 +12638,7 @@ async function discoverTranscript(targetCwd, existingBefore, startMs, timeoutMs,
 function parseTranscript2(path7, defaultModel) {
   let raw;
   try {
-    raw = readFileSync13(path7, "utf8");
+    raw = readFileSync15(path7, "utf8");
   } catch {
     return { assembled: "", inputTokens: 0, outputTokens: 0, modelUsed: defaultModel, done: false };
   }
@@ -12561,9 +12713,9 @@ function shellEscape(s) {
 // ../entries/dist/llm-runner.js
 var RUNS_DIR = cclensPath("llm-runs");
 function ensureRunsDir() {
-  if (!existsSync10(RUNS_DIR)) {
+  if (!existsSync12(RUNS_DIR)) {
     try {
-      mkdirSync10(RUNS_DIR, { recursive: true });
+      mkdirSync11(RUNS_DIR, { recursive: true });
     } catch {
     }
   }
@@ -12594,13 +12746,13 @@ function tracePath(runId) {
 }
 function safeAppend(path7, line) {
   try {
-    appendFileSync4(path7, line);
+    appendFileSync5(path7, line);
   } catch {
   }
 }
 function safeWrite(path7, line) {
   try {
-    writeFileSync9(path7, line);
+    writeFileSync11(path7, line);
   } catch {
   }
 }
@@ -12989,7 +13141,7 @@ function applyEnrichmentError(entry, errorMessage, model, costUsd, generatedAt,
 
 // ../entries/dist/budget.js
 init_fs();
-import { appendFileSync as appendFileSync5, readFileSync as readFileSync14, existsSync as existsSync11, mkdirSync as mkdirSync11 } from "node:fs";
+import { appendFileSync as appendFileSync6, readFileSync as readFileSync16, existsSync as existsSync13, mkdirSync as mkdirSync12 } from "node:fs";
 import { dirname as dirname10 } from "node:path";
 var spendPathCached = null;
 function spendPath() {
@@ -13000,17 +13152,17 @@ function spendPath() {
 }
 function appendSpend(record) {
   const p = spendPath();
-  mkdirSync11(dirname10(p), { recursive: true });
-  appendFileSync5(p, JSON.stringify(record) + "\n", { encoding: "utf8" });
+  mkdirSync12(dirname10(p), { recursive: true });
+  appendFileSync6(p, JSON.stringify(record) + "\n", { encoding: "utf8" });
 }
 function monthToDateSpend(now = /* @__PURE__ */ new Date()) {
   const p = spendPath();
-  if (!existsSync11(p))
+  if (!existsSync13(p))
     return 0;
   const year = now.getUTCFullYear();
   const month = now.getUTCMonth();
   let total = 0;
-  const raw = readFileSync14(p, "utf8");
+  const raw = readFileSync16(p, "utf8");
   for (const line of raw.split("\n")) {
     if (!line)
       continue;
@@ -13032,7 +13184,7 @@ function monthToDateSpend(now = /* @__PURE__ */ new Date()) {
 
 // ../entries/dist/pipeline-lock.js
 init_fs();
-import { writeFileSync as writeFileSync10, unlinkSync as unlinkSync4, existsSync as existsSync12, readFileSync as readFileSync15, statSync as statSync7 } from "node:fs";
+import { writeFileSync as writeFileSync12, unlinkSync as unlinkSync4, existsSync as existsSync14, readFileSync as readFileSync17, statSync as statSync7 } from "node:fs";
 var STALE_MS2 = 60 * 1e3;
 var HEARTBEAT_MS = 30 * 1e3;
 var lockPathCached = null;
@@ -13044,7 +13196,7 @@ function lockPath() {
   return lockPathCached;
 }
 function touchLock() {
-  writeFileSync10(lockPath(), String(process.pid), "utf8");
+  writeFileSync12(lockPath(), String(process.pid), "utf8");
 }
 function writeInteractiveLock() {
   touchLock();
@@ -13078,13 +13230,13 @@ function pidAlive(pid) {
 }
 function interactiveLockFresh(nowMs) {
   const p = lockPath();
-  if (!existsSync12(p))
+  if (!existsSync14(p))
     return false;
   try {
     const mtime = statSync7(p).mtimeMs;
     if (nowMs - mtime > STALE_MS2)
       return false;
-    const pid = Number(readFileSync15(p, "utf8").trim());
+    const pid = Number(readFileSync17(p, "utf8").trim());
     if (!Number.isFinite(pid) || pid <= 0)
       return false;
     if (!pidAlive(pid))
@@ -13099,7 +13251,7 @@ function interactiveLockFresh(nowMs) {
 var THIRTY_MIN_MS = 30 * 60 * 1e3;
 
 // ../entries/dist/settings.js
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync11, renameSync as renameSync6, chmodSync as chmodSync2, mkdirSync as mkdirSync12, existsSync as existsSync13 } from "node:fs";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync13, renameSync as renameSync6, chmodSync as chmodSync2, mkdirSync as mkdirSync13, existsSync as existsSync15 } from "node:fs";
 init_fs();
 var DEFAULT_SETTINGS = {
   ai_features: {
@@ -13131,10 +13283,10 @@ function fromDisk(d) {
 }
 function readSettings() {
   const p = settingsPath();
-  if (!existsSync13(p))
+  if (!existsSync15(p))
     return DEFAULT_SETTINGS;
   try {
-    const raw = readFileSync16(p, "utf8");
+    const raw = readFileSync18(p, "utf8");
     return fromDisk(JSON.parse(raw));
   } catch {
     return DEFAULT_SETTINGS;
@@ -15743,6 +15895,9 @@ async function* runWeekDigestPipeline(monday, opts) {
   }
 }
 
+// ../entries/dist/credentials.js
+init_fs();
+
 // src/perception/backfill.ts
 function toLocalDay2(ms) {
   const d = new Date(ms);
@@ -15891,14 +16046,14 @@ async function getUpdateAvailability() {
   if (isDevMode()) return null;
   const latest = await fetchLatestVersion();
   if (latest === null) return {
-    current: "0.15.3",
+    current: "0.15.4",
     latest: null,
     updateAvailable: false
   };
   return {
-    current: "0.15.3",
+    current: "0.15.4",
     latest,
-    updateAvailable: shouldUpdate("0.15.3", latest)
+    updateAvailable: shouldUpdate("0.15.4", latest)
   };
 }
 
@@ -15908,7 +16063,7 @@ var DAEMON_LOG = cclensPath("daemon.log");
 var UPDATE_STATE = cclensPath("daemon-update.json");
 var WATCHDOG_INTERVAL_MS = 5 * 1e3;
 var AUTO_UPDATE_INTERVAL_MS = 6 * 60 * 60 * 1e3;
-mkdirSync13(dirname11(USAGE_LOG3), { recursive: true });
+mkdirSync14(dirname11(USAGE_LOG3), { recursive: true });
 function log2(level, message) {
   appendDaemonLogLine(level, message);
 }
@@ -15946,14 +16101,14 @@ var perceptionHandle = setInterval(async () => {
 }, PERCEPTION_INTERVAL_MS);
 function readUpdateState() {
   try {
-    return JSON.parse(readFileSync17(UPDATE_STATE, "utf8"));
+    return JSON.parse(readFileSync19(UPDATE_STATE, "utf8"));
   } catch {
     return null;
   }
 }
 function writeUpdateState(state) {
   try {
-    writeFileSync12(UPDATE_STATE, JSON.stringify(state, null, 2), { mode: 384 });
+    writeFileSync14(UPDATE_STATE, JSON.stringify(state, null, 2), { mode: 384 });
   } catch {
   }
 }
@@ -15998,7 +16153,7 @@ async function runDaemonUpdateCheck() {
       return;
     }
     const entry = cliEntryPath();
-    if (!existsSync14(entry)) {
+    if (!existsSync16(entry)) {
       log2("warn", `update check found ${availability.latest}, but CLI entry is missing at ${entry}`);
       return;
     }
@@ -16061,6 +16216,20 @@ async function tick() {
       log2("warn", `${source.kind} poll failed: ${err.message}`);
     }
   }
+  try {
+    const zaiSnapshot = await fetchZaiUsage();
+    appendSnapshot(USAGE_LOG3, zaiSnapshot);
+    log2(
+      "info",
+      `zai snapshot 5h=${zaiSnapshot.five_hour.utilization}% 7d=${zaiSnapshot.seven_day.utilization}%`
+    );
+  } catch (err) {
+    if (err instanceof ZaiApiError && err.code === "no_key") {
+      pruneAgent(USAGE_LOG3, "zai");
+    } else {
+      log2("warn", `zai poll failed: ${err.message}`);
+    }
+  }
   try {
     const snapshot = await fetchUsage();
     appendSnapshot(USAGE_LOG3, snapshot);