dsh-thoughtdag 0.4.20 → 0.5.1

package/lib/why.mjs

@@ -7,6 +7,7 @@ import { createInterface } from "node:readline";
 import path from "node:path";
 import os from "node:os";
 import * as zlib from "node:zlib";
+import { createHash } from "node:crypto";
 
 // ../src/utils.ts
 var idCounter = 0;
@@ -963,6 +964,12 @@ function buildGraphFromTurns2(turns, sessionId, cwd) {
 }
 
 // ../src/lib/adapters/dsh-session.ts
+function resultFailed(data) {
+  if (!data) return false;
+  if (data.error) return true;
+  const parts = data.message?.content;
+  return Array.isArray(parts) && parts.some((p) => !!p && typeof p === "object" && p.isError === true);
+}
 function partsText(content, depth = 0) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content) || depth > 2) return "";
@@ -1072,26 +1079,31 @@ ${text}` : text;
       if (!reg) return;
       const res = clipText(partsText(tr.data?.message?.content), TOOL_RESULT_LIMIT);
       const t = this.ensure();
+      const failed = resultFailed(tr.data);
       t.tools.push({
         name: reg.name,
         call: reg.call,
         result: res.text,
         truncated: reg.truncated || res.truncated,
-        op: reg.op,
+        op: failed ? "other" : reg.op,
         nativeCallId: callId,
-        ...reg.paths.length ? { paths: reg.paths } : {},
-        ...reg.url ? { url: reg.url } : {},
-        ...reg.locator ? { locator: reg.locator } : {}
+        ...failed ? {} : { ...reg.paths.length ? { paths: reg.paths } : {}, ...reg.url ? { url: reg.url } : {}, ...reg.locator ? { locator: reg.locator } : {} }
       });
       this.pendingTools.delete(callId);
       return;
     }
-    if (line.type === "tool/code-dispatch") {
+    if (line.type === "tool/code-dispatch" || line.type === "tool/ptc-dispatch") {
       const d = line.data;
       if (!d?.name || !d.subCallId) return;
       const paths = toolPaths(d.arguments);
       const scope = toolScope(d.arguments);
       if (!paths.length && !scope.url) return;
+      if (d.isError === true) {
+        const attempt = clipText(renderCall(d.name, d.arguments), TOOL_CALL_LIMIT);
+        const err = clipText(partsText(d.content), TOOL_RESULT_LIMIT);
+        this.ensure().tools.push({ name: d.name, call: attempt.text, result: err.text, truncated: attempt.truncated || err.truncated, op: "other", nativeCallId: d.subCallId });
+        return;
+      }
       const op = toolOpOf(d.name);
       const call = clipText(renderCall(d.name, d.arguments), op === "write" || op === "edit" ? ARTIFACT_CALL_LIMIT : TOOL_CALL_LIMIT);
       const res = clipText(partsText(d.content), TOOL_RESULT_LIMIT);
@@ -2008,7 +2020,7 @@ ${a.extractedText.slice(0, 4e3)}`).join("\n\n");
 
 // ../cli/src/lib.ts
 var readLike = (op) => op === "read" || op === "fetch" || op === "attach";
-var INDEX_VERSION = 10;
+var INDEX_VERSION = 13;
 var EXCERPT = 200;
 var HOME = process.env.THOUGHTDAG_HOME ?? path.join(os.homedir(), ".thoughtdag");
 var FACT_FILE = path.join(HOME, "fact-index.json");
@@ -2020,6 +2032,25 @@ var CONFIG_FILE = path.join(HOME, "config.json");
 var DSH_ROOT = path.join(process.env.DSH_HOME ?? path.join(os.homedir(), ".dsh"), "sessions");
 var PI_ROOT = path.join(os.homedir(), ".pi", "agent", "sessions");
 var ROOTS = process.env.THOUGHTDAG_SESSION_ROOTS?.split(path.delimiter).filter(Boolean) ?? [path.join(os.homedir(), ".claude", "projects"), path.join(os.homedir(), ".codex", "sessions"), DSH_ROOT, PI_ROOT];
