fleetlens 0.9.0 → 0.10.1

package/dist/daemon-worker.js

@@ -32,21 +32,37 @@ function findWorktreeMarker(projectName) {
   }
   return null;
 }
+function findConductorWorkspace(projectName) {
+  const m = CONDUCTOR_RE.exec(projectName);
+  if (!m)
+    return null;
+  const workspaceName = m[1];
+  const trailingSlash = m[0].endsWith("/") ? 1 : 0;
+  const canonicalEndIdx = m.index + m[0].length - workspaceName.length - 1 - trailingSlash;
+  return { canonicalEndIdx, workspaceName };
+}
 function canonicalProjectName(projectName) {
   const normalized = projectName.replace(/\/{2,}/g, "/");
-  const hit = findWorktreeMarker(normalized);
-  if (hit)
-    return normalized.slice(0, hit.idx);
+  const wt = findWorktreeMarker(normalized);
+  if (wt)
+    return normalized.slice(0, wt.idx);
+  const cd = findConductorWorkspace(normalized);
+  if (cd)
+    return normalized.slice(0, cd.canonicalEndIdx);
   return normalized;
 }
 function worktreeName(projectName) {
   const normalized = projectName.replace(/\/{2,}/g, "/");
-  const hit = findWorktreeMarker(normalized);
-  if (!hit)
-    return null;
-  const tail = normalized.slice(hit.idx + hit.marker.length);
-  const slash = tail.indexOf("/");
-  return slash >= 0 ? tail.slice(0, slash) : tail;
+  const wt = findWorktreeMarker(normalized);
+  if (wt) {
+    const tail = normalized.slice(wt.idx + wt.marker.length);
+    const slash = tail.indexOf("/");
+    return slash >= 0 ? tail.slice(0, slash) : tail;
+  }
+  const cd = findConductorWorkspace(normalized);
+  if (cd)
+    return cd.workspaceName;
+  return null;
 }
 function makeDay(date) {
   return {
@@ -515,7 +531,7 @@ function groupByProject(sessions) {
   }
   return Array.from(map.values()).sort((a, b) => (b.lastActiveMs ?? 0) - (a.lastActiveMs ?? 0));
 }
-var BLANK_USAGE, WORKTREE_MARKERS, PR_CREATE_RE, PR_NUMBER_RE, TITLE_FLAG_RE;
+var BLANK_USAGE, WORKTREE_MARKERS, CONDUCTOR_RE, PR_CREATE_RE, PR_NUMBER_RE, TITLE_FLAG_RE;
 var init_analytics = __esm({
   "../parser/dist/analytics.js"() {
     "use strict";
@@ -525,6 +541,7 @@ var init_analytics = __esm({
       "/.worktrees/",
       "/claude/worktrees/"
     ];
+    CONDUCTOR_RE = /\/conductor\/workspaces\/[^/]+\/([^/]+)(?:\/|$)/;
     PR_CREATE_RE = /gh\s+pr\s+create\b/i;
     PR_NUMBER_RE = /#(\d+)/;
     TITLE_FLAG_RE = /--title\s+["']([^"']+)["']/;
@@ -757,10 +774,64 @@ var init_calibration = __esm({
   }
 });
 
+// ../parser/dist/user-input.js
+function stripFrameworkBoilerplate(rawText) {
+  if (!rawText)
+    return rawText;
+  let out = rawText;
+  for (const re of STRIPPABLE_WRAPPERS) {
+    out = out.replace(re, "");
+  }
+  return out.trim();
+}
+function isFrameworkInjectedUserInput(rawText) {
+  if (!rawText)
+    return false;
+  const stripped = stripFrameworkBoilerplate(rawText);
+  if (!stripped)
+    return true;
+  for (const prefix of ENTIRELY_INJECTED_PREFIXES) {
+    if (stripped.startsWith(prefix))
+      return true;
+  }
+  return false;
+}
+var STRIPPABLE_WRAPPERS, ENTIRELY_INJECTED_PREFIXES;
+var init_user_input = __esm({
+  "../parser/dist/user-input.js"() {
+    "use strict";
+    STRIPPABLE_WRAPPERS = [
+      /<system_instruction\b[^>]*>[\s\S]*?<\/system_instruction>\s*/gi
+    ];
+    ENTIRELY_INJECTED_PREFIXES = [
+      "<command-name>",
+      "<local-command-stdout>",
+      "<local-command-caveat>",
+      "<task-notification>",
+      "Base directory for this skill:"
+    ];
+  }
+});
+
 // ../parser/dist/parser.js
 function cleanText(s) {
   return s.replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
 }
+function extractRawUserText(rawMsg) {
+  const c = rawMsg?.content;
+  if (typeof c === "string")
+    return c;
+  if (Array.isArray(c)) {
+    for (const block of c) {
+      if (block && typeof block === "object") {
+        const b = block;
+        if (b.type === "text" && typeof b.text === "string")
+          return b.text;
+      }
+    }
+  }
+  return "";
+}
 function truncate(s, n = 200) {
   const one = cleanText(s);
   return one.length > n ? one.slice(0, n - 1) + "\u2026" : one;
@@ -859,7 +930,8 @@ function toEvent(raw, index) {
     const msg = r.message ?? {};
     const c = msg.content;
     if (typeof c === "string") {
-      const tm = classifyTeammateMessage(c);
+      const cleaned = stripFrameworkBoilerplate(c);
+      const tm = classifyTeammateMessage(cleaned);
       return {
         index,
         uuid,
@@ -867,8 +939,8 @@ function toEvent(raw, index) {
         timestamp,
         role: "user",
         rawType,
-        preview: truncate(c, 200),
-        blocks: [{ type: "text", text: c }],
+        preview: truncate(cleaned, 200),
+        blocks: cleaned ? [{ type: "text", text: cleaned }] : [],
         raw,
         teammateMessage: tm
       };
@@ -892,7 +964,9 @@ function toEvent(raw, index) {
         };
       }
       const textBlock = c.find((b) => b?.type === "text");
-      const tm = textBlock ? classifyTeammateMessage(textBlock.text) : void 0;
+      const cleanedText = textBlock ? stripFrameworkBoilerplate(textBlock.text) : "";
+      const cleanedBlocks = textBlock ? c.map((b) => b === textBlock ? { type: "text", text: cleanedText } : b) : c;
+      const tm = cleanedText ? classifyTeammateMessage(cleanedText) : void 0;
       return {
         index,
         uuid,
@@ -900,8 +974,8 @@ function toEvent(raw, index) {
         timestamp,
         role: "user",
         rawType,
-        preview: textBlock ? truncate(textBlock.text, 200) : truncate(JSON.stringify(c), 200),
-        blocks: c,
+        preview: cleanedText ? truncate(cleanedText, 200) : truncate(JSON.stringify(c), 200),
+        blocks: cleanedBlocks,
         raw,
         teammateMessage: tm
       };
@@ -1078,6 +1152,7 @@ function parseTranscript(rawLines) {
   let sessionId = "";
   let cwd;
   let gitBranch;
+  let entrypoint;
   let teamName;
   let agentName;
   let hasTeamCreate = false;
@@ -1121,8 +1196,8 @@ function parseTranscript(rawLines) {
     }
     if (e.role === "user") {
       const rawMsg = e.raw?.message;
-      const rawContent = typeof rawMsg?.content === "string" ? rawMsg.content : "";
-      const isHidden = rawContent.startsWith("<command-name>") || rawContent.startsWith("<local-command-caveat>") || rawContent.startsWith("Base directory for this skill:") || rawContent.startsWith("<task-notification>");
+      const rawContent = extractRawUserText(rawMsg);
+      const isHidden = isFrameworkInjectedUserInput(rawContent);
       const isTeamNoise = e.teammateMessage !== void 0 && !agentName;
       if (!isHidden && !isTeamNoise) {
         if (!firstUserPreview) {
@@ -1146,6 +1221,8 @@ function parseTranscript(rawLines) {
       cwd = o.cwd;
     if (typeof o.gitBranch === "string" && !gitBranch)
       gitBranch = o.gitBranch;
+    if (typeof o.entrypoint === "string" && !entrypoint)
+      entrypoint = o.entrypoint;
     if (typeof o.teamName === "string" && !teamName)
       teamName = o.teamName;
     if (typeof o.agentName === "string" && !agentName)
@@ -1183,6 +1260,7 @@ function parseTranscript(rawLines) {
       model,
       cwd,
       gitBranch,
+      entrypoint,
       totalUsage,
       status: "idle",
       firstUserPreview,
@@ -1207,6 +1285,7 @@ var BLANK_USAGE2, TEAMMATE_MSG_RE;
 var init_parser = __esm({
   "../parser/dist/parser.js"() {
     "use strict";
+    init_user_input();
     BLANK_USAGE2 = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
     TEAMMATE_MSG_RE = /^\s*<teammate-message\s+teammate_id="([^"]+)"[^>]*>([\s\S]*?)<\/teammate-message>/;
   }
@@ -2025,7 +2104,8 @@ function parseRollout(file, lines) {
     if (type === "event_msg" && subtype === "user_message") {
       const text = typeof payload.message === "string" ? payload.message : "";
       const preview = previewOf(text);
-      if (text) {
+      const isHidden = isFrameworkInjectedUserInput(text);
+      if (text && !isHidden) {
         if (!firstUserPreview)
           firstUserPreview = preview;
         lastUserPreview = preview;
@@ -2342,6 +2422,7 @@ var init_codex = __esm({
   "../parser/dist/codex.js"() {
     "use strict";
     init_analytics();
+    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$/;
     IDLE_GAP_MS = 3 * 60 * 1e3;
@@ -2564,7 +2645,8 @@ async function parseSession(file) {
     if (msg.type === "user") {
       const text = flattenContent(msg.displayContent ?? msg.content);
       const preview = previewOf2(text);
-      if (text) {
+      const isHidden = isFrameworkInjectedUserInput(text);
+      if (text && !isHidden) {
         if (!firstUserPreview)
           firstUserPreview = preview;
         lastUserPreview = preview;
@@ -2839,6 +2921,7 @@ var init_gemini = __esm({
   "../parser/dist/gemini.js"() {
     "use strict";
     init_analytics();
+    init_user_input();
     DEFAULT_GEMINI_ROOT = path3.join(os3.homedir(), ".gemini", "tmp");
     GEMINI_PROJECTS_FILE = path3.join(os3.homedir(), ".gemini", "projects.json");
     SESSION_FILE_RE = /^session-.+\.(jsonl|json)$/;
@@ -2858,6 +2941,8 @@ __export(fs_exports, {
   agentSources: () => agentSources,
   buildCalibrationCurve: () => buildCalibrationCurve,
   cacheStats: () => cacheStats,
+  cclensHome: () => cclensHome,
+  cclensPath: () => cclensPath,
   clearCaches: () => clearCaches,
   codexSessionLocalDay: () => codexSessionLocalDay,
   decodeProjectName: () => decodeProjectName,
@@ -2887,6 +2972,12 @@ __export(fs_exports, {
 import { promises as fs4 } from "node:fs";
 import os4 from "node:os";
 import path4 from "node:path";
+function cclensHome() {
+  return process.env.CCLENS_HOME || path4.join(os4.homedir(), ".cclens");
+}
+function cclensPath(...parts) {
+  return path4.join(cclensHome(), ...parts);
+}
 function cacheStats() {
   return claudeCodeCacheStats();
 }
@@ -2919,10 +3010,13 @@ async function getAnySession(id) {
   }
   return null;
 }
+function usageLogPath() {
+  return cclensPath("usage.jsonl");
+}
 async function loadUsageByDay(start, end) {
   let raw;
   try {
-    raw = await fs4.readFile(USAGE_LOG, "utf8");
+    raw = await fs4.readFile(usageLogPath(), "utf8");
   } catch {
     return { by_day: [] };
   }
@@ -2967,7 +3061,7 @@ async function loadUsageByDay(start, end) {
 async function loadCalibrationSnapshots() {
   let raw;
   try {
-    raw = await fs4.readFile(USAGE_LOG, "utf8");
+    raw = await fs4.readFile(usageLogPath(), "utf8");
   } catch {
     return [];
   }
@@ -3125,7 +3219,7 @@ async function loadCalibrationCurve(tier = "pro-max-20x", root = DEFAULT_ROOT, g
   ]);
   return buildCalibrationCurve(events, snapshots, tier, granularityMin);
 }
-var codexSource, geminiSource, agentSources, USAGE_LOG;
+var codexSource, geminiSource, agentSources;
 var init_fs = __esm({
   "../parser/dist/fs.js"() {
     "use strict";
@@ -3170,7 +3264,6 @@ var init_fs = __esm({
       }
     };
     agentSources = [claudeCodeSource, codexSource, geminiSource];
-    USAGE_LOG = path4.join(os4.homedir(), ".cclens", "usage.jsonl");
   }
 });
 
@@ -3339,7 +3432,13 @@ function buildPresentation(events) {
       return false;
     if (e.role === "user") {
       const txt = firstTextOfBlocks(e.blocks) ?? "";
-      if (SKILL_CONTENT_RE.test(txt))
+      if (e.blocks.length === 0 || !txt.trim())
+        return false;
+      if (SLASH_COMMAND_RE.test(txt))
+        return true;
+      if (TASK_NOTIFICATION_RE.test(txt))
+        return true;
+      if (isFrameworkInjectedUserInput(txt))
         return false;
     }
     return true;
@@ -3467,13 +3566,13 @@ function buildPresentation(events) {
   }
   return rows;
 }
-var INTERRUPT_RE, RATE_LIMIT_RE, SKILL_CONTENT_RE, SLASH_COMMAND_RE, TASK_NOTIFICATION_RE;
+var INTERRUPT_RE, RATE_LIMIT_RE, SLASH_COMMAND_RE, TASK_NOTIFICATION_RE;
 var init_presentation = __esm({
   "../parser/dist/presentation.js"() {
     "use strict";
+    init_user_input();
     INTERRUPT_RE = /\[request interrupted|interrupted by user/i;
     RATE_LIMIT_RE = /rate.?limit|overloaded_error|api error|Error sending message/i;
-    SKILL_CONTENT_RE = /^Base directory for this skill:/;
     SLASH_COMMAND_RE = /<command-name>(\/[^<\s]+)<\/command-name>(?:[\s\S]*?<command-args>([\s\S]*?)<\/command-args>)?/;
     TASK_NOTIFICATION_RE = /<task-notification>/;
   }
@@ -3607,6 +3706,7 @@ __export(dist_exports, {
   groupSnapsByCycle: () => groupSnapsByCycle,
   highLevelMetrics: () => highLevelMetrics,
   isAgentKind: () => isAgentKind,
+  isFrameworkInjectedUserInput: () => isFrameworkInjectedUserInput,
   last4CompletedWeeks: () => last4CompletedWeeks,
   modelFamily: () => modelFamily,
   parseTranscript: () => parseTranscript,
@@ -3617,6 +3717,7 @@ __export(dist_exports, {
   rowPrimaryIndex: () => rowPrimaryIndex,
   sessionAirTimeMs: () => sessionAirTimeMs,
   sessionDay: () => sessionDay,
+  stripFrameworkBoilerplate: () => stripFrameworkBoilerplate,
   summarizeBursts: () => summarizeBursts,
   toLocalDay: () => toLocalDay,
   userSoloRate: () => userSoloRate,
@@ -3627,6 +3728,7 @@ var init_dist = __esm({
     "use strict";
     init_types();
     init_parser();
+    init_user_input();
     init_presentation();
     init_analytics();
     init_aggregate();
@@ -3637,9 +3739,8 @@ var init_dist = __esm({
 });
 
 // src/daemon-worker.ts
-import { appendFileSync as appendFileSync5, mkdirSync as mkdirSync11 } from "node:fs";
-import { dirname as dirname9, join as join13 } from "node:path";
-import { homedir as homedir13 } from "node:os";
+import { appendFileSync as appendFileSync5, mkdirSync as mkdirSync12 } from "node:fs";
+import { dirname as dirname8 } from "node:path";
 
 // src/usage/token.ts
 import { execFileSync } from "node:child_process";
@@ -3799,9 +3900,13 @@ function readSnapshots(filePath) {
   }
   return snapshots;
 }
-function latestSnapshot(filePath) {
+function latestClaudeCodeSnapshot(filePath) {
   const all = readSnapshots(filePath);
-  return all.length > 0 ? all[all.length - 1] : null;
+  for (let i = all.length - 1; i >= 0; i--) {
+    const s = all[i];
+    if (!s.agent || s.agent === "claude-code") return s;
+  }
+  return null;
 }
 
 // src/daemon-worker.ts
@@ -3816,26 +3921,23 @@ function nextIntervalMs(current, outcome) {
   return Math.min(Math.max(current, BASE_INTERVAL_MS) * 2, MAX_INTERVAL_MS);
 }
 
-// src/team/sync.ts
-import { homedir as homedir4 } from "node:os";
-import { join as join4 } from "node:path";
-
 // src/team/config.ts
+init_fs();
 import { readFileSync as readFileSync3, writeFileSync, unlinkSync, mkdirSync as mkdirSync2 } from "node:fs";
 import { join as join2 } from "node:path";
-import { homedir as homedir2 } from "node:os";
-var DEFAULT_DIR = join2(homedir2(), ".cclens");
 var CONFIG_FILE = "team.json";
-function readTeamConfig(dir = DEFAULT_DIR) {
+function readTeamConfig(dir) {
+  const d = dir ?? cclensHome();
   try {
-    return JSON.parse(readFileSync3(join2(dir, CONFIG_FILE), "utf8"));
+    return JSON.parse(readFileSync3(join2(d, CONFIG_FILE), "utf8"));
   } catch {
     return null;
   }
 }
-function writeTeamConfig(config, dir = DEFAULT_DIR) {
-  mkdirSync2(dir, { recursive: true });
-  writeFileSync(join2(dir, CONFIG_FILE), JSON.stringify(config, null, 2), { mode: 384 });
+function writeTeamConfig(config, dir) {
+  const d = dir ?? cclensHome();
+  mkdirSync2(d, { recursive: true });
+  writeFileSync(join2(d, CONFIG_FILE), JSON.stringify(config, null, 2), { mode: 384 });
 }
 
 // src/team/push.ts
@@ -3843,7 +3945,7 @@ init_dist();
 import { randomUUID } from "node:crypto";
 var SNAPSHOT_FRESHNESS_MS = 10 * 60 * 1e3;
 function readLatestUsageSnapshotForWire(filePath, nowMs = Date.now()) {
-  const raw = latestSnapshot(filePath);
+  const raw = latestClaudeCodeSnapshot(filePath);
   if (!raw) return null;
   const capturedMs = Date.parse(raw.captured_at);
   if (Number.isNaN(capturedMs)) return null;
@@ -3911,10 +4013,10 @@ async function pushToTeamServer(config, payload) {
 }
 
 // src/team/queue.ts
+init_fs();
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, appendFileSync as appendFileSync2, statSync, mkdirSync as mkdirSync3 } from "node:fs";
-import { join as join3, dirname as dirname2 } from "node:path";
-import { homedir as homedir3 } from "node:os";
-var QUEUE_PATH = join3(homedir3(), ".cclens", "ingest-queue.jsonl");
+import { dirname as dirname2 } 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) {
@@ -4037,8 +4139,9 @@ async function getPlanTier(cachePath, nowMs = Date.now(), fetcher = fetchProfile
 }
 
 // src/team/sync.ts
-var USAGE_LOG2 = join4(homedir4(), ".cclens", "usage.jsonl");
-var PROFILE_CACHE = join4(homedir4(), ".cclens", "profile.json");
+init_fs();
+var USAGE_LOG = cclensPath("usage.jsonl");
+var PROFILE_CACHE = cclensPath("profile.json");
 var noopLog = () => {
 };
 async function runTeamSync(log3 = noopLog, configOverride) {
@@ -4050,7 +4153,7 @@ async function runTeamSync(log3 = noopLog, configOverride) {
     const today = toLocalDay3(Date.now());
     const sessions = await listSessions2({ limit: 1e4 });
     const rollups = buildRollupsForRange(sessions, config.lastSyncedDay);
-    const usageSnapshot = readLatestUsageSnapshotForWire(USAGE_LOG2) ?? void 0;
+    const usageSnapshot = readLatestUsageSnapshotForWire(USAGE_LOG) ?? void 0;
     const planTier = await getPlanTier(PROFILE_CACHE).catch(() => null) ?? void 0;
     const cyclePeaks = await buildCyclePeaksForPush(planTier, loadCalibrationCurve2);
     if (rollups.length === 0) {
@@ -4264,17 +4367,21 @@ var PROMPT_FRAME_ORIGIN = {
 };
 
 // ../entries/dist/signals.js
+init_dist();
 var TEAMMATE_RE = /^<teammate-message\b/;
 var SKILL_LOAD_RE = /^Base directory for this skill:/;
 var SLASH_COMMAND_RE2 = /^<command-name>|^<local-command-stdout>/;
 function classifyUserInputSource(text) {
   if (!text)
     return "human";
-  if (TEAMMATE_RE.test(text))
+  const stripped = stripFrameworkBoilerplate(text);
+  if (!stripped)
+    return "system_instruction";
+  if (TEAMMATE_RE.test(stripped))
     return "teammate";
-  if (SKILL_LOAD_RE.test(text))
+  if (SKILL_LOAD_RE.test(stripped))
     return "skill_load";
-  if (SLASH_COMMAND_RE2.test(text))
+  if (SLASH_COMMAND_RE2.test(stripped))
     return "slash_command";
   return "human";
 }
@@ -4663,7 +4770,7 @@ function aggregateDay(dayEvents, _sessionFallbackProject) {
           closeTurn(cur, closed, eventCwd);
         }
         cur = newTurn(tsMs, text);
-        if (!firstUser && text && !text.startsWith("<command-name>")) {
+        if (!firstUser && text && classifyUserInputSource(text) === "human") {
           firstUser = text;
         }
       } else {
@@ -4907,7 +5014,13 @@ function buildEntries(sessionDetail) {
       return classifyUserInputSource(text) === "human";
     }).map((ev) => blockText(ev.blocks) || ev.preview || "").join("\n");
     const satisfaction_signals = countSatisfactionSignals(humanText);
-    const user_input_sources = { human: 0, teammate: 0, skill_load: 0, slash_command: 0 };
+    const user_input_sources = {
+      human: 0,
+      teammate: 0,
+      skill_load: 0,
+      slash_command: 0,
+      system_instruction: 0
+    };
     for (const ev of dayEvents) {
       const v = viewEvent(ev);
       if (v.rawType !== "user")
@@ -4955,28 +5068,28 @@ function buildEntries(sessionDetail) {
 }
 
 // ../entries/dist/fs.js
+init_fs();
 import { readFileSync as readFileSync7, readdirSync as readdirSync2, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, renameSync as renameSync2, existsSync as existsSync4 } from "node:fs";
 import { randomBytes } from "node:crypto";
-import { join as join6 } from "node:path";
-import { homedir as homedir6 } from "node:os";
+import { join as join4 } from "node:path";
 
 // ../entries/dist/digest-fs.js
+init_fs();
 import { readFileSync as readFileSync6, readdirSync, writeFileSync as writeFileSync4, renameSync, chmodSync, mkdirSync as mkdirSync5, existsSync as existsSync3 } from "node:fs";
-import { dirname as dirname4, join as join5 } from "node:path";
-import { homedir as homedir5 } from "node:os";
+import { dirname as dirname4, join as join3 } from "node:path";
 var digestsDirCached = null;
 function digestsDir() {
   if (digestsDirCached)
     return digestsDirCached;
   const envOverride = process.env.CCLENS_DIGESTS_DIR;
-  digestsDirCached = envOverride ?? join5(homedir5(), ".cclens", "digests");
+  digestsDirCached = envOverride ?? cclensPath("digests");
   return digestsDirCached;
 }
 function dayDigestPath(date) {
-  return join5(digestsDir(), "day", `${date}.json`);
+  return join3(digestsDir(), "day", `${date}.json`);
 }
 function weekDigestPath(monday) {
-  return join5(digestsDir(), "week", `${monday}.json`);
+  return join3(digestsDir(), "week", `${monday}.json`);
 }
 function writeDayDigest(digest) {
   const final = dayDigestPath(digest.key);
@@ -5060,11 +5173,11 @@ function entriesDir() {
   if (entriesDirCached)
     return entriesDirCached;
   const envOverride = process.env.CCLENS_ENTRIES_DIR;
-  entriesDirCached = envOverride ?? join6(homedir6(), ".cclens", "entries");
+  entriesDirCached = envOverride ?? cclensPath("entries");
   return entriesDirCached;
 }
 function pathFor(sessionId, localDay) {
-  return join6(entriesDir(), `${entryKey(sessionId, localDay)}.json`);
+  return join4(entriesDir(), `${entryKey(sessionId, localDay)}.json`);
 }
 function tmpPathFor(final) {
   return `${final}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
@@ -5137,14 +5250,14 @@ function listEntriesForDay(localDay) {
 }
 
 // src/perception/state.ts
+init_fs();
 import { existsSync as existsSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync6, mkdirSync as mkdirSync7, renameSync as renameSync3 } from "node:fs";
-import { dirname as dirname5, join as join7 } from "node:path";
-import { homedir as homedir7 } from "node:os";
+import { dirname as dirname5 } from "node:path";
 var STALE_MS = 15 * 60 * 1e3;
 var pathCached = null;
 function statePath() {
   if (pathCached) return pathCached;
-  pathCached = join7(homedir7(), ".cclens", "perception-state.json");
+  pathCached = cclensPath("perception-state.json");
   return pathCached;
 }
 function readState() {
@@ -5194,17 +5307,17 @@ function updateCheckpoint(jsonlPath, cp) {
 
 // src/perception/scan.ts
 import { readdirSync as readdirSync3 } from "node:fs";
-import { join as join8 } from "node:path";
-import { homedir as homedir8 } from "node:os";
+import { join as join5 } from "node:path";
+import { homedir as homedir2 } from "node:os";
 async function listAllSessionJsonls(root) {
-  const projectsRoot = root ?? join8(homedir8(), ".claude", "projects");
+  const projectsRoot = root ?? join5(homedir2(), ".claude", "projects");
   const out = [];
   try {
     for (const project of readdirSync3(projectsRoot)) {
-      const dir = join8(projectsRoot, project);
+      const dir = join5(projectsRoot, project);
       try {
         for (const f of readdirSync3(dir)) {
-          if (f.endsWith(".jsonl")) out.push(join8(dir, f));
+          if (f.endsWith(".jsonl")) out.push(join5(dir, f));
         }
       } catch {
       }
@@ -9445,16 +9558,332 @@ ${turns || "(none \u2014 the user text was filtered out as non-human)"}`;
 var ENRICHMENT_SYSTEM_PROMPT = SYSTEM_PROMPT;
 
 // ../entries/dist/llm-runner.js
+init_fs();
 import { spawn } from "node:child_process";
-import { mkdirSync as mkdirSync8, appendFileSync as appendFileSync3, writeFileSync as writeFileSync7, existsSync as existsSync6 } from "node:fs";
-import { homedir as homedir9 } from "node:os";
-import { join as join9 } from "node:path";
+import { mkdirSync as mkdirSync9, appendFileSync as appendFileSync3, writeFileSync as writeFileSync8, existsSync as existsSync7 } from "node:fs";
+import { join as join7 } from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
-var RUNS_DIR = join9(homedir9(), ".cclens", "llm-runs");
+
+// ../entries/dist/tmux-runner.js
+import { mkdirSync as mkdirSync8, writeFileSync as writeFileSync7, existsSync as existsSync6, readdirSync as readdirSync4, realpathSync, readFileSync as readFileSync10, unlinkSync as unlinkSync2, renameSync as renameSync4 } from "node:fs";
+import { join as join6 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { spawnSync } from "node:child_process";
+var TmuxUnavailableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TmuxUnavailableError";
+  }
+};
+var TmuxRunError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TmuxRunError";
+  }
+};
+function which(bin) {
+  const r = spawnSync("/usr/bin/env", ["which", bin], { encoding: "utf8" });
+  if (r.status === 0)
+    return r.stdout.trim() || void 0;
+  return void 0;
+}
+function tmuxRunnerAvailable() {
+  if (!which("tmux"))
+    return { ok: false, reason: "tmux not on PATH" };
+  if (!which("claude"))
+    return { ok: false, reason: "claude not on PATH" };
+  return { ok: true };
+}
+function runtimeCwd() {
+  const dir = join6(homedir3(), ".cclens", "runtime");
+  if (!existsSync6(dir))
+    mkdirSync8(dir, { recursive: true });
+  return realpathSync(dir);
+}
+function ensureRuntimeCwdTrusted(cwd) {
+  const cfgPath = join6(homedir3(), ".claude.json");
+  let cfg;
+  try {
+    cfg = JSON.parse(readFileSync10(cfgPath, "utf8"));
+  } catch {
+    return;
+  }
+  const projects = cfg.projects ?? {};
+  const cur = projects[cwd];
+  if (cur && cur.hasTrustDialogAccepted === true)
+    return;
+  projects[cwd] = {
+    ...cur ?? {},
+    hasTrustDialogAccepted: true
+  };
+  cfg.projects = projects;
+  const tmp = `${cfgPath}.cclens-tmp-${process.pid}`;
+  try {
+    writeFileSync7(tmp, JSON.stringify(cfg, null, 2));
+    renameSync4(tmp, cfgPath);
+  } catch {
+    try {
+      unlinkSync2(tmp);
+    } catch {
+    }
+  }
+}
+var mutex = Promise.resolve();
+function runClaudeUnderTmux(args) {
+  const next = mutex.then(() => runClaudeUnderTmuxImpl(args));
+  mutex = next.catch(() => void 0);
+  return next;
+}
+async function runClaudeUnderTmuxImpl(args) {
+  const tmuxBin = args.tmuxBin ?? which("tmux");
+  if (!tmuxBin)
+    throw new TmuxUnavailableError("tmux not on PATH");
+  const claudeBin = args.claudeBin ?? which("claude");
+  if (!claudeBin)
+    throw new TmuxUnavailableError("claude not on PATH");
+  if (args.signal?.aborted)
+    throw new TmuxRunError("aborted before spawn");
+  const cwd = runtimeCwd();
+  ensureRuntimeCwdTrusted(cwd);
+  const runId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const sessionName = `cclens-${runId}`;
+  const systemFile = join6(cwd, `system-${runId}.txt`);
+  const userFile = join6(cwd, `user-${runId}.txt`);
+  const wrapper = join6(cwd, `run-${runId}.sh`);
+  writeFileSync7(systemFile, args.systemPrompt);
+  writeFileSync7(userFile, args.reminder ? `${args.userPrompt}
+
+---
+
+${args.reminder}` : args.userPrompt);
+  writeFileSync7(wrapper, `#!/bin/bash
+SYS="$(cat ${shellEscape(systemFile)})"
+USR="$(cat ${shellEscape(userFile)})"
+exec ${shellEscape(claudeBin)} \\
+  --model ${shellEscape(args.model)} \\
+  --strict-mcp-config --mcp-config '{"mcpServers":{}}' \\
+  --disable-slash-commands \\
+  --effort medium \\
+  --append-system-prompt "$SYS" \\
+  "$USR"
+`, { mode: 493 });
+  const existingBefore = snapshotAllTranscripts();
+  const spawn2 = spawnSync(tmuxBin, ["new-session", "-d", "-s", sessionName, "-x", "140", "-y", "50", "-c", cwd, wrapper], { encoding: "utf8" });
+  if (spawn2.status !== 0) {
+    cleanup(cwd, runId, tmuxBin, sessionName);
+    throw new TmuxRunError(`tmux new-session failed: ${spawn2.stderr.trim()}`);
+  }
+  const onAbort = () => {
+    try {
+      spawnSync(tmuxBin, ["kill-session", "-t", sessionName], { stdio: "ignore" });
+    } catch {
+    }
+  };
+  args.signal?.addEventListener("abort", onAbort, { once: true });
+  const startMs = Date.now();
+  const timeoutMs = args.timeoutMs ?? 12e4;
+  let lastReportedKb = -1;
+  let lastEmittedLength = 0;
+  try {
+    const transcriptPath = await discoverTranscript(cwd, existingBefore, startMs, timeoutMs, args.signal);
+    while (Date.now() - startMs < timeoutMs) {
+      if (args.signal?.aborted)
+        throw new TmuxRunError("aborted");
+      const { assembled, inputTokens, outputTokens, modelUsed, done } = parseTranscript2(transcriptPath, args.model);
+      if (args.onProgress) {
+        const kb = Math.floor(assembled.length / 1024);
+        if (kb > lastReportedKb) {
+          lastReportedKb = kb;
+          args.onProgress({ bytes: assembled.length, elapsedMs: Date.now() - startMs });
+        }
+      }
+      if (args.onDelta && assembled.length > lastEmittedLength) {
+        const chunk = assembled.slice(lastEmittedLength);
+        lastEmittedLength = assembled.length;
+        try {
+          args.onDelta(chunk);
+        } catch {
+        }
+      }
+      if (done && assembled.length > 0) {
+        return {
+          content: assembled,
+          input_tokens: inputTokens,
+          output_tokens: outputTokens,
+          model: modelUsed
+        };
+      }
+      await sleep(500);
+    }
+    throw new TmuxRunError(`timeout after ${timeoutMs}ms waiting for assistant turn`);
+  } finally {
+    args.signal?.removeEventListener("abort", onAbort);
+    cleanup(cwd, runId, tmuxBin, sessionName);
+  }
+}
+function num(v) {
+  return typeof v === "number" ? v : 0;
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var PROJECTS_ROOT = () => join6(homedir3(), ".claude", "projects");
+function snapshotAllTranscripts() {
+  const out = /* @__PURE__ */ new Set();
+  const root = PROJECTS_ROOT();
+  let subs;
+  try {
+    subs = readdirSync4(root);
+  } catch {
+    return out;
+  }
+  for (const sub of subs) {
+    const dir = join6(root, sub);
+    let files;
+    try {
+      files = readdirSync4(dir);
+    } catch {
+      continue;
+    }
+    for (const f of files) {
+      if (f.endsWith(".jsonl"))
+        out.add(join6(dir, f));
+    }
+  }
+  return out;
+}
+function readJsonlCwd(path5, maxLines = 8) {
+  let raw;
+  try {
+    raw = readFileSync10(path5, "utf8");
+  } catch {
+    return void 0;
+  }
+  let count = 0;
+  for (const line of raw.split("\n")) {
+    const t = line.trim();
+    if (!t)
+      continue;
+    count++;
+    try {
+      const o = JSON.parse(t);
+      if (typeof o.cwd === "string")
+        return o.cwd;
+    } catch {
+    }
+    if (count >= maxLines)
+      break;
+  }
+  return void 0;
+}
+async function discoverTranscript(targetCwd, existingBefore, startMs, timeoutMs, signal) {
+  while (Date.now() - startMs < timeoutMs) {
+    if (signal?.aborted)
+      throw new TmuxRunError("aborted");
+    const root = PROJECTS_ROOT();
+    let subs;
+    try {
+      subs = readdirSync4(root);
+    } catch {
+      subs = [];
+    }
+    for (const sub of subs) {
+      const dir = join6(root, sub);
+      let files;
+      try {
+        files = readdirSync4(dir);
+      } catch {
+        continue;
+      }
+      for (const f of files) {
+        if (!f.endsWith(".jsonl"))
+          continue;
+        const full = join6(dir, f);
+        if (existingBefore.has(full))
+          continue;
+        if (readJsonlCwd(full) === targetCwd)
+          return full;
+      }
+    }
+    await sleep(300);
+  }
+  throw new TmuxRunError(`timeout waiting for claude to create the session transcript (cwd: ${targetCwd})`);
+}
+function parseTranscript2(path5, defaultModel) {
+  let raw;
+  try {
+    raw = readFileSync10(path5, "utf8");
+  } catch {
+    return { assembled: "", inputTokens: 0, outputTokens: 0, modelUsed: defaultModel, done: false };
+  }
+  let assembled = "";
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let modelUsed = defaultModel;
+  let done = false;
+  for (const line of raw.split("\n")) {
+    const t = line.trim();
+    if (!t)
+      continue;
+    let o;
+    try {
+      o = JSON.parse(t);
+    } catch {
+      continue;
+    }
+    if (o.type !== "assistant")
+      continue;
+    const m = o.message;
+    if (!m)
+      continue;
+    const mm = m.model;
+    if (mm)
+      modelUsed = mm;
+    const content = m.content;
+    if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block.type === "text" && typeof block.text === "string") {
+          assembled += block.text;
+        }
+      }
+    }
+    const usage = m.usage;
+    if (usage) {
+      inputTokens = num(usage.input_tokens) + num(usage.cache_creation_input_tokens) + num(usage.cache_read_input_tokens);
+      outputTokens = num(usage.output_tokens);
+    }
+    if (m.stop_reason === "end_turn") {
+      done = true;
+    }
+  }
+  return { assembled, inputTokens, outputTokens, modelUsed, done };
+}
+function cleanup(cwd, runId, tmuxBin, sessionName) {
+  try {
+    spawnSync(tmuxBin, ["kill-session", "-t", sessionName], { stdio: "ignore" });
+  } catch {
+  }
+  if (process.env.FLEETLENS_TMUX_KEEP_WRAPPER !== "1") {
+    for (const f of [`system-${runId}.txt`, `user-${runId}.txt`, `run-${runId}.sh`]) {
+      try {
+        unlinkSync2(join6(cwd, f));
+      } catch {
+      }
+    }
+  }
+}
+function shellEscape(s) {
+  if (/^[A-Za-z0-9_./-]+$/.test(s))
+    return s;
+  return `'${s.replace(/'/g, `'"'"'`)}'`;
+}
+
+// ../entries/dist/llm-runner.js
+var RUNS_DIR = cclensPath("llm-runs");
 function ensureRunsDir() {
-  if (!existsSync6(RUNS_DIR)) {
+  if (!existsSync7(RUNS_DIR)) {
     try {
-      mkdirSync8(RUNS_DIR, { recursive: true });
+      mkdirSync9(RUNS_DIR, { recursive: true });
     } catch {
     }
   }
@@ -9481,7 +9910,7 @@ function newRunId(kind) {
   return `${ts}_${kind}_${short}`;
 }
 function tracePath(runId) {
-  return join9(RUNS_DIR, `${runId}.jsonl`);
+  return join7(RUNS_DIR, `${runId}.jsonl`);
 }
 function safeAppend(path5, line) {
   try {
@@ -9491,11 +9920,84 @@ function safeAppend(path5, line) {
 }
 function safeWrite(path5, line) {
   try {
-    writeFileSync7(path5, line);
+    writeFileSync8(path5, line);
   } catch {
   }
 }
-function runClaudeSubprocess(args) {
+async function runClaudeSubprocess(args) {
+  if (process.env.FLEETLENS_FORCE_PRINT_MODE !== "1") {
+    const avail = tmuxRunnerAvailable();
+    if (avail.ok) {
+      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const kind = detectKindFromSystemPrompt(args.systemPrompt);
+      const runId = newRunId(kind);
+      const trace = tracePath(runId);
+      ensureRunsDir();
+      safeWrite(trace, JSON.stringify({
+        _meta: {
+          type: "start",
+          run_id: runId,
+          kind,
+          model: args.model,
+          ts: startedAt,
+          runtime: "tmux",
+          user_prompt_chars: args.userPrompt.length,
+          reminder_chars: args.reminder?.length ?? 0
+        }
+      }) + "\n");
+      safeAppend(trace, JSON.stringify({
+        _meta: {
+          type: "payload",
+          run_id: runId,
+          system_prompt: args.systemPrompt,
+          user_prompt: args.userPrompt,
+          reminder: args.reminder ?? null
+        }
+      }) + "\n");
+      try {
+        const startMs = Date.now();
+        const res = await runClaudeUnderTmux({
+          systemPrompt: args.systemPrompt,
+          model: args.model,
+          userPrompt: args.userPrompt,
+          reminder: args.reminder,
+          onProgress: args.onProgress
+        });
+        safeAppend(trace, JSON.stringify({
+          _meta: {
+            type: "end",
+            run_id: runId,
+            runtime: "tmux",
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            elapsed_ms: Date.now() - startMs,
+            // tmux runs have no subprocess exit code (the session is killed
+            // by cleanup). Stamp 0 on success so /api/runs renders them
+            // as `ok` rather than `error`.
+            exit_code: 0,
+            content_chars: res.content.length,
+            input_tokens: res.input_tokens,
+            output_tokens: res.output_tokens,
+            model_used: res.model
+          }
+        }) + "\n");
+        return res;
+      } catch (err) {
+        const isExpected = err instanceof TmuxUnavailableError || err instanceof TmuxRunError;
+        safeAppend(trace, JSON.stringify({
+          _meta: {
+            type: "tmux_fallback",
+            run_id: runId,
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            error: err.message,
+            expected: isExpected
+          }
+        }) + "\n");
+      }
+    }
+  }
+  return runClaudePrintMode(args);
+}
+function runClaudePrintMode(args) {
   return new Promise((resolve, reject) => {
     ensureRunsDir();
     const kind = detectKindFromSystemPrompt(args.systemPrompt);
@@ -9806,29 +10308,29 @@ function applyEnrichmentError(entry, errorMessage, model, costUsd, generatedAt,
 }
 
 // ../entries/dist/budget.js
-import { appendFileSync as appendFileSync4, readFileSync as readFileSync10, existsSync as existsSync7, mkdirSync as mkdirSync9 } from "node:fs";
-import { dirname as dirname7, join as join10 } from "node:path";
-import { homedir as homedir10 } from "node:os";
+init_fs();
+import { appendFileSync as appendFileSync4, readFileSync as readFileSync11, existsSync as existsSync8, mkdirSync as mkdirSync10 } from "node:fs";
+import { dirname as dirname7 } from "node:path";
 var spendPathCached = null;
 function spendPath() {
   if (spendPathCached)
     return spendPathCached;
-  spendPathCached = join10(homedir10(), ".cclens", "llm-spend.jsonl");
+  spendPathCached = cclensPath("llm-spend.jsonl");
   return spendPathCached;
 }
 function appendSpend(record) {
   const p = spendPath();
-  mkdirSync9(dirname7(p), { recursive: true });
+  mkdirSync10(dirname7(p), { recursive: true });
   appendFileSync4(p, JSON.stringify(record) + "\n", { encoding: "utf8" });
 }
 function monthToDateSpend(now = /* @__PURE__ */ new Date()) {
   const p = spendPath();
-  if (!existsSync7(p))
+  if (!existsSync8(p))
     return 0;
   const year = now.getUTCFullYear();
   const month = now.getUTCMonth();
   let total = 0;
-  const raw = readFileSync10(p, "utf8");
+  const raw = readFileSync11(p, "utf8");
   for (const line of raw.split("\n")) {
     if (!line)
       continue;
@@ -9849,9 +10351,8 @@ function monthToDateSpend(now = /* @__PURE__ */ new Date()) {
 }
 
 // ../entries/dist/pipeline-lock.js
-import { writeFileSync as writeFileSync8, unlinkSync as unlinkSync2, existsSync as existsSync8, readFileSync as readFileSync11, statSync as statSync3 } from "node:fs";
-import { join as join11 } from "node:path";
-import { homedir as homedir11 } from "node:os";
+init_fs();
+import { writeFileSync as writeFileSync9, unlinkSync as unlinkSync3, existsSync as existsSync9, readFileSync as readFileSync12, statSync as statSync3 } from "node:fs";
 var STALE_MS2 = 60 * 1e3;
 var HEARTBEAT_MS = 30 * 1e3;
 var lockPathCached = null;
@@ -9859,11 +10360,11 @@ var heartbeat = null;
 function lockPath() {
   if (lockPathCached)
     return lockPathCached;
-  lockPathCached = join11(homedir11(), ".cclens", "llm-interactive.lock");
+  lockPathCached = cclensPath("llm-interactive.lock");
   return lockPathCached;
 }
 function touchLock() {
-  writeFileSync8(lockPath(), String(process.pid), "utf8");
+  writeFileSync9(lockPath(), String(process.pid), "utf8");
 }
 function writeInteractiveLock() {
   touchLock();
@@ -9883,7 +10384,7 @@ function removeInteractiveLock() {
     heartbeat = null;
   }
   try {
-    unlinkSync2(lockPath());
+    unlinkSync3(lockPath());
   } catch {
   }
 }
@@ -9897,13 +10398,13 @@ function pidAlive(pid) {
 }
 function interactiveLockFresh(nowMs) {
   const p = lockPath();
-  if (!existsSync8(p))
+  if (!existsSync9(p))
     return false;
   try {
     const mtime = statSync3(p).mtimeMs;
     if (nowMs - mtime > STALE_MS2)
       return false;
-    const pid = Number(readFileSync11(p, "utf8").trim());
+    const pid = Number(readFileSync12(p, "utf8").trim());
     if (!Number.isFinite(pid) || pid <= 0)
       return false;
     if (!pidAlive(pid))
@@ -9918,9 +10419,8 @@ function interactiveLockFresh(nowMs) {
 var THIRTY_MIN_MS = 30 * 60 * 1e3;
 
 // ../entries/dist/settings.js
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync9, renameSync as renameSync4, chmodSync as chmodSync2, mkdirSync as mkdirSync10, existsSync as existsSync9 } from "node:fs";
-import { dirname as dirname8, join as join12 } from "node:path";
-import { homedir as homedir12 } from "node:os";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync10, renameSync as renameSync5, chmodSync as chmodSync2, mkdirSync as mkdirSync11, existsSync as existsSync10 } from "node:fs";
+init_fs();
 var DEFAULT_SETTINGS = {
   ai_features: {
     enabled: true,
@@ -9934,7 +10434,7 @@ var settingsPathCached = null;
 function settingsPath() {
   if (settingsPathCached)
     return settingsPathCached;
-  settingsPathCached = join12(homedir12(), ".cclens", "settings.json");
+  settingsPathCached = cclensPath("settings.json");
   return settingsPathCached;
 }
 function fromDisk(d) {
@@ -9951,10 +10451,10 @@ function fromDisk(d) {
 }
 function readSettings() {
   const p = settingsPath();
-  if (!existsSync9(p))
+  if (!existsSync10(p))
     return DEFAULT_SETTINGS;
   try {
-    const raw = readFileSync12(p, "utf8");
+    const raw = readFileSync13(p, "utf8");
     return fromDisk(JSON.parse(raw));
   } catch {
     return DEFAULT_SETTINGS;
@@ -12677,11 +13177,10 @@ async function backfillYesterdayDigest(opts = {}) {
 }
 
 // src/daemon-worker.ts
-var STATE_DIR = join13(homedir13(), ".cclens");
-var USAGE_LOG3 = join13(STATE_DIR, "usage.jsonl");
-var DAEMON_LOG = join13(STATE_DIR, "daemon.log");
+var USAGE_LOG2 = cclensPath("usage.jsonl");
+var DAEMON_LOG = cclensPath("daemon.log");
 var WATCHDOG_INTERVAL_MS = 5 * 1e3;
-mkdirSync11(dirname9(USAGE_LOG3), { recursive: true });
+mkdirSync12(dirname8(USAGE_LOG2), { recursive: true });
 function log2(level, message) {
   const line = `${(/* @__PURE__ */ new Date()).toISOString()} ${level.toUpperCase()} ${message}
 `;
@@ -12734,7 +13233,7 @@ async function tick() {
         seven_day_cowork: null,
         extra_usage: null
       };
-      appendSnapshot(USAGE_LOG3, snapshot);
+      appendSnapshot(USAGE_LOG2, snapshot);
       log2(
         "info",
         `${source.kind} snapshot 5h=${snapshot.five_hour.utilization}% 7d=${snapshot.seven_day.utilization}%`
@@ -12745,7 +13244,7 @@ async function tick() {
   }
   try {
     const snapshot = await fetchUsage();
-    appendSnapshot(USAGE_LOG3, snapshot);
+    appendSnapshot(USAGE_LOG2, snapshot);
     log2(
       "info",
       `claude-code snapshot 5h=${snapshot.five_hour.utilization}% 7d=${snapshot.seven_day.utilization}%`
@@ -12771,7 +13270,7 @@ function scheduleAfter(now, outcome) {
   }
   nextPollAtMs = now + currentIntervalMs;
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function runLoop() {
@@ -12804,7 +13303,7 @@ async function runLoop() {
       }
       await runTeamSync(log2);
     }
-    await sleep(WATCHDOG_INTERVAL_MS);
+    await sleep2(WATCHDOG_INTERVAL_MS);
   }
 }
 log2(