sphica 0.5.7 → 0.6.1

package/dist/mcp-record.js

@@ -34719,9 +34719,6 @@ class StdioServerTransport {
   }
 }
 
-// server/src/db-write.ts
-import { constants as C2, DatabaseSync as DatabaseSync2 } from "node:sqlite";
-
 // server/node_modules/kysely/dist/util/object-utils.js
 function isUndefined(obj) {
   return typeof obj === "undefined" || obj === undefined;
@@ -45530,7 +45527,7 @@ import os from "node:os";
 import path from "node:path";
 import { constants as C, DatabaseSync } from "node:sqlite";
 var SCHEMA_GENERATION = 2;
-var SCHEMA_REVISION = 1;
+var SCHEMA_REVISION = 2;
 var sphicaHome = () => process.env.SPHICA_HOME || path.join(os.homedir(), ".sphica");
 var dbFile = () => process.env.SPHICA_DB || path.join(sphicaHome(), "sphica.db");
 function requireRuntime() {
@@ -45554,7 +45551,7 @@ function prepare(raw, check2) {
   const got = raw.prepare("pragma user_version").get()?.user_version;
   if (got === SCHEMA_REVISION)
     return;
-  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."));
+  throw new Error(`The database schema is revision ${got}, but this Sphica expects revision ${SCHEMA_REVISION}. ` + ((got ?? 0) < SCHEMA_REVISION ? "Update the sphica CLI (`npm i -g sphica`), then run `sphica init` to migrate it (records are kept)." : "Update sphica."));
 }
 function generationOf(raw) {
   const has = raw.prepare("select 1 from sqlite_schema where type = 'table' and name = 'sphica_generation'").get();
@@ -45626,6 +45623,9 @@ function sqliteCode(e) {
   return x?.code === "ERR_SQLITE_ERROR" && typeof x.errcode === "number" ? x.errcode & 255 : null;
 }
 
+// server/src/db-write.ts
+import { constants as C2, DatabaseSync as DatabaseSync2 } from "node:sqlite";
+
 // server/src/text.ts
 import crypto from "node:crypto";
 var segmenter = new Intl.Segmenter("ja", { granularity: "word" });
@@ -45993,22 +45993,54 @@ function captureAuthorizer(own2, action, p1, p2, triggerOrView) {
   return C2.SQLITE_DENY;
 }
 var writes = (action) => action === C2.SQLITE_INSERT || action === C2.SQLITE_UPDATE || action === C2.SQLITE_DELETE;
+var FORGET_ONLY = new Set(["forget_batch", "source_forgotten"]);
+var KEPT_BY_INGEST = new Set(["source", "unit_evidence", "unit_adoption"]);
 function ingestAuthorizer(action, p1, p2) {
   if (DDL().has(action))
     return C2.SQLITE_DENY;
-  if (writes(action) && p1 === "owner_identity")
+  if (writes(action) && (p1 === "owner_identity" || FORGET_ONLY.has(p1 ?? "")))
+    return C2.SQLITE_DENY;
+  if (action === C2.SQLITE_DELETE && KEPT_BY_INGEST.has(p1 ?? ""))
     return C2.SQLITE_DENY;
   if (action === C2.SQLITE_PRAGMA)
     return readsDataVersion(p1, p2) ? C2.SQLITE_OK : C2.SQLITE_DENY;
   return C2.SQLITE_OK;
 }
+var FORGET_WRITES = {
+  [C2.SQLITE_INSERT]: new Set(["forget_batch", "source_forgotten", "unit_state", "source_fts"]),
+  [C2.SQLITE_DELETE]: new Set([
+    "source",
+    "external_reference",
+    "unit_evidence",
+    "unit_adoption",
+    "source_processing",
+    "source_fts"
+  ])
+};
+var FORGET_UPDATES = {
+  unit: new Set(["lifecycle", "revision"]),
+  unit_state: new Set(["source_id"])
+};
+function forgetAuthorizer(action, p1, p2) {
+  if (SHADOW.test(p1 ?? "") && writes(action))
+    return C2.SQLITE_OK;
+  if (action === C2.SQLITE_UPDATE)
+    return FORGET_UPDATES[p1 ?? ""]?.has(p2 ?? "") ? C2.SQLITE_OK : C2.SQLITE_DENY;
+  if (action === C2.SQLITE_INSERT || action === C2.SQLITE_DELETE)
+    return FORGET_WRITES[action]?.has(p1 ?? "") ? C2.SQLITE_OK : C2.SQLITE_DENY;
+  if (action === C2.SQLITE_PRAGMA)
+    return readsDataVersion(p1, p2) || p1 === "secure_delete" && ["on", "1", "true"].includes((p2 ?? "").toLowerCase()) || p1 === "wal_checkpoint" ? C2.SQLITE_OK : C2.SQLITE_DENY;
+  if (action === C2.SQLITE_READ || action === C2.SQLITE_SELECT || action === C2.SQLITE_FUNCTION || action === C2.SQLITE_TRANSACTION || action === C2.SQLITE_SAVEPOINT)
+    return C2.SQLITE_OK;
+  return C2.SQLITE_DENY;
+}
 function connectWriter(role, file2 = dbFile(), create = false) {
   requireRuntime();
   if (!create)
     requireFile(file2);
   const raw = new DatabaseSync2(file2);
   try {
-    prepare(raw, create ? "none" : role === "ingest" ? "revision" : "generation");
+    prepare(raw, create ? "none" : role === "ingest" || role === "forget" ? "revision" : "generation");
     raw.function("sphica_terms", { deterministic: true }, (text) => terms(String(text ?? "")).join(" "));
   } catch (e) {
     raw.close();
@@ -46016,6 +46048,8 @@ function connectWriter(role, file2 = dbFile(), create = false) {
   }
   if (role === "ingest")
     raw.setAuthorizer(ingestAuthorizer);
+  else if (role === "forget")
+    raw.setAuthorizer(forgetAuthorizer);
   else if (role === "capture") {
     let own2 = false;
     raw.setAuthorizer((action, p1, p2, _db, triggerOrView) => captureAuthorizer(own2, action, p1, p2, triggerOrView));
@@ -46649,6 +46683,8 @@ function lock() {
   return null;
 }
 var BATCH = 500;
+var FLUSH_BUDGET_MS = 30000;
+var TOOL_FLUSH_BUDGET_MS = 2000;
 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) {
@@ -46724,98 +46760,135 @@ async function write(db, batch, projects) {
 }
 var REJECTED = new Set([18, 19, 20, 25]);
 var rejected = (e) => REJECTED.has(sqliteCode(e) ?? -1);
-async function flush(file2 = dbFile()) {
-  const unlock = lock();
-  if (!unlock)
-    return { sent: 0, deferred: 0, rejected: 0, busy: true };
-  const dir = spoolDir();
-  let client = null;
+var queued = (from) => {
+  try {
+    return fs5.readdirSync(from).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort().map((name) => ({ name, from }));
+  } catch {
+    return [];
+  }
+};
+async function sendBatch(db, names) {
+  const held = unregisteredDir();
+  const records = [];
+  for (const { name, from } of names) {
+    let r;
+    try {
+      r = current(JSON.parse(fs5.readFileSync(path5.join(from, name), "utf8")));
+    } catch {
+      fs5.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
+      fs5.renameSync(path5.join(from, name), path5.join(rejectedDir(), name));
+      continue;
+    }
+    if (r)
+      records.push({ name, from, r });
+    else
+      fs5.rmSync(path5.join(from, name), { force: true });
+  }
+  const projects = new Map((await db.selectFrom("project").select(["id", "key", "name"]).where("key", "in", [...new Set(records.map((x) => x.r.project))]).execute()).map((p) => [p.key, { id: p.id, name: p.name }]));
+  const known = records.filter((x) => projects.has(x.r.project));
+  const strayed = records.filter((x) => !projects.has(x.r.project));
+  let sent = 0;
+  const bad = [];
   try {
-    const held = unregisteredDir();
-    const list = (from) => {
+    sent = await write(db, known.map((x) => x.r), projects);
+  } catch (e) {
+    if (!rejected(e))
+      throw e;
+    for (const x of known) {
       try {
-        return fs5.readdirSync(from).filter((f) => f.endsWith(".json") && !f.startsWith(".")).map((name) => ({ name, from }));
-      } catch {
-        return [];
+        sent += await write(db, [x.r], projects);
+      } catch (e2) {
+        if (!rejected(e2))
+          throw e2;
+        bad.push(x);
       }
-    };
-    const names = [...list(dir), ...list(held)].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0).slice(0, BATCH);
-    if (names.length === 0)
-      return { sent: 0, deferred: 0, rejected: 0 };
-    const records = [];
-    for (const { name, from } of names) {
-      let r;
+    }
+  }
+  if (bad.length) {
+    fs5.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
+    for (const x of bad) {
       try {
-        r = current(JSON.parse(fs5.readFileSync(path5.join(from, name), "utf8")));
-      } catch {
-        fs5.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
-        fs5.renameSync(path5.join(from, name), path5.join(rejectedDir(), name));
-        continue;
-      }
-      if (r)
-        records.push({ name, from, r });
-      else
-        fs5.rmSync(path5.join(from, name), { force: true });
-    }
-    const db = openWriter("capture", file2);
-    client = db;
-    const projects = new Map((await db.selectFrom("project").select(["id", "key", "name"]).where("key", "in", [...new Set(records.map((x) => x.r.project))]).execute()).map((p) => [p.key, { id: p.id, name: p.name }]));
-    const known = records.filter((x) => projects.has(x.r.project));
-    const strayed = records.filter((x) => !projects.has(x.r.project));
-    let sent = 0;
-    const bad = [];
-    try {
-      sent = await write(db, known.map((x) => x.r), projects);
-    } catch (e) {
-      if (!rejected(e))
-        throw e;
-      for (const x of known) {
-        try {
-          sent += await write(db, [x.r], projects);
-        } catch (e2) {
-          if (!rejected(e2))
-            throw e2;
-          bad.push(x);
-        }
+        fs5.renameSync(path5.join(x.from, x.name), path5.join(rejectedDir(), x.name));
+      } catch (e) {
+        if (e.code !== "ENOENT")
+          throw e;
       }
     }
-    if (bad.length) {
-      fs5.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
-      for (const x of bad) {
-        try {
-          fs5.renameSync(path5.join(x.from, x.name), path5.join(rejectedDir(), x.name));
-        } catch (e) {
-          if (e.code !== "ENOENT")
-            throw e;
-        }
+  }
+  if (strayed.length) {
+    fs5.mkdirSync(held, { recursive: true, mode: 448 });
+    for (const x of strayed) {
+      if (x.from === held)
+        continue;
+      try {
+        fs5.renameSync(path5.join(x.from, x.name), path5.join(held, x.name));
+      } catch (e) {
+        if (e.code !== "ENOENT")
+          throw e;
       }
     }
-    if (strayed.length) {
-      fs5.mkdirSync(held, { recursive: true, mode: 448 });
-      for (const x of strayed) {
-        if (x.from === held)
-          continue;
-        try {
-          fs5.renameSync(path5.join(x.from, x.name), path5.join(held, x.name));
-        } catch (e) {
-          if (e.code !== "ENOENT")
-            throw e;
+  }
+  const moved = new Set([...bad, ...strayed].map((x) => x.name));
+  for (const x of records)
+    if (!moved.has(x.name))
+      fs5.rmSync(path5.join(x.from, x.name), { force: true });
+  return { sent, rejected: bad.length };
+}
+async function flush(file2 = dbFile(), budgetMs = FLUSH_BUDGET_MS) {
+  const deadline = Date.now() + budgetMs;
+  const dir = spoolDir();
+  const held = unregisteredDir();
+  const total = { sent: 0, deferred: 0, rejected: 0 };
+  let batches = 0;
+  let queueBatches = 0;
+  for (let first = true;; first = false) {
+    let unlock = lock();
+    while (!unlock && Date.now() < deadline) {
+      await new Promise((resolve) => setTimeout(resolve, Math.min(100, deadline - Date.now())));
+      if (Date.now() < deadline)
+        unlock = lock();
+    }
+    if (!unlock)
+      return first ? { ...total, busy: true } : total;
+    let client = null;
+    const send = async (names) => {
+      client ??= openWriter("capture", file2);
+      const r = await sendBatch(client, names);
+      total.sent += r.sent;
+      total.rejected += r.rejected;
+      batches++;
+    };
+    const late2 = () => batches > 0 && Date.now() >= deadline;
+    const sentBefore = batches;
+    try {
+      if (first) {
+        prune(held);
+        for (const part of chunks(queued(held), BATCH)) {
+          if (late2())
+            break;
+          await send(part);
         }
       }
+      while (queueBatches === 0 || !late2()) {
+        const part = queued(dir).slice(0, BATCH);
+        if (part.length === 0)
+          break;
+        await send(part);
+        queueBatches++;
+      }
+      prune(held);
+      total.deferred = queued(held).length;
+      if (batches > sentBefore)
+        writeState({ flushedAt: new Date().toISOString(), error: null, deferred: total.deferred });
+    } catch (e) {
+      writeState({ flushedAt: new Date().toISOString(), error: reason(e).slice(0, 300) });
+      throw e;
+    } finally {
+      await client?.destroy().catch(() => {});
+      unlock();
     }
-    const moved = new Set([...bad, ...strayed].map((x) => x.name));
-    for (const x of records)
-      if (!moved.has(x.name))
-        fs5.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 };
-  } catch (e) {
-    writeState({ flushedAt: new Date().toISOString(), error: reason(e).slice(0, 300) });
-    throw e;
-  } finally {
-    await client?.destroy().catch(() => {});
-    unlock();
+    if (Date.now() >= deadline || queued(dir).length === 0)
+      return total;
   }
 }
 async function readInput(stream) {
@@ -47040,11 +47113,13 @@ async function storeItems(db, projectId2, items) {
     const kept = fit(it.text);
     const hash2 = sha256(kept.body);
     const latest = await db.selectFrom("source").select(["id", "revision", "content_hash"]).where("project_id", "=", projectId2).where("kind", "=", it.kind).where("external_id", "=", it.externalId).orderBy("revision", "desc").executeTakeFirst();
-    if (latest && Buffer.from(latest.content_hash).equals(hash2)) {
+    const forgotten = await db.selectFrom("source_forgotten").select(["revision", "content_hash"]).where("project_id", "=", projectId2).where("kind", "=", it.kind).where("external_id", "=", it.externalId).execute();
+    const lastForgotten = Math.max(0, ...forgotten.map((f) => f.revision));
+    if (latest && latest.revision > lastForgotten && Buffer.from(latest.content_hash).equals(hash2)) {
       ids.push(latest.id);
       continue;
     }
-    if (!latest && !kept.body.trim()) {
+    if (forgotten.some((f) => Buffer.from(f.content_hash).equals(hash2)) || !latest && !kept.body.trim()) {
       ids.push(null);
       continue;
     }
@@ -47057,7 +47132,7 @@ async function storeItems(db, projectId2, items) {
       kind: it.kind,
       artifact: it.artifact,
       external_id: it.externalId,
-      revision: (latest?.revision ?? 0) + 1,
+      revision: Math.max(latest?.revision ?? 0, lastForgotten) + 1,
       author_kind: kind,
       author_login: it.author?.login ?? null,
       author_external_id: authorId,
@@ -47066,7 +47141,7 @@ async function storeItems(db, projectId2, items) {
       event_kind: it.event,
       url: it.url,
       created_at: created,
-      available_at: latest ? null : created,
+      available_at: latest || lastForgotten ? null : created,
       captured_at: now,
       text: kept.body,
       truncated: kept.truncated ? 1 : 0,
@@ -47102,7 +47177,7 @@ async function pullSources(db, projectId2, number5) {
     `pr:${number5}`,
     ...(await db.selectFrom("artifact_link").select("to_artifact").where("project_id", "=", projectId2).where("from_artifact", "=", `pr:${number5}`).execute()).map((l) => l.to_artifact)
   ];
-  return db.selectFrom("source as s").where("s.project_id", "=", projectId2).where("s.artifact", "in", artifacts).where(({ not, exists, selectFrom }) => not(exists(selectFrom("source as n").select("n.id").whereRef("n.project_id", "=", "s.project_id").whereRef("n.kind", "=", "s.kind").whereRef("n.external_id", "=", "s.external_id").whereRef("n.revision", ">", "s.revision")))).select([
+  return db.selectFrom("source as s").where("s.project_id", "=", projectId2).where("s.artifact", "in", artifacts).where(({ not, exists, selectFrom }) => not(exists(selectFrom("source as n").select("n.id").whereRef("n.project_id", "=", "s.project_id").whereRef("n.kind", "=", "s.kind").whereRef("n.external_id", "=", "s.external_id").whereRef("n.revision", ">", "s.revision")))).where(({ not, exists, selectFrom }) => not(exists(selectFrom("source_forgotten as f").select("f.source_id").whereRef("f.project_id", "=", "s.project_id").whereRef("f.kind", "=", "s.kind").whereRef("f.external_id", "=", "s.external_id").whereRef("f.revision", ">", "s.revision")))).select([
     "s.id",
     "s.kind",
     "s.artifact",
@@ -47748,7 +47823,9 @@ async function checkGlean(db, target, raw) {
           if (!target.root)
             throw new Error("the repository is not known");
           excerpt = readExcerpt(target.root, op.file);
-          if (!locate3(excerpt.raw, op.quote))
+          if ((await forgottenExcerpt(db, target.projectId, excerpt)).same)
+            errors3.push(`${what}: the owner forgot ${excerpt.path} lines ${op.file.lines.join("-")}; cite something else`);
+          else if (!locate3(excerpt.raw, op.quote))
             errors3.push(`${what}: quote not found in ${excerpt.path} lines ${op.file.lines.join("-")}`);
           else if (!quoteSpan(excerpt.raw, excerpt.text, op.quote))
             errors3.push(`${what}: the quote also appears in text Sphica masks; quote a longer or different part`);
@@ -47863,19 +47940,30 @@ async function checkGlean(db, target, raw) {
   }
   return { errors: errors3, problems, units, ops };
 }
+async function forgottenExcerpt(db, projectId2, x) {
+  const rows = await db.selectFrom("source_forgotten").select(["revision", "content_hash"]).where("project_id", "=", projectId2).where("kind", "=", "file_excerpt").where("external_id", "=", `file:${x.path}@${x.blob}#L${x.lines[0]}-${x.lines[1]}`).execute();
+  const hash2 = sha256(x.text);
+  return {
+    same: rows.some((r) => Buffer.from(r.content_hash).equals(hash2)),
+    last: Math.max(0, ...rows.map((r) => r.revision))
+  };
+}
 async function excerptSource(trx, projectId2, x) {
   const external2 = `file:${x.path}@${x.blob}#L${x.lines[0]}-${x.lines[1]}`;
   const hash2 = sha256(x.text);
   const found = await trx.selectFrom("source").select(["id", "revision", "content_hash"]).where("project_id", "=", projectId2).where("kind", "=", "file_excerpt").where("external_id", "=", external2).orderBy("revision", "desc").executeTakeFirst();
-  if (found?.content_hash.equals(hash2))
+  const forgotten = await forgottenExcerpt(trx, projectId2, x);
+  if (found && found.revision > forgotten.last && found.content_hash.equals(hash2))
     return found.id;
+  if (forgotten.same)
+    throw new Error(`the owner forgot ${x.path} lines ${x.lines.join("-")}; cite something else`);
   const now = iso(Date.now());
   const row = await trx.insertInto("source").values({
     project_id: projectId2,
     kind: "file_excerpt",
     artifact: `file:${x.path}`,
     external_id: external2,
-    revision: (found?.revision ?? 0) + 1,
+    revision: Math.max(found?.revision ?? 0, forgotten.last) + 1,
     author_kind: "person",
     created_at: now,
     captured_at: now,
@@ -48088,7 +48176,7 @@ async function liveUnits(db, projectId2, limit = 40) {
 // server/src/extract.ts
 var newRunId = () => crypto2.randomBytes(9).toString("base64url");
 async function pendingText(db, projectId2) {
-  await flush().catch(() => {});
+  await flush(undefined, TOOL_FLUSH_BUDGET_MS).catch(() => {});
   const rows = await pendingSessions(db, projectId2);
   if (!rows.length)
     return "Every captured session has been traced.";
@@ -48110,14 +48198,14 @@ async function sessionOf(db, projectId2, given) {
   return s.id;
 }
 async function beginTrace(db, projectId2, session) {
-  await flush().catch(() => {});
+  await flush(undefined, TOOL_FLUSH_BUDGET_MS).catch(() => {});
   const s = await sessionOf(db, projectId2, session);
   const run = newRunId();
   await openRun(db, { projectId: projectId2, origin: "trace", target: `session:${s}`, sessionId: s, draftId: run });
   return run;
 }
 async function beginGlean(db, projectId2, session) {
-  await flush().catch(() => {});
+  await flush(undefined, TOOL_FLUSH_BUDGET_MS).catch(() => {});
   const s = await sessionOf(db, projectId2, session);
   const run = newRunId();
   await openRun(db, { projectId: projectId2, origin: "glean", target: "glean", sessionId: s, draftId: run });
@@ -48127,7 +48215,7 @@ async function beginHarvest(db, projectId2, number5, get) {
   const project = await db.selectFrom("project").select("key").where("id", "=", projectId2).executeTakeFirst();
   const pull = await readPull(get, number5, repoOf(project?.key ?? ""));
   return inTransaction(db, async (trx) => {
-    await storeItems(trx, projectId2, pull.items);
+    const kept = (await storeItems(trx, projectId2, pull.items)).filter((id) => id !== null).length;
     await linkIssues(trx, projectId2, number5, pull.closes);
     const run = newRunId();
     await openRun(trx, {
@@ -48137,7 +48225,7 @@ async function beginHarvest(db, projectId2, number5, get) {
       sessionId: null,
       draftId: run
     });
-    return { run, sources: pull.items.length };
+    return { run, sources: kept };
   });
 }
 async function bound(db, id, projectId2) {
@@ -48288,6 +48376,153 @@ async function saveText(db, id, projectId2, root, record3) {
   });
 }
 
+// server/src/forget.ts
+class Preview extends Error {
+  outcome;
+  constructor(outcome) {
+    super("preview");
+    this.outcome = outcome;
+  }
+}
+var unknown3 = (id) => new Error(`s${id} is not a source of this project`);
+async function forgetIn(trx, projectId2, ids, at) {
+  const unique = [...new Set(ids)];
+  const rows = unique.length ? await trx.selectFrom("source").where("id", "in", unique).where("project_id", "=", projectId2).select([
+    "id",
+    "kind",
+    "artifact",
+    "external_id",
+    "revision",
+    "content_hash",
+    sql`length(cast(text as blob))`.as("bytes")
+  ]).orderBy("id").execute() : [];
+  const gone = unique.length ? await trx.selectFrom("source_forgotten").where("source_id", "in", unique).where("project_id", "=", projectId2).select("source_id").execute() : [];
+  const already = gone.map((g) => g.source_id).sort((a, b) => a - b);
+  for (const id of unique)
+    if (!rows.some((r) => r.id === id) && !already.includes(id))
+      throw unknown3(id);
+  const outcome = {
+    sources: rows.map((r) => ({ id: r.id, kind: r.kind, artifact: r.artifact, bytes: r.bytes })),
+    already,
+    units: [],
+    references: 0
+  };
+  if (!rows.length)
+    return outcome;
+  const targets = rows.map((r) => r.id);
+  const touched = await trx.selectFrom("unit as u").where("u.project_id", "=", projectId2).where((eb) => eb.or(["unit_evidence", "unit_adoption"].flatMap((t) => [
+    eb.exists(eb.selectFrom(t).select(`${t}.id`).whereRef(`${t}.unit_id`, "=", "u.id").where(`${t}.source_id`, "in", targets)),
+    eb.exists(eb.selectFrom(t).select(`${t}.id`).whereRef(`${t}.unit_id`, "=", "u.id").where(`${t}.retraction_source_id`, "in", targets))
+  ]))).select(["u.id", "u.key", "u.lifecycle"]).orderBy("u.id").execute();
+  const count = async (t, unitId) => Number((await trx.selectFrom(t).where("unit_id", "=", unitId).where((eb) => eb.or([eb("source_id", "in", targets), eb("retraction_source_id", "in", targets)])).select((eb) => eb.fn.countAll().as("n")).executeTakeFirstOrThrow()).n);
+  const removed = new Map;
+  for (const u of touched)
+    removed.set(u.id, await count("unit_evidence", u.id) + await count("unit_adoption", u.id));
+  const batch = (await trx.insertInto("forget_batch").values({ project_id: projectId2, at }).returning("id").executeTakeFirstOrThrow()).id;
+  await trx.insertInto("source_forgotten").values(rows.map((r) => ({
+    source_id: r.id,
+    project_id: projectId2,
+    artifact: r.artifact,
+    kind: r.kind,
+    external_id: r.external_id,
+    revision: r.revision,
+    content_hash: r.content_hash,
+    batch_id: batch
+  }))).execute();
+  for (const t of ["unit_evidence", "unit_adoption"])
+    await trx.deleteFrom(t).where("retraction_source_id", "in", targets).where("retracted_at", "is not", null).where("source_id", "not in", targets).execute();
+  outcome.references = Number((await trx.deleteFrom("external_reference").where("owner_source_id", "in", targets).executeTakeFirst()).numDeletedRows);
+  await trx.deleteFrom("source").where("id", "in", targets).execute();
+  const reason2 = `sources ${targets.map((id) => `s${id}`).join(", ")} forgotten by the owner`;
+  for (const u of touched) {
+    let after = u.lifecycle;
+    if (u.lifecycle === "active") {
+      await trx.insertInto("unit_state").values({ unit_id: u.id, from_state: "active", to_state: "candidate", at, reason: reason2, forget_id: batch }).execute();
+      after = "candidate";
+      try {
+        await trx.insertInto("unit_state").values({
+          unit_id: u.id,
+          from_state: "candidate",
+          to_state: "active",
+          at,
+          reason: "support checked again after forgetting sources",
+          forget_id: batch
+        }).execute();
+        after = "active";
+      } catch (e) {
+        if (!ACTIVATION.test(e.message))
+          throw e;
+      }
+    }
+    outcome.units.push({ key: u.key, before: u.lifecycle, after, removed: removed.get(u.id) ?? 0 });
+  }
+  return outcome;
+}
+async function previewForget(file2, projectId2, ids) {
+  const db = openWriter("forget", file2);
+  try {
+    return await db.connection().execute(async (c) => {
+      await sql`begin immediate`.execute(c);
+      try {
+        throw new Preview(await forgetIn(c, projectId2, ids, iso(Date.now())));
+      } catch (e) {
+        await sql`rollback`.execute(c).catch(() => {});
+        if (e instanceof Preview)
+          return e.outcome;
+        throw e;
+      }
+    });
+  } finally {
+    await db.destroy();
+  }
+}
+async function applyForget(file2, projectId2, ids, confirmed, signal) {
+  const db = openWriter("forget", file2);
+  try {
+    return await db.connection().execute(async (c) => {
+      await sql`pragma secure_delete = on`.execute(c);
+      await sql`begin immediate`.execute(c);
+      let outcome;
+      try {
+        outcome = await forgetIn(c, projectId2, ids, iso(Date.now()));
+        if (JSON.stringify(outcome) !== JSON.stringify(confirmed))
+          throw new Error("What these sources support changed after you confirmed. Nothing was forgotten; look at the preview again");
+        if (signal?.aborted)
+          throw new Error("The call was cancelled, so nothing was forgotten");
+        await sql`commit`.execute(c);
+      } catch (e) {
+        await sql`rollback`.execute(c).catch(() => {});
+        throw e;
+      }
+      try {
+        await sql`insert into source_fts (source_fts) values ('optimize')`.execute(c);
+        const checkpoint = await sql`pragma wal_checkpoint(TRUNCATE)`.execute(c);
+        return { outcome, cleanup: checkpoint.rows[0]?.busy === 0 ? "done" : "incomplete" };
+      } catch {
+        return { outcome, cleanup: "incomplete" };
+      }
+    });
+  } finally {
+    await db.destroy();
+  }
+}
+function forgetText(o) {
+  const lines = o.sources.map((s) => `- s${s.id} ${s.kind} in ${inline(s.artifact).slice(0, 120)} (${plural2(s.bytes, "byte")})`);
+  if (o.already.length)
+    lines.push(`- already forgotten: ${o.already.map((id) => `s${id}`).join(", ")} (only the cleanup runs again)`);
+  for (const u of o.units) {
+    const change = u.before === u.after ? `stays ${u.after}` : `${u.before} → ${u.after}`;
+    lines.push(`- record ${inline(u.key).slice(0, 120)}: ${change}, loses ${plural2(u.removed, "citation")}`);
+  }
+  if (o.references)
+    lines.push(`- ${plural2(o.references, "unfetched reference")} the forgotten messages gave`);
+  if (o.units.length)
+    lines.push("Records keep their own text: if one repeats the forgotten words, they stay in it.");
+  lines.push("Copies outside the database (capture's waiting and set-aside files, backups) are not touched.");
+  return lines.join(`
+`);
+}
+
 // server/src/frame.ts
 import crypto3 from "node:crypto";
 function framed(body) {
@@ -48345,7 +48580,7 @@ var tool = (fn) => fn().then((t) => reply(t), (e) => reply(`Sphica: ${head(reaso
 var server = new McpServer({ name: "sphica-record", version: versionAt(ROOT) ?? "unknown" }, {
   capabilities: { experimental: { "codex/sandbox-state-meta": {} } },
   instructions: [
-    "Writes Sphica records for the trace, harvest, and glean Skills. Use these tools only while running one of those Skills.",
+    "Writes Sphica records for the trace, harvest, glean, and forget Skills. Use these tools only while running one of those Skills.",
     "Flow: begin (trace_begin, harvest_begin, or glean_begin) returns a run id; context shows what the run may cite; check the record; save it.",
     "Always pass the repository root as cwd."
   ].join(`
@@ -48426,4 +48661,66 @@ server.registerTool("record_save", {
   const p = await projectOf(a.cwd, extra._meta);
   return saveText(conn(), a.run, p.projectId, p.root, a.record);
 }));
+var SOURCES = exports_external.array(exports_external.string().regex(/^s[1-9][0-9]{0,15}$/)).min(1).max(50).describe("Sources to forget, as search and read show them (s12)");
+var idsOf = (refs) => refs.map((r) => Number(r.slice(1)));
+var ANSWER_MS = 10 * 60 * 1000;
+server.registerTool("forget_preview", {
+  title: "What forgetting sources would do",
+  description: "Shows which sources would be removed and which records would lose citations or leave active. Changes nothing. Never shows the text.",
+  inputSchema: { sources: SOURCES, cwd: CWD },
+  annotations: READ
+}, async (a, extra) => tool(async () => {
+  const p = await projectOf(a.cwd, extra._meta);
+  return forgetText(await previewForget(dbFile(), p.projectId, idsOf(a.sources)));
+}));
+server.registerTool("forget_apply", {
+  title: "Forget sources",
+  description: "Asks the owner in the host to confirm by typing the number of sources, then removes them, their index entries, and the bytes left in the file, and judges the records that cited them again. Nothing is removed without that answer.",
+  inputSchema: { sources: SOURCES, cwd: CWD },
+  annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false }
+}, async (a, extra) => tool(async () => {
+  const p = await projectOf(a.cwd, extra._meta);
+  const ids = idsOf(a.sources);
+  const seen = await previewForget(dbFile(), p.projectId, ids);
+  const n = seen.sources.length;
+  if (n > 0) {
+    const refused = (why) => new Error(`${why}, so nothing was forgotten`);
+    if (!server.server.getClientCapabilities()?.elicitation)
+      throw refused("This host cannot ask you directly (run /sphica:forget in Claude Code)");
+    let answer;
+    try {
+      answer = await server.server.elicitInput({
+        mode: "form",
+        message: `Forget ${plural2(n, "source")} for good?
+${forgetText(seen)}`,
+        requestedSchema: {
+          type: "object",
+          properties: {
+            confirm: {
+              type: "string",
+              title: "Number of sources",
+              description: `Type ${n} to forget ${plural2(n, "source")}`
+            }
+          },
+          required: ["confirm"]
+        }
+      }, { timeout: ANSWER_MS, signal: extra.signal });
+    } catch (e) {
+      throw refused(`The confirmation did not come back (${head(reason(e), 200)})`);
+    }
+    if (extra.signal.aborted)
+      throw refused("The call was cancelled");
+    if (answer.action !== "accept")
+      throw refused(`You ${answer.action === "decline" ? "declined" : "cancelled"}`);
+    if (String(answer.content?.confirm ?? "").trim() !== String(n))
+      throw refused(`The number typed does not match ${n}`);
+  }
+  const done = await applyForget(dbFile(), p.projectId, ids, seen, extra.signal);
+  return [
+    n ? `Forgot ${plural2(n, "source")}.` : "Nothing new to forget.",
+    forgetText(done.outcome),
+    done.cleanup === "done" ? "The deleted text was cleared from the database file." : "Clearing the deleted text from the database file did not finish (another session may be reading it), so it may stay there until you run forget_apply with the same sources again."
+  ].join(`
+`);
+}));
 await server.connect(new StdioServerTransport);