+var MEMORY_ROOTS = (() => {
+  const env = process.env.THOUGHTDAG_MEMORY_ROOTS;
+  if (env !== void 0) {
+    return env.split(path.delimiter).filter(Boolean).flatMap((e) => {
+      const m = /^(claude-code|codex)=(.+)$/.exec(e);
+      return m ? [{ runner: m[1], root: m[2] }] : [];
+    });
+  }
+  if (process.env.THOUGHTDAG_SESSION_ROOTS) return [];
+  return [
+    { runner: "claude-code", root: path.join(os.homedir(), ".claude", "projects") },
+    { runner: "codex", root: path.join(os.homedir(), ".codex", "memories") }
+  ];
+})();
+var isMemoryFile = (file, runner) => {
+  if (!file.endsWith(".md")) return false;
+  if (runner === "claude-code") return path.basename(path.dirname(file)) === "memory" && path.basename(file) !== "MEMORY.md";
+  return true;
+};
 var CANVAS_RECORDS = path.join(HOME, "canvases");
 async function canvasRoots() {
   const env = process.env.THOUGHTDAG_CANVAS_ROOTS?.split(path.delimiter).filter(Boolean);
@@ -2062,6 +2093,11 @@ async function listSources() {
   const files = [];
   for (const root of ROOTS) await walk(root, 0, files, isSessionFile);
   for (const root of await canvasRoots()) await walk(root, 0, files, isCanvasFile);
+  for (const { runner, root } of MEMORY_ROOTS) {
+    const md = [];
+    await walk(root, 0, md, (name) => name.endsWith(".md"));
+    for (const m of md) if (isMemoryFile(m.file, runner)) files.push({ ...m, memory: runner });
+  }
   return files;
 }
 async function firstLine(file) {
@@ -2220,6 +2256,7 @@ async function eventsOf(file, sourceId) {
   return { runner, nativeId: s.sessionId, title: s.title, ...anchor ? { anchor } : {}, ...cwd ? { cwd } : {}, ...subagent ? { subagent } : {}, events, texts, manifest: MANIFESTS[runner], turns: s.turns };
 }
 async function parseSession(f) {
+  if (f.memory) return parseMemory(f, f.memory);
   const memo = /* @__PURE__ */ new Map();
   const sourceId = await canonicalPath(f.file, memo);
   const p = await eventsOf(f.file, sourceId);
@@ -2274,6 +2311,136 @@ async function parseSession(f) {
     bundles
   };
 }
+function frontmatterOf(text) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(text);
+  if (!m) return { meta: {}, body: text };
+  const meta = {};
+  for (const line of m[1].split(/\r?\n/)) {
+    const kv = /^\s*([A-Za-z_][\w-]*):\s*(.*)$/.exec(line);
+    if (kv && kv[2].trim()) meta[kv[1]] = kv[2].trim();
+  }
+  return { meta, body: text.slice(m[0].length) };
+}
+function sectionsOf(text, level) {
+  const out = [];
+  const lines = text.split(/\r?\n/);
+  let cur = null;
+  const isBoundary = (line) => {
+    const m = /^(#{1,6})\s+(.*)$/.exec(line);
+    return m && m[1].length <= level ? m[1].length : null;
+  };
+  for (const line of lines) {
+    const lvl = isBoundary(line);
+    if (lvl === level) {
+      if (cur) out.push({ heading: cur.heading, body: cur.body.join("\n").trim() });
+      cur = { heading: line.replace(/^#+\s+/, "").trim(), body: [] };
+      continue;
+    }
+    if (lvl !== null && lvl < level) {
+      if (cur) out.push({ heading: cur.heading, body: cur.body.join("\n").trim() });
+      cur = null;
+      continue;
+    }
+    if (cur) cur.body.push(line);
+  }
+  if (cur) out.push({ heading: cur.heading, body: cur.body.join("\n").trim() });
+  return out;
+}
+var metaLine = (body, key) => {
+  const m = new RegExp(`^${key}:\\s*(.+)$`, "m").exec(body);
+  return m ? m[1].trim() : void 0;
+};
+var claudeCwdMemo = /* @__PURE__ */ new Map();
+function claudeProjectCwd(projectDir) {
+  let p = claudeCwdMemo.get(projectDir);
+  if (!p) {
+    p = (async () => {
+      let entries = [];
+      try {
+        entries = (await fsp.readdir(projectDir)).filter((n) => n.endsWith(".jsonl")).sort();
+      } catch {
+        return "";
+      }
+      for (const n of entries) {
+        try {
+          const o = JSON.parse(await firstLine(path.join(projectDir, n)));
+          if (typeof o.cwd === "string" && o.cwd) return o.cwd;
+        } catch {
+        }
+      }
+      return "";
+    })();
+    claudeCwdMemo.set(projectDir, p);
+  }
+  return p;
+}
+async function memoryFile(file, runner) {
+  let text;
+  try {
+    text = await fsp.readFile(file, "utf8");
+  } catch {
+    return null;
+  }
+  const base = path.basename(file);
+  if (runner === "claude-code") {
+    const projectDir = path.dirname(path.dirname(file));
+    const cwd = await claudeProjectCwd(projectDir);
+    const { meta, body } = frontmatterOf(text);
+    const heading = meta.description || meta.name || base.replace(/\.md$/, "");
+    const project = path.basename(cwd || projectDir);
+    return { title: `memory \xB7 ${project} \xB7 ${base.replace(/\.md$/, "")}`, cwd, units: body.trim() ? [{ heading, body: body.trim() }] : [] };
+  }
+  if (base === "MEMORY.md") {
+    const units = [];
+    for (const g of sectionsOf(text, 1)) {
+      const cwd = /cwd=([^;\n]+)/.exec(metaLine(g.body, "applies_to") ?? "")?.[1]?.trim();
+      const subs2 = sectionsOf(g.body, 2);
+      if (!subs2.length) {
+        units.push({ heading: g.heading, body: g.body, ...cwd ? { cwd } : {} });
+        continue;
+      }
+      for (const u of subs2) units.push({ heading: `${g.heading} \u203A ${u.heading}`, body: u.body, ...cwd ? { cwd } : {} });
+    }
+    return { title: "memory \xB7 Codex \xB7 MEMORY.md", cwd: "", units };
+  }
+  if (base === "raw_memories.md") {
+    const units = sectionsOf(text, 2).map((u) => {
+      const cwd = metaLine(u.body, "cwd");
+      const at = metaLine(u.body, "updated_at");
+      const heading = cwd ? `${u.heading} \xB7 ${path.basename(cwd)}` : u.heading;
+      return { heading, body: u.body, ...cwd ? { cwd } : {}, ...at ? { at: new Date(at).toISOString() } : {} };
+    });
+    return { title: "memory \xB7 Codex \xB7 raw_memories.md", cwd: "", units };
+  }
+  const subs = sectionsOf(text, 2);
+  if (subs.length) return { title: `memory \xB7 Codex \xB7 ${base}`, cwd: "", units: subs };
+  const h1 = sectionsOf(text, 1)[0];
+  return { title: `memory \xB7 Codex \xB7 ${base}`, cwd: "", units: text.trim() ? [{ heading: h1?.heading ?? base, body: text.trim() }] : [] };
+}
+var shortHash = (s) => createHash("sha1").update(s).digest("hex").slice(0, 12);
+async function parseMemory(f, runner) {
+  const mf = await memoryFile(f.file, runner);
+  if (!mf || !mf.units.length) return null;
+  const memo = /* @__PURE__ */ new Map();
+  const cwd = mf.cwd ? await canonicalPath(mf.cwd, memo) : "";
+  const workspace = cwd ? await workspaceOf(cwd) : "";
+  const at = new Date(f.mtime).toISOString();
+  const turns = [];
+  const text = {};
+  for (const [i, u] of mf.units.entries()) {
+    const unitCwd = u.cwd ? await canonicalPath(u.cwd, memo) : "";
+    turns.push({ i, t: `memory#${i}`, at: u.at ?? at, q: questionExcerpt(u.heading), ops: {}, ...unitCwd && unitCwd !== cwd ? { cwd: unitCwd } : {} });
+    text[String(i)] = { q: u.heading, a: u.body };
+  }
+  const id = `mem-${runner === "codex" ? "cx" : "cc"}-${shortHash(await canonicalPath(f.file, memo))}`;
+  return {
+    fact: { id, runner, kind: "memory", file: f.file, mtime: f.mtime, size: f.size, cwd, workspace, title: mf.title, turns },
+    cache: {},
+    text,
+    names: {},
+    bundles: {}
+  };
+}
 var emptyFacts = () => ({ version: INDEX_VERSION, builtAt: "", sessions: {}, skipped: {}, names: {}, bundles: {} });
 var emptyCache = () => ({ version: INDEX_VERSION, sessions: {} });
 var emptyText = () => ({ version: INDEX_VERSION, sessions: {} });
@@ -2288,21 +2455,21 @@ async function readJson(file, empty) {
 var tmpFor = (file) => `${file}.${process.pid}.${Date.now().toString(36)}.tmp`;
 var LOCK_FILE = path.join(HOME, "index.lock");
 var LOCK_STALE_MS = 10 * 6e4;
-async function acquireLock() {
+async function acquireLock(file = LOCK_FILE, staleMs = LOCK_STALE_MS) {
   await fsp.mkdir(HOME, { recursive: true, mode: 448 });
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      const fh = await fsp.open(LOCK_FILE, "wx", 384);
+      const fh = await fsp.open(file, "wx", 384);
       await fh.writeFile(JSON.stringify({ pid: process.pid, at: Date.now() }));
       await fh.close();
       return async () => {
-        await fsp.rm(LOCK_FILE, { force: true }).catch(() => void 0);
+        await fsp.rm(file, { force: true }).catch(() => void 0);
       };
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
       let holder = {};
       try {
-        holder = JSON.parse(await fsp.readFile(LOCK_FILE, "utf8"));
+        holder = JSON.parse(await fsp.readFile(file, "utf8"));
       } catch {
       }
       const alive = (() => {
@@ -2314,9 +2481,9 @@ async function acquireLock() {
           return false;
         }
       })();
-      const stale = !alive || !holder.at || Date.now() - holder.at > LOCK_STALE_MS;
+      const stale = !alive || !holder.at || Date.now() - holder.at > staleMs;
       if (!stale) return null;
-      await fsp.rm(LOCK_FILE, { force: true }).catch(() => void 0);
+      await fsp.rm(file, { force: true }).catch(() => void 0);
     }
   }
   return null;
@@ -2501,7 +2668,8 @@ function summarize(facts, cache) {
     }
   }
   const sessions = new Set(Object.values(facts.sessions).map((s) => s.id)).size;
-  return { sessions, sources: Object.keys(facts.sessions).length, turns, artifacts, touches, changes, withChangeHead, withMention };
+  const mem = Object.values(facts.sessions).filter((s) => s.kind === "memory");
+  return { sessions, sources: Object.keys(facts.sessions).length, turns, artifacts, touches, changes, withChangeHead, withMention, memoryFiles: mem.length, memoryEntries: mem.reduce((n, s) => n + s.turns.length, 0) };
 }
 var allPaths = (facts) => {
   const all = /* @__PURE__ */ new Set();
@@ -2560,6 +2728,7 @@ function anchorStatus(facts, a) {
   return b.node === a.node ? "matched" : "mismatch";
 }
 function openLink(h) {
+  if (h.session.kind === "memory") return `thoughtdag://open?memory=${encodeURIComponent(h.session.file)}&entry=${h.turn.i}`;
   if (h.session.runner === "thoughtdag") return `thoughtdag://open?canvas=${encodeURIComponent(h.session.id)}&node=${encodeURIComponent(h.turn.t.split("#").pop() ?? "")}`;
   return `thoughtdag://open?session=${h.session.id}${h.turn.item ? `&turn=${encodeURIComponent(h.turn.item)}` : ""}`;
 }
@@ -2701,7 +2870,7 @@ async function findHits(facts, phrase, scope) {
       if (!body) continue;
       if (scope !== "all" && where.toLowerCase() !== scope) continue;
       if (!body.toLowerCase().includes(needle)) continue;
-      raw.push({ session, sourceKey: t.k, turn, where, snippet: snippetAround(body, needle) });
+      raw.push({ session, sourceKey: t.k, turn, where, snippet: snippetAround(body, needle), kind: session.kind === "memory" ? "memory" : "turn" });
       break;
     }
   }
@@ -2726,7 +2895,7 @@ function renderFind(facts, phrase, hits, limit, json) {
       turns: hits.length,
       sessions,
       evidence: { Q: "observed (a question, verbatim)", A: "observed (an answer, verbatim)", M: "observed (an attached material's text, verbatim)" },
-      hits: shown.map((h) => ({ session: h.session.id, runner: h.session.runner, title: h.session.title, turn: turnNumber(facts, h), at: h.turn.at ?? null, where: h.where, snippet: h.snippet, open: openLink(h) }))
+      hits: shown.map((h) => ({ kind: h.kind, session: h.session.id, runner: h.session.runner, title: h.session.title, cwd: h.turn.cwd ?? h.session.cwd, file: h.session.file, turn: turnNumber(facts, h), at: h.turn.at ?? null, where: h.where, snippet: h.snippet, open: openLink(h) }))
     }, null, 1));
     return out.join("\n");
   }
