sphica 0.6.32 → 0.6.34

package/dist/cli.js

@@ -16472,6 +16472,8 @@ var spoolDir = () => path8.join(sphicaHome(), "spool");
 var stateFile = () => path8.join(sphicaHome(), "capture.json");
 var rejectedDir = () => path8.join(spoolDir(), "rejected");
 var unregisteredDir = () => path8.join(spoolDir(), "unregistered");
+var callsDir = () => path8.join(spoolDir(), "calls");
+var callsRejectedDir = () => path8.join(callsDir(), "rejected");
 var HOLD_DAYS = 30;
 var HOLD_MAX = 1000;
 var baselineDir = () => path8.join(sphicaHome(), "worktree");
@@ -16520,7 +16522,7 @@ ${z}`,
     originalBytes: all
   };
 }
-function prune(held) {
+function prune(held, removed = () => {}) {
   let files;
   try {
     files = fs8.readdirSync(held).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort();
@@ -16530,16 +16532,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])) {
     fs8.rmSync(path8.join(held, f), { force: true });
+    removed();
+  }
 }
-function spool(record) {
-  const dir = spoolDir();
+function put(dir, record) {
   fs8.mkdirSync(dir, { recursive: true, mode: 448 });
   const name = `${Date.now()}-${process.pid}-${Math.random().toString(36).slice(2, 10)}.json`;
   const tmp = path8.join(dir, `.${name}`);
   fs8.writeFileSync(tmp, JSON.stringify(record), { mode: 384 });
   fs8.renameSync(tmp, path8.join(dir, name));
+  return path8.join(dir, name);
+}
+function spool(record) {
+  put(spoolDir(), record);
 }
 var branchOf = (root) => {
   try {
@@ -16594,9 +16601,11 @@ function captureNotice(file = dbFile()) {
   if (!fs8.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: ${plain(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;
 }
@@ -16787,37 +16796,116 @@ function onHook(host, input) {
   }
   return { flush: false };
 }
+function readStateFile() {
+  let raw = {};
+  try {
+    const parsed = JSON.parse(fs8.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 {
-    fs8.writeFileSync(stateFile(), JSON.stringify(s));
+    fs8.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 = fs8.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 report2 = (k) => {
+    const temp = { count: 0, oldestMs: 0, bytes: 0 };
+    for (const name of listed[k].temp)
+      try {
+        const st = fs8.statSync(path8.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 = fs8.readFileSync(path8.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 fs8.readdirSync(dir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).length;
+      return JSON.parse(fs8.readFileSync(path8.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(fs8.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 h2 = held.get(project) ?? { count: 0, oldestMs: 0 };
+    held.set(project, { count: h2.count + 1, oldestMs: Math.max(h2.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, report2(k)])),
+    rejected: reasons("rejected"),
+    callsRejected: reasons("callsRejected"),
+    held: [...held].map(([project, h2]) => ({ project, ...h2 })).sort((a2, b) => a2.project.localeCompare(b.project)),
+    waiting,
+    pruned: readStateFile().pruned
   };
 }
 function lock() {
@@ -16956,16 +17044,36 @@ var queued = (from) => {
     return [];
   }
 };
+var CODE_NAMES = { 18: "TOOBIG", 19: "CONSTRAINT", 20: "MISMATCH", 25: "RANGE" };
+function setAside(from, name, dir, reason2) {
+  fs8.mkdirSync(dir, { recursive: true, mode: 448 });
+  try {
+    fs8.renameSync(path8.join(from, name), path8.join(dir, name));
+  } catch (e) {
+    if (e.code === "ENOENT")
+      return;
+    throw e;
+  }
+  try {
+    fs8.writeFileSync(path8.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 r2;
     try {
-      r2 = current(JSON.parse(fs8.readFileSync(path8.join(from, name), "utf8")));
+      raw = JSON.parse(fs8.readFileSync(path8.join(from, name), "utf8"));
+    } catch {
+      setAside(from, name, rejectedDir(), "unreadable");
+      continue;
+    }
+    try {
+      r2 = current(raw);
     } catch {
-      fs8.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
-      fs8.renameSync(path8.join(from, name), path8.join(rejectedDir(), name));
+      setAside(from, name, rejectedDir(), typeof raw?.project === "string" ? "version" : "no-project");
       continue;
     }
     if (r2)
@@ -16992,21 +17100,12 @@ async function sendBatch(db, names) {
       } catch (e2) {
         if (!rejected(e2))
           throw e2;
-        bad.push(x);
-      }
-    }
-  }
-  if (bad.length) {
-    fs8.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
-    for (const x of bad) {
-      try {
-        fs8.renameSync(path8.join(x.from, x.name), path8.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) {
     fs8.mkdirSync(held, { recursive: true, mode: 448 });
     for (const x of strayed) {
@@ -17026,6 +17125,60 @@ async function sendBatch(db, names) {
       fs8.rmSync(path8.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 = fs8.readFileSync(path8.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 {
+        fs8.rmSync(path8.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();
@@ -17033,6 +17186,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) {
@@ -17054,12 +17209,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);
@@ -17068,12 +17231,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(() => {});
@@ -17092,27 +17262,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 {
+    kept = put(callsDir(), o);
+  } catch {}
+  const cap = openWriter("capture", file, waitMs);
   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();
+    await cap.insertInto("capture_tool_call").values(observationRow(o)).execute();
   } finally {
     await cap.destroy().catch(() => {});
   }
+  if (kept)
+    try {
+      fs8.rmSync(kept, { force: true });
+    } catch {}
 }
 async function main() {
   if (process.argv[2] === "--flush") {
@@ -18433,6 +18639,46 @@ Run --help for usage`),
   exceptionWhileRunningCommand: (e) => failed(reason(e)),
   commandErrorResult: (e) => failed(e.message)
 };
