sphica 0.6.28 → 0.6.30

package/dist/cli.js

@@ -3697,7 +3697,7 @@ ${indent}${caution(note)}` : ""}`);
 
 // server/src/sqlite.ts
 var SCHEMA_GENERATION = 2;
-var SCHEMA_REVISION = 9;
+var SCHEMA_REVISION = 10;
 var sphicaHome = () => process.env.SPHICA_HOME || path3.join(os2.homedir(), ".sphica");
 var dbFile = () => process.env.SPHICA_DB || path3.join(sphicaHome(), "sphica.db");
 function requireRuntime() {
@@ -14681,6 +14681,7 @@ var CAPTURE_VIEWS = new Set([
   "capture_session",
   "capture_message",
   "capture_edit",
+  "capture_tool_call",
   "capture_delivery",
   "capture_delivery_scoped",
   "capture_delivery_prune"
@@ -14689,6 +14690,7 @@ var TRIGGER_WRITES = {
   capture_session_insert: new Set(["session"]),
   capture_message_insert: new Set(["source"]),
   capture_edit_insert: new Set(["edit_observation"]),
+  capture_tool_call_insert: new Set(["tool_call_observation"]),
   capture_delivery_insert: new Set(["delivery", "delivery_unit"]),
   capture_delivery_scoped_insert: new Set(["delivery", "delivery_unit"]),
   source_fts_ai: new Set(["source_fts"])
@@ -14736,6 +14738,7 @@ function captureAuthorizer(own, action, p1, p2, triggerOrView) {
 var writes = (action) => action === C2.SQLITE_INSERT || action === C2.SQLITE_UPDATE || action === C2.SQLITE_DELETE;
 var INGEST_INSERTS = new Set([
   "project",
+  "record_call",
   "ingest_source",
   "extraction_run",
   "source_processing",
@@ -14745,6 +14748,7 @@ var INGEST_INSERTS = new Set([
   "unit_adoption",
   "unit_link",
   "unit_state",
+  "unit_replacement",
   "unit_anchor",
   "unit_alias",
   "field_def",
@@ -14765,6 +14769,7 @@ var INGEST_UPDATES = {
   unit_link: new Set(["resolved_at", "resolution"]),
   unit_evidence: new Set(RETRACTION),
   unit_adoption: new Set(RETRACTION),
+  unit_replacement: new Set(["ended_at", "end_reason", "end_run_id"]),
   work: new Set(["title", "goal", "current", "next", "status", "branch", "run_id", "updated_at"])
 };
 var INGEST_DELETES = new Set(["artifact_link"]);
@@ -14773,7 +14778,6 @@ var INGEST_TRIGGER_WRITES = {
   source_fts_ai: ["insert source_fts"],
   source_fts_ad: ["delete source_fts"],
   unit_state_apply: ["update unit"],
-  unit_state_restore: ["insert unit_state"],
   delivery_ad: ["delete delivery_unit"],
   ...Object.fromEntries([
     "evidence_i",
@@ -14784,6 +14788,8 @@ var INGEST_TRIGGER_WRITES = {
     "adoption_d",
     "link_i",
     "link_u",
+    "replacement_i",
+    "replacement_u",
     "anchor_i",
     "anchor_u",
     "alias_i",
@@ -14818,7 +14824,14 @@ function ingestAuthorizer(action, p1, p2, trigger) {
   return C2.SQLITE_DENY;
 }
 var FORGET_WRITES = {
-  [C2.SQLITE_INSERT]: new Set(["forget_batch", "source_forgotten", "unit_state", "source_fts", "unit_fts"]),
+  [C2.SQLITE_INSERT]: new Set([
+    "forget_batch",
+    "source_forgotten",
+    "unit_state",
+    "unit_replacement",
+    "source_fts",
+    "unit_fts"
+  ]),
   [C2.SQLITE_DELETE]: new Set([
     "source",
     "unit_evidence",
@@ -14832,7 +14845,8 @@ var FORGET_WRITES = {
 };
 var FORGET_UPDATES = {
   unit: new Set(["lifecycle", "revision"]),
-  unit_state: new Set(["source_id"])
+  unit_state: new Set(["source_id"]),
+  unit_replacement: new Set(["ended_at", "end_reason", "end_forget_id"])
 };
 function forgetAuthorizer(action, p1, p2) {
   if (SHADOW.test(p1 ?? "") && writes(action))
@@ -15727,6 +15741,30 @@ async function readInput(stream) {
     raw += chunk;
   return JSON.parse(raw || "{}");
 }
+var RECORD_TOOLS = "mcp__plugin_sphica_record__";
+var OBSERVE_WAIT_MS = 5000;
+var hostId = (v) => v && /^[\x21-\x7e]{1,200}$/.test(v) ? v : null;
+async function observeRecordCall(file, input, owner) {
+  const session = hostId(input.session_id);
+  const toolUse = hostId(input.tool_use_id);
+  const tool = hostId(input.tool_name);
+  if (!session || !toolUse || !tool?.startsWith(RECORD_TOOLS))
+    return;
+  const cap = openWriter("capture", file, OBSERVE_WAIT_MS);
+  try {
+    await cap.insertInto("capture_tool_call").values({
+      host: "claude-code",
+      session_external: session,
+      turn_id: hostId(input.prompt_id),
+      tool_use_id: toolUse,
+      tool_name: tool,
+      owner_turn: owner ? 1 : 0,
+      observed_at: iso(Date.now())
+    }).execute();
+  } finally {
+    await cap.destroy().catch(() => {});
+  }
+}
 async function main() {
   if (process.argv[2] === "--flush") {
     await flush();
@@ -15734,6 +15772,10 @@ async function main() {
   }
   const input = await readInput(process.stdin);
   const host = process.argv[2] === "codex" ? "codex" : "claude-code";
+  if (host === "claude-code" && input.hook_event_name === "PreToolUse") {
+    await observeRecordCall(dbFile(), input, isOwnerTurn(input));
+    return;
+  }
   if (host === "codex" && input.hook_event_name === "Stop")
     process.stdout.write("{}");
   const { flush: send, notice } = onHook(host, input);
@@ -15862,6 +15904,226 @@ function steps(heading, items, note) {
   return capture((output) => box(body, oneLine(heading), { output, rounded: true, width: "auto" }));
 }
 
+// server/src/judge.ts
+var replaceable = (successor, old) => successor === old || ["decision", "constraint"].includes(successor) && ["decision", "constraint"].includes(old);
+var owned = (kind) => kind === "decision" || kind === "constraint";
+function judge(s) {
+  const units = new Map(s.units.map((u3) => [u3.id, u3]));
+  const intentOf = new Map(s.intents.map((i2) => [i2.from, i2]));
+  const openInto = new Map(s.open.map((r2) => [r2.to, r2.from]));
+  const waits = new Map;
+  const unfit = (u3) => !u3.sound ? { why: "unsound" } : !u3.supported ? { why: "unsupported" } : owned(u3.kind) && intentOf.has(u3.id) && !u3.ownerAdopted ? { why: "no owner adoption" } : null;
+  const contenders = new Map;
+  for (const i2 of [...intentOf.values()].sort(order)) {
+    const from = units.get(i2.from);
+    const to = units.get(i2.to);
+    if (!from || !to || from.withdrawn)
+      continue;
+    const why = unfit(from) ?? (!replaceable(from.kind, to.kind) ? { why: "kinds" } : to.withdrawn ? { why: "target withdrawn" } : to.quarantined ? { why: "target quarantined" } : null);
+    if (why) {
+      waits.set(from.id, why);
+      continue;
+    }
+    contenders.set(i2.to, [...contenders.get(i2.to) ?? [], i2]);
+  }
+  const holders = new Map;
+  for (const [to, list] of contenders) {
+    const kept = openInto.get(to);
+    const holder = list.some((i2) => i2.from === kept) ? kept : list[0].from;
+    holders.set(to, holder);
+    for (const i2 of list)
+      if (i2.from !== holder)
+        waits.set(i2.from, { why: "place held", holder });
+  }
+  const holds = new Set(holders.values());
+  const lifecycle = new Map;
+  for (const u3 of s.units) {
+    if (u3.withdrawn) {
+      lifecycle.set(u3.id, "withdrawn");
+      waits.delete(u3.id);
+    } else if (holders.has(u3.id))
+      lifecycle.set(u3.id, "superseded");
+    else if (!unfit(u3) && (!intentOf.has(u3.id) || holds.has(u3.id))) {
+      lifecycle.set(u3.id, "active");
+      waits.delete(u3.id);
+    } else {
+      lifecycle.set(u3.id, "candidate");
+      if (!waits.has(u3.id))
+        waits.set(u3.id, unfit(u3) ?? { why: "unsupported" });
+    }
+  }
+  const unstood = new Map;
+  for (const [id, w] of waits)
+    unstood.set(id, w);
+  for (const [id, l] of lifecycle)
+    if (l !== "candidate")
+      waits.delete(id);
+  return { lifecycle, holders, waits, unstood };
+}
+function order(a2, b) {
+  return a2.addedAt < b.addedAt ? -1 : a2.addedAt > b.addedAt ? 1 : a2.from - b.from;
+}
+function difference(s, j) {
+  const close = [];
+  const open = [];
+  const stored = new Map(s.open.map((r2) => [r2.to, r2.from]));
+  for (const r2 of s.open)
+    if (j.holders.get(r2.to) !== r2.from)
+      close.push(r2);
+  for (const [to, from] of j.holders)
+    if (stored.get(to) !== from)
+      open.push({ from, to });
+  const transitions = [];
+  for (const u3 of s.units) {
+    const to = j.lifecycle.get(u3.id);
+    if (u3.lifecycle === null) {
+      transitions.push({ unit: u3.id, from: null, to: "candidate" });
+      if (to !== "candidate")
+        transitions.push({ unit: u3.id, from: "candidate", to });
+      continue;
+    }
+    if (u3.lifecycle === to)
+      continue;
+    if (u3.lifecycle === "withdrawn")
+      throw new Error(`unit ${u3.id} is withdrawn, which is final`);
+    if (u3.lifecycle === "superseded" && to === "withdrawn")
+      throw new Error(`unit ${u3.id} is superseded; withdraw what replaced it instead`);
+    transitions.push({ unit: u3.id, from: u3.lifecycle, to });
+  }
+  return { close, open, transitions };
+}
+
+// server/src/reconcile.ts
+function snapshotOf(rows, withdraw) {
+  const keys = new Map(rows.units.map((u3) => [u3.id, u3.key]));
+  const missing = new Map;
+  const snapshot2 = {
+    units: rows.units.map((u3) => {
+      const lifecycle = Number(u3.stated) === 1 ? u3.lifecycle : null;
+      const unquoted = Number(u3.unquoted) === 1 && Number(u3.ever) === 0;
+      if (u3.missing)
+        missing.set(u3.id, u3.missing);
+      else if (unquoted)
+        missing.set(u3.id, "a reconsider condition needs a quote of the owner");
+      return {
+        id: u3.id,
+        kind: u3.kind,
+        lifecycle,
+        withdrawn: lifecycle === "withdrawn" || withdraw.has(u3.id),
+        sound: u3.extraction === "supported" && Number(u3.unsourced) === 0,
+        quarantined: u3.extraction !== "supported",
+        supported: u3.missing === null && !unquoted,
+        ownerAdopted: Number(u3.owned) === 1
+      };
+    }),
+    intents: rows.intents.map((i2) => ({ from: i2.from_unit, to: i2.to_unit, addedAt: i2.added_at })),
+    open: rows.open.map((r2) => ({ from: r2.from_unit, to: r2.to_unit }))
+  };
+  return { snapshot: snapshot2, keys, missing };
+}
+function waitText(j, id, l, target) {
+  const w = j.waits.get(id) ?? j.unstood.get(id);
+  const name = (u3) => u3 === undefined ? "its target" : l.keys.get(u3) ?? `u${u3}`;
+  switch (w?.why) {
+    case "unsound":
+      return "its quote was not found or its source is gone, so it can never become active";
+    case "no owner adoption":
+      return "replacing another record needs the owner's or a maintainer's adoption";
+    case "place held":
+      return `waits: ${name(w.holder)} is in effect as the successor of ${name(target)}`;
+    case "target withdrawn":
+      return `${name(target)} is withdrawn, so there is nothing to replace`;
+    case "target quarantined":
+      return `${name(target)} is quarantined (its quote was never found), so it cannot be replaced`;
+    case "kinds":
+      return `${name(target)} is of a kind this record cannot replace`;
+    default:
+      return l.missing.get(id) ?? "its support is not complete";
+  }
+}
+function planOf(rows, asked) {
+  const withdraw = new Map(asked.withdraw ?? []);
+  const asking = [...withdraw.keys()];
+  const redundant = asking.filter((id) => judge(snapshotOf(rows, new Set(asking.filter((other) => other !== id))).snapshot).lifecycle.get(id) === "superseded");
+  for (const id of redundant)
+    withdraw.delete(id);
+  const loaded = snapshotOf(rows, new Set(withdraw.keys()));
+  const judged = judge(loaded.snapshot);
+  const plan = difference(loaded.snapshot, judged);
+  const { keys } = loaded;
+  const intentOf = new Map(loaded.snapshot.intents.map((i2) => [i2.from, i2.to]));
+  const writes2 = [];
+  const ended = new Map;
+  for (const r2 of plan.close) {
+    const reason2 = judged.lifecycle.get(r2.from) === "withdrawn" ? `${keys.get(r2.from)} was withdrawn` : judged.holders.has(r2.to) ? `${keys.get(judged.holders.get(r2.to))} took its place` : `${keys.get(r2.from)} no longer stands: ${waitText(judged, r2.from, loaded, r2.to)}`;
+    writes2.push({ op: "close", from: r2.from, to: r2.to, reason: reason2 });
+    ended.set(r2.to, r2.from);
+  }
+  for (const r2 of plan.open)
+    writes2.push({ op: "open", from: r2.from, to: r2.to });
+  for (const t2 of plan.transitions) {
+    const hint = asked.hints?.get(t2.unit);
+    const holder = judged.holders.get(t2.unit);
+    const gone = ended.get(t2.unit);
+    const reason2 = t2.from === null ? "first judged" : t2.to === "withdrawn" ? withdraw.get(t2.unit)?.reason ?? "withdrawn" : t2.to === "superseded" ? `superseded by ${keys.get(holder)}` : t2.from === "superseded" ? `${gone !== undefined ? keys.get(gone) : "its successor"} no longer replaces it` : t2.to === "active" ? hint?.reason ?? "support complete" : `${asked.because ?? "support lost"}: ${waitText(judged, t2.unit, loaded, intentOf.get(t2.unit))}`;
+    const source = t2.to === "withdrawn" ? withdraw.get(t2.unit)?.source ?? null : t2.to === "superseded" ? asked.hints?.get(holder)?.source ?? null : hint?.source ?? null;
+    writes2.push({ op: "state", unit: t2.unit, from: t2.from, to: t2.to, reason: reason2, source });
+  }
+  return { judged, loaded, writes: writes2, redundant, intentOf };
+}
+function proveSettled(rows) {
+  const after = snapshotOf(rows, new Set).snapshot;
+  const left = difference(after, judge(after));
+  if (left.close.length || left.open.length || left.transitions.length)
+    throw new Error(`records did not settle after judging: ${JSON.stringify(left)}`);
+}
+var UNITS_SQL = `select u.id, u.key, u.kind, u.lifecycle, u.extraction, u.unsourced, s.missing,
+  exists (select 1 from unit_state t where t.unit_id = u.id) as stated,
+  exists (select 1 from unit_state t where t.unit_id = u.id and t.to_state = 'active') as ever,
+  exists (select 1 from unit_adoption a where a.unit_id = u.id and a.route in ('owner_statement', 'explicit')
+    and a.retracted_at is null) as owned,
+  exists (select 1 from unit_option o where o.unit_id = u.id and o.reconsider_when is not null and not exists (
+    select 1 from unit_evidence e join source src on src.id = e.source_id
+    where e.option_id = o.id and e.role = 'reconsiders' and src.author_kind = 'owner')) as unquoted
+from unit u left join unit_support s on s.unit_id = u.id where u.project_id = ? order by u.id`;
+var INTENTS_SQL = `select l.from_unit, l.to_unit, l.added_at from unit_link l join unit u on u.id = l.from_unit
+where l.kind = 'supersedes' and u.project_id = ?`;
+var OPEN_SQL = `select r.from_unit, r.to_unit from unit_replacement r join unit u on u.id = r.to_unit
+where r.ended_at is null and u.project_id = ?`;
+function settleForMigration(io, runs, at) {
+  const notes = [];
+  for (const [project, run2] of runs) {
+    const rowsNow = () => {
+      const units = io.all(UNITS_SQL, project).filter((u3) => Number(u3.stated) === 1);
+      const ids = new Set(units.map((u3) => u3.id));
+      return {
+        units,
+        intents: io.all(INTENTS_SQL, project).filter((i2) => ids.has(i2.from_unit) && ids.has(i2.to_unit)),
+        open: io.all(OPEN_SQL, project).filter((r2) => ids.has(r2.from_unit) && ids.has(r2.to_unit))
+      };
+    };
+    const planned = planOf(rowsNow(), {});
+    const key = (id) => planned.loaded.keys.get(id) ?? `u${id}`;
+    for (const w of planned.writes) {
+      if (w.op === "close") {
+        io.run("update unit_replacement set ended_at = max(?, started_at), end_reason = ?, end_run_id = ? where from_unit = ? and to_unit = ? and ended_at is null", at, w.reason, run2, w.from, w.to);
+        notes.push([`${key(w.from)} → ${key(w.to)}`, `replacement ended: ${w.reason}`]);
+      } else if (w.op === "open") {
+        io.run("insert into unit_replacement (from_unit, to_unit, run_id, started_at) values (?, ?, ?, ?)", w.from, w.to, run2, at);
+        notes.push([
+          `${key(w.from)} → ${key(w.to)}`,
+          "in effect from this update (earlier history not recorded)"
+        ]);
+      } else {
+        io.run("insert into unit_state (unit_id, from_state, to_state, at, reason, source_id, run_id) values (?, ?, ?, max(?, (select created_at from unit where id = ?)), ?, ?, ?)", w.unit, w.from, w.to, at, w.unit, `revision 10: ${w.reason}`, w.source, run2);
+        notes.push([key(w.unit), `${w.from ?? "no state"} → ${w.to}: ${w.reason}`]);
+      }
+    }
+    proveSettled(rowsNow());
+  }
+  return notes;
+}
+
 // server/src/admin.ts
 var say = (text) => console.log(indent(text));
 var SCHEMA = () => path9.join(dbDir(), "schema.sql");
@@ -15978,6 +16240,15 @@ function withOwner(file, fn, create = false) {
     raw.close();
   }
 }
+function judgeEveryRecord(raw) {
+  const runs = new Map(raw.prepare("select project_id, max(id) as id from extraction_run where origin = 'migration' and target = 'revision:10' group by project_id").all().map((r2) => [r2.project_id, r2.id]));
+  const io = {
+    all: (sql2, ...p) => raw.prepare(sql2).all(...p),
+    run: (sql2, ...p) => void raw.prepare(sql2).run(...p)
+  };
+  for (const [item, action] of settleForMigration(io, runs, iso(Date.now())))
+    raw.prepare(`insert into temp.${NOTE} (rule, item, action) values ('judged again by revision 10', ?, ?)`).run(item, action);
+}
 function migrate(file = dbFile(), dir = MIGRATIONS()) {
   return withOwner(file, (raw) => {
     const from = versionOf(raw);
@@ -16002,6 +16273,8 @@ function migrate(file = dbFile(), dir = MIGRATIONS()) {
                 throw new Stop(r2, stops);
             }
             raw.exec(fs8.readFileSync(script, "utf8"));
+            if (r2 === 10)
+              judgeEveryRecord(raw);
             const broken = raw.prepare("pragma foreign_key_check").all().length;
             if (broken)
               throw new Error(`Migration to revision ${r2} left ${plural(broken, "broken reference")}; nothing was changed`);