sphica 0.6.33 → 0.6.35

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "sphica",
-  "version": "0.6.33",
+  "version": "0.6.35",
   "description": "Records Claude Code and Codex sessions on your machine and keeps past implementation and decisions, with their sources, for your agent to find.",
   "author": {
     "name": "iroha924",

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "sphica",
-  "version": "0.6.33",
+  "version": "0.6.35",
   "description": "Records Claude Code and Codex sessions on your machine and keeps past implementation and decisions, with their sources, for your agent to find.",
   "author": {
     "name": "iroha924",

package/README.md

@@ -144,7 +144,7 @@ The agent searches with Sphica's `search` and opens full records with `read`. `s
 - Showing a record does not make the agent follow it.
 - Whether the agent decided something itself is judged from what its reply says, so it can be wrong.
 - An AI's decision is adopted only when the trace runs in an interactive Claude Code session. In headless and SDK runs and in Codex it stays a candidate. The automatic trace also runs only in Claude Code; Codex tells you when sessions wait.
-- When Sphica cannot tell which turn ran one of its record tools (its hook timed out or was turned off), every reply Claude Code's agent writes in that project from then on stays a candidate, for good. Your decisions are not affected.
+- When Sphica cannot tell which turn ran one of its record tools, every reply Claude Code's agent writes in that project from then on stays a candidate. If the hook only timed out, it keeps what it saw and the next recording sends it; from then on, replies of other turns can be adopted again (when the hook knew the turn), while the turn that ran the tool stays out. If the hook was turned off, the host sent no tool call id, or the call came before Sphica was installed, nothing can be sent later and the stop stays for good. Records already saved as candidates are not adopted afterwards. `sphica doctor` lists the calls behind a stop and since when. Your decisions are not affected.
 - The automatic trace uses your subscription's usage.
 - The agent never withdraws an AI's decision. When a later record contradicts it, the AI's decision is held back from being shown until you settle it, and so is the later record unless it is your decision.
 - A code location in a record is checked against your working tree when it is read. Finding the code name (a function name, say) the record points to does not mean the decision still holds.

package/dist/capture.js

@@ -11927,6 +11927,8 @@ var spoolDir = () => path6.join(sphicaHome(), "spool");
 var stateFile = () => path6.join(sphicaHome(), "capture.json");
 var rejectedDir = () => path6.join(spoolDir(), "rejected");
 var unregisteredDir = () => path6.join(spoolDir(), "unregistered");
+var callsDir = () => path6.join(spoolDir(), "calls");
+var callsRejectedDir = () => path6.join(callsDir(), "rejected");
 var HOLD_DAYS = 30;
 var HOLD_MAX = 1000;
 var baselineDir = () => path6.join(sphicaHome(), "worktree");
@@ -11975,7 +11977,7 @@ ${z}`,
     originalBytes: all
   };
 }
-function prune(held) {
+function prune(held, removed = () => {}) {
   let files;
   try {
     files = fs5.readdirSync(held).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort();
@@ -11985,16 +11987,21 @@ function prune(held) {
   const cutoff = Date.now() - HOLD_DAYS * 24 * 60 * 60 * 1000;
   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]))
+  for (const f of new Set([...stale, ...over])) {
     fs5.rmSync(path6.join(held, f), { force: true });
+    removed();
+  }
 }
-function spool(record) {
-  const dir = spoolDir();
+function put(dir, record) {
   fs5.mkdirSync(dir, { recursive: true, mode: 448 });
   const name = `${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 10)}.json`;
   const tmp = path6.join(dir, `.${name}`);
   fs5.writeFileSync(tmp, JSON.stringify(record), { mode: 384 });
   fs5.renameSync(tmp, path6.join(dir, name));
+  return path6.join(dir, name);
+}
+function spool(record) {
+  put(spoolDir(), record);
 }
 var branchOf = (root) => {
   try {
@@ -12049,9 +12056,11 @@ function captureNotice(file = dbFile()) {
   if (!fs5.existsSync(file))
     return panel("sphica: no database, so conversations are not recorded", [file], "Create it with sphica init");
   const s = readState();
+  if (s.unreadable)
+    return panel("sphica: cannot read the recording queue", [spoolDir(), s.unreadable], "Check with sphica doctor");
   if (s.stuck)
     return panel("sphica: cannot send recordings", [`${s.pending} pending / failed: ${plain2(s.stuck.slice(0, 120))}`], "Check with sphica doctor");
-  if (s.rejected > 0)
+  if (s.rejected)
     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;
 }
@@ -12242,37 +12251,116 @@ function onHook(host, input) {
   }
   return { flush: false };
 }
+function readStateFile() {
+  let raw = {};
+  try {
+    const parsed = JSON.parse(fs5.readFileSync(stateFile(), "utf8"));
+    if (parsed && typeof parsed === "object")
+      raw = parsed;
+  } catch {}
+  const p = raw.pruned;
+  return {
+    flushedAt: typeof raw.flushedAt === "string" ? raw.flushedAt : undefined,
+    error: typeof raw.error === "string" ? raw.error || "unknown failure" : null,
+    deferred: typeof raw.deferred === "number" ? raw.deferred : undefined,
+    pruned: p && typeof p.at === "string" && typeof p.count === "number" ? { at: p.at, count: p.count } : undefined
+  };
+}
 function writeState(s) {
   try {
-    fs5.writeFileSync(stateFile(), JSON.stringify(s));
+    fs5.writeFileSync(stateFile(), JSON.stringify({ ...s, pruned: s.pruned ?? readStateFile().pruned }));
   } catch {}
 }
 function readState() {
-  const count = (dir) => {
+  const queue = listQueue(spoolDir());
+  const counts = {
+    pending: queue.files?.length ?? null,
+    rejected: listQueue(rejectedDir()).files?.length ?? null,
+    unregistered: listQueue(unregisteredDir()).files?.length ?? null
+  };
+  const state = readStateFile();
+  const stuck = state.error && (counts.pending ?? 0) > 0 ? state.error : null;
+  return { ...state, ...counts, unreadable: queue.code, stuck };
+}
+function listQueue(dir) {
+  try {
+    const names = fs5.readdirSync(dir);
+    return {
+      files: names.filter((f) => f.endsWith(".json") && !f.startsWith(".")),
+      temp: names.filter((f) => f.endsWith(".json") && f.startsWith(".")),
+      code: null
+    };
+  } catch (e) {
+    const code = e.code ?? "unknown";
+    return code === "ENOENT" ? { files: [], temp: [], code: null } : { files: null, temp: [], code };
+  }
+}
+var TEMP_AGE_MS = 60000;
+var REASON = /^[a-z]+(-[a-z]+)?(:[A-Z]+)?$/;
+function queueReport(now = Date.now()) {
+  const dirs = {
+    queue: spoolDir(),
+    calls: callsDir(),
+    rejected: rejectedDir(),
+    unregistered: unregisteredDir(),
+    callsRejected: callsRejectedDir()
+  };
+  const listed = Object.fromEntries(Object.entries(dirs).map(([k, d]) => [k, listQueue(d)]));
+  const report = (k) => {
+    const temp = { count: 0, oldestMs: 0, bytes: 0 };
+    for (const name of listed[k].temp)
+      try {
+        const st = fs5.statSync(path6.join(dirs[k], name));
+        const age = now - st.mtimeMs;
+        if (age < TEMP_AGE_MS)
+          continue;
+        temp.count++;
+        temp.bytes += st.size;
+        temp.oldestMs = Math.max(temp.oldestMs, age);
+      } catch {}
+    return { files: listed[k].files?.length ?? null, code: listed[k].code, temp };
+  };
+  const reasons = (k) => {
+    const out = {};
+    for (const name of listed[k].files ?? []) {
+      let why = "unknown";
+      try {
+        const text = fs5.readFileSync(path6.join(dirs[k], `${name}.reason`), "utf8");
+        if (REASON.test(text))
+          why = text;
+      } catch {}
+      out[why] = (out[why] ?? 0) + 1;
+    }
+    return out;
+  };
+  const read = (dir, name) => {
     try {
-      return fs5.readdirSync(dir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).length;
+      return JSON.parse(fs5.readFileSync(path6.join(dir, name), "utf8"));
     } catch {
-      return 0;
+      return null;
     }
   };
-  const counts = {
-    pending: count(spoolDir()),
-    rejected: count(rejectedDir()),
-    unregistered: count(unregisteredDir())
-  };
-  let raw = {};
-  try {
-    const parsed = JSON.parse(fs5.readFileSync(stateFile(), "utf8"));
-    if (parsed && typeof parsed === "object")
-      raw = parsed;
-  } catch {}
-  const error = typeof raw.error === "string" ? raw.error || "unknown failure" : null;
+  const held = new Map;
+  for (const name of listed.unregistered.files ?? []) {
+    const key = read(dirs.unregistered, name)?.project;
+    const project = typeof key === "string" ? key : "unreadable";
+    const age = Math.max(0, now - (Number(name.split("-")[0]) || now));
+    const h = held.get(project) ?? { count: 0, oldestMs: 0 };
+    held.set(project, { count: h.count + 1, oldestMs: Math.max(h.oldestMs, age) });
+  }
+  const waiting = new Set;
+  for (const name of listed.calls.files ?? []) {
+    const o = observation(read(dirs.calls, name));
+    if (o)
+      waiting.add(o.toolUse);
+  }
   return {
-    flushedAt: typeof raw.flushedAt === "string" ? raw.flushedAt : undefined,
-    error,
-    deferred: typeof raw.deferred === "number" ? raw.deferred : undefined,
-    ...counts,
-    stuck: error && counts.pending > 0 ? error : null
+    dirs: Object.fromEntries(Object.keys(dirs).map((k) => [k, report(k)])),
+    rejected: reasons("rejected"),
+    callsRejected: reasons("callsRejected"),
+    held: [...held].map(([project, h]) => ({ project, ...h })).sort((a, b) => a.project.localeCompare(b.project)),
+    waiting,
+    pruned: readStateFile().pruned
   };
 }
 function lock() {
@@ -12412,16 +12500,36 @@ var queued = (from) => {
     return [];
   }
 };
+var CODE_NAMES = { 18: "TOOBIG", 19: "CONSTRAINT", 20: "MISMATCH", 25: "RANGE" };
+function setAside(from, name, dir, reason2) {
+  fs5.mkdirSync(dir, { recursive: true, mode: 448 });
+  try {
+    fs5.renameSync(path6.join(from, name), path6.join(dir, name));
+  } catch (e) {
+    if (e.code === "ENOENT")
+      return;
+    throw e;
+  }
+  try {
+    fs5.writeFileSync(path6.join(dir, `${name}.reason`), reason2, { mode: 384 });
+  } catch {}
+}
 async function sendBatch(db, names) {
   const held = unregisteredDir();
   const records = [];
   for (const { name, from } of names) {
+    let raw;
     let r;
     try {
-      r = current(JSON.parse(fs5.readFileSync(path6.join(from, name), "utf8")));
+      raw = JSON.parse(fs5.readFileSync(path6.join(from, name), "utf8"));
     } catch {
-      fs5.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
-      fs5.renameSync(path6.join(from, name), path6.join(rejectedDir(), name));
+      setAside(from, name, rejectedDir(), "unreadable");
+      continue;
+    }
+    try {
+      r = current(raw);
+    } catch {
+      setAside(from, name, rejectedDir(), typeof raw?.project === "string" ? "version" : "no-project");
       continue;
     }
     if (r)
@@ -12448,21 +12556,12 @@ async function sendBatch(db, names) {
       } catch (e2) {
         if (!rejected(e2))
           throw e2;
-        bad.push(x);
-      }
-    }
-  }
-  if (bad.length) {
-    fs5.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
-    for (const x of bad) {
-      try {
-        fs5.renameSync(path6.join(x.from, x.name), path6.join(rejectedDir(), x.name));
-      } catch (e) {
-        if (e.code !== "ENOENT")
-          throw e;
+        bad.push({ ...x, why: `sqlite:${CODE_NAMES[sqliteCode(e2) ?? -1] ?? "unknown"}` });
       }
     }
   }
+  for (const x of bad)
+    setAside(x.from, x.name, rejectedDir(), x.why);
   if (strayed.length) {
     fs5.mkdirSync(held, { recursive: true, mode: 448 });
     for (const x of strayed) {
@@ -12482,6 +12581,60 @@ async function sendBatch(db, names) {
       fs5.rmSync(path6.join(x.from, x.name), { force: true });
   return { sent, rejected: bad.length };
 }
+async function sendObservations(db, names) {
+  const aside = (name, why) => {
+    try {
+      setAside(callsDir(), name, callsRejectedDir(), why);
+    } catch {}
+  };
+  const rows = [];
+  for (const { name, from } of names) {
+    let text;
+    try {
+      text = fs5.readFileSync(path6.join(from, name), "utf8");
+    } catch {
+      continue;
+    }
+    let o = null;
+    let why = "unreadable";
+    try {
+      o = observation(JSON.parse(text));
+      why = "shape";
+    } catch {}
+    if (o)
+      rows.push({ name, o });
+    else
+      aside(name, why);
+  }
+  if (!rows.length)
+    return true;
+  const insert = (part) => db.insertInto("capture_tool_call").values(part.map((x) => observationRow(x.o))).execute();
+  const bad = new Map;
+  try {
+    await insert(rows);
+  } catch (e) {
+    if (!rejected(e))
+      return false;
+    for (const x of rows)
+      try {
+        await insert([x]);
+      } catch (e2) {
+        if (!rejected(e2))
+          return false;
+        bad.set(x.name, `sqlite:${CODE_NAMES[sqliteCode(e2) ?? -1] ?? "unknown"}`);
+      }
+  }
+  for (const x of rows) {
+    const why = bad.get(x.name);
+    if (why)
+      aside(x.name, why);
+    else
+      try {
+        fs5.rmSync(path6.join(callsDir(), x.name), { force: true });
+      } catch {}
+  }
+  return true;
+}
 async function flush(file = dbFile(), budgetMs = FLUSH_BUDGET_MS) {
   const deadline = Date.now() + budgetMs;
   const dir = spoolDir();
@@ -12489,6 +12642,8 @@ async function flush(file = dbFile(), budgetMs = FLUSH_BUDGET_MS) {
   const total = { sent: 0, deferred: 0, rejected: 0 };
   let batches = 0;
   let queueBatches = 0;
+  let removed = 0;
+  const pruned = () => removed ? { at: new Date().toISOString(), count: removed } : undefined;
   for (let first = true;; first = false) {
     let unlock = lock();
     while (!unlock && Date.now() < deadline) {
@@ -12510,12 +12665,20 @@ async function flush(file = dbFile(), budgetMs = FLUSH_BUDGET_MS) {
     const sentBefore = batches;
     try {
       if (first) {
-        prune(held);
+        prune(held, () => removed++);
         for (const part of chunks(queued(held), BATCH)) {
           if (late())
             break;
           await send(part);
         }
+        for (const part of chunks(queued(callsDir()), BATCH)) {
+          if (late())
+            break;
+          client ??= openWriter("capture", file);
+          if (!await sendObservations(client, part))
+            break;
+          batches++;
+        }
       }
       while (queueBatches === 0 || !late()) {
         const part = queued(dir).slice(0, BATCH);
@@ -12524,12 +12687,19 @@ async function flush(file = dbFile(), budgetMs = FLUSH_BUDGET_MS) {
         await send(part);
         queueBatches++;
       }
-      prune(held);
+      prune(held, () => removed++);
       total.deferred = queued(held).length;
       if (batches > sentBefore)
-        writeState({ flushedAt: new Date().toISOString(), error: null, deferred: total.deferred });
+        writeState({
+          flushedAt: new Date().toISOString(),
+          error: null,
+          deferred: total.deferred,
+          pruned: pruned()
+        });
+      else if (removed)
+        writeState({ ...readStateFile(), pruned: pruned() });
     } catch (e) {
-      writeState({ flushedAt: new Date().toISOString(), error: reason(e).slice(0, 300) });
+      writeState({ flushedAt: new Date().toISOString(), error: reason(e).slice(0, 300), pruned: pruned() });
       throw e;
     } finally {
       await client?.destroy().catch(() => {});
@@ -12548,27 +12718,63 @@ async function readInput(stream) {
 }
 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))
+var hostId = (v) => typeof v === "string" && /^[\x21-\x7e]{1,200}$/.test(v) ? v : null;
+var OBSERVATION_KEYS = ["at", "host", "owner", "session", "tool", "toolUse", "turn", "v"].join();
+function observation(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return null;
+  const o = raw;
+  if (Object.keys(o).sort().join() !== OBSERVATION_KEYS)
+    return null;
+  if (o.v !== 1 || o.host !== "claude-code" || !hostId(o.session) || !hostId(o.toolUse))
+    return null;
+  if (!hostId(o.tool)?.startsWith(RECORD_TOOLS))
+    return null;
+  if (o.turn !== null && !hostId(o.turn))
+    return null;
+  if (o.owner !== 0 && o.owner !== 1)
+    return null;
+  const at = typeof o.at === "string" && /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(o.at) ? o.at : null;
+  if (!at || Number.isNaN(Date.parse(at)) || new Date(at).toISOString() !== at)
+    return null;
+  return o;
+}
+var observationRow = (o) => ({
+  host: o.host,
+  session_external: o.session,
+  turn_id: o.turn,
+  tool_use_id: o.toolUse,
+  tool_name: o.tool,
+  owner_turn: o.owner,
+  observed_at: o.at
+});
+async function observeRecordCall(file, input, owner, waitMs = OBSERVE_WAIT_MS) {
+  const o = observation({
+    v: 1,
+    host: "claude-code",
+    session: hostId(input.session_id),
+    turn: hostId(input.prompt_id),
+    toolUse: hostId(input.tool_use_id),
+    tool: hostId(input.tool_name),
+    owner: owner ? 1 : 0,
+    at: iso(Date.now())
+  });
+  if (!o)
     return;
-  const cap = openWriter("capture", file, OBSERVE_WAIT_MS);
+  let kept = null;
   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();
+    kept = put(callsDir(), o);
+  } catch {}
+  const cap = openWriter("capture", file, waitMs);
+  try {
+    await cap.insertInto("capture_tool_call").values(observationRow(o)).execute();
   } finally {
     await cap.destroy().catch(() => {});
   }
+  if (kept)
+    try {
+      fs5.rmSync(kept, { force: true });
+    } catch {}
 }
 async function main() {
   if (process.argv[2] === "--flush") {
@@ -12603,15 +12809,19 @@ export {
   TOOL_FLUSH_BUDGET_MS,
   answersOf,
   branchOf,
+  callsDir,
+  callsRejectedDir,
   captureNotice,
   closeTurn,
   current,
   fit,
   flush,
   isOwnerTurn,
+  observation,
   observeRecordCall,
   onHook,
   openTurn,
+  queueReport,
   readInput,
   readState,
   rejectedDir,