@@ -2734,7 +2903,7 @@ function renderFind(facts, phrase, hits, limit, json) {
 `);
   for (const h of shown) {
     const s = h.session;
-    out.push(`${when(h.turn, s)}  ${s.runner}  \u300C${s.title.slice(0, 60)}\u300D  #${turnNumber(facts, h)}  ${openLink(h)}`);
+    out.push(`${when(h.turn, s)}  ${s.runner}${h.kind === "memory" ? " memory" : ""}  \u300C${s.title.slice(0, 60)}\u300D  #${turnNumber(facts, h)}  ${openLink(h)}`);
     out.push(`    ${h.where}: ${h.snippet}`);
   }
   if (!shown.length) out.push("(nothing asked, answered or attached in those words \u2014 try another wording; matching is exact)");
@@ -2758,13 +2927,19 @@ function renderCheck(facts, arg, file, hits, json) {
   const parts = [`${hits.length} turn${hits.length === 1 ? "" : "s"} in ${sessions} session${sessions === 1 ? "" : "s"}`, changes ? `${changes} edit${changes === 1 ? "" : "s"}/write${changes === 1 ? "" : "s"}` : "", reads ? `${reads} read${reads === 1 ? "" : "s"}` : "", latest ? `latest ${latest.slice(0, 10)}` : ""].filter(Boolean);
   return { text: `${arg}: ${parts.join(" \xB7 ")}  \u2192  thoughtdag why ${arg}`, has };
 }
