ccsidekick 1.6.1 → 1.6.2

package/dist/ccsidekick-render.js

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
 
 // src/bin/ccsidekick-render.ts
-import { readFileSync as readFileSync11 } from "node:fs";
+import { readFileSync as readFileSync12 } from "node:fs";
 
 // src/cli/classify.ts
 import { createHash as createHash4 } from "node:crypto";
 
 // src/domain/constants.ts
-var COST_TTL_MS = 1500;
+var COST_TTL_MS = 5000;
 var USAGE_TTL_MS = 300000;
+var CREDS_TTL_MS = 3600000;
 var BALANCE_FRESHNESS_MS = 300000;
 var FX_TTL_MS = 604800000;
 var MIN_RIGHT_WIDTH = 53;
@@ -33,6 +34,8 @@ var HELPFUL_COOLDOWN_MS = 600000;
 var BURN_WINDOW_MS = 18000000;
 var COMPACT_URGENT_PCT = 90;
 var QUOTA_HIGH_PCT = 80;
+var QUOTA_PACE_MIN_PCT = 20;
+var QUOTA_PROJECT_MIN_PCT = 50;
 var PAY_AS_YOU_GO_CAUTION_PCT = 60;
 var PAY_AS_YOU_GO_NEAR_PCT = 80;
 var BALANCE_LOW = 25;
@@ -44,6 +47,17 @@ var SIGNAL_HUE_RANGES = {
   caution: { min: 20, max: 55 },
   critical: { wrapMax: 15, wrapMin: 345 }
 };
+var COMPACT_SOON_PCT = 60;
+var COMPACTION_THRASH_N = 3;
+var CACHE_RATIO_FLOOR = 0.5;
+var CACHE_WARMUP_TURNS = 20;
+var BIG_DIFF_LINES = 1000;
+var UNTRACKED_N = 20;
+var STASH_N = 5;
+var STALE_BRANCH_N = 20;
+var TODO_STALLED_MIN = 30;
+var TIER_THRESHOLDS = [3, 15, 50, 100];
+var PRICING_TIER_THRESHOLD = 200000;
 // src/domain/enums.ts
 var MOODS = ["idle", "busy", "happy", "struggling", "recovery"];
 var PRESSURE_MOODS = ["compact_hint", "block_limit", "weekly_limit"];
@@ -130,6 +144,9 @@ var REACTION_CATEGORIES = [
   "db_migrate",
   "dangerous"
 ];
+var MIN_SEVERITIES = ["low", "medium", "high", "critical"];
+var CHARACTER_MODES = ["fixed", "random"];
+var BANDINGS = ["solid", "cycle"];
 var isStack = (s) => STACKS.includes(s);
 var isEventCategory = (s) => EVENT_CATEGORIES.includes(s);
 // src/domain/ids.ts
