@dosu/cli 0.53.0-beta.6 → 0.53.0-beta.8

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.6", INSTALL_CHANNEL = "npm";
+var VERSION = "0.53.0-beta.8", INSTALL_CHANNEL = "npm";
 
 // src/debug/logger.ts
 import {
@@ -5144,7 +5156,7 @@ var init_logger = __esm(() => {
 });
 
 // src/client/contract.ts
-var CLI_CONTRACT_HASH = "1d4be4b6214f";
+var CLI_CONTRACT_HASH = "d7c6f0f0e8d0";
 
 // src/client/trpc.ts
 var exports_trpc = {};
@@ -8346,161 +8358,16 @@ var init_agents = __esm(() => {
   init_formats();
 });
 
-// src/sessions/project-dir.ts
-import {
-  closeSync as closeSync2,
-  existsSync as existsSync9,
-  mkdirSync as mkdirSync6,
-  openSync as openSync2,
-  readFileSync as readFileSync9,
-  readSync,
-  renameSync as renameSync2,
-  statSync as statSync3,
-  writeFileSync as writeFileSync6
-} from "node:fs";
-import { join as join8 } from "node:path";
-function cachePath(configDir) {
-  return join8(configDir, CACHE_FILENAME2);
-}
-function loadCacheFile(configDir) {
-  try {
-    const raw = JSON.parse(readFileSync9(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 (!existsSync9(configDir))
-      mkdirSync6(configDir, { recursive: true, mode: 448 });
-    const path3 = cachePath(configDir);
-    const tmp = `${path3}.${process.pid}.tmp`;
-    const file = { schema_version: CACHE_SCHEMA_VERSION, entries };
-    writeFileSync6(tmp, JSON.stringify(file), { mode: 384 });
-    renameSync2(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 = existsSync9) {
-  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 statSync3(path3).mtime.toISOString();
-  } catch {
-    return "";
-  }
-}
-function createProjectDirResolver(configDir = getConfigDir(), deps = {}) {
-  const exists = deps.exists ?? existsSync9;
-  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 existsSync10, readdirSync, statSync as statSync4 } 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 join9 } 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: join9(dir, entry.name),
+      path: join8(dir, entry.name),
       isDir: entry.isDirectory()
     }));
   } catch {
@@ -8513,7 +8380,7 @@ function sessionFromFile(filePath, harness, project) {
     return null;
   let mtime;
   try {
-    mtime = statSync4(filePath).mtime;
+    mtime = statSync3(filePath).mtime;
   } catch {
     return null;
   }
@@ -8527,7 +8394,7 @@ function sessionFromFile(filePath, harness, project) {
 }
 function scanClaude(home) {
   const sessions = [];
-  for (const project of listDir(join9(home, ".claude", "projects"))) {
+  for (const project of listDir(join8(home, ".claude", "projects"))) {
     if (!project.isDir)
       continue;
     for (const entry of listDir(project.path)) {
@@ -8542,10 +8409,10 @@ function scanClaude(home) {
 }
 function scanCursor(home) {
   const sessions = [];
-  for (const project of listDir(join9(home, ".cursor", "projects"))) {
+  for (const project of listDir(join8(home, ".cursor", "projects"))) {
     if (!project.isDir)
       continue;
-    for (const entry of listDir(join9(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);
@@ -8557,9 +8424,9 @@ function scanCursor(home) {
   return sessions;
 }
 function scanCodex(home, env) {
-  const codexHome2 = env.CODEX_HOME ?? join9(home, ".codex");
+  const codexHome2 = env.CODEX_HOME ?? join8(home, ".codex");
   const sessions = [];
-  for (const year of listDir(join9(codexHome2, "sessions"))) {
+  for (const year of listDir(join8(codexHome2, "sessions"))) {
     if (!year.isDir)
       continue;
     for (const month of listDir(year.path)) {
@@ -8615,9 +8482,9 @@ function querySqlite(dbPath, sql) {
   }
 }
 function scanOpencode(home, env) {
-  const dataDir = env.XDG_DATA_HOME ?? join9(home, ".local", "share");
-  const dbPath = join9(dataDir, "opencode", "opencode.db");
-  if (!existsSync10(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)
@@ -8655,10 +8522,10 @@ function scanAgentSessions(options = {}) {
 var init_scan = () => {};
 
 // src/sync/watermark.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync10, renameSync as renameSync3, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join10 } from "node:path";
+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 join10(configDir, STATE_FILENAME);
+  return join9(configDir, STATE_FILENAME);
 }
 function loadSyncState(configDir = getConfigDir()) {
   const empty = {
@@ -8667,10 +8534,10 @@ function loadSyncState(configDir = getConfigDir()) {
     consecutive_failures: 0
   };
   const path3 = syncStatePath(configDir);
-  if (!existsSync11(path3))
+  if (!existsSync10(path3))
     return empty;
   try {
-    const raw = JSON.parse(readFileSync10(path3, "utf-8"));
+    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) => ({
@@ -8711,12 +8578,12 @@ function setSyncPaused(paused, configDir = getConfigDir()) {
   saveSyncState(state, configDir);
 }
 function saveSyncState(state, configDir = getConfigDir()) {
-  if (!existsSync11(configDir))
-    mkdirSync7(configDir, { recursive: true, mode: 448 });
+  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 });
-  renameSync3(tmp, path3);
+  writeFileSync6(tmp, JSON.stringify(state, null, 2), { mode: 384 });
+  renameSync2(tmp, path3);
 }
 function backoffUntil(state) {
   if (state.consecutive_failures === 0 || !state.last_attempt_at)
@@ -8768,6 +8635,1668 @@ var init_watermark = __esm(() => {
   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 readFileSync10 } from "node:fs";
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function jsonlRecords(raw) {
+  const records = [];
+  for (const line of raw.split(`
+`)) {
+    if (line.trim() === "")
+      continue;
+    try {
+      const record = asRecord(JSON.parse(line));
+      if (record)
+        records.push(record);
+    } catch {}
+  }
+  return records;
+}
+function textFromContent(content, textTypes) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return "";
+  const parts = [];
+  for (const entry of content) {
+    const item = asRecord(entry);
+    if (!item)
+      continue;
+    if (typeof item.type === "string" && textTypes.has(item.type) && typeof item.text === "string") {
+      parts.push(item.text);
+    }
+  }
+  return parts.join(`
+`);
+}
+function pushTurn(turns, role, text) {
+  if (text.trim() !== "")
+    turns.push({ role, text });
+}
+function readClaude(raw) {
+  const turns = [];
+  for (const record of jsonlRecords(raw)) {
+    const role = record.type;
+    if (role !== "user" && role !== "assistant")
+      continue;
+    if (record.isSidechain === true)
+      continue;
+    const message = asRecord(record.message);
+    if (!message)
+      continue;
+    pushTurn(turns, role, textFromContent(message.content, PLAIN_TEXT));
+  }
+  return turns;
+}
+function readCursor(raw) {
+  const turns = [];
+  for (const record of jsonlRecords(raw)) {
+    const role = record.role;
+    if (role !== "user" && role !== "assistant")
+      continue;
+    const message = asRecord(record.message);
+    if (!message)
+      continue;
+    pushTurn(turns, role, textFromContent(message.content, PLAIN_TEXT));
+  }
+  return turns;
+}
+function isCodexInjectedBlock(text) {
+  const head = text.trimStart().toLowerCase();
+  return head.startsWith("<user_instructions>") || head.startsWith("<environment_context>") || head.startsWith("<recommended_plugins>");
+}
+function readCodex(raw) {
+  const turns = [];
+  for (const record of jsonlRecords(raw)) {
+    if (record.type !== "response_item")
+      continue;
+    const payload = asRecord(record.payload);
+    if (payload?.type !== "message")
+      continue;
+    const role = payload.role;
+    if (role !== "user" && role !== "assistant")
+      continue;
+    const text = textFromContent(payload.content, CODEX_TEXT);
+    if (role === "user" && isCodexInjectedBlock(text))
+      continue;
+    pushTurn(turns, role, text);
+  }
+  return turns;
+}
+function readOpencode(dbPath, sessionId) {
+  if (!/^[A-Za-z0-9_-]+$/.test(sessionId))
+    return [];
+  const rows = querySqlite(dbPath, "SELECT m.data AS message, p.data AS part FROM part p " + "JOIN message m ON m.id = p.message_id " + `WHERE p.session_id = '${sessionId}' ORDER BY p.time_created, p.id`);
+  if (!rows)
+    return [];
+  const turns = [];
+  for (const row of rows) {
+    if (typeof row.message !== "string" || typeof row.part !== "string")
+      continue;
+    try {
+      const message = asRecord(JSON.parse(row.message));
+      const part = asRecord(JSON.parse(row.part));
+      const role = message?.role;
+      if (role !== "user" && role !== "assistant")
+        continue;
+      if (part?.type !== "text" || typeof part.text !== "string")
+        continue;
+      pushTurn(turns, role, part.text);
+    } catch {}
+  }
+  return turns;
+}
+function readSessionTurns(session) {
+  try {
+    switch (session.harness) {
+      case "claude":
+        return readClaude(readFileSync10(session.path, "utf8"));
+      case "cursor":
+        return readCursor(readFileSync10(session.path, "utf8"));
+      case "codex":
+        return readCodex(readFileSync10(session.path, "utf8"));
+      case "opencode":
+        return readOpencode(session.path, session.id);
+    }
+  } catch {
+    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_TOKEN2);
+}
+function isWorthMining(session) {
+  const turns = readSessionTurns(session);
+  if (turns.length < MIN_WORTH_TURNS)
+    return false;
+  let chars = 0;
+  for (const turn of turns) {
+    chars += turn.text.length;
+    if (chars >= MIN_WORTH_CHARS)
+      return true;
+  }
+  return false;
+}
+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 {
@@ -8791,8 +10320,8 @@ var init_backlog = __esm(() => {
 });
 
 // src/sync/lock.ts
-import { existsSync as existsSync12, readFileSync as readFileSync11, rmSync as rmSync2, statSync as statSync5, writeFileSync as writeFileSync8 } from "node:fs";
-import { join as join11 } from "node:path";
+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);
@@ -8802,7 +10331,7 @@ function processAlive(pid) {
   }
 }
 function lockPath(configDir = getConfigDir()) {
-  return join11(configDir, LOCK_FILENAME);
+  return join12(configDir, LOCK_FILENAME);
 }
 function stopSyncRun(pid, configDir = getConfigDir(), kill = process.kill.bind(process)) {
   if (!Number.isInteger(pid) || pid <= 0)
@@ -8819,7 +10348,7 @@ function stopSyncRun(pid, configDir = getConfigDir(), kill = process.kill.bind(p
   }
   try {
     const path3 = lockPath(configDir);
-    if (existsSync12(path3) && readFileSync11(path3, "utf8") === String(pid)) {
+    if (existsSync12(path3) && readFileSync13(path3, "utf8") === String(pid)) {
       rmSync2(path3, { force: true });
     }
   } catch {}
@@ -8830,7 +10359,7 @@ function fileLock(configDir = getConfigDir(), now = () => new Date) {
   let held = false;
   const tryCreate = () => {
     try {
-      writeFileSync8(path3, String(process.pid), { flag: "wx" });
+      writeFileSync9(path3, String(process.pid), { flag: "wx" });
       return true;
     } catch {
       return false;
@@ -8844,7 +10373,7 @@ function fileLock(configDir = getConfigDir(), now = () => new Date) {
       }
       try {
         const age = now().getTime() - statSync5(path3).mtimeMs;
-        const holder = Number.parseInt(readFileSync11(path3, "utf8"), 10);
+        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 });
@@ -8859,7 +10388,7 @@ function fileLock(configDir = getConfigDir(), now = () => new Date) {
         return;
       held = false;
       try {
-        if (existsSync12(path3) && readFileSync11(path3, "utf8") === String(process.pid)) {
+        if (existsSync12(path3) && readFileSync13(path3, "utf8") === String(process.pid)) {
           rmSync2(path3, { force: true });
         }
       } catch {}
@@ -8873,7 +10402,7 @@ var init_lock = __esm(() => {
 });
 
 // src/sync/status.ts
-import { readFileSync as readFileSync12, statSync as statSync6 } from "node:fs";
+import { readFileSync as readFileSync14, statSync as statSync6 } from "node:fs";
 function formatTokenCount(tokens) {
   if (tokens < 1000)
     return String(tokens);
@@ -8896,7 +10425,7 @@ function defaultIsProcessAlive2(pid) {
 }
 function defaultReadLog() {
   try {
-    return readFileSync12(logger.getLogPath(), "utf-8");
+    return readFileSync14(logger.getLogPath(), "utf-8");
   } catch {
     return "";
   }
@@ -8904,7 +10433,7 @@ function defaultReadLog() {
 function readLockFile(configDir) {
   const path3 = lockPath(configDir);
   try {
-    const pid = Number.parseInt(readFileSync12(path3, "utf-8"), 10);
+    const pid = Number.parseInt(readFileSync14(path3, "utf-8"), 10);
     return { pid: Number.isNaN(pid) ? -1 : pid, mtime: statSync6(path3).mtime };
   } catch {
     return null;
@@ -8939,160 +10468,6 @@ var init_status = __esm(() => {
   init_watermark();
 });
 
-// src/sessions/read.ts
-import { readFileSync as readFileSync13 } from "node:fs";
-function asRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
-}
-function jsonlRecords(raw) {
-  const records = [];
-  for (const line of raw.split(`
-`)) {
-    if (line.trim() === "")
-      continue;
-    try {
-      const record = asRecord(JSON.parse(line));
-      if (record)
-        records.push(record);
-    } catch {}
-  }
-  return records;
-}
-function textFromContent(content, textTypes) {
-  if (typeof content === "string")
-    return content;
-  if (!Array.isArray(content))
-    return "";
-  const parts = [];
-  for (const entry of content) {
-    const item = asRecord(entry);
-    if (!item)
-      continue;
-    if (typeof item.type === "string" && textTypes.has(item.type) && typeof item.text === "string") {
-      parts.push(item.text);
-    }
-  }
-  return parts.join(`
-`);
-}
-function pushTurn(turns, role, text) {
-  if (text.trim() !== "")
-    turns.push({ role, text });
-}
-function readClaude(raw) {
-  const turns = [];
-  for (const record of jsonlRecords(raw)) {
-    const role = record.type;
-    if (role !== "user" && role !== "assistant")
-      continue;
-    if (record.isSidechain === true)
-      continue;
-    const message = asRecord(record.message);
-    if (!message)
-      continue;
-    pushTurn(turns, role, textFromContent(message.content, PLAIN_TEXT));
-  }
-  return turns;
-}
-function readCursor(raw) {
-  const turns = [];
-  for (const record of jsonlRecords(raw)) {
-    const role = record.role;
-    if (role !== "user" && role !== "assistant")
-      continue;
-    const message = asRecord(record.message);
-    if (!message)
-      continue;
-    pushTurn(turns, role, textFromContent(message.content, PLAIN_TEXT));
-  }
-  return turns;
-}
-function isCodexInjectedBlock(text) {
-  const head = text.trimStart().toLowerCase();
-  return head.startsWith("<user_instructions>") || head.startsWith("<environment_context>") || head.startsWith("<recommended_plugins>");
-}
-function readCodex(raw) {
-  const turns = [];
-  for (const record of jsonlRecords(raw)) {
-    if (record.type !== "response_item")
-      continue;
-    const payload = asRecord(record.payload);
-    if (payload?.type !== "message")
-      continue;
-    const role = payload.role;
-    if (role !== "user" && role !== "assistant")
-      continue;
-    const text = textFromContent(payload.content, CODEX_TEXT);
-    if (role === "user" && isCodexInjectedBlock(text))
-      continue;
-    pushTurn(turns, role, text);
-  }
-  return turns;
-}
-function readOpencode(dbPath, sessionId) {
-  if (!/^[A-Za-z0-9_-]+$/.test(sessionId))
-    return [];
-  const rows = querySqlite(dbPath, "SELECT m.data AS message, p.data AS part FROM part p " + "JOIN message m ON m.id = p.message_id " + `WHERE p.session_id = '${sessionId}' ORDER BY p.time_created, p.id`);
-  if (!rows)
-    return [];
-  const turns = [];
-  for (const row of rows) {
-    if (typeof row.message !== "string" || typeof row.part !== "string")
-      continue;
-    try {
-      const message = asRecord(JSON.parse(row.message));
-      const part = asRecord(JSON.parse(row.part));
-      const role = message?.role;
-      if (role !== "user" && role !== "assistant")
-        continue;
-      if (part?.type !== "text" || typeof part.text !== "string")
-        continue;
-      pushTurn(turns, role, part.text);
-    } catch {}
-  }
-  return turns;
-}
-function readSessionTurns(session) {
-  try {
-    switch (session.harness) {
-      case "claude":
-        return readClaude(readFileSync13(session.path, "utf8"));
-      case "cursor":
-        return readCursor(readFileSync13(session.path, "utf8"));
-      case "codex":
-        return readCodex(readFileSync13(session.path, "utf8"));
-      case "opencode":
-        return readOpencode(session.path, session.id);
-    }
-  } catch {
-    return [];
-  }
-}
-function estimateSessionTokens(session) {
-  let chars = 0;
-  for (const turn of readSessionTurns(session))
-    chars += turn.text.length;
-  return Math.round(chars / CHARS_PER_TOKEN);
-}
-function isWorthMining(session) {
-  const turns = readSessionTurns(session);
-  if (turns.length < MIN_WORTH_TURNS)
-    return false;
-  let chars = 0;
-  for (const turn of turns) {
-    chars += turn.text.length;
-    if (chars >= MIN_WORTH_CHARS)
-      return true;
-  }
-  return false;
-}
-var PLAIN_TEXT, CODEX_TEXT, CHARS_PER_TOKEN = 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"]);
-});
-
 // src/sync/sync.ts
 function logGateResult(ready, inFlight, watermark) {
   const preview = ready.slice(0, LOG_PREVIEW_LIMIT).map((s) => `${s.harness}/${s.id}`).join(", ");
@@ -9136,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(", ")}`);
     }
@@ -9303,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() {
@@ -9320,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":
@@ -9353,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;
@@ -9415,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"];
 }
@@ -9423,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;
   }
@@ -9440,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;
     }
@@ -52091,7 +53594,7 @@ __export(exports_util, {
   extend: () => extend,
   explicitlyAborted: () => explicitlyAborted,
   escapeRegex: () => escapeRegex,
-  esc: () => esc,
+  esc: () => esc2,
   defineLazyInternal: () => defineLazyInternal,
   defineLazy: () => defineLazy,
   createTransparentProxy: () => createTransparentProxy,
@@ -52242,7 +53745,7 @@ function randomString(length = 10) {
   }
   return str;
 }
-function esc(str) {
+function esc2(str) {
   return JSON.stringify(str);
 }
 function slugify(input) {
@@ -55363,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;
@@ -64600,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: {
@@ -64813,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__"');
@@ -64858,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;`);
@@ -65120,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) {
@@ -65321,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;
@@ -65351,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})`;
@@ -65465,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) {
@@ -71401,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) {
@@ -71414,10 +72926,11 @@ async function runMiner(options) {
   const abort = new AbortController;
   const timer = setTimeout(() => abort.abort(), options.timeoutMs ?? DEFAULT_TIMEOUT_MS2);
   let notesWritten = 0;
+  let lastSessionId;
   let turns = 0;
   const env = buildMinerEnv({
     apiKey: options.apiKey,
-    gatewayURL: options.gatewayURL ?? getLlmGatewayURL(),
+    gatewayURL,
     configDir: configDir.path,
     runID,
     trigger: options.trigger,
@@ -71457,6 +72970,9 @@ async function runMiner(options) {
               message: `Tool ${toolName} is not permitted in mining runs.`
             };
           }
+          if (toolName === `mcp__${SESSIONS_SERVER_NAME}__read_session`) {
+            lastSessionId = sessionIdFromReadInput(input2) ?? lastSessionId;
+          }
           if (toolName === `mcp__${KNOWLEDGE_SERVER_NAME}__write_knowledge`) {
             if (notesWritten >= maxNotes) {
               return {
@@ -71465,6 +72981,10 @@ async function runMiner(options) {
               };
             }
             notesWritten += 1;
+            return {
+              behavior: "allow",
+              updatedInput: lastSessionId ? { ...input2, transcript_id: lastSessionId } : input2
+            };
           }
           return { behavior: "allow", updatedInput: input2 };
         }
@@ -71525,6 +73045,7 @@ 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();
@@ -71548,17 +73069,17 @@ var init_runner = __esm(() => {
 });
 
 // src/version/skill-update-check.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync9, readFileSync as readFileSync17, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join19 } from "node:path";
+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 join19(getConfigDir(), CACHE_FILENAME3);
+  return join20(getConfigDir(), CACHE_FILENAME3);
 }
 function readSkillCache() {
   try {
     const path3 = getCachePath2();
     if (!existsSync17(path3))
       return null;
-    const data = JSON.parse(readFileSync17(path3, "utf-8"));
+    const data = JSON.parse(readFileSync18(path3, "utf-8"));
     if (typeof data.lastCheck === "number" && typeof data.latestSha === "string" && typeof data.installedSha === "string") {
       return data;
     }
@@ -71571,9 +73092,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() {
@@ -71647,7 +73168,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 homedir6 } from "node:os";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 function skillAgentIDsForProviders(providerIDs) {
   return [
     ...new Set(providerIDs.map((providerID) => SKILL_AGENT_BY_PROVIDER[providerID]).filter((agent) => Boolean(agent)))
@@ -71658,17 +73179,17 @@ function skillInstallTargetForProvider(providerID) {
   if (!agentID)
     return null;
   if (agentID === "claude-code") {
-    const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR?.trim() || join20(homedir6(), ".claude");
-    return { path: join20(claudeConfigDir, "skills", SKILL_NAME), symlink: true };
+    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: join20(homedir6(), ".codeium", "windsurf", "skills", SKILL_NAME),
+      path: join21(homedir6(), ".codeium", "windsurf", "skills", SKILL_NAME),
       symlink: true
     };
   }
   return {
-    path: join20(homedir6(), ".agents", "skills", SKILL_NAME),
+    path: join21(homedir6(), ".agents", "skills", SKILL_NAME),
     symlink: false
   };
 }
@@ -71677,12 +73198,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();
     });
   });
 }
@@ -71829,15 +73350,15 @@ import { randomUUID as randomUUID3 } from "node:crypto";
 import {
   existsSync as existsSync18,
   lstatSync as lstatSync2,
-  mkdirSync as mkdirSync10,
-  readFileSync as readFileSync18,
+  mkdirSync as mkdirSync11,
+  readFileSync as readFileSync19,
   renameSync as renameSync5,
   unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync11
+  writeFileSync as writeFileSync12
 } from "node:fs";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 function getTelemetrySettingsPath() {
-  return join21(getConfigDir(), TELEMETRY_SETTINGS_FILENAME);
+  return join22(getConfigDir(), TELEMETRY_SETTINGS_FILENAME);
 }
 function loadTelemetrySettings() {
   return readTelemetrySettings().settings;
@@ -71905,7 +73426,7 @@ function readTelemetrySettings() {
   }
   let content;
   try {
-    content = readFileSync18(path3, "utf-8");
+    content = readFileSync19(path3, "utf-8");
   } catch {
     return { status: "error", settings: disabledTelemetrySettings() };
   }
@@ -71938,8 +73459,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
@@ -71983,14 +73504,14 @@ var init_settings = __esm(() => {
 });
 
 // src/telemetry/debug-id.ts
-var BUNDLE_DEBUG_ID_PLACEHOLDER = "1952c680-18dc-c6aa-6475-6e2164756e21";
+var BUNDLE_DEBUG_ID_PLACEHOLDER = "cf222ab5-3069-6407-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))
@@ -72116,7 +73637,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;
@@ -72354,7 +73875,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;
@@ -72378,7 +73899,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");
@@ -72851,7 +74372,7 @@ var init_antigravity = __esm(() => {
 });
 
 // src/mcp/providers/claude.ts
-import { join as join22 } from "node:path";
+import { join as join23 } from "node:path";
 var ClaudeProvider = () => createJSONProvider({
   providerName: "Claude Code",
   providerID: "claude",
@@ -72860,24 +74381,24 @@ var ClaudeProvider = () => createJSONProvider({
   paths: ["~/.claude"],
   globalPath: "~/.claude.json",
   topKey: "mcpServers",
-  localConfigPath: (cwd) => join22(cwd, ".mcp.json")
+  localConfigPath: (cwd) => join23(cwd, ".mcp.json")
 });
 var init_claude = __esm(() => {
   init_base();
 });
 
 // src/mcp/providers/claude-desktop.ts
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 function configPath() {
-  return join23(appSupportDir(), "Claude", "claude_desktop_config.json");
+  return join24(appSupportDir(), "Claude", "claude_desktop_config.json");
 }
 var ClaudeDesktopProvider = () => ({
   name: () => "Claude Desktop",
   id: () => "claude-desktop",
   supportsLocal: () => false,
   priority: () => 2,
-  detectPaths: () => [join23(appSupportDir(), "Claude")],
-  isInstalled: () => isInstalled([join23(appSupportDir(), "Claude")]),
+  detectPaths: () => [join24(appSupportDir(), "Claude")],
+  isInstalled: () => isInstalled([join24(appSupportDir(), "Claude")]),
   globalConfigPath: () => configPath(),
   isConfigured: () => isJSONKeyConfigured(configPath(), "mcpServers"),
   install(cfg, global2) {
@@ -72907,14 +74428,14 @@ var init_claude_desktop = __esm(() => {
 });
 
 // src/mcp/providers/cline.ts
-import { join as join24 } from "node:path";
-var extensionDir = () => join24(appSupportDir(), "Code", "User", "globalStorage", "saoudrizwan.claude-dev"), ClineProvider = () => createJSONProvider({
+import { join as join25 } from "node:path";
+var extensionDir = () => join25(appSupportDir(), "Code", "User", "globalStorage", "saoudrizwan.claude-dev"), ClineProvider = () => createJSONProvider({
   providerName: "Cline",
   providerID: "cline",
   local: false,
   priorityValue: 11,
   paths: [extensionDir()],
-  globalPath: join24(extensionDir(), "settings", "cline_mcp_settings.json"),
+  globalPath: join25(extensionDir(), "settings", "cline_mcp_settings.json"),
   topKey: "mcpServers",
   buildServer: (cfg) => ({
     url: mcpURL(cfg.active_account.target.deployment_id),
@@ -72930,7 +74451,7 @@ var init_cline = __esm(() => {
 });
 
 // src/mcp/providers/cline-cli.ts
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 function clineDir() {
   return process.env.CLINE_DIR ?? expandHome("~/.cline");
 }
@@ -72940,7 +74461,7 @@ var ClineCliProvider = () => createJSONProvider({
   local: false,
   priorityValue: 12,
   paths: [clineDir()],
-  globalPath: join25(clineDir(), "data", "settings", "cline_mcp_settings.json"),
+  globalPath: join26(clineDir(), "data", "settings", "cline_mcp_settings.json"),
   topKey: "mcpServers",
   buildServer: (cfg) => ({
     url: mcpURL(cfg.active_account.target.deployment_id),
@@ -72956,20 +74477,20 @@ var init_cline_cli = __esm(() => {
 });
 
 // src/mcp/providers/codex.ts
-import { existsSync as existsSync20, readFileSync as readFileSync19 } from "node:fs";
-import { join as join26 } from "node:path";
+import { existsSync as existsSync20, readFileSync as readFileSync20 } from "node:fs";
+import { join as join27 } from "node:path";
 function codexHome2() {
   return process.env.CODEX_HOME ?? expandHome("~/.codex");
 }
 function getConfigPath2(global2) {
   if (global2)
-    return join26(codexHome2(), "config.toml");
-  return join26(process.cwd(), ".codex", "config.toml");
+    return join27(codexHome2(), "config.toml");
+  return join27(process.cwd(), ".codex", "config.toml");
 }
 function readTOML(path3) {
   if (!existsSync20(path3))
     return "";
-  return readFileSync19(path3, "utf-8");
+  return readFileSync20(path3, "utf-8");
 }
 function writeTOML(path3, content) {
   writeSecureFile(path3, content);
@@ -73032,9 +74553,9 @@ var CodexProvider = () => ({
   priority: () => 8,
   detectPaths: () => ["~/.codex"],
   isInstalled: () => isInstalled(["~/.codex"]),
-  globalConfigPath: () => join26(codexHome2(), "config.toml"),
+  globalConfigPath: () => join27(codexHome2(), "config.toml"),
   isConfigured: () => {
-    const content = readTOML(join26(codexHome2(), "config.toml"));
+    const content = readTOML(join27(codexHome2(), "config.toml"));
     return content.includes("[mcp_servers.dosu]");
   },
   install(cfg, global2) {
@@ -73056,10 +74577,10 @@ var init_codex = __esm(() => {
 });
 
 // src/mcp/providers/copilot.ts
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 function globalPath() {
   if (process.env.XDG_CONFIG_HOME) {
-    return join27(process.env.XDG_CONFIG_HOME, "mcp-config.json");
+    return join28(process.env.XDG_CONFIG_HOME, "mcp-config.json");
   }
   return expandHome("~/.copilot/mcp-config.json");
 }
@@ -73090,7 +74611,7 @@ var CopilotProvider = () => ({
       };
       installJSONServer(globalPath(), "mcpServers", server);
     } else {
-      const configPath2 = join27(process.cwd(), ".vscode", "mcp.json");
+      const configPath2 = join28(process.cwd(), ".vscode", "mcp.json");
       const server = {
         type: "http",
         url: url2,
@@ -73103,7 +74624,7 @@ var CopilotProvider = () => ({
     if (global2) {
       removeJSONServer(globalPath(), "mcpServers");
     } else {
-      const configPath2 = join27(process.cwd(), ".vscode", "mcp.json");
+      const configPath2 = join28(process.cwd(), ".vscode", "mcp.json");
       removeJSONServer(configPath2, "servers");
     }
   }
@@ -73115,7 +74636,7 @@ var init_copilot = __esm(() => {
 });
 
 // src/mcp/providers/cursor.ts
-import { join as join28 } from "node:path";
+import { join as join29 } from "node:path";
 var CursorProvider = () => createJSONProvider({
   providerName: "Cursor",
   providerID: "cursor",
@@ -73128,7 +74649,7 @@ var CursorProvider = () => createJSONProvider({
     url: mcpURL(cfg.active_account.target.deployment_id),
     headers: mcpHeaders(cfg.active_account.target.api_key)
   }),
-  localConfigPath: (cwd) => join28(cwd, ".cursor", "mcp.json")
+  localConfigPath: (cwd) => join29(cwd, ".cursor", "mcp.json")
 });
 var init_cursor = __esm(() => {
   init_config_helpers();
@@ -73136,7 +74657,7 @@ var init_cursor = __esm(() => {
 });
 
 // src/mcp/providers/factory.ts
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 var FactoryProvider = () => createJSONProvider({
   providerName: "Factory",
   providerID: "factory",
@@ -73145,14 +74666,14 @@ var FactoryProvider = () => createJSONProvider({
   paths: ["~/.factory"],
   globalPath: "~/.factory/mcp.json",
   topKey: "mcpServers",
-  localConfigPath: (cwd) => join29(cwd, ".factory", "mcp.json")
+  localConfigPath: (cwd) => join30(cwd, ".factory", "mcp.json")
 });
 var init_factory = __esm(() => {
   init_base();
 });
 
 // src/mcp/providers/gemini.ts
-import { join as join30 } from "node:path";
+import { join as join31 } from "node:path";
 var GeminiProvider = () => createJSONProvider({
   providerName: "Gemini CLI",
   providerID: "gemini",
@@ -73161,7 +74682,7 @@ var GeminiProvider = () => createJSONProvider({
   paths: ["~/.gemini"],
   globalPath: "~/.gemini/settings.json",
   topKey: "mcpServers",
-  localConfigPath: (cwd) => join30(cwd, ".gemini", "settings.json")
+  localConfigPath: (cwd) => join31(cwd, ".gemini", "settings.json")
 });
 var init_gemini = __esm(() => {
   init_base();
@@ -73212,7 +74733,7 @@ var init_manual = __esm(() => {
 
 // src/mcp/providers/mcporter.ts
 import { existsSync as existsSync21 } from "node:fs";
-import { join as join31 } from "node:path";
+import { join as join32 } from "node:path";
 function resolveGlobalConfigPath() {
   const jsonPath = expandHome("~/.mcporter/mcporter.json");
   if (existsSync21(jsonPath))
@@ -73239,7 +74760,7 @@ var MCPorterProvider = () => ({
   globalConfigPath: () => resolveGlobalConfigPath(),
   isConfigured: () => isJSONKeyConfigured(resolveGlobalConfigPath(), "mcpServers"),
   install(cfg, global2) {
-    const configPath2 = global2 ? resolveGlobalConfigPath() : join31(process.cwd(), "config", "mcporter.json");
+    const configPath2 = global2 ? resolveGlobalConfigPath() : join32(process.cwd(), "config", "mcporter.json");
     const server = {
       type: "http",
       url: mcpEndpoint4(cfg),
@@ -73248,7 +74769,7 @@ var MCPorterProvider = () => ({
     installJSONServer(configPath2, "mcpServers", server);
   },
   remove(global2) {
-    const configPath2 = global2 ? resolveGlobalConfigPath() : join31(process.cwd(), "config", "mcporter.json");
+    const configPath2 = global2 ? resolveGlobalConfigPath() : join32(process.cwd(), "config", "mcporter.json");
     removeJSONServer(configPath2, "mcpServers");
   }
 });
@@ -73259,7 +74780,7 @@ var init_mcporter = __esm(() => {
 });
 
 // src/mcp/providers/opencode.ts
-import { join as join32 } from "node:path";
+import { join as join33 } from "node:path";
 var OpenCodeProvider = () => createJSONProvider({
   providerName: "OpenCode",
   providerID: "opencode",
@@ -73274,7 +74795,7 @@ var OpenCodeProvider = () => createJSONProvider({
     enabled: true,
     headers: mcpHeaders(cfg.active_account.target.api_key)
   }),
-  localConfigPath: (cwd) => join32(cwd, "opencode.json")
+  localConfigPath: (cwd) => join33(cwd, "opencode.json")
 });
 var init_opencode = __esm(() => {
   init_config_helpers();
@@ -73282,16 +74803,16 @@ var init_opencode = __esm(() => {
 });
 
 // src/mcp/providers/vscode.ts
-import { join as join33 } from "node:path";
+import { join as join34 } from "node:path";
 var VSCodeProvider = () => createJSONProvider({
   providerName: "VS Code",
   providerID: "vscode",
   local: true,
   priorityValue: 6,
-  paths: [join33(appSupportDir(), "Code")],
-  globalPath: join33(appSupportDir(), "Code", "User", "mcp.json"),
+  paths: [join34(appSupportDir(), "Code")],
+  globalPath: join34(appSupportDir(), "Code", "User", "mcp.json"),
   topKey: "servers",
-  localConfigPath: (cwd) => join33(cwd, ".vscode", "mcp.json")
+  localConfigPath: (cwd) => join34(cwd, ".vscode", "mcp.json")
 });
 var init_vscode = __esm(() => {
   init_detect();
@@ -73300,14 +74821,14 @@ var init_vscode = __esm(() => {
 
 // src/mcp/providers/windsurf.ts
 import { homedir as homedir8 } from "node:os";
-import { join as join34 } from "node:path";
+import { join as join35 } from "node:path";
 var WindsurfProvider = () => createJSONProvider({
   providerName: "Windsurf",
   providerID: "windsurf",
   local: false,
   priorityValue: 9,
-  paths: [join34(homedir8(), ".codeium", "windsurf")],
-  globalPath: join34(homedir8(), ".codeium", "windsurf", "mcp_config.json"),
+  paths: [join35(homedir8(), ".codeium", "windsurf")],
+  globalPath: join35(homedir8(), ".codeium", "windsurf", "mcp_config.json"),
   topKey: "mcpServers"
 });
 var init_windsurf = __esm(() => {
@@ -73316,12 +74837,12 @@ var init_windsurf = __esm(() => {
 
 // src/mcp/providers/zed.ts
 import { platform as platform3 } from "node:os";
-import { join as join35 } from "node:path";
+import { join as join36 } from "node:path";
 function zedConfigDir() {
   const os3 = platform3();
   if (os3 === "darwin" || os3 === "win32")
-    return join35(appSupportDir(), "Zed");
-  return join35(appSupportDir(), "zed");
+    return join36(appSupportDir(), "Zed");
+  return join36(appSupportDir(), "zed");
 }
 var ZedProvider = () => createJSONProvider({
   providerName: "Zed",
@@ -73329,7 +74850,7 @@ var ZedProvider = () => createJSONProvider({
   local: true,
   priorityValue: 10,
   paths: [zedConfigDir()],
-  globalPath: join35(zedConfigDir(), "settings.json"),
+  globalPath: join36(zedConfigDir(), "settings.json"),
   topKey: "context_servers",
   buildServer: (cfg) => ({
     source: "custom",
@@ -73337,7 +74858,7 @@ var ZedProvider = () => createJSONProvider({
     url: mcpURL(cfg.active_account.target.deployment_id),
     headers: mcpHeaders(cfg.active_account.target.api_key)
   }),
-  localConfigPath: (cwd) => join35(cwd, ".zed", "settings.json")
+  localConfigPath: (cwd) => join36(cwd, ".zed", "settings.json")
 });
 var init_zed = __esm(() => {
   init_config_helpers();
@@ -73396,8 +74917,8 @@ var init_providers = __esm(() => {
 });
 
 // src/version/update-check.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync11, readFileSync as readFileSync20, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join36 } from "node:path";
+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);
 }
@@ -73419,14 +74940,14 @@ function isNewerVersion(latest, current) {
   return false;
 }
 function getCachePath3() {
-  return join36(getConfigDir(), CACHE_FILENAME4);
+  return join37(getConfigDir(), CACHE_FILENAME4);
 }
 function readCache() {
   try {
     const path3 = getCachePath3();
     if (!existsSync22(path3))
       return null;
-    const data = JSON.parse(readFileSync20(path3, "utf-8"));
+    const data = JSON.parse(readFileSync21(path3, "utf-8"));
     if (typeof data.lastCheck === "number" && isValidVersion(data.latestVersion)) {
       return data;
     }
@@ -73439,9 +74960,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() {
@@ -73551,14 +75072,14 @@ var init_update_check = __esm(() => {
 });
 
 // src/rules/installer.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync21, unlinkSync as unlinkSync4, writeFileSync as writeFileSync13 } from "node:fs";
+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 dirname8, join as join37 } from "node:path";
+import { dirname as dirname9, join as join38 } from "node:path";
 function claudeConfigDir() {
-  return process.env.CLAUDE_CONFIG_DIR || join37(homedir9(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR || join38(homedir9(), ".claude");
 }
 function codexHome3() {
-  return process.env.CODEX_HOME || join37(homedir9(), ".codex");
+  return process.env.CODEX_HOME || join38(homedir9(), ".codex");
 }
 function isRuleAgent(agent) {
   return Object.hasOwn(RULE_TARGETS, agent);
@@ -73584,17 +75105,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 (readFileSync21(path3, "utf-8") === content)
+  if (readFileSync22(path3, "utf-8") === content)
     return "unchanged";
-  writeFileSync13(path3, content, "utf-8");
+  writeFileSync14(path3, content, "utf-8");
   return "updated";
 }
 function findSection(content) {
@@ -73623,11 +75144,11 @@ function upsertSection(path3, content) {
   if (!existsSync23(path3)) {
     const section2 = buildSection(content);
     ensureParent(path3);
-    writeFileSync13(path3, `${section2}
+    writeFileSync14(path3, `${section2}
 `, "utf-8");
     return "created";
   }
-  const existing = readFileSync21(path3, "utf-8");
+  const existing = readFileSync22(path3, "utf-8");
   const lineEnding = lineEndingFor(existing);
   const section = buildSection(content, lineEnding);
   const location = findSection(existing);
@@ -73640,7 +75161,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) {
@@ -73663,7 +75184,7 @@ function removeRuleForAgent(agent) {
     unlinkSync4(path3);
     return { agent, path: path3, action: "removed" };
   }
-  const existing = readFileSync21(path3, "utf-8");
+  const existing = readFileSync22(path3, "utf-8");
   const lineEnding = lineEndingFor(existing);
   const location = findSection(existing);
   if (!location)
@@ -73672,7 +75193,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" };
 }
@@ -73700,36 +75221,36 @@ var init_installer = __esm(() => {
   RULE_TARGETS = {
     claude: {
       kind: "file",
-      path: () => join37(claudeConfigDir(), "rules", "dosu.md")
+      path: () => join38(claudeConfigDir(), "rules", "dosu.md")
     },
     cursor: {
       kind: "file",
-      path: () => join37(homedir9(), ".cursor", "rules", "dosu.mdc"),
+      path: () => join38(homedir9(), ".cursor", "rules", "dosu.mdc"),
       cursorFrontmatter: true
     },
     codex: {
       kind: "section",
-      path: () => join37(codexHome3(), "AGENTS.md")
+      path: () => join38(codexHome3(), "AGENTS.md")
     },
     opencode: {
       kind: "section",
-      path: () => join37(homedir9(), ".config", "opencode", "AGENTS.md")
+      path: () => join38(homedir9(), ".config", "opencode", "AGENTS.md")
     },
     gemini: {
       kind: "section",
-      path: () => join37(homedir9(), ".gemini", "GEMINI.md")
+      path: () => join38(homedir9(), ".gemini", "GEMINI.md")
     },
     antigravity: {
       kind: "section",
-      path: () => join37(homedir9(), ".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 readFileSync22, writeFileSync as writeFileSync14 } from "node:fs";
-import { join as join38 } from "node:path";
+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 {
     const stdout2 = execSync3("git rev-parse --is-inside-work-tree", {
@@ -73743,10 +75264,10 @@ function inGitWorkTree(cwd = process.cwd()) {
 }
 function dosuAgentsSectionState(cwd = process.cwd()) {
   try {
-    const path3 = join38(cwd, "AGENTS.md");
+    const path3 = join39(cwd, "AGENTS.md");
     if (!existsSync24(path3))
       return "missing";
-    const content = readFileSync22(path3, "utf-8");
+    const content = readFileSync23(path3, "utf-8");
     const startMatch = content.match(SECTION_START_RE);
     if (!startMatch || !content.includes(DOSU_SECTION_END))
       return "missing";
@@ -73781,14 +75302,14 @@ function findSection2(content) {
   return { start, end };
 }
 function upsertDosuAgentsSection(cwd = process.cwd(), content = FALLBACK_DOSU_RULE) {
-  const path3 = join38(cwd, "AGENTS.md");
+  const path3 = join39(cwd, "AGENTS.md");
   if (!existsSync24(path3)) {
     const section2 = buildDosuAgentsSection(content);
-    writeFileSync14(path3, `${section2}
+    writeFileSync15(path3, `${section2}
 `);
     return { path: path3, action: "created" };
   }
-  const existing = readFileSync22(path3, "utf-8");
+  const existing = readFileSync23(path3, "utf-8");
   const lineEnding = lineEndingFor2(existing);
   const section = renderDosuAgentsSection(content, lineEnding);
   const location = findSection2(existing);
@@ -73800,7 +75321,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) {
@@ -73882,7 +75403,7 @@ var init_alt_screen = __esm(() => {
 });
 
 // src/tui/activity-view.ts
-import { readFileSync as readFileSync23 } from "node:fs";
+import { readFileSync as readFileSync24 } from "node:fs";
 function reduceActivityViewKey(key) {
   if (key === "q" || key === ESC7 || key === CTRL_C4)
     return "back";
@@ -74127,7 +75648,7 @@ function renderActivityFrame(status, activity, width, backlog = null, pane = DEF
 }
 function defaultReadLog2() {
   try {
-    return readFileSync23(logger.getLogPath(), "utf-8");
+    return readFileSync24(logger.getLogPath(), "utf-8");
   } catch {
     return "";
   }
@@ -74212,7 +75733,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();
@@ -74229,7 +75750,7 @@ ${CLEAR_BELOW}`);
       input2.pause();
       leaveAltScreen();
       output2.write(SHOW_CURSOR3);
-      resolve6();
+      resolve7();
     };
     const onData = (chunk) => {
       for (const key of parseKeys(chunk.toString())) {
@@ -74748,8 +76269,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");
@@ -74807,8 +76328,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();
@@ -76112,7 +77633,7 @@ ${CLEAR_BELOW2}`);
     pagesPending = false;
     draw();
   });
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const wasRaw = input2.isRaw ?? false;
     input2.setRawMode?.(true);
     input2.resume();
@@ -76127,7 +77648,7 @@ ${CLEAR_BELOW2}`);
       input2.pause();
       leaveAltScreen();
       output2.write(SHOW_CURSOR4);
-      resolve6();
+      resolve7();
     };
     const onData = (chunk) => {
       for (const key of parseKeys(chunk.toString())) {
@@ -76528,7 +78049,7 @@ ${CLEAR_BELOW3}`);
     });
     draw();
   };
-  return new Promise((resolve6) => {
+  return new Promise((resolve7) => {
     const wasRaw = input2.isRaw ?? false;
     input2.setRawMode?.(true);
     input2.resume();
@@ -76540,7 +78061,7 @@ ${CLEAR_BELOW3}`);
       input2.pause();
       leaveAltScreen();
       output2.write(SHOW_CURSOR5);
-      resolve6();
+      resolve7();
     };
     const onData = (chunk) => {
       for (const key of parseKeys(chunk.toString())) {
@@ -76731,7 +78252,7 @@ async function runMainMenu() {
   const buildOptions = () => {
     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" }
       ];
     }
@@ -76747,6 +78268,7 @@ 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" },
@@ -76771,6 +78293,10 @@ async function runMainMenu() {
         await runActivityView();
         home();
         break;
+      case "report":
+        await runKnowledgeReport();
+        home();
+        break;
       case "analytics":
         await runAnalyticsView();
         home();
@@ -76798,6 +78324,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;
@@ -76925,6 +78462,7 @@ var init_tui = __esm(() => {
   init_config();
   init_agents();
   init_providers();
+  init_generate();
   init_project_dir();
   init_scan();
   init_agents_md_step();
@@ -77204,7 +78742,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(() => {
@@ -77578,7 +79116,7 @@ import {
   constants as constants3,
   fstatSync,
   openSync as openSync5,
-  readFileSync as readFileSync24,
+  readFileSync as readFileSync25,
   readSync as readSync4,
   unlinkSync as unlinkSync5
 } from "node:fs";
@@ -80708,6 +82246,7 @@ init_trpc();
 init_config();
 init_agents();
 init_formats();
+init_generate();
 init_backlog();
 init_detach();
 init_status();
@@ -80716,7 +82255,7 @@ init_watermark();
 var import_picocolors18 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync16 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { delimiter as delimiter4, join as join18 } from "node:path";
+import { delimiter as delimiter4, join as join19 } from "node:path";
 function requireConfig7() {
   const cfg = requireLoginConfig();
   if (!cfg.active_account?.target?.org_id || !cfg.active_account?.target?.space_id) {
@@ -80823,7 +82362,7 @@ ${results.length - opts.limit} more results not shown.`));
       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("--json", "Output as JSON").action(async (opts) => {
+  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) {
@@ -80838,7 +82377,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;
     }
@@ -80859,12 +82400,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;
@@ -81082,7 +82666,7 @@ function reportHookFailure(agent, err) {
 }
 function dosuOnPath() {
   const bin = process.platform === "win32" ? "dosu.cmd" : "dosu";
-  return (process.env.PATH ?? "").split(delimiter4).some((dir) => dir !== "" && existsSync16(join18(dir, bin)));
+  return (process.env.PATH ?? "").split(delimiter4).some((dir) => dir !== "" && existsSync16(join19(dir, bin)));
 }
 
 // src/commands/libraries.ts
@@ -81422,7 +83006,7 @@ init_dist();
 init_commander();
 init_trpc();
 var import_picocolors22 = __toESM(require_picocolors(), 1);
-import { readFileSync as readFileSync16 } from "node:fs";
+import { readFileSync as readFileSync17 } from "node:fs";
 function requireConfig10() {
   return requireLoginConfig();
 }
@@ -81598,7 +83182,7 @@ function reviewCommand() {
     let body = opts.body;
     if (opts.bodyFile) {
       try {
-        body = readFileSync16(opts.bodyFile, "utf-8");
+        body = readFileSync17(opts.bodyFile, "utf-8");
       } catch (err) {
         console.error(import_picocolors22.default.red(`Failed to read --body-file: ${err.message}`));
         process.exit(1);
@@ -82387,8 +83971,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 {
@@ -82742,7 +84326,7 @@ Use 'dosu mcp add <agent>' to add Dosu MCP to a tool.`);
     }
     if (opts.follow) {
       try {
-        const lines = readFileSync24(logPath, "utf-8").split(`
+        const lines = readFileSync25(logPath, "utf-8").split(`
 `);
         if (lines.at(-1) === "")
           lines.pop();
@@ -82758,7 +84342,7 @@ Use 'dosu mcp add <agent>' to add Dosu MCP to a tool.`);
     if (opts.tail !== undefined) {
       const n5 = typeof opts.tail === "string" ? parseInt(opts.tail, 10) || 50 : 50;
       try {
-        const content = readFileSync24(logPath, "utf-8");
+        const content = readFileSync25(logPath, "utf-8");
         const lines = content.split(`
 `);
         console.log(lines.slice(-n5).join(`
@@ -82829,4 +84413,4 @@ execute().catch((err) => {
   process.exit(1);
 });
 
-//# debugId=1952c680-18dc-c6aa-6475-6e2164756e21
+//# debugId=cf222ab5-3069-6407-6475-6e2164756e21