@dosu/cli 0.53.0-beta.1 → 0.53.0-beta.11

package/bin/dosu.js

@@ -2529,8 +2529,20 @@ function getSupabaseURL() {
 function getSupabaseAnonKey() {
   return process.env.SUPABASE_ANON_KEY_OVERRIDE ?? "sb_publishable_NePQHMbqqlFOp1aaHbp5Bg_zyA-kYd6" ?? "";
 }
+function isAbsoluteHttpUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
 function getLlmGatewayURL() {
-  return process.env.DOSU_LLM_GATEWAY_URL_OVERRIDE ?? `${getBackendURL()}/v1/llm-gateway`;
+  const override = process.env.DOSU_LLM_GATEWAY_URL_OVERRIDE;
+  if (override)
+    return override;
+  const backend = getBackendURL().replace(/\/$/, "");
+  return backend ? `${backend}/v1/llm-gateway` : "";
 }
 
 // src/client/client.ts
@@ -5006,7 +5018,7 @@ function isNpxInvocation(channel = INSTALL_CHANNEL, env = process.env) {
 function getVersionString() {
   return `v${VERSION}`;
 }
-var VERSION = "0.53.0-beta.1", INSTALL_CHANNEL = "npm";
+var VERSION = "0.53.0-beta.11", INSTALL_CHANNEL = "npm";
 
 // src/debug/logger.ts
 import {
@@ -5144,7 +5156,7 @@ var init_logger = __esm(() => {
 });
 
 // src/client/contract.ts
-var CLI_CONTRACT_HASH = "bb1ad28625bd";
+var CLI_CONTRACT_HASH = "d7c6f0f0e8d0";
 
 // src/client/trpc.ts
 var exports_trpc = {};
@@ -5327,6 +5339,48 @@ function breadcrumb(segments, width = contentWidth()) {
 function visibleWidth(text) {
   return text.replace(ANSI_PATTERN2, "").length;
 }
+function tabStrip(labels, active2, width, { spread = true } = {}) {
+  if (!spread) {
+    const cellW = Math.max(...labels.map(([, label]) => label.length)) + 2 * TAB_CELL_PAD;
+    let row2 = "";
+    let rule2 = "";
+    for (const [id, label] of labels) {
+      const left = Math.floor((cellW - label.length) / 2);
+      const cell = " ".repeat(left) + label + " ".repeat(cellW - label.length - left);
+      row2 += id === active2 ? brand(import_picocolors9.default.bold(cell)) : import_picocolors9.default.dim(cell);
+      rule2 += id === active2 ? brand("━".repeat(cellW)) : import_picocolors9.default.dim("─".repeat(cellW));
+    }
+    return [row2, rule2];
+  }
+  const GAP_MIN = 3;
+  const totalLen = labels.reduce((sum, [, label]) => sum + label.length, 0);
+  const slots = Math.max(1, labels.length - 1);
+  const spare = Math.max(GAP_MIN * slots, width - totalLen);
+  const baseGap = Math.floor(spare / slots);
+  const bonus = spare % slots;
+  let row = "";
+  let col = 0;
+  let activeStart = 0;
+  let activeLen = 0;
+  labels.forEach(([id, label], i2) => {
+    if (i2 > 0) {
+      const gap = baseGap + (i2 <= bonus ? 1 : 0);
+      row += " ".repeat(gap);
+      col += gap;
+    }
+    if (id === active2) {
+      activeStart = col;
+      activeLen = label.length;
+      row += brand(import_picocolors9.default.bold(label));
+    } else {
+      row += import_picocolors9.default.dim(label);
+    }
+    col += label.length;
+  });
+  const tail = Math.max(0, width - activeStart - activeLen);
+  const rule = import_picocolors9.default.dim("─".repeat(activeStart)) + brand("━".repeat(activeLen)) + import_picocolors9.default.dim("─".repeat(tail));
+  return [row, rule];
+}
 function centerBlock(lines, width) {
   const blockWidth = Math.max(...lines.map(visibleWidth));
   const pad = " ".repeat(Math.max(0, Math.floor((width - blockWidth) / 2)));
@@ -5383,8 +5437,9 @@ function installCenteredLayout(stream = process.stdout) {
     active = false;
   };
 }
-var import_picocolors9, ESC2, CONTENT_WIDTH = 64, TOKEN_PATTERN, COLUMN_RESET_FINALS, active = false, ANSI_PATTERN2;
+var import_picocolors9, ESC2, CONTENT_WIDTH = 64, TOKEN_PATTERN, COLUMN_RESET_FINALS, active = false, ANSI_PATTERN2, TAB_CELL_PAD = 2;
 var init_layout = __esm(() => {
+  init_styles();
   import_picocolors9 = __toESM(require_picocolors(), 1);
   ESC2 = String.fromCharCode(27);
   TOKEN_PATTERN = new RegExp(`(\r
@@ -8303,391 +8358,16 @@ var init_agents = __esm(() => {
   init_formats();
 });
 
-// src/sync/lock.ts
-import { existsSync as existsSync9, readFileSync as readFileSync9, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync6 } from "node:fs";
-import { join as join8 } from "node:path";
-function processAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return err.code === "EPERM";
-  }
-}
-function lockPath(configDir = getConfigDir()) {
-  return join8(configDir, LOCK_FILENAME);
-}
-function fileLock(configDir = getConfigDir(), now = () => new Date) {
-  const path3 = lockPath(configDir);
-  let held = false;
-  const tryCreate = () => {
-    try {
-      writeFileSync6(path3, String(process.pid), { flag: "wx" });
-      return true;
-    } catch {
-      return false;
-    }
-  };
-  return {
-    acquire() {
-      if (tryCreate()) {
-        held = true;
-        return true;
-      }
-      try {
-        const age = now().getTime() - statSync3(path3).mtimeMs;
-        const holder = Number.parseInt(readFileSync9(path3, "utf8"), 10);
-        const holderDead = Number.isInteger(holder) && holder > 0 && !processAlive(holder);
-        if (age > STALE_LOCK_MS || holderDead) {
-          rmSync2(path3, { force: true });
-          held = tryCreate();
-          return held;
-        }
-      } catch {}
-      return false;
-    },
-    release() {
-      if (!held)
-        return;
-      held = false;
-      try {
-        if (existsSync9(path3) && readFileSync9(path3, "utf8") === String(process.pid)) {
-          rmSync2(path3, { force: true });
-        }
-      } catch {}
-    }
-  };
-}
-var LOCK_FILENAME = "knowledge-sync.lock", STALE_LOCK_MS;
-var init_lock = __esm(() => {
-  init_config();
-  STALE_LOCK_MS = 15 * 60 * 1000;
-});
-
-// src/sync/watermark.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync10, renameSync as renameSync2, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join9 } from "node:path";
-function syncStatePath(configDir = getConfigDir()) {
-  return join9(configDir, STATE_FILENAME);
-}
-function loadSyncState(configDir = getConfigDir()) {
-  const empty = {
-    schema_version: STATE_SCHEMA_VERSION,
-    watermark: null,
-    consecutive_failures: 0
-  };
-  const path3 = syncStatePath(configDir);
-  if (!existsSync10(path3))
-    return empty;
-  try {
-    const raw = JSON.parse(readFileSync10(path3, "utf-8"));
-    if (raw.schema_version !== STATE_SCHEMA_VERSION)
-      return empty;
-    const minedSessions = Array.isArray(raw.mined_sessions) ? raw.mined_sessions.filter((record) => typeof record === "object" && record !== null && typeof record.at === "string" && typeof record.session === "string").map((record) => ({
-      at: record.at,
-      session: record.session,
-      ...typeof record.project === "string" ? { project: record.project } : {}
-    })) : [];
-    const rawRefusal = raw.last_refusal;
-    const lastRefusal = rawRefusal && typeof rawRefusal.at === "string" && typeof rawRefusal.outcome === "string" && typeof rawRefusal.message === "string" ? { at: rawRefusal.at, outcome: rawRefusal.outcome, message: rawRefusal.message } : undefined;
-    return {
-      schema_version: STATE_SCHEMA_VERSION,
-      watermark: typeof raw.watermark === "string" ? raw.watermark : null,
-      last_attempt_at: typeof raw.last_attempt_at === "string" ? raw.last_attempt_at : undefined,
-      consecutive_failures: typeof raw.consecutive_failures === "number" && raw.consecutive_failures >= 0 ? raw.consecutive_failures : 0,
-      mined_sessions: minedSessions,
-      total_mined: typeof raw.total_mined === "number" && raw.total_mined >= 0 ? raw.total_mined : minedSessions.length,
-      total_notes: typeof raw.total_notes === "number" && raw.total_notes >= 0 ? raw.total_notes : 0,
-      total_learning_tokens: typeof raw.total_learning_tokens === "number" && raw.total_learning_tokens >= 0 ? raw.total_learning_tokens : 0,
-      ...lastRefusal ? { last_refusal: lastRefusal } : {},
-      ...Array.isArray(raw.project_filter) ? {
-        project_filter: raw.project_filter.filter((p2) => typeof p2 === "string")
-      } : {}
-    };
-  } catch {
-    return empty;
-  }
-}
-function saveSyncState(state, configDir = getConfigDir()) {
-  if (!existsSync10(configDir))
-    mkdirSync6(configDir, { recursive: true, mode: 448 });
-  const path3 = syncStatePath(configDir);
-  const tmp = `${path3}.${process.pid}.tmp`;
-  writeFileSync7(tmp, JSON.stringify(state, null, 2), { mode: 384 });
-  renameSync2(tmp, path3);
-}
-function backoffUntil(state) {
-  if (state.consecutive_failures === 0 || !state.last_attempt_at)
-    return null;
-  const last = Date.parse(state.last_attempt_at);
-  if (Number.isNaN(last))
-    return null;
-  const delay = Math.min(BACKOFF_BASE_MS * 2 ** (state.consecutive_failures - 1), BACKOFF_MAX_MS);
-  return new Date(last + delay);
-}
-function isUnderDir(dir, base) {
-  const root = base.endsWith("/") ? base.slice(0, -1) : base;
-  return dir === root || dir.startsWith(`${root}/`);
-}
-function filterSessionsByProject(sessions, filter, resolveDir) {
-  if (!filter || filter.length === 0)
-    return [...sessions];
-  const includeUnknown = filter.includes(UNKNOWN_PROJECT);
-  const dirs = filter.filter((entry) => entry !== UNKNOWN_PROJECT);
-  return sessions.filter((session) => {
-    const dir = resolveDir(session);
-    if (!dir)
-      return includeUnknown;
-    return dirs.some((base) => isUnderDir(dir, base));
-  });
-}
-function gateSessions(sessions, watermark, now = new Date, quietPeriodMs = DEFAULT_QUIET_PERIOD_MS) {
-  const watermarkMs = watermark ? Date.parse(watermark) : Number.NEGATIVE_INFINITY;
-  const completedBefore = now.getTime() - quietPeriodMs;
-  const ready = [];
-  const open2 = [];
-  for (const session of sessions) {
-    const updated = Date.parse(session.updated);
-    if (Number.isNaN(updated) || updated <= watermarkMs)
-      continue;
-    if (updated > completedBefore) {
-      open2.push(session);
-    } else {
-      ready.push(session);
-    }
-  }
-  return { ready, open: open2 };
-}
-var STATE_FILENAME = "knowledge-sync.json", STATE_SCHEMA_VERSION = 1, DEFAULT_QUIET_PERIOD_MS, BACKOFF_BASE_MS, BACKOFF_MAX_MS, MINED_HISTORY_LIMIT = 500, UNKNOWN_PROJECT = "(unknown)";
-var init_watermark = __esm(() => {
-  init_config();
-  DEFAULT_QUIET_PERIOD_MS = 5 * 60 * 1000;
-  BACKOFF_BASE_MS = 15 * 60 * 1000;
-  BACKOFF_MAX_MS = 24 * 60 * 60 * 1000;
-});
-
-// src/sync/status.ts
-import { readFileSync as readFileSync11, statSync as statSync4 } from "node:fs";
-function formatTokenCount(tokens) {
-  if (tokens < 1000)
-    return String(tokens);
-  if (tokens < 1e6) {
-    const k = tokens / 1000;
-    return `~${k >= 100 ? Math.round(k) : k.toFixed(1).replace(/\.0$/, "")}k`;
-  }
-  const m3 = tokens / 1e6;
-  return `~${m3 >= 100 ? Math.round(m3) : m3.toFixed(1).replace(/\.0$/, "")}M`;
-}
-function defaultIsProcessAlive2(pid) {
-  if (!Number.isInteger(pid) || pid <= 0)
-    return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return err.code === "EPERM";
-  }
-}
-function defaultReadLog() {
-  try {
-    return readFileSync11(logger.getLogPath(), "utf-8");
-  } catch {
-    return "";
-  }
-}
-function readLockFile(configDir) {
-  const path3 = lockPath(configDir);
-  try {
-    const pid = Number.parseInt(readFileSync11(path3, "utf-8"), 10);
-    return { pid: Number.isNaN(pid) ? -1 : pid, mtime: statSync4(path3).mtime };
-  } catch {
-    return null;
-  }
-}
-function recentSyncActivity(log3) {
-  return log3.split(`
-`).filter((line) => line.includes("[sync]") || line.includes("[miner]")).slice(-ACTIVITY_LINES).map((line) => line.replace(/ \[(DEBUG|INFO|WARN|ERROR)\]/, ""));
-}
-function getSyncStatus(deps = {}) {
-  const configDir = deps.configDir ?? getConfigDir();
-  const isProcessAlive = deps.isProcessAlive ?? defaultIsProcessAlive2;
-  const readLog = deps.readLog ?? defaultReadLog;
-  const lock = readLockFile(configDir);
-  const running = lock !== null && isProcessAlive(lock.pid);
-  const state = loadSyncState(configDir);
-  const retryAt = backoffUntil(state);
-  return {
-    running,
-    ...lock ? { pid: lock.pid, startedAt: lock.mtime.toISOString() } : {},
-    ...lock && !running ? { staleLock: true } : {},
-    state,
-    ...retryAt ? { backoffUntil: retryAt.toISOString() } : {},
-    recentActivity: recentSyncActivity(readLog())
-  };
-}
-var ACTIVITY_LINES = 10;
-var init_status = __esm(() => {
-  init_config();
-  init_logger();
-  init_lock();
-  init_watermark();
-});
-
-// src/sessions/project-dir.ts
-import {
-  closeSync as closeSync2,
-  existsSync as existsSync11,
-  mkdirSync as mkdirSync7,
-  openSync as openSync2,
-  readFileSync as readFileSync12,
-  readSync,
-  renameSync as renameSync3,
-  statSync as statSync5,
-  writeFileSync as writeFileSync8
-} from "node:fs";
-import { join as join10 } from "node:path";
-function cachePath(configDir) {
-  return join10(configDir, CACHE_FILENAME2);
-}
-function loadCacheFile(configDir) {
-  try {
-    const raw = JSON.parse(readFileSync12(cachePath(configDir), "utf-8"));
-    if (raw.schema_version !== CACHE_SCHEMA_VERSION || typeof raw.entries !== "object")
-      return {};
-    return raw.entries;
-  } catch {
-    return {};
-  }
-}
-function saveCacheFile(configDir, entries) {
-  try {
-    if (!existsSync11(configDir))
-      mkdirSync7(configDir, { recursive: true, mode: 448 });
-    const path3 = cachePath(configDir);
-    const tmp = `${path3}.${process.pid}.tmp`;
-    const file = { schema_version: CACHE_SCHEMA_VERSION, entries };
-    writeFileSync8(tmp, JSON.stringify(file), { mode: 384 });
-    renameSync3(tmp, path3);
-  } catch {}
-}
-function readHead(path3, bytes = HEAD_BYTES) {
-  let fd;
-  try {
-    fd = openSync2(path3, "r");
-  } catch {
-    return null;
-  }
-  try {
-    const buf = Buffer.alloc(bytes);
-    const read = readSync(fd, buf, 0, bytes, 0);
-    return buf.subarray(0, read).toString("utf-8");
-  } catch {
-    return null;
-  } finally {
-    closeSync2(fd);
-  }
-}
-function cwdFromJsonlHead(text) {
-  for (const line of text.split(`
-`).slice(0, HEAD_LINES)) {
-    if (!line.includes('"cwd"'))
-      continue;
-    try {
-      const obj = JSON.parse(line);
-      const cwd = obj.cwd ?? obj.payload?.cwd;
-      if (typeof cwd === "string" && cwd.startsWith("/"))
-        return cwd;
-    } catch {}
-  }
-  return null;
-}
-function unmungeSlug(slug, exists = existsSync11) {
-  const tokens = slug.replace(/^-/, "").split("-");
-  if (tokens.length === 0 || tokens[0] === "")
-    return null;
-  let budget = 5000;
-  const walk = (prefix, index) => {
-    if (budget-- <= 0)
-      return null;
-    if (index === tokens.length)
-      return exists(prefix) ? prefix : null;
-    const asSegment = prefix === "" || exists(prefix) ? walk(`${prefix}/${tokens[index]}`, index + 1) : null;
-    if (asSegment)
-      return asSegment;
-    return prefix === "" ? null : walk(`${prefix}-${tokens[index]}`, index + 1);
-  };
-  return walk("", 0);
-}
-function fileMtime(path3) {
-  try {
-    return statSync5(path3).mtime.toISOString();
-  } catch {
-    return "";
-  }
-}
-function createProjectDirResolver(configDir = getConfigDir(), deps = {}) {
-  const exists = deps.exists ?? existsSync11;
-  const head = deps.readHead ?? readHead;
-  const mtime = deps.mtime ?? fileMtime;
-  const entries = loadCacheFile(configDir);
-  let dirty = false;
-  const compute = (session) => {
-    switch (session.harness) {
-      case "opencode":
-        return session.project ?? null;
-      case "claude": {
-        const text = head(session.path);
-        const cwd = text ? cwdFromJsonlHead(text) : null;
-        if (cwd)
-          return cwd;
-        return session.project ? unmungeSlug(session.project, exists) : null;
-      }
-      case "codex": {
-        const text = head(session.path);
-        return text ? cwdFromJsonlHead(text) : null;
-      }
-      case "cursor":
-        return session.project ? unmungeSlug(session.project, exists) : null;
-      default:
-        return null;
-    }
-  };
-  return {
-    resolve(session) {
-      const key = `${session.harness}/${session.id}`;
-      const cached = entries[key];
-      if (cached && (cached.dir !== null || cached.mtime === mtime(session.path))) {
-        return cached.dir;
-      }
-      const dir = compute(session);
-      entries[key] = { dir, mtime: mtime(session.path) };
-      dirty = true;
-      return dir;
-    },
-    flush() {
-      if (!dirty)
-        return;
-      saveCacheFile(configDir, entries);
-      dirty = false;
-    }
-  };
-}
-var CACHE_FILENAME2 = "project-dirs.json", CACHE_SCHEMA_VERSION = 1, HEAD_BYTES, HEAD_LINES = 50;
-var init_project_dir = __esm(() => {
-  init_config();
-  HEAD_BYTES = 128 * 1024;
-});
-
 // src/sessions/scan.ts
-import { existsSync as existsSync12, readdirSync, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync9, readdirSync, statSync as statSync3 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { homedir as homedir3 } from "node:os";
-import { basename, join as join11 } from "node:path";
+import { basename, join as join8 } from "node:path";
 function listDir(dir) {
   try {
     return readdirSync(dir, { withFileTypes: true }).map((entry) => ({
       name: entry.name,
-      path: join11(dir, entry.name),
+      path: join8(dir, entry.name),
       isDir: entry.isDirectory()
     }));
   } catch {
@@ -8700,7 +8380,7 @@ function sessionFromFile(filePath, harness, project) {
     return null;
   let mtime;
   try {
-    mtime = statSync6(filePath).mtime;
+    mtime = statSync3(filePath).mtime;
   } catch {
     return null;
   }
@@ -8714,7 +8394,7 @@ function sessionFromFile(filePath, harness, project) {
 }
 function scanClaude(home) {
   const sessions = [];
-  for (const project of listDir(join11(home, ".claude", "projects"))) {
+  for (const project of listDir(join8(home, ".claude", "projects"))) {
     if (!project.isDir)
       continue;
     for (const entry of listDir(project.path)) {
@@ -8729,10 +8409,10 @@ function scanClaude(home) {
 }
 function scanCursor(home) {
   const sessions = [];
-  for (const project of listDir(join11(home, ".cursor", "projects"))) {
+  for (const project of listDir(join8(home, ".cursor", "projects"))) {
     if (!project.isDir)
       continue;
-    for (const entry of listDir(join11(project.path, "agent-transcripts"))) {
+    for (const entry of listDir(join8(project.path, "agent-transcripts"))) {
       const files = entry.isDir ? listDir(entry.path).filter((f2) => !f2.isDir) : [entry];
       for (const file of files) {
         const session = sessionFromFile(file.path, "cursor", project.name);
@@ -8744,9 +8424,9 @@ function scanCursor(home) {
   return sessions;
 }
 function scanCodex(home, env) {
-  const codexHome2 = env.CODEX_HOME ?? join11(home, ".codex");
+  const codexHome2 = env.CODEX_HOME ?? join8(home, ".codex");
   const sessions = [];
-  for (const year of listDir(join11(codexHome2, "sessions"))) {
+  for (const year of listDir(join8(codexHome2, "sessions"))) {
     if (!year.isDir)
       continue;
     for (const month of listDir(year.path)) {
@@ -8802,9 +8482,9 @@ function querySqlite(dbPath, sql) {
   }
 }
 function scanOpencode(home, env) {
-  const dataDir = env.XDG_DATA_HOME ?? join11(home, ".local", "share");
-  const dbPath = join11(dataDir, "opencode", "opencode.db");
-  if (!existsSync12(dbPath))
+  const dataDir = env.XDG_DATA_HOME ?? join8(home, ".local", "share");
+  const dbPath = join8(dataDir, "opencode", "opencode.db");
+  if (!existsSync9(dbPath))
     return [];
   const rows = querySqlite(dbPath, "SELECT id, directory, time_updated FROM session WHERE parent_id IS NULL");
   if (!rows)
@@ -8841,8 +8521,863 @@ function scanAgentSessions(options = {}) {
 }
 var init_scan = () => {};
 
+// src/sync/watermark.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync9, renameSync as renameSync2, writeFileSync as writeFileSync6 } from "node:fs";
+import { join as join9 } from "node:path";
+function syncStatePath(configDir = getConfigDir()) {
+  return join9(configDir, STATE_FILENAME);
+}
+function loadSyncState(configDir = getConfigDir()) {
+  const empty = {
+    schema_version: STATE_SCHEMA_VERSION,
+    watermark: null,
+    consecutive_failures: 0
+  };
+  const path3 = syncStatePath(configDir);
+  if (!existsSync10(path3))
+    return empty;
+  try {
+    const raw = JSON.parse(readFileSync9(path3, "utf-8"));
+    if (raw.schema_version !== STATE_SCHEMA_VERSION)
+      return empty;
+    const minedSessions = Array.isArray(raw.mined_sessions) ? raw.mined_sessions.filter((record) => typeof record === "object" && record !== null && typeof record.at === "string" && typeof record.session === "string").map((record) => ({
+      at: record.at,
+      session: record.session,
+      ...typeof record.project === "string" ? { project: record.project } : {}
+    })) : [];
+    const rawRefusal = raw.last_refusal;
+    const lastRefusal = rawRefusal && typeof rawRefusal.at === "string" && typeof rawRefusal.outcome === "string" && typeof rawRefusal.message === "string" ? { at: rawRefusal.at, outcome: rawRefusal.outcome, message: rawRefusal.message } : undefined;
+    const rawRun = raw.run;
+    const run2 = rawRun && typeof rawRun.pid === "number" && typeof rawRun.started_at === "string" && typeof rawRun.baseline_mined === "number" && rawRun.baseline_mined >= 0 ? { pid: rawRun.pid, started_at: rawRun.started_at, baseline_mined: rawRun.baseline_mined } : undefined;
+    return {
+      schema_version: STATE_SCHEMA_VERSION,
+      watermark: typeof raw.watermark === "string" ? raw.watermark : null,
+      last_attempt_at: typeof raw.last_attempt_at === "string" ? raw.last_attempt_at : undefined,
+      consecutive_failures: typeof raw.consecutive_failures === "number" && raw.consecutive_failures >= 0 ? raw.consecutive_failures : 0,
+      mined_sessions: minedSessions,
+      total_mined: typeof raw.total_mined === "number" && raw.total_mined >= 0 ? raw.total_mined : minedSessions.length,
+      total_notes: typeof raw.total_notes === "number" && raw.total_notes >= 0 ? raw.total_notes : 0,
+      total_learning_tokens: typeof raw.total_learning_tokens === "number" && raw.total_learning_tokens >= 0 ? raw.total_learning_tokens : 0,
+      ...lastRefusal ? { last_refusal: lastRefusal } : {},
+      ...run2 ? { run: run2 } : {},
+      ...raw.paused === true ? { paused: true } : {},
+      ...Array.isArray(raw.project_filter) ? {
+        project_filter: raw.project_filter.filter((p2) => typeof p2 === "string")
+      } : {}
+    };
+  } catch {
+    return empty;
+  }
+}
+function setSyncPaused(paused, configDir = getConfigDir()) {
+  const state = loadSyncState(configDir);
+  if (paused)
+    state.paused = true;
+  else
+    delete state.paused;
+  saveSyncState(state, configDir);
+}
+function saveSyncState(state, configDir = getConfigDir()) {
+  if (!existsSync10(configDir))
+    mkdirSync6(configDir, { recursive: true, mode: 448 });
+  const path3 = syncStatePath(configDir);
+  const tmp = `${path3}.${process.pid}.tmp`;
+  writeFileSync6(tmp, JSON.stringify(state, null, 2), { mode: 384 });
+  renameSync2(tmp, path3);
+}
+function backoffUntil(state) {
+  if (state.consecutive_failures === 0 || !state.last_attempt_at)
+    return null;
+  const last = Date.parse(state.last_attempt_at);
+  if (Number.isNaN(last))
+    return null;
+  const delay = Math.min(BACKOFF_BASE_MS * 2 ** (state.consecutive_failures - 1), BACKOFF_MAX_MS);
+  return new Date(last + delay);
+}
+function isUnderDir(dir, base) {
+  const root = base.endsWith("/") ? base.slice(0, -1) : base;
+  return dir === root || dir.startsWith(`${root}/`);
+}
+function filterSessionsByProject(sessions, filter, resolveDir) {
+  if (!filter || filter.length === 0)
+    return [...sessions];
+  const includeUnknown = filter.includes(UNKNOWN_PROJECT);
+  const dirs = filter.filter((entry) => entry !== UNKNOWN_PROJECT);
+  return sessions.filter((session) => {
+    const dir = resolveDir(session);
+    if (!dir)
+      return includeUnknown;
+    return dirs.some((base) => isUnderDir(dir, base));
+  });
+}
+function gateSessions(sessions, watermark, now = new Date, quietPeriodMs = DEFAULT_QUIET_PERIOD_MS) {
+  const watermarkMs = watermark ? Date.parse(watermark) : Number.NEGATIVE_INFINITY;
+  const completedBefore = now.getTime() - quietPeriodMs;
+  const ready = [];
+  const open2 = [];
+  for (const session of sessions) {
+    const updated = Date.parse(session.updated);
+    if (Number.isNaN(updated) || updated <= watermarkMs)
+      continue;
+    if (updated > completedBefore) {
+      open2.push(session);
+    } else {
+      ready.push(session);
+    }
+  }
+  return { ready, open: open2 };
+}
+var STATE_FILENAME = "knowledge-sync.json", STATE_SCHEMA_VERSION = 1, DEFAULT_QUIET_PERIOD_MS, BACKOFF_BASE_MS, BACKOFF_MAX_MS, MINED_HISTORY_LIMIT = 500, UNKNOWN_PROJECT = "(unknown)";
+var init_watermark = __esm(() => {
+  init_config();
+  DEFAULT_QUIET_PERIOD_MS = 5 * 60 * 1000;
+  BACKOFF_BASE_MS = 15 * 60 * 1000;
+  BACKOFF_MAX_MS = 24 * 60 * 60 * 1000;
+});
+
+// src/report/fetch.ts
+async function fetchReportNotes(cfg) {
+  const orgId = cfg.active_account?.target?.org_id;
+  if (!orgId || !cfg.active_account?.session.access_token) {
+    throw new Error("Not signed in. Run `dosu setup` to connect an account first.");
+  }
+  const { createTypedClient: createTypedClient2 } = await Promise.resolve().then(() => (init_trpc(), exports_trpc));
+  const client = createTypedClient2(cfg);
+  const { notes } = await client.notes.listMine.query({
+    org_id: orgId,
+    limit: REPORT_NOTES_LIMIT
+  });
+  return notes.map((note) => ({
+    title: note.title,
+    content: note.body,
+    at: note.created_at,
+    ...note.transcript_id ? { transcript_id: note.transcript_id } : {},
+    ...note.repo ? { repo: note.repo } : {},
+    ...note.branch ? { branch: note.branch } : {}
+  }));
+}
+var REPORT_NOTES_LIMIT = 500;
+
+// src/report/css.ts
+var REPORT_CSS = `
+  :root {
+    --ink: #14201c;
+    --muted: #5c6b64;
+    --line: #d5ddd8;
+    --bg: #f4f7f5;
+    --card: #ffffff;
+    --accent: #0b6e4f;
+    --accent-soft: #e3f2eb;
+    --warn: #8a5a00;
+    --warn-bg: #fff6e5;
+  }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0;
+    font-family: "Iowan Old Style", "Palatino Linotype", Palatino, Georgia, serif;
+    color: var(--ink);
+    background: var(--bg);
+    line-height: 1.45;
+  }
+  .wrap { max-width: 880px; margin: 0 auto; padding: 2.5rem 1.5rem 4rem; }
+  header.hero {
+    border-bottom: 2px solid var(--ink);
+    padding-bottom: 1.25rem;
+    margin-bottom: 1.75rem;
+  }
+  .eyebrow {
+    font-family: ui-sans-serif, system-ui, sans-serif;
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    font-size: 0.72rem;
+    color: var(--muted);
+    margin: 0 0 0.4rem;
+  }
+  h1 { font-size: 2rem; font-weight: 600; margin: 0 0 0.5rem; letter-spacing: -0.02em; }
+  h2 { font-size: 1.25rem; margin: 2rem 0 0.75rem; border-top: 1px solid var(--line); padding-top: 1.25rem; }
+  h3 { margin: 0; font-size: 1.05rem; }
+  .lede { color: var(--muted); margin: 0 0 1rem; }
+  .meta-line { font-family: ui-sans-serif, system-ui, sans-serif; font-size: 0.85rem; color: var(--muted); }
+  .toolbar { display: flex; flex-wrap: wrap; gap: 0.6rem; margin: 1rem 0 0; }
+  button, .btn {
+    font-family: ui-sans-serif, system-ui, sans-serif;
+    border: 1px solid var(--ink);
+    background: var(--ink);
+    color: #fff;
+    padding: 0.55rem 0.9rem;
+    border-radius: 4px;
+    cursor: pointer;
+    font-size: 0.9rem;
+    text-decoration: none;
+    display: inline-block;
+  }
+  .stats { display: grid; grid-template-columns: repeat(auto-fit, minmax(140px, 1fr)); gap: 0.75rem; margin: 1rem 0; }
+  .stat { background: var(--card); border: 1px solid var(--line); padding: 0.85rem 1rem; border-radius: 6px; }
+  .stat.highlight { background: var(--accent-soft); border-color: #b7d8c7; }
+  .stat .label {
+    font-family: ui-sans-serif, system-ui, sans-serif;
+    font-size: 0.72rem;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    color: var(--muted);
+  }
+  .stat .value { font-size: 1.35rem; font-weight: 600; margin-top: 0.25rem; }
+  .pct { font-size: 0.9rem; font-weight: 500; color: var(--accent); }
+  table { width: 100%; border-collapse: collapse; font-family: ui-sans-serif, system-ui, sans-serif; font-size: 0.82rem; background: var(--card); }
+  th, td { border-bottom: 1px solid var(--line); padding: 0.45rem 0.5rem; text-align: left; vertical-align: top; }
+  th { color: var(--muted); font-weight: 600; }
+  td.num { text-align: right; font-variant-numeric: tabular-nums; }
+  .card { background: var(--card); border: 1px solid var(--line); border-radius: 8px; padding: 1rem 1.1rem; margin: 0.75rem 0; }
+  .card header { display: flex; flex-wrap: wrap; gap: 0.4rem; align-items: baseline; }
+  .badge {
+    font-family: ui-sans-serif, system-ui, sans-serif;
+    font-size: 0.68rem;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    border: 1px solid var(--line);
+    padding: 0.1rem 0.4rem;
+    border-radius: 3px;
+    color: var(--muted);
+  }
+  .status-written { background: var(--accent-soft); color: var(--accent); border-color: #b7d8c7; }
+  .status-pending { background: var(--warn-bg); color: var(--warn); border-color: #efd59a; }
+  .status-proposed { background: #eef1f0; }
+  .status-already_in_library { background: #eef1f0; }
+  .note-body {
+    white-space: pre-wrap;
+    font-family: ui-sans-serif, system-ui, sans-serif;
+    font-size: 0.86rem;
+    background: var(--bg);
+    border-radius: 4px;
+    padding: 0.75rem;
+    overflow-x: auto;
+  }
+  .idea { font-size: 1.05rem; color: var(--ink); margin: 0.5rem 0 0.4rem; }
+  .work { font-family: ui-sans-serif, system-ui, sans-serif; font-size: 0.85rem; color: var(--muted); margin: 0.25rem 0 0.5rem; }
+  .work-label {
+    font-family: ui-sans-serif, system-ui, sans-serif;
+    font-size: 0.68rem;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+    color: var(--muted);
+    margin-right: 0.4rem;
+  }
+  .note-tech { margin-top: 0.6rem; }
+  .note-tech summary { cursor: pointer; font-family: ui-sans-serif, system-ui, sans-serif; font-size: 0.82rem; color: var(--muted); margin-top: 0.5rem; }
+  .trace { margin-top: 0.65rem; }
+  .trace > summary { cursor: pointer; font-family: ui-sans-serif, system-ui, sans-serif; font-size: 0.82rem; color: var(--muted); }
+  .trace-bar { display: flex; height: 8px; border-radius: 999px; overflow: hidden; background: #e8eee9; margin: 0.5rem 0 0.35rem; }
+  .tb { display: block; height: 100%; }
+  .tb.context { background: var(--accent); }
+  .tb.planning { background: #8a97a3; }
+  .tb.other { background: #b5a89a; }
+  .trace-legend { font-family: ui-sans-serif, system-ui, sans-serif; font-size: 0.75rem; color: var(--muted); margin: 0 0 0.45rem; }
+  .trace-steps { list-style: none; padding: 0; margin: 0.35rem 0 0; }
+  .trace-steps li {
+    display: grid;
+    grid-template-columns: auto 1fr auto;
+    column-gap: 0.4rem;
+    align-items: baseline;
+    font-family: ui-sans-serif, system-ui, sans-serif;
+    font-size: 0.78rem;
+    padding: 0.16rem 0;
+    border-bottom: 1px solid var(--line);
+  }
+  .trace-steps .chip { font-size: 0.6rem; text-transform: uppercase; letter-spacing: 0.04em; padding: 0.08rem 0.38rem; margin: 0; }
+  .trace-steps .pv { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+  .trace-steps .tok { font-variant-numeric: tabular-nums; color: var(--muted); text-align: right; }
+  .ts-head { color: var(--muted); font-size: 0.68rem; text-transform: uppercase; letter-spacing: 0.04em; border-bottom: 1px solid var(--line); }
+  .ts-head .chip { background: none; border: 0; padding-left: 0; color: inherit; }
+  .ts-head .pv, .ts-head .tok { color: inherit; overflow: visible; text-overflow: unset; }
+  .ts-user .chip { background: #eef1f0; }
+  .ts-context .chip { background: var(--accent-soft); color: var(--accent); border-color: #b7d8c7; }
+  .ts-planning .chip { background: #eef1f4; }
+  .ts-other .chip { background: #f3efe9; }
+  .ts-code { opacity: 0.55; color: var(--muted); }
+  .ts-omit .pv { font-style: italic; }
+  .meta, .query, .muted, .footnote {
+    font-family: ui-sans-serif, system-ui, sans-serif;
+    font-size: 0.85rem;
+    color: var(--muted);
+  }
+  code { font-size: 0.84em; }
+  footer.cta { margin-top: 2.5rem; padding: 1.25rem; background: var(--accent-soft); border: 1px solid #b7d8c7; border-radius: 8px; }
+  footer.cta h2 { border: 0; padding: 0; margin: 0 0 0.5rem; }
+  @media print {
+    body { background: #fff; }
+    .toolbar, .no-print { display: none !important; }
+    .wrap { max-width: none; padding: 0; }
+    .card, .stat { break-inside: avoid; }
+    a { color: inherit; text-decoration: none; }
+    details.trace > *:not(summary) { display: none !important; }
+  }
+`;
+
+// src/report/html.ts
+function esc(value) {
+  return String(value ?? "").replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function fmtInt(n2) {
+  const v = Number(n2);
+  if (!Number.isFinite(v))
+    return "—";
+  return Math.trunc(v).toLocaleString("en-US");
+}
+function applyStatusDefaults(candidates, dryRun) {
+  const fallback = dryRun ? "proposed" : "written";
+  const known = new Set(["written", "pending", "proposed", "already_in_library"]);
+  return candidates.map((c2) => {
+    const current = (c2.status ?? "").trim().toLowerCase();
+    return { ...c2, status: known.has(current) ? current : fallback };
+  });
+}
+function tokenTotalsFromCandidates(candidates, inventory) {
+  if (candidates.length === 0)
+    return null;
+  let replaced = 0;
+  let hasRediscovery = false;
+  let readCost = 0;
+  for (const c2 of candidates) {
+    const raw = c2.approx_rediscovery_tokens;
+    if (raw != null) {
+      hasRediscovery = true;
+      replaced += Math.max(0, Number(raw) || 0);
+    }
+    const blob = `${c2.title ?? ""}
+${c2.content ?? ""}`;
+    readCost += Math.round(blob.length / CHARS_PER_TOKEN);
+  }
+  if (!hasRediscovery)
+    return null;
+  let baseline = inventory.totals?.learning_tokens ?? 0;
+  if (!baseline) {
+    baseline = inventory.transcripts.reduce((sum, t2) => sum + (t2.learning_tokens || 0), 0);
+  }
+  const saved = Math.max(0, replaced - readCost);
+  const pct = baseline ? Math.round(1000 * saved / baseline) / 10 : 0;
+  return {
+    baseline_tokens: baseline,
+    replaced_baseline_tokens: replaced,
+    read_knowledge_tokens: readCost,
+    tokens_saved: saved,
+    pct_saved: pct
+  };
+}
+function presentationCopy(c2) {
+  const idea = (c2.plain_english || "").trim() || (c2.content || "").trim();
+  const how = (c2.how_found || "").trim();
+  if (how)
+    return [idea, how];
+  const raw = c2.approx_rediscovery_tokens ?? c2.baseline_tokens;
+  const n2 = raw == null ? 0 : Number(raw) || 0;
+  const work = n2 ? `About ${n2.toLocaleString("en-US")} tokens of reading, searching, and tracing in this session before the conclusion.` : "Investigation stretch was not measured.";
+  return [idea, work];
+}
+function parseLineSpec(spec) {
+  const out = new Set;
+  if (spec == null)
+    return out;
+  const raw = Array.isArray(spec) ? spec.map(String).join(",") : String(spec);
+  if (!raw.trim())
+    return out;
+  for (const part of raw.split(",")) {
+    const trimmed = part.trim();
+    if (!trimmed)
+      continue;
+    if (trimmed.includes("-")) {
+      const [a3, b2] = trimmed.split("-", 2);
+      let start = Number.parseInt(a3.trim(), 10);
+      let end = Number.parseInt(b2.trim(), 10);
+      if (!Number.isFinite(start) || !Number.isFinite(end))
+        continue;
+      if (end < start)
+        [start, end] = [end, start];
+      for (let i2 = start;i2 <= end; i2++)
+        out.add(i2);
+    } else {
+      const n2 = Number.parseInt(trimmed, 10);
+      if (Number.isFinite(n2))
+        out.add(n2);
+    }
+  }
+  return out;
+}
+function expandDigestTurns(turns, spec) {
+  if (turns.length === 0 || spec.size === 0)
+    return [];
+  const minLine = Math.min(...spec);
+  const maxLine = Math.max(...spec);
+  let start = minLine;
+  for (const turn of turns) {
+    const line = Number(turn.line) || 0;
+    if (turn.role === "user" && line <= minLine)
+      start = line;
+  }
+  return turns.filter((turn) => {
+    const line = Number(turn.line) || 0;
+    return start <= line && line <= maxLine;
+  });
+}
+function collapsePreview(text, limit = PREVIEW_CHARS) {
+  const cleaned = (text || "").replace(TAG_RE, " ").replace(WS_RE, " ").trim();
+  if (cleaned.length > limit)
+    return `${cleaned.slice(0, limit - 1).trimEnd()}…`;
+  return cleaned;
+}
+function turnText(turn) {
+  const texts = turn.text ?? [];
+  if (typeof texts === "string")
+    return texts;
+  return texts.filter(Boolean).join(" ");
+}
+function innerToolName(tool) {
+  const name = String(tool.name ?? "");
+  for (const key of ["toolName", "tool_name"]) {
+    const val = tool[key];
+    if (val)
+      return String(val);
+  }
+  if (tool.knowledge?.tool)
+    return String(tool.knowledge.tool);
+  if (name.startsWith("mcp:"))
+    return name.split(":", 2)[1] ?? name;
+  if (name.startsWith("mcp__"))
+    return name.split("__").at(-1) ?? name;
+  return name;
+}
+function displayToolName(tool) {
+  const inner = innerToolName(tool);
+  const wrapper = String(tool.name ?? "");
+  if (inner === "GetMcpTools" || wrapper === "GetMcpTools")
+    return "MCP schema";
+  if (SQL_DISPLAY.has(inner))
+    return "SQL";
+  if (LOGS_DISPLAY.has(inner))
+    return "Logs";
+  return inner || wrapper || "tool";
+}
+function firstArgPreview(args, keys) {
+  if (typeof args !== "object" || args === null)
+    return "";
+  const row = args;
+  for (const key of keys) {
+    if (row[key]) {
+      const pv = collapsePreview(String(row[key]));
+      if (pv)
+        return pv;
+    }
+  }
+  return "";
+}
+function toolPreview(tool, text) {
+  const name = String(tool.name ?? "");
+  const inner = innerToolName(tool);
+  if (tool.path) {
+    const raw = String(tool.path);
+    const leaf = raw.includes("/") ? raw.split("/").at(-1) : raw;
+    const pv = collapsePreview(leaf ?? "");
+    if (pv)
+      return pv;
+  }
+  if (tool.pattern) {
+    const pv = collapsePreview(String(tool.pattern));
+    if (pv)
+      return pv;
+  }
+  if (tool.command_preview) {
+    const pv = collapsePreview(String(tool.command_preview));
+    if (pv)
+      return pv;
+  }
+  if (tool.query) {
+    const pv = collapsePreview(String(tool.query));
+    if (pv)
+      return pv;
+  }
+  if (tool.file_path) {
+    const raw = String(tool.file_path);
+    const leaf = raw.includes("/") ? raw.split("/").at(-1) : raw;
+    const pv = collapsePreview(leaf ?? "");
+    if (pv)
+      return pv;
+  }
+  if (tool.prompt) {
+    const pv = collapsePreview(String(tool.prompt));
+    if (pv)
+      return pv;
+  }
+  if (tool.knowledge) {
+    const pv = firstArgPreview(tool.knowledge.arguments, ["query", "sql", "command"]);
+    if (pv)
+      return pv;
+  }
+  const fromArgs = firstArgPreview(tool.arguments, ["query", "sql", "command", "description"]);
+  if (fromArgs)
+    return fromArgs;
+  const toolName = tool.toolName || tool.tool_name;
+  if (toolName) {
+    const combo = tool.server ? `${toolName} · ${tool.server}` : String(toolName);
+    const pv = collapsePreview(combo);
+    if (pv)
+      return pv;
+  }
+  const fromText = collapsePreview(text);
+  if (fromText)
+    return fromText;
+  if (name === "GetMcpTools" || inner === "GetMcpTools")
+    return "Look up available MCP tools";
+  if (name === "CallMcpTool") {
+    const extra = toolName || (inner !== "CallMcpTool" ? inner : "");
+    return extra ? `MCP call · ${extra}` : "MCP call";
+  }
+  return "No input recorded";
+}
+function classifyDigestTool(tool) {
+  const name = String(tool.name ?? "");
+  const inner = innerToolName(tool);
+  const canonical = inner || name;
+  if (["Write", "Edit", "MultiEdit", "StrReplace", "Delete"].includes(canonical))
+    return "code";
+  if (["TodoWrite", "update_plan", "SwitchMode"].includes(canonical))
+    return "planning";
+  if (["write_knowledge", "finalize_session_knowledge"].includes(canonical))
+    return "other";
+  return "context";
+}
+function usableTools(turn) {
+  return (turn.tools ?? []).filter((tool) => !SKIP_TOOL_NAMES.has(String(tool.name ?? "")));
+}
+function buildTraceSteps(turns) {
+  const steps = [];
+  for (const turn of turns) {
+    const role = turn.role ?? "";
+    const est = Number(turn.est_tokens) || 0;
+    const text = turnText(turn);
+    const tools = usableTools(turn);
+    if (role === "user") {
+      if (!text)
+        continue;
+      steps.push({
+        kind: "user",
+        bucket: "other",
+        label: "Question",
+        preview: collapsePreview(text) || "No input recorded",
+        tokens: est
+      });
+      continue;
+    }
+    if (tools.length > 0) {
+      const share2 = Math.trunc(est / tools.length);
+      const remainder = est - share2 * tools.length;
+      tools.forEach((tool, i2) => {
+        const bucket = classifyDigestTool(tool);
+        const preview = toolPreview(tool, text);
+        steps.push({
+          kind: "tool",
+          bucket,
+          label: displayToolName(tool),
+          preview: bucket === "code" ? `${preview} · implementation (not counted)` : preview,
+          tokens: share2 + (i2 === 0 ? remainder : 0)
+        });
+      });
+      continue;
+    }
+    if (text) {
+      steps.push({
+        kind: "reasoning",
+        bucket: "other",
+        label: "Reasoning",
+        preview: collapsePreview(text),
+        tokens: est
+      });
+    }
+  }
+  return steps;
+}
+function capTraceSteps(steps) {
+  if (steps.length <= MAX_TRACE_STEPS)
+    return steps;
+  const omitted = steps.length - MAX_TRACE_STEPS;
+  return [steps[0], { omitted }, ...steps.slice(-(MAX_TRACE_STEPS - 1))];
+}
+function renderTraceHtml(candidate, digests) {
+  const tid = String(candidate.transcript_id ?? "").trim();
+  const digest = tid ? digests?.[tid] : undefined;
+  if (!digest)
+    return "";
+  const spec = parseLineSpec(candidate.investigation_lines);
+  if (spec.size === 0)
+    return "";
+  const turns = expandDigestTurns(digest.turns, spec);
+  if (turns.length === 0)
+    return "";
+  const steps = buildTraceSteps(turns);
+  if (steps.length === 0)
+    return "";
+  const learning = { context: 0, planning: 0, other: 0 };
+  const toolCounts = new Map;
+  let reasoningN = 0;
+  for (const step of steps) {
+    const bucket = step.bucket;
+    const tokens = Number(step.tokens) || 0;
+    if (bucket === "context" || bucket === "planning" || bucket === "other") {
+      learning[bucket] += tokens;
+    }
+    if (step.kind === "reasoning")
+      reasoningN += 1;
+    else if (step.kind === "tool" && bucket !== "code") {
+      const label = String(step.label || "tool");
+      toolCounts.set(label, (toolCounts.get(label) ?? 0) + 1);
+    }
+  }
+  const learningTotal = learning.context + learning.planning + learning.other;
+  const official = candidate.approx_rediscovery_tokens;
+  const summaryTokens = official != null && Number.isFinite(Number(official)) ? Number(official) : learningTotal;
+  const bits = [...toolCounts.entries()].sort((a3, b2) => b2[1] - a3[1]).slice(0, 5).map(([name, n2]) => `${n2} ${name}`);
+  if (reasoningN)
+    bits.push(`${reasoningN} reasoning`);
+  bits.push(`~${fmtInt(summaryTokens)} tok`);
+  const summary = `Work to learn this · ${bits.join(" · ")}`;
+  const learnSum = learningTotal || 1;
+  const bar = ["context", "planning", "other"].map((bucket) => {
+    const pct = learningTotal ? 100 * learning[bucket] / learnSum : 0;
+    return `<span class="tb ${bucket}" style="width:${pct.toFixed(1)}%"></span>`;
+  }).join("");
+  const legendParts = [];
+  if (learning.context)
+    legendParts.push(`Reads &amp; search ${fmtInt(learning.context)}`);
+  if (learning.planning)
+    legendParts.push(`Planning ${fmtInt(learning.planning)}`);
+  if (learning.other)
+    legendParts.push(`Reasoning ${fmtInt(learning.other)}`);
+  const rows = [
+    '<li class="ts-head" aria-hidden="true"><span class="chip">Action</span><span class="pv">What it did</span><span class="tok">Tokens</span></li>'
+  ];
+  for (const step of capTraceSteps(steps)) {
+    if (step.omitted) {
+      rows.push(`<li class="ts-omit"><span class="chip"></span><span class="pv">${esc(step.omitted)} earlier steps omitted</span><span class="tok"></span></li>`);
+      continue;
+    }
+    const bucket = String(step.bucket || "other");
+    const css = step.kind === "user" ? "ts-user" : { context: "ts-context", planning: "ts-planning", other: "ts-other", code: "ts-code" }[bucket] ?? "ts-other";
+    const tok = step.tokens ? `<span class="tok">${esc(fmtInt(step.tokens))}</span>` : '<span class="tok"></span>';
+    rows.push(`<li class="${css}"><span class="chip">${esc(step.label)}</span><span class="pv">${esc(step.preview)}</span>${tok}</li>`);
+  }
+  return `
+<details class="trace">
+  <summary>${esc(summary)}</summary>
+  <div class="trace-bar" title="context / planning / other">${bar}</div>
+  <p class="trace-legend">${legendParts.join(" · ")}</p>
+  <ol class="trace-steps">${rows.join("")}</ol>
+</details>
+`;
+}
+function notesSectionCopy(candidates) {
+  const n2 = candidates.length;
+  const written = candidates.filter((c2) => (c2.status || "written").toLowerCase() === "written").length;
+  const pending = candidates.filter((c2) => (c2.status || "").toLowerCase() === "pending").length;
+  const already = candidates.filter((c2) => (c2.status || "").toLowerCase() === "already_in_library").length;
+  const proposed = n2 - written - pending - already;
+  if (n2 > 0 && already === n2) {
+    return [
+      "Notes already in the Library",
+      "These pages were already present — no new write_knowledge calls.",
+      "Share",
+      "Nothing new to write; the Library already had these pages."
+    ];
+  }
+  if (n2 > 0 && written === n2) {
+    return [
+      "Notes written to Dosu",
+      "",
+      "Share",
+      "Notes are on the backfill branch and in the candidate-topic pipeline. Print / Save as PDF if you want a copy."
+    ];
+  }
+  if (n2 > 0 && proposed === n2) {
+    return [
+      "Proposed write_knowledge calls",
+      "Plain-English takeaway plus what it took to find — not the original user prompts.",
+      "Next step",
+      "Run the skill (without dry-run) so these payloads are written via write_knowledge."
+    ];
+  }
+  if (n2 === 0) {
+    return [
+      "write_knowledge notes",
+      "Plain-English takeaway plus what it took to find — not the original user prompts.",
+      "Next step",
+      "Run knowledge sync so learnings are extracted and written via write_knowledge."
+    ];
+  }
+  const bits = [];
+  if (written)
+    bits.push(`${written} written`);
+  if (proposed)
+    bits.push(`${proposed} proposed`);
+  if (pending)
+    bits.push(`${pending} pending`);
+  if (already)
+    bits.push(`${already} already in library`);
+  return [
+    "write_knowledge notes",
+    `${bits.join(", ")} — Plain-English takeaway plus what it took to find — not the original user prompts.`,
+    "Share",
+    "Written notes are in the candidate-topic pipeline. Proposed/pending items still need a write."
+  ];
+}
+function buildReportHtml(options) {
+  const inventory = options.inventory;
+  const transcripts = inventory.transcripts ?? [];
+  let candidates = applyStatusDefaults(options.candidates ?? [], Boolean(options.dryRun));
+  candidates = [...candidates].sort((a3, b2) => {
+    const av = Number(a3.approx_rediscovery_tokens) || 0;
+    const bv = Number(b2.approx_rediscovery_tokens) || 0;
+    return bv - av;
+  });
+  const org = options.orgName || "Your team";
+  const repo = options.repo || inventory.cwd || "—";
+  const branch = options.branch || "—";
+  const summary = options.summary || "Local agent session logs were mined into Dosu notes so the next task can reuse them — reducing rediscovery cost.";
+  const generated = `${(options.generatedAt ?? new Date).toISOString().replace("T", " ").slice(0, 16)} UTC`;
+  const derived = tokenTotalsFromCandidates(candidates, inventory);
+  const [notesHeading, notesLede, footerTitle, footerBody] = notesSectionCopy(candidates);
+  const candidateRows = candidates.map((c2, i2) => {
+    const [idea, work] = presentationCopy(c2);
+    const traceHtml = renderTraceHtml(c2, options.digests);
+    const content = (c2.content || "").trim();
+    const ideaHtml = idea ? `<p class="idea">${esc(idea)}</p>` : "<p class='muted'>Extract a lean note before writing to Dosu.</p>";
+    const workHtml = `<p class="work"><span class="work-label">To find this</span> ${esc(work)}</p>`;
+    const techHtml = content && content !== idea ? `<details class="note-tech"><summary>Technical note</summary><pre class="note-body">${esc(content)}</pre></details>` : "";
+    const status = c2.status || "written";
+    const queryHtml = c2.user_query ? `<p class="query"><strong>Trigger:</strong> ${esc(c2.user_query)}</p>` : "";
+    return `
+<article class="card" id="c-${i2 + 1}">
+  <header>
+    <span class="badge status-${esc(status)}">${esc(status)}</span>
+    <h3>${esc(c2.title || "Untitled")}</h3>
+  </header>
+  <p class="meta">
+    session ${esc(c2.session_title || c2.transcript_id || "—")}
+    · rediscovery ~${fmtInt(c2.approx_rediscovery_tokens ?? c2.baseline_tokens)} tok
+  </p>
+  ${ideaHtml}
+  ${workHtml}
+  ${traceHtml}
+  ${techHtml}
+  ${queryHtml}
+</article>`;
+  });
+  const heavy = [...transcripts].sort((a3, b2) => (b2.learning_tokens || 0) - (a3.learning_tokens || 0)).slice(0, 8);
+  const heavyRows = heavy.map((t2) => {
+    const title = (t2.title || "").trim() || t2.transcript_id;
+    const query = (t2.user_queries?.[0] || "").slice(0, 100);
+    return `<tr>
+      <td>${esc(t2.source)}</td>
+      <td>${esc(title)}</td>
+      <td class="num">${fmtInt(t2.learning_tokens)}</td>
+      <td class="num">${fmtInt(t2.rediscovery_tool_calls)}</td>
+      <td>${esc(query)}</td>
+    </tr>`;
+  }).join("");
+  let tokenSection;
+  if (derived) {
+    tokenSection = `
+<section>
+  <h2>Estimated context savings</h2>
+  <p class="lede">Counterfactual: replace rediscovery stretches with a Dosu <code>read_knowledge</code> hit.</p>
+  <div class="stats">
+    <div class="stat"><div class="label">Baseline (cost to learn)</div><div class="value">${fmtInt(derived.baseline_tokens)}</div></div>
+    <div class="stat"><div class="label">Learning replaced</div><div class="value">${fmtInt(derived.replaced_baseline_tokens)}</div></div>
+    <div class="stat"><div class="label">Read cost</div><div class="value">${fmtInt(derived.read_knowledge_tokens)}</div></div>
+    <div class="stat highlight"><div class="label">Est. tokens saved</div><div class="value">${fmtInt(derived.tokens_saved)} <span class="pct">(${esc(`${derived.pct_saved}%`)})</span></div></div>
+  </div>
+</section>`;
+  } else {
+    tokenSection = `
+<section>
+  <h2>Estimated context savings</h2>
+  <p class="muted">No rediscovery estimates on the notes yet — each candidate needs <code>approx_rediscovery_tokens</code>.</p>
+</section>`;
+  }
+  const notesBody = candidateRows.join("") || '<p class="muted">No write_knowledge payloads yet. Run knowledge sync so the miner extracts learnings.</p>';
+  const lede = notesLede ? `<p class="lede">${esc(notesLede)}</p>` : "";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Dosu knowledge report — ${esc(org)}</title>
+<style>
+${REPORT_CSS}
+</style>
+</head>
+<body>
+  <div class="wrap">
+    <header class="hero">
+      <p class="eyebrow">Dosu · Knowledge report</p>
+      <h1>${esc(org)}</h1>
+      <p class="lede">${esc(summary)}</p>
+      <p class="meta-line">
+        Repo <code>${esc(repo)}</code>
+        · branch <code>${esc(branch)}</code>
+        · generated ${esc(generated)}
+      </p>
+      <div class="toolbar no-print">
+        <button type="button" onclick="window.print()">Print / Save as PDF</button>
+      </div>
+    </header>
+
+    ${tokenSection}
+
+    <section>
+      <h2>${esc(notesHeading)} <span class="muted">(${candidates.length})</span></h2>
+      ${lede}
+      ${notesBody}
+    </section>
+
+    <section>
+      <h2>Heaviest sessions</h2>
+      <p class="lede">Where learning cost was highest — prime targets for Dosu cache hits.</p>
+      <table>
+        <thead>
+          <tr>
+            <th>Host</th><th>Session</th><th>Learning tokens</th><th>Rediscovery tools</th><th>Query</th>
+          </tr>
+        </thead>
+        <tbody>
+          ${heavyRows || '<tr><td colspan="5" class="muted">No sessions</td></tr>'}
+        </tbody>
+      </table>
+    </section>
+
+    <footer class="cta">
+      <h2>${esc(footerTitle)}</h2>
+      <p>${esc(footerBody)}</p>
+      <p class="meta">
+        Print tip: use <strong>Print / Save as PDF</strong> above (or ⌘P / Ctrl+P).
+        Session logs stay between you and your agent — only note text is written to Dosu.
+      </p>
+      <div class="toolbar no-print">
+        <button type="button" onclick="window.print()">Print / Save as PDF</button>
+      </div>
+    </footer>
+  </div>
+</body>
+</html>
+`;
+}
+var CHARS_PER_TOKEN = 4, MAX_TRACE_STEPS = 50, PREVIEW_CHARS = 80, SQL_DISPLAY, LOGS_DISPLAY, SKIP_TOOL_NAMES, TAG_RE, WS_RE;
+var init_html = __esm(() => {
+  SQL_DISPLAY = new Set(["execute_sql", "query_run", "list_tables"]);
+  LOGS_DISPLAY = new Set(["query_logs"]);
+  SKIP_TOOL_NAMES = new Set(["tool_result"]);
+  TAG_RE = /<[^>]+>/g;
+  WS_RE = /\s+/g;
+});
+
 // src/sessions/read.ts
-import { readFileSync as readFileSync13 } from "node:fs";
+import { readFileSync as readFileSync10 } from "node:fs";
 function asRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
 }
@@ -8958,11 +9493,11 @@ function readSessionTurns(session) {
   try {
     switch (session.harness) {
       case "claude":
-        return readClaude(readFileSync13(session.path, "utf8"));
+        return readClaude(readFileSync10(session.path, "utf8"));
       case "cursor":
-        return readCursor(readFileSync13(session.path, "utf8"));
+        return readCursor(readFileSync10(session.path, "utf8"));
       case "codex":
-        return readCodex(readFileSync13(session.path, "utf8"));
+        return readCodex(readFileSync10(session.path, "utf8"));
       case "opencode":
         return readOpencode(session.path, session.id);
     }
@@ -8970,11 +9505,58 @@ function readSessionTurns(session) {
     return [];
   }
 }
+function isRediscoveryTool(name) {
+  return REDISCOVERY_TOOLS.has(name) || name.startsWith("web_search");
+}
+function toolNamesFromContent(content) {
+  if (!Array.isArray(content))
+    return [];
+  const names = [];
+  for (const entry of content) {
+    const item = asRecord(entry);
+    if (item?.type === "tool_use" && typeof item.name === "string")
+      names.push(item.name);
+  }
+  return names;
+}
+function countRediscoveryToolCalls(session) {
+  try {
+    switch (session.harness) {
+      case "claude":
+      case "cursor": {
+        let n2 = 0;
+        for (const record of jsonlRecords(readFileSync10(session.path, "utf8"))) {
+          const message = asRecord(record.message);
+          for (const name of toolNamesFromContent(message?.content)) {
+            if (isRediscoveryTool(name))
+              n2 += 1;
+          }
+        }
+        return n2;
+      }
+      case "codex": {
+        let n2 = 0;
+        for (const record of jsonlRecords(readFileSync10(session.path, "utf8"))) {
+          const payload = asRecord(record.payload);
+          if (payload?.type === "function_call" && typeof payload.name === "string") {
+            if (isRediscoveryTool(payload.name))
+              n2 += 1;
+          }
+        }
+        return n2;
+      }
+      case "opencode":
+        return 0;
+    }
+  } catch {
+    return 0;
+  }
+}
 function estimateSessionTokens(session) {
   let chars = 0;
   for (const turn of readSessionTurns(session))
     chars += turn.text.length;
-  return Math.round(chars / CHARS_PER_TOKEN);
+  return Math.round(chars / CHARS_PER_TOKEN2);
 }
 function isWorthMining(session) {
   const turns = readSessionTurns(session);
@@ -8988,11 +9570,902 @@ function isWorthMining(session) {
   }
   return false;
 }
-var PLAIN_TEXT, CODEX_TEXT, CHARS_PER_TOKEN = 4, MIN_WORTH_TURNS = 4, MIN_WORTH_CHARS = 2000;
+var PLAIN_TEXT, CODEX_TEXT, REDISCOVERY_TOOLS, CHARS_PER_TOKEN2 = 4, MIN_WORTH_TURNS = 4, MIN_WORTH_CHARS = 2000;
 var init_read = __esm(() => {
   init_scan();
   PLAIN_TEXT = new Set(["text"]);
   CODEX_TEXT = new Set(["input_text", "output_text"]);
+  REDISCOVERY_TOOLS = new Set([
+    "Read",
+    "Grep",
+    "Glob",
+    "Shell",
+    "WebSearch",
+    "WebFetch",
+    "Task",
+    "SemanticSearch",
+    "Bash",
+    "Edit",
+    "MultiEdit",
+    "NotebookEdit",
+    "Agent",
+    "exec_command",
+    "write_stdin",
+    "web_search",
+    "web_search_call",
+    "open_page",
+    "apply_patch",
+    "update_plan",
+    "list_dir",
+    "grep_files",
+    "read_file"
+  ]);
+});
+
+// src/report/queries.ts
+function extractUserQueries(text) {
+  const matches = [...text.matchAll(USER_QUERY_RE)].map((m3) => m3[1].trim()).filter(Boolean);
+  if (matches.length > 0)
+    return matches;
+  const cleaned = text.replace(TIMESTAMP_RE, "").trim();
+  if (cleaned.startsWith("# AGENTS.md") || cleaned.startsWith("<INSTRUCTIONS>") || cleaned.startsWith("<permissions instructions>")) {
+    return [];
+  }
+  return cleaned ? [cleaned] : [];
+}
+function sessionTitleFromUserText(text, max = TITLE_CHARS) {
+  const first = extractUserQueries(text)[0] ?? "";
+  const collapsed = first.replace(/\s+/g, " ").trim();
+  if (collapsed.length > max)
+    return `${collapsed.slice(0, max - 1).trimEnd()}…`;
+  return collapsed;
+}
+var TITLE_CHARS = 80, USER_QUERY_RE, TIMESTAMP_RE;
+var init_queries = __esm(() => {
+  USER_QUERY_RE = /<user_query>\s*([\s\S]*?)\s*<\/user_query>/gi;
+  TIMESTAMP_RE = /<timestamp>[\s\S]*?<\/timestamp>/gi;
+});
+
+// src/report/digest.ts
+import { readFileSync as readFileSync11 } from "node:fs";
+function asRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function estimateTokens(text) {
+  return Math.round(text.length / CHARS_PER_TOKEN3);
+}
+function digestEstTokens(texts, tools, resultChars) {
+  const countable = tools.filter((t2) => t2.name !== "tool_result");
+  let payload = texts.join(`
+`);
+  if (countable.length > 0)
+    payload += JSON.stringify(countable);
+  let tokens = estimateTokens(payload);
+  if (resultChars > 0)
+    tokens += Math.max(1, Math.round(resultChars / CHARS_PER_TOKEN3));
+  return tokens;
+}
+function copyToolInputFields(entry, inp) {
+  const row = asRecord2(inp);
+  if (!row)
+    return;
+  if (typeof row.path === "string")
+    entry.path = row.path;
+  if (typeof row.file_path === "string") {
+    entry.file_path = row.file_path;
+    entry.path ??= row.file_path;
+  }
+  if (typeof row.pattern === "string")
+    entry.pattern = row.pattern;
+  if (row.command != null)
+    entry.command_preview = String(row.command).slice(0, 160);
+  if (row.prompt != null) {
+    entry.prompt = String(row.prompt).slice(0, 160);
+    entry.command_preview ??= entry.prompt;
+  }
+  if (typeof row.query === "string")
+    entry.query = row.query;
+  if (typeof row.description === "string" && !entry.command_preview) {
+    entry.command_preview = row.description.slice(0, 160);
+  }
+}
+function copyMcpFields(entry, name, inp) {
+  const row = asRecord2(inp);
+  if (!row)
+    return;
+  const isMcp = MCP_DIGEST_TOOLS.has(name) || name.startsWith("mcp__") || Boolean(row.toolName || row.server);
+  if (!isMcp)
+    return;
+  const toolName = row.toolName ?? row.tool_name;
+  if (typeof toolName === "string")
+    entry.toolName = toolName;
+  if (typeof row.server === "string")
+    entry.server = row.server;
+  if (name === "GetMcpTools" && typeof row.pattern === "string")
+    entry.pattern = row.pattern;
+  const args = asRecord2(row.arguments);
+  if (args)
+    entry.arguments = args;
+  else if (name.startsWith("mcp__"))
+    entry.arguments = row;
+}
+function blocksToDigest(content, maxTextChars) {
+  const texts = [];
+  const tools = [];
+  let resultChars = 0;
+  const blocks = Array.isArray(content) ? content : typeof content === "string" && content ? [{ type: "text", text: content }] : [];
+  for (const block2 of blocks) {
+    const item = asRecord2(block2);
+    if (!item)
+      continue;
+    const btype = item.type;
+    if ((btype === "text" || btype === "input_text" || btype === "output_text") && typeof item.text === "string" && item.text) {
+      let t2 = item.text;
+      if (t2.length > maxTextChars)
+        t2 = `${t2.slice(0, maxTextChars)}
+…[truncated]`;
+      texts.push(t2);
+    } else if (btype === "tool_use" && typeof item.name === "string") {
+      const entry = { name: item.name };
+      const inp = item.input ?? {};
+      copyToolInputFields(entry, inp);
+      copyMcpFields(entry, item.name, inp);
+      tools.push(entry);
+    } else if (btype === "tool_result") {
+      const c2 = item.content;
+      if (typeof c2 === "string")
+        resultChars += c2.length;
+      else if (c2 != null)
+        resultChars += JSON.stringify(c2).length;
+      tools.push({ name: "tool_result" });
+    }
+  }
+  return { texts, tools, resultChars };
+}
+function pushTurn2(turns, line, role, texts, tools, resultChars) {
+  if (role === "user" && texts.length > 0) {
+    const qs = extractUserQueries(texts.join(`
+`));
+    if (qs.length > 0)
+      texts.splice(0, texts.length, ...qs);
+  }
+  if (role === "user" && texts.length === 0)
+    return;
+  if (texts.length === 0 && tools.length === 0)
+    return;
+  turns.push({
+    line,
+    role,
+    text: texts,
+    tools,
+    est_tokens: digestEstTokens(texts, tools, resultChars)
+  });
+}
+function digestCursor(raw) {
+  const turns = [];
+  const lines = raw.split(`
+`);
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const line = lines[i2].trim();
+    if (!line)
+      continue;
+    let obj;
+    try {
+      const parsed = asRecord2(JSON.parse(line));
+      if (!parsed)
+        continue;
+      obj = parsed;
+    } catch {
+      continue;
+    }
+    const role = obj.role;
+    if (role !== "user" && role !== "assistant")
+      continue;
+    const message = asRecord2(obj.message);
+    const { texts, tools, resultChars } = blocksToDigest(message?.content, role === "assistant" ? MAX_ASSISTANT_CHARS : 2000);
+    pushTurn2(turns, i2 + 1, role, texts, tools, resultChars);
+  }
+  return turns;
+}
+function digestClaude(raw) {
+  const turns = [];
+  const lines = raw.split(`
+`);
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const line = lines[i2].trim();
+    if (!line)
+      continue;
+    let obj;
+    try {
+      const parsed = asRecord2(JSON.parse(line));
+      if (!parsed)
+        continue;
+      obj = parsed;
+    } catch {
+      continue;
+    }
+    const etype = obj.type;
+    if (etype !== "user" && etype !== "assistant")
+      continue;
+    if (obj.isSidechain === true)
+      continue;
+    const message = asRecord2(obj.message);
+    const { texts, tools, resultChars } = blocksToDigest(message?.content, etype === "assistant" ? MAX_ASSISTANT_CHARS : 2000);
+    pushTurn2(turns, i2 + 1, etype, texts, tools, resultChars);
+  }
+  return turns;
+}
+function digestCodex(raw) {
+  const turns = [];
+  const lines = raw.split(`
+`);
+  for (let i2 = 0;i2 < lines.length; i2++) {
+    const line = lines[i2].trim();
+    if (!line)
+      continue;
+    let obj;
+    try {
+      const parsed = asRecord2(JSON.parse(line));
+      if (!parsed)
+        continue;
+      obj = parsed;
+    } catch {
+      continue;
+    }
+    const payload = asRecord2(obj.payload) ?? {};
+    const etype = obj.type;
+    if (etype === "event_msg" && payload.type === "user_message") {
+      const msg = String(payload.message ?? "").slice(0, 2000);
+      if (msg) {
+        turns.push({
+          line: i2 + 1,
+          role: "user",
+          text: [msg],
+          tools: [],
+          est_tokens: estimateTokens(msg)
+        });
+      }
+    } else if (etype === "event_msg" && payload.type === "agent_message") {
+      let msg = String(payload.message ?? "");
+      if (msg.length > MAX_ASSISTANT_CHARS)
+        msg = `${msg.slice(0, MAX_ASSISTANT_CHARS)}
+…[truncated]`;
+      if (msg) {
+        turns.push({
+          line: i2 + 1,
+          role: "assistant",
+          text: [msg],
+          tools: [],
+          est_tokens: estimateTokens(msg)
+        });
+      }
+    } else if (etype === "response_item" && payload.type === "function_call") {
+      const name = typeof payload.name === "string" ? payload.name : "function_call";
+      const args = payload.arguments;
+      const preview = typeof args === "string" ? args.slice(0, 160) : JSON.stringify(args ?? "").slice(0, 160);
+      turns.push({
+        line: i2 + 1,
+        role: "assistant",
+        text: [],
+        tools: [{ name, command_preview: preview }],
+        est_tokens: estimateTokens(preview)
+      });
+    }
+  }
+  return turns;
+}
+function sessionToDigest(session) {
+  try {
+    switch (session.harness) {
+      case "claude":
+        return { turns: digestClaude(readFileSync11(session.path, "utf8")) };
+      case "cursor":
+        return { turns: digestCursor(readFileSync11(session.path, "utf8")) };
+      case "codex":
+        return { turns: digestCodex(readFileSync11(session.path, "utf8")) };
+      case "opencode": {
+        const turns = readSessionTurns(session).map((turn, index) => ({
+          role: turn.role,
+          line: index + 1,
+          est_tokens: Math.round(turn.text.length / CHARS_PER_TOKEN3),
+          text: [turn.text],
+          tools: []
+        }));
+        return { turns };
+      }
+    }
+  } catch {
+    return { turns: [] };
+  }
+}
+function digestsForSessions(sessions) {
+  const out = {};
+  for (const session of sessions) {
+    out[session.id] = sessionToDigest(session);
+  }
+  return out;
+}
+function digestTurnText(turn) {
+  const texts = turn.text ?? [];
+  if (typeof texts === "string")
+    return texts;
+  return texts.filter(Boolean).join(`
+`);
+}
+var CHARS_PER_TOKEN3 = 4, MAX_ASSISTANT_CHARS = 4000, MCP_DIGEST_TOOLS;
+var init_digest = __esm(() => {
+  init_read();
+  init_queries();
+  MCP_DIGEST_TOOLS = new Set(["CallMcpTool", "GetMcpTools"]);
+});
+
+// src/report/notes.ts
+function sessionIdFromReadInput(input) {
+  if (typeof input !== "object" || input === null || Array.isArray(input))
+    return;
+  const id = input.id;
+  return typeof id === "string" && id.trim() ? id : undefined;
+}
+function significantWords(text) {
+  const out = new Set;
+  for (const raw of text.toLowerCase().match(/[a-z][a-z0-9._-]{2,}/g) ?? []) {
+    const word = raw.replace(/^\.+|\.+$/g, "");
+    if (word.length >= 3 && !STOP_WORDS.has(word))
+      out.add(word);
+  }
+  return out;
+}
+function overlapCount(a3, b2) {
+  let n2 = 0;
+  for (const word of a3)
+    if (b2.has(word))
+      n2 += 1;
+  return n2;
+}
+function noteWords(note) {
+  return { title: significantWords(note.title), content: significantWords(note.content) };
+}
+function sessionCycles(turns) {
+  const starts = [];
+  for (let i2 = 0;i2 < turns.length; i2++) {
+    if (turns[i2].role === "user" && digestTurnText(turns[i2]).trim())
+      starts.push(i2);
+  }
+  return starts.map((start, i2) => {
+    const end = i2 + 1 < starts.length ? starts[i2 + 1] : turns.length;
+    const text = turns.slice(start, end).map((t2) => {
+      const paths = (t2.tools ?? []).map((tool) => tool.path || tool.pattern || tool.command_preview || "").filter(Boolean).join(" ");
+      return `${digestTurnText(t2)} ${paths}`;
+    }).join(`
+`);
+    return { start, end, text };
+  });
+}
+function cycleMatchScore(words, cycleText) {
+  const cycleWords = significantWords(cycleText);
+  return overlapCount(words.title, cycleWords) * 2 + overlapCount(words.content, cycleWords);
+}
+function cleanedUserQuery(text) {
+  const queries = extractUserQueries(text);
+  return (queries[0] ?? text).replace(/\s+/g, " ").trim();
+}
+function attributeRediscovery(notes, sessions) {
+  const byId = new Map(sessions.map((s) => [s.id, s]));
+  const candidates = notes.map((note) => ({
+    title: note.title,
+    content: note.content,
+    transcript_id: note.transcript_id,
+    repo: note.repo,
+    branch: note.branch,
+    status: "written"
+  }));
+  const indexesBySession = new Map;
+  for (let i2 = 0;i2 < notes.length; i2++) {
+    const id = notes[i2].transcript_id;
+    if (!id || !byId.has(id))
+      continue;
+    const list = indexesBySession.get(id) ?? [];
+    list.push(i2);
+    indexesBySession.set(id, list);
+  }
+  for (const [sessionId, indexes] of indexesBySession) {
+    const session = byId.get(sessionId);
+    if (!session)
+      continue;
+    const turns = sessionToDigest(session).turns;
+    const firstUser = turns.find((t2) => t2.role === "user");
+    const firstText = firstUser ? digestTurnText(firstUser) : "";
+    const sessionTitle = firstText ? sessionTitleFromUserText(firstText) : undefined;
+    for (const i2 of indexes) {
+      if (sessionTitle)
+        candidates[i2].session_title = sessionTitle;
+      if (firstText)
+        candidates[i2].user_query = cleanedUserQuery(firstText).slice(0, 200);
+    }
+    if (turns.length === 0)
+      continue;
+    const cycles = sessionCycles(turns);
+    const taken = new Set;
+    const ranked = indexes.map((i2) => {
+      const words = noteWords(notes[i2]);
+      let bestScore = 0;
+      for (const cycle of cycles) {
+        const score = cycleMatchScore(words, cycle.text);
+        if (score > bestScore)
+          bestScore = score;
+      }
+      return { i: i2, words, bestScore };
+    }).sort((a3, b2) => b2.bestScore - a3.bestScore);
+    for (const item of ranked) {
+      if (item.bestScore <= 0)
+        continue;
+      let pick = -1;
+      let pickScore = 0;
+      for (let ci = 0;ci < cycles.length; ci++) {
+        if (taken.has(ci))
+          continue;
+        const score = cycleMatchScore(item.words, cycles[ci].text);
+        if (score > pickScore) {
+          pickScore = score;
+          pick = ci;
+        }
+      }
+      if (pick < 0 || pickScore <= 0)
+        continue;
+      taken.add(pick);
+      const cycle = cycles[pick];
+      const slice = turns.slice(cycle.start, cycle.end);
+      const tokens = slice.reduce((sum, t2) => sum + (Number(t2.est_tokens) || 0), 0);
+      candidates[item.i].approx_rediscovery_tokens = tokens;
+      const startLine = slice[0]?.line ?? cycle.start + 1;
+      const endLine = slice.at(-1)?.line ?? cycle.end;
+      candidates[item.i].investigation_lines = `${startLine}-${endLine}`;
+      const cycleUser = slice.find((t2) => t2.role === "user");
+      if (cycleUser) {
+        const q = digestTurnText(cycleUser);
+        candidates[item.i].user_query = cleanedUserQuery(q).slice(0, 200);
+        candidates[item.i].session_title = sessionTitleFromUserText(q);
+      }
+    }
+  }
+  return candidates;
+}
+function sessionsToInventory(sessions) {
+  const transcripts = sessions.map((session) => {
+    const turns = readSessionTurns(session);
+    const queries = turns.filter((t2) => t2.role === "user").flatMap((t2) => extractUserQueries(t2.text));
+    const title = queries[0] ? sessionTitleFromUserText(queries[0]) : undefined;
+    return {
+      source: session.harness,
+      transcript_id: session.id,
+      ...title ? { title } : {},
+      learning_tokens: estimateSessionTokens(session),
+      rediscovery_tool_calls: countRediscoveryToolCalls(session),
+      user_queries: queries.slice(0, 3)
+    };
+  });
+  const learning_tokens = transcripts.reduce((sum, t2) => sum + t2.learning_tokens, 0);
+  return { transcripts, totals: { learning_tokens } };
+}
+var STOP_WORDS;
+var init_notes = __esm(() => {
+  init_read();
+  init_digest();
+  init_queries();
+  init_digest();
+  STOP_WORDS = new Set([
+    "about",
+    "after",
+    "also",
+    "and",
+    "are",
+    "but",
+    "can",
+    "does",
+    "for",
+    "from",
+    "have",
+    "into",
+    "just",
+    "must",
+    "not",
+    "that",
+    "the",
+    "this",
+    "they",
+    "with",
+    "what",
+    "when",
+    "which",
+    "will",
+    "your"
+  ]);
+});
+
+// src/report/write.ts
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname as dirname4, join as join10, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+function defaultReportPath() {
+  return join10(tmpdir(), "dosu-knowledge-report.html");
+}
+async function writeAndOpenReport(options) {
+  const out = resolve(options.out ?? defaultReportPath());
+  mkdirSync7(dirname4(out), { recursive: true });
+  writeFileSync7(out, options.html, "utf8");
+  if (options.open !== false) {
+    const url = pathToFileURL(out).href;
+    if (options.openUrl) {
+      await options.openUrl(url);
+    } else {
+      const open2 = await Promise.resolve().then(() => (init_open(), exports_open));
+      await open2.default(url);
+    }
+  }
+  return out;
+}
+var init_write = () => {};
+
+// src/report/generate.ts
+function sessionsForNotes(notes, sessions) {
+  const ids = new Set(notes.map((n2) => n2.transcript_id).filter((id) => Boolean(id)));
+  return sessions.filter((s) => ids.has(s.id));
+}
+function noteTime(note) {
+  const parsed = Date.parse(note.at ?? "");
+  return Number.isNaN(parsed) ? 0 : parsed;
+}
+async function emitKnowledgeReport(options = {}) {
+  const cfg = loadConfig();
+  const notes = [...options.notes ?? await (options.fetchNotes ?? fetchReportNotes)(cfg)].sort((a3, b2) => noteTime(a3) - noteTime(b2));
+  const scanned = options.sessions ?? scanAgentSessions();
+  const sessions = sessionsForNotes(notes, scanned);
+  const candidates = attributeRediscovery(notes, sessions);
+  const inventory = sessionsToInventory(sessions);
+  const state = loadSyncState();
+  if (inventory.totals && state.total_learning_tokens && !options.sessions) {
+    inventory.totals.learning_tokens = state.total_learning_tokens;
+  }
+  const html = buildReportHtml({
+    inventory,
+    candidates,
+    orgName: options.orgName ?? cfg.active_account?.target?.org_name ?? "Your team",
+    repo: options.repo ?? notes.find((n2) => n2.repo)?.repo,
+    branch: options.branch ?? notes.find((n2) => n2.branch)?.branch,
+    generatedAt: options.generatedAt,
+    digests: digestsForSessions(sessions)
+  });
+  return writeAndOpenReport({
+    html,
+    out: options.out ?? defaultReportPath(),
+    open: options.open,
+    openUrl: options.openUrl
+  });
+}
+var init_generate = __esm(() => {
+  init_config();
+  init_scan();
+  init_watermark();
+  init_html();
+  init_notes();
+  init_write();
+});
+
+// src/sessions/project-dir.ts
+import {
+  closeSync as closeSync2,
+  existsSync as existsSync11,
+  mkdirSync as mkdirSync8,
+  openSync as openSync2,
+  readFileSync as readFileSync12,
+  readSync,
+  renameSync as renameSync3,
+  statSync as statSync4,
+  writeFileSync as writeFileSync8
+} from "node:fs";
+import { join as join11 } from "node:path";
+function cachePath(configDir) {
+  return join11(configDir, CACHE_FILENAME2);
+}
+function loadCacheFile(configDir) {
+  try {
+    const raw = JSON.parse(readFileSync12(cachePath(configDir), "utf-8"));
+    if (raw.schema_version !== CACHE_SCHEMA_VERSION || typeof raw.entries !== "object")
+      return {};
+    return raw.entries;
+  } catch {
+    return {};
+  }
+}
+function saveCacheFile(configDir, entries) {
+  try {
+    if (!existsSync11(configDir))
+      mkdirSync8(configDir, { recursive: true, mode: 448 });
+    const path3 = cachePath(configDir);
+    const tmp = `${path3}.${process.pid}.tmp`;
+    const file = { schema_version: CACHE_SCHEMA_VERSION, entries };
+    writeFileSync8(tmp, JSON.stringify(file), { mode: 384 });
+    renameSync3(tmp, path3);
+  } catch {}
+}
+function readHead(path3, bytes = HEAD_BYTES) {
+  let fd;
+  try {
+    fd = openSync2(path3, "r");
+  } catch {
+    return null;
+  }
+  try {
+    const buf = Buffer.alloc(bytes);
+    const read = readSync(fd, buf, 0, bytes, 0);
+    return buf.subarray(0, read).toString("utf-8");
+  } catch {
+    return null;
+  } finally {
+    closeSync2(fd);
+  }
+}
+function cwdFromJsonlHead(text) {
+  for (const line of text.split(`
+`).slice(0, HEAD_LINES)) {
+    if (!line.includes('"cwd"'))
+      continue;
+    try {
+      const obj = JSON.parse(line);
+      const cwd = obj.cwd ?? obj.payload?.cwd;
+      if (typeof cwd === "string" && cwd.startsWith("/"))
+        return cwd;
+    } catch {}
+  }
+  return null;
+}
+function unmungeSlug(slug, exists = existsSync11) {
+  const tokens = slug.replace(/^-/, "").split("-");
+  if (tokens.length === 0 || tokens[0] === "")
+    return null;
+  let budget = 5000;
+  const walk = (prefix, index) => {
+    if (budget-- <= 0)
+      return null;
+    if (index === tokens.length)
+      return exists(prefix) ? prefix : null;
+    const asSegment = prefix === "" || exists(prefix) ? walk(`${prefix}/${tokens[index]}`, index + 1) : null;
+    if (asSegment)
+      return asSegment;
+    return prefix === "" ? null : walk(`${prefix}-${tokens[index]}`, index + 1);
+  };
+  return walk("", 0);
+}
+function fileMtime(path3) {
+  try {
+    return statSync4(path3).mtime.toISOString();
+  } catch {
+    return "";
+  }
+}
+function createProjectDirResolver(configDir = getConfigDir(), deps = {}) {
+  const exists = deps.exists ?? existsSync11;
+  const head = deps.readHead ?? readHead;
+  const mtime = deps.mtime ?? fileMtime;
+  const entries = loadCacheFile(configDir);
+  let dirty = false;
+  const compute = (session) => {
+    switch (session.harness) {
+      case "opencode":
+        return session.project ?? null;
+      case "claude": {
+        const text = head(session.path);
+        const cwd = text ? cwdFromJsonlHead(text) : null;
+        if (cwd)
+          return cwd;
+        return session.project ? unmungeSlug(session.project, exists) : null;
+      }
+      case "codex": {
+        const text = head(session.path);
+        return text ? cwdFromJsonlHead(text) : null;
+      }
+      case "cursor":
+        return session.project ? unmungeSlug(session.project, exists) : null;
+      default:
+        return null;
+    }
+  };
+  return {
+    resolve(session) {
+      const key = `${session.harness}/${session.id}`;
+      const cached = entries[key];
+      if (cached && (cached.dir !== null || cached.mtime === mtime(session.path))) {
+        return cached.dir;
+      }
+      const dir = compute(session);
+      entries[key] = { dir, mtime: mtime(session.path) };
+      dirty = true;
+      return dir;
+    },
+    flush() {
+      if (!dirty)
+        return;
+      saveCacheFile(configDir, entries);
+      dirty = false;
+    }
+  };
+}
+var CACHE_FILENAME2 = "project-dirs.json", CACHE_SCHEMA_VERSION = 1, HEAD_BYTES, HEAD_LINES = 50;
+var init_project_dir = __esm(() => {
+  init_config();
+  HEAD_BYTES = 128 * 1024;
+});
+
+// src/sync/backlog.ts
+function listSessionBacklog() {
+  try {
+    const state = loadSyncState();
+    let sessions = scanAgentSessions({});
+    if (state.project_filter?.length) {
+      const resolver = createProjectDirResolver();
+      sessions = filterSessionsByProject(sessions, state.project_filter, resolver.resolve);
+      resolver.flush();
+    }
+    const gate = gateSessions(sessions, state.watermark);
+    return { queued: gate.ready.reverse(), open: gate.open.reverse() };
+  } catch {
+    return { queued: [], open: [] };
+  }
+}
+var init_backlog = __esm(() => {
+  init_project_dir();
+  init_scan();
+  init_watermark();
+});
+
+// src/sync/lock.ts
+import { existsSync as existsSync12, readFileSync as readFileSync13, rmSync as rmSync2, statSync as statSync5, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join12 } from "node:path";
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function lockPath(configDir = getConfigDir()) {
+  return join12(configDir, LOCK_FILENAME);
+}
+function stopSyncRun(pid, configDir = getConfigDir(), kill = process.kill.bind(process)) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  let killed = false;
+  try {
+    kill(-pid, "SIGTERM");
+    killed = true;
+  } catch {
+    try {
+      kill(pid, "SIGTERM");
+      killed = true;
+    } catch {}
+  }
+  try {
+    const path3 = lockPath(configDir);
+    if (existsSync12(path3) && readFileSync13(path3, "utf8") === String(pid)) {
+      rmSync2(path3, { force: true });
+    }
+  } catch {}
+  return killed;
+}
+function fileLock(configDir = getConfigDir(), now = () => new Date) {
+  const path3 = lockPath(configDir);
+  let held = false;
+  const tryCreate = () => {
+    try {
+      writeFileSync9(path3, String(process.pid), { flag: "wx" });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  return {
+    acquire() {
+      if (tryCreate()) {
+        held = true;
+        return true;
+      }
+      try {
+        const age = now().getTime() - statSync5(path3).mtimeMs;
+        const holder = Number.parseInt(readFileSync13(path3, "utf8"), 10);
+        const holderDead = Number.isInteger(holder) && holder > 0 && !processAlive(holder);
+        if (age > STALE_LOCK_MS || holderDead) {
+          rmSync2(path3, { force: true });
+          held = tryCreate();
+          return held;
+        }
+      } catch {}
+      return false;
+    },
+    release() {
+      if (!held)
+        return;
+      held = false;
+      try {
+        if (existsSync12(path3) && readFileSync13(path3, "utf8") === String(process.pid)) {
+          rmSync2(path3, { force: true });
+        }
+      } catch {}
+    }
+  };
+}
+var LOCK_FILENAME = "knowledge-sync.lock", STALE_LOCK_MS;
+var init_lock = __esm(() => {
+  init_config();
+  STALE_LOCK_MS = 15 * 60 * 1000;
+});
+
+// src/sync/status.ts
+import { readFileSync as readFileSync14, statSync as statSync6 } from "node:fs";
+function formatTokenCount(tokens) {
+  if (tokens < 1000)
+    return String(tokens);
+  if (tokens < 1e6) {
+    const k = tokens / 1000;
+    return `~${k >= 100 ? Math.round(k) : k.toFixed(1).replace(/\.0$/, "")}k`;
+  }
+  const m3 = tokens / 1e6;
+  return `~${m3 >= 100 ? Math.round(m3) : m3.toFixed(1).replace(/\.0$/, "")}M`;
+}
+function defaultIsProcessAlive2(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function defaultReadLog() {
+  try {
+    return readFileSync14(logger.getLogPath(), "utf-8");
+  } catch {
+    return "";
+  }
+}
+function readLockFile(configDir) {
+  const path3 = lockPath(configDir);
+  try {
+    const pid = Number.parseInt(readFileSync14(path3, "utf-8"), 10);
+    return { pid: Number.isNaN(pid) ? -1 : pid, mtime: statSync6(path3).mtime };
+  } catch {
+    return null;
+  }
+}
+function recentSyncActivity(log3) {
+  return log3.split(`
+`).filter((line) => line.includes("[sync]") || line.includes("[miner]")).slice(-ACTIVITY_LINES).map((line) => line.replace(/ \[(DEBUG|INFO|WARN|ERROR)\]/, ""));
+}
+function getSyncStatus(deps = {}) {
+  const configDir = deps.configDir ?? getConfigDir();
+  const isProcessAlive = deps.isProcessAlive ?? defaultIsProcessAlive2;
+  const readLog = deps.readLog ?? defaultReadLog;
+  const lock = readLockFile(configDir);
+  const running = lock !== null && isProcessAlive(lock.pid);
+  const state = loadSyncState(configDir);
+  const retryAt = backoffUntil(state);
+  return {
+    running,
+    ...lock ? { pid: lock.pid, startedAt: lock.mtime.toISOString() } : {},
+    ...lock && !running ? { staleLock: true } : {},
+    state,
+    ...retryAt ? { backoffUntil: retryAt.toISOString() } : {},
+    recentActivity: recentSyncActivity(readLog())
+  };
+}
+var ACTIVITY_LINES = 10;
+var init_status = __esm(() => {
+  init_config();
+  init_logger();
+  init_lock();
+  init_watermark();
 });
 
 // src/sync/sync.ts
@@ -9016,11 +10489,18 @@ async function runKnowledgeSync(options = {}) {
   const now = deps.now ?? (() => new Date);
   const state = loadState();
   if (options.quiet) {
+    if (state.paused) {
+      logger.debug("sync", "skipping quiet sync: mining is paused");
+      return { status: "skipped-paused", readySessions: 0, inFlightSessions: 0, sessions: [] };
+    }
     const retryAt = backoffUntil(state);
     if (retryAt && now() < retryAt) {
       logger.debug("sync", `skipping quiet sync: backoff until ${retryAt.toISOString()}`);
       return { status: "skipped-backoff", readySessions: 0, inFlightSessions: 0, sessions: [] };
     }
+  } else if (state.paused) {
+    delete state.paused;
+    logger.debug("sync", "manual sync resumes paused mining");
   }
   let ready;
   let open2;
@@ -9031,14 +10511,14 @@ async function runKnowledgeSync(options = {}) {
     }));
     let sessions = await listSessions();
     if (state.project_filter?.length) {
-      let resolve = deps.resolveProjectDir;
+      let resolve2 = deps.resolveProjectDir;
       let flush;
-      if (!resolve) {
+      if (!resolve2) {
         const resolver = createProjectDirResolver();
-        resolve = resolver.resolve;
+        resolve2 = resolver.resolve;
         flush = resolver.flush;
       }
-      sessions = filterSessionsByProject(sessions, state.project_filter, resolve);
+      sessions = filterSessionsByProject(sessions, state.project_filter, resolve2);
       flush?.();
       logger.debug("sync", `project filter active: ${state.project_filter.join(", ")}`);
     }
@@ -9075,6 +10555,13 @@ async function runKnowledgeSync(options = {}) {
     return { status: "skipped-lock", ...base };
   }
   try {
+    if (state.run?.pid !== process.pid) {
+      state.run = {
+        pid: process.pid,
+        started_at: now().toISOString(),
+        baseline_mined: state.total_mined ?? 0
+      };
+    }
     const worthMining = deps.worthMining ?? isWorthMining;
     const examined = [];
     const batch = [];
@@ -9191,13 +10678,141 @@ var init_sync = __esm(() => {
   init_watermark();
 });
 
+// src/report/backfill.ts
+function noteTime2(at) {
+  const parsed = Date.parse(at ?? "");
+  return Number.isNaN(parsed) ? Number.NaN : parsed;
+}
+function correlateBackfill(input) {
+  const batches = new Map;
+  for (const e of input.ledger) {
+    const members = batches.get(e.at) ?? [];
+    members.push(e.session);
+    batches.set(e.at, members);
+  }
+  const batchTimes = [...batches.keys()].map((at) => ({ at, t: Date.parse(at) })).filter((b2) => !Number.isNaN(b2.t));
+  const sessionByKey = new Map(input.sessions.map((s) => [`${s.harness}/${s.id}`, s]));
+  const cyclesCache = new Map;
+  const cyclesFor = (session) => {
+    let cycles = cyclesCache.get(session.id);
+    if (!cycles) {
+      cycles = sessionCycles(sessionToDigest(session).turns);
+      cyclesCache.set(session.id, cycles);
+    }
+    return cycles;
+  };
+  const mappings = [];
+  let ambiguous = 0;
+  let noBatch = 0;
+  for (const note of input.notes) {
+    const time = noteTime2(note.at);
+    if (Number.isNaN(time)) {
+      noBatch += 1;
+      continue;
+    }
+    let batchAt;
+    let bestD = Number.POSITIVE_INFINITY;
+    for (const b2 of batchTimes) {
+      const d = Math.abs(b2.t - time);
+      if (d <= BATCH_TOLERANCE_MS && d < bestD) {
+        bestD = d;
+        batchAt = b2.at;
+      }
+    }
+    if (!batchAt) {
+      noBatch += 1;
+      continue;
+    }
+    const members = (batches.get(batchAt) ?? []).map((k) => sessionByKey.get(k)).filter((s) => s !== undefined);
+    if (members.length === 0) {
+      noBatch += 1;
+      continue;
+    }
+    const words = noteWords(note);
+    let best;
+    let second = 0;
+    for (const session of members) {
+      let score = 0;
+      for (const cycle of cyclesFor(session)) {
+        const s = cycleMatchScore(words, cycle.text);
+        if (s > score)
+          score = s;
+      }
+      if (!best || score > best.score) {
+        second = best?.score ?? 0;
+        best = { session, score };
+      } else if (score > second) {
+        second = score;
+      }
+    }
+    if (!best || best.score < MIN_SCORE || second > 0 && best.score < second * CLEAR_WIN_RATIO) {
+      ambiguous += 1;
+      continue;
+    }
+    mappings.push({ note_id: note.id, transcript_id: best.session.id });
+  }
+  return { mappings, ambiguous, noBatch };
+}
+var BATCH_TOLERANCE_MS, CLEAR_WIN_RATIO = 1.5, MIN_SCORE = 3;
+var init_backfill = __esm(() => {
+  init_digest();
+  init_notes();
+  BATCH_TOLERANCE_MS = 30 * 60 * 1000;
+});
+
+// src/report/backfill-run.ts
+var exports_backfill_run = {};
+__export(exports_backfill_run, {
+  runBackfill: () => runBackfill
+});
+async function defaultFetchUnattributed(cfg) {
+  const orgId = cfg.active_account?.target?.org_id;
+  if (!orgId || !cfg.active_account?.session.access_token) {
+    throw new Error("Not signed in. Run `dosu setup` to connect an account first.");
+  }
+  const { createTypedClient: createTypedClient2 } = await Promise.resolve().then(() => (init_trpc(), exports_trpc));
+  const client = createTypedClient2(cfg);
+  const { notes } = await client.notes.listMine.query({ org_id: orgId, limit: 500 });
+  return notes.filter((n2) => !n2.transcript_id).map((n2) => ({ id: n2.id, title: n2.title, content: n2.body, at: n2.created_at }));
+}
+async function defaultApply(cfg, mappings) {
+  const { createTypedClient: createTypedClient2 } = await Promise.resolve().then(() => (init_trpc(), exports_trpc));
+  const client = createTypedClient2(cfg);
+  let updated = 0;
+  for (let i2 = 0;i2 < mappings.length; i2 += MUTATION_CHUNK) {
+    const chunk = mappings.slice(i2, i2 + MUTATION_CHUNK);
+    const res = await client.notes.attributeTranscripts.mutate({ mappings: chunk });
+    updated += res.updated;
+  }
+  return updated;
+}
+async function runBackfill(deps = {}) {
+  const cfg = (deps.loadCfg ?? loadConfig)();
+  const notes = await (deps.fetchUnattributed ?? defaultFetchUnattributed)(cfg);
+  if (notes.length === 0) {
+    return { candidates: 0, mappings: [], ambiguous: 0, noBatch: 0, updated: 0 };
+  }
+  const ledger = (deps.ledger ?? (() => loadSyncState().mined_sessions ?? []))();
+  const sessions = (deps.scan ?? scanAgentSessions)();
+  const { mappings, ambiguous, noBatch } = correlateBackfill({ notes, ledger, sessions });
+  const updated = mappings.length > 0 ? await (deps.apply ?? defaultApply)(cfg, mappings) : 0;
+  return { candidates: notes.length, mappings, ambiguous, noBatch, updated };
+}
+var MUTATION_CHUNK = 500;
+var init_backfill_run = __esm(() => {
+  init_config();
+  init_scan();
+  init_watermark();
+  init_backfill();
+});
+
 // src/miner/config-dir.ts
-import { mkdtempSync, rmSync as rmSync3, writeFileSync as writeFileSync9 } from "node:fs";
-import { tmpdir } from "node:os";
-import { join as join12 } from "node:path";
+import { mkdtempSync, rmSync as rmSync3, writeFileSync as writeFileSync10 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join13 } from "node:path";
 function createRunConfigDir() {
-  const path3 = mkdtempSync(join12(tmpdir(), "dosu-miner-"));
-  writeFileSync9(join12(path3, ".claude.json"), JSON.stringify({ hasCompletedOnboarding: true }));
+  const path3 = mkdtempSync(join13(tmpdir2(), "dosu-miner-"));
+  writeFileSync10(join13(path3, ".claude.json"), JSON.stringify({ hasCompletedOnboarding: true }));
   return {
     path: path3,
     cleanup() {
@@ -9208,7 +10823,7 @@ function createRunConfigDir() {
 var init_config_dir = () => {};
 
 // src/miner/conflicts.ts
-import { existsSync as existsSync13, readFileSync as readFileSync14 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync15 } from "node:fs";
 function managedSettingsPaths(platform3 = process.platform) {
   switch (platform3) {
     case "darwin":
@@ -9241,7 +10856,7 @@ function detectSettingsConflicts(paths = managedSettingsPaths()) {
       continue;
     let settings2;
     try {
-      settings2 = JSON.parse(readFileSync14(file, "utf8"));
+      settings2 = JSON.parse(readFileSync15(file, "utf8"));
     } catch {
       conflicts.push({ file, keys: ["<unreadable or invalid JSON>"] });
       continue;
@@ -9303,7 +10918,7 @@ var init_env = __esm(() => {
 import { accessSync, constants, existsSync as existsSync14 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { homedir as homedir4 } from "node:os";
-import { delimiter as delimiter2, dirname as dirname4, join as join13 } from "node:path";
+import { delimiter as delimiter2, dirname as dirname5, join as join14 } from "node:path";
 function binaryNames(platform3 = process.platform) {
   return platform3 === "win32" ? ["claude.exe", "claude.cmd"] : ["claude"];
 }
@@ -9311,8 +10926,8 @@ function sdkNativeBinaryExists() {
   try {
     const requireRuntime = createRequire3(import.meta.url);
     const pkg = `@anthropic-ai/claude-agent-sdk-${process.platform}-${process.arch}`;
-    const pkgDir = dirname4(requireRuntime.resolve(`${pkg}/package.json`));
-    return binaryNames().some((name) => existsSync14(join13(pkgDir, name)));
+    const pkgDir = dirname5(requireRuntime.resolve(`${pkg}/package.json`));
+    return binaryNames().some((name) => existsSync14(join14(pkgDir, name)));
   } catch {
     return false;
   }
@@ -9328,10 +10943,10 @@ function isExecutable(path3) {
 function findSystemClaude(env = process.env, homeDir = homedir4()) {
   const names = binaryNames();
   const dirs = (env.PATH ?? "").split(delimiter2).filter(Boolean);
-  dirs.push(join13(homeDir, ".local", "bin"), join13(homeDir, ".claude", "local"));
+  dirs.push(join14(homeDir, ".local", "bin"), join14(homeDir, ".claude", "local"));
   for (const dir of dirs) {
     for (const name of names) {
-      const candidate = join13(dir, name);
+      const candidate = join14(dir, name);
       if (isExecutable(candidate))
         return candidate;
     }
@@ -9363,24 +10978,16 @@ function buildMinerPrompt(sessions) {
 
 ${list}
 
-Read each session with read_session, decide what (if anything) is durable per your rules, dedupe against read_knowledge, then write the distilled notes with write_knowledge. When you are done, reply with a one-line summary: how many sessions you read and how many notes you wrote.`;
+Work through them ONE AT A TIME: read a single session with read_session, decide what (if anything) is durable per your rules, dedupe against read_knowledge, and write that session's notes with write_knowledge BEFORE moving on to the next session. Each note is attributed to the session you read just before writing it, so do not read the next session until you have written this one's notes. When you are done, reply with a one-line summary: how many sessions you read and how many notes you wrote.`;
 }
 
 // src/miner/prompt-core.ts
-function extractMinerCore(markdown) {
-  const start = markdown.indexOf(MINER_CORE_START);
-  const end = markdown.indexOf(MINER_CORE_END);
-  if (start === -1 || end === -1 || end <= start) {
-    throw new Error(`miner-core markers not found (expected ${MINER_CORE_START} … ${MINER_CORE_END})`);
-  }
-  return markdown.slice(start + MINER_CORE_START.length, end).trim();
-}
-var MINER_CORE_START = "<!-- dosu:miner-core:start -->", MINER_CORE_END = "<!-- dosu:miner-core:end -->";
-
-// src/miner/prompt-core.generated.ts
 var MINER_CORE_RULES = `Rules — non-negotiable:
-1. Before writing anything, call read_knowledge with the candidate topic to check whether the
-knowledge already exists. Never write a duplicate or near-duplicate.
+1. Before writing anything, call read_knowledge with the candidate topic. If the same fact is
+already recorded, skip it — never write a duplicate or near-duplicate. If the topic exists but
+the session shows it has changed or been superseded, do write: a note stating the current state
+and what changed. Only restatements of already-recorded facts are duplicates; an update to an
+existing topic is not.
 2. Write ONLY durable, non-obvious knowledge:
 - decisions and their rationale (chose A over B because ...)
 - non-obvious constraints (API, schema, RLS, feature flags, deploy quirks)
@@ -9408,43 +11015,6 @@ verified, omit both.
 long verbatim transcript spans. Summarize in your own words.
 9. A trivial session with no real user query is normal: skip it silently.`;
 
-// src/miner/prompt-source.ts
-import { readFileSync as readFileSync15 } from "node:fs";
-import { homedir as homedir5 } from "node:os";
-import { join as join14 } from "node:path";
-function candidateSkillPromptPaths(env = process.env) {
-  const paths = [];
-  if (env.DOSU_SKILL_REPO?.trim()) {
-    paths.push(join14(env.DOSU_SKILL_REPO.trim(), "skills", SKILL_PROMPT_RELPATH));
-  }
-  paths.push(join14(homedir5(), ".agents", "skills", SKILL_PROMPT_RELPATH));
-  const claudeConfigDir = env.CLAUDE_CONFIG_DIR?.trim() || join14(homedir5(), ".claude");
-  paths.push(join14(claudeConfigDir, "skills", SKILL_PROMPT_RELPATH));
-  paths.push(join14(homedir5(), ".codeium", "windsurf", "skills", SKILL_PROMPT_RELPATH));
-  return paths;
-}
-function resolveMinerCoreRules(env = process.env) {
-  for (const path3 of candidateSkillPromptPaths(env)) {
-    let markdown;
-    try {
-      markdown = readFileSync15(path3, "utf-8");
-    } catch {
-      continue;
-    }
-    try {
-      return { rules: extractMinerCore(markdown), source: path3 };
-    } catch (err) {
-      logger.debug("miner", `skipping unusable skill rules at ${path3}: ${err}`);
-    }
-  }
-  return { rules: MINER_CORE_RULES, source: "bundled" };
-}
-var SKILL_PROMPT_RELPATH;
-var init_prompt_source = __esm(() => {
-  init_logger();
-  SKILL_PROMPT_RELPATH = join14("log-to-dosu-knowledge", "references", "miner-system-prompt.md");
-});
-
 // node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 var exports_sdk = {};
 __export(exports_sdk, {
@@ -52024,7 +53594,7 @@ __export(exports_util, {
   extend: () => extend,
   explicitlyAborted: () => explicitlyAborted,
   escapeRegex: () => escapeRegex,
-  esc: () => esc,
+  esc: () => esc2,
   defineLazyInternal: () => defineLazyInternal,
   defineLazy: () => defineLazy,
   createTransparentProxy: () => createTransparentProxy,
@@ -52175,7 +53745,7 @@ function randomString(length = 10) {
   }
   return str;
 }
-function esc(str) {
+function esc2(str) {
   return JSON.stringify(str);
 }
 function slugify(input) {
@@ -55296,7 +56866,7 @@ var init_schemas = __esm(() => {
         if (key === "__proto__")
           continue;
         const id2 = ids[key];
-        const k2 = typeof key === "symbol" ? `syms[${syms.indexOf(key)}]` : esc(key);
+        const k2 = typeof key === "symbol" ? `syms[${syms.indexOf(key)}]` : esc2(key);
         const isPresent = `${k2} in input`;
         const schema = shape[key];
         const optin = schema?._zod?.optin;
@@ -64533,16 +66103,16 @@ function generateStringFormatCheck(doc, ctx, def, accessor) {
       doc.write(`if (${accessor} !== ${accessor}.toUpperCase()) return INVALID;`);
       break;
     case "includes":
-      doc.write(`if (!${accessor}.includes(${esc(def.includes)})) return INVALID;`);
+      doc.write(`if (!${accessor}.includes(${esc2(def.includes)})) return INVALID;`);
       break;
     case "starts_with": {
       const prefix = def.prefix;
-      doc.write(`if (${accessor}.slice(0, ${prefix.length}) !== ${esc(prefix)}) return INVALID;`);
+      doc.write(`if (${accessor}.slice(0, ${prefix.length}) !== ${esc2(prefix)}) return INVALID;`);
       break;
     }
     case "ends_with": {
       const suffix = def.suffix;
-      doc.write(`if (${accessor}.slice(-${suffix.length}) !== ${esc(suffix)}) return INVALID;`);
+      doc.write(`if (${accessor}.slice(-${suffix.length}) !== ${esc2(suffix)}) return INVALID;`);
       break;
     }
     default: {
@@ -64746,8 +66316,8 @@ function generateObjectCheck(doc, ctx, schema, accessor, buildsValue = true) {
   const keys = Object.keys(shape);
   const symbolKeys = Object.getOwnPropertySymbols(shape);
   const allKeys = symbolKeys.length ? [...keys, ...symbolKeys] : keys;
-  const keyExpr = (k2) => typeof k2 === "symbol" ? addConstant(ctx, k2) : esc(k2);
-  const propKey = (k2) => typeof k2 === "symbol" ? `[${keyExpr(k2)}]` : esc(k2);
+  const keyExpr = (k2) => typeof k2 === "symbol" ? addConstant(ctx, k2) : esc2(k2);
+  const propKey = (k2) => typeof k2 === "symbol" ? `[${keyExpr(k2)}]` : esc2(k2);
   const propShape = shape;
   if (keys.includes("__proto__")) {
     throw new ZodCompileUnsupportedError('object shape key "__proto__"');
@@ -64791,7 +66361,7 @@ function generateObjectCheck(doc, ctx, schema, accessor, buildsValue = true) {
   if (catchall) {
     const catchallType = catchall._zod.def.type;
     if (catchallType === "never") {
-      const condition = keys.map((k2) => `k !== ${esc(k2)}`).join(" && ") || "true";
+      const condition = keys.map((k2) => `k !== ${esc2(k2)}`).join(" && ") || "true";
       doc.write(`for (const k in ${accessor}) {`);
       doc.indented((d3) => {
         d3.write(`if (${condition}) return INVALID;`);
@@ -65053,7 +66623,7 @@ function generateLiteralCheck(doc, ctx, schema, accessor) {
     return accessor;
   }
   if (typeof value === "string") {
-    doc.write(`if (${accessor} !== ${esc(value)}) return INVALID;`);
+    doc.write(`if (${accessor} !== ${esc2(value)}) return INVALID;`);
   } else if (typeof value === "number" || typeof value === "boolean") {
     doc.write(`if (${accessor} !== ${value}) return INVALID;`);
   } else if (value === null) {
@@ -65254,7 +66824,7 @@ function generateDiscriminatedUnionCheck(doc, ctx, def, accessor) {
   }
   const discVar = newVar(ctx);
   const outputVar = newVar(ctx);
-  doc.write(`const ${discVar} = ${accessor}?.[${esc(def.discriminator)}];`);
+  doc.write(`const ${discVar} = ${accessor}?.[${esc2(def.discriminator)}];`);
   doc.write(`let ${outputVar};`);
   let firstBranch = true;
   const claimed = new Set;
@@ -65284,7 +66854,7 @@ function generateDiscriminatedUnionCheck(doc, ctx, def, accessor) {
 }
 function literalEquality(ctx, accessor, value) {
   if (typeof value === "string")
-    return `${accessor} === ${esc(value)}`;
+    return `${accessor} === ${esc2(value)}`;
   if (typeof value === "number") {
     if (Number.isNaN(value))
       return `Number.isNaN(${accessor})`;
@@ -65398,7 +66968,7 @@ function generateRecordCheck(doc, ctx, schema, accessor) {
 }
 function literalPropertyKey(ctx, key) {
   if (typeof key === "string")
-    return esc(key);
+    return esc2(key);
   return addConstant(ctx, key);
 }
 function generateMapCheck(doc, ctx, schema, accessor) {
@@ -71334,6 +72904,15 @@ async function runMiner(options) {
       message: `Refusing to run: conflicting Claude Code settings would override the miner's auth (${detail})`
     };
   }
+  const gatewayURL = options.gatewayURL ?? getLlmGatewayURL();
+  if (!isAbsoluteHttpUrl(gatewayURL)) {
+    return {
+      outcome: "error",
+      notesWritten: 0,
+      turns: 0,
+      message: "LLM gateway URL is not set. From source, use `bun run dev` (production endpoints) or `bun run dev:local` (local stack)."
+    };
+  }
   const { query } = await Promise.resolve().then(() => (init_sdk(), exports_sdk));
   const claudeExecutable = resolveClaudeExecutable();
   if (claudeExecutable) {
@@ -71347,23 +72926,23 @@ async function runMiner(options) {
   const abort = new AbortController;
   const timer = setTimeout(() => abort.abort(), options.timeoutMs ?? DEFAULT_TIMEOUT_MS2);
   let notesWritten = 0;
+  let currentSession;
+  const readsSinceWrite = new Set;
   let turns = 0;
   const env = buildMinerEnv({
     apiKey: options.apiKey,
-    gatewayURL: options.gatewayURL ?? getLlmGatewayURL(),
+    gatewayURL,
     configDir: configDir.path,
     runID,
     trigger: options.trigger,
     cliVersion: getVersionString(),
     deploymentID: options.deploymentID
   });
-  const coreRules = resolveMinerCoreRules();
-  logger.debug("miner", `write-knowledge rules source: ${coreRules.source}`);
   try {
     const run2 = query({
       prompt: buildMinerPrompt(options.sessions),
       options: {
-        systemPrompt: buildMinerSystemPrompt(coreRules.rules),
+        systemPrompt: buildMinerSystemPrompt(MINER_CORE_RULES),
         env,
         abortController: abort,
         maxTurns: options.maxTurns ?? DEFAULT_MAX_TURNS,
@@ -71392,6 +72971,13 @@ async function runMiner(options) {
               message: `Tool ${toolName} is not permitted in mining runs.`
             };
           }
+          if (toolName === `mcp__${SESSIONS_SERVER_NAME}__read_session`) {
+            const id2 = sessionIdFromReadInput(input2);
+            if (id2) {
+              currentSession = id2;
+              readsSinceWrite.add(id2);
+            }
+          }
           if (toolName === `mcp__${KNOWLEDGE_SERVER_NAME}__write_knowledge`) {
             if (notesWritten >= maxNotes) {
               return {
@@ -71399,7 +72985,21 @@ async function runMiner(options) {
                 message: `Note cap reached (${maxNotes} per run); stop writing and summarize.`
               };
             }
+            if (readsSinceWrite.size > 1) {
+              readsSinceWrite.clear();
+              currentSession = undefined;
+              return {
+                behavior: "deny",
+                message: "Write each session's notes right after reading THAT session, before reading the next. You have read multiple sessions without writing, so a note cannot be attributed to one. Re-read only the session this note is about, then write it."
+              };
+            }
             notesWritten += 1;
+            readsSinceWrite.clear();
+            const { transcript_id: _authoredByModel, ...clean } = input2;
+            return {
+              behavior: "allow",
+              updatedInput: currentSession ? { ...clean, transcript_id: currentSession } : clean
+            };
           }
           return { behavior: "allow", updatedInput: input2 };
         }
@@ -71460,11 +73060,11 @@ var DEFAULT_MAX_TURNS = 160, DEFAULT_MAX_NOTES = 80, DEFAULT_TIMEOUT_MS2, KNOWLE
 var init_runner = __esm(() => {
   init_logger();
   init_config_helpers();
+  init_notes();
   init_config_dir();
   init_conflicts();
   init_env();
   init_executable();
-  init_prompt_source();
   init_tools();
   DEFAULT_TIMEOUT_MS2 = 30 * 60 * 1000;
   GATEWAY_ERRORS = {
@@ -71484,7 +73084,7 @@ var init_runner = __esm(() => {
 });
 
 // src/version/skill-update-check.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync9, readFileSync as readFileSync18, writeFileSync as writeFileSync10 } from "node:fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync10, readFileSync as readFileSync18, writeFileSync as writeFileSync11 } from "node:fs";
 import { join as join20 } from "node:path";
 function getCachePath2() {
   return join20(getConfigDir(), CACHE_FILENAME3);
@@ -71507,9 +73107,9 @@ function writeSkillCache(cache) {
   try {
     const dir = getConfigDir();
     if (!existsSync17(dir)) {
-      mkdirSync9(dir, { recursive: true, mode: 448 });
+      mkdirSync10(dir, { recursive: true, mode: 448 });
     }
-    writeFileSync10(getCachePath2(), JSON.stringify(cache), { mode: 384 });
+    writeFileSync11(getCachePath2(), JSON.stringify(cache), { mode: 384 });
   } catch {}
 }
 function clearInstalledSha() {
@@ -71582,7 +73182,7 @@ var init_skill_update_check = __esm(() => {
 
 // src/commands/skill.ts
 import { exec as exec2, execSync as execSync2 } from "node:child_process";
-import { homedir as homedir7 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 import { join as join21 } from "node:path";
 function skillAgentIDsForProviders(providerIDs) {
   return [
@@ -71594,17 +73194,17 @@ function skillInstallTargetForProvider(providerID) {
   if (!agentID)
     return null;
   if (agentID === "claude-code") {
-    const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR?.trim() || join21(homedir7(), ".claude");
+    const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR?.trim() || join21(homedir6(), ".claude");
     return { path: join21(claudeConfigDir, "skills", SKILL_NAME), symlink: true };
   }
   if (agentID === "windsurf") {
     return {
-      path: join21(homedir7(), ".codeium", "windsurf", "skills", SKILL_NAME),
+      path: join21(homedir6(), ".codeium", "windsurf", "skills", SKILL_NAME),
       symlink: true
     };
   }
   return {
-    path: join21(homedir7(), ".agents", "skills", SKILL_NAME),
+    path: join21(homedir6(), ".agents", "skills", SKILL_NAME),
     symlink: false
   };
 }
@@ -71613,12 +73213,12 @@ function skillAgentArgs(providerIDs) {
   return agents.map((agent) => `-a ${agent}`).join(" ");
 }
 function execQuiet(command) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     exec2(command, { windowsHide: true }, (error61) => {
       if (error61)
         reject(error61);
       else
-        resolve5();
+        resolve6();
     });
   });
 }
@@ -71765,11 +73365,11 @@ import { randomUUID as randomUUID3 } from "node:crypto";
 import {
   existsSync as existsSync18,
   lstatSync as lstatSync2,
-  mkdirSync as mkdirSync10,
+  mkdirSync as mkdirSync11,
   readFileSync as readFileSync19,
   renameSync as renameSync5,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync11
+  writeFileSync as writeFileSync12
 } from "node:fs";
 import { join as join22 } from "node:path";
 function getTelemetrySettingsPath() {
@@ -71874,8 +73474,8 @@ function writeTelemetrySettings(settings2) {
   const temporaryPath = `${path3}.${process.pid}.${randomUUID3()}.tmp`;
   try {
     if (!existsSync18(dir))
-      mkdirSync10(dir, { recursive: true, mode: 448 });
-    writeFileSync11(temporaryPath, `${JSON.stringify(settings2, null, 2)}
+      mkdirSync11(dir, { recursive: true, mode: 448 });
+    writeFileSync12(temporaryPath, `${JSON.stringify(settings2, null, 2)}
 `, {
       flag: "wx",
       mode: 384
@@ -71919,14 +73519,14 @@ var init_settings = __esm(() => {
 });
 
 // src/telemetry/debug-id.ts
-var BUNDLE_DEBUG_ID_PLACEHOLDER = "fd3fcdcd-886d-763b-6475-6e2164756e21";
+var BUNDLE_DEBUG_ID_PLACEHOLDER = "fa7cf492-7aa5-180c-6475-6e2164756e21";
 
 // src/telemetry/telemetry.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
 import { existsSync as existsSync19 } from "node:fs";
 import { request as httpRequest2 } from "node:http";
 import { request as httpsRequest } from "node:https";
-import { isAbsolute as isAbsolute4, relative as relative2, resolve as resolve5, sep as sep5 } from "node:path";
+import { isAbsolute as isAbsolute4, relative as relative2, resolve as resolve6, sep as sep5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function safeString(value, pattern, fallback) {
   if (typeof value !== "string" || !pattern.test(value))
@@ -72052,7 +73652,7 @@ function parseOwnedStackLine(originalLine, packageRoot) {
   }
   if (!isAbsolute4(absolutePath))
     return;
-  const resolvedPath = resolve5(absolutePath);
+  const resolvedPath = resolve6(absolutePath);
   const relativePath = relative2(packageRoot, resolvedPath);
   if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep5}`) || isAbsolute4(relativePath)) {
     return;
@@ -72290,7 +73890,7 @@ function fetchWithoutRedirect(url2, init = {}) {
   } catch (error61) {
     return Promise.reject(error61);
   }
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     let request;
     let response;
     let settled = false;
@@ -72314,7 +73914,7 @@ function fetchWithoutRedirect(url2, init = {}) {
       response?.destroy();
       request?.socket?.destroy();
       request?.destroy();
-      resolve6(value);
+      resolve7(value);
     };
     const onAbort = () => {
       const error61 = new Error("telemetry request aborted");
@@ -73235,15 +74835,15 @@ var init_vscode = __esm(() => {
 });
 
 // src/mcp/providers/windsurf.ts
-import { homedir as homedir9 } from "node:os";
+import { homedir as homedir8 } from "node:os";
 import { join as join35 } from "node:path";
 var WindsurfProvider = () => createJSONProvider({
   providerName: "Windsurf",
   providerID: "windsurf",
   local: false,
   priorityValue: 9,
-  paths: [join35(homedir9(), ".codeium", "windsurf")],
-  globalPath: join35(homedir9(), ".codeium", "windsurf", "mcp_config.json"),
+  paths: [join35(homedir8(), ".codeium", "windsurf")],
+  globalPath: join35(homedir8(), ".codeium", "windsurf", "mcp_config.json"),
   topKey: "mcpServers"
 });
 var init_windsurf = __esm(() => {
@@ -73332,7 +74932,7 @@ var init_providers = __esm(() => {
 });
 
 // src/version/update-check.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync11, readFileSync as readFileSync21, writeFileSync as writeFileSync12 } from "node:fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync21, writeFileSync as writeFileSync13 } from "node:fs";
 import { join as join37 } from "node:path";
 function isValidVersion(value) {
   return typeof value === "string" && SEMVER_PATTERN.test(value);
@@ -73375,9 +74975,9 @@ function writeCache(cache) {
   try {
     const dir = getConfigDir();
     if (!existsSync22(dir)) {
-      mkdirSync11(dir, { recursive: true, mode: 448 });
+      mkdirSync12(dir, { recursive: true, mode: 448 });
     }
-    writeFileSync12(getCachePath3(), JSON.stringify(cache), { mode: 384 });
+    writeFileSync13(getCachePath3(), JSON.stringify(cache), { mode: 384 });
   } catch {}
 }
 async function fetchLatestVersion() {
@@ -73487,14 +75087,14 @@ var init_update_check = __esm(() => {
 });
 
 // src/rules/installer.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync22, unlinkSync as unlinkSync4, writeFileSync as writeFileSync13 } from "node:fs";
-import { homedir as homedir10 } from "node:os";
-import { dirname as dirname8, join as join38 } from "node:path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync13, readFileSync as readFileSync22, unlinkSync as unlinkSync4, writeFileSync as writeFileSync14 } from "node:fs";
+import { homedir as homedir9 } from "node:os";
+import { dirname as dirname9, join as join38 } from "node:path";
 function claudeConfigDir() {
-  return process.env.CLAUDE_CONFIG_DIR || join38(homedir10(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR || join38(homedir9(), ".claude");
 }
 function codexHome3() {
-  return process.env.CODEX_HOME || join38(homedir10(), ".codex");
+  return process.env.CODEX_HOME || join38(homedir9(), ".codex");
 }
 function isRuleAgent(agent) {
   return Object.hasOwn(RULE_TARGETS, agent);
@@ -73520,17 +75120,17 @@ async function fetchDosuRule(fetchImpl = globalThis.fetch) {
   return normalizeRule(FALLBACK_DOSU_RULE);
 }
 function ensureParent(path3) {
-  mkdirSync12(dirname8(path3), { recursive: true });
+  mkdirSync13(dirname9(path3), { recursive: true });
 }
 function writeIfChanged(path3, content) {
   if (!existsSync23(path3)) {
     ensureParent(path3);
-    writeFileSync13(path3, content, "utf-8");
+    writeFileSync14(path3, content, "utf-8");
     return "created";
   }
   if (readFileSync22(path3, "utf-8") === content)
     return "unchanged";
-  writeFileSync13(path3, content, "utf-8");
+  writeFileSync14(path3, content, "utf-8");
   return "updated";
 }
 function findSection(content) {
@@ -73559,7 +75159,7 @@ function upsertSection(path3, content) {
   if (!existsSync23(path3)) {
     const section2 = buildSection(content);
     ensureParent(path3);
-    writeFileSync13(path3, `${section2}
+    writeFileSync14(path3, `${section2}
 `, "utf-8");
     return "created";
   }
@@ -73576,7 +75176,7 @@ function upsertSection(path3, content) {
   }
   if (next === existing)
     return "unchanged";
-  writeFileSync13(path3, next, "utf-8");
+  writeFileSync14(path3, next, "utf-8");
   return "updated";
 }
 function installRuleForAgent(agent, content) {
@@ -73608,7 +75208,7 @@ function removeRuleForAgent(agent) {
   if (!next) {
     unlinkSync4(path3);
   } else {
-    writeFileSync13(path3, `${next}${lineEnding}`, "utf-8");
+    writeFileSync14(path3, `${next}${lineEnding}`, "utf-8");
   }
   return { agent, path: path3, action: "removed" };
 }
@@ -73640,7 +75240,7 @@ var init_installer = __esm(() => {
     },
     cursor: {
       kind: "file",
-      path: () => join38(homedir10(), ".cursor", "rules", "dosu.mdc"),
+      path: () => join38(homedir9(), ".cursor", "rules", "dosu.mdc"),
       cursorFrontmatter: true
     },
     codex: {
@@ -73649,22 +75249,22 @@ var init_installer = __esm(() => {
     },
     opencode: {
       kind: "section",
-      path: () => join38(homedir10(), ".config", "opencode", "AGENTS.md")
+      path: () => join38(homedir9(), ".config", "opencode", "AGENTS.md")
     },
     gemini: {
       kind: "section",
-      path: () => join38(homedir10(), ".gemini", "GEMINI.md")
+      path: () => join38(homedir9(), ".gemini", "GEMINI.md")
     },
     antigravity: {
       kind: "section",
-      path: () => join38(homedir10(), ".gemini", "GEMINI.md")
+      path: () => join38(homedir9(), ".gemini", "GEMINI.md")
     }
   };
 });
 
 // src/setup/agents-md-step.ts
 import { execSync as execSync3 } from "node:child_process";
-import { existsSync as existsSync24, readFileSync as readFileSync23, writeFileSync as writeFileSync14 } from "node:fs";
+import { existsSync as existsSync24, readFileSync as readFileSync23, writeFileSync as writeFileSync15 } from "node:fs";
 import { join as join39 } from "node:path";
 function inGitWorkTree(cwd = process.cwd()) {
   try {
@@ -73720,7 +75320,7 @@ function upsertDosuAgentsSection(cwd = process.cwd(), content = FALLBACK_DOSU_RU
   const path3 = join39(cwd, "AGENTS.md");
   if (!existsSync24(path3)) {
     const section2 = buildDosuAgentsSection(content);
-    writeFileSync14(path3, `${section2}
+    writeFileSync15(path3, `${section2}
 `);
     return { path: path3, action: "created" };
   }
@@ -73736,7 +75336,7 @@ function upsertDosuAgentsSection(cwd = process.cwd(), content = FALLBACK_DOSU_RU
   }
   if (next === existing)
     return { path: path3, action: "unchanged" };
-  writeFileSync14(path3, next);
+  writeFileSync15(path3, next);
   return { path: path3, action: "updated" };
 }
 async function stepUpdateAgentsMd(cwd = process.cwd(), content) {
@@ -73832,6 +75432,8 @@ function reduceActivityViewKey(key) {
     return "down";
   if (key === "s")
     return "sync";
+  if (key === "f")
+    return "full";
   return "none";
 }
 function cycleTab(tab, delta = 1) {
@@ -73847,9 +75449,16 @@ function reduceSyncConfirmKey(key) {
     return "cancel";
   return "none";
 }
-function formatActivityLine(line, width) {
+function syncConfirmMode(status) {
+  if (status.running)
+    return "stop";
+  if (status.state.paused)
+    return "resume";
+  return "start";
+}
+function formatActivityLine(line, width, full = false) {
   const compact = stripAnsiCodes(line).replace(/^\[(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2})[^\]]*\]/, (_match, _date2, time3) => time3);
-  if (compact.length <= width)
+  if (full || compact.length <= width)
     return compact;
   return `${compact.slice(0, Math.max(0, width - 1))}…`;
 }
@@ -73861,34 +75470,33 @@ function appendSyncActivity(buffer, chunk, max = ACTIVITY_VIEW_BUFFER_LINES) {
 function clip(text, max) {
   return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
 }
-function formatMinedRow(record2) {
+function formatMinedRow(record2, full = false) {
   const match = record2.at.match(/^\d{4}-(\d{2}-\d{2})T(\d{2}:\d{2})/);
   const stamp = match ? `${match[1]} ${match[2]}` : record2.at;
   const slash = record2.session.indexOf("/");
   const harness = slash > 0 ? record2.session.slice(0, slash) : "-";
   const id2 = slash > 0 ? record2.session.slice(slash + 1) : record2.session;
-  const project = clip(record2.project ?? "-", 28);
-  return `${harness.padEnd(8)}  ${stamp}  ${project}  ${clip(id2, 24)}`;
+  const rawProject = record2.project ?? "-";
+  const project = full ? rawProject : clip(rawProject, 28);
+  return `${harness.padEnd(8)}  ${stamp}  ${project}  ${full ? id2 : clip(id2, 24)}`;
 }
-function formatQueuedRow(session) {
+function formatQueuedRow(session, full = false) {
   const stamp = session.updated.replace("T", " ").slice(5, 16);
-  const project = clip(session.project ?? "-", 28);
-  return `${session.harness.padEnd(8)}  ${stamp}  ${project}  ${clip(session.id, 24)}`;
-}
-function defaultListBacklog() {
-  try {
-    const state = loadSyncState();
-    let sessions = scanAgentSessions({});
-    if (state.project_filter?.length) {
-      const resolver = createProjectDirResolver();
-      sessions = filterSessionsByProject(sessions, state.project_filter, resolver.resolve);
-      resolver.flush();
-    }
-    const gate = gateSessions(sessions, state.watermark);
-    return { queued: gate.ready.reverse(), open: gate.open.reverse() };
-  } catch {
-    return { queued: [], open: [] };
+  const rawProject = session.project ?? "-";
+  const project = full ? rawProject : clip(rawProject, 28);
+  return `${session.harness.padEnd(8)}  ${stamp}  ${project}  ${full ? session.id : clip(session.id, 24)}`;
+}
+function wrapRow(text, width, indent = "    ") {
+  if (text.length <= width)
+    return [text];
+  const out = [text.slice(0, width)];
+  let rest = text.slice(width);
+  const inner = Math.max(1, width - indent.length);
+  while (rest.length > 0) {
+    out.push(indent + rest.slice(0, inner));
+    rest = rest.slice(inner);
   }
+  return out;
 }
 function windowList(lines, scroll, height = ACTIVITY_VIEW_LIST_LINES) {
   const clamped = Math.max(0, Math.min(scroll, Math.max(0, lines.length - height)));
@@ -73948,6 +75556,9 @@ function statusLine(status) {
     const pid = status.pid !== undefined ? ` (pid ${status.pid})` : "";
     return `⛏️ ${import_picocolors30.default.bold(brand("Mining sessions..."))}${import_picocolors30.default.dim(`${pid}${since}`)}`;
   }
+  if (status.state.paused) {
+    return `${import_picocolors30.default.yellow("○")} ${import_picocolors30.default.bold("Paused")} ${import_picocolors30.default.dim("· mining stays off until you resume")}`;
+  }
   if (status.staleLock) {
     return `${import_picocolors30.default.yellow("○")} ${import_picocolors30.default.bold("Not running")} ${import_picocolors30.default.dim("· a previous run exited without cleaning up")}`;
   }
@@ -73966,40 +75577,12 @@ function progressLine(done, ready, width, notes = 0) {
   return `${bar} ${done}/${total} mined · ${pct}%${suffix}`;
 }
 function tabBar(tab, queuedCount, openCount, minedCount, width) {
-  const labels = [
+  return tabStrip([
     ["activity", "Activity"],
     ["mined", `Mined (${minedCount})`],
     ["queued", `Queued (${queuedCount})`],
     ["open", `Open (${openCount})`]
-  ];
-  const GAP_MIN = 3;
-  const totalLen = labels.reduce((sum, [, label]) => sum + label.length, 0);
-  const slots = labels.length - 1;
-  const spare = Math.max(GAP_MIN * slots, width - totalLen);
-  const baseGap = Math.floor(spare / slots);
-  const bonus = spare % slots;
-  let row = "";
-  let col = 0;
-  let activeStart = 0;
-  let activeLen = 0;
-  labels.forEach(([id2, label], i5) => {
-    if (i5 > 0) {
-      const gap = baseGap + (i5 <= bonus ? 1 : 0);
-      row += " ".repeat(gap);
-      col += gap;
-    }
-    if (id2 === tab) {
-      activeStart = col;
-      activeLen = label.length;
-      row += brand(import_picocolors30.default.bold(label));
-    } else {
-      row += import_picocolors30.default.dim(label);
-    }
-    col += label.length;
-  });
-  const tail = Math.max(0, width - activeStart - activeLen);
-  const rule2 = import_picocolors30.default.dim("─".repeat(activeStart)) + brand("━".repeat(activeLen)) + import_picocolors30.default.dim("─".repeat(tail));
-  return [row, rule2];
+  ], tab, width);
 }
 function activityWidth(columns) {
   return Math.max(20, columns - 2 * layoutMargin(columns) - 1);
@@ -74019,15 +75602,17 @@ function wrapLine(text, width, indent = "  ") {
     out.push(line);
   return out;
 }
-function confirmBox(queuedCount, backlog, width) {
+function confirmBox(queuedCount, backlog, width, mode = "start") {
   const inFlight = backlog && backlog.inFlight > 0 ? ` (+${backlog.inFlight} open, mined once ${backlog.inFlight === 1 ? "it goes" : "they go"} quiet)` : "";
-  const scope = queuedCount > 0 ? `${queuedCount} session${queuedCount === 1 ? "" : "s"} queued${inFlight} · runs in the background` : `queue empty${inFlight} · a run would only pick up sessions that finish from here`;
+  const scope = mode === "stop" ? "the run is killed mid-batch · mining stays paused until you resume" : queuedCount > 0 ? `${queuedCount} session${queuedCount === 1 ? "" : "s"} queued${inFlight} · runs in the background` : `queue empty${inFlight} · a run would only pick up sessions that finish from here`;
+  const title = mode === "stop" ? "Stop mining?" : mode === "resume" ? "Resume mining?" : "Start mining now?";
+  const verb = mode === "stop" ? "stop" : mode === "resume" ? "resume" : "start";
   const maxInner = Math.max(20, Math.min(width, contentWidth()) - 4);
   const rows = [
-    `⛏ ${import_picocolors30.default.bold(brand("Start mining now?"))}`,
+    import_picocolors30.default.bold(brand(title)),
     ...wrapLine(scope, maxInner, "").map((line) => import_picocolors30.default.dim(line)),
     "",
-    `${import_picocolors30.default.bold("enter")} start · ${import_picocolors30.default.bold("esc")} cancel`
+    `${import_picocolors30.default.bold("enter")} ${verb} · ${import_picocolors30.default.bold("esc")} cancel`
   ];
   const inner = Math.min(maxInner, Math.max(...rows.map(visibleWidth)));
   const pad = (row) => row + " ".repeat(Math.max(0, inner - visibleWidth(row)));
@@ -74041,7 +75626,7 @@ function renderActivityFrame(status, activity, width, backlog = null, pane = DEF
   const mined = status.state.watermark ? `Mined sessions up to ${localTime(status.state.watermark)}` : "Nothing mined yet";
   const queueDetail = [];
   if (status.backoffUntil) {
-    queueDetail.push(`retrying after ${localTime(status.backoffUntil)}`);
+    queueDetail.push(`retrying after ${localTime(status.backoffUntil)} · s syncs now`);
   }
   let progress = null;
   if (status.running && backlog) {
@@ -74051,14 +75636,18 @@ function renderActivityFrame(status, activity, width, backlog = null, pane = DEF
   }
   const refusal = !status.running && status.state.last_refusal;
   const refusalLines = refusal ? wrapLine(`! Mining paused: ${refusal.message} (${localTime(refusal.at)})`, width).map((line) => import_picocolors30.default.yellow(line)) : [];
-  const minedRows = (status.state.mined_sessions ?? []).map((record2) => formatActivityLine(formatMinedRow(record2), width));
-  const queuedRows = queued.map((session) => formatActivityLine(formatQueuedRow(session), width));
-  const openRows = open5.map((session) => formatActivityLine(formatQueuedRow(session), width));
-  const source = pane.tab === "activity" ? activity.map((line) => formatActivityLine(line, width)) : pane.tab === "queued" ? queuedRows : pane.tab === "open" ? openRows : minedRows;
+  const fullRows = Boolean(pane.fullRows);
+  const minedRows = (status.state.mined_sessions ?? []).map((record2) => fullRows ? formatMinedRow(record2, true) : formatActivityLine(formatMinedRow(record2), width));
+  const sessionRow = (session) => fullRows ? formatQueuedRow(session, true) : formatActivityLine(formatQueuedRow(session), width);
+  const queuedRows = queued.map(sessionRow);
+  const openRows = open5.map(sessionRow);
+  const source = pane.tab === "activity" ? activity.map((line) => formatActivityLine(line, width, fullRows)) : pane.tab === "queued" ? queuedRows : pane.tab === "open" ? openRows : minedRows;
   const emptyMined = status.state.watermark ? "No sessions recorded yet. History starts with the next mining run." : "No mined sessions yet.";
   const empty = pane.tab === "activity" ? "No sync activity in the log yet." : pane.tab === "queued" ? "Queue empty. Finished agent sessions appear here." : pane.tab === "open" ? "No open sessions. Live agent sessions sit here until they go quiet." : emptyMined;
-  const { visible, above, below } = windowList(source, pane.scroll);
-  const listRows = visible.length > 0 ? visible.map((row) => import_picocolors30.default.dim(row)) : [import_picocolors30.default.dim(empty)];
+  const height = fullRows ? ACTIVITY_VIEW_FULL_LIST_ROWS : ACTIVITY_VIEW_LIST_LINES;
+  const { visible, above, below } = windowList(source, pane.scroll, height);
+  const display = fullRows ? visible.flatMap((row) => wrapRow(row, width)) : visible;
+  const listRows = display.length > 0 ? display.map((row) => import_picocolors30.default.dim(row)) : [import_picocolors30.default.dim(empty)];
   const scrollParts = [];
   if (above > 0)
     scrollParts.push(`↑ ${above} earlier`);
@@ -74075,13 +75664,14 @@ function renderActivityFrame(status, activity, width, backlog = null, pane = DEF
     "",
     ...tabBar(pane.tab, queued.length, open5.length, status.state.total_mined ?? minedRows.length, width),
     ...listRows,
-    ...scrollParts.length > 0 ? [import_picocolors30.default.dim(scrollParts.join(" · "))] : [],
+    ...scrollParts.length > 0 ? [import_picocolors30.default.dim(clip(scrollParts.join(" · "), width))] : [],
     "",
-    ...pane.confirm ? centerBlock(confirmBox(queued.length, backlog, width), width) : [
+    ...pane.confirm ? centerBlock(confirmBox(queued.length, backlog, width, pane.confirm), width) : [
       import_picocolors30.default.dim([
         "tab switch",
         "↑↓ scroll",
-        ...status.running ? [] : ["s sync now"],
+        fullRows ? "f clip" : "f full rows",
+        status.running ? "s stop" : status.state.paused ? "s resume" : "s sync now",
         "esc back"
       ].join(" · "))
     ]
@@ -74104,8 +75694,10 @@ function runActivityView(io2 = {}) {
   const getStatus = io2.getStatus ?? (() => getSyncStatus({ readLog: () => "" }));
   const readLog = io2.readLog ?? defaultReadLog2;
   const createFollower = io2.createFollower ?? ((emit) => createLogFollower(logger.getLogPath(), emit));
-  const startSync = io2.startSync ?? (() => spawnDetachedSelf(["knowledge", "sync", "--quiet", "--bootstrap"]));
-  const listBacklog = io2.listBacklog ?? defaultListBacklog;
+  const startSync = io2.startSync ?? (() => spawnDetachedSelf(["knowledge", "sync", "--bootstrap"]));
+  const stopSync = io2.stopSync ?? stopSyncRun;
+  const setPaused = io2.setPaused ?? setSyncPaused;
+  const listBacklog = io2.listBacklog ?? listSessionBacklog;
   const pollMs = io2.pollMs ?? ACTIVITY_VIEW_POLL_MS;
   const seed = readLog();
   let activity = appendSyncActivity([], seed);
@@ -74113,7 +75705,8 @@ function runActivityView(io2 = {}) {
   let runProgress = foldRunProgress(null, seed);
   let tab = "activity";
   let scroll = 0;
-  let confirmSync = false;
+  let fullRows = false;
+  let confirmSync = null;
   let status = getStatus();
   let sessions = listBacklog();
   let queuedWatermark = status.state.watermark;
@@ -74131,12 +75724,18 @@ function runActivityView(io2 = {}) {
       return sessions.open.length;
     return (status.state.mined_sessions ?? []).length;
   };
+  const listHeight = () => fullRows ? ACTIVITY_VIEW_FULL_LIST_ROWS : ACTIVITY_VIEW_LIST_LINES;
   let lastFrame = null;
   let minedBeforeRun = null;
   const draw = () => {
     status = getStatus();
     if (status.running) {
-      minedBeforeRun ??= status.state.total_mined ?? 0;
+      const run2 = status.state.run;
+      if (run2 && run2.pid === status.pid) {
+        minedBeforeRun = run2.baseline_mined;
+      } else {
+        minedBeforeRun ??= status.state.total_mined ?? 0;
+      }
     } else {
       minedBeforeRun = null;
     }
@@ -74144,10 +75743,12 @@ function runActivityView(io2 = {}) {
       queuedWatermark = status.state.watermark;
       sessions = listBacklog();
     }
-    if (confirmSync && status.running)
-      confirmSync = false;
+    if ((confirmSync === "start" || confirmSync === "resume") && status.running)
+      confirmSync = null;
+    if (confirmSync === "stop" && !status.running)
+      confirmSync = null;
     const width = activityWidth(output2.columns ?? 80);
-    const frame = renderActivityFrame(status, activity, width, backlog, { tab, scroll, confirm: confirmSync }, sessions.queued, minedBeforeRun ?? 0, sessions.open, runProgress);
+    const frame = renderActivityFrame(status, activity, width, backlog, { tab, scroll, confirm: confirmSync ?? undefined, fullRows }, sessions.queued, minedBeforeRun ?? 0, sessions.open, runProgress);
     if (frame === lastFrame)
       return;
     lastFrame = frame;
@@ -74167,7 +75768,7 @@ ${CLEAR_BELOW}`);
   const leaveAltScreen = enterAltScreen(output2);
   output2.write(HIDE_CURSOR3);
   draw();
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const wasRaw = input2.isRaw ?? false;
     input2.setRawMode?.(true);
     input2.resume();
@@ -74184,21 +75785,32 @@ ${CLEAR_BELOW}`);
       input2.pause();
       leaveAltScreen();
       output2.write(SHOW_CURSOR3);
-      resolve6();
+      resolve7();
     };
     const onData = (chunk) => {
       for (const key of parseKeys(chunk.toString())) {
         if (confirmSync) {
           const decision = reduceSyncConfirmKey(key);
           if (decision === "start") {
-            confirmSync = false;
-            const ok2 = startSync();
-            const note = ok2 ? "[sync] sync requested · starting a background run" : "[sync] could not start a background run · try `dosu knowledge sync`";
+            const mode = confirmSync;
+            confirmSync = null;
+            let note;
+            if (mode === "stop") {
+              const ok2 = status.pid !== undefined && stopSync(status.pid);
+              if (ok2)
+                setPaused(true);
+              note = ok2 ? "[sync] mining stopped · paused until you resume" : "[sync] could not stop the run · it may have just finished";
+            } else {
+              if (mode === "resume")
+                setPaused(false);
+              const ok2 = startSync();
+              note = ok2 ? "[sync] sync requested · starting a background run" : "[sync] could not start a background run · try `dosu knowledge sync`";
+            }
             activity = appendSyncActivity(activity, `[${new Date().toISOString()}] [INFO] ${note}
 `);
             draw();
           } else if (decision === "cancel") {
-            confirmSync = false;
+            confirmSync = null;
             draw();
           }
           continue;
@@ -74209,18 +75821,20 @@ ${CLEAR_BELOW}`);
           return;
         }
         if (action === "sync") {
-          if (!status.running) {
-            confirmSync = true;
-            draw();
-          }
+          confirmSync = syncConfirmMode(status);
+          draw();
         } else if (action === "tab" || action === "tab-back") {
           tab = cycleTab(tab, action === "tab" ? 1 : -1);
           scroll = 0;
           if (tab === "queued" || tab === "open")
             sessions = listBacklog();
           draw();
+        } else if (action === "full") {
+          fullRows = !fullRows;
+          scroll = 0;
+          draw();
         } else if (action === "up") {
-          const maxScroll = Math.max(0, activeListLength() - ACTIVITY_VIEW_LIST_LINES);
+          const maxScroll = Math.max(0, activeListLength() - listHeight());
           if (scroll < maxScroll) {
             scroll += 1;
             draw();
@@ -74236,14 +75850,14 @@ ${CLEAR_BELOW}`);
     input2.on("data", onData);
   });
 }
-var import_picocolors30, ESC7, HIDE_CURSOR3, SHOW_CURSOR3, CTRL_C4, KEY_UP4, KEY_DOWN4, KEY_RIGHT3, KEY_LEFT3, CURSOR_HOME, CLEAR_BELOW, CLEAR_EOL, ACTIVITY_VIEW_POLL_MS = 500, ACTIVITY_VIEW_LIST_LINES = 10, ACTIVITY_VIEW_BUFFER_LINES = 200, ACTIVITY_VIEW_TABS, DEFAULT_PANE;
+var import_picocolors30, ESC7, HIDE_CURSOR3, SHOW_CURSOR3, CTRL_C4, KEY_UP4, KEY_DOWN4, KEY_RIGHT3, KEY_LEFT3, CURSOR_HOME, CLEAR_BELOW, CLEAR_EOL, ACTIVITY_VIEW_POLL_MS = 500, ACTIVITY_VIEW_LIST_LINES = 10, ACTIVITY_VIEW_FULL_LIST_ROWS = 5, ACTIVITY_VIEW_BUFFER_LINES = 200, ACTIVITY_VIEW_TABS, DEFAULT_PANE;
 var init_activity_view = __esm(() => {
   init_follow();
   init_logger();
-  init_project_dir();
-  init_scan();
   init_styles();
+  init_backlog();
   init_detach();
+  init_lock();
   init_status();
   init_watermark();
   init_alt_screen();
@@ -74694,8 +76308,8 @@ h1 {
 async function startCallbackServer(opts = {}) {
   let resolveToken;
   let rejectToken;
-  const tokenPromise = new Promise((resolve6, reject) => {
-    resolveToken = resolve6;
+  const tokenPromise = new Promise((resolve7, reject) => {
+    resolveToken = resolve7;
     rejectToken = reject;
   });
   const http = __require("node:http");
@@ -74753,8 +76367,8 @@ async function startCallbackServer(opts = {}) {
     res.writeHead(200, { "Content-Type": "text/html" });
     res.end(buildSuccessHtml(email3 ?? undefined, opts.successVariant ?? "auth"));
   });
-  await new Promise((resolve6) => {
-    httpServer.listen(0, "localhost", () => resolve6());
+  await new Promise((resolve7) => {
+    httpServer.listen(0, "localhost", () => resolve7());
   });
   httpServer.unref();
   const addr = httpServer.address();
@@ -75883,12 +77497,21 @@ var init_flow2 = __esm(() => {
 function reduceAnalyticsViewKey(key) {
   if (key === "q" || key === ESC8 || key === CTRL_C5)
     return "back";
+  if (key === "\t" || key === KEY_RIGHT4)
+    return "tab";
+  if (key === KEY_LEFT4)
+    return "tab-back";
   if (key === KEY_UP5 || key === "k")
     return "up";
   if (key === KEY_DOWN5 || key === "j")
     return "down";
   return "none";
 }
+function cycleAnalyticsTab(tab, delta = 1) {
+  const index = ANALYTICS_VIEW_TABS.indexOf(tab);
+  const next = (index + delta + ANALYTICS_VIEW_TABS.length) % ANALYTICS_VIEW_TABS.length;
+  return ANALYTICS_VIEW_TABS[next];
+}
 function clip2(text, max) {
   return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
 }
@@ -75925,38 +77548,37 @@ function loadPageStatsFromConfig() {
     return Promise.resolve(null);
   }
 }
-function analyticsRows(state, pageStats = null) {
+function overviewRows(state) {
   const minedTotal = state.total_mined ?? 0;
   const notes = state.total_notes ?? 0;
   const tokens = state.total_learning_tokens ?? 0;
-  const label = (text) => text.padEnd(26);
-  const rows = [];
-  if (minedTotal > 0 || notes > 0) {
-    rows.push(`${label("Sessions mined")}${minedTotal}`, `${label("Suggested pages")}${notes}`);
-    if (tokens > 0) {
-      rows.push(`${label("Investigation distilled")}${formatTokenCount(tokens)} tokens`);
-    }
-    const byProject = new Map;
-    for (const record2 of state.mined_sessions ?? []) {
-      const key = record2.project ?? "(unknown)";
-      byProject.set(key, (byProject.get(key) ?? 0) + 1);
-    }
-    if (byProject.size > 0) {
-      rows.push("", "Mined by project (recent history)");
-      const top = [...byProject.entries()].sort((a9, b2) => b2[1] - a9[1]).slice(0, 8);
-      for (const [project, count] of top) {
-        rows.push(`${label(clip2(project, 24))}${count}`);
-      }
-    }
+  if (minedTotal === 0 && notes === 0)
+    return [];
+  const rows = [`${label("Sessions mined")}${minedTotal}`, `${label("Suggested pages")}${notes}`];
+  if (tokens > 0) {
+    rows.push(`${label("Investigation distilled")}${formatTokenCount(tokens)} tokens`);
+  }
+  return rows;
+}
+function projectRows(state) {
+  const byProject = new Map;
+  for (const record2 of state.mined_sessions ?? []) {
+    const key = record2.project ?? "(unknown)";
+    byProject.set(key, (byProject.get(key) ?? 0) + 1);
   }
+  const data = [...byProject.entries()].sort((a9, b2) => b2[1] - a9[1]).map(([project, count]) => `${label(clip2(project, 24))}${count}`);
+  return data.length > 0 ? [`${label("Project")}Sessions`, ...data] : [];
+}
+function pageRows(pageStats) {
+  const rows = [];
   if (pageStats && pageStats.topCited.length > 0) {
-    rows.push(...rows.length > 0 ? [""] : [], `Top cited pages (${TOP_CITED_DAYS}d)`);
+    rows.push(`${label(`Top cited (${TOP_CITED_DAYS}d)`)}Citations`);
     for (const row of pageStats.topCited) {
       rows.push(`${label(clip2(row.title, 24))}${row.citation_count}`);
     }
   }
   if (pageStats && pageStats.topUpdated.length > 0) {
-    rows.push(...rows.length > 0 ? [""] : [], "Recently updated pages");
+    rows.push(...rows.length > 0 ? [""] : [], `${label("Recently updated")}Updated`);
     for (const row of pageStats.topUpdated) {
       rows.push(`${label(clip2(row.title, 24))}${row.updated_at.slice(0, 10)}`);
     }
@@ -75971,22 +77593,36 @@ function windowReport(lines, scroll, height = ANALYTICS_VIEW_LINES) {
     below: Math.max(0, lines.length - clamped - height)
   };
 }
-function renderAnalyticsFrame(state, scroll, pageStats = null) {
-  const rows = analyticsRows(state, pageStats);
+function analyticsTabRows(tab, state, pageStats) {
+  if (tab === "overview")
+    return overviewRows(state);
+  if (tab === "projects")
+    return projectRows(state);
+  return pageRows(pageStats);
+}
+function renderAnalyticsFrame(state, tab, scroll, pageStats = null, pagesPending = false, width = contentWidth()) {
+  const rows = analyticsTabRows(tab, state, pageStats);
   const { visible, above, below } = windowReport(rows, scroll);
-  const listRows = visible.length > 0 ? visible.map((row) => import_picocolors32.default.dim(row)) : [import_picocolors32.default.dim("No analytics yet. They appear after the first mining run.")];
+  const empty = tab === "overview" ? "No analytics yet. They appear after the first mining run." : tab === "projects" ? "No per-project history yet. It fills in as sessions are mined." : pagesPending ? "Loading page analytics..." : "No page analytics yet.";
+  const listRows = visible.length > 0 ? visible.map((row) => import_picocolors32.default.dim(row)) : [import_picocolors32.default.dim(empty)];
   const scrollParts = [];
   if (above > 0)
     scrollParts.push(`↑ ${above} earlier`);
   if (below > 0)
     scrollParts.push(`↓ ${below} more`);
   const lines = [
-    breadcrumb(["Home", "Analytics"]),
+    breadcrumb(["Home", "Analytics"], width),
+    "",
+    ...tabStrip([
+      ["overview", "Overview"],
+      ["projects", "Projects"],
+      ["pages", "Pages"]
+    ], tab, width, { spread: false }),
     "",
     ...listRows,
     ...scrollParts.length > 0 ? [import_picocolors32.default.dim(scrollParts.join(" · "))] : [],
     "",
-    import_picocolors32.default.dim("↑↓ scroll · esc back")
+    import_picocolors32.default.dim("tab switch · ↑↓ scroll · esc back")
   ];
   return lines.join(`
 `);
@@ -75999,14 +77635,17 @@ function runAnalyticsView(io2 = {}) {
   const getStatus = io2.getStatus ?? (() => getSyncStatus({ readLog: () => "" }));
   const loadPageStats = io2.loadPageStats ?? loadPageStatsFromConfig;
   const pollMs = io2.pollMs ?? ANALYTICS_VIEW_POLL_MS;
+  let tab = "overview";
   let scroll = 0;
   let status = getStatus();
   let pageStats = null;
+  let pagesPending = true;
   let closed = false;
   let lastFrame = null;
   const draw = () => {
     status = getStatus();
-    const frame = renderAnalyticsFrame(status.state, scroll, pageStats);
+    const width = Math.min(contentWidth(output2.columns ?? 80), (output2.columns ?? 80) - 1);
+    const frame = renderAnalyticsFrame(status.state, tab, scroll, pageStats, pagesPending, width);
     if (frame === lastFrame)
       return;
     lastFrame = frame;
@@ -76027,12 +77666,13 @@ ${CLEAR_BELOW2}`);
   output2.write(HIDE_CURSOR4);
   draw();
   loadPageStats().then((stats) => {
-    if (closed || !stats)
+    if (closed)
       return;
     pageStats = stats;
+    pagesPending = false;
     draw();
   });
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const wasRaw = input2.isRaw ?? false;
     input2.setRawMode?.(true);
     input2.resume();
@@ -76047,7 +77687,7 @@ ${CLEAR_BELOW2}`);
       input2.pause();
       leaveAltScreen();
       output2.write(SHOW_CURSOR4);
-      resolve6();
+      resolve7();
     };
     const onData = (chunk) => {
       for (const key of parseKeys(chunk.toString())) {
@@ -76056,13 +77696,17 @@ ${CLEAR_BELOW2}`);
           finish();
           return;
         }
-        if (action === "up") {
+        if (action === "tab" || action === "tab-back") {
+          tab = cycleAnalyticsTab(tab, action === "tab" ? 1 : -1);
+          scroll = 0;
+          draw();
+        } else if (action === "up") {
           if (scroll > 0) {
             scroll -= 1;
             draw();
           }
         } else if (action === "down") {
-          const maxScroll = Math.max(0, analyticsRows(status.state, pageStats).length - ANALYTICS_VIEW_LINES);
+          const maxScroll = Math.max(0, analyticsTabRows(tab, status.state, pageStats).length - ANALYTICS_VIEW_LINES);
           if (scroll < maxScroll) {
             scroll += 1;
             draw();
@@ -76073,7 +77717,7 @@ ${CLEAR_BELOW2}`);
     input2.on("data", onData);
   });
 }
-var import_picocolors32, ESC8, HIDE_CURSOR4, SHOW_CURSOR4, CTRL_C5, KEY_UP5, KEY_DOWN5, CURSOR_HOME2, CLEAR_BELOW2, CLEAR_EOL2, ANALYTICS_VIEW_POLL_MS = 1000, ANALYTICS_VIEW_LINES = 12, TOP_PAGES_LIMIT = 5, TOP_CITED_DAYS = 30;
+var import_picocolors32, ESC8, HIDE_CURSOR4, SHOW_CURSOR4, CTRL_C5, KEY_UP5, KEY_DOWN5, KEY_RIGHT4, KEY_LEFT4, CURSOR_HOME2, CLEAR_BELOW2, CLEAR_EOL2, ANALYTICS_VIEW_POLL_MS = 1000, ANALYTICS_VIEW_LINES = 14, ANALYTICS_VIEW_TABS, TOP_PAGES_LIMIT = 5, TOP_CITED_DAYS = 30, label = (text) => text.padEnd(26);
 var init_analytics_view = __esm(() => {
   init_trpc();
   init_config();
@@ -76088,9 +77732,12 @@ var init_analytics_view = __esm(() => {
   CTRL_C5 = String.fromCharCode(3);
   KEY_UP5 = `${ESC8}[A`;
   KEY_DOWN5 = `${ESC8}[B`;
+  KEY_RIGHT4 = `${ESC8}[C`;
+  KEY_LEFT4 = `${ESC8}[D`;
   CURSOR_HOME2 = `${ESC8}[H`;
   CLEAR_BELOW2 = `${ESC8}[0J`;
   CLEAR_EOL2 = `${ESC8}[K`;
+  ANALYTICS_VIEW_TABS = ["overview", "projects", "pages"];
 });
 
 // src/tui/banner.ts
@@ -76108,7 +77755,7 @@ function checklistRows(ctx) {
   const rows = [["workspace", ctx.directory]];
   rows.push([
     "account",
-    ctx.signedIn ? `${on2} signed in` : `${off} ${import_picocolors33.default.dim("not signed in · run Setup")}`
+    ctx.sessionExpired ? `${off} ${import_picocolors33.default.yellow("session expired")} ${import_picocolors33.default.dim(`${DOT3} run Log in`)}` : ctx.signedIn ? `${on2} signed in` : `${off} ${import_picocolors33.default.dim(`not signed in ${DOT3} run Setup`)}`
   ]);
   const missing = new Set(ctx.setupMissing ?? []);
   const warnRow = `${off} ${import_picocolors33.default.yellow("not configured")} ${import_picocolors33.default.dim(`${DOT3} run Setup`)}`;
@@ -76144,8 +77791,8 @@ function checklistRows(ctx) {
       `${import_picocolors33.default.yellow(`↑ ${ctx.update.version} available`)} ${import_picocolors33.default.dim(`${DOT3} ${ctx.update.hint}`)}`
     ]);
   }
-  const labelWidth = Math.max(...rows.map(([label]) => label.length));
-  return rows.map(([label, value]) => `${import_picocolors33.default.dim(label.padEnd(labelWidth))}  ${value}`);
+  const labelWidth = Math.max(...rows.map(([label2]) => label2.length));
+  return rows.map(([label2, value]) => `${import_picocolors33.default.dim(label2.padEnd(labelWidth))}  ${value}`);
 }
 function renderBanner(ctx) {
   const logo = LOGO_ROWS.map(paintLogoRow);
@@ -76274,7 +77921,7 @@ function wrapBody(text, width) {
 function clip3(text, max) {
   return text.length <= max ? text : `${text.slice(0, max - 1)}…`;
 }
-function pageRows(pages, width) {
+function pageRows2(pages, width) {
   const titleWidth = Math.max(16, width - 32);
   return pages.map((page) => {
     const title = clip3(page.title, titleWidth).padEnd(titleWidth + 1);
@@ -76298,7 +77945,7 @@ function renderPagesFrame(model, width, selected) {
   } else if (model.pages.length === 0) {
     body.push(import_picocolors34.default.dim("No pages in this Library yet."));
   } else {
-    const rows = pageRows(model.pages, width - 2);
+    const rows = pageRows2(model.pages, width - 2);
     const { start, above } = windowSelection(rows.length, selected);
     const visible = rows.slice(start, start + PAGES_VIEW_LINES);
     body.push(...visible.map((row, i5) => start + i5 === selected ? `${brand("▸")} ${import_picocolors34.default.bold(row)}` : `  ${import_picocolors34.default.dim(row)}`));
@@ -76441,7 +78088,7 @@ ${CLEAR_BELOW3}`);
     });
     draw();
   };
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const wasRaw = input2.isRaw ?? false;
     input2.setRawMode?.(true);
     input2.resume();
@@ -76453,7 +78100,7 @@ ${CLEAR_BELOW3}`);
       input2.pause();
       leaveAltScreen();
       output2.write(SHOW_CURSOR5);
-      resolve6();
+      resolve7();
     };
     const onData = (chunk) => {
       for (const key of parseKeys(chunk.toString())) {
@@ -76525,9 +78172,19 @@ __export(exports_tui, {
   runTUI: () => runTUI,
   handleLogout: () => handleLogout
 });
-import { homedir as homedir11 } from "node:os";
+import { homedir as homedir10 } from "node:os";
 import { basename as basename4 } from "node:path";
-function bannerContext(cfg) {
+async function probeSession(cfg) {
+  if (!isAuthenticated(cfg) || !isTokenExpired(cfg))
+    return { expired: false };
+  try {
+    await new Client(cfg).refreshToken();
+    return { expired: false };
+  } catch (err) {
+    return { expired: err instanceof SessionExpiredError };
+  }
+}
+function bannerContext(cfg, session) {
   let webAppHost = "app.dosu.dev";
   try {
     webAppHost = new URL(getWebAppURL()).host;
@@ -76545,9 +78202,10 @@ function bannerContext(cfg) {
     webAppHost,
     directory: basename4(process.cwd()),
     signedIn: isAuthenticated(cfg),
+    sessionExpired: session.expired,
     deploymentName: cfg.active_account?.target?.deployment_name,
     libraryName: cfg.active_account?.target?.library_name,
-    setupMissing: isAuthenticated(cfg) ? missingSetupSteps(cfg) : [],
+    setupMissing: isAuthenticated(cfg) && !session.expired ? missingSetupSteps(cfg) : [],
     ...inGitWorkTree() ? { repoAgentsMd: dosuAgentsSectionState() } : {},
     agents,
     mining: isMining(),
@@ -76624,17 +78282,18 @@ function isMining() {
     return false;
   }
 }
-function drawHome(cfg) {
+function drawHome(cfg, session) {
   if (process.stdout.isTTY) {
     process.stdout.write(CLEAR_SCREEN);
     process.stdout.write(`
 `.repeat(frameTopMargin()));
   }
-  process.stdout.write(`${renderBanner(bannerContext(cfg))}
+  process.stdout.write(`${renderBanner(bannerContext(cfg, session))}
 `);
 }
 async function runMainMenu() {
   const cfg = loadConfig();
+  const session = await probeSession(cfg);
   const runSetupAndReload = async () => {
     await runSetup();
     const fresh = loadConfig();
@@ -76642,9 +78301,19 @@ async function runMainMenu() {
     cfg.active_account = fresh.active_account;
   };
   const buildOptions = () => {
+    if (session.expired) {
+      return [
+        {
+          label: "Log in again",
+          hint: "(session expired · opens your browser)",
+          value: "auth"
+        },
+        { label: "Exit", value: "exit" }
+      ];
+    }
     if (!isAuthenticated(cfg)) {
       return [
-        { label: "Log in / Sign up", hint: "opens your browser", value: "auth" },
+        { label: "Log in / Sign up", hint: "(opens your browser)", value: "auth" },
         { label: "Exit", value: "exit" }
       ];
     }
@@ -76660,15 +78329,16 @@ async function runMainMenu() {
         label: mining ? `Activity ⛏️ ${brand("mining sessions...")}` : "Activity",
         value: "sync"
       },
+      { label: "Knowledge report", hint: "(opens in browser)", value: "report" },
       { label: "Analytics", value: "analytics" },
       { label: "Pages", value: "pages" },
       { label: "Settings", value: "settings" },
       { label: "Exit", value: "exit" }
     ];
   };
-  const home = () => drawHome(cfg);
+  const home = () => drawHome(cfg, session);
   home();
-  if (isAuthenticated(cfg) && !isSetUp(cfg)) {
+  if (isAuthenticated(cfg) && !session.expired && !isSetUp(cfg)) {
     await runSetupAndReload();
     home();
   }
@@ -76684,6 +78354,10 @@ async function runMainMenu() {
         await runActivityView();
         home();
         break;
+      case "report":
+        await runKnowledgeReport();
+        home();
+        break;
       case "analytics":
         await runAnalyticsView();
         home();
@@ -76698,6 +78372,7 @@ async function runMainMenu() {
         break;
       case "auth":
         await handleAuthenticate(cfg);
+        session.expired = session.expired && isTokenExpired(cfg);
         home();
         if (isAuthenticated(cfg) && !isSetUp(cfg)) {
           await runSetupAndReload();
@@ -76711,6 +78386,17 @@ async function runMainMenu() {
     }
   }
 }
+async function runKnowledgeReport() {
+  const s = spinner2();
+  s.start("Writing knowledge report...");
+  try {
+    const path3 = await emitKnowledgeReport({ open: true });
+    s.stop(`Opened ${path3}`);
+  } catch (err) {
+    s.stop("Could not write the report");
+    log2.error(err instanceof Error ? err.message : String(err));
+  }
+}
 async function runSettings(cfg) {
   while (true) {
     const target = cfg.active_account?.target;
@@ -76751,7 +78437,7 @@ async function runSettings(cfg) {
   }
 }
 function displayDir(dir) {
-  const home = homedir11();
+  const home = homedir10();
   return dir === home ? "~" : dir.startsWith(`${home}/`) ? `~${dir.slice(home.length)}` : dir;
 }
 function discoverProjectDirs() {
@@ -76835,9 +78521,11 @@ function handleLogout(cfg) {
 }
 var import_picocolors35, ESC10, CLEAR_SCREEN;
 var init_tui = __esm(() => {
+  init_client();
   init_config();
   init_agents();
   init_providers();
+  init_generate();
   init_project_dir();
   init_scan();
   init_agents_md_step();
@@ -77117,7 +78805,7 @@ Could not open a browser automatically.`);
   throw new Error("Authentication timed out. Run 'dosu login' to try again.");
 }
 function sleep4(ms2) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms2));
+  return new Promise((resolve7) => setTimeout(resolve7, ms2));
 }
 var POLL_INTERVAL_MS = 5000;
 var init_device = __esm(() => {
@@ -80621,12 +82309,15 @@ init_trpc();
 init_config();
 init_agents();
 init_formats();
+init_generate();
+init_backlog();
 init_detach();
 init_status();
 init_sync();
+init_watermark();
 var import_picocolors18 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync16 } from "node:fs";
-import { homedir as homedir6 } from "node:os";
+import { homedir as homedir5 } from "node:os";
 import { delimiter as delimiter4, join as join19 } from "node:path";
 function requireConfig7() {
   const cfg = requireLoginConfig();
@@ -80690,7 +82381,51 @@ ${results.length - opts.limit} more results not shown.`));
     console.log(`  ID:       ${store.id}`);
     console.log(`  Space ID: ${store.space_id}`);
   });
-  cmd.command("sync").description("Scan local agent session history and report the mining backlog").option("--quiet", "Background mode for hooks: honor backoff, exit 0, print nothing").option("--detach", "Re-spawn detached and return immediately (used by agent hooks)").option("--bootstrap", "Backfill mode: mine the full local session history regardless of age and drain the backlog (used by setup)").option("--status", "Show whether a sync is running now, plus watermark and recent activity").option("--json", "Output as JSON").action(async (opts) => {
+  cmd.command("sessions").description("List local agent sessions with full project and session ids (the untruncated view of the Activity screen's tabs)").option("--queued", "Only sessions queued for mining").option("--open", "Only live sessions still inside the quiet period").option("--mined", "Only recent mined-session history").option("--json", "Output as JSON").action((opts) => {
+    const all = !opts.queued && !opts.open && !opts.mined;
+    const wantQueued = all || Boolean(opts.queued);
+    const wantOpen = all || Boolean(opts.open);
+    const wantMined = all || Boolean(opts.mined);
+    const backlog = wantQueued || wantOpen ? listSessionBacklog() : { queued: [], open: [] };
+    const mined = wantMined ? loadSyncState().mined_sessions ?? [] : [];
+    if (opts.json) {
+      printResult({
+        ...wantQueued ? { queued: backlog.queued } : {},
+        ...wantOpen ? { open: backlog.open } : {},
+        ...wantMined ? { mined } : {}
+      }, opts);
+      return;
+    }
+    const sessionRows = (sessions) => sessions.map((s) => [s.harness, s.updated, s.project ?? "-", s.id]);
+    const minedRows = mined.map((record2) => {
+      const slash = record2.session.indexOf("/");
+      const harness = slash > 0 ? record2.session.slice(0, slash) : "-";
+      const id2 = slash > 0 ? record2.session.slice(slash + 1) : record2.session;
+      return [harness, record2.at, record2.project ?? "-", id2];
+    });
+    let first = true;
+    const section = (title, rows, stamp, emptyMsg) => {
+      if (!first)
+        console.log();
+      first = false;
+      console.log(import_picocolors18.default.bold(`${title} (${rows.length})`));
+      if (rows.length === 0) {
+        console.log(import_picocolors18.default.dim(`  ${emptyMsg}`));
+        return;
+      }
+      printTable(["Agent", stamp, "Project", "Session"], rows);
+    };
+    if (wantQueued) {
+      section("Queued", sessionRows(backlog.queued), "Updated", "Queue empty. Finished agent sessions appear here.");
+    }
+    if (wantOpen) {
+      section("Open", sessionRows(backlog.open), "Updated", "No open sessions. Live agent sessions sit here until they go quiet.");
+    }
+    if (wantMined) {
+      section("Mined", minedRows, "Mined at", "No mined sessions recorded yet.");
+    }
+  });
+  cmd.command("sync").description("Scan local agent session history and report the mining backlog").option("--quiet", "Background mode for hooks: honor backoff, exit 0, print nothing").option("--detach", "Re-spawn detached and return immediately (used by agent hooks)").option("--bootstrap", "Backfill mode: mine the full local session history regardless of age and drain the backlog (used by setup)").option("--status", "Show whether a sync is running now, plus watermark and recent activity").option("--report", "Write the same HTML harvest report as the log-to-dosu-knowledge skill and open it").option("--out <path>", "HTML report path (default: tmp/dosu-knowledge-report.html)").option("--json", "Output as JSON").action(async (opts) => {
     if (opts.status) {
       const status = getSyncStatus();
       if (opts.json) {
@@ -80705,7 +82440,9 @@ ${results.length - opts.limit} more results not shown.`));
         "knowledge",
         "sync",
         ...opts.quiet ? ["--quiet"] : [],
-        ...opts.bootstrap ? ["--bootstrap"] : []
+        ...opts.bootstrap ? ["--bootstrap"] : [],
+        ...opts.report ? ["--report"] : [],
+        ...opts.out ? ["--out", opts.out] : []
       ]);
       return;
     }
@@ -80726,12 +82463,55 @@ ${results.length - opts.limit} more results not shown.`));
     if (opts.quiet)
       return;
     if (opts.json) {
-      printResult(outcome, opts);
       if (outcome.status === "error")
         process.exitCode = 1;
+      if (opts.report) {
+        try {
+          const report = await emitKnowledgeReport({ out: opts.out, open: false });
+          printResult({ ...outcome, report }, opts);
+        } catch (err) {
+          const report_error = err instanceof Error ? err.message : String(err);
+          printResult({ ...outcome, report_error }, opts);
+        }
+      } else {
+        printResult(outcome, opts);
+      }
       return;
     }
     printSyncOutcome(outcome);
+    if (opts.report) {
+      try {
+        const report = await emitKnowledgeReport({ out: opts.out, open: true });
+        console.log(`Wrote ${report}`);
+      } catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+      }
+    }
+  });
+  cmd.command("report").description("Render the knowledge report from your Dosu notes and the local session logs").option("--out <path>", "HTML report path (default: tmp/dosu-knowledge-report.html)").option("--json", "Output the report path as JSON").option("--no-open", "Write the file without opening a browser").action(async (opts) => {
+    const path3 = await emitKnowledgeReport({
+      out: opts.out,
+      open: opts.json ? false : opts.open
+    });
+    if (opts.json) {
+      printResult({ report: path3 }, opts);
+      return;
+    }
+    console.log(`Wrote ${path3}`);
+  });
+  cmd.command("backfill-transcripts").description("One-shot: attribute pre-existing notes to the local sessions that produced them, so the report can show their traces").option("--json", "Output the result as JSON").action(async (opts) => {
+    const { runBackfill: runBackfill2 } = await Promise.resolve().then(() => (init_backfill_run(), exports_backfill_run));
+    const result = await runBackfill2();
+    if (opts.json) {
+      printResult(result, opts);
+      return;
+    }
+    if (result.candidates === 0) {
+      console.log("All your notes already have a transcript — nothing to backfill.");
+      return;
+    }
+    console.log(`Attributed ${result.updated} of ${result.candidates} notes (${result.ambiguous} ambiguous, ${result.noBatch} without a local mining batch). Run 'dosu knowledge report' to see their traces.`);
   });
   cmd.addCommand(hooksCommand());
   return cmd;
@@ -80771,10 +82551,13 @@ function printSyncStatus(status, now = new Date) {
   } else {
     console.log("○ No sync running.");
   }
+  if (status.state.paused) {
+    console.log(import_picocolors18.default.yellow("  Mining paused: stopped by you. Resume from the Activity screen or run 'dosu knowledge sync'."));
+  }
   const wm2 = status.state.watermark;
   console.log(`  Mined through:   ${wm2 ? `${wm2} (${formatAge(wm2, now)})` : "nothing mined yet"}`);
   if (status.state.project_filter?.length) {
-    const home = homedir6();
+    const home = homedir5();
     const scope = status.state.project_filter.map((dir) => dir.startsWith(`${home}/`) ? `~${dir.slice(home.length)}` : dir).join(", ");
     console.log(`  Mining scope:    ${scope}`);
   }
@@ -80847,6 +82630,10 @@ function printSyncOutcome(outcome) {
       console.log(import_picocolors18.default.dim("Skipped: a recent sync failed; waiting out the retry backoff."));
       break;
     }
+    case "skipped-paused": {
+      console.log(import_picocolors18.default.dim("Skipped: mining is paused. Run 'dosu knowledge sync' to resume."));
+      break;
+    }
   }
 }
 function resolveHookAgents(ids) {
@@ -80953,7 +82740,6 @@ var LIBRARY_VISIBILITIES = ["public", "internal", "private"];
 var CONFIG_SETTINGS = {
   commit_to_trigger_pr: true,
   default_accept_review: true,
-  default_save_publish: true,
   review_timeout_days: true
 };
 var CONFIG_SETTING_NAMES = Object.keys(CONFIG_SETTINGS);
@@ -81597,7 +83383,10 @@ init_skill();
 // src/commands/sources.ts
 init_commander();
 init_trpc();
+init_github_step();
+init_installation_server();
 var import_picocolors25 = __toESM(require_picocolors(), 1);
+var CONNECT_TIMEOUT_DEFAULT_SECONDS = 600;
 function requireConfig11() {
   const cfg = requireLoginConfig();
   if (!cfg.active_account?.target?.org_id) {
@@ -81606,6 +83395,15 @@ function requireConfig11() {
   }
   return cfg;
 }
+function rejectWebOnlyProvider(provider, json2) {
+  const url2 = getWebAppURL();
+  if (json2) {
+    printResult({ provider, cli_supported: false, connect_via: "web", url: url2 }, { json: true });
+  } else {
+    console.error(import_picocolors25.default.yellow(`Connecting '${provider}' sources is web-only for now. Open ${url2}, add the source ` + `under Data Sources, then re-run 'dosu sources list'.`));
+  }
+  process.exit(1);
+}
 function sourcesCommand() {
   const cmd = new Command("sources").description("Manage connected data sources");
   cmd.command("list").description("List all connected data sources").option("--json", "Output as JSON").action(async (opts) => {
@@ -81688,6 +83486,154 @@ function sourcesCommand() {
     }
     console.log(import_picocolors25.default.green("Data source deleted."));
   });
+  cmd.command("connect").description("Install or update a provider integration (currently GitHub) via the browser").argument("[provider]", "Provider to connect (github)", "github").option("--json", "Emit machine-readable NDJSON progress events").option("--timeout <seconds>", "Seconds to wait for the browser install to complete", String(CONNECT_TIMEOUT_DEFAULT_SECONDS)).option("--no-open", "Print the URL without opening a browser").action(async (provider, opts) => {
+    const providerName = provider.toLowerCase();
+    if (providerName !== "github") {
+      rejectWebOnlyProvider(providerName, opts.json);
+      return;
+    }
+    const cfg = requireConfig11();
+    const client = createTypedClient(cfg);
+    const orgID = cfg.active_account.target.org_id;
+    const timeoutSeconds = Math.max(1, Number.parseInt(opts.timeout ?? "", 10)) || CONNECT_TIMEOUT_DEFAULT_SECONDS;
+    const before = await fetchListForOrg(client, orgID);
+    const { server, installationPromise } = await startInstallationCallbackServer();
+    let timeoutId;
+    try {
+      const connectURL = new URL("/cli/connect-github", getWebAppURL());
+      connectURL.searchParams.set("callback", `http://localhost:${server.port}/callback`);
+      const url2 = connectURL.toString();
+      if (opts.json) {
+        console.log(JSON.stringify({
+          event: "awaiting_install",
+          provider: "github",
+          url: url2,
+          timeout_seconds: timeoutSeconds
+        }));
+      } else {
+        console.log(`Open this URL to install or update the Dosu GitHub App:
+  ${import_picocolors25.default.cyan(url2)}`);
+        if (opts.open !== false) {
+          try {
+            const open5 = await Promise.resolve().then(() => (init_open(), exports_open));
+            await open5.default(url2);
+          } catch {}
+        }
+        console.log(import_picocolors25.default.dim("Waiting for the install to complete..."));
+      }
+      const timedOut = new Promise((resolve6) => {
+        timeoutId = setTimeout(() => resolve6(null), timeoutSeconds * 1000);
+      });
+      const result = await Promise.race([installationPromise, timedOut]);
+      if (result === null) {
+        if (opts.json) {
+          console.log(JSON.stringify({ event: "timeout", timeout_seconds: timeoutSeconds }));
+        } else {
+          console.error(import_picocolors25.default.red(`Timed out after ${timeoutSeconds}s. Finish the install in the browser, then re-run 'dosu sources connect github'.`));
+        }
+        process.exit(1);
+        return;
+      }
+      const refresh = await waitForRepositoryRefresh(client, orgID, before);
+      const beforeIds = new Set(before.map((repo) => repo.repository_id));
+      const newRepositories = refresh.repos.filter((repo) => !beforeIds.has(repo.repository_id)).map((repo) => ({ slug: repo.slug, repository_id: repo.repository_id }));
+      if (opts.json) {
+        console.log(JSON.stringify({
+          event: "installed",
+          installation_id: result.installation_id,
+          new_repositories: newRepositories
+        }));
+        return;
+      }
+      console.log(import_picocolors25.default.green(`GitHub App connected (installation ${result.installation_id}).`));
+      if (newRepositories.length > 0) {
+        for (const repo of newRepositories) {
+          console.log(`  ${repo.slug}`);
+        }
+        console.log(import_picocolors25.default.dim("Next: dosu sources create github --repo <owner/name> --library <library-id>"));
+      } else {
+        console.log(import_picocolors25.default.dim("No new repositories visible yet — GitHub may still be syncing. " + "Re-run 'dosu sources connect github' or check 'dosu sources list' shortly."));
+      }
+    } finally {
+      clearTimeout(timeoutId);
+      server.close();
+    }
+  });
+  cmd.command("create").description("Create a data source from an installed provider and attach it to a library (requires confirmation)").argument("<provider>", "Provider (currently: github)").requiredOption("--repo <owner/name>", "GitHub repository slug visible to the Dosu app").option("--library <id>", "Library (space) ID to attach to; defaults to the active library").option("--confirm", "Apply without the interactive prompt").option("--json", "Output as JSON").action(async (provider, opts) => {
+    const providerName = provider.toLowerCase();
+    if (providerName !== "github") {
+      rejectWebOnlyProvider(providerName, opts.json);
+      return;
+    }
+    const cfg = requireConfig11();
+    const orgID = cfg.active_account.target.org_id;
+    const libraryID = opts.library ?? cfg.active_account?.target?.space_id;
+    if (!libraryID) {
+      console.error(import_picocolors25.default.red("No library specified and no active library. Pass --library <id>."));
+      process.exit(1);
+      return;
+    }
+    const client = createTypedClient(cfg);
+    const repos = await fetchListForOrg(client, orgID);
+    const repo = repos.find((r9) => r9.slug.toLowerCase() === opts.repo.toLowerCase());
+    if (!repo) {
+      console.error(import_picocolors25.default.red(`Repository '${opts.repo}' is not visible to Dosu. Run ` + `'dosu sources connect github' to grant the GitHub App access, then retry.`));
+      process.exit(1);
+      return;
+    }
+    if (repo.is_fork === true) {
+      console.error(import_picocolors25.default.red(`'${repo.slug}' is a fork and can't be synced.` + (repo.fork_parent_slug ? ` Connect '${repo.fork_parent_slug}' instead.` : "")));
+      process.exit(1);
+      return;
+    }
+    if (!await confirmAction({
+      confirmed: opts.confirm,
+      json: opts.json,
+      message: `Create a data source for ${repo.slug} and attach it to library ${libraryID}?`,
+      preview: {
+        action: "create_source",
+        provider: "github",
+        repository: repo.slug,
+        repository_id: repo.repository_id,
+        library_id: libraryID
+      }
+    }))
+      return;
+    const existingDeployments = await fetchOrgGithubDeployments(client, orgID);
+    const existingDataSources = await fetchOrgGithubDataSources(client, orgID);
+    const created = await createDeploymentForRepo(client, orgID, libraryID, repo, {
+      deploymentID: existingDeployments.get(repo.repository_id),
+      dataSourceID: existingDataSources.get(repo.repository_id)
+    });
+    if (!created) {
+      console.error(import_picocolors25.default.red("Could not create the data source. Check 'dosu logs --tail 50' for details."));
+      process.exit(1);
+      return;
+    }
+    const survivors = await verifyDataSourcesPersist(client, orgID, [created.data_source_id]);
+    if (survivors.dropped.size > 0) {
+      await deleteOrphanDeployment(client, created.deployment_id, repo.slug);
+      console.error(import_picocolors25.default.red(`Dosu couldn't sync '${repo.slug}' (the GitHub App may not have access to it). ` + "Nothing was created."));
+      process.exit(1);
+      return;
+    }
+    const receipt = {
+      provider: "github",
+      repository: repo.slug,
+      repository_id: repo.repository_id,
+      data_source_id: created.data_source_id,
+      deployment_id: created.deployment_id,
+      library_id: libraryID,
+      attached: true
+    };
+    if (opts.json) {
+      printResult(receipt, opts);
+      return;
+    }
+    console.log(import_picocolors25.default.green(`Connected ${repo.slug} to library ${libraryID}.`));
+    console.log(import_picocolors25.default.dim(`  data source ${created.data_source_id}`));
+    console.log(import_picocolors25.default.dim(`  deployment ${created.deployment_id}`));
+  });
   return cmd;
 }
 
@@ -81957,7 +83903,7 @@ init_skill();
 var import_picocolors28 = __toESM(require_picocolors(), 1);
 import { spawnSync } from "node:child_process";
 import { realpathSync as realpathSync2 } from "node:fs";
-import { homedir as homedir8 } from "node:os";
+import { homedir as homedir7 } from "node:os";
 import { posix, win32 as win322 } from "node:path";
 var PACKAGE_NAME = "@dosu/cli";
 var LATEST_PACKAGE = `${PACKAGE_NAME}@latest`;
@@ -82034,7 +83980,7 @@ function packageRoots(manager, platform3, comSpec, env, cwd) {
     manager === "npm" ? path3.join(lines[0], "@dosu", "cli") : path3.join(lines[0], "node_modules", "@dosu", "cli")
   ];
 }
-function owningPackageManager(entrypoint, platform3, comSpec, env = process.env, cwd = homedir8()) {
+function owningPackageManager(entrypoint, platform3, comSpec, env = process.env, cwd = homedir7()) {
   const path3 = platform3 === "win32" ? win322 : posix;
   if (!entrypoint || !path3.isAbsolute(entrypoint))
     return null;
@@ -82087,7 +84033,7 @@ Or install Dosu globally with your package manager:`);
 function runUpgrade(channel = INSTALL_CHANNEL, options = {}) {
   const platform3 = options.platform ?? process.platform;
   const env = options.env ?? process.env;
-  const cwd = options.cwd ?? homedir8();
+  const cwd = options.cwd ?? homedir7();
   let manager = null;
   if (channel === "npm") {
     if (isNpxInvocation(channel, env)) {
@@ -82248,8 +84194,8 @@ async function finishTelemetry(operation) {
   try {
     await Promise.race([
       Promise.resolve().then(operation),
-      new Promise((resolve6) => {
-        timeout = setTimeout(resolve6, TELEMETRY_FLUSH_TIMEOUT_MS);
+      new Promise((resolve7) => {
+        timeout = setTimeout(resolve7, TELEMETRY_FLUSH_TIMEOUT_MS);
       })
     ]);
   } catch {} finally {
@@ -82690,4 +84636,4 @@ execute().catch((err) => {
   process.exit(1);
 });
 
-//# debugId=fd3fcdcd-886d-763b-6475-6e2164756e21
+//# debugId=fa7cf492-7aa5-180c-6475-6e2164756e21