-async function renderRecall(facts, sidPrefix, n) {
-  const out = [];
+async function recallTurn(facts, sidPrefix, n) {
   const any = Object.values(facts.sessions).find((x) => x.id.startsWith(sidPrefix));
   if (!any) throw new Error(`no session starts with ${sidPrefix}`);
   const frag = fragmentsOf(facts, any.id).find((f) => n >= f.offset && n < f.offset + f.s.turns.length);
   const s = frag?.s ?? any;
   const local = frag ? n - frag.offset : n;
+  const base = { runner: s.runner, session: s.id, title: s.title, turn: n, file: s.file };
+  if (s.kind === "memory") {
+    const mf = await memoryFile(s.file, s.runner);
+    const u = mf?.units[local];
+    if (!u) throw new Error(`memory ${s.id.slice(0, 8)} has no entry #${n}`);
+    return { ...base, kind: "memory", at: s.turns[local]?.at, cwd: s.turns[local]?.cwd ?? s.cwd, question: u.heading, response: u.body, tools: [] };
+  }
   const p = await eventsOf(s.file);
   const turn = p?.turns?.[local] ?? (() => {
     const tid = s.turns[local]?.t;
@@ -2772,31 +2947,429 @@ async function renderRecall(facts, sidPrefix, n) {
     return text ? { question: text.question, response: text.response, tools: [], at: s.turns[local]?.at } : void 0;
   })();
   if (!turn) throw new Error(`session ${s.id.slice(0, 8)} has no turn #${n}`);
-  out.push(`${s.runner}  \u300C${s.title}\u300D  turn #${n}${turn.at ? `  ${turn.at.slice(0, 16).replace("T", " ")}` : ""}
+  return { ...base, kind: "turn", at: turn.at, cwd: s.cwd, question: turn.question, response: turn.response, tools: turn.tools };
+}
+async function renderRecall(facts, sidPrefix, n) {
+  const r = await recallTurn(facts, sidPrefix, n);
+  const out = [];
+  out.push(`${r.runner}${r.kind === "memory" ? " memory" : ""}  \u300C${r.title}\u300D  ${r.kind === "memory" ? "entry" : "turn"} #${n}${r.at ? `  ${r.at.slice(0, 16).replace("T", " ")}` : ""}
+`);
+  if (r.kind === "memory") {
+    out.push(`## ${r.question.trim()}
+
+${r.response.trim() || "(empty)"}
 `);
+    return out.join("\n");
+  }
   out.push(`## Question
 
-${turn.question.trim()}
+${r.question.trim()}
 `);
   out.push(`## Answer
 
-${turn.response.trim() || "(none)"}
+${r.response.trim() || "(none)"}
 `);
-  if (turn.tools.length) {
-    out.push(`## Tools (${turn.tools.length})
+  if (r.tools.length) {
+    out.push(`## Tools (${r.tools.length})
 `);
-    for (const t of turn.tools) {
+    for (const t of r.tools) {
       out.push(`- ${t.name}${t.paths?.length ? `  ${t.paths.join(", ")}` : ""}`);
       if (t.op === "edit" || t.op === "write") out.push(t.call.slice(0, 1200).split("\n").map((l) => `    ${l}`).join("\n"));
+      else if (t.op === "other" && /^error\b/i.test(t.result.trimStart())) out.push(`    \u2717 ${t.result.trim().split("\n")[0].slice(0, 200)}`);
     }
   }
   return out.join("\n");
 }
-var CLI_VERSION = "0.1.0";
+async function findJson(phrase, opts = {}) {
+  const facts = await ensureFresh();
+  let hits = await findHits(facts, phrase, opts.scope ?? "all");
+  if (opts.cwd) {
+    const want = opts.cwd.replace(/[\\/]+$/, "");
+    hits = hits.filter((h) => {
+      const c = h.turn.cwd ?? h.session.cwd;
+      return c === want || c.startsWith(want + path.sep);
+    });
+  }
+  const limit = opts.limit ?? 20;
+  const shown = [...hits.filter((h) => h.kind === "memory").slice(0, limit), ...hits.filter((h) => h.kind === "turn").slice(0, limit)];
+  return {
+    phrase,
+    turns: hits.length,
+    sessions: new Set(hits.map((h) => h.session.id)).size,
+    hits: shown.map((h) => ({ kind: h.kind, session: h.session.id, runner: h.session.runner, title: h.session.title, cwd: h.turn.cwd ?? h.session.cwd, file: h.session.file, turn: turnNumber(facts, h), at: h.turn.at ?? null, where: h.where, snippet: h.snippet, open: openLink(h) }))
+  };
+}
+async function recallJson(session, n) {
+  return recallTurn(await ensureFresh(), session, n);
+}
+var vocabCache = null;
+async function vocabulary() {
+  let stamp = "";
+  try {
+    const st = await fsp.stat(TEXT_LINES);
+    stamp = `${st.mtimeMs}:${st.size}`;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+  if (vocabCache && vocabCache.builtFrom === stamp) return vocabCache.counts;
+  const counts = /* @__PURE__ */ new Map();
+  const lines = createInterface({ input: createReadStream(TEXT_LINES, { encoding: "utf8", highWaterMark: 1 << 20 }) });
+  for await (const line of lines) {
+    let t;
+    try {
+      t = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    for (const body of [t.q, t.a, t.m]) {
+      if (!body) continue;
+      for (const m of body.matchAll(/[A-Za-z][A-Za-z0-9_-]{3,}/g)) {
+        const w = m[0].toLowerCase();
+        counts.set(w, (counts.get(w) ?? 0) + 1);
+      }
+    }
+  }
+  vocabCache = { builtFrom: stamp, counts };
+  return counts;
+}
+function editDistance(a, b, max) {
+  if (Math.abs(a.length - b.length) > max) return max + 1;
+  let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    const cur = [i];
+    let rowMin = i;
+    for (let j = 1; j <= b.length; j++) {
+      const v = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+      cur.push(v);
+      if (v < rowMin) rowMin = v;
+    }
+    if (rowMin > max) return max + 1;
+    prev = cur;
+  }
+  return prev[b.length];
+}
+async function suggestJson(term, k = 8) {
+  const t = term.toLowerCase().trim();
+  const counts = await vocabulary();
+  const known = counts.get(t) ?? 0;
+  if (!t || t.length < 3) return { term, known, suggestions: [] };
+  const max = t.length >= 6 ? 2 : 1;
+  const out = [];
+  for (const [w, count] of counts) {
+    if (w === t) continue;
+    const d = editDistance(t, w, max);
+    if (d <= max) out.push({ term: w, count, distance: d });
+  }
+  out.sort((a, b) => a.distance - b.distance || b.count - a.count);
+  return { term, known, suggestions: out.slice(0, k) };
+}
+var TOPICS_FILE = path.join(HOME, "topics.json");
+var TOPICS_VERSION = 1;
+var emptyTopics = () => ({ version: TOPICS_VERSION, topics: [], labels: {}, labeledAt: {}, updatedAt: "" });
+var loadTopics = async () => {
+  try {
+    const v = JSON.parse(await fsp.readFile(TOPICS_FILE, "utf8"));
+    return v.version === TOPICS_VERSION ? { ...emptyTopics(), ...v } : emptyTopics();
+  } catch {
+    return emptyTopics();
+  }
+};
+var turnKey = (k, i) => `${k}#${i}`;
+var cleanForJudge = (s) => s.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "").replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "");
+async function systemOne(call, state, questions) {
+  const body = call.wrap === "cloudflare" ? { model: call.model ?? "typesafe/jev", input: { state, questions } } : { ...call.model ? { model: call.model } : {}, state, questions };
+  const r = await fetch(call.url, { method: "POST", headers: { "Content-Type": "application/json", ...call.headers }, body: JSON.stringify(body), signal: AbortSignal.timeout(9e4) });
+  const text = await r.text();
+  let j = {};
+  try {
+    j = JSON.parse(text);
+  } catch {
+    throw new Error(`judge answered ${r.status} with non-JSON`);
+  }
+  if (!r.ok) throw new Error(typeof j.error === "string" ? j.error : j.error?.message ?? `HTTP ${r.status}`);
+  const answers = (call.wrap === "cloudflare" ? j.result?.answers : j.answers) ?? {};
+  return answers;
+}
+var labelStatus = { running: false, done: 0, total: 0, labeled: 0, errors: 0, startedAt: null, finishedAt: null, lastError: null, stopRequested: false };
+async function topicsJson() {
+  const tf = await loadTopics();
+  const text = await loadText();
+  const turns = Object.values(text.sessions).reduce((n, c) => n + c, 0);
+  const counts = /* @__PURE__ */ new Map();
+  for (const per of Object.values(tf.labels)) for (const [id, p] of Object.entries(per)) if (p >= 0.6) counts.set(id, (counts.get(id) ?? 0) + 1);
+  return { topics: tf.topics.map((t) => ({ ...t, count: counts.get(t.id) ?? 0 })), labeled: Object.keys(tf.labels).length, turns, status: { ...labelStatus } };
+}
+async function setTopics(topics) {
+  const tf = await loadTopics();
+  const clean = topics.filter((t) => t.name?.trim()).map((t) => ({ id: t.id && /^[a-z0-9_-]{1,40}$/.test(t.id) ? t.id : shortHash(t.name.trim().toLowerCase()), name: t.name.trim().slice(0, 60), description: (t.description ?? "").trim().slice(0, 240) }));
+  const keep = new Set(clean.map((t) => t.id));
+  for (const [k, per] of Object.entries(tf.labels)) {
+    for (const id of Object.keys(per)) if (!keep.has(id)) delete per[id];
+    if (!Object.keys(per).length) {
+      delete tf.labels[k];
+      delete tf.labeledAt[k];
+    }
+  }
+  tf.topics = clean;
+  tf.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writePrivate(TOPICS_FILE, tf);
+  return clean;
+}
+async function labelStart(call, opts = {}) {
+  if (labelStatus.running) return { ...labelStatus };
+  const tf = await loadTopics();
+  if (!tf.topics.length) throw new Error("no topics to label with");
+  const batch = Math.max(1, Math.min(16, opts.batch ?? 8));
+  Object.assign(labelStatus, { running: true, done: 0, total: 0, labeled: 0, errors: 0, startedAt: (/* @__PURE__ */ new Date()).toISOString(), finishedAt: null, lastError: null, stopRequested: false });
+  void (async () => {
+    try {
+      const needs = (t) => {
+        const have = tf.labels[turnKey(t.k, t.i)];
+        if (have && tf.topics.every((tp) => tp.id in have)) return false;
+        return (t.q?.trim().length ?? 0) + (t.a?.trim().length ?? 0) >= 40;
+      };
+      const open = async () => {
+        try {
+          await fsp.access(TEXT_LINES);
+          return createInterface({ input: createReadStream(TEXT_LINES, { encoding: "utf8", highWaterMark: 1 << 20 }) });
+        } catch {
+          return null;
+        }
+      };
+      const keys = [];
+      const first = await open();
+      if (first) for await (const line of first) {
+        let t;
+        try {
+          t = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (needs(t)) keys.push(turnKey(t.k, t.i));
+      }
+      const chosen = new Set(opts.max ? keys.slice(-opts.max) : keys);
+      const pending = [];
+      const second = chosen.size ? await open() : null;
+      if (second) for await (const line of second) {
+        let t;
+        try {
+          t = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (chosen.has(turnKey(t.k, t.i))) pending.push(t);
+      }
+      pending.reverse();
+      labelStatus.total = pending.length;
+      let sinceWrite = 0;
+      for (let at = 0; at < pending.length && !labelStatus.stopRequested; at += batch) {
+        const group = pending.slice(at, at + batch);
+        const state = {};
+        const questions = {};
+        group.forEach((t, gi) => {
+          state[`t${gi}`] = { q: cleanForJudge((t.q ?? "").slice(0, 300)), a: cleanForJudge((t.a ?? "").slice(0, 700)) };
+          for (const tp of tf.topics) questions[`t${gi}_${tp.id}`] = { type: "noul", instructions: `Is the turn \`t${gi}\` about the topic "${tp.name}"${tp.description ? ` (${tp.description})` : ""}?` };
+        });
+        try {
+          const answers = await systemOne(call, state, questions);
+          group.forEach((t, gi) => {
+            const key = turnKey(t.k, t.i);
+            const per = tf.labels[key] ?? {};
+            for (const tp of tf.topics) {
+              const p = answers[`t${gi}_${tp.id}`]?.noul;
+              if (typeof p === "number") per[tp.id] = Math.round(p * 100) / 100;
+            }
+            tf.labels[key] = per;
+            tf.labeledAt[key] = (/* @__PURE__ */ new Date()).toISOString();
+            labelStatus.labeled++;
+          });
+        } catch (e) {
+          labelStatus.errors++;
+          labelStatus.lastError = e instanceof Error ? e.message : String(e);
+          if (labelStatus.errors >= 5 && labelStatus.labeled === 0) break;
+          await new Promise((r) => setTimeout(r, 1500));
+        }
+        labelStatus.done = Math.min(pending.length, at + group.length);
+        sinceWrite += group.length;
+        if (sinceWrite >= 80) {
+          tf.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          await writePrivate(TOPICS_FILE, tf);
+          sinceWrite = 0;
+        }
+      }
+      tf.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await writePrivate(TOPICS_FILE, tf);
+    } catch (e) {
+      labelStatus.lastError = e instanceof Error ? e.message : String(e);
+    } finally {
+      labelStatus.running = false;
+      labelStatus.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  })();
+  return { ...labelStatus };
+}
+function labelStop() {
+  if (labelStatus.running) labelStatus.stopRequested = true;
+  return { ...labelStatus };
+}
+async function byTopicJson(topicIds, opts = {}) {
+  const tf = await loadTopics();
+  const facts = await loadFacts();
+  const minP = opts.minP ?? 0.6;
+  const want = new Set(topicIds);
+  const rows = [];
+  for (const [key, per] of Object.entries(tf.labels)) {
+    let score = 0;
+    const topics = {};
+    for (const [id, p] of Object.entries(per)) if (want.has(id) && p >= minP) {
+      score = Math.max(score, p);
+      topics[id] = p;
+    }
+    if (!score) continue;
+    const hash = key.lastIndexOf("#");
+    rows.push({ key, k: key.slice(0, hash), i: Number(key.slice(hash + 1)), score, topics });
+  }
+  const hits = [];
+  for (const r of rows) {
+    const session = facts.sessions[r.k];
+    const turn = session?.turns.find((t) => t.i === r.i);
+    if (!session || !turn) continue;
+    hits.push({ kind: session.kind === "memory" ? "memory" : "turn", session: session.id, runner: session.runner, title: session.title, cwd: turn.cwd ?? session.cwd, file: session.file, turn: turnNumber(facts, { session, sourceKey: r.k, turn }), at: turn.at ?? null, where: "Q", snippet: turn.q.slice(0, 200), open: openLink({ session, turn }), topics: r.topics, _score: r.score });
+  }
+  hits.sort((a, b) => (b._score ?? 0) - (a._score ?? 0) || (b.at ?? "").localeCompare(a.at ?? ""));
+  const total = hits.length;
+  return { hits: hits.slice(0, opts.limit ?? 60).map((h) => {
+    const { _score, ...rest } = h;
+    void _score;
+    return rest;
+  }), total };
+}
+var DOSSIERS_FILE = path.join(HOME, "dossiers.json");
+var DOSSIERS_VERSION = 1;
+var emptyDossiers = () => ({ version: DOSSIERS_VERSION, byTopic: {} });
+var loadDossiers = async () => {
+  try {
+    const v = JSON.parse(await fsp.readFile(DOSSIERS_FILE, "utf8"));
+    return v.version === DOSSIERS_VERSION ? { ...emptyDossiers(), ...v } : emptyDossiers();
+  } catch {
+    return emptyDossiers();
+  }
+};
+var emptyDossier = (topicId) => ({ topicId, sections: { what: [], decisions: [], now: [], open: [] }, sources: {}, covered: [], pending: [], changelog: [], builtAt: null, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+async function dossiersJson() {
+  const [tf, df] = await Promise.all([loadTopics(), loadDossiers()]);
+  const out = [];
+  for (const tp of tf.topics) {
+    const d = df.byTopic[tp.id];
+    const labeled = (await byTopicJson([tp.id], { limit: 5e3 })).hits.map((h) => `${h.session}#${h.turn}`);
+    const covered = new Set(d?.covered ?? []);
+    const s = d?.sections;
+    const sentences = s ? s.what.length + s.decisions.length + s.now.length + s.open.length : 0;
+    out.push({ topicId: tp.id, name: tp.name, built: !!d?.builtAt, builtAt: d?.builtAt ?? null, updatedAt: d?.updatedAt ?? "", lead: s?.what[0]?.text ?? s?.now[0]?.text ?? "", sentences, covered: covered.size, pending: d?.pending.length ?? 0, newTurns: labeled.filter((k) => !covered.has(k)).length, labeled: labeled.length });
+  }
+  return out;
+}
+async function dossierJson(topicId) {
+  return (await loadDossiers()).byTopic[topicId] ?? null;
+}
+var DOSSIERS_LOCK = path.join(HOME, "dossiers.lock");
+var DOSSIERS_LOCK_WAIT_MS = 5e3;
+var dossierWrites = Promise.resolve();
+async function withDossiers(fn) {
+  const run = async () => {
+    let release = null;
+    const deadline = Date.now() + DOSSIERS_LOCK_WAIT_MS;
+    while (!(release = await acquireLock(DOSSIERS_LOCK, 3e4)) && Date.now() < deadline) await new Promise((r) => setTimeout(r, 60));
+    try {
+      const df = await loadDossiers();
+      const out = fn(df);
+      await writePrivate(DOSSIERS_FILE, df);
+      return out;
+    } finally {
+      await release?.();
+    }
+  };
+  const p = dossierWrites.then(run, run);
+  dossierWrites = p.catch(() => void 0);
+  return p;
+}
+async function setDossier(topicId, d) {
+  return withDossiers((df) => {
+    const cur = df.byTopic[topicId] ?? emptyDossier(topicId);
+    const { consumePending, ...rest } = d;
+    const patch = Object.fromEntries(Object.entries(rest).filter(([, v]) => v !== void 0));
+    const next = { ...cur, ...patch, topicId, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    if (consumePending) {
+      const read = new Set(consumePending);
+      next.pending = cur.pending.filter((p) => !read.has(p.id));
+    }
+    df.byTopic[topicId] = next;
+    return next;
+  });
+}
+async function deleteDossier(topicId) {
+  await withDossiers((df) => {
+    delete df.byTopic[topicId];
+  });
+}
+async function dossierAddPending(topicId, item) {
+  return withDossiers((df) => {
+    const cur = df.byTopic[topicId] ?? emptyDossier(topicId);
+    cur.pending.push({ id: shortHash(`${Date.now()}:${cur.pending.length}:${item.text}`), text: item.text.slice(0, 400), at: (/* @__PURE__ */ new Date()).toISOString(), ...item.from ? { from: item.from } : {} });
+    cur.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    df.byTopic[topicId] = cur;
+    return cur;
+  });
+}
+async function dossierNewTurns(topicId, opts = {}) {
+  const d = (await loadDossiers()).byTopic[topicId];
+  const covered = new Set(d?.covered ?? []);
+  const all = await byTopicJson([topicId], { limit: 5e3 });
+  const fresh = all.hits.filter((h) => !covered.has(`${h.session}#${h.turn}`));
+  const sorted = fresh.sort((a, b) => (b.at ?? "").localeCompare(a.at ?? "")).slice(0, opts.limit ?? 120);
+  const excerpts = [];
+  for (const h of sorted) {
+    try {
+      const r = await recallJson(h.session, h.turn);
+      excerpts.push({ key: `${h.session}#${h.turn}`, q: r.question.replace(/\s+/g, " ").slice(0, 300), a: r.response.replace(/\s+/g, " ").slice(0, 600) });
+    } catch {
+    }
+  }
+  return { hits: sorted, excerpts, total: fresh.length };
+}
+async function sampleQuestions(n = 120) {
+  const out = [];
+  let lines = null;
+  try {
+    await fsp.access(TEXT_LINES);
+    lines = createInterface({ input: createReadStream(TEXT_LINES, { encoding: "utf8", highWaterMark: 1 << 20 }) });
+  } catch {
+    return out;
+  }
+  const all = [];
+  for await (const line of lines) {
+    let t;
+    try {
+      t = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const q = (t.q ?? "").trim();
+    if (q.length >= 20 && q.length <= 400) all.push(q);
+  }
+  const step = Math.max(1, Math.floor(all.length / n));
+  for (let i = 0; i < all.length && out.length < n; i += step) out.push(all[i].slice(0, 200));
+  return out;
+}
+async function memoriesJson() {
+  const facts = await ensureFresh();
+  return Object.values(facts.sessions).filter((x) => x.kind === "memory").sort((a, b) => b.mtime - a.mtime).map((x) => ({ id: x.id, runner: x.runner, file: x.file, title: x.title, cwd: x.cwd, entries: x.turns.length, mtime: x.mtime, headings: x.turns.map((t) => t.q) }));
+}
+var CLI_VERSION = "0.2.1";
 var MCP_TOOLS = [
   { name: "why_check", description: "Cheap first question before editing a file: does this artifact have any history in local agent sessions? One line; history true/false.", inputSchema: { type: "object", properties: { path: { type: "string", description: "file path (absolute or relative to cwd), URL, or arxiv:<id>" } }, required: ["path"] } },
   { name: "why_file", description: "The turns across local Claude Code, Codex, DeepSeek Harness, Pi and ThoughtDAG sessions that touched a file, URL or paper: when, what changed (\u0394, observed), what was asked, what the answer said about it (\u2248, a candidate explanation, not a verified reason). Each hit carries a deep link.", inputSchema: { type: "object", properties: { path: { type: "string" }, include_read: { type: "boolean", description: "also list turns that only read it (default false)" }, limit: { type: "number", description: "max hits (default 10)" } }, required: ["path"] } },
-  { name: "find", description: "Where these exact words were asked (Q), answered (A) or attached (M) across local sessions and canvases. Exact, case-insensitive match; every hit is a verbatim snippet with a pointer.", inputSchema: { type: "object", properties: { phrase: { type: "string" }, in: { type: "string", enum: ["q", "a", "m", "all"] }, limit: { type: "number" } }, required: ["phrase"] } },
+  { name: "find", description: "Where these exact words were asked (Q), answered (A) or attached (M) across local sessions, canvases and the memories Claude Code and Codex keep for themselves. Exact, case-insensitive match; every hit is a verbatim snippet with a pointer.", inputSchema: { type: "object", properties: { phrase: { type: "string" }, in: { type: "string", enum: ["q", "a", "m", "all"] }, limit: { type: "number" } }, required: ["phrase"] } },
   { name: "recall_turn", description: "One turn in full \u2014 the question, the answer, the tool calls with their diffs \u2014 by session id (or prefix) and turn number as shown by why_file.", inputSchema: { type: "object", properties: { session: { type: "string" }, turn: { type: "number" } }, required: ["session", "turn"] } }
 ];
 async function mcpCall(name, a) {
@@ -2835,21 +3408,38 @@ export {
   TEXT_LINES,
   artifactsLine,
   buildIndex,
+  byTopicJson,
+  deleteDossier,
+  dossierAddPending,
+  dossierJson,
+  dossierNewTurns,
+  dossiersJson,
   ensureFresh,
   eventsOf,
   factsForCheck,
   findHits,
+  findJson,
   hitsFor,
+  labelStart,
+  labelStop,
   loadCache,
   loadFacts,
   mcpCall,
+  memoriesJson,
+  recallJson,
+  recallTurn,
   renderCheck,
   renderFind,
   renderRecall,
   renderWhy,
   resolveQuery,
+  sampleQuestions,
+  setDossier,
   setQuiet,
+  setTopics,
+  suggestJson,
   summarize,
+  topicsJson,
   when,
   zstdSkipped
 };