fleetlens 0.13.2 → 0.14.0

package/dist/index.js

@@ -4002,13 +4002,138 @@ async function readJsonl2(filePath) {
   }
   return out;
 }
+function dedupeReplayedLines(lines) {
+  const keepAt = /* @__PURE__ */ new Map();
+  lines.forEach((line, i) => {
+    const rec = line;
+    if (typeof rec.uuid !== "string")
+      return;
+    const prev = keepAt.get(rec.uuid);
+    if (prev === void 0) {
+      keepAt.set(rec.uuid, i);
+      return;
+    }
+    const prevHasTs = lines[prev].timestamp !== void 0;
+    if (!prevHasTs && rec.timestamp !== void 0)
+      keepAt.set(rec.uuid, i);
+  });
+  return lines.filter((line, i) => {
+    const rec = line;
+    return typeof rec.uuid !== "string" || keepAt.get(rec.uuid) === i;
+  });
+}
+function textFromContent(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const b of content) {
+      if (b && typeof b === "object" && b.type === "text") {
+        const t = b.text;
+        if (typeof t === "string")
+          parts.push(t);
+      }
+    }
+    if (parts.length)
+      return parts.join("\n");
+  }
+  return void 0;
+}
+function partitionCoworkLines(lines) {
+  const mainLines = [];
+  const subagentGroups = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const ptid = line.parent_tool_use_id;
+    if (typeof ptid === "string") {
+      const g = subagentGroups.get(ptid);
+      if (g)
+        g.push(line);
+      else
+        subagentGroups.set(ptid, [line]);
+    } else {
+      mainLines.push(line);
+    }
+  }
+  return { mainLines, subagentGroups };
+}
+function buildCoworkSubagents(subagentGroups, allLines, sessionStartMs) {
+  if (subagentGroups.size === 0)
+    return [];
+  const refs = /* @__PURE__ */ new Map();
+  for (const line of allLines) {
+    const rec = line;
+    const content = rec.message?.content;
+    if (!Array.isArray(content))
+      continue;
+    for (const b of content) {
+      if (!b || typeof b !== "object")
+        continue;
+      const block = b;
+      if (block.type === "tool_use" && block.name === "Agent" && typeof block.id === "string") {
+        const input = block.input ?? {};
+        const ref = refs.get(block.id) ?? {};
+        if (typeof rec.uuid === "string")
+          ref.parentUuid = rec.uuid;
+        if (typeof input.description === "string")
+          ref.description = input.description;
+        if (typeof input.subagent_type === "string")
+          ref.agentType = input.subagent_type;
+        if (typeof input.prompt === "string")
+          ref.prompt = input.prompt;
+        refs.set(block.id, ref);
+      } else if (block.type === "tool_result" && typeof block.tool_use_id === "string" && subagentGroups.has(block.tool_use_id)) {
+        const ref = refs.get(block.tool_use_id) ?? {};
+        ref.finalText = textFromContent(block.content) ?? ref.finalText;
+        refs.set(block.tool_use_id, ref);
+      }
+    }
+  }
+  const runs2 = [];
+  for (const [toolUseId, groupLines] of subagentGroups) {
+    const summary = summarizeSubagentLines(groupLines);
+    const ref = refs.get(toolUseId) ?? {};
+    const finalText = ref.finalText ?? summary.finalText;
+    const finalPreview = finalText ? finalText.replace(/\s+/g, " ").trim().slice(0, 240) : summary.finalPreview;
+    const startTOffsetMs = sessionStartMs !== void 0 && summary.startMs !== void 0 ? Math.max(0, summary.startMs - sessionStartMs) : void 0;
+    const endTOffsetMs = sessionStartMs !== void 0 && summary.endMs !== void 0 ? Math.max(0, summary.endMs - sessionStartMs) : void 0;
+    const durationMs = summary.startMs !== void 0 && summary.endMs !== void 0 ? summary.endMs - summary.startMs : void 0;
+    runs2.push({
+      agentId: toolUseId,
+      agentType: ref.agentType ?? "unknown",
+      description: ref.description ?? (ref.prompt ? ref.prompt.replace(/\s+/g, " ").trim().slice(0, 80) : "(no description)"),
+      startMs: summary.startMs,
+      endMs: summary.endMs,
+      durationMs,
+      startTOffsetMs,
+      endTOffsetMs,
+      eventCount: summary.eventCount,
+      totalUsage: summary.totalUsage,
+      parentUuid: ref.parentUuid,
+      parentToolUseId: toolUseId,
+      runInBackground: false,
+      finalPreview,
+      finalText,
+      prompt: ref.prompt,
+      model: summary.model,
+      toolCalls: summary.toolCalls,
+      toolCallCount: summary.toolCallCount,
+      assistantMessageCount: summary.assistantMessageCount
+    });
+  }
+  runs2.sort((a, b) => (a.startMs ?? 0) - (b.startMs ?? 0));
+  return runs2;
+}
 async function parseCoworkSession(file) {
   const [lines, coworkMeta, spaceIdToPath] = await Promise.all([
     readJsonl2(file.auditPath),
     readCoworkMeta(file.metaPath),
     loadSpacesForWorkspace(file.workspaceDir)
   ]);
-  const { meta: baseMeta, events } = parseTranscript(lines);
+  const deduped = dedupeReplayedLines(lines);
+  const { mainLines, subagentGroups } = partitionCoworkLines(deduped);
+  const { meta: baseMeta, events } = parseTranscript(mainLines);
+  const sessionStartMs = baseMeta.firstTimestamp ? Date.parse(baseMeta.firstTimestamp) : void 0;
+  const subagents = buildCoworkSubagents(subagentGroups, deduped, sessionStartMs);
   const { projectName, projectDir, cwd } = resolveProject(coworkMeta, spaceIdToPath);
   const meta = {
     ...baseMeta,
@@ -4021,7 +4146,7 @@ async function parseCoworkSession(file) {
     cwd: cwd ?? baseMeta.cwd,
     model: baseMeta.model ?? coworkMeta.model
   };
-  return { meta, events };
+  return { meta, events, subagents };
 }
 function cacheKeyFor(file) {
   return {
@@ -4072,8 +4197,12 @@ async function getCoworkSession(id, opts = {}) {
   const cached = detailCache5.get(file.auditPath);
   if (cached && cacheKeyMatches(cached.key, key))
     return cached.detail;
-  const { meta, events } = await parseCoworkSession(file);
-  const detail = { ...meta, events };
+  const { meta, events, subagents } = await parseCoworkSession(file);
+  const detail = {
+    ...meta,
+    events,
+    ...subagents.length ? { subagents } : {}
+  };
   detailCache5.set(file.auditPath, { detail, key });
   return detail;
 }
@@ -4082,6 +4211,7 @@ var init_cowork = __esm({
   "../parser/dist/cowork.js"() {
     "use strict";
     init_analytics();
+    init_claude_code();
     init_parser();
     DEFAULT_COWORK_ROOT = defaultCoworkRoot();
     SESSION_ID_RE = /^local_[0-9a-f-]+$/;
@@ -4400,9 +4530,14 @@ function buildCalibrationCurve(events, snapshots, tier = "pro-max-20x", granular
     curve.push({
       ts: new Date(cur).toISOString(),
       real_5h: real5,
-      pred_5h: Math.max(0, Math.min(200, p5)),
+      // Predicted utilization LEGITIMATELY exceeds 200 on overage (the
+      // extrapolated cycle close). The old min(200) clamp silently capped it,
+      // so cyclePeaks.peakPct could never carry a *predicted* overage to the
+      // team server (which now accepts up to 10000). Keep only a generous
+      // finite ceiling as a corruption guard, matching the wire cap.
+      pred_5h: Math.max(0, Math.min(1e4, p5)),
       real_7d: real7,
-      pred_7d: Math.max(0, Math.min(200, p7)),
+      pred_7d: Math.max(0, Math.min(1e4, p7)),
       cycle_end_5h: r5k != null ? new Date(r5k).toISOString() : null,
       cycle_end_7d: r7k != null ? new Date(r7k).toISOString() : null
     });
@@ -4542,7 +4677,7 @@ function getServerStatus() {
   return { running: false };
 }
 function isServerStale(status2) {
-  return status2.running === true && status2.version !== "0.13.2";
+  return status2.running === true && status2.version !== "0.14.0";
 }
 async function ensureCurrentServer(opts = {}) {
   const status2 = getServerStatus();
@@ -4598,7 +4733,7 @@ async function startServer(opts = {}) {
   });
   child.unref();
   const pid = child.pid;
-  writePid(PID_FILE, pid, port, "0.13.2");
+  writePid(PID_FILE, pid, port, "0.14.0");
   await waitForHealth(`http://localhost:${port}`, 1e4);
   return { pid, port };
 }
@@ -4958,9 +5093,9 @@ Installed: ${PACKAGE_NAME}@${verify.installedVersion}  at ${verify.installedPath
     console.warn(
       `    \u2022 reinstall in the correct Node env: 'npm install -g ${PACKAGE_NAME}@latest'`
     );
-  } else if (verify.installedVersion !== "0.13.2") {
+  } else if (verify.installedVersion !== "0.14.0") {
     console.log(
-      `  \u2192 This process is still running ${"0.13.2"}. Next invocation will use ${verify.installedVersion}.`
+      `  \u2192 This process is still running ${"0.14.0"}. Next invocation will use ${verify.installedVersion}.`
     );
   }
 }
@@ -4995,14 +5130,14 @@ async function getUpdateAvailability() {
   if (isDevMode()) return null;
   const latest = await fetchLatestVersion();
   if (latest === null) return {
-    current: "0.13.2",
+    current: "0.14.0",
     latest: null,
     updateAvailable: false
   };
   return {
-    current: "0.13.2",
+    current: "0.14.0",
     latest,
-    updateAvailable: shouldUpdate("0.13.2", latest)
+    updateAvailable: shouldUpdate("0.14.0", latest)
   };
 }
 async function checkForUpdate() {
@@ -5092,7 +5227,7 @@ async function restartServices(state) {
 }
 async function forceUpdate() {
   const latest = await fetchLatestVersion();
-  const current = "0.13.2";
+  const current = "0.14.0";
   if (latest === null) {
     console.error("Could not reach npm registry. Check your network.");
     process.exit(1);
@@ -5450,7 +5585,7 @@ async function status() {
     console.log(`Server:  running on ${url} (PID ${server.pid}, v${ver})`);
     if (isServerStale(server)) {
       console.log(
-        `  \u26A0  serving stale ${ver} (CLI is ${"0.13.2"}) \u2014 run 'fleetlens start' to restart on the current version`
+        `  \u26A0  serving stale ${ver} (CLI is ${"0.14.0"}) \u2014 run 'fleetlens start' to restart on the current version`
       );
     }
   } else {
@@ -6058,8 +6193,42 @@ var init_usage = __esm({
 });
 
 // ../entries/dist/types.js
-function entryKey(sessionId, localDay) {
-  return `${sessionId}__${localDay}`;
+function pendingEnrichment() {
+  return {
+    status: "pending",
+    generated_at: null,
+    model: null,
+    cost_usd: null,
+    error: null,
+    brief_summary: null,
+    underlying_goal: null,
+    friction_detail: null,
+    user_instructions: [],
+    outcome: null,
+    claude_helpfulness: null,
+    goal_categories: {},
+    retry_count: 0
+  };
+}
+function skippedTrivialEnrichment(generatedAt) {
+  return {
+    status: "skipped_trivial",
+    generated_at: generatedAt,
+    model: null,
+    cost_usd: null,
+    error: null,
+    brief_summary: null,
+    underlying_goal: null,
+    friction_detail: null,
+    user_instructions: [],
+    outcome: "trivial",
+    claude_helpfulness: null,
+    goal_categories: {},
+    retry_count: 0
+  };
+}
+function entryKey(sessionId, localDay2) {
+  return `${sessionId}__${localDay2}`;
 }
 function parseEntryKey(key) {
   const m = /^([^_]+(?:_[^_]+)*)__(\d{4}-\d{2}-\d{2})$/.exec(key);
@@ -6067,10 +6236,11 @@ function parseEntryKey(key) {
     return null;
   return { session_id: m[1], local_day: m[2] };
 }
-var GOAL_CATEGORIES, CURRENT_DAY_DIGEST_SCHEMA_VERSION, CURRENT_WEEK_DIGEST_SCHEMA_VERSION, CURRENT_MONTH_DIGEST_SCHEMA_VERSION, PROMPT_FRAME_ORIGIN;
+var CURRENT_ENTRY_SCHEMA_VERSION, GOAL_CATEGORIES, CURRENT_DAY_DIGEST_SCHEMA_VERSION, CURRENT_WEEK_DIGEST_SCHEMA_VERSION, CURRENT_MONTH_DIGEST_SCHEMA_VERSION, PROMPT_FRAME_ORIGIN;
 var init_types = __esm({
   "../entries/dist/types.js"() {
     "use strict";
+    CURRENT_ENTRY_SCHEMA_VERSION = 2;
     GOAL_CATEGORIES = [
       "build",
       "plan",
@@ -6588,6 +6758,35 @@ function classifyUserInputSource(text) {
     return "slash_command";
   return "human";
 }
+function countSatisfactionSignals(text) {
+  if (!text)
+    return { happy: 0, satisfied: 0, dissatisfied: 0, frustrated: 0 };
+  return {
+    happy: (text.match(HAPPY_RE) ?? []).length,
+    satisfied: (text.match(SATISFIED_RE) ?? []).length,
+    dissatisfied: (text.match(DISSATISFIED_RE) ?? []).length,
+    frustrated: (text.match(FRUSTRATED_RE) ?? []).length
+  };
+}
+function extractUserInstructions(text) {
+  if (!text)
+    return [];
+  INSTRUCTION_RE.lastIndex = 0;
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  let m;
+  while ((m = INSTRUCTION_RE.exec(text)) !== null) {
+    const phrase = m[1].trim().replace(/\s+/g, " ");
+    const lc = phrase.toLowerCase();
+    if (seen.has(lc))
+      continue;
+    seen.add(lc);
+    out.push(phrase);
+    if (out.length >= 5)
+      break;
+  }
+  return out;
+}
 function classifySubagentRole(sa) {
   const text = `${sa.description} ${sa.prompt_preview}`.toLowerCase();
   if (/\b(re-?review|review[s]?|verify|audit|spec[- ]review|code[- ]quality|code[- ]reuse|efficiency review|sanity check|quick test)\b/.test(text)) {
@@ -6725,7 +6924,7 @@ function computeEntrySignals(entry) {
     continuation_kind
   };
 }
-var TEAMMATE_RE, SKILL_LOAD_RE, SLASH_COMMAND_RE2, STOCK_SUBAGENT_PREFIXES, STOCK_SKILL_PREFIXES, EXTERNAL_REF_PATTERNS;
+var TEAMMATE_RE, SKILL_LOAD_RE, SLASH_COMMAND_RE2, HAPPY_RE, SATISFIED_RE, DISSATISFIED_RE, FRUSTRATED_RE, INSTRUCTION_RE, STOCK_SUBAGENT_PREFIXES, STOCK_SKILL_PREFIXES, EXTERNAL_REF_PATTERNS;
 var init_signals = __esm({
   "../entries/dist/signals.js"() {
     "use strict";
@@ -6733,6 +6932,11 @@ var init_signals = __esm({
     TEAMMATE_RE = /^<teammate-message\b/;
     SKILL_LOAD_RE = /^Base directory for this skill:/;
     SLASH_COMMAND_RE2 = /^<command-name>|^<local-command-stdout>/;
+    HAPPY_RE = /\b(?:yay|yaay|yass|woohoo|nice|great|love(?:ly)?|perfect|amazing|awesome)\s*!|!!!/gi;
+    SATISFIED_RE = /\b(?:thanks|thank you|looks good|lgtm|works|that works|all good|sounds good)\b/gi;
+    DISSATISFIED_RE = /\b(?:that'?s (?:not|wrong)|try again|no, (?:that|this)|not quite|incorrect)\b/gi;
+    FRUSTRATED_RE = /\b(?:broken|stop|why (?:did|are|would) you|give up|ugh|argh|wtf)\b/gi;
+    INSTRUCTION_RE = /\b(?:can you|please|let's|let us|i need|could you|would you)\s+([^.?!\n]{5,200})/gi;
     STOCK_SUBAGENT_PREFIXES = /^(general-purpose|Explore|Plan|claude-code-guide|playwright-qa-verifier|statusline-setup|frontend-design:|code-review:|code-simplifier:|codex:|superpowers:)/;
     STOCK_SKILL_PREFIXES = /^(superpowers|mcp__|frontend-design|code-review|codex|claude-code-guide|claude-api):/i;
     EXTERNAL_REF_PATTERNS = [
@@ -6745,6 +6949,9 @@ var init_signals = __esm({
 });
 
 // ../entries/dist/trivial.js
+function isTrivial(n) {
+  return n.active_min < 1 && n.turn_count < 3 && n.tools_total === 0;
+}
 var init_trivial = __esm({
   "../entries/dist/trivial.js"() {
     "use strict";
@@ -6752,7 +6959,521 @@ var init_trivial = __esm({
 });
 
 // ../entries/dist/build.js
-var IDLE_GAP_MS4;
+function viewEvent(ev) {
+  let rawType;
+  if (ev.role === "user" || ev.role === "tool-result")
+    rawType = "user";
+  else if (ev.role === "agent" || ev.role === "agent-thinking" || ev.role === "tool-call")
+    rawType = "assistant";
+  else if (ev.rawType === "summary")
+    rawType = "summary";
+  else
+    rawType = "system";
+  const rawCwd = ev.raw?.cwd;
+  return {
+    rawType,
+    content: ev.blocks ?? [],
+    model: ev.model,
+    msgId: ev.messageId,
+    usage: ev.usage ? {
+      input_tokens: ev.usage.input,
+      output_tokens: ev.usage.output,
+      cache_read_input_tokens: ev.usage.cacheRead,
+      cache_creation_input_tokens: ev.usage.cacheWrite
+    } : void 0,
+    cwd: rawCwd
+  };
+}
+function parseMs(iso) {
+  if (!iso)
+    return void 0;
+  const ms = Date.parse(iso);
+  return Number.isNaN(ms) ? void 0 : ms;
+}
+function trunc(s, n) {
+  if (!s)
+    return "";
+  const one = s.replace(/\s+/g, " ").trim();
+  return one.length <= n ? one : one.slice(0, n - 1) + "\u2026";
+}
+function minimizeImages(s) {
+  if (!s)
+    return s;
+  let counter = 0;
+  return s.replace(IMAGE_BLOCK_RE, () => `[Image #${++counter}]`);
+}
+function bashVerb(cmd) {
+  if (!cmd)
+    return "?";
+  let firstSeg = cmd.split(BASH_CHAIN_SPLIT_RE, 1)[0].trim();
+  if (firstSeg.startsWith("cd ") || firstSeg === "cd") {
+    const parts = cmd.split(/&&|;/, 3);
+    if (parts.length >= 2)
+      firstSeg = parts[1].trim();
+  }
+  const tokens = firstSeg.split(/\s+/).filter(Boolean);
+  while (tokens.length && SHELL_NOISE.has(tokens[0]))
+    tokens.shift();
+  if (!tokens.length)
+    return "?";
+  let first = tokens[0];
+  if (first.includes("=") && !first.startsWith("/")) {
+    tokens.shift();
+    if (!tokens.length)
+      return "?";
+    first = tokens[0];
+  }
+  if (first.includes("/") && !first.startsWith("./")) {
+    first = first.replace(/\/+$/, "").split("/").pop();
+  }
+  return first.replace(/^["']|["']$/g, "") || "?";
+}
+function firstTextBlock(blocks) {
+  if (!Array.isArray(blocks))
+    return "";
+  for (const b of blocks) {
+    if (b && typeof b === "object" && b.type === "text") {
+      return String(b.text ?? "");
+    }
+  }
+  return "";
+}
+function blockText(blocks) {
+  if (!blocks)
+    return "";
+  return blocks.filter((b) => !!b && typeof b === "object" && b.type === "text" && typeof b.text === "string").map((b) => b.text).join(" ");
+}
+function groupEventsByLocalDay(events) {
+  const byDay = /* @__PURE__ */ new Map();
+  for (const ev of events) {
+    if (!ev.timestamp)
+      continue;
+    const ms = Date.parse(ev.timestamp);
+    if (Number.isNaN(ms))
+      continue;
+    const day2 = toLocalDay(ms);
+    let bucket = byDay.get(day2);
+    if (!bucket) {
+      bucket = [];
+      byDay.set(day2, bucket);
+    }
+    bucket.push(ev);
+  }
+  return byDay;
+}
+function newTurn(startMs, userInput = "") {
+  return {
+    startMs,
+    lastMs: startMs,
+    eventTs: startMs !== void 0 ? [startMs] : [],
+    userInput,
+    toolsTotal: 0,
+    toolMix: /* @__PURE__ */ new Map(),
+    bashVerbs: /* @__PURE__ */ new Map(),
+    skills: /* @__PURE__ */ new Map(),
+    subagents: [],
+    taskOps: 0,
+    toolErrors: 0,
+    consecSameToolMax: 0,
+    consec: 0,
+    endedInInterrupt: false,
+    models: /* @__PURE__ */ new Map(),
+    tokensIn: 0,
+    tokensOut: 0,
+    tokensCacheR: 0,
+    tokensCacheW: 0,
+    seenMsgIds: /* @__PURE__ */ new Set()
+  };
+}
+function closeTurn(t, closed, cwd) {
+  const ts = [...t.eventTs].sort((a, b) => a - b);
+  let active = 0;
+  for (let i = 1; i < ts.length; i++) {
+    const dt = ts[i] - ts[i - 1];
+    if (dt < IDLE_GAP_MS4)
+      active += dt;
+  }
+  closed.push({
+    startMs: t.startMs ?? 0,
+    activeMs: active,
+    userInput: t.userInput,
+    firstAgentText: t.firstAgentText,
+    lastAgentText: t.lastAgentText,
+    toolsTotal: t.toolsTotal,
+    toolMix: t.toolMix,
+    bashVerbs: t.bashVerbs,
+    skills: t.skills,
+    subagents: t.subagents,
+    taskOps: t.taskOps,
+    toolErrors: t.toolErrors,
+    consecSameToolMax: t.consecSameToolMax,
+    endedInInterrupt: t.endedInInterrupt,
+    models: t.models,
+    totalTokens: t.tokensIn + t.tokensOut + t.tokensCacheR + t.tokensCacheW,
+    cwd
+  });
+}
+function aggregateDay(dayEvents, _sessionFallbackProject) {
+  const prTitles = [];
+  let commits = 0;
+  let pushes = 0;
+  const gitToolUseIds = /* @__PURE__ */ new Set();
+  const githubRepos = /* @__PURE__ */ new Set();
+  const editedDirCounts = /* @__PURE__ */ new Map();
+  const modelTurns = /* @__PURE__ */ new Map();
+  let totalToolErrors = 0;
+  let totalInterrupts = 0;
+  let exitPlanCalls = 0;
+  let taskOpsTotal = 0;
+  let firstUser;
+  let finalAgent;
+  const cwdCounts = /* @__PURE__ */ new Map();
+  const closed = [];
+  let cur;
+  const allTs = [];
+  let lastEventCwd;
+  for (const ev of dayEvents) {
+    const tsMs = parseMs(ev.timestamp);
+    if (tsMs !== void 0)
+      allTs.push(tsMs);
+    const view = viewEvent(ev);
+    const rawType = view.rawType;
+    const msg = { content: view.content, id: view.msgId, model: view.model, usage: view.usage };
+    const content = view.content;
+    const eventCwd = view.cwd;
+    if (eventCwd)
+      lastEventCwd = eventCwd;
+    if (rawType === "user") {
+      const isToolResultOnly = Array.isArray(content) && content.length > 0 && content.every((c) => c && typeof c === "object" && c.type === "tool_result");
+      if (!isToolResultOnly) {
+        const text = firstTextBlock(content) || (typeof content === "string" ? content : "");
+        if (cur) {
+          if (text && INTERRUPT_RE2.test(text)) {
+            cur.endedInInterrupt = true;
+            totalInterrupts++;
+          }
+          closeTurn(cur, closed, eventCwd);
+        }
+        cur = newTurn(tsMs, text);
+        if (!firstUser && text && classifyUserInputSource(text) === "human") {
+          firstUser = text;
+        }
+      } else {
+        if (Array.isArray(content)) {
+          for (const c of content) {
+            if (!c || typeof c !== "object" || c.type !== "tool_result")
+              continue;
+            if (c.is_error) {
+              totalToolErrors++;
+              if (cur)
+                cur.toolErrors++;
+            }
+            const tuId = c.tool_use_id;
+            if (tuId && gitToolUseIds.has(tuId)) {
+              const rc = c.content;
+              const text = typeof rc === "string" ? rc : Array.isArray(rc) ? rc.map((b) => b && typeof b === "object" && typeof b.text === "string" ? b.text : "").join("\n") : "";
+              for (const m of text.matchAll(/(?<![.\w])github\.com[:/]([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+?)(?:\.git\b|[/\s"'),]|$)/g)) {
+                if (m[1].toLowerCase() === "user-attachments")
+                  continue;
+                githubRepos.add(`${m[1]}/${m[2]}`.toLowerCase());
+              }
+            }
+          }
+        }
+        if (cur && tsMs !== void 0) {
+          cur.eventTs.push(tsMs);
+          cur.lastMs = tsMs;
+        }
+      }
+    } else if (rawType === "assistant") {
+      if (cur && tsMs !== void 0) {
+        cur.eventTs.push(tsMs);
+        cur.lastMs = tsMs;
+      }
+      const model = msg.model;
+      if (model) {
+        modelTurns.set(model, (modelTurns.get(model) ?? 0) + 1);
+        if (cur)
+          cur.models.set(model, (cur.models.get(model) ?? 0) + 1);
+      }
+      const msgId = msg.id;
+      const usage2 = msg.usage;
+      if (cur && msgId && !cur.seenMsgIds.has(msgId) && usage2) {
+        cur.seenMsgIds.add(msgId);
+        cur.tokensIn += usage2.input_tokens ?? 0;
+        cur.tokensOut += usage2.output_tokens ?? 0;
+        cur.tokensCacheR += usage2.cache_read_input_tokens ?? 0;
+        cur.tokensCacheW += usage2.cache_creation_input_tokens ?? 0;
+      }
+      if (Array.isArray(content)) {
+        for (const c of content) {
+          if (!c || typeof c !== "object")
+            continue;
+          const ct = c;
+          if (ct.type === "text" && ct.text) {
+            finalAgent = ct.text;
+            if (cur) {
+              if (cur.firstAgentText === void 0)
+                cur.firstAgentText = ct.text;
+              cur.lastAgentText = ct.text;
+            }
+          } else if (ct.type === "tool_use") {
+            const name = ct.name ?? "unknown";
+            if (cur) {
+              cur.toolsTotal++;
+              cur.toolMix.set(name, (cur.toolMix.get(name) ?? 0) + 1);
+              if (name === cur.lastTool)
+                cur.consec++;
+              else {
+                cur.lastTool = name;
+                cur.consec = 1;
+              }
+              if (cur.consec > cur.consecSameToolMax)
+                cur.consecSameToolMax = cur.consec;
+              if (name === "Skill") {
+                const sk = String(ct.input?.skill ?? "unknown");
+                cur.skills.set(sk, (cur.skills.get(sk) ?? 0) + 1);
+              }
+              if (name === "Agent") {
+                const inp = ct.input ?? {};
+                cur.subagents.push({
+                  type: String(inp.subagent_type ?? "general-purpose"),
+                  description: trunc(String(inp.description ?? ""), 80),
+                  prompt_preview: trunc(String(inp.prompt ?? ""), 240),
+                  background: Boolean(inp.run_in_background)
+                });
+              }
+              if (name === "ExitPlanMode")
+                exitPlanCalls++;
+              if (name === "TodoWrite" || name === "TaskCreate" || name === "TaskUpdate") {
+                cur.taskOps++;
+                taskOpsTotal++;
+              }
+            }
+            if (name === "Bash") {
+              const cmd = String(ct.input?.command ?? "");
+              if (cur)
+                cur.bashVerbs.set(bashVerb(cmd), (cur.bashVerbs.get(bashVerb(cmd)) ?? 0) + 1);
+              if (/\bgh\s+pr\s+create\b/.test(cmd)) {
+                const m = cmd.match(PR_TITLE_RE);
+                prTitles.push(m?.[1] ?? cmd.slice(0, 120));
+              }
+              if (/\bgit\s+commit\b/.test(cmd))
+                commits++;
+              if (/\bgit\s+push\b/.test(cmd))
+                pushes++;
+              if (ct.id && /\bgit\s+push\b|\bgh\s+pr\s+/.test(cmd))
+                gitToolUseIds.add(ct.id);
+            }
+            if (eventCwd && (name === "Bash" || name === "Edit" || name === "Write" || name === "Read")) {
+              cwdCounts.set(eventCwd, (cwdCounts.get(eventCwd) ?? 0) + 1);
+            }
+            if (name === "Edit" || name === "Write" || name === "MultiEdit" || name === "NotebookEdit") {
+              const fp = String(ct.input?.file_path ?? ct.input?.notebook_path ?? "");
+              const slash = fp.lastIndexOf("/");
+              if (slash > 0) {
+                const dir = fp.slice(0, slash);
+                editedDirCounts.set(dir, (editedDirCounts.get(dir) ?? 0) + 1);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if (cur)
+    closeTurn(cur, closed, lastEventCwd);
+  const tsSorted = [...allTs].sort((a, b) => a - b);
+  let activeMs2 = 0;
+  for (let i = 1; i < tsSorted.length; i++) {
+    const dt = tsSorted[i] - tsSorted[i - 1];
+    if (dt < IDLE_GAP_MS4)
+      activeMs2 += dt;
+  }
+  const tsSortedStrings = dayEvents.map((e) => e.timestamp).filter((t) => !!t).sort();
+  const start_iso = tsSortedStrings[0] ?? "";
+  const end_iso = tsSortedStrings[tsSortedStrings.length - 1] ?? "";
+  return {
+    closed,
+    firstUser,
+    finalAgent,
+    prTitles,
+    commits,
+    pushes,
+    githubRepos: [...githubRepos].slice(0, 5),
+    editedDirs: [...editedDirCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 8).map(([dir]) => dir),
+    modelTurns,
+    totalToolErrors,
+    totalInterrupts,
+    exitPlanCalls,
+    taskOpsTotal,
+    cwdCounts,
+    start_iso,
+    end_iso,
+    activeMs: activeMs2
+  };
+}
+function buildTopTools(closed) {
+  const toolMix = /* @__PURE__ */ new Map();
+  const bashVerbsAll = /* @__PURE__ */ new Map();
+  for (const t of closed) {
+    for (const [k, v] of t.toolMix)
+      toolMix.set(k, (toolMix.get(k) ?? 0) + v);
+    for (const [k, v] of t.bashVerbs)
+      bashVerbsAll.set(k, (bashVerbsAll.get(k) ?? 0) + v);
+  }
+  const top = [...toolMix.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3);
+  return top.map(([name, count]) => {
+    if (name === "Bash" && bashVerbsAll.size > 0) {
+      const sub = [...bashVerbsAll.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([v, c]) => c > 1 ? `${v}\xD7${c}` : v).join(", ");
+      return `Bash\xD7${count} (${sub})`;
+    }
+    return count > 1 ? `${name}\xD7${count}` : name;
+  });
+}
+function buildEntries(sessionDetail) {
+  const byDay = groupEventsByLocalDay(sessionDetail.events);
+  const entries2 = [];
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const sessionFallbackProject = canonicalProjectName(sessionDetail.projectName ?? "");
+  for (const [local_day, dayEvents] of byDay) {
+    if (dayEvents.length === 0)
+      continue;
+    const agg = aggregateDay(dayEvents, sessionFallbackProject);
+    const { closed } = agg;
+    const turnCount = closed.length;
+    const toolsTotal = closed.reduce((s, t) => s + t.toolsTotal, 0);
+    const tokensTotal = closed.reduce((s, t) => s + t.totalTokens, 0);
+    const subagentCalls = closed.reduce((s, t) => s + t.subagents.length, 0);
+    const skillsMap = /* @__PURE__ */ new Map();
+    for (const t of closed) {
+      for (const [k, v] of t.skills)
+        skillsMap.set(k, (skillsMap.get(k) ?? 0) + v);
+    }
+    const skillCalls = [...skillsMap.values()].reduce((a, b) => a + b, 0);
+    const taskOps = agg.taskOpsTotal;
+    const interrupts = agg.totalInterrupts;
+    const toolErrors = agg.totalToolErrors;
+    const consecMax = Math.max(0, ...closed.map((t) => t.consecSameToolMax));
+    const exitPlanCalls = agg.exitPlanCalls;
+    const prs = agg.prTitles.length;
+    const commits = agg.commits;
+    const pushes = agg.pushes;
+    const activeMin = Math.round(agg.activeMs / 6e3) / 10;
+    const numbers = {
+      active_min: activeMin,
+      turn_count: turnCount,
+      tools_total: toolsTotal,
+      subagent_calls: subagentCalls,
+      skill_calls: skillCalls,
+      task_ops: taskOps,
+      interrupts,
+      tool_errors: toolErrors,
+      consec_same_tool_max: consecMax,
+      exit_plan_calls: exitPlanCalls,
+      prs,
+      commits,
+      pushes,
+      tokens_total: tokensTotal
+    };
+    const longestTurnActiveMs = Math.max(0, ...closed.map((t) => t.activeMs));
+    const flags = [];
+    if (interrupts >= 3)
+      flags.push("interrupt_heavy");
+    if (toolErrors >= 20)
+      flags.push("high_errors");
+    if (consecMax >= 8)
+      flags.push("loop_suspected");
+    if (agg.activeMs < 5 * 6e4 && prs >= 1)
+      flags.push("fast_ship");
+    if (exitPlanCalls > 0)
+      flags.push("plan_used");
+    const subagentTurns = closed.filter((t) => t.subagents.length >= 1).length;
+    if (subagentTurns >= 3)
+      flags.push("orchestrated");
+    if (longestTurnActiveMs >= 20 * 6e4 && interrupts === 0)
+      flags.push("long_autonomous");
+    const primaryModel = [...agg.modelTurns.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))[0]?.[0] ?? null;
+    const modelMix = Object.fromEntries(agg.modelTurns);
+    const firstUserRaw = agg.firstUser ?? "";
+    const first_user = trunc(minimizeImages(firstUserRaw), 400);
+    const finalAgentRaw = agg.finalAgent ?? "";
+    const final_agent = trunc(minimizeImages(finalAgentRaw), 400);
+    let project = sessionFallbackProject;
+    if (agg.cwdCounts.size > 0) {
+      const best = [...agg.cwdCounts.entries()].sort((a, b) => b[1] - a[1])[0];
+      project = canonicalProjectName(best[0]);
+    }
+    const top_tools = buildTopTools(closed);
+    const skills = Object.fromEntries(skillsMap);
+    const subagents = closed.flatMap((t) => t.subagents);
+    const humanText = dayEvents.filter((ev) => {
+      const v = viewEvent(ev);
+      if (v.rawType !== "user")
+        return false;
+      const content = v.content;
+      const isToolResultOnly = content.length > 0 && content.every((c) => c.type === "tool_result");
+      if (isToolResultOnly)
+        return false;
+      const text = blockText(ev.blocks) || ev.preview || "";
+      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,
+      system_instruction: 0
+    };
+    for (const ev of dayEvents) {
+      const v = viewEvent(ev);
+      if (v.rawType !== "user")
+        continue;
+      const content = v.content;
+      const isToolResultOnly = content.length > 0 && content.every((c) => c.type === "tool_result");
+      if (isToolResultOnly)
+        continue;
+      const text = blockText(ev.blocks) || ev.preview || "";
+      const src = classifyUserInputSource(text);
+      user_input_sources[src]++;
+    }
+    const pendingUserInstructions = extractUserInstructions(humanText).slice(0, 5);
+    const trivial = isTrivial(numbers);
+    const entry = {
+      version: CURRENT_ENTRY_SCHEMA_VERSION,
+      agent: sessionDetail.agent,
+      session_id: sessionDetail.id,
+      local_day,
+      project,
+      start_iso: agg.start_iso,
+      end_iso: agg.end_iso,
+      numbers,
+      flags,
+      primary_model: primaryModel,
+      model_mix: modelMix,
+      first_user,
+      final_agent,
+      pr_titles: agg.prTitles,
+      ...agg.githubRepos.length ? { github_repos: agg.githubRepos } : {},
+      ...agg.editedDirs.length ? { edited_dirs: agg.editedDirs } : {},
+      top_tools,
+      skills,
+      subagents,
+      satisfaction_signals,
+      user_input_sources,
+      enrichment: trivial ? skippedTrivialEnrichment(generatedAt) : { ...pendingEnrichment(), user_instructions: pendingUserInstructions },
+      generated_at: generatedAt,
+      source_jsonl: sessionDetail.filePath ?? "",
+      source_checkpoint: { byte_offset: 0, last_event_ts: agg.end_iso || null }
+    };
+    entry.signals = computeEntrySignals(entry);
+    entries2.push(entry);
+  }
+  entries2.sort((a, b) => a.local_day.localeCompare(b.local_day));
+  return entries2;
+}
+var IDLE_GAP_MS4, INTERRUPT_RE2, PR_TITLE_RE, BASH_CHAIN_SPLIT_RE, SHELL_NOISE, IMAGE_BLOCK_RE;
 var init_build = __esm({
   "../entries/dist/build.js"() {
     "use strict";
@@ -6761,6 +7482,11 @@ var init_build = __esm({
     init_signals();
     init_trivial();
     IDLE_GAP_MS4 = 3 * 60 * 1e3;
+    INTERRUPT_RE2 = /\[request interrupted|interrupted by user/i;
+    PR_TITLE_RE = /--title\s+["']([^"']+)["']/;
+    BASH_CHAIN_SPLIT_RE = /\|\||&&|;|\|/;
+    SHELL_NOISE = /* @__PURE__ */ new Set(["sudo", "time", "nohup", "nice", "env", "exec"]);
+    IMAGE_BLOCK_RE = /\[Image:\s*source:\s*[^\]]+\]/g;
   }
 });
 
@@ -6955,6 +7681,7 @@ __export(fs_exports2, {
   __setDigestsDirForTest: () => __setDigestsDirForTest,
   __setEntriesDirForTest: () => __setEntriesDirForTest,
   entriesDir: () => entriesDir,
+  entryExists: () => entryExists,
   getCurrentMonthDigestFromCache: () => getCurrentMonthDigestFromCache,
   getCurrentWeekDigestFromCache: () => getCurrentWeekDigestFromCache,
   getTodayDigestFromCache: () => getTodayDigestFromCache,
@@ -6991,8 +7718,8 @@ function __setEntriesDirForTest(path7) {
   entriesDirCached = path7;
   mkdirSync6(path7, { recursive: true });
 }
-function pathFor(sessionId, localDay) {
-  return join8(entriesDir(), `${entryKey(sessionId, localDay)}.json`);
+function pathFor(sessionId, localDay2) {
+  return join8(entriesDir(), `${entryKey(sessionId, localDay2)}.json`);
 }
 function tmpPathFor(final) {
   return `${final}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
@@ -7034,24 +7761,27 @@ function writeEntryPreservingEnrichment(fresh) {
   writeFileSync5(tmp, JSON.stringify(toWrite, null, 2), { encoding: "utf8" });
   renameSync2(tmp, final);
 }
-function readEntry(sessionId, localDay) {
-  const p = pathFor(sessionId, localDay);
+function readEntry(sessionId, localDay2) {
+  const p = pathFor(sessionId, localDay2);
   if (!existsSync7(p))
     return null;
   const raw = readFileSync9(p, "utf8");
   return JSON.parse(raw);
 }
+function entryExists(sessionId, localDay2) {
+  return existsSync7(pathFor(sessionId, localDay2));
+}
 function listEntryKeys() {
   const dir = entriesDir();
   if (!existsSync7(dir))
     return [];
   return readdirSync2(dir).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
 }
-function listEntriesForDay(localDay) {
+function listEntriesForDay(localDay2) {
   const out = [];
   for (const key of listEntryKeys()) {
     const parsed = parseEntryKey(key);
-    if (!parsed || parsed.local_day !== localDay)
+    if (!parsed || parsed.local_day !== localDay2)
       continue;
     const e = readEntry(parsed.session_id, parsed.local_day);
     if (e)
@@ -11220,7 +11950,7 @@ var init_zod = __esm({
 });
 
 // ../entries/dist/prompts/enrich.js
-function trunc(s, n) {
+function trunc2(s, n) {
   if (s.length <= n)
     return s;
   return s.slice(0, n - 1) + "\u2026";
@@ -11241,7 +11971,7 @@ function buildEnrichmentUserPrompt(entry, humanTurns) {
     satisfaction_signals: entry.satisfaction_signals,
     user_input_sources: entry.user_input_sources
   };
-  const turns = humanTurns.slice(0, 8).map((t, i) => `${i + 1}. ${trunc(t, 300)}`).join("\n");
+  const turns = humanTurns.slice(0, 8).map((t, i) => `${i + 1}. ${trunc2(t, 300)}`).join("\n");
   return `SLICE FACTS:
 ${JSON.stringify(facts, null, 2)}
 
@@ -12382,7 +13112,7 @@ var init_settings = __esm({
 });
 
 // ../entries/dist/prompts/digest-day.js
-function trunc2(s, n) {
+function trunc3(s, n) {
   if (s.length <= n)
     return s;
   return s.slice(0, n - 1) + "\u2026";
@@ -12393,9 +13123,9 @@ function prettyProject(p) {
 }
 function buildDigestUserPrompt(base, entries2) {
   const enriched = entries2.filter((e) => e.enrichment.status === "done");
-  const summaries = enriched.slice(0, 12).map((e) => `- (${prettyProject(e.project)}, ${Math.round(e.numbers.active_min)}m) ${trunc2(e.enrichment.brief_summary ?? "", 240)}`).join("\n");
-  const frictions = enriched.map((e) => e.enrichment.friction_detail).filter((x) => !!x).slice(0, 6).map((f, i) => `${i + 1}. ${trunc2(f, 240)}`).join("\n");
-  const instructions = enriched.flatMap((e) => e.enrichment.user_instructions).slice(0, 10).map((s, i) => `${i + 1}. ${trunc2(s, 240)}`).join("\n");
+  const summaries = enriched.slice(0, 12).map((e) => `- (${prettyProject(e.project)}, ${Math.round(e.numbers.active_min)}m) ${trunc3(e.enrichment.brief_summary ?? "", 240)}`).join("\n");
+  const frictions = enriched.map((e) => e.enrichment.friction_detail).filter((x) => !!x).slice(0, 6).map((f, i) => `${i + 1}. ${trunc3(f, 240)}`).join("\n");
+  const instructions = enriched.flatMap((e) => e.enrichment.user_instructions).slice(0, 10).map((s, i) => `${i + 1}. ${trunc3(s, 240)}`).join("\n");
   const per_entry = entries2.map((e) => ({
     agent: e.agent ?? "claude-code",
     project: prettyProject(e.project),
@@ -14425,7 +15155,7 @@ function activeMs(timestamps) {
   }
   return active;
 }
-function bashVerb(cmd) {
+function bashVerb2(cmd) {
   if (!cmd)
     return "?";
   let firstSeg = cmd.split(/\|\||&&|;|\|/, 1)[0].trim();
@@ -14435,7 +15165,7 @@ function bashVerb(cmd) {
       firstSeg = parts[1].trim();
   }
   const tokens = firstSeg.split(/\s+/).filter(Boolean);
-  while (tokens.length && SHELL_NOISE.has(tokens[0]))
+  while (tokens.length && SHELL_NOISE2.has(tokens[0]))
     tokens.shift();
   if (!tokens.length)
     return "?";
@@ -14508,7 +15238,7 @@ function eventsToTurns(events, windowStartMs, windowEndMs) {
       const isToolOnly = blocks.length > 0 && blocks.every((c) => c.type === "tool_result");
       if (!isToolOnly) {
         const text = blocks.filter((b) => b.type === "text").map((b) => b.text).join(" ");
-        const interrupted = INTERRUPT_RE2.test(text);
+        const interrupted = INTERRUPT_RE3.test(text);
         if (cur && interrupted)
           cur.interrupts += 1;
         if (cur)
@@ -14562,10 +15292,10 @@ function eventsToTurns(events, windowStartMs, windowEndMs) {
             cur.todo_ops += 1;
           } else if (name === "Bash") {
             const cmd = String(ct.input?.command ?? "");
-            const v = bashVerb(cmd);
+            const v = bashVerb2(cmd);
             cur.bash_verbs.set(v, (cur.bash_verbs.get(v) ?? 0) + 1);
             if (/\bgh\s+pr\s+create\b/.test(cmd)) {
-              const m = cmd.match(PR_TITLE_RE);
+              const m = cmd.match(PR_TITLE_RE2);
               cur.pr_created = m?.[1] ?? cmd.slice(0, 120);
             }
           }
@@ -14988,7 +15718,7 @@ async function generateTopSession(slice, opts = {}) {
     void lastModel;
   }
 }
-var IDLE_GAP_MS5, LONG_AUTONOMOUS_MIN, N_USER, N_FIRST_AGENT, N_LAST_AGENT, N_USER_TURN1, N_SUBAGENT, SHELL_NOISE, INTERRUPT_RE2, PR_TITLE_RE, PinResponseSchema, TopSessionResponseSchema, SYSTEM_PROMPT5, TOP_SESSION_SYSTEM_PROMPT, DEFAULT_MODEL5, defaultCallLLMTopSession, validateTopSession;
+var IDLE_GAP_MS5, LONG_AUTONOMOUS_MIN, N_USER, N_FIRST_AGENT, N_LAST_AGENT, N_USER_TURN1, N_SUBAGENT, SHELL_NOISE2, INTERRUPT_RE3, PR_TITLE_RE2, PinResponseSchema, TopSessionResponseSchema, SYSTEM_PROMPT5, TOP_SESSION_SYSTEM_PROMPT, DEFAULT_MODEL5, defaultCallLLMTopSession, validateTopSession;
 var init_top_sessions = __esm({
   "../entries/dist/top-sessions.js"() {
     "use strict";
@@ -15002,9 +15732,9 @@ var init_top_sessions = __esm({
     N_LAST_AGENT = 200;
     N_USER_TURN1 = 400;
     N_SUBAGENT = 240;
-    SHELL_NOISE = /* @__PURE__ */ new Set(["sudo", "time", "nohup", "nice", "env", "exec"]);
-    INTERRUPT_RE2 = /\[request interrupted|interrupted by user/i;
-    PR_TITLE_RE = /--title\s+["']([^"']+)["']/;
+    SHELL_NOISE2 = /* @__PURE__ */ new Set(["sudo", "time", "nohup", "nice", "env", "exec"]);
+    INTERRUPT_RE3 = /\[request interrupted|interrupted by user/i;
+    PR_TITLE_RE2 = /--title\s+["']([^"']+)["']/;
     PinResponseSchema = external_exports.object({
       start_min: external_exports.number(),
       end_min: external_exports.number().optional(),
@@ -15119,8 +15849,8 @@ VOCABULARY:
 });
 
 // ../entries/dist/digest-week-pipeline.js
-function mondayFor(localDay) {
-  const d = /* @__PURE__ */ new Date(`${localDay}T00:00:00`);
+function mondayFor(localDay2) {
+  const d = /* @__PURE__ */ new Date(`${localDay2}T00:00:00`);
   const dow = d.getDay();
   const offset = dow === 0 ? -6 : 1 - dow;
   d.setDate(d.getDate() + offset);
@@ -15796,8 +16526,8 @@ async function digest(args2) {
   printHelp2();
   process.exit(1);
 }
-function mondayOf(localDay) {
-  const d = /* @__PURE__ */ new Date(`${localDay}T00:00:00`);
+function mondayOf(localDay2) {
+  const d = /* @__PURE__ */ new Date(`${localDay2}T00:00:00`);
   const dow = d.getDay();
   const offset = dow === 0 ? -6 : 1 - dow;
   d.setDate(d.getDate() + offset);
@@ -16097,6 +16827,52 @@ var init_config = __esm({
   }
 });
 
+// src/perception/build-entries.ts
+import { statSync as statSync3, readFileSync as readFileSync14 } from "node:fs";
+import { basename, dirname as dirname10 } from "node:path";
+function decodeProjectDirName(projectDir) {
+  if (projectDir.startsWith("-")) {
+    return "/" + projectDir.slice(1).replace(/-/g, "/");
+  }
+  return projectDir.replace(/-/g, "/");
+}
+function buildEntriesForFile(filePath) {
+  const stat = statSync3(filePath);
+  const raw = readFileSync14(filePath, "utf8");
+  const rawLines = raw.split("\n").filter(Boolean).map((l) => {
+    try {
+      return JSON.parse(l);
+    } catch {
+      return null;
+    }
+  }).filter((x) => x !== null);
+  if (rawLines.length === 0) return null;
+  const { meta, events } = parseTranscript(rawLines);
+  const fileName = basename(filePath);
+  const projectDir = basename(dirname10(filePath));
+  const sessionId = fileName.replace(/\.jsonl$/, "");
+  const sd = {
+    ...meta,
+    id: sessionId,
+    filePath,
+    projectDir,
+    projectName: meta.cwd ?? decodeProjectDirName(projectDir),
+    events
+  };
+  const built = buildEntries(sd);
+  for (const e of built) {
+    e.source_checkpoint.byte_offset = stat.size;
+  }
+  return built;
+}
+var init_build_entries = __esm({
+  "src/perception/build-entries.ts"() {
+    "use strict";
+    init_dist();
+    init_dist2();
+  }
+});
+
 // src/team/push.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 function readLatestUsageSnapshotForWire(filePath, nowMs = Date.now()) {
@@ -16164,7 +16940,7 @@ function sessionTouchesDay(s, day2) {
   }
   return sessionDay(s) === day2;
 }
-function buildRichRollupBlocks(day2, daySessions, entries2, privateProjects, resolveRepo) {
+function buildRichRollupBlocks(day2, daySessions, entries2, resolveRepo) {
   const bounds = dayBoundsMs(day2);
   const clippedSessions = [];
   for (const s of daySessions) {
@@ -16190,7 +16966,6 @@ function buildRichRollupBlocks(day2, daySessions, entries2, privateProjects, res
   };
   const sessionRepo = /* @__PURE__ */ new Map();
   for (const e of entries2) {
-    if (privateProjects.has(projectRepoName(e.project)) || privateProjects.has(e.project)) continue;
     const r = repoForEntry(e);
     if (r) sessionRepo.set(e.session_id, r);
   }
@@ -16198,7 +16973,6 @@ function buildRichRollupBlocks(day2, daySessions, entries2, privateProjects, res
   for (const s of clippedSessions) {
     const canonical = canonicalProjectName(s.projectName);
     const name = projectRepoName(s.projectName);
-    if (privateProjects.has(name) || privateProjects.has(canonical)) continue;
     const repo = resolveRepo?.(canonical) ?? sessionRepo.get(s.id);
     const key = repo ?? name;
     const ms = s.activeSegments.reduce((sum, seg) => sum + (seg.endMs - seg.startMs), 0);
@@ -16221,7 +16995,6 @@ function buildRichRollupBlocks(day2, daySessions, entries2, privateProjects, res
   let longTotalMin = 0;
   let longMaxSingleMin = 0;
   for (const e of entries2) {
-    if (privateProjects.has(projectRepoName(e.project)) || privateProjects.has(e.project)) continue;
     const shape = e.signals?.working_shape ?? null;
     if (shape) {
       const cur = workingShapes.get(shape) ?? { sessions: 0, agentTimeMs: 0 };
@@ -16297,19 +17070,35 @@ function buildEnrichedExtras(entries2) {
   }
   return { outcomeMix, helpfulnessMix, goalMix };
 }
-function buildRichBlocksForDay(day2, daySessions, privateProjects, enrichmentOptIn, resolveRepo) {
+function resetEnsuredSessions() {
+  ensuredSessions.clear();
+}
+function ensureEntriesForDay(day2, daySessions) {
+  for (const s of daySessions) {
+    if (ensuredSessions.has(s.id)) continue;
+    if ((s.agent ?? "claude-code") !== "claude-code") continue;
+    if (entryExists(s.id, day2)) continue;
+    ensuredSessions.add(s.id);
+    try {
+      for (const e of buildEntriesForFile(s.filePath) ?? []) writeEntryPreservingEnrichment(e);
+    } catch {
+    }
+  }
+}
+function buildRichBlocksForDay(day2, daySessions, resolveRepo) {
+  ensureEntriesForDay(day2, daySessions);
   const entries2 = listEntriesForDay(day2);
   if (entries2.length === 0) return void 0;
-  const rich = buildRichRollupBlocks(day2, daySessions, entries2, privateProjects, resolveRepo);
-  const enriched = enrichmentOptIn ? buildEnrichedExtras(entries2) : void 0;
-  return enriched ? { rich, enriched } : { rich };
+  const rich = buildRichRollupBlocks(day2, daySessions, entries2, resolveRepo);
+  const enriched = buildEnrichedExtras(entries2);
+  return { rich, enriched };
 }
 function buildIngestPayload(inputs) {
   const richRollup = inputs.rollup && inputs.richExtras ? { ...inputs.rollup, ...inputs.richExtras } : void 0;
   return {
     ingestId: randomUUID2(),
     observedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    cliVersion: "0.13.2",
+    cliVersion: "0.14.0",
     ...richRollup || inputs.enrichedExtras || inputs.artifactSignals ? { schemaVersion: RICH_ROLLUP_SCHEMA_VERSION } : {},
     ...inputs.rollup ? { dailyRollup: inputs.rollup } : {},
     ...richRollup ? { richRollup } : {},
@@ -16317,7 +17106,8 @@ function buildIngestPayload(inputs) {
     ...inputs.artifactSignals ? { artifactSignals: inputs.artifactSignals } : {},
     ...inputs.usageSnapshot ? { usageSnapshot: inputs.usageSnapshot } : {},
     ...inputs.planTier ? { planTier: inputs.planTier } : {},
-    ...inputs.cyclePeaks ? { cyclePeaks: inputs.cyclePeaks } : {}
+    ...inputs.cyclePeaks ? { cyclePeaks: inputs.cyclePeaks } : {},
+    ...inputs.syncLog && inputs.syncLog.length ? { syncLog: inputs.syncLog } : {}
   };
 }
 async function pushToTeamServer(config, payload) {
@@ -16333,22 +17123,24 @@ async function pushToTeamServer(config, payload) {
   const body = await res.json().catch(() => null);
   return { ok: res.ok, status: res.status, body };
 }
-var SNAPSHOT_FRESHNESS_MS, POST_TIMEOUT_MS;
+var SNAPSHOT_FRESHNESS_MS, POST_TIMEOUT_MS, ensuredSessions;
 var init_push = __esm({
   "src/team/push.ts"() {
     "use strict";
     init_dist();
     init_fs();
     init_fs2();
+    init_build_entries();
     init_storage();
     SNAPSHOT_FRESHNESS_MS = 10 * 60 * 1e3;
     POST_TIMEOUT_MS = 15e3;
+    ensuredSessions = /* @__PURE__ */ new Set();
   }
 });
 
 // src/team/git-remote.ts
-import { existsSync as existsSync13, readFileSync as readFileSync14, statSync as statSync3 } from "node:fs";
-import { dirname as dirname10, isAbsolute, join as join11, resolve } from "node:path";
+import { existsSync as existsSync13, readFileSync as readFileSync15, statSync as statSync4 } from "node:fs";
+import { dirname as dirname11, isAbsolute, join as join11, resolve } from "node:path";
 function parseGithubRemote(url) {
   const m = url.trim().match(GITHUB_URL_RE);
   return m ? `${m[1]}/${m[2]}`.toLowerCase() : null;
@@ -16369,15 +17161,15 @@ function originUrl(configText) {
 }
 function gitConfigPathFor(dir) {
   const dotGit = join11(dir, ".git");
-  const st = statSync3(dotGit, { throwIfNoEntry: false });
+  const st = statSync4(dotGit, { throwIfNoEntry: false });
   if (!st) return null;
   if (st.isDirectory()) return join11(dotGit, "config");
-  const m = readFileSync14(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
+  const m = readFileSync15(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
   if (!m) return null;
   const gd = isAbsolute(m[1]) ? m[1] : resolve(dir, m[1]);
   const commondirFile = join11(gd, "commondir");
   if (existsSync13(commondirFile)) {
-    const common = readFileSync14(commondirFile, "utf8").trim();
+    const common = readFileSync15(commondirFile, "utf8").trim();
     return join11(isAbsolute(common) ? common : resolve(gd, common), "config");
   }
   return join11(gd, "config");
@@ -16390,14 +17182,14 @@ function createRepoResolver() {
     if (hit !== void 0) return hit;
     let repo = null;
     try {
-      for (let d = dir; ; d = dirname10(d)) {
+      for (let d = dir; ; d = dirname11(d)) {
         const config = gitConfigPathFor(d);
         if (config && existsSync13(config)) {
-          const url = originUrl(readFileSync14(config, "utf8"));
+          const url = originUrl(readFileSync15(config, "utf8"));
           repo = url ? parseGithubRemote(url) : null;
           break;
         }
-        if (d === dirname10(d)) break;
+        if (d === dirname11(d)) break;
       }
     } catch {
       repo = null;
@@ -16415,14 +17207,14 @@ var init_git_remote = __esm({
 });
 
 // src/team/queue.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync10, appendFileSync as appendFileSync4, statSync as statSync4, mkdirSync as mkdirSync11 } from "node:fs";
-import { dirname as dirname11 } from "node:path";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync10, appendFileSync as appendFileSync4, statSync as statSync5, mkdirSync as mkdirSync11 } from "node:fs";
+import { dirname as dirname12 } from "node:path";
 function enqueuePayload(payload, queuePath = QUEUE_PATH) {
-  mkdirSync11(dirname11(queuePath), { recursive: true });
+  mkdirSync11(dirname12(queuePath), { recursive: true });
   const entry = { payload, enqueuedAt: (/* @__PURE__ */ new Date()).toISOString() };
   appendFileSync4(queuePath, JSON.stringify(entry) + "\n", "utf8");
   try {
-    const { size } = statSync4(queuePath);
+    const { size } = statSync5(queuePath);
     if (size > MAX_SIZE_BYTES) {
       pruneOldest(queuePath);
     }
@@ -16432,7 +17224,7 @@ function enqueuePayload(payload, queuePath = QUEUE_PATH) {
 function dequeuePayloads(queuePath = QUEUE_PATH) {
   let lines;
   try {
-    lines = readFileSync15(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync16(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return [];
   }
@@ -16453,7 +17245,7 @@ function dequeuePayloads(queuePath = QUEUE_PATH) {
 function pruneOldest(queuePath) {
   let lines;
   try {
-    lines = readFileSync15(queuePath, "utf8").trim().split("\n").filter(Boolean);
+    lines = readFileSync16(queuePath, "utf8").trim().split("\n").filter(Boolean);
   } catch {
     return;
   }
@@ -16472,8 +17264,8 @@ var init_queue2 = __esm({
 });
 
 // src/usage/profile.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync12, readFileSync as readFileSync16, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname12 } from "node:path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync12, readFileSync as readFileSync17, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname13 } from "node:path";
 function mapRateLimitTier(rateLimitTier) {
   switch (rateLimitTier) {
     case "default_claude_pro":
@@ -16515,7 +17307,7 @@ async function fetchProfile(nowMs = Date.now()) {
 function readCachedProfile(cachePath) {
   if (!existsSync14(cachePath)) return null;
   try {
-    const raw = JSON.parse(readFileSync16(cachePath, "utf8"));
+    const raw = JSON.parse(readFileSync17(cachePath, "utf8"));
     if (typeof raw.fetchedAtMs !== "number" || !raw.profile) return null;
     return raw;
   } catch {
@@ -16523,7 +17315,7 @@ function readCachedProfile(cachePath) {
   }
 }
 function writeCachedProfile(cachePath, profile, nowMs = Date.now()) {
-  mkdirSync12(dirname12(cachePath), { recursive: true });
+  mkdirSync12(dirname13(cachePath), { recursive: true });
   writeFileSync11(
     cachePath,
     JSON.stringify({ fetchedAtMs: nowMs, profile }, null, 2),
@@ -16703,6 +17495,38 @@ var init_backfill = __esm({
   }
 });
 
+// src/team/sync-log.ts
+import { readFileSync as readFileSync18 } from "node:fs";
+function readPendingSyncLog(watermark) {
+  let raw;
+  try {
+    raw = readFileSync18(cclensPath("daemon.log"), "utf8");
+  } catch {
+    return { lines: [] };
+  }
+  const lines = [];
+  for (const line of raw.split("\n")) {
+    const m = line.match(/^(\S+) (INFO|WARN|ERROR) (.*)$/);
+    if (!m) continue;
+    const [, ts, levelRaw, msg] = m;
+    if (!msg.startsWith("[sync] ")) continue;
+    if (watermark && ts <= watermark) continue;
+    const clipped = msg.length > MAX_MSG_CHARS ? msg.slice(0, MAX_MSG_CHARS) + "\u2026" : msg;
+    lines.push({ ts, level: levelRaw.toLowerCase(), msg: clipped });
+  }
+  const capped = lines.slice(0, MAX_LINES);
+  return { lines: capped, watermark: capped.length ? capped[capped.length - 1].ts : void 0 };
+}
+var MAX_LINES, MAX_MSG_CHARS;
+var init_sync_log = __esm({
+  "src/team/sync-log.ts"() {
+    "use strict";
+    init_fs();
+    MAX_LINES = 300;
+    MAX_MSG_CHARS = 1900;
+  }
+});
+
 // src/team/last-push.ts
 import { writeFileSync as writeFileSync12, unlinkSync as unlinkSync5, mkdirSync as mkdirSync13 } from "node:fs";
 import { join as join12 } from "node:path";
@@ -16740,7 +17564,7 @@ __export(file_probe_exports, {
   probeArtifactSignals: () => probeArtifactSignals
 });
 import { createHash } from "node:crypto";
-import { existsSync as existsSync15, readdirSync as readdirSync4, statSync as statSync5 } from "node:fs";
+import { existsSync as existsSync15, readdirSync as readdirSync4, statSync as statSync6 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 import { join as join13, relative, resolve as resolve2, sep } from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
@@ -16771,7 +17595,7 @@ function listMarkdownFiles(dir) {
     const full = join13(dir, name);
     let stat;
     try {
-      stat = statSync5(full);
+      stat = statSync6(full);
     } catch {
       continue;
     }
@@ -16788,19 +17612,19 @@ function firstSeenDateOf(file) {
     const out = execFileSync2(
       "git",
       ["log", "--diff-filter=A", "--follow", "--format=%cs", "--", file],
-      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname13(file) }
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname14(file) }
     ).trim().split("\n").filter(Boolean);
     if (out.length > 0) return out[out.length - 1];
   } catch {
   }
   try {
-    const s = statSync5(file);
-    return new Date((s.birthtime || s.mtime).getTime()).toISOString().slice(0, 10);
+    const s = statSync6(file);
+    return localDay(s.birthtime || s.mtime);
   } catch {
-    return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    return todayLocal();
   }
 }
-function dirname13(p) {
+function dirname14(p) {
   const i = p.lastIndexOf(sep);
   return i < 0 ? "." : p.slice(0, i);
 }
@@ -16815,13 +17639,15 @@ function detectGitEmail(cwd) {
     return null;
   }
 }
-function todayLocal() {
-  const d = /* @__PURE__ */ new Date();
+function localDay(d) {
   const y = d.getFullYear();
   const m = String(d.getMonth() + 1).padStart(2, "0");
   const day2 = String(d.getDate()).padStart(2, "0");
   return `${y}-${m}-${day2}`;
 }
+function todayLocal() {
+  return localDay(/* @__PURE__ */ new Date());
+}
 function scanAuthored(roots, subdir, day2) {
   const out = [];
   for (const r of roots) {
@@ -16846,11 +17672,11 @@ function scanEdited(roots, day2) {
       if (firstSeen === day2) continue;
       let stat;
       try {
-        stat = statSync5(f);
+        stat = statSync6(f);
       } catch {
         continue;
       }
-      const mtimeDay = new Date(stat.mtime.getTime()).toISOString().slice(0, 10);
+      const mtimeDay = localDay(stat.mtime);
       if (mtimeDay !== day2) continue;
       const rel = relative(dir, f);
       out.push({ pathHash: pathHash(`${r.label}:skills:${rel}`), lineDelta: 0 });
@@ -16872,7 +17698,7 @@ function claudemdLineDelta(extraRoots, authorEmail, day2) {
       const out = execFileSync2(
         "git",
         ["log", "--numstat", "--format=COMMIT %cs %ae", "--", file],
-        { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname13(file) }
+        { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], cwd: dirname14(file) }
       );
       let currentDate = "";
       let currentEmail = "";
@@ -16964,13 +17790,11 @@ async function runActivityBackfill(command2, config, log) {
       summary: { pushed: 0, fromDay: targetDay }
     };
   }
-  const privateProjects = new Set(config.privateProjects ?? []);
-  const enrichmentOptIn = !!config.enrichmentOptIn;
   const resolveRepo = createRepoResolver();
   let pushed = 0;
   for (const rollup of rollups) {
     const daySessions = sessions.filter((s) => sessionTouchesDay(s, rollup.day));
-    const richBlocks = buildRichBlocksForDay(rollup.day, daySessions, privateProjects, enrichmentOptIn, resolveRepo);
+    const richBlocks = buildRichBlocksForDay(rollup.day, daySessions, resolveRepo);
     let artifactSignals = null;
     try {
       artifactSignals = probeArtifactSignals2({ day: rollup.day, extraRoots: [process.cwd()] });
@@ -17012,13 +17836,95 @@ var init_commands = __esm({
 // src/team/sync.ts
 var sync_exports = {};
 __export(sync_exports, {
+  buildSyncLine: () => buildSyncLine,
   runTeamSync: () => runTeamSync
 });
 import { randomUUID as randomUUID4 } from "node:crypto";
+function syncLogDelivered(body) {
+  const blocks = body?.blocks;
+  return !blocks || blocks.accepted.includes("syncLog");
+}
+function levelForStatus(s) {
+  if (s === "ok" || s === "idle") return "info";
+  if (s === "degraded" || s === "failed") return "warn";
+  return "error";
+}
+function fmtDuration(ms) {
+  return ms >= 1e3 ? `${(ms / 1e3).toFixed(1)}s` : `${ms}ms`;
+}
+function liveSnapshotStr(snap) {
+  if (!snap) return void 0;
+  const f = snap.fiveHour?.utilization;
+  const s = snap.sevenDay?.utilization;
+  const parts = [
+    typeof f === "number" ? `5h ${Math.round(f)}%` : null,
+    typeof s === "number" ? `7d ${Math.round(s)}%` : null
+  ].filter(Boolean);
+  return parts.length ? parts.join(" / ") : void 0;
+}
+function buildSyncLine(status2, trigger, s, elapsedMs, nextSyncMs) {
+  const parts = [`[sync] ${status2}`, trigger];
+  if (s.pushedDays.length) {
+    parts.push(
+      s.pushedDays.length === 1 ? `pushed 1 day (${s.pushedDays[0]})` : `pushed ${s.pushedDays.length} days (${s.pushedDays[0]}\u2192${s.pushedDays[s.pushedDays.length - 1]})`
+    );
+  }
+  if (s.queued) {
+    parts.push(
+      s.queuedDay ? `queued ${s.queued} for retry (${s.queuedDay}, HTTP ${s.queuedStatus})` : `queued ${s.queued} for retry`
+    );
+  }
+  if (s.droppedDays.length) {
+    parts.push(`dropped ${s.droppedDays.length} unrecoverable (${s.droppedDays.join(",")})`);
+  }
+  if (s.recoveredDays?.length) {
+    parts.push(
+      `recovered ${s.recoveredDays.length} dropped day${s.recoveredDays.length === 1 ? "" : "s"} (${s.recoveredDays.join(",")})`
+    );
+  }
+  if (s.queuedDrained) parts.push(`drained ${s.queuedDrained} from backlog`);
+  if (s.idleReason) parts.push(s.idleReason);
+  if (s.live) parts.push(`live ${s.live}`);
+  if (s.usageSnapshots > 0) {
+    parts.push(`usage +${s.usageSnapshots} snapshot${s.usageSnapshots === 1 ? "" : "s"}`);
+  }
+  if (s.accepted?.length) parts.push(`server accepted ${s.accepted.join(",")}`);
+  if (s.skipped && Object.keys(s.skipped).length) {
+    parts.push(
+      `server SKIPPED ${Object.entries(s.skipped).map(([k, v]) => `${k} (${v})`).join("; ")}`
+    );
+  }
+  if (s.errorMsg) parts.push(s.errorMsg);
+  parts.push(fmtDuration(elapsedMs));
+  if (nextSyncMs) parts.push(`next ~${Math.round(nextSyncMs / 6e4)}m`);
+  return parts.join(" \xB7 ");
+}
 async function runTeamSync(log = noopLog2, configOverride, options = {}) {
   const config = configOverride === void 0 ? readTeamConfig() : configOverride;
   if (!config) return { paired: false, pushed: 0, queued: 0, queuedDrained: 0 };
+  const startedAt = Date.now();
+  const trigger = options.trigger ?? "auto";
+  const summary = {
+    pushedDays: [],
+    droppedDays: [],
+    queued: 0,
+    queuedDrained: 0,
+    usageSnapshots: 0
+  };
+  const finish = (status2) => {
+    log(
+      levelForStatus(status2),
+      buildSyncLine(status2, trigger, summary, Date.now() - startedAt, options.nextSyncMs)
+    );
+  };
+  const recordVerdict = (body) => {
+    if (body?.blocks) {
+      summary.accepted = [.../* @__PURE__ */ new Set([...summary.accepted ?? [], ...body.blocks.accepted])];
+      summary.skipped = { ...summary.skipped, ...body.blocks.skipped };
+    }
+  };
   try {
+    resetEnsuredSessions();
     const { listSessions: listSessions2, loadCalibrationCurve: loadCalibrationCurve2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
     const { toLocalDay: toLocalDay4 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
     const today = toLocalDay4(Date.now());
@@ -17027,6 +17933,7 @@ async function runTeamSync(log = noopLog2, configOverride, options = {}) {
       nextConfig = { ...nextConfig, ...patch };
       writeTeamConfig(nextConfig);
     };
+    const pendingLog = readPendingSyncLog(config.lastSyncedLogAt);
     const collectedCommands = /* @__PURE__ */ new Map();
     const collectCommands = (commands) => {
       if (!commands) return;
@@ -17064,6 +17971,25 @@ async function runTeamSync(log = noopLog2, configOverride, options = {}) {
         log("warn", `team command dispatch error: ${err.message}`);
       }
     };
+    const isValidationPoison = (status3) => status3 === 400 || status3 === 422;
+    const drainBacklog = async () => {
+      let drained = 0;
+      const backlog = dequeuePayloads();
+      for (let i = 0; i < backlog.length; i++) {
+        const qResult = await pushToTeamServer(config, backlog[i]);
+        if (!qResult.ok) {
+          if (isValidationPoison(qResult.status)) {
+            log("warn", `team push: queued payload rejected (HTTP ${qResult.status}); dropping unrecoverable item`);
+            continue;
+          }
+          for (const remaining of backlog.slice(i)) enqueuePayload(remaining);
+          break;
+        }
+        collectCommands(qResult.body?.commands);
+        drained++;
+      }
+      return drained;
+    };
     const usageBackfill = await runTeamBackfill(log, USAGE_LOG4, config, {
       sinceCapturedAt: options.forceUsageBackfill ? void 0 : config.lastSyncedUsageSnapshotAt
     });
@@ -17071,121 +17997,167 @@ async function runTeamSync(log = noopLog2, configOverride, options = {}) {
       persistConfig({ lastSyncedUsageSnapshotAt: usageBackfill.lastSnapshotAt });
     }
     const sessions = await listSessions2({ limit: 1e4 });
-    const rollups = buildRollupsForRange(sessions, config.lastSyncedDay);
+    const allRollups = buildRollupsForRange(sessions);
+    const rollups = allRollups.filter((r) => !config.lastSyncedDay || r.day >= config.lastSyncedDay);
     const usageSnapshot = readLatestUsageSnapshotForWire(USAGE_LOG4) ?? void 0;
     const planTier = await getPlanTier(PROFILE_CACHE2).catch(() => null) ?? void 0;
     const cyclePeaks = await buildCyclePeaksForPush(planTier, loadCalibrationCurve2);
     if (rollups.length === 0) {
       const hasLiveData = Boolean(usageSnapshot || planTier || cyclePeaks);
       if (!hasLiveData) {
-        if (usageBackfill.sentSnapshots === 0) log("info", "team push: nothing to sync");
+        summary.usageSnapshots = usageBackfill.sentSnapshots;
+        if (usageBackfill.sentSnapshots > 0) {
+          finish("ok");
+        } else {
+          summary.idleReason = "nothing to sync";
+          finish("idle");
+        }
         return { paired: true, pushed: 0, queued: 0, queuedDrained: 0, usageBackfill };
       }
-      const payload = buildIngestPayload({ usageSnapshot, planTier, cyclePeaks });
+      summary.usageSnapshots = usageBackfill.sentSnapshots;
+      summary.live = liveSnapshotStr(usageSnapshot);
+      const payload = buildIngestPayload({ usageSnapshot, planTier, cyclePeaks, syncLog: pendingLog.lines });
       const result = await pushToTeamServer(config, payload);
       if (!result.ok) {
+        if (isValidationPoison(result.status)) {
+          const errLine2 = `team push: live-only payload rejected (HTTP ${result.status}); dropping unrecoverable payload`;
+          writeLastPushFailure(payload, errLine2);
+          summary.errorMsg = `live-snapshot push HTTP ${result.status} (validation) \u2014 dropped unrecoverable`;
+          finish("error");
+          return { paired: true, pushed: 0, queued: 0, queuedDrained: 0, usageBackfill };
+        }
         const errLine = `team push failed (${result.status})`;
-        log("warn", `${errLine}; queueing`);
         writeLastPushFailure(payload, errLine);
         enqueuePayload(payload);
+        summary.queued = 1;
+        summary.errorMsg = `live-snapshot push HTTP ${result.status} \u2014 queued for retry`;
+        finish("failed");
         return { paired: true, pushed: 0, queued: 1, queuedDrained: 0, usageBackfill };
       }
       writeLastPushSuccess(payload);
-      collectCommands(result.body?.commands);
-      let queuedDrained2 = 0;
-      const backlog = dequeuePayloads();
-      for (let i = 0; i < backlog.length; i++) {
-        const qResult = await pushToTeamServer(config, backlog[i]);
-        if (!qResult.ok) {
-          for (const remaining of backlog.slice(i)) enqueuePayload(remaining);
-          break;
-        }
-        collectCommands(qResult.body?.commands);
-        queuedDrained2++;
+      if (pendingLog.watermark && syncLogDelivered(result.body)) {
+        persistConfig({ lastSyncedLogAt: pendingLog.watermark });
       }
-      log("info", `team push ok: live-only (no new daily activity)` + (queuedDrained2 ? `, ${queuedDrained2} queued retried` : ""));
+      collectCommands(result.body?.commands);
+      recordVerdict(result.body);
+      const queuedDrained2 = await drainBacklog();
+      summary.queuedDrained = queuedDrained2;
+      summary.idleReason = "no new daily activity";
+      finish(summary.skipped && Object.keys(summary.skipped).length ? "degraded" : "idle");
       await dispatchAndReport();
       return { paired: true, pushed: 1, queued: 0, queuedDrained: queuedDrained2, usageBackfill };
     }
     let pushed = 0;
     let queued = 0;
     let failedDay;
-    let lastPushedDay;
-    const privateProjects = new Set(config.privateProjects ?? []);
-    const enrichmentOptIn = !!config.enrichmentOptIn;
+    let lastResolvedDay;
+    const droppedDaysBefore = config.droppedDays ?? [];
+    const workingDropped = [...droppedDaysBefore];
+    let syncLogWasDelivered = false;
     const resolveRepo = createRepoResolver();
     const { probeArtifactSignals: probeArtifactSignals2 } = await Promise.resolve().then(() => (init_file_probe(), file_probe_exports));
-    for (let i = 0; i < rollups.length; i++) {
-      const rollup = rollups[i];
-      const isLatest = i === rollups.length - 1;
+    const buildDayPayload = (rollup, opts) => {
       const daySessions = sessions.filter((s) => sessionTouchesDay(s, rollup.day));
-      const richBlocks = buildRichBlocksForDay(
-        rollup.day,
-        daySessions,
-        privateProjects,
-        enrichmentOptIn,
-        resolveRepo
-      );
+      const richBlocks = buildRichBlocksForDay(rollup.day, daySessions, resolveRepo);
       let artifactSignals = null;
       try {
-        artifactSignals = probeArtifactSignals2({
-          day: rollup.day,
-          extraRoots: [process.cwd()]
-        });
+        artifactSignals = probeArtifactSignals2({ day: rollup.day, extraRoots: [process.cwd()] });
       } catch {
       }
-      const payload = buildIngestPayload({
+      return buildIngestPayload({
         rollup,
         richExtras: richBlocks?.rich,
         enrichedExtras: richBlocks?.enriched,
         artifactSignals: artifactSignals ?? void 0,
-        usageSnapshot: isLatest ? usageSnapshot : void 0,
+        // Current-cycle data only on the latest day so older days aren't tagged
+        // with today's snapshot / peaks.
+        usageSnapshot: opts.latest ? usageSnapshot : void 0,
         planTier,
-        // Same rationale as usageSnapshot — current cycle data only on the
-        // latest rollup so older days don't get tagged with today's peaks.
-        cyclePeaks: isLatest ? cyclePeaks : void 0
+        cyclePeaks: opts.latest ? cyclePeaks : void 0,
+        syncLog: opts.syncLog
+      });
+    };
+    for (let i = 0; i < rollups.length; i++) {
+      const rollup = rollups[i];
+      const isLatest = i === rollups.length - 1;
+      const payload = buildDayPayload(rollup, {
+        latest: isLatest,
+        syncLog: i === 0 ? pendingLog.lines : void 0
       });
       const result = await pushToTeamServer(config, payload);
       if (!result.ok) {
+        if (isValidationPoison(result.status)) {
+          const errLine2 = `team push: ${rollup.day} rejected (HTTP ${result.status}); skipping past unrecoverable day`;
+          writeLastPushFailure(payload, errLine2);
+          summary.droppedDays.push(rollup.day);
+          if (!workingDropped.includes(rollup.day)) workingDropped.push(rollup.day);
+          lastResolvedDay = rollup.day;
+          continue;
+        }
         const errLine = `team push failed on ${rollup.day} (${result.status})`;
-        log("warn", `${errLine}; queueing`);
         writeLastPushFailure(payload, errLine);
         enqueuePayload(payload);
         queued++;
+        summary.queuedDay = rollup.day;
+        summary.queuedStatus = result.status;
         failedDay = rollup.day;
         break;
       }
       writeLastPushSuccess(payload);
       collectCommands(result.body?.commands);
+      recordVerdict(result.body);
+      if (i === 0) syncLogWasDelivered = syncLogDelivered(result.body);
       pushed++;
-      lastPushedDay = rollup.day;
+      summary.pushedDays.push(rollup.day);
+      lastResolvedDay = rollup.day;
     }
-    if (failedDay) {
-      if (lastPushedDay) persistConfig({ lastSyncedDay: lastPushedDay });
-    } else {
-      persistConfig({ lastSyncedDay: today });
-    }
-    let queuedDrained = 0;
     if (!failedDay) {
-      const backlog = dequeuePayloads();
-      for (let i = 0; i < backlog.length; i++) {
-        const qResult = await pushToTeamServer(config, backlog[i]);
-        if (!qResult.ok) {
-          for (const remaining of backlog.slice(i)) enqueuePayload(remaining);
-          break;
+      const retryDay = [...droppedDaysBefore].sort().find((d) => !summary.droppedDays.includes(d));
+      const retryRollup = retryDay ? allRollups.find((r) => r.day === retryDay) : void 0;
+      if (retryDay && retryRollup) {
+        const payload = buildDayPayload(retryRollup, { latest: false });
+        const result = await pushToTeamServer(config, payload);
+        if (result.ok) {
+          writeLastPushSuccess(payload);
+          collectCommands(result.body?.commands);
+          recordVerdict(result.body);
+          const idx = workingDropped.indexOf(retryDay);
+          if (idx >= 0) workingDropped.splice(idx, 1);
+          summary.recoveredDays = [retryDay];
+        } else {
+          writeLastPushFailure(payload, `team push: dropped-day retry ${retryDay} failed (HTTP ${result.status})`);
         }
-        collectCommands(qResult.body?.commands);
-        queuedDrained++;
       }
     }
-    if (pushed > 0) {
-      log("info", `team push ok: ${pushed} day${pushed === 1 ? "" : "s"} pushed` + (queuedDrained ? `, ${queuedDrained} queued retried` : "") + (queued ? `, ${queued} queued for retry` : ""));
-    }
+    const nextDropped = [...new Set(workingDropped)].sort().slice(-90);
+    const prevDropped = [...new Set(droppedDaysBefore)].sort();
+    const droppedChanged = nextDropped.length !== prevDropped.length || nextDropped.some((d, i) => d !== prevDropped[i]);
+    const droppedPatch = droppedChanged ? { droppedDays: nextDropped } : {};
+    if (failedDay) {
+      if (lastResolvedDay || droppedChanged) {
+        persistConfig({ ...lastResolvedDay ? { lastSyncedDay: lastResolvedDay } : {}, ...droppedPatch });
+      }
+    } else {
+      persistConfig({ lastSyncedDay: today, ...droppedPatch });
+    }
+    if (syncLogWasDelivered && pendingLog.watermark) {
+      persistConfig({ lastSyncedLogAt: pendingLog.watermark });
+    }
+    const queuedDrained = !failedDay ? await drainBacklog() : 0;
+    summary.queued = queued;
+    summary.queuedDrained = queuedDrained;
+    summary.usageSnapshots = usageBackfill.sentSnapshots;
+    let status2;
+    if (failedDay) status2 = "failed";
+    else if (summary.droppedDays.length || summary.skipped && Object.keys(summary.skipped).length) status2 = "degraded";
+    else status2 = "ok";
+    finish(status2);
     await dispatchAndReport();
     return { paired: true, pushed, queued, queuedDrained, usageBackfill, failedDay };
   } catch (err) {
     const message = err.message;
-    log("warn", `team push error: ${message}`);
+    summary.errorMsg = `sync aborted: ${message}`;
+    finish("error");
     writeLastPushFailure(
       { ingestId: "n/a", observedAt: (/* @__PURE__ */ new Date()).toISOString() },
       `team push error: ${message}`
@@ -17249,8 +18221,13 @@ async function buildCyclePeaksForPush(planTier, loadCurve) {
     return out.slice(-maxCycles);
   };
   return {
+    // 7d cycle history cap (26 ≈ six months) MUST stay in lock-step with two
+    // downstream sites or the strip silently truncates: the server read
+    // (loadMembership7dCyclePeaks maxCyclesPerMember in plan-queries.ts) and
+    // the renderer (CyclePeaksStrip maxBars in member-plan-block.tsx). The 5h
+    // cap (24) is independent — leave it.
     fiveHour: peaksFor("cycle_end_5h", "real_5h", "pred_5h", 24),
-    sevenDay: peaksFor("cycle_end_7d", "real_7d", "pred_7d", 12)
+    sevenDay: peaksFor("cycle_end_7d", "real_7d", "pred_7d", 26)
   };
 }
 var inFlightCommands, USAGE_LOG4, PROFILE_CACHE2, noopLog2;
@@ -17262,6 +18239,7 @@ var init_sync = __esm({
     init_git_remote();
     init_queue2();
     init_backfill();
+    init_sync_log();
     init_last_push();
     init_commands();
     init_profile();
@@ -17274,6 +18252,30 @@ var init_sync = __esm({
   }
 });
 
+// src/daemon-log.ts
+var daemon_log_exports = {};
+__export(daemon_log_exports, {
+  appendDaemonLogLine: () => appendDaemonLogLine
+});
+import { appendFileSync as appendFileSync5 } from "node:fs";
+function appendDaemonLogLine(level, msg) {
+  try {
+    appendFileSync5(
+      cclensPath("daemon.log"),
+      `${(/* @__PURE__ */ new Date()).toISOString()} ${level.toUpperCase()} ${msg}
+`,
+      "utf8"
+    );
+  } catch {
+  }
+}
+var init_daemon_log = __esm({
+  "src/daemon-log.ts"() {
+    "use strict";
+    init_fs();
+  }
+});
+
 // src/team/join.ts
 var join_exports = {};
 __export(join_exports, {
@@ -17304,13 +18306,21 @@ async function joinTeam(args2) {
     bearerToken,
     teamSlug: data.team.slug,
     teamName: data.team.name,
-    pairedAt: (/* @__PURE__ */ new Date()).toISOString()
+    pairedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    // Fence off any daemon.log history from a PREVIOUS team so the first push
+    // doesn't sweep the prior team's [sync] lines onto this team's log. The
+    // pair run's own [sync] line is written after this instant, so it still
+    // uploads on the next sync.
+    lastSyncedLogAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   writeTeamConfig(config);
   console.log(`Paired with "${data.team.name}" as ${data.user.displayName || data.user.email}`);
   console.log(`  role: ${data.membership.role}`);
   console.log("  Syncing local history\u2026");
-  const sync = await runTeamSync(void 0, config, { forceUsageBackfill: true });
+  const sync = await runTeamSync(logToDaemonLog, config, {
+    forceUsageBackfill: true,
+    trigger: "pair"
+  });
   const backfill = sync.usageBackfill;
   if (backfill?.error) {
     console.log(`  \u26A0 Usage history sync failed: ${backfill.error} \u2014 daemon will retry automatically.`);
@@ -17332,11 +18342,14 @@ async function joinTeam(args2) {
   }
   console.log("  Daemon polls every 5 minutes \u2014 next push happens automatically.");
 }
+var logToDaemonLog;
 var init_join = __esm({
   "src/team/join.ts"() {
     "use strict";
     init_config();
     init_sync();
+    init_daemon_log();
+    logToDaemonLog = appendDaemonLogLine;
   }
 });
 
@@ -17415,12 +18428,12 @@ var logs_exports = {};
 __export(logs_exports, {
   teamLogs: () => teamLogs
 });
-import { readFileSync as readFileSync17 } from "node:fs";
+import { readFileSync as readFileSync19 } from "node:fs";
 async function teamLogs() {
   const logPath = cclensPath("daemon.log");
   try {
-    const lines = readFileSync17(logPath, "utf8").trim().split("\n");
-    const teamLines = lines.filter((l) => l.includes("team "));
+    const lines = readFileSync19(logPath, "utf8").trim().split("\n");
+    const teamLines = lines.filter((l) => l.includes("[sync] ") || l.includes("team "));
     if (teamLines.length === 0) {
       console.log("No team-related log entries found.");
       return;
@@ -17469,7 +18482,15 @@ async function team(args2) {
     }
     case "sync": {
       const { runTeamSync: runTeamSync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
-      const outcome = await runTeamSync2((level, msg) => console.log(`[${level}] ${msg}`));
+      const { appendDaemonLogLine: appendDaemonLogLine2 } = await Promise.resolve().then(() => (init_daemon_log(), daemon_log_exports));
+      const outcome = await runTeamSync2(
+        (level, msg) => {
+          console.log(`[${level}] ${msg}`);
+          appendDaemonLogLine2(level, msg);
+        },
+        void 0,
+        { trigger: "manual" }
+      );
       if (!outcome.paired) {
         console.error("Not paired. Run 'fleetlens team join <url> <device-token>' first.");
         process.exit(1);
@@ -17525,7 +18546,7 @@ __export(runs_exports, {
   runs: () => runs
 });
 import { execSync as execSync2 } from "node:child_process";
-import { existsSync as existsSync16, readFileSync as readFileSync18, readdirSync as readdirSync5, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync16, readFileSync as readFileSync20, readdirSync as readdirSync5, statSync as statSync7 } from "node:fs";
 import { join as join14 } from "node:path";
 async function runs(args2) {
   const json = args2.includes("--json");
@@ -17611,7 +18632,7 @@ function listActiveRuns() {
 }
 function readSpend(sinceMs) {
   if (!existsSync16(SPEND_PATH)) return [];
-  const lines = readFileSync18(SPEND_PATH, "utf-8").split("\n").filter((l) => l.trim());
+  const lines = readFileSync20(SPEND_PATH, "utf-8").split("\n").filter((l) => l.trim());
   const out = [];
   for (const line of lines) {
     try {
@@ -17736,7 +18757,7 @@ function listTraceFiles() {
   const entries2 = readdirSync5(RUNS_DIR2).filter((f) => f.endsWith(".jsonl"));
   return entries2.map((f) => {
     const path7 = join14(RUNS_DIR2, f);
-    const st = statSync6(path7);
+    const st = statSync7(path7);
     return { runId: f.replace(/\.jsonl$/, ""), path: path7, mtimeMs: st.mtimeMs };
   }).sort((a, b) => b.mtimeMs - a.mtimeMs);
 }
@@ -17760,7 +18781,7 @@ function resolveRunId(arg) {
   return null;
 }
 function readTrace(path7) {
-  return readFileSync18(path7, "utf-8").split("\n").filter((l) => l.trim()).map((l) => {
+  return readFileSync20(path7, "utf-8").split("\n").filter((l) => l.trim()).map((l) => {
     try {
       return JSON.parse(l);
     } catch {
@@ -17792,13 +18813,13 @@ recent runs:`);
   const events = readTrace(r.path);
   printTrace(r.runId, events);
   if (!follow) return;
-  let lastSize = statSync6(r.path).size;
+  let lastSize = statSync7(r.path).size;
   let lastIdx = events.length;
   console.log("\n  \u27F6 following \xB7 ^C to quit\n");
   process.on("SIGINT", () => process.exit(0));
   while (true) {
     await new Promise((res) => setTimeout(res, 500));
-    const st = statSync6(r.path);
+    const st = statSync7(r.path);
     if (st.size === lastSize) continue;
     lastSize = st.size;
     const all = readTrace(r.path);
@@ -17947,7 +18968,7 @@ async function main() {
     case "version":
     case "--version":
     case "-v":
-      console.log(`fleetlens ${"0.13.2"}`);
+      console.log(`fleetlens ${"0.14.0"}`);
       break;
     case "help":
     case "--help":