@@ -324,7 +341,6 @@ var pricing_default = [
 
 // src/derived/pricing.ts
 var PER_MILLION = 1e6;
-var TIER_THRESHOLD = 200000;
 var RAW = pricing_default;
 var TABLE = (() => {
   const byKey = new Map;
@@ -403,9 +419,9 @@ function resolvePrice(modelId, aliases = NO_ALIASES, atMs) {
   return rows ? pickRow(rows, atMs) : null;
 }
 function tiered(tokens, base, above) {
-  if (tokens <= TIER_THRESHOLD || above === undefined)
+  if (tokens <= PRICING_TIER_THRESHOLD || above === undefined)
     return tokens * base;
-  return TIER_THRESHOLD * base + (tokens - TIER_THRESHOLD) * above;
+  return PRICING_TIER_THRESHOLD * base + (tokens - PRICING_TIER_THRESHOLD) * above;
 }
 function priceMessage(usage, modelId, aliases = NO_ALIASES, atMs) {
   const row = resolvePrice(modelId, aliases, atMs);
@@ -480,6 +496,7 @@ function joinRecords(attribution, cache, tz) {
   for (const [session, g] of groupBySession(cache)) {
     const attr = attribution[session];
     out.push({
+      session,
       character: attr?.character ?? "unknown",
       project: attr?.project ?? g.projectRaw,
       start: g.start,
@@ -489,7 +506,6 @@ function joinRecords(attribution, cache, tz) {
   }
   return out;
 }
-var TIER_THRESHOLDS = [3, 15, 50, 100];
 function tierForCount(n) {
   const [t1, t2, t3, t4] = TIER_THRESHOLDS;
   if (n < t1)
@@ -516,7 +532,7 @@ function currentStreak(activeDays, today) {
   }
   return streak;
 }
-function deriveFamiliarity(attribution, character, cache, project, clock) {
+function deriveFamiliarity(attribution, character, cache, project, clock, currentSession = "") {
   const tz = clock.timezone();
   const records = joinRecords(attribution, cache, tz);
   const seenProject = records.some((r) => r.project === String(project));
@@ -528,10 +544,12 @@ function deriveFamiliarity(attribution, character, cache, project, clock) {
   let lastEnd = Number.NEGATIVE_INFINITY;
   let workingSinceMs = Number.POSITIVE_INFINITY;
   for (const r of mine) {
-    if (r.end > lastEnd)
-      lastEnd = r.end;
     if (r.start < workingSinceMs)
       workingSinceMs = r.start;
+    if (r.session === currentSession)
+      continue;
+    if (r.end > lastEnd)
+      lastEnd = r.end;
   }
   const daysSinceLastSession = Number.isFinite(lastEnd) ? Math.floor((clock.now() - lastEnd) / MS_PER_DAY) : Number.POSITIVE_INFINITY;
   return {
@@ -757,7 +775,6 @@ function classify(toolName, command, ok) {
   return category !== undefined ? { category } : null;
 }
 // src/derived/signals.ts
-var QUOTA_CRITICAL_PCT = 80;
 function contextBand(pct) {
   if (pct < 34)
     return "nominal";
@@ -766,9 +783,9 @@ function contextBand(pct) {
   return "critical";
 }
 function quotaBand(usedPct, resetsAtMs, windowMs, nowMs) {
-  if (usedPct >= QUOTA_CRITICAL_PCT)
+  if (usedPct >= QUOTA_HIGH_PCT)
     return "critical";
-  if (resetsAtMs === undefined)
+  if (resetsAtMs === undefined || usedPct < QUOTA_PACE_MIN_PCT)
     return contextBand(usedPct);
   const usedFraction = usedPct / 100;
   const elapsedFraction = Math.max((nowMs - (resetsAtMs - windowMs)) / windowMs, 0.01);
@@ -779,6 +796,13 @@ function quotaBand(usedPct, resetsAtMs, windowMs, nowMs) {
     return "caution";
   return "critical";
 }
+function overQuotaPace(usedPct, resetsAtMs, windowMs, nowMs) {
+  if (resetsAtMs === undefined)
+    return false;
+  const usedFraction = usedPct / 100;
+  const elapsedFraction = Math.max((nowMs - (resetsAtMs - windowMs)) / windowMs, 0.01);
+  return usedFraction / elapsedFraction > 1.5;
+}
 
 // src/derived/context.ts
 function deriveContext(payload, scan) {
@@ -1149,12 +1173,13 @@ function buildWindow(payloadQuota, oauthQuota, windowMs, clock) {
     return;
   }
   const band = quotaBand(usedPct, resetsAtMs, windowMs, clock.now());
+  const overPace = overQuotaPace(usedPct, resetsAtMs, windowMs, clock.now());
   if (resetsAtMs === undefined)
-    return { usedPct, band };
+    return { usedPct, band, overPace };
   const left = resetsAtMs - clock.now();
   if (left <= 0)
-    return { usedPct, band };
-  return { usedPct, band, resetIn: fmtLeft(left) };
+    return { usedPct, band, overPace };
+  return { usedPct, band, overPace, resetIn: fmtLeft(left) };
 }
 function buildPayg(usage) {
   const extra = usage?.extra_usage;
@@ -1252,7 +1277,7 @@ function readJson(path, fallback) {
 }
 
 // src/sources/storage/withLock.ts
-import { closeSync, mkdirSync as mkdirSync2, openSync, statSync, unlinkSync } from "node:fs";
+import { closeSync, mkdirSync as mkdirSync2, openSync, renameSync as renameSync2, statSync, unlinkSync } from "node:fs";
 import { dirname as dirname2 } from "node:path";
 var STALE_MS = 30000;
 function withLock(lockPath, fn, readOnly) {
@@ -1267,8 +1292,12 @@ function withLock(lockPath, fn, readOnly) {
   } catch {
     try {
       if (Date.now() - statSync(lockPath).mtimeMs > STALE_MS) {
-        unlinkSync(lockPath);
+        const aside = `${lockPath}.stale`;
+        renameSync2(lockPath, aside);
         fd = openSync(lockPath, "wx");
+        try {
+          unlinkSync(aside);
+        } catch {}
       }
     } catch {}
   }
@@ -1355,14 +1384,27 @@ function upsertAttribution(root, sessionId, rec) {
   const path = storePath(root);
   withLock(`${path}.lock`, () => {
     const store = coerceStore(readJson(path, undefined));
+    const existing = store[sessionId];
+    if (existing !== undefined && existing.project === rec.project && existing.character === rec.character) {
+      return;
+    }
     store[sessionId] = rec.updatedMs !== undefined ? { project: rec.project, character: rec.character, updatedMs: rec.updatedMs } : { project: rec.project, character: rec.character };
     atomicWrite(path, JSON.stringify(store));
   }, () => {});
 }
 // src/sources/balance.ts
+import { statSync as statSync3 } from "node:fs";
+var BALANCE_MAX_BYTES = 64 * 1024;
 function readBalance(path, clock) {
   if (path === "")
     return null;
+  try {
+    const st = statSync3(path);
+    if (!st.isFile() || st.size > BALANCE_MAX_BYTES)
+      return null;
+  } catch {
+    return null;
+  }
   const raw = readJson(path, undefined);
   if (typeof raw !== "object" || raw === null)
     return null;
@@ -2493,10 +2535,10 @@ function loadConfig(globalToml = "", projectToml = "") {
   const statusline = section(g, p, "statusline");
   const d = DEFAULT_CONFIG;
   return {
-    schema_version: numv(p["schema_version"] ?? g["schema_version"], d.schema_version),
+    schema_version: numv(p["schema_version"], numv(g["schema_version"], d.schema_version)),
     character: {
       enabled: bool(character["enabled"], d.character.enabled),
-      mode: oneOf(character["mode"], ["fixed", "random"], d.character.mode),
+      mode: oneOf(character["mode"], CHARACTER_MODES, d.character.mode),
       name: str(character["name"], d.character.name),
       roster: stringArray(character["roster"], d.character.roster)
     },
@@ -2505,7 +2547,7 @@ function loadConfig(globalToml = "", projectToml = "") {
       ...typeof theme["statusline"] === "string" ? { statusline: theme["statusline"] } : {},
       ...typeof theme["logo"] === "string" ? { logo: theme["logo"] } : {},
       ...typeof theme["comment"] === "string" ? { comment: theme["comment"] } : {},
-      banding: oneOf(theme["banding"], ["solid", "cycle"], d.theme.banding),
+      banding: oneOf(theme["banding"], BANDINGS, d.theme.banding),
       mood_shift: bool(theme["mood_shift"], d.theme.mood_shift),
       icons: mergeIcons({
         ...obj(obj(g["theme"])["icons"]),
@@ -2515,7 +2557,7 @@ function loadConfig(globalToml = "", projectToml = "") {
     comments: {
       character: bool(comments["character"], d.comments.character),
       helpful: bool(comments["helpful"], d.comments.helpful),
-      min_severity: oneOf(comments["min_severity"], ["low", "medium", "high", "critical"], d.comments.min_severity)
+      min_severity: oneOf(comments["min_severity"], MIN_SEVERITIES, d.comments.min_severity)
     },
     network: {
       fx_refresh: bool(network["fx_refresh"], d.network.fx_refresh),
@@ -2645,7 +2687,19 @@ function coerceEntry(v) {
   }
   const projectPath = typeof v["projectPath"] === "string" ? v["projectPath"] : String(record.project);
   const models = Array.isArray(v["models"]) ? v["models"].filter((x) => typeof x === "string") : [];
-  return { mtime, size, total, lines, models, projectPath, record };
+  const byteOffset = asNumber(v["byteOffset"]);
+  const headHash = typeof v["headHash"] === "string" ? v["headHash"] : undefined;
+  return {
+    mtime,
+    size,
+    total,
+    lines,
+    models,
+    projectPath,
+    record,
+    ...byteOffset !== undefined ? { byteOffset } : {},
+    ...headHash !== undefined ? { headHash } : {}
+  };
 }
 function coerceByModel(v) {
   if (!isObject(v))
@@ -2702,7 +2756,6 @@ function writeCostCache(root, c) {
 // src/sources/creds.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { readFileSync as readFileSync4 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
 import { join as join5 } from "node:path";
 
 // src/sources/oauthUsage.ts
@@ -2899,7 +2952,6 @@ function readUsage(root, clock, opts) {
 }
 
 // src/sources/creds.ts
-var KEYCHAIN_SERVICE2 = "Claude Code-credentials";
 var SUBSCRIPTIONS = new Set(["pro", "max", "team", "enterprise"]);
 var isObject3 = (v) => typeof v === "object" && v !== null;
 var defaultRunner = (cmd, args) => {
@@ -2916,11 +2968,8 @@ var defaultRunner = (cmd, args) => {
     return "";
   }
 };
-function configBase2() {
-  return process.env["CLAUDE_CONFIG_DIR"] ?? join5(homedir3(), ".claude");
-}
 function readBlob(run, base) {
-  for (const service of [keychainService(base), KEYCHAIN_SERVICE2]) {
+  for (const service of [keychainService(base), KEYCHAIN_SERVICE]) {
     const keychain = run("security", ["find-generic-password", "-s", service, "-w"]);
     if (keychain.trim() !== "")
       return keychain;
@@ -2930,7 +2979,7 @@ function readBlob(run, base) {
     if (file.trim() !== "")
       return file;
   } catch {}
-  const secretTool = run("secret-tool", ["lookup", "service", KEYCHAIN_SERVICE2]);
+  const secretTool = run("secret-tool", ["lookup", "service", KEYCHAIN_SERVICE]);
   if (secretTool.trim() !== "")
     return secretTool;
   return "";
@@ -2959,7 +3008,7 @@ function readOrgTier(base) {
 }
 function readCreds(run = defaultRunner) {
   try {
-    const base = configBase2();
+    const base = configBase();
     const blob = readBlob(run, base);
     if (blob.trim() !== "") {
       const tier = parseSubscription(blob);
@@ -2973,6 +3022,39 @@ function readCreds(run = defaultRunner) {
     return null;
   }
 }
+var CREDS_CACHE_FILE = "creds.json";
+function credsCachePath(root) {
+  return join5(cacheDir(root), CREDS_CACHE_FILE);
+}
+function coerceCachedCreds(raw) {
+  if (!isObject3(raw) || typeof raw["at"] !== "number")
+    return null;
+  const at = raw["at"];
+  const info = raw["info"];
+  if (info === null)
+    return { info: null, at };
+  if (isObject3(info) && typeof info["present"] === "boolean") {
+    const sub = info["subscriptionType"];
+    return {
+      at,
+      info: typeof sub === "string" && SUBSCRIPTIONS.has(sub) ? { present: info["present"], subscriptionType: sub } : { present: info["present"] }
+    };
+  }
+  return null;
+}
+function readCredsCached(root) {
+  return coerceCachedCreds(readJson(credsCachePath(root), undefined))?.info ?? null;
+}
+function refreshCreds(root, clock, run = defaultRunner) {
+  const cached = coerceCachedCreds(readJson(credsCachePath(root), undefined));
+  const now = clock.now();
+  if (cached !== null && now - cached.at <= CREDS_TTL_MS)
+    return;
+  const info = readCreds(run);
+  try {
+    atomicWrite(credsCachePath(root), JSON.stringify({ info, at: now }));
+  } catch {}
+}
 // src/sources/env.ts
 var on = (v) => v === "1" || v === "true";
 function isCustomHost(base) {
@@ -3455,12 +3537,14 @@ function readSubmoduleRollup(run, workTreeRoot) {
   return rollup;
 }
 function readGit(cwd, run = defaultRunner2(cwd)) {
-  if (run(["rev-parse", "--is-inside-work-tree"]).trim() !== "true")
+  const probe = run(["rev-parse", "--is-inside-work-tree", "--git-dir", "--show-toplevel"]).split(`
+`);
+  if ((probe[0] ?? "").trim() !== "true")
     return null;
   const status = parseStatus(run(["status", "--porcelain=v2", "--branch", "--show-stash"]));
-  const gitDirRaw = run(["rev-parse", "--git-dir"]).trim();
+  const gitDirRaw = (probe[1] ?? "").trim();
   const gitDir = gitDirRaw === "" ? "" : resolve(cwd, gitDirRaw);
-  const workTreeRoot = run(["rev-parse", "--show-toplevel"]).trim();
+  const workTreeRoot = (probe[2] ?? "").trim();
   const tag = run(["describe", "--tags", "--exact-match"]).trim() || undefined;
   const originRepo = normalizeOriginRepo(run(["remote", "get-url", "origin"]));
   const defaultBranch = resolveDefaultBranch(run);
@@ -3507,7 +3591,7 @@ function readGit(cwd, run = defaultRunner2(cwd)) {
 }
 // src/sources/helpfulEnv.ts
 import { readFileSync as readFileSync7 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
+import { homedir as homedir3 } from "node:os";
 import { delimiter, join as join9 } from "node:path";
 var opt3 = (key, value) => value !== undefined ? { [key]: value } : {};
 function kubeconfigPath() {
@@ -3517,7 +3601,7 @@ function kubeconfigPath() {
     if (first !== undefined)
       return first;
   }
-  return join9(homedir4(), ".kube", "config");
+  return join9(homedir3(), ".kube", "config");
 }
 function readKubeContext() {
   try {
@@ -3821,7 +3905,7 @@ function writeState(sessionDir2, s) {
   }, () => {});
 }
 // src/sources/transcript.ts
-import { readFileSync as readFileSync8, readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
+import { closeSync as closeSync2, openSync as openSync2, readFileSync as readFileSync8, readSync, readdirSync as readdirSync2, statSync as statSync4 } from "node:fs";
 import { basename, dirname as dirname6, join as join12 } from "node:path";
 var asObj = (v) => v !== null && typeof v === "object" ? v : undefined;
 var asStr = (v) => typeof v === "string" ? v : undefined;
@@ -4047,7 +4131,7 @@ function reconstructTodos(lines) {
 }
 function statSafe(p) {
   try {
-    const s = statSync3(p);
+    const s = statSync4(p);
     return { mtimeMs: s.mtimeMs, size: s.size };
   } catch {
     return null;
@@ -4060,6 +4144,63 @@ function readSafe(p) {
     return "";
   }
 }
+function readBufSafe(p) {
+  try {
+    return readFileSync8(p);
+  } catch {
+    return null;
+  }
+}
+function readRange(p, start, end) {
+  if (end <= start)
+    return Buffer.alloc(0);
+  let fd;
+  try {
+    fd = openSync2(p, "r");
+    const len = end - start;
+    const buf = Buffer.allocUnsafe(len);
+    let off = 0;
+    while (off < len) {
+      const n = readSync(fd, buf, off, len - off, start + off);
+      if (n === 0)
+        break;
+      off += n;
+    }
+    return off === len ? buf : null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined)
+      closeSync2(fd);
+  }
+}
+var HEAD_HASH_BYTES = 4096;
+function headHashOf(head) {
+  let h = 2166136261;
+  for (const b of head) {
+    h ^= b;
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16);
+}
+function makeInternModel(models) {
+  const index = new Map;
+  models.forEach((m, i) => index.set(m, i));
+  return (model) => {
+    let i = index.get(model);
+    if (i === undefined) {
+      i = models.length;
+      models.push(model);
+      index.set(model, i);
+    }
+    return i;
+  };
+}
+function lastLineEnd(buf) {
+  const i = buf.lastIndexOf(10);
+  return i < 0 ? 0 : i + 1;
+}
+var headLen = (byteOffset) => Math.min(HEAD_HASH_BYTES, byteOffset);
 var EMPTY_TOKENS = {
   input: 0,
   output: 0,
@@ -4150,7 +4291,7 @@ function* walkTree(dir, encodedDir) {
     const full = join12(dir, name);
     let st;
     try {
-      st = statSync3(full);
+      st = statSync4(full);
     } catch {
       continue;
     }
@@ -4189,22 +4330,16 @@ function scanBounds(lines) {
   return { sessionId, start, end };
 }
 function priceFile(path, encodedDir, st, price, resolveProject) {
-  const lines = parseAll(readSafe(path));
+  const buf = readBufSafe(path) ?? Buffer.alloc(0);
+  const byteOffset = lastLineEnd(buf);
+  const headHash = headHashOf(buf.subarray(0, headLen(byteOffset)));
+  const lines = parseAll(buf.subarray(0, byteOffset).toString("utf8"));
   const { sessionId, start, end } = scanBounds(lines);
   const priced = collapseStreaming(lines);
   const gate = makeDedupGate();
   const costLines = [];
   const models = [];
-  const modelIndex = new Map;
-  const internModel = (model) => {
-    let i = modelIndex.get(model);
-    if (i === undefined) {
-      i = models.length;
-      models.push(model);
-      modelIndex.set(model, i);
-    }
-    return i;
-  };
+  const internModel = makeInternModel(models);
   let total = 0;
   let input = 0;
   let output = 0;
@@ -4249,6 +4384,8 @@ function priceFile(path, encodedDir, st, price, resolveProject) {
   return {
     mtime: st.mtimeMs,
     size: st.size,
+    byteOffset,
+    headHash,
     total,
     lines: costLines,
     models,
@@ -4256,6 +4393,138 @@ function priceFile(path, encodedDir, st, price, resolveProject) {
     record
   };
 }
+function resumeCostFile(cached, path, st, price) {
+  const tail = readAppendedTail(cached, path, st);
+  if (tail === null)
+    return null;
+  if (tail === "partial")
+    return { ...cached, mtime: st.mtimeMs, size: st.size };
+  const models = [...cached.models];
+  const keyIndex = new Map;
+  cached.lines.forEach((l, i) => {
+    if (l.id !== undefined && l.reqId !== undefined)
+      keyIndex.set(`${l.id}|${l.reqId}`, i);
+  });
+  const gate = makeDedupGate();
+  const acc = {
+    lines: [...cached.lines],
+    models,
+    counted: cached.lines.map((l) => gate(l.id, l.reqId, l.sidechain)),
+    keyIndex,
+    gate,
+    internModel: makeInternModel(models),
+    input: cached.record.tokens.input,
+    output: cached.record.tokens.output,
+    cacheRead: cached.record.tokens.cache_read,
+    cacheCreation: cached.record.tokens.cache_creation,
+    total: cached.total,
+    messages: cached.record.messages,
+    start: cached.record.start,
+    end: cached.record.end
+  };
+  for (const l of collapseStreaming(tail.appended))
+    foldAppendedLine(acc, l, price);
+  return {
+    mtime: st.mtimeMs,
+    size: st.size,
+    byteOffset: tail.newByteOffset,
+    headHash: tail.newHeadHash,
+    total: acc.total,
+    lines: acc.lines,
+    models: acc.models,
+    projectPath: cached.projectPath,
+    record: {
+      ...cached.record,
+      start: acc.start,
+      end: acc.end,
+      tokens: {
+        input: acc.input,
+        output: acc.output,
+        cache_read: acc.cacheRead,
+        cache_creation: acc.cacheCreation
+      },
+      messages: acc.messages
+    }
+  };
+}
+function costLineOf(internModel, l, cost, totalTok) {
+  return {
+    ...l.id !== undefined ? { id: l.id } : {},
+    ...l.requestId !== undefined ? { reqId: l.requestId } : {},
+    sidechain: l.isSidechain,
+    ts: l.tsMs ?? 0,
+    cost,
+    ...l.model !== undefined ? { m: internModel(l.model) } : {},
+    tok: totalTok
+  };
+}
+function readAppendedTail(cached, path, st) {
+  const offset = cached.byteOffset;
+  if (offset === undefined || offset === 0 || st.size < offset)
+    return null;
+  const head = readRange(path, 0, headLen(offset));
+  if (head === null || headHashOf(head) !== cached.headHash)
+    return null;
+  const tailBuf = readRange(path, offset, st.size);
+  if (tailBuf === null)
+    return null;
+  const added = lastLineEnd(tailBuf);
+  if (added === 0)
+    return "partial";
+  const newByteOffset = offset + added;
+  const newHead = headLen(newByteOffset) === head.length ? head : readRange(path, 0, headLen(newByteOffset));
+  if (newHead === null)
+    return null;
+  return {
+    appended: parseAll(tailBuf.subarray(0, added).toString("utf8")),
+    newByteOffset,
+    newHeadHash: headHashOf(newHead)
+  };
+}
+function widenBounds(acc, tsMs) {
+  if (tsMs === undefined)
+    return;
+  if (tsMs > acc.end)
+    acc.end = tsMs;
+  if (acc.start === 0 || tsMs < acc.start)
+    acc.start = tsMs;
+}
+function foldAppendedLine(acc, l, price) {
+  widenBounds(acc, l.tsMs);
+  const usage = l.usage;
+  if (usage === undefined)
+    return;
+  const t = tokenize(usage);
+  const totalTok = t.input + t.output + t.cache_read + t.c5m + t.c1h;
+  const key = l.id !== undefined && l.requestId !== undefined ? `${l.id}|${l.requestId}` : null;
+  const existing = key !== null ? acc.keyIndex.get(key) : undefined;
+  const old = existing !== undefined ? acc.lines[existing] : undefined;
+  if (existing !== undefined && old !== undefined) {
+    if (totalTok <= (old.tok ?? 0))
+      return;
+    const cost2 = price(usage, l.model ?? "", l.tsMs);
+    if (acc.counted[existing] === true) {
+      acc.output += totalTok - (old.tok ?? 0);
+      acc.total += cost2 - old.cost;
+    }
+    acc.lines[existing] = costLineOf(acc.internModel, l, cost2, totalTok);
+    return;
+  }
+  const cost = price(usage, l.model ?? "", l.tsMs);
+  const isCounted = acc.gate(l.id, l.requestId, l.isSidechain);
+  if (key !== null)
+    acc.keyIndex.set(key, acc.lines.length);
+  acc.lines.push(costLineOf(acc.internModel, l, cost, totalTok));
+  acc.counted.push(isCounted);
+  if (isCounted) {
+    acc.input += t.input;
+    acc.output += t.output;
+    acc.cacheRead += t.cache_read;
+    acc.cacheCreation += t.c5m + t.c1h;
+    acc.total += cost;
+    acc.messages += 1;
+  }
+}
 function buildAggregate(files, chat) {
   const sessionProject = {};
   const all = [];
@@ -4290,17 +4559,27 @@ function scanCostTree(root, cache, clock, price, resolveProject) {
     return cache;
   const chat = cache.aggregate.chat;
   const files = {};
+  let changed = false;
   for (const { path, encodedDir } of walkJsonl(root)) {
     const st = statSafe(path);
     if (!st)
       continue;
     const cached = cache.files[path];
-    files[path] = cached && cached.mtime === st.mtimeMs && cached.size === st.size ? cached : priceFile(path, encodedDir, st, price, resolveProject);
+    if (cached && cached.mtime === st.mtimeMs && cached.size === st.size) {
+      files[path] = cached;
+    } else {
+      const resumed = cached ? resumeCostFile(cached, path, st, price) : null;
+      files[path] = resumed ?? priceFile(path, encodedDir, st, price, resolveProject);
+      changed = true;
+    }
   }
+  const sameFileSet = Object.keys(files).length === Object.keys(cache.files).length;
+  if (!changed && sameFileSet)
+    return { files, aggregate: cache.aggregate, lastScanTs: now };
   return { files, aggregate: buildAggregate(files, chat), lastScanTs: now };
 }
 // src/cli/classify.ts
-var FAIL_RE = /FAILED|Error|✗|not ok|FAIL/;
+var FAIL_RE = /\bFAILED\b|\bFAIL\b|✗|✕|\bnot ok\b|error:|error\[|error TS\d|error CS\d|\bpanic:|Traceback \(most recent call last\)|[1-9]\d* (?:failed|failing|errors?)\b/;
 function asObject(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v) ? v : undefined;
 }
@@ -4316,10 +4595,8 @@ function softFail(toolResponse) {
     return false;
   if (r["isError"] === true || r["interrupted"] === true)
     return true;
-  const stderr = asString(r["stderr"]);
-  if (stderr !== undefined && stderr !== "")
-    return true;
-  const out = `${asString(r["stdout"]) ?? ""}${stderr ?? ""}`;
+  const out = `${asString(r["stdout"]) ?? ""}
+${asString(r["stderr"]) ?? ""}`;
   return FAIL_RE.test(out);
 }
 function commandOf(toolInput) {
@@ -4340,16 +4617,6 @@ function appendClassified(dir, toolName, command, ok, ts) {
   if (c !== null)
     appendEvent(dir, { ts, ...c });
 }
-function appendBatch(dir, calls, ts) {
-  for (const call of calls) {
-    const c = asObject(call);
-    const toolName = c !== undefined ? asString(c["tool_name"]) : undefined;
-    if (c === undefined || toolName === undefined)
-      continue;
-    const ok = !softFail(c["tool_response"]);
-    appendClassified(dir, toolName, commandOf(c["tool_input"]), ok, ts);
-  }
-}
 function runClassify(stdin, env, clock) {
   try {
     const r = asObject(JSON.parse(stdin));
@@ -4361,12 +4628,6 @@ function runClassify(stdin, env, clock) {
     const dir = sessionDir(ccsidekickRoot(env), session);
     const ts = clock.now();
     const hook = asString(r["hook_event_name"]);
-    if (hook === "PostToolBatch") {
-      const calls = r["tool_calls"];
-      if (Array.isArray(calls))
-        appendBatch(dir, calls, ts);
-      return;
-    }
     const toolName = asString(r["tool_name"]);
     if (toolName === undefined)
       return;
@@ -4379,7 +4640,7 @@ function runClassify(stdin, env, clock) {
   } catch {}
 }
 // src/cli/render.ts
-import { readFileSync as readFileSync10 } from "node:fs";
+import { readFileSync as readFileSync11 } from "node:fs";
 import { dirname as dirname7, join as join14 } from "node:path";
 
 // src/compose/character.ts
@@ -6096,16 +6357,6 @@ function composeStatusline(ctx) {
   return { fields, providerBadge };
 }
 // src/compose/helpful/catalog.ts
-var COMPACT_SOON_PCT = 60;
-var QUOTA_PROJECT_MIN_PCT = 50;
-var COMPACTION_THRASH_N = 3;
-var CACHE_RATIO_FLOOR = 0.5;
-var CACHE_WARMUP_TURNS = 20;
-var BIG_DIFF_LINES = 1000;
-var UNTRACKED_N = 20;
-var STASH_N = 5;
-var STALE_BRANCH_N = 20;
-var TODO_STALLED_MIN = 30;
 var EFFORT_LOW_LEVEL = "low";
 var PROD_CONTEXT_PATTERN = /prod/i;
 var SECRET_PATTERNS = [
@@ -6280,7 +6531,7 @@ var HELPFUL_CATALOG = [
     category: "quota",
     momentary: false,
     template: "5h limit at {pct}%, {reset} to reset. Save heavy asks for after.",
-    test: (i) => i.quota.block !== undefined && i.quota.block.usedPct > QUOTA_HIGH_PCT,
+    test: (i) => i.quota.block !== undefined && i.quota.block.usedPct > QUOTA_HIGH_PCT && i.quota.block.overPace === true,
     render: (i) => `5h limit at ${pct(i.quota.block?.usedPct ?? 0)}, ${bare(i.quota.block?.resetIn)} to reset. Save heavy asks for after.`
   },
   {
@@ -6289,7 +6540,7 @@ var HELPFUL_CATALOG = [
     category: "quota",
     momentary: false,
     template: "Weekly quota {pct}% spent, {reset} to go. Ration the big requests.",
-    test: (i) => i.quota.weekly !== undefined && i.quota.weekly.usedPct > QUOTA_HIGH_PCT,
+    test: (i) => i.quota.weekly !== undefined && i.quota.weekly.usedPct > QUOTA_HIGH_PCT && i.quota.weekly.overPace === true,
     render: (i) => `Weekly quota ${pct(i.quota.weekly?.usedPct ?? 0)} spent, ${bare(i.quota.weekly?.resetIn)} to go. Ration the big requests.`
   },
   {
@@ -6298,7 +6549,7 @@ var HELPFUL_CATALOG = [
     category: "quota",
     momentary: false,
     template: "This burn rate empties the 5h block before reset, cutting you off mid-task.",
-    test: (i) => i.quota.block !== undefined && i.quota.block.band !== "nominal" && i.quota.block.usedPct > QUOTA_PROJECT_MIN_PCT,
+    test: (i) => i.quota.block !== undefined && i.quota.block.usedPct > QUOTA_PROJECT_MIN_PCT && i.quota.block.overPace === true,
     render: () => "This burn rate empties the 5h block before reset, cutting you off mid-task."
   },
   {
@@ -6307,7 +6558,7 @@ var HELPFUL_CATALOG = [
     category: "quota",
     momentary: false,
     template: "At this pace the weekly quota runs dry before reset, locking you out for days.",
-    test: (i) => i.quota.weekly !== undefined && i.quota.weekly.band !== "nominal" && i.quota.weekly.usedPct > QUOTA_PROJECT_MIN_PCT,
+    test: (i) => i.quota.weekly !== undefined && i.quota.weekly.usedPct > QUOTA_PROJECT_MIN_PCT && i.quota.weekly.overPace === true,
     render: () => "At this pace the weekly quota runs dry before reset, locking you out for days."
   },
   {
@@ -6928,16 +7179,33 @@ var PACKS = [
   "yoda"
 ];
 // src/cli/gc.ts
-import { existsSync as existsSync2, readdirSync as readdirSync3, rmSync, statSync as statSync4 } from "node:fs";
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync10,
+  readdirSync as readdirSync3,
+  rmSync,
+  statSync as statSync5,
+  writeFileSync as writeFileSync3
+} from "node:fs";
 import { join as join13 } from "node:path";
 var DAY_MS = 86400000;
+var GC_MIN_INTERVAL_MS = 6 * 60 * 60 * 1000;
+function readGcStamp(path) {
+  try {
+    const n = Number(readFileSync10(path, "utf8"));
+    return Number.isFinite(n) ? n : undefined;
+  } catch {
+    return;
+  }
+}
 function newestMtime(dir) {
   let newest = 0;
   try {
-    newest = statSync4(dir).mtimeMs;
+    newest = statSync5(dir).mtimeMs;
     for (const name of readdirSync3(dir)) {
       try {
-        const m = statSync4(join13(dir, name)).mtimeMs;
+        const m = statSync5(join13(dir, name)).mtimeMs;
         if (m > newest)
           newest = m;
       } catch {}
@@ -6957,7 +7225,7 @@ function pruneSessions(root, now) {
   for (const name of names) {
     const dir = join13(sessions, name);
     try {
-      if (!statSync4(dir).isDirectory())
+      if (!statSync5(dir).isDirectory())
         continue;
     } catch {
       continue;
@@ -6970,23 +7238,48 @@ function pruneSessions(root, now) {
 function pruneCostCache(root) {
   const cache = readCostCache(root);
   const kept = {};
+  const liveSessions = new Set;
   let dropped = false;
   for (const [path, entry] of Object.entries(cache.files)) {
-    if (existsSync2(path))
+    if (existsSync2(path)) {
       kept[path] = entry;
-    else
+      liveSessions.add(String(entry.record.session));
+    } else {
       dropped = true;
+    }
+  }
+  const chatKept = {};
+  let chatDropped = false;
+  for (const [session, cost] of Object.entries(cache.aggregate.chat)) {
+    if (liveSessions.has(session))
+      chatKept[session] = cost;
+    else
+      chatDropped = true;
+  }
+  if (dropped || chatDropped) {
+    writeCostCache(root, {
+      ...cache,
+      files: kept,
+      aggregate: { ...cache.aggregate, chat: chatKept }
+    });
   }
-  if (dropped)
-    writeCostCache(root, { ...cache, files: kept });
 }
 function runGc(root, clock) {
+  const now = clock.now();
+  const stampPath = join13(root, "cache", ".gc-stamp");
+  const last = readGcStamp(stampPath);
+  if (last !== undefined && now - last < GC_MIN_INTERVAL_MS)
+    return;
   try {
-    pruneSessions(root, clock.now());
+    pruneSessions(root, now);
   } catch {}
   try {
     pruneCostCache(root);
   } catch {}
+  try {
+    mkdirSync5(join13(root, "cache"), { recursive: true });
+    writeFileSync3(stampPath, String(now));
+  } catch {}
 }
 
 // src/cli/render.ts
@@ -6995,7 +7288,7 @@ var TIER_MILESTONES = new Set(TIER_THRESHOLDS);
 var YEAR_MS = 365 * 86400000;
 function readTextSafe(path) {
   try {
-    return readFileSync10(path, "utf8");
+    return readFileSync11(path, "utf8");
   } catch {
     return "";
   }
@@ -7030,19 +7323,29 @@ function applyThemeIcons(fields, theme, config) {
   });
 }
 function readGated(overrides, envInputs, config, root, dir, markers, clock) {
-  const creds = overrides?.creds !== undefined ? overrides.creds : envInputs.hasApiKey || config.network.usage_fetch ? readCreds() : null;
+  const creds = overrides?.creds !== undefined ? overrides.creds : envInputs.hasApiKey || config.network.usage_fetch ? readCredsCached(root) : null;
   const usage = overrides?.usage !== undefined ? overrides.usage : config.network.usage_fetch ? readUsageCached(root) : null;
   const balance = overrides?.balance !== undefined ? overrides.balance : config.network.balance_path !== "" ? readBalance(config.network.balance_path, clock) : null;
   const helpfulEnv = needsHelpfulEnv(markers) ? readHelpfulEnv(dir) : EMPTY_HELPFUL_ENV;
   return { creds, usage, balance, helpfulEnv };
 }
 var DEFAULT_EMBLEM = "❝";
-function lookupPackTheme(name) {
-  const loaded = loadPack(name);
+function packThemeOf(loaded) {
   if (!loaded.ok || loaded.pack.theme === undefined)
     return null;
   return { displayName: loaded.pack.displayName, ...loaded.pack.theme };
 }
+function makePackThemeLookup(persona, loaded, load = loadPack) {
+  const memo = new Map;
+  return (name) => {
+    const cached = memo.get(name);
+    if (cached !== undefined || memo.has(name))
+      return cached ?? null;
+    const theme = packThemeOf(name === persona ? loaded : load(name));
+    memo.set(name, theme);
+    return theme;
+  };
+}
 var NOOP = () => {};
 function runRender(stdin, env, term, clock, overrides) {
   try {
@@ -7105,8 +7408,8 @@ function build(stdin, env, term, clock, overrides) {
   const stacks = deriveStacks(markers, events);
   const fresh = freshestEvent(events);
   const stack = pickStack(stacks, fresh?.stack);
-  const familiarity = deriveFamiliarity(attribution, persona, scannedCache, project, clock);
-  const theme = resolveTheme(config, lookupPackTheme, persona);
+  const familiarity = deriveFamiliarity(attribution, persona, scannedCache, project, clock, String(session));
+  const theme = resolveTheme(config, makePackThemeLookup(persona, loaded), persona);
   const composeInputs = {
     provider,
     model,
@@ -7207,6 +7510,10 @@ function build(stdin, env, term, clock, overrides) {
     }
     swallow(() => {
       const payloadChat = payload.cost?.total_cost_usd;
+      const rescanned = scannedCache !== costCache;
+      const chatChanged = !isDefault && payloadChat !== undefined && scannedCache.aggregate.chat[String(session)] !== payloadChat;
+      if (!rescanned && !chatChanged)
+        return;
       const toWrite = !isDefault && payloadChat !== undefined ? {
         ...scannedCache,
         aggregate: {
@@ -7230,6 +7537,10 @@ function build(stdin, env, term, clock, overrides) {
     swallow(() => {
       readUsage(root, clock, { enabled: config.network.usage_fetch });
     });
+    swallow(() => {
+      if (envInputs.hasApiKey || config.network.usage_fetch)
+        refreshCreds(root, clock);
+    });
     swallow(() => {
       runGc(root, clock);
     });
@@ -7251,7 +7562,7 @@ function dispatchRender() {
       noColor: process.env["NO_COLOR"] !== undefined,
       isTTY: true
     };
-    const { line, persist } = runRender(readFileSync11(0, "utf8"), process.env, term, systemClock);
+    const { line, persist } = runRender(readFileSync12(0, "utf8"), process.env, term, systemClock);
     process.stdout.write(`${line}
 `);
     persist();
@@ -7259,7 +7570,7 @@ function dispatchRender() {
 }
 function dispatchClassify() {
   try {
-    runClassify(readFileSync11(0, "utf8"), process.env, systemClock);
+    runClassify(readFileSync12(0, "utf8"), process.env, systemClock);
   } catch {} finally {
     process.exit(0);
   }