fleetlens 0.13.2 → 0.15.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-]+$/;
@@ -4092,8 +4222,17 @@ var init_cowork = __esm({
 });
 
 // ../parser/dist/team-config.js
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, mkdirSync as mkdirSync2, renameSync } from "node:fs";
 import { join } from "node:path";
+function shouldSyncProject(repoName, sp) {
+  if (!sp)
+    return true;
+  if (sp.excluded.includes(repoName))
+    return false;
+  if (sp.included.includes(repoName))
+    return true;
+  return sp.autoIncludeNew;
+}
 function readTeamConfig(dir) {
   const d = dir ?? cclensHome();
   try {
@@ -4105,7 +4244,9 @@ function readTeamConfig(dir) {
 function writeTeamConfig(config, dir) {
   const d = dir ?? cclensHome();
   mkdirSync2(d, { recursive: true });
-  writeFileSync2(join(d, CONFIG_FILE), JSON.stringify(config, null, 2), { mode: 384 });
+  const tmp = join(d, `${CONFIG_FILE}.${process.pid}.tmp`);
+  writeFileSync2(tmp, JSON.stringify(config, null, 2), { mode: 384 });
+  renameSync(tmp, join(d, CONFIG_FILE));
 }
 function clearTeamConfig(dir) {
   const d = dir ?? cclensHome();
@@ -4179,6 +4320,7 @@ __export(fs_exports, {
   readJsonlFile: () => readJsonlFile,
   readTeamConfig: () => readTeamConfig,
   sessionIdFromFileName: () => sessionIdFromFileName,
+  shouldSyncProject: () => shouldSyncProject,
   walkJsonlFiles: () => walkJsonlFiles,
   writeTeamConfig: () => writeTeamConfig
 });
@@ -4400,9 +4542,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 +4689,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.15.0";
 }
 async function ensureCurrentServer(opts = {}) {
   const status2 = getServerStatus();
@@ -4598,8 +4745,8 @@ async function startServer(opts = {}) {
   });
   child.unref();
   const pid = child.pid;
-  writePid(PID_FILE, pid, port, "0.13.2");
-  await waitForHealth(`http://localhost:${port}`, 1e4);
+  writePid(PID_FILE, pid, port, "0.15.0");
+  await waitForHealth(`http://localhost:${port}`, 3e4);
   return { pid, port };
 }
 function stopServer() {
@@ -4661,6 +4808,13 @@ var init_server = __esm({
 });
 
 // src/usage/storage.ts
+var storage_exports = {};
+__export(storage_exports, {
+  appendSnapshot: () => appendSnapshot,
+  latestClaudeCodeSnapshot: () => latestClaudeCodeSnapshot,
+  latestSnapshot: () => latestSnapshot,
+  readSnapshots: () => readSnapshots
+});
 import { appendFileSync, mkdirSync as mkdirSync3, readFileSync as readFileSync3, existsSync as existsSync2 } from "node:fs";
 import { dirname as dirname3 } from "node:path";
 function appendSnapshot(filePath, snapshot) {
@@ -4958,9 +5112,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.15.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.15.0"}. Next invocation will use ${verify.installedVersion}.`
     );
   }
 }
@@ -4995,14 +5149,14 @@ async function getUpdateAvailability() {
   if (isDevMode()) return null;
   const latest = await fetchLatestVersion();
   if (latest === null) return {
-    current: "0.13.2",
+    current: "0.15.0",
     latest: null,
     updateAvailable: false
   };
   return {
-    current: "0.13.2",
+    current: "0.15.0",
     latest,
-    updateAvailable: shouldUpdate("0.13.2", latest)
+    updateAvailable: shouldUpdate("0.15.0", latest)
   };
 }
 async function checkForUpdate() {
@@ -5092,7 +5246,7 @@ async function restartServices(state) {
 }
 async function forceUpdate() {
   const latest = await fetchLatestVersion();
-  const current = "0.13.2";
+  const current = "0.15.0";
   if (latest === null) {
     console.error("Could not reach npm registry. Check your network.");
     process.exit(1);
@@ -5135,10 +5289,13 @@ __export(autostart_exports, {
   autostart: () => autostart,
   buildPlist: () => buildPlist,
   dismissPrompt: () => dismissPrompt,
+  ensureTeamAutostart: () => ensureTeamAutostart,
+  hasOptedOut: () => hasOptedOut,
   installAutostart: () => installAutostart,
   isAutostartInstalled: () => isAutostartInstalled,
   isPromptDismissed: () => isPromptDismissed,
-  maybePromptAutostart: () => maybePromptAutostart
+  maybePromptAutostart: () => maybePromptAutostart,
+  recordOptOut: () => recordOptOut
 });
 import { existsSync as existsSync5, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3, rmSync, readFileSync as readFileSync6, realpathSync as realpathSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
@@ -5175,7 +5332,6 @@ function buildPlist(opts) {
   <array>
     <string>${nodePath}</string>
     <string>${scriptPath}</string>
-    <string>daemon</string>
     <string>start</string>
   </array>
   <key>RunAtLoad</key>
@@ -5207,9 +5363,10 @@ async function installAutostart() {
   await runLaunchctl(["unload", p]).catch(() => {
   });
   await runLaunchctl(["load", "-w", p]);
-  console.log("Autostart installed \u2014 the Fleetlens usage daemon will start at login.");
+  writeFlags({ optedOut: false });
+  console.log("Autostart installed \u2014 Fleetlens (dashboard + usage daemon) will start at login.");
   console.log(`  LaunchAgent: ${p}`);
-  console.log(`  Runs:        ${nodePath} ${scriptPath} daemon start`);
+  console.log(`  Runs:        ${nodePath} ${scriptPath} start`);
   console.log(
     "  Note: the Node path above is baked in. If you upgrade or switch Node (e.g. via nvm), re-run `fleetlens autostart install`."
   );
@@ -5221,14 +5378,27 @@ async function uninstallAutostart() {
     return;
   }
   const p = plistPath();
+  recordOptOut();
   if (!existsSync5(p)) {
-    console.log("Autostart is not installed \u2014 nothing to remove.");
+    console.log("Autostart is not installed \u2014 nothing to remove. Noted your opt-out; team join won't enable it.");
     return;
   }
   await runLaunchctl(["unload", "-w", p]).catch(() => {
   });
   rmSync(p, { force: true });
   console.log(`Autostart removed (${p}). The daemon will no longer start at login.`);
+  console.log("  Opt-out recorded \u2014 team join/start won't re-enable it.");
+}
+async function ensureTeamAutostart() {
+  try {
+    if (!isMac()) return;
+    if (isAutostartInstalled()) return;
+    if (hasOptedOut()) return;
+    console.log("  Team reporting stays on across reboots: enabling Fleetlens auto-start at login (dashboard + daemon).");
+    console.log("  (Opt out anytime: fleetlens autostart uninstall \u2014 join won't re-enable it.)");
+    await installAutostart();
+  } catch {
+  }
 }
 async function statusAutostart() {
   if (!isMac()) {
@@ -5249,22 +5419,33 @@ async function statusAutostart() {
 function promptFlagPath() {
   return cclensPath("autostart.json");
 }
-function isPromptDismissed() {
+function readFlags() {
   try {
-    const j = JSON.parse(readFileSync6(promptFlagPath(), "utf8"));
-    return j.promptDismissed === true;
+    return JSON.parse(readFileSync6(promptFlagPath(), "utf8"));
   } catch {
-    return false;
+    return {};
   }
 }
-function dismissPrompt() {
+function writeFlags(patch) {
   const p = promptFlagPath();
   try {
     mkdirSync4(dirname6(p), { recursive: true });
-    writeFileSync3(p, JSON.stringify({ promptDismissed: true }, null, 2), "utf8");
+    writeFileSync3(p, JSON.stringify({ ...readFlags(), ...patch }, null, 2), "utf8");
   } catch {
   }
 }
+function isPromptDismissed() {
+  return readFlags().promptDismissed === true;
+}
+function dismissPrompt() {
+  writeFlags({ promptDismissed: true });
+}
+function hasOptedOut() {
+  return readFlags().optedOut === true;
+}
+function recordOptOut() {
+  writeFlags({ optedOut: true });
+}
 function promptYesNo(question, defaultYes) {
   return new Promise((resolve3) => {
     const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -5279,15 +5460,20 @@ function promptYesNo(question, defaultYes) {
 async function maybePromptAutostart(opts) {
   try {
     if (!isMac()) return;
-    if (!opts.daemonStarted) return;
     if (process.env.__FLEETLENS_UPDATED) return;
+    const { readTeamConfig: readTeamConfig2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+    if (readTeamConfig2()) {
+      await ensureTeamAutostart();
+      return;
+    }
+    if (!opts.daemonStarted) return;
     if (!process.stdin.isTTY) return;
     if (isAutostartInstalled()) return;
     if (isPromptDismissed()) return;
     console.log("");
-    console.log("Tip: keep the Fleetlens usage daemon running after you restart your Mac?");
-    console.log("     This installs a launchd LaunchAgent that runs `fleetlens daemon start`");
-    console.log("     at login (daemon only \u2014 not the dashboard server).");
+    console.log("Tip: keep Fleetlens running after you restart your Mac?");
+    console.log("     This installs a launchd LaunchAgent that runs `fleetlens start`");
+    console.log("     at login (dashboard server + usage daemon).");
     const yes = await promptYesNo("Set that up now? [Y/n] ", true);
     if (yes) {
       await installAutostart();
@@ -5450,7 +5636,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.15.0"}) \u2014 run 'fleetlens start' to restart on the current version`
       );
     }
   } else {
@@ -5588,6 +5774,11 @@ var init_token = __esm({
 });
 
 // src/usage/api.ts
+var api_exports = {};
+__export(api_exports, {
+  UsageApiError: () => UsageApiError,
+  fetchUsage: () => fetchUsage
+});
 async function fetchUsage() {
   const creds = readOAuthCredentials();
   if (!creds) {
@@ -6058,8 +6249,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 +6292,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 +6814,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 +6980,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 +6988,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 +7005,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 +7015,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 +7538,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;
   }
 });
 
@@ -6784,7 +7566,7 @@ var init_dist2 = __esm({
 });
 
 // ../entries/dist/digest-fs.js
-import { readFileSync as readFileSync8, readdirSync, writeFileSync as writeFileSync4, renameSync, chmodSync, mkdirSync as mkdirSync5, existsSync as existsSync6 } from "node:fs";
+import { readFileSync as readFileSync8, readdirSync, writeFileSync as writeFileSync4, renameSync as renameSync2, chmodSync, mkdirSync as mkdirSync5, existsSync as existsSync6 } from "node:fs";
 import { dirname as dirname7, join as join7 } from "node:path";
 function parseDigestFile(path7, expectedVersion) {
   try {
@@ -6833,7 +7615,7 @@ function writeDayDigest(digest2) {
     } catch {
     }
   }
-  renameSync(tmp, final);
+  renameSync2(tmp, final);
 }
 function readDayDigest(date) {
   const p = dayDigestPath(date);
@@ -6869,7 +7651,7 @@ function writeWeekDigest(digest2) {
     } catch {
     }
   }
-  renameSync(tmp, final);
+  renameSync2(tmp, final);
 }
 function readWeekDigest(monday) {
   const p = weekDigestPath(monday);
@@ -6906,7 +7688,7 @@ function writeMonthDigest(digest2) {
     } catch {
     }
   }
-  renameSync(tmp, final);
+  renameSync2(tmp, final);
 }
 function readMonthDigest(yearMonth) {
   const p = monthDigestPath(yearMonth);
@@ -6955,6 +7737,7 @@ __export(fs_exports2, {
   __setDigestsDirForTest: () => __setDigestsDirForTest,
   __setEntriesDirForTest: () => __setEntriesDirForTest,
   entriesDir: () => entriesDir,
+  entryExists: () => entryExists,
   getCurrentMonthDigestFromCache: () => getCurrentMonthDigestFromCache,
   getCurrentWeekDigestFromCache: () => getCurrentWeekDigestFromCache,
   getTodayDigestFromCache: () => getTodayDigestFromCache,
@@ -6977,7 +7760,7 @@ __export(fs_exports2, {
   writeMonthDigest: () => writeMonthDigest,
   writeWeekDigest: () => writeWeekDigest
 });
-import { readFileSync as readFileSync9, readdirSync as readdirSync2, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, renameSync as renameSync2, existsSync as existsSync7 } from "node:fs";
+import { readFileSync as readFileSync9, readdirSync as readdirSync2, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, renameSync as renameSync3, existsSync as existsSync7 } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { join as join8 } from "node:path";
 function entriesDir() {
@@ -6991,8 +7774,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")}`;
@@ -7004,7 +7787,7 @@ function writeEntry(entry) {
   const tmp = tmpPathFor(final);
   const json = JSON.stringify(entry, null, 2);
   writeFileSync5(tmp, json, { encoding: "utf8" });
-  renameSync2(tmp, final);
+  renameSync3(tmp, final);
 }
 function enrichmentInputHash(e) {
   return [
@@ -7032,26 +7815,29 @@ function writeEntryPreservingEnrichment(fresh) {
   }
   const tmp = tmpPathFor(final);
   writeFileSync5(tmp, JSON.stringify(toWrite, null, 2), { encoding: "utf8" });
-  renameSync2(tmp, final);
+  renameSync3(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 +12006,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 +12027,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)}
 
@@ -11322,7 +12108,7 @@ RESPOND WITH ONLY VALID JSON (no prose, no code fence):
 });
 
 // ../entries/dist/tmux-runner.js
-import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync6, existsSync as existsSync8, readdirSync as readdirSync3, realpathSync as realpathSync3, readFileSync as readFileSync10, unlinkSync as unlinkSync3, renameSync as renameSync3 } from "node:fs";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync6, existsSync as existsSync8, readdirSync as readdirSync3, realpathSync as realpathSync3, readFileSync as readFileSync10, unlinkSync as unlinkSync3, renameSync as renameSync4 } from "node:fs";
 import { join as join9 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 import { spawnSync as spawnSync2 } from "node:child_process";
@@ -11365,7 +12151,7 @@ function ensureRuntimeCwdTrusted(cwd) {
   const tmp = `${cfgPath}.cclens-tmp-${process.pid}`;
   try {
     writeFileSync6(tmp, JSON.stringify(cfg, null, 2));
-    renameSync3(tmp, cfgPath);
+    renameSync4(tmp, cfgPath);
   } catch {
     try {
       unlinkSync3(tmp);
@@ -12308,7 +13094,7 @@ var init_queue = __esm({
 });
 
 // ../entries/dist/settings.js
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync9, renameSync as renameSync4, chmodSync as chmodSync2, mkdirSync as mkdirSync10, existsSync as existsSync12 } from "node:fs";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync9, renameSync as renameSync5, chmodSync as chmodSync2, mkdirSync as mkdirSync10, existsSync as existsSync12 } from "node:fs";
 import { dirname as dirname9 } from "node:path";
 function settingsPath() {
   if (settingsPathCached)
@@ -12361,7 +13147,7 @@ function writeSettings(s) {
   if (process.platform !== "win32") {
     chmodSync2(tmp, 384);
   }
-  renameSync4(tmp, p);
+  renameSync5(tmp, p);
 }
 var DEFAULT_SETTINGS, settingsPathCached;
 var init_settings = __esm({
@@ -12382,7 +13168,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 +13179,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 +15211,7 @@ function activeMs(timestamps) {
   }
   return active;
 }
-function bashVerb(cmd) {
+function bashVerb2(cmd) {
   if (!cmd)
     return "?";
   let firstSeg = cmd.split(/\|\||&&|;|\|/, 1)[0].trim();
@@ -14435,7 +15221,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 +15294,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 +15348,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 +15774,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 +15788,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 +15905,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 +16582,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 +16883,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()) {
@@ -16157,6 +16989,10 @@ function clipSegmentsToDay(segments, bounds) {
   }
   return out;
 }
+function filterSyncedSessions(sessions, syncProjects) {
+  if (!syncProjects) return sessions;
+  return sessions.filter((s) => shouldSyncProject(projectRepoName(s.projectName), syncProjects));
+}
 function sessionTouchesDay(s, day2) {
   const bounds = dayBoundsMs(day2);
   if (s.activeSegments && s.activeSegments.length > 0) {
@@ -16164,7 +17000,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 +17026,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 +17033,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 +17055,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 +17130,36 @@ function buildEnrichedExtras(entries2) {
   }
   return { outcomeMix, helpfulnessMix, goalMix };
 }
-function buildRichBlocksForDay(day2, daySessions, privateProjects, enrichmentOptIn, resolveRepo) {
-  const entries2 = listEntriesForDay(day2);
+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 sessionIds = new Set(daySessions.map((s) => s.id));
+  const entries2 = listEntriesForDay(day2).filter((e) => sessionIds.has(e.session_id));
   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.15.0",
     ...richRollup || inputs.enrichedExtras || inputs.artifactSignals ? { schemaVersion: RICH_ROLLUP_SCHEMA_VERSION } : {},
     ...inputs.rollup ? { dailyRollup: inputs.rollup } : {},
     ...richRollup ? { richRollup } : {},
@@ -16317,7 +17167,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 +17184,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 +17222,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 +17243,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 +17268,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 +17285,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 +17306,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 +17325,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 +17368,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 +17376,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 +17556,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 +17625,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 +17656,7 @@ function listMarkdownFiles(dir) {
     const full = join13(dir, name);
     let stat;
     try {
-      stat = statSync5(full);
+      stat = statSync6(full);
     } catch {
       continue;
     }
@@ -16788,19 +17673,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 +17700,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 +17733,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 +17759,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 = "";
@@ -16936,8 +17823,8 @@ async function dispatchCommand(command2, config, log) {
   }
 }
 async function runActivityBackfill(command2, config, log) {
-  const { listSessions: listSessions2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-  const { toLocalDay: toLocalDay4 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+  const { listSessions: listSessions2, shouldSyncProject: shouldSyncProject2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+  const { toLocalDay: toLocalDay4, projectRepoName: projectRepoName2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
   const { probeArtifactSignals: probeArtifactSignals2 } = await Promise.resolve().then(() => (init_file_probe(), file_probe_exports));
   const days = command2.params.days;
   const todayMs = Date.now();
@@ -16946,7 +17833,7 @@ async function runActivityBackfill(command2, config, log) {
   log("info", `command ${command2.id}: backfill-activity from ${targetDay} (${days} days)`);
   let sessions;
   try {
-    sessions = await listSessions2({ limit: 1e4 });
+    sessions = filterSyncedSessions(await listSessions2({ limit: 1e4 }), config.syncProjects);
   } catch (err) {
     return {
       id: command2.id,
@@ -16964,16 +17851,15 @@ 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()] });
+      const cwdAllowed = shouldSyncProject2(projectRepoName2(process.cwd()), config.syncProjects);
+      artifactSignals = probeArtifactSignals2({ day: rollup.day, extraRoots: cwdAllowed ? [process.cwd()] : [] });
     } catch {
     }
     const payload = buildIngestPayload({
@@ -17012,21 +17898,128 @@ 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 };
+  if (config.setupPending) {
+    log(
+      "info",
+      buildSyncLine(
+        "idle",
+        options.trigger ?? "auto",
+        {
+          pushedDays: [],
+          droppedDays: [],
+          queued: 0,
+          queuedDrained: 0,
+          usageSnapshots: 0,
+          idleReason: "setup pending \u2014 finish onboarding in the dashboard (/team/onboarding)"
+        },
+        0,
+        options.nextSyncMs
+      )
+    );
+    return { paired: true, pushed: 0, queued: 0, queuedDrained: 0, setupPending: true };
+  }
+  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 };
+    }
+  };
+  const emit = options.onProgress ?? (() => {
+  });
   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 { toLocalDay: toLocalDay4, projectRepoName: projectRepoName2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
     const today = toLocalDay4(Date.now());
-    let nextConfig = { ...config };
+    let patches = {};
     const persistConfig = (patch) => {
-      nextConfig = { ...nextConfig, ...patch };
-      writeTeamConfig(nextConfig);
+      patches = { ...patches, ...patch };
+      const onDisk = readTeamConfig();
+      if (!onDisk) return;
+      writeTeamConfig({ ...onDisk, ...patches });
     };
+    const pendingLog = readPendingSyncLog(config.lastSyncedLogAt);
     const collectedCommands = /* @__PURE__ */ new Map();
     const collectCommands = (commands) => {
       if (!commands) return;
@@ -17064,128 +18057,259 @@ 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 queuedPayload = backlog[i];
+        if (queuedPayload.richRollup?.projects?.some((p) => !shouldSyncProject(p.project, config.syncProjects))) {
+          log("info", "team push: dropped queued payload containing now-excluded project(s)");
+          continue;
+        }
+        const qResult = await pushToTeamServer(config, queuedPayload);
+        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;
+    };
+    emit({ type: "phase", phase: "usage-backfill" });
     const usageBackfill = await runTeamBackfill(log, USAGE_LOG4, config, {
       sinceCapturedAt: options.forceUsageBackfill ? void 0 : config.lastSyncedUsageSnapshotAt
     });
+    emit({
+      type: "usage",
+      inserted: usageBackfill.insertedSnapshots ?? 0,
+      alreadyKnown: usageBackfill.skippedSnapshots ?? 0
+    });
     if (usageBackfill.lastSnapshotAt) {
       persistConfig({ lastSyncedUsageSnapshotAt: usageBackfill.lastSnapshotAt });
     }
-    const sessions = await listSessions2({ limit: 1e4 });
-    const rollups = buildRollupsForRange(sessions, config.lastSyncedDay);
+    const unfilteredSessions = await listSessions2({ limit: 1e4 });
+    const sessions = filterSyncedSessions(unfilteredSessions, config.syncProjects);
+    const allRollups = buildRollupsForRange(sessions);
+    const inWindow = (day2) => !config.lastSyncedDay || day2 >= config.lastSyncedDay;
+    const rollups = allRollups.filter((r) => inWindow(r.day));
+    if (config.syncProjects) {
+      const filteredDays = new Set(allRollups.map((r) => r.day));
+      for (const r of buildRollupsForRange(unfilteredSessions)) {
+        if (!filteredDays.has(r.day) && inWindow(r.day)) {
+          rollups.push({
+            day: r.day,
+            agentTimeMs: 0,
+            sessions: 0,
+            uniqueSessions: 0,
+            toolCalls: 0,
+            turns: 0,
+            tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }
+          });
+        }
+      }
+      rollups.sort((a, b) => a.day < b.day ? -1 : 1);
+    }
+    emit({ type: "phase", phase: "activity", totalDays: rollups.length });
     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");
+        }
+        emit({ type: "done", pushed: 0, queued: 0, pushedDays: summary.pushedDays });
         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");
+          emit({ type: "done", pushed: 0, queued: 0, pushedDays: summary.pushedDays });
+          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");
+        emit({ type: "done", pushed: 0, queued: 1, pushedDays: summary.pushedDays });
         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();
+      emit({ type: "done", pushed: 1, queued: 0, pushedDays: summary.pushedDays });
       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;
+    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);
+      const tombstone = daySessions.length === 0 && !!config.syncProjects;
+      const emptyRich = tombstone ? {
+        projects: [],
+        workingShapes: [],
+        concurrencyPeak: 0,
+        parallelMinutes: 0,
+        longAutonomous: { count: 0, totalMin: 0, maxSingleMin: 0 },
+        toolErrors: 0,
+        skillsLoaded: [],
+        subagentsDispatched: [],
+        brainstormWarmupSessions: 0,
+        planModeUsed: 0,
+        prs: 0,
+        commits: 0,
+        pushes: 0
+      } : void 0;
       let artifactSignals = null;
       try {
-        artifactSignals = probeArtifactSignals2({
-          day: rollup.day,
-          extraRoots: [process.cwd()]
-        });
+        const cwdAllowed = shouldSyncProject(projectRepoName2(process.cwd()), config.syncProjects);
+        artifactSignals = probeArtifactSignals2({ day: rollup.day, extraRoots: cwdAllowed ? [process.cwd()] : [] });
       } catch {
       }
-      const payload = buildIngestPayload({
+      return buildIngestPayload({
         rollup,
-        richExtras: richBlocks?.rich,
-        enrichedExtras: richBlocks?.enriched,
+        richExtras: richBlocks?.rich ?? emptyRich,
+        enrichedExtras: richBlocks?.enriched ?? (tombstone ? { outcomeMix: {}, helpfulnessMix: {}, goalMix: {} } : void 0),
         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
+      });
+    };
+    const rollupsDesc = [...rollups].reverse();
+    for (let i = 0; i < rollupsDesc.length; i++) {
+      const rollup = rollupsDesc[i];
+      const isLatest = i === 0;
+      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);
+          emit({ type: "day", day: rollup.day, index: i + 1, total: rollupsDesc.length, outcome: "dropped" });
+          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;
+        emit({ type: "day", day: rollup.day, index: i + 1, total: rollupsDesc.length, outcome: "queued" });
         break;
       }
       writeLastPushSuccess(payload);
       collectCommands(result.body?.commands);
+      recordVerdict(result.body);
+      if (i === 0) syncLogWasDelivered = syncLogDelivered(result.body);
       pushed++;
-      lastPushedDay = rollup.day;
-    }
-    if (failedDay) {
-      if (lastPushedDay) persistConfig({ lastSyncedDay: lastPushedDay });
-    } else {
-      persistConfig({ lastSyncedDay: today });
+      summary.pushedDays.push(rollup.day);
+      emit({ type: "day", day: rollup.day, index: i + 1, total: rollupsDesc.length, outcome: "pushed" });
     }
-    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));
+      if (retryDay && summary.pushedDays.includes(retryDay)) {
+        const idx = workingDropped.indexOf(retryDay);
+        if (idx >= 0) workingDropped.splice(idx, 1);
+        summary.recoveredDays = [retryDay];
+      }
+      const retryRollup = retryDay && !summary.pushedDays.includes(retryDay) ? allRollups.find((r) => r.day === retryDay) ?? (config.syncProjects ? {
+        day: retryDay,
+        agentTimeMs: 0,
+        sessions: 0,
+        uniqueSessions: 0,
+        toolCalls: 0,
+        turns: 0,
+        tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }
+      } : void 0) : 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 (droppedChanged) persistConfig(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();
+    emit({ type: "done", pushed, queued, pushedDays: summary.pushedDays });
     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}`;
+    emit({ type: "error", message });
+    finish("error");
     writeLastPushFailure(
       { ingestId: "n/a", observedAt: (/* @__PURE__ */ new Date()).toISOString() },
       `team push error: ${message}`
@@ -17249,8 +18373,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 +18391,7 @@ var init_sync = __esm({
     init_git_remote();
     init_queue2();
     init_backfill();
+    init_sync_log();
     init_last_push();
     init_commands();
     init_profile();
@@ -17274,15 +18404,47 @@ 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, {
+  carryOverSyncProjects: () => carryOverSyncProjects,
   joinTeam: () => joinTeam
 });
+function carryOverSyncProjects(existing, serverUrl, teamSlug) {
+  if (existing && existing.serverUrl === serverUrl && existing.teamSlug === teamSlug) {
+    return existing.syncProjects;
+  }
+  return void 0;
+}
 async function joinTeam(args2) {
-  const [serverUrl, bearerToken] = args2;
+  const noBrowser = args2.includes("--no-browser");
+  const [serverUrl, bearerToken] = args2.filter((a) => !a.startsWith("--"));
   if (!serverUrl || !bearerToken) {
-    console.error("Usage: fleetlens team join <server-url> <device-token>");
+    console.error("Usage: fleetlens team join <server-url> <device-token> [--no-browser]");
     console.error("");
     console.error("Get the device token from the dashboard after signup,");
     console.error("or from Settings \u2192 My device token.");
@@ -17298,45 +18460,93 @@ async function joinTeam(args2) {
     process.exit(1);
   }
   const data = await res.json();
+  const existing = readTeamConfig();
   const config = {
     serverUrl,
     memberId: data.membership.id,
     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(),
+    syncProjects: carryOverSyncProjects(existing, serverUrl, data.team.slug),
+    // Browser path: gate the daemon until the wizard's "Start syncing".
+    ...noBrowser ? {} : { setupPending: true }
   };
   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 backfill = sync.usageBackfill;
-  if (backfill?.error) {
-    console.log(`  \u26A0 Usage history sync failed: ${backfill.error} \u2014 daemon will retry automatically.`);
-  } else if ((backfill?.insertedSnapshots ?? 0) > 0) {
-    console.log(
-      `  \u2713 Synced ${backfill.insertedSnapshots} usage snapshot${backfill.insertedSnapshots === 1 ? "" : "s"} from local history.`
-    );
-  } else if ((backfill?.sentSnapshots ?? 0) > 0) {
-    console.log(`  \u2713 ${backfill.sentSnapshots} usage snapshots already on server (deduped on capture time).`);
-  } else {
-    console.log("  \xB7 No local usage snapshots yet \u2014 daemon will start collecting.");
+  if (noBrowser) {
+    console.log("  Syncing local history\u2026");
+    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.`);
+    } else if ((backfill?.insertedSnapshots ?? 0) > 0) {
+      console.log(
+        `  \u2713 Synced ${backfill.insertedSnapshots} usage snapshot${backfill.insertedSnapshots === 1 ? "" : "s"} from local history.`
+      );
+    } else if ((backfill?.sentSnapshots ?? 0) > 0) {
+      console.log(`  \u2713 ${backfill.sentSnapshots} usage snapshots already on server (deduped on capture time).`);
+    } else {
+      console.log("  \xB7 No local usage snapshots yet \u2014 daemon will start collecting.");
+    }
+    if (sync.error) {
+      console.log(`  \u26A0 Team sync failed: ${sync.error} \u2014 will retry on next daemon cycle.`);
+    } else if (sync.pushed > 0) {
+      console.log(`  \u2713 Synced ${sync.pushed} activity payload${sync.pushed === 1 ? "" : "s"}.`);
+    } else {
+      console.log("  \xB7 No new session activity to push.");
+    }
+    console.log("  Daemon polls every 5 minutes \u2014 next push happens automatically.");
+    const { ensureTeamAutostart: ensureNoBrowser } = await Promise.resolve().then(() => (init_autostart(), autostart_exports));
+    await ensureNoBrowser();
+    return;
   }
-  if (sync.error) {
-    console.log(`  \u26A0 Team sync failed: ${sync.error} \u2014 will retry on next daemon cycle.`);
-  } else if (sync.pushed > 0) {
-    console.log(`  \u2713 Synced ${sync.pushed} activity payload${sync.pushed === 1 ? "" : "s"}.`);
-  } else {
-    console.log("  \xB7 No new session activity to push.");
+  try {
+    const { fetchUsage: fetchUsage2 } = await Promise.resolve().then(() => (init_api(), api_exports));
+    const { appendSnapshot: appendSnapshot2 } = await Promise.resolve().then(() => (init_storage(), storage_exports));
+    const { cclensPath: cclensPath2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+    appendSnapshot2(cclensPath2("usage.jsonl"), await fetchUsage2());
+  } catch {
   }
-  console.log("  Daemon polls every 5 minutes \u2014 next push happens automatically.");
+  const { ensureTeamAutostart: ensureTeamAutostart2 } = await Promise.resolve().then(() => (init_autostart(), autostart_exports));
+  await ensureTeamAutostart2();
+  console.log("  Opening your browser to finish setup\u2026");
+  let url;
+  try {
+    const server = await ensureCurrentServer({});
+    url = `http://localhost:${server.port}/team/onboarding`;
+    const daemon2 = startDaemonSilent();
+    if (!daemon2.started && !daemon2.alreadyRunning) {
+      console.warn(`  \u26A0 Daemon failed to start \u2014 ${daemon2.error}`);
+    }
+  } catch (err) {
+    console.error(`  \u26A0 Could not start the dashboard: ${err.message}`);
+    console.error("  Re-run 'fleetlens team join' after fixing it, or use --no-browser to sync everything from the terminal.");
+    process.exit(1);
+  }
+  openBrowser(url);
+  console.log(`  Continue in your browser: ${url}`);
+  console.log("  Nothing syncs until you finish setup there.");
 }
+var logToDaemonLog;
 var init_join = __esm({
   "src/team/join.ts"() {
     "use strict";
     init_config();
     init_sync();
+    init_daemon_log();
+    init_server();
+    init_daemon();
+    logToDaemonLog = appendDaemonLogLine;
   }
 });
 
@@ -17415,12 +18625,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;
@@ -17468,20 +18678,42 @@ async function team(args2) {
       break;
     }
     case "sync": {
+      const progressJson = args2.includes("--progress-json");
       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) => {
+          if (!progressJson) console.log(`[${level}] ${msg}`);
+          appendDaemonLogLine2(level, msg);
+        },
+        void 0,
+        {
+          trigger: "manual",
+          onProgress: progressJson ? (ev) => console.log(JSON.stringify(ev)) : void 0
+        }
+      );
       if (!outcome.paired) {
         console.error("Not paired. Run 'fleetlens team join <url> <device-token>' first.");
         process.exit(1);
       }
+      if (outcome.setupPending) {
+        if (progressJson) {
+          console.log(JSON.stringify({ type: "error", message: "setup pending \u2014 selection not saved yet" }));
+        } else {
+          console.error("Setup pending \u2014 nothing synced. Finish onboarding in the dashboard (/team/onboarding) or re-run 'fleetlens team join'.");
+        }
+        process.exit(1);
+      }
       const inserted = outcome.usageBackfill?.insertedSnapshots ?? 0;
       const madeProgress = outcome.pushed > 0 || outcome.queuedDrained > 0 || inserted > 0;
       if (outcome.error || outcome.usageBackfill?.error && !madeProgress) process.exit(1);
-      const sent = outcome.usageBackfill?.sentSnapshots ?? 0;
-      const usageChecked = sent > 0 ? `, ${sent} usage snapshot${sent === 1 ? "" : "s"} checked` : "";
-      console.log(
-        `\u2713 ${outcome.pushed} activity payload${outcome.pushed === 1 ? "" : "s"} pushed` + usageChecked + (outcome.queuedDrained ? `, ${outcome.queuedDrained} queued retried` : "") + (outcome.queued ? `, ${outcome.queued} queued for retry (will fire next cycle)` : "")
-      );
+      if (!progressJson) {
+        const sent = outcome.usageBackfill?.sentSnapshots ?? 0;
+        const usageChecked = sent > 0 ? `, ${sent} usage snapshot${sent === 1 ? "" : "s"} checked` : "";
+        console.log(
+          `\u2713 ${outcome.pushed} activity payload${outcome.pushed === 1 ? "" : "s"} pushed` + usageChecked + (outcome.queuedDrained ? `, ${outcome.queuedDrained} queued retried` : "") + (outcome.queued ? `, ${outcome.queued} queued for retry (will fire next cycle)` : "")
+        );
+      }
       break;
     }
     case "backfill": {
@@ -17505,7 +18737,7 @@ async function team(args2) {
     default:
       console.log(`Usage: fleetlens team <join|status|leave|logs|sync|backfill>
 
-  join <url> <device-token>    Pair daemon with a team server (auto-backfills usage history)
+  join <url> <device-token> [--no-browser]   Pair with a team server (opens browser setup; --no-browser syncs everything immediately)
   status                       Show team pairing state and sync info
   leave                        Unpair from the team server
   logs                         Show recent team-related daemon log entries
@@ -17525,7 +18757,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 +18843,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 +18968,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 +18992,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 +19024,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 +19179,7 @@ async function main() {
     case "version":
     case "--version":
     case "-v":
-      console.log(`fleetlens ${"0.13.2"}`);
+      console.log(`fleetlens ${"0.15.0"}`);
       break;
     case "help":
     case "--help":
@@ -17976,7 +19208,7 @@ Advanced:
   autostart <install|uninstall|status>   Run the usage daemon at login (macOS launchd)
 
 Team:
-  team join <url> <token>           Pair with a team server
+  team join <url> <token>           Pair with a team server (browser setup)
   team status                       Show team pairing state
   team leave                        Unpair from team server
   team logs                         Show team-related daemon logs