sphica 0.4.0 → 0.5.0

package/dist/capture.js

@@ -2,9 +2,9 @@
 
 // server/src/capture.ts
 import { spawn } from "node:child_process";
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 import os3 from "node:os";
-import path3 from "node:path";
+import path5 from "node:path";
 
 // server/node_modules/kysely/dist/util/object-utils.js
 function isUndefined(obj) {
@@ -10813,7 +10813,8 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { constants as C, DatabaseSync } from "node:sqlite";
-var SCHEMA_REVISION = 7;
+var SCHEMA_GENERATION = 2;
+var SCHEMA_REVISION = 1;
 var dbFile = () => process.env.SPHICA_DB || path.join(os.homedir(), ".sphica", "sphica.db");
 function requireRuntime() {
   const proto = DatabaseSync.prototype;
@@ -10824,18 +10825,35 @@ function requireFile(file) {
   if (!fs.existsSync(file))
     throw new Error(`No database at ${file}. Create it with \`sphica init\`.`);
 }
-function prepare(raw, checkVersion) {
+function prepare(raw, check) {
   raw.enableDefensive(true);
   raw.exec("pragma foreign_keys = on");
   raw.exec("pragma busy_timeout = 5000");
-  if (!checkVersion)
+  if (check === "none")
+    return;
+  checkGeneration(raw);
+  if (check === "generation")
     return;
   const got = raw.prepare("pragma user_version").get()?.user_version;
   if (got === SCHEMA_REVISION)
     return;
-  if (!got)
+  throw new Error(`The database schema is revision ${got}, but this Sphica expects revision ${SCHEMA_REVISION}. ` + ((got ?? 0) < SCHEMA_REVISION ? "Move it aside (it is left unchanged), then run `sphica init`." : "Update sphica."));
+}
+function generationOf(raw) {
+  const has = raw.prepare("select 1 from sqlite_schema where type = 'table' and name = 'sphica_generation'").get();
+  if (!has) {
+    const any = raw.prepare("select 1 from sqlite_schema where type = 'table' and name = 'project'").get();
+    return any ? 1 : null;
+  }
+  return raw.prepare("select generation from sphica_generation").get()?.generation ?? null;
+}
+function checkGeneration(raw) {
+  const got = generationOf(raw);
+  if (got === SCHEMA_GENERATION)
+    return;
+  if (got === null)
     throw new Error("The database has no sphica schema. Create it with `sphica init`.");
-  throw new Error(`The database schema is revision ${got}, but this Sphica expects revision ${SCHEMA_REVISION}. ` + (got < SCHEMA_REVISION ? "Run `sphica db migrate`." : "Update sphica."));
+  throw new Error(got < SCHEMA_GENERATION ? "The database was made by Sphica 0.4 or earlier, and this Sphica cannot read it. Move it aside (it is left unchanged), then run `sphica init`." : "The database was made by a newer Sphica. Update sphica.");
 }
 var READER_FUNCTIONS = new Set([
   "bm25",
@@ -10853,10 +10871,10 @@ var READER_FUNCTIONS = new Set([
   "min",
   "substr"
 ]);
-var SHADOW = /^(knowledge|message)_fts_(data|idx|docsize|config)$/;
+var SHADOW = /^(unit|source)_fts_(data|idx|docsize|config)$/;
 
 // server/src/db.ts
-var JSON_COLUMNS = new Set(["refs", "downsides", "next", "files", "paths"]);
+var JSON_COLUMNS = new Set(["next"]);
 var TOP_LEVEL = /^\$\[\d+\]\."([^"]+)"$/;
 var parseJson = new ParseJSONResultsPlugin({
   shouldParse: (_value, jsonPath) => JSON_COLUMNS.has(jsonPath.match(TOP_LEVEL)?.[1] ?? "")
@@ -10901,13 +10919,27 @@ var HIRAGANA_ONLY = /^[\p{Script=Hiragana}ー]+$/u;
 var STOP = new Set(["the", "a", "an", "of", "to", "in", "is", "and", "or", "for", "on", "it", "be"]);
 var IDENT = /#\d+|[a-z0-9][a-z0-9_./#-]*[a-z0-9]/g;
 var MAX_TERM = 100;
+var OKURIGANA = /^(\p{Script=Han}+)[\p{Script=Hiragana}ー]+$/u;
+function singular(w) {
+  if (!/^[a-z]{4,}$/.test(w))
+    return w;
+  if (w.endsWith("ies"))
+    return `${w.slice(0, -3)}y`;
+  if (w.endsWith("ie"))
+    return `${w.slice(0, -2)}y`;
+  if (/(?:ss|us|x|z|ch|sh)es$/.test(w))
+    return w.slice(0, -2);
+  if (/(?:ch|sh|us)e$/.test(w))
+    return w.slice(0, -1);
+  return w.endsWith("s") && !/(?:ss|us|is)$/.test(w) ? w.slice(0, -1) : w;
+}
 function terms(text) {
   const norm = text.normalize("NFKC").toLowerCase();
   const out = [];
   const keep = (w) => {
     if (w.length > MAX_TERM || STOP.has(w) || HIRAGANA_ONLY.test(w))
       return;
-    out.push(w);
+    out.push(OKURIGANA.exec(w)?.[1] ?? singular(w));
   };
   for (const s of segmenter.segment(norm))
     if (s.isWordLike)
@@ -10917,6 +10949,48 @@ function terms(text) {
       keep(m[0]);
   return out.filter(Boolean);
 }
+var QUESTION = new Set([
+  ...[
+    "why",
+    "what",
+    "which",
+    "when",
+    "where",
+    "who",
+    "how",
+    "do",
+    "does",
+    "did",
+    "we",
+    "our",
+    "us",
+    "you",
+    "i",
+    "are",
+    "was",
+    "were"
+  ],
+  ...[
+    "will",
+    "would",
+    "should",
+    "can",
+    "could",
+    "there",
+    "this",
+    "that",
+    "with",
+    "from",
+    "any",
+    "ever",
+    "long",
+    "use",
+    "used",
+    "using"
+  ],
+  ...["add", "get", "make", "have", "has", "not", "no", "yes", "reason"],
+  ...["理由", "仕組", "何", "方", "場合", "今", "件"]
+]);
 var sha256 = (s) => crypto.createHash("sha256").update(s).digest();
 function uuidFrom(...parts) {
   const b = crypto.createHash("sha256").update(parts.join("\x00")).digest().subarray(0, 16);
@@ -11110,16 +11184,21 @@ var DDL = () => ddl ??= new Set([
   return code;
 }));
 var readsDataVersion = (p1, p2) => p1 === "data_version" && p2 === null;
-var CAPTURE_VIEWS = new Set(["capture_conversation", "capture_message", "capture_message_file"]);
+var CAPTURE_VIEWS = new Set(["capture_session", "capture_message", "capture_edit", "capture_delivery"]);
 var TRIGGER_WRITES = {
-  capture_conversation_insert: new Set(["conversation"]),
-  capture_message_insert: new Set(["message"]),
-  capture_message_file_insert: new Set(["message_file"]),
-  message_fts_ai: new Set(["message_fts"])
+  capture_session_insert: new Set(["session"]),
+  capture_message_insert: new Set(["source"]),
+  capture_edit_insert: new Set(["edit_observation"]),
+  capture_delivery_insert: new Set(["delivery", "delivery_unit"]),
+  source_fts_ai: new Set(["source_fts"])
+};
+var TRIGGER_FUNCTIONS = {
+  capture_delivery_insert: new Set(["coalesce", "json_each", "last_insert_rowid"])
 };
 var CAPTURE_READS = {
   project: new Set(["id", "key", "name"]),
-  message: new Set(["id"])
+  session: new Set(["id"]),
+  source: new Set(["id", "session_id", "external_id", "kind"])
 };
 function captureAuthorizer(own, action, p1, p2, triggerOrView) {
   const table = p1 ?? "";
@@ -11139,7 +11218,7 @@ function captureAuthorizer(own, action, p1, p2, triggerOrView) {
     return CAPTURE_READS[table]?.has(p2 ?? "") ? C2.SQLITE_OK : C2.SQLITE_DENY;
   }
   if (action === C2.SQLITE_FUNCTION)
-    return p2 === "sphica_terms" ? C2.SQLITE_OK : C2.SQLITE_DENY;
+    return p2 === "sphica_terms" || triggerOrView !== null && TRIGGER_FUNCTIONS[triggerOrView]?.has(p2 ?? "") ? C2.SQLITE_OK : C2.SQLITE_DENY;
   if (action === C2.SQLITE_PRAGMA)
     return readsDataVersion(p1, p2) ? C2.SQLITE_OK : C2.SQLITE_DENY;
   if (action === C2.SQLITE_SELECT || action === C2.SQLITE_TRANSACTION || action === C2.SQLITE_SAVEPOINT)
@@ -11159,7 +11238,7 @@ function connectWriter(role, file = dbFile(), create = false) {
     requireFile(file);
   const raw = new DatabaseSync2(file);
   try {
-    prepare(raw, role === "ingest");
+    prepare(raw, create ? "none" : role === "ingest" ? "revision" : "generation");
     raw.function("sphica_terms", { deterministic: true }, (text) => terms(String(text ?? "")).join(" "));
   } catch (e) {
     raw.close();
@@ -11190,8 +11269,7 @@ function openWriter(role, file = dbFile()) {
 }
 
 // server/src/knowledge.ts
-var indexesMessage = (speakerKind) => speakerKind === "self";
-var conversationId = (projectId, origin, externalId) => uuidFrom(String(projectId), origin, externalId);
+var sessionId = (projectId, host, externalId) => uuidFrom(String(projectId), host, externalId);
 
 // server/src/panel.ts
 import { stripVTControlCharacters, styleText } from "node:util";
@@ -11210,8 +11288,15 @@ var plain2 = (s) => visible(stripVTControlCharacters(s.replace(STRING_SEQUENCE,
 import { execFileSync } from "node:child_process";
 import fs2 from "node:fs";
 import os2 from "node:os";
+import path3 from "node:path";
+
+// server/src/anchors.ts
 import path2 from "node:path";
-var localFile = () => path2.join(os2.homedir(), ".sphica", "projects.json");
+var MAX_BYTES = 2 * 1024 * 1024;
+var leaves = (rel) => rel === ".." || rel.startsWith(`..${path2.sep}`) || path2.isAbsolute(rel);
+
+// server/src/project.ts
+var localFile = () => path3.join(os2.homedir(), ".sphica", "projects.json");
 var LOCAL_KEY = /^[a-z0-9][a-z0-9._-]*$/;
 function normalizeRemote(url) {
   const raw = String(url ?? "").trim();
@@ -11256,32 +11341,32 @@ function localMap() {
   } catch {
     m = null;
   }
-  if (!m || typeof m !== "object" || Array.isArray(m) || Object.entries(m).some(([root, name]) => !path2.isAbsolute(root) || typeof name !== "string" || !LOCAL_KEY.test(name)))
+  if (!m || typeof m !== "object" || Array.isArray(m) || Object.entries(m).some(([root, name]) => !path3.isAbsolute(root) || typeof name !== "string" || !LOCAL_KEY.test(name)))
     throw new Error(`${localFile()} is not a valid JSON project table. Fix or delete it, then name the project again.`);
   return m;
 }
 function identify(dir) {
-  const given = path2.resolve(dir);
+  const given = path3.resolve(dir);
   const top = git(given, "rev-parse", "--show-toplevel");
   const root = top || given;
   const remote = top ? normalizeRemote(git(root, "remote", "get-url", "origin")) : null;
   if (remote)
     return { key: `git:${remote}`, root, name: remote.split("/").slice(1).join("/") || remote };
   const map = localMap();
-  for (let d = root;; d = path2.dirname(d)) {
+  for (let d = root;; d = path3.dirname(d)) {
     const local = map[d];
     if (local && LOCAL_KEY.test(local))
       return { key: `local:${local}`, root: d, name: local };
-    if (top || path2.dirname(d) === d)
+    if (top || path3.dirname(d) === d)
       return null;
   }
 }
 function relativeTo(root, file, cwd = root) {
-  const abs = path2.resolve(cwd, file);
-  const rel = path2.relative(root, abs);
-  if (!rel || rel === ".." || rel.startsWith(`..${path2.sep}`) || path2.isAbsolute(rel))
+  const abs = path3.resolve(cwd, file);
+  const rel = path3.relative(root, abs);
+  if (!rel || leaves(rel))
     return null;
-  return rel.split(path2.sep).join("/");
+  return rel.split(path3.sep).join("/");
 }
 function patchPaths(patch) {
   const out = [];
@@ -11294,23 +11379,104 @@ function patchPaths(patch) {
   return out;
 }
 
+// server/src/worktree.ts
+import { execFileSync as execFileSync2 } from "node:child_process";
+import fs3 from "node:fs";
+import path4 from "node:path";
+var MAX_PATHS = 200;
+var git2 = (root, args) => {
+  try {
+    return execFileSync2("git", ["-C", root, ...args], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 5000,
+      maxBuffer: 16 * 1024 * 1024
+    });
+  } catch {
+    return null;
+  }
+};
+var usable = (p) => p !== "" && !p.includes("\\");
+function snapshot(root) {
+  const out = git2(root, ["status", "--porcelain=v2", "-z", "--untracked-files=all"]);
+  if (out === null)
+    return null;
+  const fields = out.split("\x00");
+  const entries = {};
+  for (let i = 0;i < fields.length; i++) {
+    const f = fields[i] ?? "";
+    const skip = { "1": 8, "2": 9, u: 10, "?": 1 }[f[0] ?? ""];
+    if (!skip)
+      continue;
+    const parts = f.split(" ");
+    const p = parts.slice(skip).join(" ");
+    if (f[0] === "2")
+      i++;
+    if (!usable(p))
+      continue;
+    let st;
+    try {
+      st = fs3.lstatSync(path4.join(root, p), { throwIfNoEntry: false });
+    } catch {
+      st = undefined;
+    }
+    entries[p] = `${parts.slice(0, skip).join(" ")} ${st ? `${st.size}:${st.mtimeMs}` : "gone"}`;
+  }
+  const head2 = git2(root, ["rev-parse", "--verify", "-q", "HEAD"])?.trim() || null;
+  return { head: head2, entries };
+}
+function changed(root, before, after) {
+  const paths = new Set;
+  for (const p of new Set([...Object.keys(before.entries), ...Object.keys(after.entries)]))
+    if (before.entries[p] !== after.entries[p])
+      paths.add(p);
+  if (before.head && after.head && before.head !== after.head && git2(root, ["merge-base", "--is-ancestor", before.head, after.head]) !== null) {
+    for (const p of (git2(root, ["diff", "--name-only", "-z", before.head, after.head]) ?? "").split("\x00"))
+      if (usable(p))
+        paths.add(p);
+  }
+  return [...paths].sort().slice(0, MAX_PATHS);
+}
+
 // server/src/capture.ts
-var spoolDir = () => path3.join(os3.homedir(), ".sphica", "spool");
-var stateFile = () => path3.join(os3.homedir(), ".sphica", "capture.json");
-var rejectedDir = () => path3.join(spoolDir(), "rejected");
-var unregisteredDir = () => path3.join(spoolDir(), "unregistered");
+var spoolDir = () => path5.join(os3.homedir(), ".sphica", "spool");
+var stateFile = () => path5.join(os3.homedir(), ".sphica", "capture.json");
+var rejectedDir = () => path5.join(spoolDir(), "rejected");
+var unregisteredDir = () => path5.join(spoolDir(), "unregistered");
 var HOLD_DAYS = 30;
 var HOLD_MAX = 1000;
+var baselineDir = () => path5.join(os3.homedir(), ".sphica", "worktree");
+function current(raw) {
+  const r = raw;
+  if (r.v === 2)
+    return raw;
+  if (r.v !== 1)
+    throw new Error(`unknown queue record version ${String(r.v)}`);
+  const old = raw;
+  if (old.kind === "message")
+    return {
+      ...old,
+      v: 2,
+      kind: "message",
+      speaker: old.speaker === "self" ? "owner" : "assistant",
+      redacted: false
+    };
+  if (old.action !== "edit")
+    return null;
+  return { ...old, v: 2, kind: "edit", event: null, path: old.path, via: "tool" };
+}
 var MAX_MESSAGE = 128 * 1024;
 var KEEP = 8 * 1024;
 function fit(body) {
   const all = bytes(body);
   if (all <= MAX_MESSAGE) {
     const kept = mask(body);
-    return { body: kept, truncated: false, originalBytes: bytes(kept) };
+    return { body: kept, truncated: false, redacted: kept !== body, originalBytes: all };
   }
-  const a = head(mask(head(body, KEEP * 2)), KEEP);
-  const z = tail(mask(tail(body, KEEP * 2)), KEEP);
+  const start = head(body, KEEP * 2);
+  const end = tail(body, KEEP * 2);
+  const a = head(mask(start), KEEP);
+  const z = tail(mask(end), KEEP);
   const cut = all - bytes(a) - bytes(z);
   return {
     body: `${a}
@@ -11319,13 +11485,14 @@ function fit(body) {
 
 ${z}`,
     truncated: true,
+    redacted: mask(start) !== start || mask(end) !== end,
     originalBytes: all
   };
 }
 function prune(held) {
   let files;
   try {
-    files = fs3.readdirSync(held).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort();
+    files = fs4.readdirSync(held).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort();
   } catch {
     return;
   }
@@ -11333,21 +11500,21 @@ function prune(held) {
   const stale = files.filter((f) => Number(f.split("-")[0]) < cutoff);
   const over = files.slice(0, Math.max(0, files.length - HOLD_MAX));
   for (const f of new Set([...stale, ...over]))
-    fs3.rmSync(path3.join(held, f), { force: true });
+    fs4.rmSync(path5.join(held, f), { force: true });
 }
 function spool(record) {
   const dir = spoolDir();
-  fs3.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs4.mkdirSync(dir, { recursive: true, mode: 448 });
   const name = `${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 10)}.json`;
-  const tmp = path3.join(dir, `.${name}`);
-  fs3.writeFileSync(tmp, JSON.stringify(record), { mode: 384 });
-  fs3.renameSync(tmp, path3.join(dir, name));
+  const tmp = path5.join(dir, `.${name}`);
+  fs4.writeFileSync(tmp, JSON.stringify(record), { mode: 384 });
+  fs4.renameSync(tmp, path5.join(dir, name));
 }
 var branchOf = (root) => {
   try {
-    const dotgit = path3.join(root, ".git");
-    const gitdir = fs3.statSync(dotgit).isFile() ? path3.resolve(root, fs3.readFileSync(dotgit, "utf8").match(/^gitdir: (.+)$/m)?.[1]?.trim() ?? "") : dotgit;
-    const h = fs3.readFileSync(path3.join(gitdir, "HEAD"), "utf8").trim();
+    const dotgit = path5.join(root, ".git");
+    const gitdir = fs4.statSync(dotgit).isFile() ? path5.resolve(root, fs4.readFileSync(dotgit, "utf8").match(/^gitdir: (.+)$/m)?.[1]?.trim() ?? "") : dotgit;
+    const h = fs4.readFileSync(path5.join(gitdir, "HEAD"), "utf8").trim();
     return h.startsWith("ref: refs/heads/") ? h.slice("ref: refs/heads/".length) : null;
   } catch {
     return null;
@@ -11368,63 +11535,30 @@ var INJECTED = [
   /^(?:Another Claude|A peer) session sent a message(?: while you were working)?:/
 ];
 var digest = (s) => sha256(s).toString("hex").slice(0, 16);
-var saidDir = () => path3.join(spoolDir(), "said");
-var RENAME_TRIES = 20;
-var RENAME_WAIT_MS = 15;
-var sleepSync = (ms) => {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-};
-function remember(session, id) {
-  const dir = saidDir();
-  fs3.mkdirSync(dir, { recursive: true, mode: 448 });
-  const file = path3.join(dir, uuidFrom(session));
-  const tmp = `${file}.${process.pid}`;
-  fs3.writeFileSync(tmp, id, { mode: 384 });
-  for (let i = 0;; i++) {
-    try {
-      fs3.renameSync(tmp, file);
-      break;
-    } catch (e) {
-      const code = e.code;
-      if (i >= RENAME_TRIES || code !== "EPERM" && code !== "EBUSY") {
-        fs3.rmSync(tmp, { force: true });
-        throw e;
-      }
-      sleepSync(RENAME_WAIT_MS);
-    }
-  }
-  const old = Date.now() - 30 * 86400000;
-  for (const f of fs3.readdirSync(dir)) {
-    const st = fs3.statSync(path3.join(dir, f), { throwIfNoEntry: false });
-    if (st && st.mtimeMs < old)
-      fs3.rmSync(path3.join(dir, f), { force: true });
-  }
-}
-function lastSaid(session) {
-  try {
-    return fs3.readFileSync(path3.join(saidDir(), uuidFrom(session)), "utf8");
-  } catch {
-    return null;
-  }
-}
 function answersOf(input) {
   const response = input.tool_response;
   const answers = response?.answers;
   if (!answers || typeof answers !== "object")
     return null;
-  const lines = Object.entries(answers).map(([q, a]) => {
-    const notes = response?.annotations?.[q]?.notes;
-    const memo = typeof notes === "string" && notes.trim() ? `
+  const pairs = Object.entries(answers);
+  if (!pairs.length)
+    return null;
+  return {
+    questions: pairs.map(([q], i) => `Q${i + 1}: ${q}`).join(`
+
+`),
+    answers: pairs.map(([q, a], i) => {
+      const notes = response?.annotations?.[q]?.notes;
+      const memo = typeof notes === "string" && notes.trim() ? `
 Notes: ${notes.trim()}` : "";
-    return `Q: ${q}
-A: ${Array.isArray(a) ? a.join(" / ") : String(a)}${memo}`;
-  });
-  return lines.length ? lines.join(`
+      return `A${i + 1}: ${Array.isArray(a) ? a.join(" / ") : String(a)}${memo}`;
+    }).join(`
 
-`) : null;
+`)
+  };
 }
 function captureNotice(file = dbFile()) {
-  if (!fs3.existsSync(file))
+  if (!fs4.existsSync(file))
     return panel("sphica: no database, so conversations are not recorded", [file], "Create it with sphica init");
   const s = readState();
   if (s.stuck)
@@ -11433,6 +11567,34 @@ function captureNotice(file = dbFile()) {
     return panel(`sphica: the database rejected ${plural(s.rejected, "record")}`, [rejectedDir(), `Move them back to ${spoolDir()} to resend`], "Fix them first, then check with sphica doctor");
   return null;
 }
+var baselineFile = (host, session) => path5.join(baselineDir(), `${digest(`${host}\x00${session}`)}.json`);
+function readBaseline(file) {
+  try {
+    return JSON.parse(fs4.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeBaseline(file, b) {
+  fs4.mkdirSync(path5.dirname(file), { recursive: true, mode: 448 });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs4.writeFileSync(tmp, JSON.stringify(b), { mode: 384 });
+  fs4.renameSync(tmp, file);
+}
+function pruneBaselines() {
+  const cutoff = Date.now() - HOLD_DAYS * 24 * 60 * 60 * 1000;
+  let files;
+  try {
+    files = fs4.readdirSync(baselineDir());
+  } catch {
+    return;
+  }
+  for (const f of files) {
+    const file = path5.join(baselineDir(), f);
+    if ((fs4.statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? Date.now()) < cutoff)
+      fs4.rmSync(file, { force: true });
+  }
+}
 function onHook(host, input) {
   const event = input.hook_event_name;
   const owner = () => isOwnerTurn(input, undefined, undefined, host === "codex" ? process.env.CODEX_THREAD_ID : undefined);
@@ -11441,9 +11603,14 @@ function onHook(host, input) {
       return { flush: false };
     const file = process.env.CLAUDE_ENV_FILE;
     if (file && input.session_id && /^[A-Za-z0-9_-]+$/.test(input.session_id)) {
-      fs3.appendFileSync(file, `export SPHICA_PARENT_SESSION=${input.session_id}
+      fs4.appendFileSync(file, `export SPHICA_PARENT_SESSION=${input.session_id}
 `);
     }
+    const place2 = identify(input.cwd ?? process.cwd());
+    const now = place2 && snapshot(place2.root);
+    if (now)
+      writeBaseline(baselineFile(host, String(input.session_id)), { ...now, running: false });
+    pruneBaselines();
     return { flush: false, notice: captureNotice() };
   }
   if (!owner())
@@ -11458,7 +11625,7 @@ function onHook(host, input) {
     return { flush: false };
   const at = new Date().toISOString();
   const base = {
-    v: 1,
+    v: 2,
     host,
     session: String(input.session_id),
     project: place.key,
@@ -11466,23 +11633,37 @@ function onHook(host, input) {
     turn,
     at
   };
-  const say = (key, speaker, raw) => {
+  const say = (key, speaker, raw, when = at) => {
     const kept = fit(clean(raw).trim());
     if (!kept.body.trim())
       return;
     const id = `${key}:${digest(kept.body)}`;
-    spool({ ...base, kind: "message", id, speaker, ...kept });
-    if (speaker === "self")
-      remember(base.session, id);
+    spool({ ...base, at: when, kind: "message", id, speaker, ...kept });
   };
+  const baseline = baselineFile(host, base.session);
+  if (event === "UserPromptSubmit") {
+    if (!readBaseline(baseline)?.running) {
+      const now = snapshot(place.root);
+      if (now)
+        writeBaseline(baseline, { ...now, running: true });
+    }
+  }
   if (event === "UserPromptSubmit" && input.prompt) {
     const prompt = input.prompt.trimStart();
     if (!INJECTED.some((r) => r.test(prompt)))
-      say(`${turn}:self`, "self", prompt);
+      say(`${turn}:owner`, "owner", prompt);
   }
   if (event === "Stop") {
     if (input.last_assistant_message)
       say(`${turn}:assistant`, "assistant", input.last_assistant_message);
+    const now = snapshot(place.root);
+    if (now) {
+      const before = readBaseline(baseline);
+      if (before)
+        for (const p of changed(place.root, before, now))
+          spool({ ...base, kind: "edit", event: null, path: p, via: "status" });
+      writeBaseline(baseline, { ...now, running: false });
+    }
     return { flush: true };
   }
   if (event === "PostToolUse") {
@@ -11490,31 +11671,31 @@ function onHook(host, input) {
     const ti = input.tool_input ?? {};
     if (tool === "AskUserQuestion") {
       const said = answersOf(input);
-      if (said)
-        say(`${turn}:ask:${input.tool_use_id ?? at}`, "self", said);
+      if (said) {
+        const id = `${turn}:ask:${input.tool_use_id ?? at}`;
+        say(`${id}:q`, "assistant", said.questions, new Date(Date.parse(at) - 1).toISOString());
+        say(id, "owner", said.answers);
+      }
       return { flush: false };
     }
     if (tool === "Read")
       return { flush: false };
-    const message = lastSaid(base.session);
-    if (!message)
-      return { flush: false };
     const cwd = input.cwd ?? place.root;
     const files = (tool === "apply_patch" ? patchPaths(String(ti.command ?? "")) : [ti.file_path, ti.notebook_path].filter((p) => typeof p === "string")).flatMap((p) => relativeTo(place.root, p, cwd) ?? []);
     for (const p of files)
-      spool({ ...base, kind: "file", message, path: p, action: "edit" });
+      spool({ ...base, kind: "edit", event: input.tool_use_id ?? null, path: p, via: "tool" });
   }
   return { flush: false };
 }
 function writeState(s) {
   try {
-    fs3.writeFileSync(stateFile(), JSON.stringify(s));
+    fs4.writeFileSync(stateFile(), JSON.stringify(s));
   } catch {}
 }
 function readState() {
   const count = (dir) => {
     try {
-      return fs3.readdirSync(dir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).length;
+      return fs4.readdirSync(dir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).length;
     } catch {
       return 0;
     }
@@ -11526,7 +11707,7 @@ function readState() {
   };
   let raw = {};
   try {
-    const parsed = JSON.parse(fs3.readFileSync(stateFile(), "utf8"));
+    const parsed = JSON.parse(fs4.readFileSync(stateFile(), "utf8"));
     if (parsed && typeof parsed === "object")
       raw = parsed;
   } catch {}
@@ -11540,25 +11721,25 @@ function readState() {
   };
 }
 function lock() {
-  const file = path3.join(spoolDir(), ".lock");
-  fs3.mkdirSync(spoolDir(), { recursive: true, mode: 448 });
+  const file = path5.join(spoolDir(), ".lock");
+  fs4.mkdirSync(spoolDir(), { recursive: true, mode: 448 });
   for (let attempt = 0;attempt < 2; attempt++) {
     try {
-      fs3.writeFileSync(file, String(process.pid), { flag: "wx", mode: 384 });
+      fs4.writeFileSync(file, String(process.pid), { flag: "wx", mode: 384 });
       return () => {
         try {
-          if (fs3.readFileSync(file, "utf8") === String(process.pid))
-            fs3.rmSync(file, { force: true });
+          if (fs4.readFileSync(file, "utf8") === String(process.pid))
+            fs4.rmSync(file, { force: true });
         } catch {}
       };
     } catch (e) {
       if (e.code !== "EEXIST")
         throw e;
     }
-    const st = fs3.statSync(file, { throwIfNoEntry: false });
+    const st = fs4.statSync(file, { throwIfNoEntry: false });
     if (!st)
       continue;
-    const holder = Number(fs3.readFileSync(file, "utf8") || 0);
+    const holder = Number(fs4.readFileSync(file, "utf8") || 0);
     const fresh = Date.now() - st.mtimeMs < 5 * 60000;
     const alive = (() => {
       if (holder <= 0)
@@ -11571,7 +11752,7 @@ function lock() {
     })();
     if (alive && fresh)
       return null;
-    fs3.rmSync(file, { force: true });
+    fs4.rmSync(file, { force: true });
   }
   return null;
 }
@@ -11580,27 +11761,21 @@ var ROWS = 1000;
 var chunks = (xs, n = ROWS) => Array.from({ length: Math.ceil(xs.length / n) }, (_, i) => xs.slice(i * n, (i + 1) * n));
 async function write(db, batch, projects) {
   return inTransaction(db, async (trx) => {
-    const conversations = new Map;
+    const sessions = new Map;
     for (const r of batch) {
       const p = projects.get(r.project);
       if (!p)
         continue;
-      const id = conversationId(p.id, r.host, r.session);
-      const prev = conversations.get(id);
+      const id = sessionId(p.id, r.host, r.session);
+      const prev = sessions.get(id);
       if (!prev || Date.parse(r.at) < Date.parse(prev.at))
-        conversations.set(id, {
-          project: p.id,
-          host: r.host,
-          session: r.session,
-          branch: r.branch,
-          at: r.at
-        });
+        sessions.set(id, { project: p.id, host: r.host, session: r.session, branch: r.branch, at: r.at });
     }
-    for (const part of chunks([...conversations]))
-      await trx.insertInto("capture_conversation").values(part.map(([id, v]) => ({
+    for (const part of chunks([...sessions]))
+      await trx.insertInto("capture_session").values(part.map(([id, v]) => ({
         id,
         project_id: v.project,
-        origin: v.host,
+        host: v.host,
         external_id: v.session,
         branch: v.branch,
         started_at: iso(v.at)
@@ -11609,44 +11784,49 @@ async function write(db, batch, projects) {
       const p = m.kind === "message" ? projects.get(m.project) : undefined;
       if (m.kind !== "message" || !p)
         return [];
-      const conversation = conversationId(p.id, m.host, m.session);
-      return [{ m, conversation, id: uuidFrom(conversation, m.id) }];
-    });
-    let before = 0;
-    for (const part of chunks(messages)) {
-      const ids = part.map((x) => x.id);
-      before += (await trx.selectFrom("message").select("id").where("id", "in", ids).execute()).length;
+      return [{ m, session: sessionId(p.id, m.host, m.session) }];
+    });
+    const present = async () => {
+      let n = 0;
+      for (const part of chunks(messages))
+        for (const [session, ids] of Map.groupBy(part, (x) => x.session))
+          n += (await trx.selectFrom("source").select("id").where("kind", "=", "session_message").where("session_id", "=", session).where("external_id", "in", ids.map((x) => x.m.id)).execute()).length;
+      return n;
+    };
+    const before = await present();
+    const now = iso(Date.now());
+    for (const part of chunks(messages))
       await trx.insertInto("capture_message").values(part.map((x) => ({
-        id: x.id,
-        conversation_id: x.conversation,
         external_id: x.m.id,
+        session_id: x.session,
         turn_id: x.m.turn,
-        speaker_kind: x.m.speaker,
-        body: x.m.body,
+        speaker: x.m.speaker,
+        created_at: iso(x.m.at),
+        captured_at: now,
+        text: x.m.body,
         truncated: x.m.truncated ? 1 : 0,
+        redacted: x.m.redacted ? 1 : 0,
         original_bytes: x.m.originalBytes,
-        sent_at: iso(x.m.at),
-        content_hash: sha256(x.m.body),
-        indexed: indexesMessage(x.m.speaker) ? 1 : 0
+        content_hash: sha256(x.m.body)
       }))).execute();
-    }
-    let after = 0;
-    for (const part of chunks(messages))
-      after += (await trx.selectFrom("message").select("id").where("id", "in", part.map((x) => x.id)).execute()).length;
-    const files = batch.flatMap((r) => {
-      const p = r.kind === "file" ? projects.get(r.project) : undefined;
-      if (r.kind !== "file" || !p)
+    const after = await present();
+    const edits = batch.flatMap((r) => {
+      const p = r.kind === "edit" ? projects.get(r.project) : undefined;
+      if (r.kind !== "edit" || !p)
         return [];
       return [
         {
-          message_id: uuidFrom(conversationId(p.id, r.host, r.session), r.message),
+          session_id: sessionId(p.id, r.host, r.session),
+          turn_id: r.turn,
+          tool_event_id: r.event,
           path: r.path,
-          action: r.action
+          via: r.via,
+          observed_at: iso(r.at)
         }
       ];
     });
-    for (const part of chunks(files))
-      await trx.insertInto("capture_message_file").values(part).execute();
+    for (const part of chunks(edits))
+      await trx.insertInto("capture_edit").values(part).execute();
     return after - before;
   });
 }
@@ -11662,7 +11842,7 @@ async function flush(file = dbFile()) {
     const held = unregisteredDir();
     const list = (from) => {
       try {
-        return fs3.readdirSync(from).filter((f) => f.endsWith(".json") && !f.startsWith(".")).map((name) => ({ name, from }));
+        return fs4.readdirSync(from).filter((f) => f.endsWith(".json") && !f.startsWith(".")).map((name) => ({ name, from }));
       } catch {
         return [];
       }
@@ -11672,15 +11852,18 @@ async function flush(file = dbFile()) {
       return { sent: 0, deferred: 0, rejected: 0 };
     const records = [];
     for (const { name, from } of names) {
+      let r;
       try {
-        records.push({
-          name,
-          from,
-          r: JSON.parse(fs3.readFileSync(path3.join(from, name), "utf8"))
-        });
+        r = current(JSON.parse(fs4.readFileSync(path5.join(from, name), "utf8")));
       } catch {
-        fs3.rmSync(path3.join(from, name), { force: true });
+        fs4.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
+        fs4.renameSync(path5.join(from, name), path5.join(rejectedDir(), name));
+        continue;
       }
+      if (r)
+        records.push({ name, from, r });
+      else
+        fs4.rmSync(path5.join(from, name), { force: true });
     }
     const db = openWriter("capture", file);
     client = db;
@@ -11694,8 +11877,7 @@ async function flush(file = dbFile()) {
     } catch (e) {
       if (!rejected(e))
         throw e;
-      const ordered = [...known].sort((a, b) => Number(a.r.kind === "file") - Number(b.r.kind === "file"));
-      for (const x of ordered) {
+      for (const x of known) {
         try {
           sent += await write(db, [x.r], projects);
         } catch (e2) {
@@ -11705,15 +11887,11 @@ async function flush(file = dbFile()) {
         }
       }
     }
-    const lost = new Set(bad.flatMap((x) => x.r.kind === "message" && x.r.speaker === "self" ? [`${x.r.session}\x00${x.r.id}`] : []));
-    for (const x of known)
-      if (x.r.kind === "file" && lost.has(`${x.r.session}\x00${x.r.message}`) && !bad.includes(x))
-        bad.push(x);
     if (bad.length) {
-      fs3.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
+      fs4.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
       for (const x of bad) {
         try {
-          fs3.renameSync(path3.join(x.from, x.name), path3.join(rejectedDir(), x.name));
+          fs4.renameSync(path5.join(x.from, x.name), path5.join(rejectedDir(), x.name));
         } catch (e) {
           if (e.code !== "ENOENT")
             throw e;
@@ -11721,12 +11899,12 @@ async function flush(file = dbFile()) {
       }
     }
     if (strayed.length) {
-      fs3.mkdirSync(held, { recursive: true, mode: 448 });
+      fs4.mkdirSync(held, { recursive: true, mode: 448 });
       for (const x of strayed) {
         if (x.from === held)
           continue;
         try {
-          fs3.renameSync(path3.join(x.from, x.name), path3.join(held, x.name));
+          fs4.renameSync(path5.join(x.from, x.name), path5.join(held, x.name));
         } catch (e) {
           if (e.code !== "ENOENT")
             throw e;
@@ -11736,7 +11914,7 @@ async function flush(file = dbFile()) {
     const moved = new Set([...bad, ...strayed].map((x) => x.name));
     for (const x of records)
       if (!moved.has(x.name))
-        fs3.rmSync(path3.join(x.from, x.name), { force: true });
+        fs4.rmSync(path5.join(x.from, x.name), { force: true });
     prune(held);
     writeState({ flushedAt: new Date().toISOString(), error: null, deferred: strayed.length });
     return { sent, deferred: strayed.length, rejected: bad.length };
@@ -11776,11 +11954,12 @@ if (process.argv[1] && /capture\.(ts|js)$/.test(process.argv[1])) {
 export {
   MAX_MESSAGE,
   answersOf,
+  branchOf,
   captureNotice,
+  current,
   fit,
   flush,
   isOwnerTurn,
-  lock,
   onHook,
   readInput,
   readState,