+async function adoptionStops(db, waiting, say2) {
+  const calls = await db.selectFrom("record_call as c").innerJoin("project as p", "p.id", "c.project_id").select(["p.id", "p.name", "p.key", "c.host", "c.tool_use_id", "c.called_at"]).where((eb) => eb.or([
+    eb("c.host", "is", null),
+    eb.and([eb("c.host", "=", "codex"), eb("c.caller_session", "is", null)]),
+    eb.and([
+      eb("c.host", "=", "claude-code"),
+      eb.not(eb.exists(eb.selectFrom("tool_call_observation as o").select("o.id").where("o.host", "=", "claude-code").whereRef("o.tool_use_id", "=", "c.tool_use_id")))
+    ])
+  ])).orderBy("p.name").orderBy("c.called_at").execute();
+  const turnless = await db.selectFrom("tool_call_observation as o").innerJoin("session as se", (j) => j.on("se.host", "=", "claude-code").onRef("se.external_id", "=", "o.session_external")).innerJoin("project as p", "p.id", "se.project_id").select((eb) => [
+    "p.id",
+    "p.name",
+    "p.key",
+    eb.fn.count("se.id").distinct().as("sessions"),
+    eb.fn.min("o.observed_at").as("first")
+  ]).where("o.host", "=", "claude-code").where("o.turn_id", "is", null).groupBy(["p.id", "p.name", "p.key"]).orderBy("p.name").execute();
+  const groups = new Map;
+  for (const c of calls) {
+    const k = `${c.id}\x00${c.host ?? ""}`;
+    groups.set(k, [...groups.get(k) ?? [], c]);
+  }
+  const keys = new Map;
+  for (const c of [...calls, ...turnless])
+    keys.set(c.name, (keys.get(c.name) ?? new Set).add(c.key));
+  const named = (p) => inline((keys.get(p.name)?.size ?? 0) > 1 ? `${p.name} (${p.key})` : p.name);
+  for (const group2 of groups.values()) {
+    const [first] = group2;
+    if (!first)
+      continue;
+    const from = new Date(first.called_at).toLocaleString("sv-SE");
+    const n2 = group2.length;
+    const text = first.host === "claude-code" ? (() => {
+      const resend = group2.filter((c) => c.tool_use_id && waiting.has(c.tool_use_id)).length;
+      return `Claude Code replies from ${from} on are not adopted as AI decisions: ${plural(n2, "record tool call")} without a hook observation (${resend} waiting to be resent, ${n2 - resend} that cannot be)`;
+    })() : first.host === "codex" ? `Codex replies from ${from} on are not adopted as AI decisions: ${plural(n2, "record tool call")} that named no session` : `replies of every host from ${from} on are not adopted as AI decisions: ${plural(n2, "record tool call")} that named no host`;
+    say2("warn", "AI adoption", `${named(first)}: ${text}`);
+  }
+  for (const t2 of turnless)
+    say2("warn", "AI adoption", `${named(t2)}: Claude Code replies in ${plural(Number(t2.sessions), "session")} from ${new Date(t2.first ?? "").toLocaleString("sv-SE")} on are not adopted as AI decisions: a record tool's hook did not know the turn`);
+}
 async function doctor(cwd) {
   const issues = [];
   const count = (m, label) => {
@@ -18484,7 +18730,36 @@ async function doctor(cwd) {
     }
   }
   const s = readState();
-  say2(s.stuck ? "fail" : s.rejected ? "warn" : "ok", "Recording", `${s.pending} pending${s.flushedAt ? ` / last sent ${new Date(s.flushedAt).toLocaleString("sv-SE")}` : ""}${s.stuck ? ` / failed: ${plain(s.stuck)} (sent again after the next turn)` : ""}${s.unregistered ? ` / ${s.unregistered} set aside for unregistered projects (${unregisteredDir()})` : ""}${s.rejected ? ` / ${s.rejected} rejected by the database (${rejectedDir()})` : ""}`);
+  if (s.unreadable)
+    say2("fail", "Recording", `the queue cannot be read (${inline(s.unreadable)}) at ${inline(spoolDir())}`);
+  else
+    say2(s.stuck ? "fail" : "ok", "Recording", `${s.pending} pending${s.flushedAt ? ` / last sent ${new Date(s.flushedAt).toLocaleString("sv-SE")}` : ""}${s.stuck ? ` / failed: ${plain(s.stuck)} (sent again after the next turn)` : ""}`);
+  const q = queueReport();
+  const dirOf = {
+    queue: spoolDir(),
+    calls: callsDir(),
+    rejected: rejectedDir(),
+    unregistered: unregisteredDir(),
+    callsRejected: callsRejectedDir()
+  };
+  const minutes = (ms) => ms < 2 * 3600000 ? `${Math.round(ms / 60000)} min` : ms < 2 * 86400000 ? `${Math.round(ms / 3600000)} h` : `${Math.round(ms / 86400000)} days`;
+  const reasons = (r2) => Object.entries(r2).sort(([a2], [b]) => a2.localeCompare(b)).map(([why, n2]) => `${inline(why)} ${n2}`).join(", ");
+  for (const [k, d] of Object.entries(q.dirs)) {
+    if (d.code && k !== "queue")
+      say2("fail", "Queue directory", `${inline(dirOf[k])} cannot be read (${inline(d.code)})`);
+    if (d.temp.count)
+      say2("warn", "Left-behind files", `${plural(d.temp.count, "temporary file")} older than a minute in ${inline(dirOf[k])} (oldest ${minutes(d.temp.oldestMs)}, ${d.temp.bytes} bytes): written but never put in the queue`);
+  }
+  if (q.dirs.rejected.files)
+    say2("warn", "Rejected records", `${plural(q.dirs.rejected.files, "record")} in ${inline(rejectedDir())}: ${reasons(q.rejected)}. Fix them, then move them back to ${inline(spoolDir())} to resend`);
+  if (q.held.length)
+    say2("none", "Held recordings", `for projects not registered, in ${inline(unregisteredDir())}: ${q.held.map((h2) => `${inline(h2.project)} ${h2.count} (oldest ${minutes(h2.oldestMs)})`).join(" / ")}. Register a project with sphica init to send its recordings`);
+  if (q.pruned)
+    say2("none", "Last prune", `${plural(q.pruned.count, "held recording")} expired at ${new Date(q.pruned.at).toLocaleString("sv-SE")}`);
+  if (q.dirs.calls.files)
+    say2("none", "Observations to resend", `${plural(q.dirs.calls.files, "record tool observation")} ${q.dirs.calls.files === 1 ? "waits" : "wait"} in ${inline(callsDir())} for the next send`);
+  if (q.dirs.callsRejected.files)
+    say2("warn", "Observations not sent", `${plural(q.dirs.callsRejected.files, "file")} in ${inline(callsRejectedDir())}: ${reasons(q.callsRejected)}`);
   if (usable2) {
     try {
       await withDb("reader", async (db) => {
@@ -18493,6 +18768,7 @@ async function doctor(cwd) {
         const twice = await db.selectFrom("unit").select("project_id").where("lifecycle", "in", ["active", "candidate"]).groupBy(["project_id", "content_hash"]).having((eb) => eb.fn.countAll(), ">", 1).execute();
         if (twice.length)
           say2("warn", "Records", `${plural(twice.length, "set")} of live records hold the same words. Read them with Sphica's read and withdraw the extra ones with /sphica:glean`);
+        await adoptionStops(db, q.waiting, say2);
         const { found, ambiguous } = localRoots();
         const homes = [os4.homedir()];
         try {