sphica 0.6.31 → 0.6.33

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "sphica",
-  "version": "0.6.31",
+  "version": "0.6.33",
   "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.31",
+  "version": "0.6.33",
   "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/dist/cli.js

@@ -92,7 +92,8 @@ var require_src = __commonJS(function(exports, module) {
 });
 
 // server/src/cli.ts
-import fs9 from "node:fs";
+import fs10 from "node:fs";
+import os4 from "node:os";
 import path10 from "node:path";
 
 // server/node_modules/@clack/core/dist/index.mjs
@@ -2966,7 +2967,7 @@ async function run(app, inputs, context) {
 }
 
 // server/src/admin.ts
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import path9 from "node:path";
 import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
 
@@ -5013,7 +5014,7 @@ function backups(file = dbFile()) {
 
 // server/src/capture.ts
 import { spawn } from "node:child_process";
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 import path8 from "node:path";
 
 // server/node_modules/kysely/dist/util/object-utils.js
@@ -16118,7 +16119,7 @@ var sessionId = (projectId, host, externalId) => uuidFrom(String(projectId), hos
 
 // server/src/project.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
-import fs5 from "node:fs";
+import fs6 from "node:fs";
 import os3 from "node:os";
 import path6 from "node:path";
 
@@ -16127,6 +16128,127 @@ import path5 from "node:path";
 var MAX_BYTES = 2 * 1024 * 1024;
 var leaves = (rel) => rel === ".." || rel.startsWith(`..${path5.sep}`) || path5.isAbsolute(rel);
 
+// server/src/file-lock.ts
+import fs5 from "node:fs";
+var WAIT_MS = 5000;
+var POLL_MS = 40;
+var TRIES = 5;
+var sleep = (ms) => {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+};
+function retryBusy(op) {
+  for (let attempt = 1;; attempt++) {
+    try {
+      op();
+      return;
+    } catch (e) {
+      const code = e.code;
+      if (attempt >= TRIES || !(code === "EPERM" || code === "EACCES" || code === "EBUSY"))
+        throw e;
+      sleep(50 * attempt);
+    }
+  }
+}
+function heldBy(lock) {
+  let holder = 0;
+  try {
+    holder = Number(fs5.readFileSync(lock, "utf8").trim()) || 0;
+  } catch {}
+  if (holder <= 0)
+    return `${lock} is held by another process. Run this again when it finishes.`;
+  try {
+    process.kill(holder, 0);
+  } catch (e) {
+    if (e.code === "ESRCH")
+      return `${lock} is held by process ${holder}, which is not running. If no sphica init is running, delete ${lock} and run this again.`;
+  }
+  return `${lock} is held by process ${holder}. Run this again when it finishes.`;
+}
+function withFileLock(lock, fn, waitMs = WAIT_MS) {
+  const mine = String(process.pid);
+  const until = performance.now() + waitMs;
+  for (;; ) {
+    let fd = null;
+    let refused = null;
+    try {
+      fd = fs5.openSync(lock, "wx");
+    } catch (e) {
+      const code = e.code;
+      if (code === "EPERM" || code === "EACCES" || code === "EBUSY")
+        refused = e;
+      else if (code !== "EEXIST")
+        throw e;
+    }
+    if (fd !== null) {
+      try {
+        try {
+          fs5.writeFileSync(fd, mine);
+        } finally {
+          fs5.closeSync(fd);
+        }
+      } catch (e) {
+        try {
+          retryBusy(() => fs5.rmSync(lock, { force: true }));
+        } catch {}
+        throw e;
+      }
+      break;
+    }
+    if (performance.now() >= until)
+      throw refused ?? new Error(heldBy(lock));
+    sleep(POLL_MS);
+  }
+  let result;
+  try {
+    result = fn();
+  } catch (e) {
+    try {
+      release(lock, mine);
+    } catch {}
+    throw e;
+  }
+  release(lock, mine);
+  return result;
+}
+function release(lock, mine) {
+  const cannot = (e) => new Error(`The work finished, but Sphica could not remove ${lock} (${e.message}). Delete it before running this again.`);
+  let held = "";
+  try {
+    retryBusy(() => {
+      held = fs5.readFileSync(lock, "utf8");
+    });
+  } catch (e) {
+    if (e.code === "ENOENT")
+      return;
+    throw cannot(e);
+  }
+  if (held !== mine)
+    return;
+  try {
+    retryBusy(() => fs5.rmSync(lock, { force: true }));
+  } catch (e) {
+    throw cannot(e);
+  }
+}
+function replaceFile(file, text) {
+  const tmp = `${file}.${process.pid}.tmp`;
+  try {
+    const fd = fs5.openSync(tmp, "w");
+    try {
+      fs5.writeFileSync(fd, text);
+      fs5.fsyncSync(fd);
+    } finally {
+      fs5.closeSync(fd);
+    }
+    retryBusy(() => fs5.renameSync(tmp, file));
+  } catch (e) {
+    try {
+      retryBusy(() => fs5.rmSync(tmp, { force: true }));
+    } catch {}
+    throw e;
+  }
+}
+
 // server/src/project.ts
 var localFile = () => path6.join(sphicaHome(), "projects.json");
 var LOCAL_KEY = /^[a-z0-9][a-z0-9._-]*$/;
@@ -16170,7 +16292,7 @@ var git = (dir, ...args) => {
 function localMap() {
   let raw;
   try {
-    raw = fs5.readFileSync(localFile(), "utf8");
+    raw = fs6.readFileSync(localFile(), "utf8");
   } catch (e) {
     if (e.code === "ENOENT")
       return {};
@@ -16217,14 +16339,27 @@ function nameLocal(dir, name) {
   if (place?.key.startsWith("git:"))
     throw new Error(`${place.root} has a git remote, so its key is ${place.key}. Add it without --name.`);
   const root = rootOf(dir);
-  const m = localMap();
-  m[root] = name;
-  fs5.mkdirSync(path6.dirname(localFile()), { recursive: true, mode: 448 });
-  fs5.writeFileSync(localFile(), `${JSON.stringify(m, null, 2)}
+  fs6.mkdirSync(path6.dirname(localFile()), { recursive: true, mode: 448 });
+  withFileLock(`${localFile()}.lock`, () => {
+    const m = localMap();
+    m[root] = name;
+    replaceFile(localFile(), `${JSON.stringify(m, null, 2)}
 `);
+  });
   return { key: `local:${name}`, root, name };
 }
-function localRoots(roots = [path6.join(os3.homedir(), "Projects")]) {
+function underHome(p, homes, api = path6) {
+  for (const h2 of homes) {
+    const rel = api.relative(h2, p);
+    if (rel === "")
+      return "~";
+    if (rel !== ".." && !rel.startsWith(`..${api.sep}`) && !api.isAbsolute(rel))
+      return `~${api.sep}${rel}`;
+  }
+  return p;
+}
+var projectsDir = () => path6.join(os3.homedir(), "Projects");
+function localRoots(roots = [projectsDir()]) {
   const seen = new Map;
   const add = (p) => {
     if (p)
@@ -16233,7 +16368,7 @@ function localRoots(roots = [path6.join(os3.homedir(), "Projects")]) {
   for (const r2 of roots) {
     let entries = [];
     try {
-      entries = fs5.readdirSync(r2, { withFileTypes: true });
+      entries = fs6.readdirSync(r2, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -16242,7 +16377,7 @@ function localRoots(roots = [path6.join(os3.homedir(), "Projects")]) {
         add(identify(path6.join(r2, e.name)));
   }
   for (const [root, name] of Object.entries(localMap())) {
-    if (LOCAL_KEY.test(name) && fs5.existsSync(root))
+    if (LOCAL_KEY.test(name) && fs6.existsSync(root))
       add({ key: `local:${name}`, root, name });
   }
   const found = new Map;
@@ -16275,7 +16410,7 @@ function patchPaths(patch) {
 
 // server/src/worktree.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 import path7 from "node:path";
 var MAX_PATHS = 200;
 var git2 = (root, args) => {
@@ -16310,7 +16445,7 @@ function snapshot(root) {
       continue;
     let st;
     try {
-      st = fs6.lstatSync(path7.join(root, p), { throwIfNoEntry: false });
+      st = fs7.lstatSync(path7.join(root, p), { throwIfNoEntry: false });
     } catch {
       st = undefined;
     }
@@ -16388,7 +16523,7 @@ ${z}`,
 function prune(held) {
   let files;
   try {
-    files = fs7.readdirSync(held).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort();
+    files = fs8.readdirSync(held).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort();
   } catch {
     return;
   }
@@ -16396,21 +16531,21 @@ function prune(held) {
   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]))
-    fs7.rmSync(path8.join(held, f), { force: true });
+    fs8.rmSync(path8.join(held, f), { force: true });
 }
 function spool(record) {
   const dir = spoolDir();
-  fs7.mkdirSync(dir, { recursive: true, mode: 448 });
+  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}`);
-  fs7.writeFileSync(tmp, JSON.stringify(record), { mode: 384 });
-  fs7.renameSync(tmp, path8.join(dir, name));
+  fs8.writeFileSync(tmp, JSON.stringify(record), { mode: 384 });
+  fs8.renameSync(tmp, path8.join(dir, name));
 }
 var branchOf = (root) => {
   try {
     const dotgit = path8.join(root, ".git");
-    const gitdir = fs7.statSync(dotgit).isFile() ? path8.resolve(root, fs7.readFileSync(dotgit, "utf8").match(/^gitdir: (.+)$/m)?.[1]?.trim() ?? "") : dotgit;
-    const h2 = fs7.readFileSync(path8.join(gitdir, "HEAD"), "utf8").trim();
+    const gitdir = fs8.statSync(dotgit).isFile() ? path8.resolve(root, fs8.readFileSync(dotgit, "utf8").match(/^gitdir: (.+)$/m)?.[1]?.trim() ?? "") : dotgit;
+    const h2 = fs8.readFileSync(path8.join(gitdir, "HEAD"), "utf8").trim();
     return h2.startsWith("ref: refs/heads/") ? h2.slice("ref: refs/heads/".length) : null;
   } catch {
     return null;
@@ -16456,7 +16591,7 @@ Notes: ${notes.trim()}` : "";
   };
 }
 function captureNotice(file = dbFile()) {
-  if (!fs7.existsSync(file))
+  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.stuck)
@@ -16473,7 +16608,7 @@ var isStart = (v) => {
 };
 function readStart(file) {
   try {
-    const s = JSON.parse(fs7.readFileSync(file, "utf8"));
+    const s = JSON.parse(fs8.readFileSync(file, "utf8"));
     return isStart(s) ? s : null;
   } catch {
     return null;
@@ -16482,7 +16617,7 @@ function readStart(file) {
 function readStarts(dir) {
   let names;
   try {
-    names = fs7.readdirSync(dir);
+    names = fs8.readdirSync(dir);
   } catch (e) {
     return e.code === "ENOENT" ? [] : null;
   }
@@ -16505,10 +16640,10 @@ function newestTurn(starts) {
   return at.length === 1 ? at[0]?.turn ?? null : null;
 }
 function writeStart(dir, s, file = startFile(dir, s.turn)) {
-  fs7.mkdirSync(dir, { recursive: true, mode: 448 });
+  fs8.mkdirSync(dir, { recursive: true, mode: 448 });
   const tmp = path8.join(dir, `.${path8.basename(file)}.${process.pid}.tmp`);
-  fs7.writeFileSync(tmp, JSON.stringify(s), { mode: 384 });
-  fs7.renameSync(tmp, file);
+  fs8.writeFileSync(tmp, JSON.stringify(s), { mode: 384 });
+  fs8.renameSync(tmp, file);
 }
 function openTurn(dir, turn, root) {
   if (readStart(startFile(dir, turn))?.running)
@@ -16538,22 +16673,22 @@ function stopTurn(dir, turn) {
 }
 function pruneBaselines() {
   const cutoff = Date.now() - HOLD_DAYS * 24 * 60 * 60 * 1000;
-  const fresh = (file) => (fs7.statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? Date.now()) >= cutoff;
+  const fresh = (file) => (fs8.statSync(file, { throwIfNoEntry: false })?.mtimeMs ?? Date.now()) >= cutoff;
   let names;
   try {
-    names = fs7.readdirSync(baselineDir());
+    names = fs8.readdirSync(baselineDir());
   } catch {
     return;
   }
   for (const name of names) {
     const at = path8.join(baselineDir(), name);
-    if (!fs7.statSync(at, { throwIfNoEntry: false })?.isDirectory()) {
+    if (!fs8.statSync(at, { throwIfNoEntry: false })?.isDirectory()) {
       if (!fresh(at))
-        fs7.rmSync(at, { force: true });
+        fs8.rmSync(at, { force: true });
     } else {
-      const files = fs7.readdirSync(at);
+      const files = fs8.readdirSync(at);
       if (files.length && !files.some((f) => fresh(path8.join(at, f))))
-        fs7.rmSync(at, { recursive: true, force: true });
+        fs8.rmSync(at, { recursive: true, force: true });
     }
   }
 }
@@ -16572,7 +16707,7 @@ function onHook(host, input) {
       return { flush: false };
     const file = process.env.CLAUDE_ENV_FILE;
     if (file && input.session_id && /^[A-Za-z0-9_-]+$/.test(input.session_id)) {
-      fs7.appendFileSync(file, `export SPHICA_PARENT_SESSION=${input.session_id}
+      fs8.appendFileSync(file, `export SPHICA_PARENT_SESSION=${input.session_id}
 `);
     }
     attempt(pruneBaselines);
@@ -16654,13 +16789,13 @@ function onHook(host, input) {
 }
 function writeState(s) {
   try {
-    fs7.writeFileSync(stateFile(), JSON.stringify(s));
+    fs8.writeFileSync(stateFile(), JSON.stringify(s));
   } catch {}
 }
 function readState() {
   const count = (dir) => {
     try {
-      return fs7.readdirSync(dir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).length;
+      return fs8.readdirSync(dir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).length;
     } catch {
       return 0;
     }
@@ -16672,7 +16807,7 @@ function readState() {
   };
   let raw = {};
   try {
-    const parsed = JSON.parse(fs7.readFileSync(stateFile(), "utf8"));
+    const parsed = JSON.parse(fs8.readFileSync(stateFile(), "utf8"));
     if (parsed && typeof parsed === "object")
       raw = parsed;
   } catch {}
@@ -16687,24 +16822,24 @@ function readState() {
 }
 function lock() {
   const file = path8.join(spoolDir(), ".lock");
-  fs7.mkdirSync(spoolDir(), { recursive: true, mode: 448 });
+  fs8.mkdirSync(spoolDir(), { recursive: true, mode: 448 });
   for (let attempt2 = 0;attempt2 < 2; attempt2++) {
     try {
-      fs7.writeFileSync(file, String(process.pid), { flag: "wx", mode: 384 });
+      fs8.writeFileSync(file, String(process.pid), { flag: "wx", mode: 384 });
       return () => {
         try {
-          if (fs7.readFileSync(file, "utf8") === String(process.pid))
-            fs7.rmSync(file, { force: true });
+          if (fs8.readFileSync(file, "utf8") === String(process.pid))
+            fs8.rmSync(file, { force: true });
         } catch {}
       };
     } catch (e) {
       if (e.code !== "EEXIST")
         throw e;
     }
-    const st = fs7.statSync(file, { throwIfNoEntry: false });
+    const st = fs8.statSync(file, { throwIfNoEntry: false });
     if (!st)
       continue;
-    const holder = Number(fs7.readFileSync(file, "utf8") || 0);
+    const holder = Number(fs8.readFileSync(file, "utf8") || 0);
     const fresh = Date.now() - st.mtimeMs < 5 * 60000;
     const alive = (() => {
       if (holder <= 0)
@@ -16717,7 +16852,7 @@ function lock() {
     })();
     if (alive && fresh)
       return null;
-    fs7.rmSync(file, { force: true });
+    fs8.rmSync(file, { force: true });
   }
   return null;
 }
@@ -16816,7 +16951,7 @@ var REJECTED = new Set([18, 19, 20, 25]);
 var rejected = (e) => REJECTED.has(sqliteCode(e) ?? -1);
 var queued = (from) => {
   try {
-    return fs7.readdirSync(from).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort().map((name) => ({ name, from }));
+    return fs8.readdirSync(from).filter((f) => f.endsWith(".json") && !f.startsWith(".")).sort().map((name) => ({ name, from }));
   } catch {
     return [];
   }
@@ -16827,16 +16962,16 @@ async function sendBatch(db, names) {
   for (const { name, from } of names) {
     let r2;
     try {
-      r2 = current(JSON.parse(fs7.readFileSync(path8.join(from, name), "utf8")));
+      r2 = current(JSON.parse(fs8.readFileSync(path8.join(from, name), "utf8")));
     } catch {
-      fs7.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
-      fs7.renameSync(path8.join(from, name), path8.join(rejectedDir(), name));
+      fs8.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
+      fs8.renameSync(path8.join(from, name), path8.join(rejectedDir(), name));
       continue;
     }
     if (r2)
       records.push({ name, from, r: r2 });
     else
-      fs7.rmSync(path8.join(from, name), { force: true });
+      fs8.rmSync(path8.join(from, name), { force: true });
   }
   let sent = 0;
   let strayed = [];
@@ -16862,10 +16997,10 @@ async function sendBatch(db, names) {
     }
   }
   if (bad.length) {
-    fs7.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
+    fs8.mkdirSync(rejectedDir(), { recursive: true, mode: 448 });
     for (const x of bad) {
       try {
-        fs7.renameSync(path8.join(x.from, x.name), path8.join(rejectedDir(), x.name));
+        fs8.renameSync(path8.join(x.from, x.name), path8.join(rejectedDir(), x.name));
       } catch (e) {
         if (e.code !== "ENOENT")
           throw e;
@@ -16873,12 +17008,12 @@ async function sendBatch(db, names) {
     }
   }
   if (strayed.length) {
-    fs7.mkdirSync(held, { recursive: true, mode: 448 });
+    fs8.mkdirSync(held, { recursive: true, mode: 448 });
     for (const x of strayed) {
       if (x.from === held)
         continue;
       try {
-        fs7.renameSync(path8.join(x.from, x.name), path8.join(held, x.name));
+        fs8.renameSync(path8.join(x.from, x.name), path8.join(held, x.name));
       } catch (e) {
         if (e.code !== "ENOENT")
           throw e;
@@ -16888,7 +17023,7 @@ async function sendBatch(db, names) {
   const moved = new Set([...bad, ...strayed].map((x) => x.name));
   for (const x of records)
     if (!moved.has(x.name))
-      fs7.rmSync(path8.join(x.from, x.name), { force: true });
+      fs8.rmSync(path8.join(x.from, x.name), { force: true });
   return { sent, rejected: bad.length };
 }
 async function flush(file = dbFile(), budgetMs = FLUSH_BUDGET_MS) {
@@ -17348,7 +17483,7 @@ var STOP2 = "sphica_migration_stop";
 var NOTE = "sphica_migration_note";
 var KEEP2 = 3;
 function backUp(raw, file, from) {
-  fs8.mkdirSync(backupDir(file), { recursive: true, mode: 448 });
+  fs9.mkdirSync(backupDir(file), { recursive: true, mode: 448 });
   const done = backupPath(file, from);
   const partial = `${done}.partial`;
   try {
@@ -17364,10 +17499,10 @@ function backUp(raw, file, from) {
     } finally {
       look.close();
     }
-    fs8.renameSync(partial, done);
+    fs9.renameSync(partial, done);
   } catch (e) {
     for (const f of [partial, `${partial}-wal`, `${partial}-shm`])
-      fs8.rmSync(f, { force: true });
+      fs9.rmSync(f, { force: true });
     throw new Error(`Could not back up ${file} before migrating it, so nothing was migrated (${e.message}). Check free space in ${backupDir(file)}.`);
   }
   return done;
@@ -17381,7 +17516,7 @@ function prune2(file, kept) {
   }
   for (const old of all.filter((b) => b !== kept).slice(KEEP2 - 1))
     try {
-      fs8.rmSync(old, { force: true });
+      fs9.rmSync(old, { force: true });
     } catch {}
 }
 var versionOf = (raw) => raw.prepare("pragma user_version").get().user_version;
@@ -17473,20 +17608,20 @@ function migrate(file = dbFile(), dir = MIGRATIONS()) {
     try {
       for (let r2 = from + 1;r2 <= SCHEMA_REVISION; r2++) {
         const script = MIGRATION(dir, r2);
-        if (!fs8.existsSync(script))
+        if (!fs9.existsSync(script))
           throw new Error(`This Sphica has no migration script for revision ${r2} (${script} is missing). Reinstall sphica (\`npm i -g sphica@${packageVersionAt(ROOT) ?? "latest"}\`), then run \`sphica init\` again.`);
         raw.exec("pragma foreign_keys = off");
         try {
           const notes = immediate(raw, () => {
             if (versionOf(raw) !== r2 - 1)
               return [];
-            if (fs8.existsSync(CHECK(dir, r2))) {
-              raw.exec(fs8.readFileSync(CHECK(dir, r2), "utf8"));
+            if (fs9.existsSync(CHECK(dir, r2))) {
+              raw.exec(fs9.readFileSync(CHECK(dir, r2), "utf8"));
               const stops = taken(raw, STOP2);
               if (stops.length)
                 throw new Stop(r2, stops);
             }
-            raw.exec(fs8.readFileSync(script, "utf8"));
+            raw.exec(fs9.readFileSync(script, "utf8"));
             if (r2 === 10)
               judgeEveryRecord(raw);
             const broken = raw.prepare("pragma foreign_key_check").all().length;
@@ -17511,7 +17646,7 @@ ${e.list}` : "";
       if (now === from) {
         let left = "the backup made for this run was removed";
         try {
-          fs8.rmSync(backup, { force: true });
+          fs9.rmSync(backup, { force: true });
         } catch {
           left = `the backup made for this run is still at ${backup}; delete it yourself`;
         }
@@ -17528,7 +17663,7 @@ ${e.list}` : "";
   });
 }
 function dbInit(file = dbFile()) {
-  if (fs8.existsSync(file)) {
+  if (fs9.existsSync(file)) {
     const look = new DatabaseSync3(file, { readOnly: true });
     let generation;
     try {
@@ -17549,27 +17684,32 @@ function dbInit(file = dbFile()) {
     }
     return;
   }
-  fs8.mkdirSync(path9.dirname(file), { recursive: true, mode: 448 });
+  fs9.mkdirSync(path9.dirname(file), { recursive: true, mode: 448 });
   const tmp = `${file}.${process.pid}.tmp`;
-  fs8.rmSync(tmp, { force: true });
+  fs9.rmSync(tmp, { force: true });
   try {
     withOwner(tmp, (raw) => {
       raw.exec("pragma journal_mode = wal");
-      raw.exec(fs8.readFileSync(SCHEMA(), "utf8"));
+      raw.exec(fs9.readFileSync(SCHEMA(), "utf8"));
       if (versionOf(raw) !== SCHEMA_REVISION)
         throw new Error(`db/schema.sql has user_version ${versionOf(raw)}, but the code expects ${SCHEMA_REVISION}`);
       optimize(raw);
     }, true);
-    try {
-      fs8.linkSync(tmp, file);
-    } catch (e) {
-      if (e.code === "EEXIST" || fs8.existsSync(file))
-        throw new Error(`${file} already exists (another sphica init created it first). Run this again to check it.`);
-      fs8.renameSync(tmp, file);
-    }
+    const taken2 = () => new Error(`${file} already exists (another sphica init created it first). Run this again to check it.`);
+    withFileLock(`${file}.init.lock`, () => {
+      if (fs9.existsSync(file))
+        throw taken2();
+      try {
+        fs9.linkSync(tmp, file);
+      } catch (e) {
+        if (e.code === "EEXIST")
+          throw taken2();
+        fs9.renameSync(tmp, file);
+      }
+    });
   } finally {
     for (const f of [tmp, `${tmp}-wal`, `${tmp}-shm`])
-      fs8.rmSync(f, { force: true });
+      fs9.rmSync(f, { force: true });
   }
   say(`Created: ${file} (revision ${SCHEMA_REVISION})`);
 }
@@ -17605,7 +17745,7 @@ function reindex(file = dbFile()) {
   say(`Rebuilt the index: ${plural(counts.units, "unit")}, ${plural(counts.sources, "source")}`);
 }
 function inspect(file = dbFile()) {
-  const size = (f) => fs8.existsSync(f) ? fs8.statSync(f).size : 0;
+  const size = (f) => fs9.existsSync(f) ? fs9.statSync(f).size : 0;
   return withOwner(file, (raw) => {
     const check = (table) => {
       try {
@@ -18329,7 +18469,7 @@ async function doctor(cwd) {
   let usable2 = false;
   if (!runtime)
     say2("none", "DB", "cannot check until Node is upgraded");
-  else if (!fs9.existsSync(file))
+  else if (!fs10.existsSync(file))
     say2("fail", "DB", `missing (${file}). Create it with sphica init`);
   else {
     try {
@@ -18353,7 +18493,12 @@ 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`);
-        const { found } = localRoots();
+        const { found, ambiguous } = localRoots();
+        const homes = [os4.homedir()];
+        try {
+          homes.push(fs10.realpathSync.native(os4.homedir()));
+        } catch {}
+        const tilde = (p) => underHome(p, homes);
         const rows = await db.selectFrom("project as p").select((eb) => [
           "p.key",
           "p.name",
@@ -18364,7 +18509,8 @@ async function doctor(cwd) {
           console.log(section("Projects", true));
         const column = Math.max(...rows.map((x) => width(inline(x.name)))) + 2;
         for (const x of rows) {
-          const where = found.get(x.key) ? "" : " (not on this machine)";
+          const copies = ambiguous.get(x.key);
+          const where = copies ? ` (${copies.length} copies: ${copies.map((c) => inline(tilde(c))).sort().join(", ")})` : found.get(x.key) ? "" : ` (not found in ${inline(tilde(projectsDir()))} or the named projects)`;
           console.log(indent(`  ${mark("none")} ${pad(inline(x.name), column)}${plural(Number(x.records ?? 0), "record")}${x.extracted ? ` / last extraction ${new Date(x.extracted).toLocaleString("sv-SE")}` : ""}${where}`));
         }
       });
@@ -18409,7 +18555,7 @@ async function bindGitHub() {
 }
 async function init(flags) {
   const cwd = flags.cwd ?? process.cwd();
-  if (!fs9.statSync(cwd, { throwIfNoEntry: false })?.isDirectory())
+  if (!fs10.statSync(cwd, { throwIfNoEntry: false })?.isDirectory())
     throw new Error(`${cwd} is not a directory`);
   const found = identify(cwd);
   if (flags.name !== undefined) {
@@ -18448,7 +18594,7 @@ async function uninstall(yes) {
   await boxed("sphica uninstall", async () => {
     if (process.env.SPHICA_HOME)
       throw new Error("SPHICA_HOME is set; uninstall deletes only ~/.sphica. Unset SPHICA_HOME and run it again");
-    if (!fs9.existsSync(home))
+    if (!fs10.existsSync(home))
       console.log(indent(`${mark("none")} ${home} does not exist`));
     else {
       if (!yes) {
@@ -18460,7 +18606,7 @@ async function uninstall(yes) {
         if (isCancel(answer) || !answer)
           return "cancelled";
       }
-      fs9.rmSync(home, { recursive: true, force: true });
+      fs10.rmSync(home, { recursive: true, force: true });
       console.log(indent(`${mark("ok")} deleted ${home}`));
     }
     if (where.length > 1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sphica",
-  "version": "0.6.31",
+  "version": "0.6.33",
   "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",