fleetlens 0.10.0 → 0.10.2

package/dist/daemon-worker.js

@@ -1152,6 +1152,7 @@ function parseTranscript(rawLines) {
   let sessionId = "";
   let cwd;
   let gitBranch;
+  let entrypoint;
   let teamName;
   let agentName;
   let hasTeamCreate = false;
@@ -1220,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)
@@ -1257,6 +1260,7 @@ function parseTranscript(rawLines) {
       model,
       cwd,
       gitBranch,
+      entrypoint,
       totalUsage,
       status: "idle",
       firstUserPreview,
@@ -2937,6 +2941,8 @@ __export(fs_exports, {
   agentSources: () => agentSources,
   buildCalibrationCurve: () => buildCalibrationCurve,
   cacheStats: () => cacheStats,
+  cclensHome: () => cclensHome,
+  cclensPath: () => cclensPath,
   clearCaches: () => clearCaches,
   codexSessionLocalDay: () => codexSessionLocalDay,
   decodeProjectName: () => decodeProjectName,
@@ -2966,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();
 }
@@ -2998,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: [] };
   }
@@ -3046,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 [];
   }
@@ -3204,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";
@@ -3249,7 +3264,6 @@ var init_fs = __esm({
       }
     };
     agentSources = [claudeCodeSource, codexSource, geminiSource];
-    USAGE_LOG = path4.join(os4.homedir(), ".cclens", "usage.jsonl");
   }
 });
 
@@ -3269,6 +3283,7 @@ function rowPrimaryIndex(r) {
 function buildMegaRows(rows) {
   const out = [];
   let buffer = [];
+  let turnAnchor = null;
   const flush = () => {
     if (buffer.length === 0)
       return;
@@ -3327,9 +3342,10 @@ function buildMegaRows(rows) {
     const toolNames = Array.from(toolMap.entries()).sort((a, b) => b[1] - a[1]).map(([name, count]) => ({ name, count }));
     const first = buffer[0];
     const last = buffer[buffer.length - 1];
-    const start = first.tOffsetMs;
+    const anchorOffset = turnAnchor?.tOffsetMs;
+    const start = anchorOffset ?? first.tOffsetMs;
     const end = last.tOffsetMs;
-    const durationMs = start !== void 0 && end !== void 0 ? end - start : void 0;
+    const durationMs = start !== void 0 && end !== void 0 && end >= start ? end - start : void 0;
     out.push({
       kind: "turn",
       rows: buffer,
@@ -3354,6 +3370,7 @@ function buildMegaRows(rows) {
     if (r.kind === "user" || r.kind === "interrupt") {
       flush();
       out.push(r);
+      turnAnchor = r;
     } else {
       buffer.push(r);
     }
@@ -3725,9 +3742,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";
@@ -3908,26 +3924,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
@@ -4003,10 +4016,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) {
@@ -4129,8 +4142,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) {
@@ -4142,7 +4156,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) {
@@ -5057,28 +5071,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);
@@ -5162,11 +5176,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")}`;
@@ -5239,14 +5253,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() {
@@ -5296,17 +5310,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 {
       }
@@ -9547,16 +9561,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 {
     }
   }
@@ -9583,7 +9913,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 {
@@ -9593,11 +9923,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);
@@ -9908,29 +10311,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;
@@ -9951,9 +10354,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;
@@ -9961,11 +10363,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();
@@ -9985,7 +10387,7 @@ function removeInteractiveLock() {
     heartbeat = null;
   }
   try {
-    unlinkSync2(lockPath());
+    unlinkSync3(lockPath());
   } catch {
   }
 }
@@ -9999,13 +10401,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))
@@ -10020,9 +10422,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,
@@ -10036,7 +10437,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) {
@@ -10053,10 +10454,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;
@@ -12779,11 +13180,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}
 `;
@@ -12836,7 +13236,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}%`
@@ -12847,7 +13247,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}%`
@@ -12873,7 +13273,7 @@ function scheduleAfter(now, outcome) {
   }
   nextPollAtMs = now + currentIntervalMs;
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function runLoop() {
@@ -12906,7 +13306,7 @@ async function runLoop() {
       }
       await runTeamSync(log2);
     }
-    await sleep(WATCHDOG_INTERVAL_MS);
+    await sleep2(WATCHDOG_INTERVAL_MS);
   }
 }
 log2(