sphica 0.6.13 → 0.6.15

package/dist/mcp-record.js

@@ -45869,7 +45869,7 @@ var HOST_MARKS = new Set([".orphaned_at", ".in_use"]);
 
 // server/src/sqlite.ts
 var SCHEMA_GENERATION = 2;
-var SCHEMA_REVISION = 4;
+var SCHEMA_REVISION = 5;
 var sphicaHome = () => process.env.SPHICA_HOME || path2.join(os.homedir(), ".sphica");
 var dbFile = () => process.env.SPHICA_DB || path2.join(sphicaHome(), "sphica.db");
 function requireRuntime() {
@@ -46047,24 +46047,92 @@ 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) {
+var INGEST_INSERTS = new Set([
+  "project",
+  "ingest_source",
+  "extraction_run",
+  "source_processing",
+  "unit",
+  "unit_option",
+  "unit_evidence",
+  "unit_adoption",
+  "unit_link",
+  "unit_state",
+  "unit_anchor",
+  "unit_alias",
+  "field_def",
+  "unit_field",
+  "work",
+  "artifact_link"
+]);
+var RETRACTION = [
+  "retracted_at",
+  "retraction_reason",
+  "retraction_source_id",
+  "retraction_span_start",
+  "retraction_span_end"
+];
+var INGEST_UPDATES = {
+  extraction_run: new Set(["status", "finished_at"]),
+  unit_anchor: new Set(["retired_at", "replaced_by"]),
+  unit_link: new Set(["resolved_at", "resolution"]),
+  unit_evidence: new Set(RETRACTION),
+  unit_adoption: new Set(RETRACTION),
+  work: new Set(["title", "goal", "current", "next", "status", "branch", "run_id", "updated_at"])
+};
+var INGEST_DELETES = new Set(["artifact_link"]);
+var INGEST_TRIGGER_WRITES = {
+  ingest_source_insert: ["insert source"],
+  source_fts_ai: ["insert source_fts"],
+  source_fts_ad: ["delete source_fts"],
+  unit_state_apply: ["update unit"],
+  unit_state_restore: ["insert unit_state"],
+  ...Object.fromEntries([
+    "evidence_i",
+    "evidence_u",
+    "evidence_d",
+    "adoption_i",
+    "adoption_u",
+    "adoption_d",
+    "link_i",
+    "link_u",
+    "anchor_i",
+    "anchor_u",
+    "alias_i",
+    "field_i",
+    "field_d"
+  ].map((t) => [`unit_rev_${t}`, ["update unit"]])),
+  unit_fts_ai: ["insert unit_fts"],
+  unit_fts_ad: ["delete unit_fts"],
+  ...Object.fromEntries(["option_i", "anchor_i", "anchor_u", "anchor_d", "alias_i", "alias_d", "field_i", "field_d"].map((t) => [
+    `unit_fts_${t}`,
+    ["delete unit_fts", "insert unit_fts"]
+  ]))
+};
+var opOf = (action) => action === C2.SQLITE_INSERT ? "insert" : action === C2.SQLITE_UPDATE ? "update" : action === C2.SQLITE_DELETE ? "delete" : undefined;
+function ingestAuthorizer(action, p1, p2, trigger) {
   if (DDL().has(action))
     return C2.SQLITE_DENY;
-  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;
+  const op = opOf(action);
+  if (op) {
+    const table = p1 ?? "";
+    if (SHADOW.test(table))
+      return C2.SQLITE_OK;
+    if (trigger !== null)
+      return INGEST_TRIGGER_WRITES[trigger]?.includes(`${op} ${table}`) ? C2.SQLITE_OK : C2.SQLITE_DENY;
+    const allowed = op === "insert" ? INGEST_INSERTS.has(table) : op === "update" ? INGEST_UPDATES[table]?.has(p2 ?? "") : INGEST_DELETES.has(table);
+    return allowed ? C2.SQLITE_OK : C2.SQLITE_DENY;
+  }
   if (action === C2.SQLITE_PRAGMA)
     return readsDataVersion(p1, p2) ? C2.SQLITE_OK : C2.SQLITE_DENY;
-  return C2.SQLITE_OK;
+  if (action === C2.SQLITE_READ || action === C2.SQLITE_SELECT || action === C2.SQLITE_FUNCTION || action === C2.SQLITE_RECURSIVE || action === C2.SQLITE_TRANSACTION || action === C2.SQLITE_SAVEPOINT)
+    return C2.SQLITE_OK;
+  return C2.SQLITE_DENY;
 }
 var FORGET_WRITES = {
   [C2.SQLITE_INSERT]: new Set(["forget_batch", "source_forgotten", "unit_state", "source_fts", "unit_fts"]),
   [C2.SQLITE_DELETE]: new Set([
     "source",
-    "external_reference",
     "unit_evidence",
     "unit_adoption",
     "source_processing",
@@ -46104,7 +46172,7 @@ function connectWriter(role, file2 = dbFile(), create = false) {
     throw e;
   }
   if (role === "ingest")
-    raw.setAuthorizer(ingestAuthorizer);
+    raw.setAuthorizer((action, p1, p2, _db, trigger) => ingestAuthorizer(action, p1, p2, trigger));
   else if (role === "forget")
     raw.setAuthorizer(forgetAuthorizer);
   else if (role === "capture") {
@@ -46348,7 +46416,7 @@ async function projectId(db, key) {
 function relativeTo(root, file2, cwd = root) {
   const abs = path4.resolve(cwd, file2);
   const rel = path4.relative(root, abs);
-  if (!rel || leaves(rel))
+  if (!rel || leaves(rel) || /\p{Cc}/u.test(rel))
     return null;
   return rel.split(path4.sep).join("/");
 }
@@ -46380,7 +46448,7 @@ var git2 = (root, args) => {
     return null;
   }
 };
-var usable = (p) => p !== "" && !p.includes("\\");
+var usable = (p) => p !== "" && !p.includes("\\") && !/\p{Cc}/u.test(p);
 function snapshot(root) {
   const out = git2(root, ["status", "--porcelain=v2", "-z", "--untracked-files=all"]);
   if (out === null)
@@ -47030,7 +47098,7 @@ var item = (v) => ({
   ...v
 });
 var sha = (s) => s && /^[0-9a-f]{40}$/.test(s) ? s : null;
-var cleanPath = (p) => p && !p.startsWith("/") && !p.includes("\\") && !p.split("/").some((x) => x === "" || x === "." || x === "..") ? p : null;
+var cleanPath = (p) => p && !p.startsWith("/") && !p.includes("\\") && !/\p{Cc}/u.test(p) && !p.split("/").some((x) => x === "" || x === "." || x === "..") ? p : null;
 async function readPull(get, number5, repo = null) {
   const p = await get(`pulls/${number5}`);
   const artifact = `pr:${number5}`;
@@ -47090,7 +47158,7 @@ async function readPull(get, number5, repo = null) {
         createdAt: c.created_at,
         text: c.body,
         path: cleanPath(c.path),
-        lines: end && start ? [start, end] : null,
+        lines: cleanPath(c.path) && end && start ? [start, end] : null,
         hunk: c.diff_hunk ?? null,
         commit: sha(c.commit_id)
       }));
@@ -47173,7 +47241,7 @@ async function storeItems(db, projectId2, items) {
   for (const it of 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();
+    const latest = await db.selectFrom("source").select(["id", "revision", "content_hash"]).where("project_id", "=", projectId2).where("kind", "=", it.kind).where("external_id", "=", it.externalId).where("session_id", "is", null).orderBy("revision", "desc").executeTakeFirst();
     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)) {
@@ -47188,19 +47256,20 @@ async function storeItems(db, projectId2, items) {
     const bound = authorId !== null && owners.has(authorId) && SPOKEN.has(it.kind);
     const kind = bound ? "owner" : it.author?.type === "Bot" ? "bot" : "person";
     const created = iso(it.createdAt);
-    const row = await db.insertInto("source").values({
+    const revision = Math.max(latest?.revision ?? 0, lastForgotten) + 1;
+    await db.insertInto("ingest_source").values({
       project_id: projectId2,
       kind: it.kind,
       artifact: it.artifact,
       external_id: it.externalId,
-      revision: Math.max(latest?.revision ?? 0, lastForgotten) + 1,
+      revision,
       author_kind: kind,
       author_login: it.author?.login ?? null,
       author_external_id: authorId,
       author_association: it.association,
       parent_external_id: it.parent,
       event_kind: it.event,
-      url: it.url,
+      url: it.url && /^https?:\/\//.test(it.url) ? it.url : null,
       created_at: created,
       available_at: latest || lastForgotten ? null : created,
       captured_at: now,
@@ -47215,11 +47284,15 @@ async function storeItems(db, projectId2, items) {
       diff_hunk: it.hunk === null ? null : fit(it.hunk).body,
       commit_sha: it.commit,
       indexed: it.kind === "pr_event" ? 0 : 1
-    }).returning("id").executeTakeFirstOrThrow();
-    ids.push(row.id);
+    }).execute();
+    ids.push(await itemId(db, projectId2, it.kind, it.externalId, revision));
   }
   return ids;
 }
+async function itemId(db, projectId2, kind, externalId, revision) {
+  const row = await db.selectFrom("source").select("id").where("project_id", "=", projectId2).where("kind", "=", kind).where("external_id", "=", externalId).where("revision", "=", revision).where("session_id", "is", null).executeTakeFirstOrThrow();
+  return row.id;
+}
 async function linkIssues(db, projectId2, number5, closes) {
   let stale = db.deleteFrom("artifact_link").where("project_id", "=", projectId2).where("from_artifact", "=", `pr:${number5}`).where("kind", "=", "closes");
   if (closes.length)
@@ -47526,7 +47599,8 @@ async function checkRecord(db, target, raw, facts = prepareRecord(target.root, r
   const linked = [
     ...new Set(record3.units.flatMap((u) => [...u.supersedes ? [u.supersedes] : [], ...u.conflicts]))
   ];
-  const others = new Map((linked.length ? await db.selectFrom("unit").select(["id", "key", "lifecycle"]).where("project_id", "=", target.projectId).where("key", "in", linked).execute() : []).map((u) => [u.key, u]));
+  const others = new Map((linked.length ? await db.selectFrom("unit").select(["id", "key", "kind", "lifecycle"]).where("project_id", "=", target.projectId).where("key", "in", linked).execute() : []).map((u) => [u.key, u]));
+  const holders = new Map((others.size ? await db.selectFrom("unit_link as l").innerJoin("unit as n", "n.id", "l.from_unit").select(["l.to_unit", "n.key", "n.lifecycle"]).where("l.kind", "=", "supersedes").where("l.to_unit", "in", [...others.values()].map((o) => o.id)).where("n.lifecycle", "<>", "withdrawn").where("n.extraction", "=", "supported").where("n.unsourced", "=", 0).execute() : []).map((h) => [h.to_unit, h]));
   const maintainers = new Set(record3.units.some((u) => u.supersedes || u.conflicts.length) ? (await db.selectFrom("source").select("author_login").distinct().where("project_id", "=", target.projectId).where("author_association", "in", [...MAINTAINERS]).execute()).flatMap((r) => r.author_login ? [r.author_login] : []) : []);
   const units = [];
   const claimed = new Set;
@@ -47647,6 +47721,22 @@ async function checkRecord(db, target, raw, facts = prepareRecord(target.root, r
       problems.push(`${key}: another path-only anchor on ${x.path} already covers it; left out`);
       anchors.splice(anchors.indexOf(x), 1);
     }
+    const places = new Set;
+    for (const x of [...anchors]) {
+      const at = [
+        x.path,
+        x.role,
+        x.commit ?? "",
+        x.symbol ?? "",
+        x.symbol ? "" : x.lines ? place(x) : ""
+      ].join("\x00");
+      if (!places.has(at)) {
+        places.add(at);
+        continue;
+      }
+      problems.push(`${key}: the anchor on ${x.path}${x.symbol ? ` ${x.symbol}` : ""} appears twice; left out`);
+      anchors.splice(anchors.indexOf(x), 1);
+    }
     const aliases = [...new Set(u.aliases.map((a) => a.trim()))];
     const bad = aliases.filter((a) => !a || a.length > 40);
     if (bad.length)
@@ -47658,11 +47748,16 @@ async function checkRecord(db, target, raw, facts = prepareRecord(target.root, r
         errors3.push(`${key}: supersedes ${u.supersedes}, which is not a record of this project`);
       else if (!["active", "candidate"].includes(old.lifecycle))
         errors3.push(`${key}: ${u.supersedes} is already ${old.lifecycle}`);
-      else if (claimed.has(old.id))
+      else if (claimed.has(old.id) && !quarantine.length)
         errors3.push(`${key}: another record in this save already supersedes ${u.supersedes}`);
-      else
+      else if (!replaceable(u.kind, old.kind))
+        errors3.push(`${key}: a ${u.kind} cannot supersede ${u.supersedes}, a ${old.kind} (a record supersedes one of its own kind; a decision and a constraint can replace each other)`);
+      else if (holders.has(old.id) && !quarantine.length) {
+        const h = holders.get(old.id);
+        errors3.push(`${key}: ${u.supersedes} already has a successor, ${h?.key} (${h?.lifecycle}); withdraw it first, or supersede it instead`);
+      } else
         supersedes = old.id;
-      if (supersedes !== null)
+      if (supersedes !== null && !quarantine.length)
         claimed.add(supersedes);
     }
     const conflicts = u.conflicts.flatMap((k) => {
@@ -47764,6 +47859,7 @@ var contentHash = (u) => sha256(JSON.stringify([
   u.revisit_when ?? null,
   u.options.map((o) => o.reconsider_when === undefined ? [o.text, o.outcome, o.why ?? null] : [o.text, o.outcome, o.why ?? null, o.reconsider_when])
 ]));
+var replaceable = (successor, old) => successor === old || ["decision", "constraint"].includes(successor) && ["decision", "constraint"].includes(old);
 var ACTIVATION = /needs|cannot become active/;
 async function saveRecord(trx, target, runId, checked, looked) {
   if (checked.errors.length)
@@ -47966,9 +48062,14 @@ ${checked.errors.map((e) => `  ${e}`).join(`
   }
   for (const s of new Set(looked))
     await trx.insertInto("source_processing").values({ source_id: s, run_id: runId, outcome: cited.has(s) ? "units" : "no_unit" }).onConflict((oc) => oc.doNothing()).execute();
-  await trx.updateTable("extraction_run").set({ status: "saved", finished_at: now }).where("id", "=", runId).execute();
   return saved;
 }
+async function finishRun(trx, runId) {
+  await trx.updateTable("extraction_run").set((eb) => ({
+    status: "saved",
+    finished_at: eb.fn("max", [eb.val(iso(Date.now())), eb.ref("started_at")])
+  })).where("id", "=", runId).execute();
+}
 
 // server/src/glean.ts
 var MAX_FILE = 1024 * 1024;
@@ -48175,7 +48276,7 @@ async function checkGlean(db, target, raw, facts = prepareGlean(target.root, raw
     }
     return { s, at };
   };
-  const replaced = new Set;
+  const replaced = new Map;
   const anchored = new Set;
   const places = [];
   for (const [i, op] of parsed.data.ops.entries()) {
@@ -48245,17 +48346,20 @@ async function checkGlean(db, target, raw, facts = prepareGlean(target.root, raw
       if (!from)
         errors3.push(`${what}: the from path is not inside the repository`);
       else {
-        let q = db.selectFrom("unit_anchor").select("id").where("unit_id", "=", u.id).where("path", "=", from).where("retired_at", "is", null);
+        let q = db.selectFrom("unit_anchor").select(["id", "path", "symbol", "role", "commit_sha"]).where("unit_id", "=", u.id).where("path", "=", from).where("retired_at", "is", null);
         if (op.from.symbol)
           q = q.where("symbol", "=", op.from.symbol);
         const live = await q.execute();
         const name = `${from}${op.from.symbol ? ` ${op.from.symbol}` : ""}`;
         if (live.length === 1) {
           replaces = live[0]?.id ?? null;
+          const held = live[0];
+          if (held && held.commit_sha === null && held.path === repoPath(op.to.path) && held.symbol === (op.to.symbol ?? null) && held.role === op.to.role)
+            errors3.push(`${what}: the anchor on ${name} is already that place`);
           if (replaces !== null && replaced.has(replaces))
             errors3.push(`${what}: another operation in this batch already replaces ${name}`);
           if (replaces !== null)
-            replaced.add(replaces);
+            replaced.set(replaces, i);
         } else if (!live.length)
           errors3.push(`${what}: no live anchor on ${name}`);
         else
@@ -48271,13 +48375,26 @@ async function checkGlean(db, target, raw, facts = prepareGlean(target.root, raw
       if (anchored.has(k))
         errors3.push(`${what}: another operation in this batch already anchors ${name}`);
       anchored.add(k);
-      places.push({ what, unit: u.id, rel, symbol: dest.symbol ?? null, role: dest.role, commit, name });
+      places.push({
+        what,
+        unit: u.id,
+        rel,
+        symbol: dest.symbol ?? null,
+        role: dest.role,
+        commit,
+        name,
+        replacing: op.op === "replace_anchor" ? i : null
+      });
     }
     if (op.op === "retract_evidence" || op.op === "retract_adoption" || op.op === "withdraw" || op.op === "resolve_conflict") {
       const got = await span(op.reason_source, op.reason_quote, what);
       if (got && got.s.author_kind !== "owner")
         errors3.push(`${what}: only the owner's words can retract, withdraw, or resolve`);
     }
+    if (op.op === "withdraw") {
+      if (u.lifecycle === "superseded")
+        errors3.push(`${what}: ${op.unit} is superseded, so there is nothing live to withdraw (withdraw the record that replaced it, if that one no longer holds)`);
+    }
     if (op.op === "resolve_conflict") {
       const open2 = await db.selectFrom("unit_link as l").innerJoin("unit as a", "a.id", "l.from_unit").innerJoin("unit as b", "b.id", "l.to_unit").select("l.from_unit").where("l.kind", "=", "conflicts").where("l.resolved_at", "is", null).where((eb) => eb.or([
         eb.and([eb("a.id", "=", u.id), eb("b.key", "=", op.with)]),
@@ -48308,11 +48425,14 @@ async function checkGlean(db, target, raw, facts = prepareGlean(target.root, raw
     ops.push({ input: op, unitId: u.id, lifecycle: u.lifecycle, excerpt, retracts, replaces });
   }
   for (const x of places) {
-    let q = db.selectFrom("unit_anchor").select("id").where("unit_id", "=", x.unit).where("path", "=", x.rel).where("role", "=", x.role).where("retired_at", "is", null).where("id", "not in", [...replaced, -1]);
+    const gone = [...replaced].filter(([, by]) => x.replacing === null || by < x.replacing).map(([id]) => id);
+    let q = db.selectFrom("unit_anchor").select("id").where("unit_id", "=", x.unit).where("path", "=", x.rel).where("role", "=", x.role).where("retired_at", "is", null).where("id", "not in", [...gone, -1]);
     q = x.symbol ? q.where("symbol", "=", x.symbol) : q.where("symbol", "is", null);
     q = x.commit ? q.where("commit_sha", "=", x.commit) : q.where("commit_sha", "is", null);
-    if (await q.executeTakeFirst())
-      errors3.push(`${x.what}: the record already has a live anchor on ${x.name}`);
+    const held = await q.executeTakeFirst();
+    if (!held || x.replacing !== null && replaced.get(held.id) === x.replacing)
+      continue;
+    errors3.push(replaced.has(held.id) ? `${x.what}: a later operation of this batch moves the anchor off ${x.name}; put that replacement before this one, or make the moves in two saves` : `${x.what}: the record already has a live anchor on ${x.name}`);
   }
   return { errors: errors3, problems, units, ops };
 }
@@ -48327,19 +48447,20 @@ async function forgottenExcerpt(db, projectId2, x) {
 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();
+  const found = await trx.selectFrom("source").select(["id", "revision", "content_hash"]).where("project_id", "=", projectId2).where("kind", "=", "file_excerpt").where("external_id", "=", external2).where("session_id", "is", null).orderBy("revision", "desc").executeTakeFirst();
   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({
+  const revision2 = Math.max(found?.revision ?? 0, forgotten.last) + 1;
+  await trx.insertInto("ingest_source").values({
     project_id: projectId2,
     kind: "file_excerpt",
     artifact: `file:${x.path}`,
     external_id: external2,
-    revision: Math.max(found?.revision ?? 0, forgotten.last) + 1,
+    revision: revision2,
     author_kind: "person",
     created_at: now,
     captured_at: now,
@@ -48354,8 +48475,8 @@ async function excerptSource(trx, projectId2, x) {
     commit_sha: x.commit,
     blob_sha: x.blob,
     indexed: 1
-  }).returning("id").executeTakeFirstOrThrow();
-  return row.id;
+  }).execute();
+  return itemId(trx, projectId2, "file_excerpt", external2, revision2);
 }
 async function move(trx, unitId, to, reason2, sourceId, runId) {
   const u = await trx.selectFrom("unit").select("lifecycle").where("id", "=", unitId).executeTakeFirstOrThrow();
@@ -48392,7 +48513,11 @@ ${c.errors.map((e) => `  ${e}`).join(`
     return { id: s.id, start: at[0], end: at[1] };
   };
   const touched = new Map;
-  for (const p of c.ops) {
+  const ordered = [
+    ...c.ops.filter((p) => p.input.op === "replace_anchor"),
+    ...c.ops.filter((p) => p.input.op !== "replace_anchor")
+  ];
+  for (const p of ordered) {
     const op = p.input;
     touched.set(p.unitId, op.unit);
     if (op.op === "add_evidence") {
@@ -48431,6 +48556,11 @@ ${c.errors.map((e) => `  ${e}`).join(`
       refresh(c.units.facts, rel);
       const symbol2 = to.symbol && !symbolMasked(c.units.facts, rel, to.symbol) ? to.symbol : null;
       const at = symbol2 ? symbolAt(c.units.facts, rel, symbol2) : null;
+      if (op.op === "replace_anchor") {
+        const held = await trx.selectFrom("unit_anchor as a").innerJoin("unit as u", "u.id", "a.unit_id").select(["u.kind", "u.lifecycle", "a.role", "a.commit_sha", "a.edit_observation_id"]).where("a.id", "=", p.replaces ?? -1).executeTakeFirst();
+        if (held?.kind === "implementation" && held.lifecycle === "active" && held.role === "evidence" && (held.commit_sha !== null || held.edit_observation_id !== null))
+          await move(trx, p.unitId, "candidate", "glean: code anchor replaced, support checked again", null, runId);
+      }
       const added = await trx.insertInto("unit_anchor").values({
         unit_id: p.unitId,
         path: rel,
@@ -48445,11 +48575,6 @@ ${c.errors.map((e) => `  ${e}`).join(`
       }).returning("id").executeTakeFirstOrThrow();
       if (op.op === "replace_anchor")
         await trx.updateTable("unit_anchor").set({ retired_at: now, replaced_by: added.id }).where("id", "=", p.replaces ?? -1).where("retired_at", "is", null).execute();
-      if (op.op === "replace_anchor") {
-        const held = await trx.selectFrom("unit_anchor as a").innerJoin("unit as u", "u.id", "a.unit_id").select(["u.kind", "u.lifecycle", "a.role", "a.commit_sha", "a.edit_observation_id"]).where("a.id", "=", p.replaces ?? -1).executeTakeFirst();
-        if (held?.kind === "implementation" && held.lifecycle === "active" && held.role === "evidence" && (held.commit_sha !== null || held.edit_observation_id !== null))
-          await move(trx, p.unitId, "candidate", "glean: code anchor replaced, support checked again", null, runId);
-      }
       changed2.push(`${op.unit}: anchor ${op.op === "anchor" ? "added" : "replaced"}`);
     } else {
       const reason2 = await spanOf(op.reason_source, op.reason_quote);
@@ -48470,9 +48595,22 @@ ${c.errors.map((e) => `  ${e}`).join(`
         continue;
       }
       if (op.op === "withdraw") {
+        touched.delete(p.unitId);
+        const held = await trx.selectFrom("unit").select("lifecycle").where("id", "=", p.unitId).executeTakeFirstOrThrow();
+        if (held.lifecycle === "superseded") {
+          changed2.push(`${op.unit}: superseded by a record of this save, so not withdrawn`);
+          continue;
+        }
+        const replaced = await trx.selectFrom("unit_link as l").innerJoin("unit as o", "o.id", "l.to_unit").select(["o.id", "o.key"]).where("l.from_unit", "=", p.unitId).where("l.kind", "=", "supersedes").where("o.lifecycle", "=", "superseded").execute();
         await move(trx, p.unitId, "withdrawn", `withdrawn: ${head(op.reason_quote, 200)}`, reason2.id, runId);
         changed2.push(`${op.unit}: withdrawn`);
-        touched.delete(p.unitId);
+        for (const o of replaced) {
+          const now2 = await trx.selectFrom("unit").select("lifecycle").where("id", "=", o.id).executeTakeFirstOrThrow();
+          if (now2.lifecycle !== "candidate")
+            continue;
+          changed2.push(`${o.key}: no longer superseded`);
+          touched.set(o.id, o.key);
+        }
         continue;
       }
       const current2 = await trx.selectFrom("unit").select("lifecycle").where("id", "=", p.unitId).executeTakeFirstOrThrow();
@@ -48500,7 +48638,6 @@ ${c.errors.map((e) => `  ${e}`).join(`
       changed2.push(`${o.key}: superseded`);
     }
   }
-  await trx.updateTable("extraction_run").set({ status: "saved", finished_at: now }).where("id", "=", runId).execute();
   return { units, changed: changed2 };
 }
 
@@ -48868,6 +49005,7 @@ async function saveText(db, id, projectId2, root, record3, probe) {
       ].map((q) => q.source));
       return saveRecord(trx, scope.target, run.id, checked, scope.looked.filter((s) => shown.has(s) || cited.has(s)));
     });
+    await finishRun(trx, run.id);
     return [
       ...saved.active.map((k) => `✓ ${k} active`),
       ...saved.superseded.map((k) => `✓ ${k} superseded`),
@@ -48925,7 +49063,6 @@ async function forgetIn(trx, projectId2, ids, at) {
     sources: rows.map((r) => ({ id: r.id, kind: r.kind, artifact: r.artifact, bytes: r.bytes })),
     already,
     units: [],
-    references: 0,
     fields: { definitions: 0, values: 0 }
   };
   if (!rows.length)
@@ -48959,9 +49096,6 @@ async function forgetIn(trx, projectId2, ids, at) {
     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) {
@@ -49045,8 +49179,6 @@ function forgetText(o, file3) {
     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.fields.definitions || o.fields.values)
     lines.push(`- ${plural2(o.fields.definitions, "field definition")} and ${plural2(o.fields.values, "field value")} go with them`);
   if (o.units.length || o.fields.values)

package/dist/mcp.js

@@ -46030,7 +46030,7 @@ var HOST_MARKS = new Set([".orphaned_at", ".in_use"]);
 
 // server/src/sqlite.ts
 var SCHEMA_GENERATION = 2;
-var SCHEMA_REVISION = 4;
+var SCHEMA_REVISION = 5;
 var sphicaHome = () => process.env.SPHICA_HOME || path2.join(os.homedir(), ".sphica");
 var dbFile = () => process.env.SPHICA_DB || path2.join(sphicaHome(), "sphica.db");
 function requireRuntime() {
@@ -46354,10 +46354,8 @@ async function describe3(db, u, root, asOf) {
   for (const l of links) {
     if (l.kind === "supersedes")
       out.push(l.from_id === u.id ? `Supersedes ${l.to_key}` : `Superseded by ${l.from_key}`);
-    else if (l.kind === "conflicts")
-      out.push(`Conflicts with ${l.from_id === u.id ? l.to_key : l.from_key}${l.resolved_at ? " (resolved)" : " (unresolved)"}`);
     else
-      out.push(`${l.from_id === u.id ? "Implements" : "Implemented by"} ${l.from_id === u.id ? l.to_key : l.from_key}`);
+      out.push(`Conflicts with ${l.from_id === u.id ? l.to_key : l.from_key}${l.resolved_at ? " (resolved)" : " (unresolved)"}`);
   }
   out.push(`History: ${history.map((s) => `${s.to_state} ${s.at} (${s.reason})`).join("; ")}`);
   return out.join(`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sphica",
-  "version": "0.6.13",
+  "version": "0.6.15",
   "description": "Records Claude Code and Codex sessions on your machine and keeps past implementation and decisions, with their sources, for your agent to find.",
   "license": "MIT",
   "type": "module",

package/skills/glean/SKILL.md

@@ -73,7 +73,7 @@ read tools `search` and `read`. Pass the repository root as `cwd` to every tool.
 | `anchor` / `replace_anchor` | Adds a code location, or replaces one whose code moved (`from` and `to`, citing the owner's words); the old one is kept as history. A replacement carries no commit, so an implementation whose proof was the replaced anchor goes back to candidate: add an `anchor` op with `commit` in the same batch to keep it active. A `symbol` that is a key or a value Sphica masks is refused: anchor a name, or the path alone |
 | `retract_evidence` / `retract_adoption` | Marks a link mistaken, citing the owner's words (`reason_source`, `reason_quote`). When the record cites the same source more than once, add `quote` to say which one. It is kept as history, and the record is judged again |
 | `resolve_conflict` | Ends an unresolved conflict between `unit` and `with`, citing the owner's words (`reason_source`, `reason_quote`). Until then neither record is shown on its own |
-| `withdraw` | Withdraws a record the owner says no longer holds, citing the owner's words |
+| `withdraw` | Withdraws a record the owner says no longer holds, citing the owner's words. A superseded record is refused: withdraw the record that replaced it |
 
 Every op carries the `revision` read printed; a record changed since is refused, so read it again. To correct what a record says, write a new
 record in `units` (trace's shape, keys saved as `glean:<key>`) with `supersedes` naming the old one (citing the owner's words, a maintainer's, or the owner's session, not other people's text); records are never rewritten.