fleetlens 0.15.2 → 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);
@@ -114,11 +80,22 @@ function worktreeName(projectName) {
     return ss.workspaceName;
   return null;
 }
-function projectRepoName(projectName) {
+function projectKey(projectName) {
   const canonical = canonicalProjectName(projectName);
   const segs = canonical.replace(/\/+$/, "").split("/").filter(Boolean);
   return segs[segs.length - 1] || canonical;
 }
+function sessionProjectKey(s) {
+  return s.repoName ?? projectKey(s.projectName);
+}
+function buildProjectKeyResolver(sessions) {
+  const alias = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    if (s.repoName)
+      alias.set(projectKey(s.projectName), s.repoName);
+  }
+  return (s) => s.repoName ?? alias.get(projectKey(s.projectName)) ?? projectKey(s.projectName);
+}
 function makeDay(date) {
   return {
     date,
@@ -553,8 +530,9 @@ function summarizeBursts(bursts) {
 }
 function groupByProject(sessions) {
   const map = /* @__PURE__ */ new Map();
+  const keyOf = buildProjectKeyResolver(sessions);
   for (const s of sessions) {
-    const repo = projectRepoName(s.projectName);
+    const repo = keyOf(s);
     const key = repo;
     let cur = map.get(key);
     if (!cur) {
@@ -583,7 +561,7 @@ function groupByProject(sessions) {
     p.metrics = highLevelMetrics(p.sessions);
     const wtNames = /* @__PURE__ */ new Set();
     for (const s of p.sessions) {
-      const wt = worktreeName(s.projectName);
+      const wt = s.worktreeName ?? worktreeName(s.projectName) ?? (s.cwd ? worktreeName(s.cwd) : null);
       if (wt)
         wtNames.add(wt);
     }
@@ -602,7 +580,7 @@ function groupByProject(sessions) {
   }
   return Array.from(map.values()).sort((a, b) => (b.lastActiveMs ?? 0) - (a.lastActiveMs ?? 0));
 }
-var BLANK_USAGE, WORKTREE_MARKERS, CONDUCTOR_RE, SUPERSET_MARKER, UUID_SEG_RE, PR_CREATE_RE, PR_NUMBER_RE, TITLE_FLAG_RE;
+var BLANK_USAGE, WORKTREE_MARKERS, CONDUCTOR_RE, SUPERSET_MARKER, UUID_SEG_RE, projectRepoName, PR_CREATE_RE, PR_NUMBER_RE, TITLE_FLAG_RE;
 var init_analytics = __esm({
   "../parser/dist/analytics.js"() {
     "use strict";
@@ -615,6 +593,7 @@ var init_analytics = __esm({
     CONDUCTOR_RE = /\/conductor\/workspaces\/[^/]+\/([^/]+)(?:\/|$)/;
     SUPERSET_MARKER = "/.superset/worktrees/";
     UUID_SEG_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+    projectRepoName = projectKey;
     PR_CREATE_RE = /gh\s+pr\s+create\b/i;
     PR_NUMBER_RE = /#(\d+)/;
     TITLE_FLAG_RE = /--title\s+["']([^"']+)["']/;
@@ -628,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";
@@ -667,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));
   }
@@ -1413,6 +1400,187 @@ var init_parser = __esm({
   }
 });
 
+// ../parser/dist/git-project.js
+import { existsSync, readFileSync as readFileSync2, realpathSync, statSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+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)
+    return void 0;
+  const gitDir = m[1].trim();
+  return isAbsolute(gitDir) ? gitDir : resolve(root, gitDir);
+}
+function resolveCommonDir(gitDir) {
+  const file = join2(gitDir, "commondir");
+  if (!existsSync(file))
+    return void 0;
+  const common = readFileSync2(file, "utf8").trim();
+  if (!common)
+    return void 0;
+  return isAbsolute(common) ? common : resolve(gitDir, common);
+}
+function dotGitInfoFor(root) {
+  const dotGit = join2(root, ".git");
+  const st = statSync(dotGit, { throwIfNoEntry: false });
+  if (!st)
+    return null;
+  if (st.isDirectory())
+    return { root, gitDir: dotGit, commonDir: dotGit };
+  const gitDir = resolveGitDir(root, readFileSync2(dotGit, "utf8"));
+  if (!gitDir)
+    return { root };
+  return { root, gitDir, commonDir: resolveCommonDir(gitDir) };
+}
+function walkBoundary(start) {
+  const home = realpathOrSelf(homedir2());
+  return start === home || start.startsWith(`${home}/`) ? home : void 0;
+}
+function nearestDotGit(start) {
+  if (!start || !isAbsolute(start))
+    return null;
+  const boundary = walkBoundary(start);
+  for (let dir = start.replace(/\/+$/, "") || start; ; dir = dirname(dir)) {
+    if (dir === boundary)
+      return null;
+    const info = dotGitInfoFor(dir);
+    if (info)
+      return info;
+    const parent = dirname(dir);
+    if (parent === dir)
+      return null;
+  }
+}
+function originUrl(configText) {
+  let inOrigin = false;
+  for (const line of configText.split("\n")) {
+    const t = line.trim();
+    if (t.startsWith("[")) {
+      inOrigin = /^\[remote\s+"origin"\]/.test(t);
+      continue;
+    }
+    if (!inOrigin)
+      continue;
+    const m = t.match(/^url\s*=\s*(.+)$/);
+    if (m)
+      return m[1].trim();
+  }
+  return void 0;
+}
+function parseRemote(url) {
+  const m = url.match(REMOTE_URL_RE);
+  if (!m)
+    return void 0;
+  const host = m[1];
+  const segs = m[2].split("/").filter(Boolean);
+  if (segs.length < 2)
+    return void 0;
+  const name = segs[segs.length - 1];
+  const owner = segs.slice(0, -1).join("/");
+  return { host, owner, name, url, webUrl: `https://${host}/${owner}/${name}` };
+}
+function remoteFor(git) {
+  const dir = git.commonDir ?? git.gitDir;
+  if (!dir)
+    return void 0;
+  const config = join2(dir, "config");
+  if (!existsSync(config))
+    return void 0;
+  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 (!existsSync(head))
+    return void 0;
+  const t = readFileSync2(head, "utf8").trim();
+  const m = t.match(/^ref:\s*refs\/heads\/(.+)$/);
+  return m ? m[1] : `detached @ ${t.slice(0, 7)}`;
+}
+function defaultBranch(commonDir) {
+  if (!commonDir)
+    return void 0;
+  const head = join2(commonDir, "refs", "remotes", "origin", "HEAD");
+  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 (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 (!existsSync(path7))
+    return { exists: false, isWorktree: false };
+  try {
+    const git = nearestDotGit(realpathOrSelf(path7));
+    if (!git)
+      return { exists: true, isWorktree: false };
+    const projectRoot = projectRootFromCommonDir(git.commonDir);
+    const isWorktree = !!projectRoot && realpathOrSelf(projectRoot) !== realpathOrSelf(git.root);
+    return {
+      exists: true,
+      isWorktree,
+      branch: headBranch(git.gitDir),
+      defaultBranch: defaultBranch(git.commonDir),
+      remote: remoteFor(git)
+    };
+  } catch {
+    return { exists: true, isWorktree: false };
+  }
+}
+function projectRootFromCommonDir(commonDir) {
+  if (!commonDir)
+    return void 0;
+  return basename(commonDir) === ".git" ? dirname(commonDir) : void 0;
+}
+function realpathOrSelf(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function resolveProjectIdentity(cwd) {
+  const normalized = realpathOrSelf(cwd.replace(/\/{2,}/g, "/"));
+  try {
+    const git = nearestDotGit(normalized);
+    if (git) {
+      const projectRoot = realpathOrSelf(projectRootFromCommonDir(git.commonDir) ?? git.root);
+      const gitRoot = realpathOrSelf(git.root);
+      const wt2 = projectRoot !== gitRoot ? worktreeName(normalized) ?? basename(git.root) : void 0;
+      const identity = { projectName: projectRoot };
+      if (wt2)
+        identity.worktreeName = wt2;
+      const remote = remoteFor(git);
+      if (remote) {
+        identity.remote = remote;
+        identity.repoName = remote.name;
+      }
+      return identity;
+    }
+  } catch {
+  }
+  const projectName = canonicalProjectName(normalized);
+  const wt = worktreeName(normalized) ?? void 0;
+  return wt ? { projectName, worktreeName: wt } : { projectName };
+}
+var REMOTE_URL_RE;
+var init_git_project = __esm({
+  "../parser/dist/git-project.js"() {
+    "use strict";
+    init_analytics();
+    REMOTE_URL_RE = /^(?:(?:https?|ssh|git):\/\/)?(?:[^@/]+@)?([^/:]+)[:/](.+?)(?:\.git)?\/?$/;
+  }
+});
+
 // ../parser/dist/team.js
 function groupByTeam(sessions, details) {
   const byTeam = /* @__PURE__ */ new Map();
@@ -1881,12 +2049,16 @@ async function getCachedMeta(f) {
     const sessionId = sessionIdFromFileName(f.fileName);
     const projectDirPath = path.dirname(f.fullPath);
     const wf = await scanWorkflowAggregate(projectDirPath, sessionId);
+    const cwd = meta.cwd ?? decodeProjectName(f.projectDir);
+    const project = resolveProjectIdentity(cwd);
     const full = {
       ...meta,
       id: sessionId,
       filePath: f.fullPath,
       projectDir: f.projectDir,
-      projectName: meta.cwd ?? decodeProjectName(f.projectDir),
+      projectName: project.projectName,
+      worktreeName: project.worktreeName,
+      repoName: project.repoName,
       ...wf.workflowCount > 0 ? { workflowCount: wf.workflowCount, spawnedAgentCount: wf.spawnedAgentCount } : {},
       ...foldWorkflowAgentTime(meta.activeSegments, wf.spans)
     };
@@ -1907,12 +2079,16 @@ async function getCachedDetail(f) {
     const sessionId = sessionIdFromFileName(f.fileName);
     await applySubagentUsage(meta, rawLines, f);
     const wf = await scanWorkflowAggregate(path.dirname(f.fullPath), sessionId);
+    const cwd = meta.cwd ?? decodeProjectName(f.projectDir);
+    const project = resolveProjectIdentity(cwd);
     const detail = {
       ...meta,
       id: sessionId,
       filePath: f.fullPath,
       projectDir: f.projectDir,
-      projectName: meta.cwd ?? decodeProjectName(f.projectDir),
+      projectName: project.projectName,
+      worktreeName: project.worktreeName,
+      repoName: project.repoName,
       events,
       ...wf.workflowCount > 0 ? { workflowCount: wf.workflowCount, spawnedAgentCount: wf.spawnedAgentCount } : {},
       ...foldWorkflowAgentTime(meta.activeSegments, wf.spans)
@@ -2404,19 +2580,25 @@ async function listProjects(root = DEFAULT_ROOT) {
       cur.lastActiveMs = f.mtimeMs;
     byRawDir.set(f.projectDir, cur);
   }
-  const cwdForProject = (dir) => {
+  const cachedIdentityForProject = (dir) => {
     for (const [, entry] of metaCache.entries()) {
-      if (entry.meta.projectDir === dir && entry.meta.cwd) {
-        return entry.meta.cwd;
+      if (entry.meta.projectDir === dir) {
+        return {
+          cwd: entry.meta.cwd,
+          projectName: entry.meta.projectName,
+          worktreeName: entry.meta.worktreeName
+        };
       }
     }
     return void 0;
   };
   const canonicalMap = /* @__PURE__ */ new Map();
   for (const [rawDir, { count, lastActiveMs }] of byRawDir) {
-    const cwdOrDecoded = cwdForProject(rawDir) ?? decodeProjectName(rawDir);
-    const repo = projectRepoName(cwdOrDecoded);
-    const wt = worktreeName(cwdOrDecoded);
+    const cached = cachedIdentityForProject(rawDir);
+    const cwdOrDecoded = cached?.cwd ?? decodeProjectName(rawDir);
+    const projectName = cached?.projectName ?? canonicalProjectName(cwdOrDecoded);
+    const wt = cached?.worktreeName ?? worktreeName(cwdOrDecoded) ?? void 0;
+    const repo = projectKey(projectName);
     const agg = canonicalMap.get(repo) ?? {
       canonicalName: repo,
       count: 0,
@@ -2482,6 +2664,7 @@ var init_claude_code = __esm({
     "use strict";
     init_parser();
     init_analytics();
+    init_git_project();
     init_team();
     init_agent_metadata();
     init_calibration();
@@ -2788,13 +2971,16 @@ function parseRollout(file, lines) {
   const activeSegments = computeActiveSegments2(tsMs);
   const airTimeMs = activeSegments.reduce((acc, s) => acc + (s.endMs - s.startMs), 0);
   const durationMs = firstTimestamp && lastTimestamp ? Date.parse(lastTimestamp) - Date.parse(firstTimestamp) : void 0;
-  const projectName = cwd ? canonicalProjectName(cwd) : "(unknown)";
+  const project = cwd ? resolveProjectIdentity(cwd) : void 0;
+  const projectName = project?.projectName ?? "(unknown)";
   const projectDir = cwd ? cwd.replace(/^\//, "-").replace(/\//g, "-") : "(unknown)";
   const meta = {
     agent: "codex",
     id: file.sessionId,
     filePath: file.filePath,
     projectName,
+    worktreeName: project?.worktreeName,
+    repoName: project?.repoName,
     projectDir,
     sessionId: file.sessionId,
     firstTimestamp,
@@ -2926,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,
@@ -2953,6 +3142,7 @@ var init_codex = __esm({
   "../parser/dist/codex.js"() {
     "use strict";
     init_analytics();
+    init_git_project();
     init_user_input();
     DEFAULT_CODEX_ROOT = path2.join(os2.homedir(), ".codex", "sessions");
     ROLLOUT_RE = /^rollout-(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2})-([0-9a-f-]+)\.jsonl$/;
@@ -3332,13 +3522,16 @@ async function parseSession(file) {
   const airTimeMs = activeSegments.reduce((acc, s) => acc + (s.endMs - s.startMs), 0);
   const durationMs = firstTimestamp && lastTimestamp ? Date.parse(lastTimestamp) - Date.parse(firstTimestamp) : void 0;
   const sessionId = metaRec.sessionId ?? file.filenameId;
-  const projectName = cwd ? canonicalProjectName(cwd) : file.slug;
+  const project = cwd ? resolveProjectIdentity(cwd) : void 0;
+  const projectName = project?.projectName ?? file.slug;
   const projectDir = cwd ? cwd.replace(/^\//, "-").replace(/\//g, "-") : file.slug;
   const meta = {
     agent: "gemini",
     id: sessionId,
     filePath: file.filePath,
     projectName,
+    worktreeName: project?.worktreeName,
+    repoName: project?.repoName,
     projectDir,
     sessionId,
     firstTimestamp,
@@ -3452,6 +3645,7 @@ var init_gemini = __esm({
   "../parser/dist/gemini.js"() {
     "use strict";
     init_analytics();
+    init_git_project();
     init_user_input();
     DEFAULT_GEMINI_ROOT = path3.join(os3.homedir(), ".gemini", "tmp");
     GEMINI_PROJECTS_FILE = path3.join(os3.homedir(), ".gemini", "projects.json");
@@ -3725,13 +3919,16 @@ async function parseSession2(file) {
   const durationMs = firstTimestamp && lastTimestamp ? Date.parse(lastTimestamp) - Date.parse(firstTimestamp) : void 0;
   const sessionId = file.conversationId;
   const cwd = file.cwd;
-  const projectName = cwd ? canonicalProjectName(cwd) : file.conversationId;
+  const project = cwd ? resolveProjectIdentity(cwd) : void 0;
+  const projectName = project?.projectName ?? file.conversationId;
   const projectDir = cwd ? cwd.replace(/^\//, "-").replace(/\//g, "-") : file.conversationId;
   const meta = {
     agent: "antigravity",
     id: sessionId,
     filePath: file.filePath,
     projectName,
+    worktreeName: project?.worktreeName,
+    repoName: project?.repoName,
     projectDir,
     sessionId,
     firstTimestamp,
@@ -3838,6 +4035,7 @@ var init_antigravity = __esm({
   "../parser/dist/antigravity.js"() {
     "use strict";
     init_analytics();
+    init_git_project();
     init_user_input();
     DEFAULT_ANTIGRAVITY_ROOT = path4.join(os4.homedir(), ".gemini", "antigravity-cli");
     IDLE_GAP_MS3 = 3 * 60 * 1e3;
@@ -3957,8 +4155,10 @@ function resolveProject(meta, spaceIdToPath) {
   if (!projectPath) {
     return { projectName: "cowork:unspaced", projectDir: "cowork-unspaced" };
   }
+  const project = resolveProjectIdentity(projectPath);
   return {
-    projectName: canonicalProjectName(projectPath),
+    projectName: project.projectName,
+    worktreeName: project.worktreeName,
     projectDir: projectPath.replace(/^\//, "-").replace(/\//g, "-"),
     cwd: projectPath
   };
@@ -4185,8 +4385,8 @@ var DEFAULT_COWORK_ROOT, SESSION_ID_RE, spacesCache, metaCache5, detailCache5;
 var init_cowork = __esm({
   "../parser/dist/cowork.js"() {
     "use strict";
-    init_analytics();
     init_claude_code();
+    init_git_project();
     init_parser();
     DEFAULT_COWORK_ROOT = defaultCoworkRoot();
     SESSION_ID_RE = /^local_[0-9a-f-]+$/;
@@ -4197,36 +4397,36 @@ var init_cowork = __esm({
 });
 
 // ../parser/dist/team-config.js
-import { readFileSync as readFileSync3, writeFileSync, unlinkSync, mkdirSync as mkdirSync2, renameSync } from "node:fs";
-import { join as join2 } from "node:path";
-function shouldSyncProject(repoName, sp) {
+import { readFileSync as readFileSync3, writeFileSync, unlinkSync, mkdirSync, renameSync } from "node:fs";
+import { join as join3 } from "node:path";
+function shouldSyncProject(projectKey2, sp) {
   if (!sp)
     return true;
-  if (sp.excluded.includes(repoName))
+  if (sp.excluded.includes(projectKey2))
     return false;
-  if (sp.included.includes(repoName))
+  if (sp.included.includes(projectKey2))
     return true;
   return sp.autoIncludeNew;
 }
 function readTeamConfig(dir) {
   const d = dir ?? cclensHome();
   try {
-    return JSON.parse(readFileSync3(join2(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 });
-  const tmp = join2(d, `${CONFIG_FILE}.${process.pid}.tmp`);
+  mkdirSync(d, { recursive: true });
+  const tmp = join3(d, `${CONFIG_FILE}.${process.pid}.tmp`);
   writeFileSync(tmp, JSON.stringify(config, null, 2), { mode: 384 });
-  renameSync(tmp, join2(d, CONFIG_FILE));
+  renameSync(tmp, join3(d, CONFIG_FILE));
 }
 function clearTeamConfig(dir) {
   const d = dir ?? cclensHome();
   try {
-    unlinkSync(join2(d, CONFIG_FILE));
+    unlinkSync(join3(d, CONFIG_FILE));
   } catch {
   }
 }
@@ -4259,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,
@@ -4292,14 +4493,17 @@ __export(fs_exports, {
   loadTeamForSession: () => loadTeamForSession,
   loadUsageByDay: () => loadUsageByDay,
   loadWorkflowAgentDetail: () => loadWorkflowAgentDetail,
+  pruneUsageAgent: () => pruneUsageAgent,
+  readGitFolder: () => readGitFolder,
   readJsonlFile: () => readJsonlFile,
   readTeamConfig: () => readTeamConfig,
+  resolveProjectIdentity: () => resolveProjectIdentity,
   sessionIdFromFileName: () => sessionIdFromFileName,
   shouldSyncProject: () => shouldSyncProject,
   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() {
@@ -4345,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 {
@@ -4569,6 +4794,7 @@ var init_fs = __esm({
     init_antigravity();
     init_cowork();
     init_claude_code();
+    init_git_project();
     init_codex();
     init_gemini();
     init_antigravity();
@@ -4636,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"() {
@@ -5053,11 +5326,13 @@ __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,
   buildMegaRows: () => buildMegaRows,
   buildPresentation: () => buildPresentation,
+  buildProjectKeyResolver: () => buildProjectKeyResolver,
   buildSpendIndex: () => buildSpendIndex,
   calendarMonth: () => calendarMonth,
   calendarWeek: () => calendarWeek,
@@ -5086,10 +5361,12 @@ __export(dist_exports, {
   predictAnchored: () => predictAnchored,
   priorCalendarMonth: () => priorCalendarMonth,
   priorCalendarWeek: () => priorCalendarWeek,
+  projectKey: () => projectKey,
   projectRepoName: () => projectRepoName,
   rowPrimaryIndex: () => rowPrimaryIndex,
   sessionAirTimeMs: () => sessionAirTimeMs,
   sessionDay: () => sessionDay,
+  sessionProjectKey: () => sessionProjectKey,
   stripFrameworkBoilerplate: () => stripFrameworkBoilerplate,
   summarizeBursts: () => summarizeBursts,
   toLocalDay: () => toLocalDay,
@@ -5118,25 +5395,25 @@ __export(file_probe_exports, {
   probeArtifactSignals: () => probeArtifactSignals
 });
 import { createHash } from "node:crypto";
-import { existsSync as existsSync6, readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join as join7, relative, resolve as resolve2, sep } from "node:path";
+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";
 function pathHash(relPath) {
   return createHash("sha256").update(relPath.split(sep).join("/")).digest("hex").slice(0, 32);
 }
 function defaultScanRoots(extraRoots = []) {
   const roots = [];
-  const home = join7(homedir2(), ".claude");
-  if (existsSync6(home)) roots.push({ root: home, label: "user" });
+  const home = join8(homedir3(), ".claude");
+  if (existsSync9(home)) roots.push({ root: home, label: "user" });
   for (const e of extraRoots) {
-    const r = resolve2(e, ".claude");
-    if (existsSync6(r) && r !== home) roots.push({ root: r, label: "project" });
+    const r = resolve3(e, ".claude");
+    if (existsSync9(r) && r !== home) roots.push({ root: r, label: "project" });
   }
   return roots;
 }
 function listMarkdownFiles(dir) {
-  if (!existsSync6(dir)) return [];
+  if (!existsSync9(dir)) return [];
   const out = [];
   let entries;
   try {
@@ -5146,10 +5423,10 @@ function listMarkdownFiles(dir) {
   }
   for (const name of entries) {
     if (name.startsWith(".")) continue;
-    const full = join7(dir, name);
+    const full = join8(dir, name);
     let stat;
     try {
-      stat = statSync4(full);
+      stat = statSync5(full);
     } catch {
       continue;
     }
@@ -5166,19 +5443,19 @@ function firstSeenDateOf(file) {
     const out = execFileSync2(
       "git",
       ["log", "--diff-filter=A", "--follow", "--format=%cs", "--", file],
-      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname7(file) }
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname8(file) }
     ).trim().split("\n").filter(Boolean);
     if (out.length > 0) return out[out.length - 1];
   } catch {
   }
   try {
-    const s = statSync4(file);
+    const s = statSync5(file);
     return localDay(s.birthtime || s.mtime);
   } catch {
     return todayLocal();
   }
 }
-function dirname7(p) {
+function dirname8(p) {
   const i = p.lastIndexOf(sep);
   return i < 0 ? "." : p.slice(0, i);
 }
@@ -5205,8 +5482,8 @@ function todayLocal() {
 function scanAuthored(roots, subdir, day) {
   const out = [];
   for (const r of roots) {
-    const dir = join7(r.root, subdir);
-    if (!existsSync6(dir)) continue;
+    const dir = join8(r.root, subdir);
+    if (!existsSync9(dir)) continue;
     for (const f of listMarkdownFiles(dir)) {
       const firstSeen = firstSeenDateOf(f);
       if (firstSeen !== day) continue;
@@ -5219,14 +5496,14 @@ function scanAuthored(roots, subdir, day) {
 function scanEdited(roots, day) {
   const out = [];
   for (const r of roots) {
-    const dir = join7(r.root, "skills");
-    if (!existsSync6(dir)) continue;
+    const dir = join8(r.root, "skills");
+    if (!existsSync9(dir)) continue;
     for (const f of listMarkdownFiles(dir)) {
       const firstSeen = firstSeenDateOf(f);
       if (firstSeen === day) continue;
       let stat;
       try {
-        stat = statSync4(f);
+        stat = statSync5(f);
       } catch {
         continue;
       }
@@ -5242,17 +5519,17 @@ function claudemdLineDelta(extraRoots, authorEmail, day) {
   let delta = 0;
   const candidates = [];
   for (const e of extraRoots) {
-    const f = resolve2(e, "CLAUDE.md");
-    if (existsSync6(f)) candidates.push(f);
+    const f = resolve3(e, "CLAUDE.md");
+    if (existsSync9(f)) candidates.push(f);
   }
-  const homeClaudeMd = join7(homedir2(), "CLAUDE.md");
-  if (existsSync6(homeClaudeMd)) candidates.push(homeClaudeMd);
+  const homeClaudeMd = join8(homedir3(), "CLAUDE.md");
+  if (existsSync9(homeClaudeMd)) candidates.push(homeClaudeMd);
   for (const file of candidates) {
     try {
       const out = execFileSync2(
         "git",
         ["log", "--numstat", "--format=COMMIT %cs %ae", "--", file],
-        { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname7(file) }
+        { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname8(file) }
       );
       let currentDate = "";
       let currentEmail = "";
@@ -5303,8 +5580,8 @@ var init_file_probe = __esm({
 
 // src/daemon-worker.ts
 import { spawn as spawn2 } from "node:child_process";
-import { closeSync, existsSync as existsSync13, mkdirSync as mkdirSync13, openSync, readFileSync as readFileSync16, writeFileSync as writeFileSync12 } from "node:fs";
-import { dirname as dirname10, join as join11 } from "node:path";
+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";
 
 // src/usage/token.ts
@@ -5445,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}
 `,
@@ -5486,9 +5867,9 @@ import { randomUUID } from "node:crypto";
 
 // ../entries/dist/fs.js
 init_fs();
-import { readFileSync as readFileSync5, readdirSync as readdirSync2, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, renameSync as renameSync3, existsSync as existsSync3 } 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 join4 } from "node:path";
+import { join as join5 } from "node:path";
 
 // ../entries/dist/types.js
 var CURRENT_ENTRY_SCHEMA_VERSION = 2;
@@ -5561,12 +5942,12 @@ var PROMPT_FRAME_ORIGIN = {
 
 // ../entries/dist/digest-fs.js
 init_fs();
-import { readFileSync as readFileSync4, readdirSync, writeFileSync as writeFileSync2, renameSync as renameSync2, chmodSync, mkdirSync as mkdirSync3, existsSync as existsSync2 } from "node:fs";
-import { dirname as dirname2, join as join3 } from "node:path";
+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(readFileSync4(path7, "utf8"));
+    const parsed = JSON.parse(readFileSync7(path7, "utf8"));
     if (!parsed || typeof parsed !== "object")
       return null;
     if (parsed.version !== expectedVersion)
@@ -5586,16 +5967,16 @@ function digestsDir() {
   return digestsDirCached;
 }
 function dayDigestPath(date) {
-  return join3(digestsDir(), "day", `${date}.json`);
+  return join4(digestsDir(), "day", `${date}.json`);
 }
 function weekDigestPath(monday) {
-  return join3(digestsDir(), "week", `${monday}.json`);
+  return join4(digestsDir(), "week", `${monday}.json`);
 }
 function writeDayDigest(digest) {
   const final = dayDigestPath(digest.key);
-  mkdirSync3(dirname2(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);
@@ -5606,7 +5987,7 @@ function writeDayDigest(digest) {
 }
 function readDayDigest(date) {
   const p = dayDigestPath(date);
-  if (!existsSync2(p))
+  if (!existsSync5(p))
     return null;
   return parseDigestFile(p, CURRENT_DAY_DIGEST_SCHEMA_VERSION);
 }
@@ -5626,9 +6007,9 @@ function setTodayDigestInCache(date, digest, nowMs) {
 }
 function writeWeekDigest(digest) {
   const final = weekDigestPath(digest.key);
-  mkdirSync3(dirname2(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);
@@ -5639,7 +6020,7 @@ function writeWeekDigest(digest) {
 }
 function readWeekDigest(monday) {
   const p = weekDigestPath(monday);
-  if (!existsSync2(p))
+  if (!existsSync5(p))
     return null;
   return parseDigestFile(p, CURRENT_WEEK_DIGEST_SCHEMA_VERSION);
 }
@@ -5669,18 +6050,18 @@ function entriesDir() {
   return entriesDirCached;
 }
 function pathFor(sessionId, localDay2) {
-  return join4(entriesDir(), `${entryKey(sessionId, localDay2)}.json`);
+  return join5(entriesDir(), `${entryKey(sessionId, localDay2)}.json`);
 }
 function tmpPathFor(final) {
   return `${final}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
 }
 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([
@@ -5704,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;
@@ -5712,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 (!existsSync3(p))
+  if (!existsSync6(p))
     return null;
-  const raw = readFileSync5(p, "utf8");
+  const raw = readFileSync8(p, "utf8");
   return JSON.parse(raw);
 }
 function entryExists(sessionId, localDay2) {
-  return existsSync3(pathFor(sessionId, localDay2));
+  return existsSync6(pathFor(sessionId, localDay2));
 }
 function listEntryKeys() {
   const dir = entriesDir();
-  if (!existsSync3(dir))
+  if (!existsSync6(dir))
     return [];
   return readdirSync2(dir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
 }
@@ -5746,8 +6127,8 @@ function listEntriesForDay(localDay2) {
 
 // src/perception/build-entries.ts
 init_dist();
-import { statSync, readFileSync as readFileSync6 } from "node:fs";
-import { basename, dirname as dirname3 } from "node:path";
+import { statSync as statSync2, readFileSync as readFileSync9 } from "node:fs";
+import { basename as basename2, dirname as dirname4 } from "node:path";
 
 // ../entries/dist/signals.js
 init_dist();
@@ -6338,6 +6719,7 @@ function buildEntries(sessionDetail) {
   const entries = [];
   const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
   const sessionFallbackProject = canonicalProjectName(sessionDetail.projectName ?? "");
+  const trustSessionProject = !!sessionDetail.worktreeName;
   for (const [local_day, dayEvents] of byDay) {
     if (dayEvents.length === 0)
       continue;
@@ -6402,7 +6784,7 @@ function buildEntries(sessionDetail) {
     const finalAgentRaw = agg.finalAgent ?? "";
     const final_agent = trunc(minimizeImages(finalAgentRaw), 400);
     let project = sessionFallbackProject;
-    if (agg.cwdCounts.size > 0) {
+    if (!trustSessionProject && agg.cwdCounts.size > 0) {
       const best = [...agg.cwdCounts.entries()].sort((a, b) => b[1] - a[1])[0];
       project = canonicalProjectName(best[0]);
     }
@@ -6484,8 +6866,8 @@ function decodeProjectDirName(projectDir) {
   return projectDir.replace(/-/g, "/");
 }
 function buildEntriesForFile(filePath) {
-  const stat = statSync(filePath);
-  const raw = readFileSync6(filePath, "utf8");
+  const stat = statSync2(filePath);
+  const raw = readFileSync9(filePath, "utf8");
   const rawLines = raw.split("\n").filter(Boolean).map((l) => {
     try {
       return JSON.parse(l);
@@ -6495,8 +6877,8 @@ function buildEntriesForFile(filePath) {
   }).filter((x) => x !== null);
   if (rawLines.length === 0) return null;
   const { meta, events } = parseTranscript(rawLines);
-  const fileName = basename(filePath);
-  const projectDir = basename(dirname3(filePath));
+  const fileName = basename2(filePath);
+  const projectDir = basename2(dirname4(filePath));
   const sessionId = fileName.replace(/\.jsonl$/, "");
   const sd = {
     ...meta,
@@ -6577,7 +6959,7 @@ function clipSegmentsToDay(segments, bounds) {
 }
 function filterSyncedSessions(sessions, syncProjects) {
   if (!syncProjects) return sessions;
-  return sessions.filter((s) => shouldSyncProject(projectRepoName(s.projectName), syncProjects));
+  return sessions.filter((s) => shouldSyncProject(projectKey(s.projectName), syncProjects));
 }
 function sessionTouchesDay(s, day) {
   const bounds = dayBoundsMs(day);
@@ -6618,7 +7000,7 @@ function buildRichRollupBlocks(day, daySessions, entries, resolveRepo) {
   const projects = /* @__PURE__ */ new Map();
   for (const s of clippedSessions) {
     const canonical = canonicalProjectName(s.projectName);
-    const name = projectRepoName(s.projectName);
+    const name = projectKey(s.projectName);
     const repo = resolveRepo?.(canonical) ?? sessionRepo.get(s.id);
     const key = repo ?? name;
     const ms = s.activeSegments.reduce((sum, seg) => sum + (seg.endMs - seg.startMs), 0);
@@ -6661,7 +7043,7 @@ function buildRichRollupBlocks(day, daySessions, entries, resolveRepo) {
     commits += e.numbers.commits;
     pushes += e.numbers.pushes;
     if (e.github_repos?.length) {
-      const key = sessionRepo.get(e.session_id) ?? projectRepoName(e.project);
+      const key = sessionRepo.get(e.session_id) ?? projectKey(e.project);
       const set = projectRepos.get(key) ?? /* @__PURE__ */ new Set();
       for (const r of e.github_repos) set.add(r);
       projectRepos.set(key, set);
@@ -6746,7 +7128,7 @@ function buildIngestPayload(inputs) {
   return {
     ingestId: randomUUID(),
     observedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    cliVersion: "0.15.2",
+    cliVersion: "0.15.4",
     ...richRollup || inputs.enrichedExtras || inputs.artifactSignals ? { schemaVersion: RICH_ROLLUP_SCHEMA_VERSION } : {},
     ...inputs.rollup ? { dailyRollup: inputs.rollup } : {},
     ...richRollup ? { richRollup } : {},
@@ -6773,14 +7155,14 @@ async function pushToTeamServer(config, payload) {
 }
 
 // src/team/git-remote.ts
-import { existsSync as existsSync4, readFileSync as readFileSync7, statSync as statSync2 } from "node:fs";
-import { dirname as dirname4, isAbsolute, join as join5, resolve } from "node:path";
+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) {
   const m = url.trim().match(GITHUB_URL_RE);
   return m ? `${m[1]}/${m[2]}`.toLowerCase() : null;
 }
-function originUrl(configText) {
+function originUrl2(configText) {
   let inOrigin = false;
   for (const line of configText.split("\n")) {
     const t = line.trim();
@@ -6795,36 +7177,36 @@ function originUrl(configText) {
   return null;
 }
 function gitConfigPathFor(dir) {
-  const dotGit = join5(dir, ".git");
-  const st = statSync2(dotGit, { throwIfNoEntry: false });
+  const dotGit = join6(dir, ".git");
+  const st = statSync3(dotGit, { throwIfNoEntry: false });
   if (!st) return null;
-  if (st.isDirectory()) return join5(dotGit, "config");
-  const m = readFileSync7(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
+  if (st.isDirectory()) return join6(dotGit, "config");
+  const m = readFileSync10(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
   if (!m) return null;
-  const gd = isAbsolute(m[1]) ? m[1] : resolve(dir, m[1]);
-  const commondirFile = join5(gd, "commondir");
-  if (existsSync4(commondirFile)) {
-    const common = readFileSync7(commondirFile, "utf8").trim();
-    return join5(isAbsolute(common) ? common : resolve(gd, common), "config");
+  const gd = isAbsolute2(m[1]) ? m[1] : resolve2(dir, m[1]);
+  const commondirFile = join6(gd, "commondir");
+  if (existsSync7(commondirFile)) {
+    const common = readFileSync10(commondirFile, "utf8").trim();
+    return join6(isAbsolute2(common) ? common : resolve2(gd, common), "config");
   }
-  return join5(gd, "config");
+  return join6(gd, "config");
 }
 function createRepoResolver() {
   const cache = /* @__PURE__ */ new Map();
   return (dir) => {
-    if (!dir || !isAbsolute(dir)) return null;
+    if (!dir || !isAbsolute2(dir)) return null;
     const hit = cache.get(dir);
     if (hit !== void 0) return hit;
     let repo = null;
     try {
-      for (let d = dir; ; d = dirname4(d)) {
+      for (let d = dir; ; d = dirname5(d)) {
         const config = gitConfigPathFor(d);
-        if (config && existsSync4(config)) {
-          const url = originUrl(readFileSync7(config, "utf8"));
+        if (config && existsSync7(config)) {
+          const url = originUrl2(readFileSync10(config, "utf8"));
           repo = url ? parseGithubRemote(url) : null;
           break;
         }
-        if (d === dirname4(d)) break;
+        if (d === dirname5(d)) break;
       }
     } catch {
       repo = null;
@@ -6836,17 +7218,17 @@ function createRepoResolver() {
 
 // src/team/queue.ts
 init_fs();
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync4, appendFileSync as appendFileSync3, statSync as statSync3, mkdirSync as mkdirSync5 } from "node:fs";
-import { dirname as dirname5 } from "node:path";
+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(dirname5(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 } = statSync3(queuePath);
+    const { size } = statSync4(queuePath);
     if (size > MAX_SIZE_BYTES) {
       pruneOldest(queuePath);
     }
@@ -6856,7 +7238,7 @@ function enqueuePayload(payload, queuePath = QUEUE_PATH) {
 function dequeuePayloads(queuePath = QUEUE_PATH) {
   let lines;
   try {
-    lines = readFileSync8(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync11(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return [];
   }
@@ -6871,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 = readFileSync8(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
@@ -6890,8 +7272,8 @@ init_storage();
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/usage/profile.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync6, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname6 } from "node:path";
+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";
 var PROFILE_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -6934,9 +7316,9 @@ async function fetchProfile(nowMs = Date.now()) {
   };
 }
 function readCachedProfile(cachePath) {
-  if (!existsSync5(cachePath)) return null;
+  if (!existsSync8(cachePath)) return null;
   try {
-    const raw = JSON.parse(readFileSync9(cachePath, "utf8"));
+    const raw = JSON.parse(readFileSync12(cachePath, "utf8"));
     if (typeof raw.fetchedAtMs !== "number" || !raw.profile) return null;
     return raw;
   } catch {
@@ -6944,8 +7326,8 @@ function readCachedProfile(cachePath) {
   }
 }
 function writeCachedProfile(cachePath, profile, nowMs = Date.now()) {
-  mkdirSync6(dirname6(cachePath), { recursive: true });
-  writeFileSync5(
+  mkdirSync7(dirname7(cachePath), { recursive: true });
+  writeFileSync7(
     cachePath,
     JSON.stringify({ fetchedAtMs: nowMs, profile }, null, 2),
     { mode: 384 }
@@ -7105,13 +7487,13 @@ async function runTeamBackfill(log3 = noopLog, filePath = USAGE_LOG, configOverr
 
 // src/team/sync-log.ts
 init_fs();
-import { readFileSync as readFileSync10 } 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 = readFileSync10(cclensPath("daemon.log"), "utf8");
+    raw = readFileSync13(cclensPath("daemon.log"), "utf8");
   } catch {
     return { lines: [] };
   }
@@ -7131,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 { join as join6 } from "node:path";
+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(join6(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);
@@ -7161,8 +7543,8 @@ async function dispatchCommand(command, config, log3) {
   }
 }
 async function runActivityBackfill(command, config, log3) {
-  const { listSessions: listSessions2, shouldSyncProject: shouldSyncProject2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-  const { toLocalDay: toLocalDay3, projectRepoName: projectRepoName2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+  const { listSessions: listSessions2, resolveProjectIdentity: resolveProjectIdentity2, shouldSyncProject: shouldSyncProject2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+  const { toLocalDay: toLocalDay3, projectKey: projectKey2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
   const { probeArtifactSignals: probeArtifactSignals2 } = await Promise.resolve().then(() => (init_file_probe(), file_probe_exports));
   const days = command.params.days;
   const todayMs = Date.now();
@@ -7196,7 +7578,7 @@ async function runActivityBackfill(command, config, log3) {
     const richBlocks = buildRichBlocksForDay(rollup.day, daySessions, resolveRepo);
     let artifactSignals = null;
     try {
-      const cwdAllowed = shouldSyncProject2(projectRepoName2(process.cwd()), config.syncProjects);
+      const cwdAllowed = shouldSyncProject2(projectKey2(resolveProjectIdentity2(process.cwd()).projectName), config.syncProjects);
       artifactSignals = probeArtifactSignals2({ day: rollup.day, extraRoots: cwdAllowed ? [process.cwd()] : [] });
     } catch {
     }
@@ -7227,6 +7609,7 @@ async function runActivityBackfill(command, config, log3) {
 }
 
 // src/team/sync.ts
+init_dist();
 init_fs();
 var inFlightCommands = /* @__PURE__ */ new Set();
 var USAGE_LOG2 = cclensPath("usage.jsonl");
@@ -7341,7 +7724,7 @@ async function runTeamSync(log3 = noopLog2, configOverride, options = {}) {
   try {
     resetEnsuredSessions();
     const { listSessions: listSessions2, loadCalibrationCurve: loadCalibrationCurve2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-    const { toLocalDay: toLocalDay3, projectRepoName: projectRepoName2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+    const { toLocalDay: toLocalDay3 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
     const today = toLocalDay3(Date.now());
     let patches = {};
     const persistConfig = (patch) => {
@@ -7528,7 +7911,7 @@ async function runTeamSync(log3 = noopLog2, configOverride, options = {}) {
       } : void 0;
       let artifactSignals = null;
       try {
-        const cwdAllowed = shouldSyncProject(projectRepoName2(process.cwd()), config.syncProjects);
+        const cwdAllowed = shouldSyncProject(projectKey(resolveProjectIdentity(process.cwd()).projectName), config.syncProjects);
         artifactSignals = probeArtifactSignals2({ day: rollup.day, extraRoots: cwdAllowed ? [process.cwd()] : [] });
       } catch {
       }
@@ -7715,13 +8098,13 @@ async function buildCyclePeaksForPush(planTier, loadCurve) {
 }
 
 // src/perception/worker.ts
-import { statSync as statSync5 } from "node:fs";
+import { statSync as statSync6 } from "node:fs";
 init_fs();
 
 // src/perception/state.ts
 init_fs();
-import { existsSync as existsSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync8, renameSync as renameSync4 } from "node:fs";
-import { dirname as dirname8 } from "node:path";
+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;
 function statePath() {
@@ -7731,7 +8114,7 @@ function statePath() {
 }
 function readState() {
   const p = statePath();
-  if (!existsSync7(p)) {
+  if (!existsSync10(p)) {
     return {
       sweep_in_progress: false,
       last_sweep_started_at: null,
@@ -7739,14 +8122,14 @@ function readState() {
       file_checkpoints: {}
     };
   }
-  const raw = readFileSync11(p, "utf8");
+  const raw = readFileSync14(p, "utf8");
   return JSON.parse(raw);
 }
 function writeState(s) {
   const p = statePath();
-  mkdirSync8(dirname8(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() {
@@ -7776,17 +8159,17 @@ function updateCheckpoint(jsonlPath, cp) {
 
 // src/perception/scan.ts
 import { readdirSync as readdirSync4 } from "node:fs";
-import { join as join8 } from "node:path";
-import { homedir as homedir3 } from "node:os";
+import { join as join9 } from "node:path";
+import { homedir as homedir4 } from "node:os";
 async function listAllSessionJsonls(root) {
-  const projectsRoot = root ?? join8(homedir3(), ".claude", "projects");
+  const projectsRoot = root ?? join9(homedir4(), ".claude", "projects");
   const out = [];
   try {
     for (const project of readdirSync4(projectsRoot)) {
-      const dir = join8(projectsRoot, project);
+      const dir = join9(projectsRoot, project);
       try {
         for (const f of readdirSync4(dir)) {
-          if (f.endsWith(".jsonl")) out.push(join8(dir, f));
+          if (f.endsWith(".jsonl")) out.push(join9(dir, f));
         }
       } catch {
       }
@@ -7813,7 +8196,7 @@ async function runPerceptionSweep(opts = {}) {
     const files = await listAllSessionJsonls(opts.projectsRoot);
     for (const f of files) {
       try {
-        const stat = statSync5(f);
+        const stat = statSync6(f);
         const prev = state.file_checkpoints[f];
         if (prev && prev.byte_offset >= stat.size) continue;
         const built = buildEntriesForFile(f);
@@ -7845,7 +8228,7 @@ async function runPerceptionSweep(opts = {}) {
               const built = buildEntries(detail);
               for (const e of built) {
                 try {
-                  const stat = statSync5(meta.filePath);
+                  const stat = statSync6(meta.filePath);
                   e.source_checkpoint.byte_offset = stat.size;
                 } catch {
                 }
@@ -12002,14 +12385,14 @@ 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 existsSync9 } from "node:fs";
-import { join as join10 } from "node:path";
+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 existsSync8, readdirSync as readdirSync5, realpathSync, readFileSync as readFileSync12, unlinkSync as unlinkSync3, renameSync as renameSync5 } from "node:fs";
-import { join as join9 } from "node:path";
-import { homedir as homedir4 } from "node:os";
+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";
 var TmuxUnavailableError = class extends Error {
   constructor(message) {
@@ -12037,16 +12420,16 @@ function tmuxRunnerAvailable() {
   return { ok: true };
 }
 function runtimeCwd() {
-  const dir = join9(homedir4(), ".cclens", "runtime");
-  if (!existsSync8(dir))
-    mkdirSync9(dir, { recursive: true });
-  return realpathSync(dir);
+  const dir = join10(homedir5(), ".cclens", "runtime");
+  if (!existsSync11(dir))
+    mkdirSync10(dir, { recursive: true });
+  return realpathSync2(dir);
 }
 function ensureRuntimeCwdTrusted(cwd) {
-  const cfgPath = join9(homedir4(), ".claude.json");
+  const cfgPath = join10(homedir5(), ".claude.json");
   let cfg;
   try {
-    cfg = JSON.parse(readFileSync12(cfgPath, "utf8"));
+    cfg = JSON.parse(readFileSync15(cfgPath, "utf8"));
   } catch {
     return;
   }
@@ -12061,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 {
@@ -12089,16 +12472,16 @@ async function runClaudeUnderTmuxImpl(args) {
   ensureRuntimeCwdTrusted(cwd);
   const runId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   const sessionName = `cclens-${runId}`;
-  const systemFile = join9(cwd, `system-${runId}.txt`);
-  const userFile = join9(cwd, `user-${runId}.txt`);
-  const wrapper = join9(cwd, `run-${runId}.sh`);
-  writeFileSync8(systemFile, args.systemPrompt);
-  writeFileSync8(userFile, args.reminder ? `${args.userPrompt}
+  const systemFile = join10(cwd, `system-${runId}.txt`);
+  const userFile = join10(cwd, `user-${runId}.txt`);
+  const wrapper = join10(cwd, `run-${runId}.sh`);
+  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)} \\
@@ -12170,7 +12553,7 @@ function num(v) {
 function sleep(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
-var PROJECTS_ROOT = () => join9(homedir4(), ".claude", "projects");
+var PROJECTS_ROOT = () => join10(homedir5(), ".claude", "projects");
 function snapshotAllTranscripts() {
   const out = /* @__PURE__ */ new Set();
   const root = PROJECTS_ROOT();
@@ -12181,7 +12564,7 @@ function snapshotAllTranscripts() {
     return out;
   }
   for (const sub of subs) {
-    const dir = join9(root, sub);
+    const dir = join10(root, sub);
     let files;
     try {
       files = readdirSync5(dir);
@@ -12190,7 +12573,7 @@ function snapshotAllTranscripts() {
     }
     for (const f of files) {
       if (f.endsWith(".jsonl"))
-        out.add(join9(dir, f));
+        out.add(join10(dir, f));
     }
   }
   return out;
@@ -12198,7 +12581,7 @@ function snapshotAllTranscripts() {
 function readJsonlCwd(path7, maxLines = 8) {
   let raw;
   try {
-    raw = readFileSync12(path7, "utf8");
+    raw = readFileSync15(path7, "utf8");
   } catch {
     return void 0;
   }
@@ -12231,7 +12614,7 @@ async function discoverTranscript(targetCwd, existingBefore, startMs, timeoutMs,
       subs = [];
     }
     for (const sub of subs) {
-      const dir = join9(root, sub);
+      const dir = join10(root, sub);
       let files;
       try {
         files = readdirSync5(dir);
@@ -12241,7 +12624,7 @@ async function discoverTranscript(targetCwd, existingBefore, startMs, timeoutMs,
       for (const f of files) {
         if (!f.endsWith(".jsonl"))
           continue;
-        const full = join9(dir, f);
+        const full = join10(dir, f);
         if (existingBefore.has(full))
           continue;
         if (readJsonlCwd(full) === targetCwd)
@@ -12255,7 +12638,7 @@ async function discoverTranscript(targetCwd, existingBefore, startMs, timeoutMs,
 function parseTranscript2(path7, defaultModel) {
   let raw;
   try {
-    raw = readFileSync12(path7, "utf8");
+    raw = readFileSync15(path7, "utf8");
   } catch {
     return { assembled: "", inputTokens: 0, outputTokens: 0, modelUsed: defaultModel, done: false };
   }
@@ -12315,7 +12698,7 @@ function cleanup(cwd, runId, tmuxBin, sessionName, transcriptPath) {
     }
     for (const f of [`system-${runId}.txt`, `user-${runId}.txt`, `run-${runId}.sh`]) {
       try {
-        unlinkSync3(join9(cwd, f));
+        unlinkSync3(join10(cwd, f));
       } catch {
       }
     }
@@ -12330,9 +12713,9 @@ function shellEscape(s) {
 // ../entries/dist/llm-runner.js
 var RUNS_DIR = cclensPath("llm-runs");
 function ensureRunsDir() {
-  if (!existsSync9(RUNS_DIR)) {
+  if (!existsSync12(RUNS_DIR)) {
     try {
-      mkdirSync10(RUNS_DIR, { recursive: true });
+      mkdirSync11(RUNS_DIR, { recursive: true });
     } catch {
     }
   }
@@ -12359,17 +12742,17 @@ function newRunId(kind) {
   return `${ts}_${kind}_${short}`;
 }
 function tracePath(runId) {
-  return join10(RUNS_DIR, `${runId}.jsonl`);
+  return join11(RUNS_DIR, `${runId}.jsonl`);
 }
 function safeAppend(path7, line) {
   try {
-    appendFileSync4(path7, line);
+    appendFileSync5(path7, line);
   } catch {
   }
 }
 function safeWrite(path7, line) {
   try {
-    writeFileSync9(path7, line);
+    writeFileSync11(path7, line);
   } catch {
   }
 }
@@ -12447,7 +12830,7 @@ async function runClaudeSubprocess(args) {
   return runClaudePrintMode(args);
 }
 function runClaudePrintMode(args) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve4, reject) => {
     ensureRunsDir();
     const kind = detectKindFromSystemPrompt(args.systemPrompt);
     const runId = newRunId(kind);
@@ -12578,7 +12961,7 @@ ${args.reminder}` : args.userPrompt;
         reject(new Error(`claude exited ${code}: ${stderr.trim().slice(0, 300)}`));
         return;
       }
-      resolve3({ content: buffer, input_tokens: inputTokens, output_tokens: outputTokens, model: modelUsed });
+      resolve4({ content: buffer, input_tokens: inputTokens, output_tokens: outputTokens, model: modelUsed });
     });
     proc.on("error", (err) => {
       safeAppend(trace, JSON.stringify({ _meta: { type: "spawn_error", run_id: runId, ts: (/* @__PURE__ */ new Date()).toISOString(), error: err.message } }) + "\n");
@@ -12758,8 +13141,8 @@ function applyEnrichmentError(entry, errorMessage, model, costUsd, generatedAt,
 
 // ../entries/dist/budget.js
 init_fs();
-import { appendFileSync as appendFileSync5, readFileSync as readFileSync13, existsSync as existsSync10, mkdirSync as mkdirSync11 } from "node:fs";
-import { dirname as dirname9 } from "node:path";
+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() {
   if (spendPathCached)
@@ -12769,17 +13152,17 @@ function spendPath() {
 }
 function appendSpend(record) {
   const p = spendPath();
-  mkdirSync11(dirname9(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 (!existsSync10(p))
+  if (!existsSync13(p))
     return 0;
   const year = now.getUTCFullYear();
   const month = now.getUTCMonth();
   let total = 0;
-  const raw = readFileSync13(p, "utf8");
+  const raw = readFileSync16(p, "utf8");
   for (const line of raw.split("\n")) {
     if (!line)
       continue;
@@ -12801,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 existsSync11, readFileSync as readFileSync14, statSync as statSync6 } 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;
@@ -12813,7 +13196,7 @@ function lockPath() {
   return lockPathCached;
 }
 function touchLock() {
-  writeFileSync10(lockPath(), String(process.pid), "utf8");
+  writeFileSync12(lockPath(), String(process.pid), "utf8");
 }
 function writeInteractiveLock() {
   touchLock();
@@ -12847,13 +13230,13 @@ function pidAlive(pid) {
 }
 function interactiveLockFresh(nowMs) {
   const p = lockPath();
-  if (!existsSync11(p))
+  if (!existsSync14(p))
     return false;
   try {
-    const mtime = statSync6(p).mtimeMs;
+    const mtime = statSync7(p).mtimeMs;
     if (nowMs - mtime > STALE_MS2)
       return false;
-    const pid = Number(readFileSync14(p, "utf8").trim());
+    const pid = Number(readFileSync17(p, "utf8").trim());
     if (!Number.isFinite(pid) || pid <= 0)
       return false;
     if (!pidAlive(pid))
@@ -12868,7 +13251,7 @@ function interactiveLockFresh(nowMs) {
 var THIRTY_MIN_MS = 30 * 60 * 1e3;
 
 // ../entries/dist/settings.js
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync11, renameSync as renameSync6, chmodSync as chmodSync2, mkdirSync as mkdirSync12, existsSync as existsSync12 } 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: {
@@ -12900,10 +13283,10 @@ function fromDisk(d) {
 }
 function readSettings() {
   const p = settingsPath();
-  if (!existsSync12(p))
+  if (!existsSync15(p))
     return DEFAULT_SETTINGS;
   try {
-    const raw = readFileSync15(p, "utf8");
+    const raw = readFileSync18(p, "utf8");
     return fromDisk(JSON.parse(raw));
   } catch {
     return DEFAULT_SETTINGS;
@@ -15512,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);
@@ -15660,14 +16046,14 @@ async function getUpdateAvailability() {
   if (isDevMode()) return null;
   const latest = await fetchLatestVersion();
   if (latest === null) return {
-    current: "0.15.2",
+    current: "0.15.4",
     latest: null,
     updateAvailable: false
   };
   return {
-    current: "0.15.2",
+    current: "0.15.4",
     latest,
-    updateAvailable: shouldUpdate("0.15.2", latest)
+    updateAvailable: shouldUpdate("0.15.4", latest)
   };
 }
 
@@ -15677,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(dirname10(USAGE_LOG3), { recursive: true });
+mkdirSync14(dirname11(USAGE_LOG3), { recursive: true });
 function log2(level, message) {
   appendDaemonLogLine(level, message);
 }
@@ -15715,14 +16101,14 @@ var perceptionHandle = setInterval(async () => {
 }, PERCEPTION_INTERVAL_MS);
 function readUpdateState() {
   try {
-    return JSON.parse(readFileSync16(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 {
   }
 }
@@ -15735,7 +16121,7 @@ function nextUpdateCheckFromState(nowMs) {
 }
 var nextUpdateCheckAtMs = nextUpdateCheckFromState(Date.now());
 function cliEntryPath() {
-  return join11(dirname10(fileURLToPath(import.meta.url)), "index.js");
+  return join12(dirname11(fileURLToPath(import.meta.url)), "index.js");
 }
 async function runDaemonUpdateCheck() {
   if (process.env.FLEETLENS_DAEMON_AUTO_UPDATE === "0") {
@@ -15767,7 +16153,7 @@ async function runDaemonUpdateCheck() {
       return;
     }
     const entry = cliEntryPath();
-    if (!existsSync13(entry)) {
+    if (!existsSync16(entry)) {
       log2("warn", `update check found ${availability.latest}, but CLI entry is missing at ${entry}`);
       return;
     }
@@ -15830,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);
@@ -15859,7 +16259,7 @@ function scheduleAfter(now, outcome) {
   nextPollAtMs = now + currentIntervalMs;
 }
 function sleep2(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 async function runLoop() {
   while (true) {