@inerrata-corporation/errata 2.0.18-dev.3597 → 2.0.18-dev.3612

package/errata.mjs

@@ -33461,6 +33461,13 @@ function foreignDaemonNote(lock, selfEntry) {
   ];
   return runningInstalled ? [...head2, "this CLI is a different bundle from the daemon it is talking to \u2014 its view may not match what the daemon runs."] : [...head2, "`errata update` does not replace it. To move onto the installed package: errata stop, then errata dash."];
 }
+function daemonVersionNote(lock, selfVersion) {
+  if (!lock.version || lock.version === selfVersion) return null;
+  return [
+    `the running daemon is ${lock.version}, but this CLI is ${selfVersion} \u2014 it was started before the update.`,
+    `restart it onto ${selfVersion}: errata stop, then errata start`
+  ];
+}
 function isProcessAlive(pid) {
   if (!Number.isSafeInteger(pid) || pid <= 0) return false;
   try {
@@ -33500,6 +33507,20 @@ function isDaemonAlive(lockPath) {
 function daemonLockBlocksStartup(lockPath) {
   return daemonLockState(readDaemonLock(lockPath), true) !== "stale";
 }
+async function waitForDaemonExit(lock, timeoutMs, pollMs = 200) {
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    if (daemonLockState(lock, true) === "stale") return true;
+    if (Date.now() >= deadline) return false;
+    await new Promise((resolve10) => setTimeout(resolve10, pollMs));
+  }
+}
+function releaseOwnLock(lockPath) {
+  try {
+    if (parseDaemonLock(readFileSync12(lockPath, "utf8"))?.pid === process.pid) unlinkSync2(lockPath);
+  } catch {
+  }
+}
 function stopLockedDaemon(lockPath) {
   let original;
   try {
@@ -73598,7 +73619,7 @@ var init_report_render = __esm({
 
 // src/cli.ts
 init_src6();
-import { closeSync as closeSync2, existsSync as existsSync39, openSync as openSync2, readFileSync as readFileSync42, renameSync as renameSync6, statSync as statSync12 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync39, openSync as openSync2, readFileSync as readFileSync41, renameSync as renameSync6, statSync as statSync12 } from "node:fs";
 import { join as join48, resolve as pathResolve2 } from "node:path";
 import { spawn as spawn5 } from "node:child_process";
 
@@ -82685,7 +82706,7 @@ function createWatchBreaker(deps) {
 }
 
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.18-dev.3597" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.18-dev.3612" : "2.0.0-alpha.0";
 var IGNORED_PATH = /[\\/](?:\.git|node_modules|\.errata|\.claude|\.codex|\.cursor|\.turbo|\.next|dist|coverage|test-results|playwright-report|__pycache__)(?:[\\/]|$)/;
 var IGNORED_NOISE = /castalia\.db|eventlog\.sqlite|turn-cursors/;
 var GIT_OP_MUTE_MS = 4e3;
@@ -85407,10 +85428,20 @@ async function startDaemon(opts) {
   };
 }
 async function listenServer(fetchFn, port) {
-  return new Promise((resolve10) => {
+  return new Promise((resolve10, reject) => {
     const server = serve({ fetch: fetchFn, hostname: "127.0.0.1", port }, (info2) => {
       resolve10({ server, port: info2.port });
     });
+    server.once(
+      "error",
+      (err2) => {
+        reject(
+          err2.code === "EADDRINUSE" ? new Error(
+            `port ${port} is still held by another process \u2014 usually a previous errata daemon that has not finished shutting down. Wait for it to exit (errata stop waits for it), then start again.`
+          ) : err2
+        );
+      }
+    );
   });
 }
 
@@ -85715,7 +85746,7 @@ function invalidateInstanceReceipt(current, destination, failedId, mirrorLegacy)
 // src/multi.ts
 init_dist();
 init_src5();
-import { existsSync as existsSync34, readFileSync as readFileSync36, unlinkSync as unlinkSync5, writeFileSync as writeFileSync26 } from "node:fs";
+import { existsSync as existsSync34, writeFileSync as writeFileSync26 } from "node:fs";
 import { resolve as pathResolve } from "node:path";
 
 // src/principle-sync.ts
@@ -89657,6 +89688,7 @@ var SessionAffinity = class {
 // src/multi.ts
 init_checkout_root();
 var PROCESS_STARTED_AT = Date.now();
+var SHUTDOWN_CONNECTION_GRACE_MS = 2e3;
 var SELF_ENTRY = process.argv[1] ? pathResolve(process.argv[1]) : "";
 var LOCAL_BUILD_ENTRY = SELF_ENTRY && !isInstalledEntry(SELF_ENTRY) ? SELF_ENTRY : void 0;
 function withLaunchOrigin(pending) {
@@ -91479,21 +91511,23 @@ async function startMultiDaemon(opts = {}) {
       clearInterval(historyRetry);
       clearTimeout(codexWakeBoot);
       try {
-        const cur = readFileSync36(lockPath, "utf8");
-        if (JSON.parse(cur).pid === process.pid) unlinkSync5(lockPath);
-      } catch {
-      }
-      await new Promise(
-        (res) => server.close(res)
-      );
-      updatePoller?.stop();
-      healthSentinel.stop();
-      await Promise.allSettled(attaching.values());
-      for (const r of records) await r.engine.stop();
-      if (consolidateWorker) await consolidateWorker.stop();
-      try {
-        sharedStore.close();
-      } catch {
+        const http = server;
+        const closed = new Promise((res) => http.close(res));
+        http.closeIdleConnections?.();
+        const force = setTimeout(() => http.closeAllConnections?.(), SHUTDOWN_CONNECTION_GRACE_MS);
+        await closed;
+        clearTimeout(force);
+        updatePoller?.stop();
+        healthSentinel.stop();
+        await Promise.allSettled(attaching.values());
+        for (const r of records) await r.engine.stop();
+        if (consolidateWorker) await consolidateWorker.stop();
+        try {
+          sharedStore.close();
+        } catch {
+        }
+      } finally {
+        releaseOwnLock(lockPath);
       }
     }
   };
@@ -91943,8 +91977,31 @@ function installedHarnessVersion(bin) {
     return null;
   }
 }
+function daemonDoctorCheck(input) {
+  const { lock, state, selfVersion, lockPath } = input;
+  if (!lock || state === "stale") {
+    return { id: "daemon", status: "warn", detail: "Daemon is not running \u2014 start it: errata start" };
+  }
+  if (state === "unknown") {
+    return {
+      id: "daemon",
+      status: "fail",
+      detail: `${lockPath} names pid ${lock.pid}, but that process's identity cannot be verified. If \`ps -p ${lock.pid}\` shows no errata process, delete the lock; otherwise run errata stop.`
+    };
+  }
+  const where = `pid ${lock.pid}${lock.webUiUrl ? ` \xB7 ${lock.webUiUrl}` : ""}`;
+  if (lock.version && lock.version !== selfVersion) {
+    return {
+      id: "daemon",
+      status: "warn",
+      detail: `Running ${lock.version} (${where}), but this CLI is ${selfVersion} \u2014 restart it: errata stop, then errata start`
+    };
+  }
+  return { id: "daemon", status: "pass", detail: `Running${lock.version ? ` ${lock.version}` : ""} \xB7 ${where}` };
+}
 async function diagnoseInstallation(cfg, dependencies) {
   const checks = [];
+  if (dependencies.daemon) checks.push(dependencies.daemon());
   if (dependencies.codexHooks) checks.push(...await dependencies.codexHooks());
   const profileName = cfg.activeInstallationProfile;
   const profile = profileName ? cfg.installationProfiles[profileName] : void 0;
@@ -92041,12 +92098,12 @@ async function diagnoseInstallation(cfg, dependencies) {
 
 // src/codex-doctor.ts
 import { spawn as spawn4 } from "node:child_process";
-import { readFileSync as readFileSync38, statSync as statSync10 } from "node:fs";
+import { readFileSync as readFileSync37, statSync as statSync10 } from "node:fs";
 import { join as join44 } from "node:path";
 import { createInterface } from "node:readline";
 
 // src/codex-hooks.ts
-import { existsSync as existsSync35, mkdirSync as mkdirSync9, readFileSync as readFileSync37, renameSync as renameSync5, unlinkSync as unlinkSync6, writeFileSync as writeFileSync27 } from "node:fs";
+import { existsSync as existsSync35, mkdirSync as mkdirSync9, readFileSync as readFileSync36, renameSync as renameSync5, unlinkSync as unlinkSync5, writeFileSync as writeFileSync27 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
 import { join as join43 } from "node:path";
 
@@ -92217,23 +92274,23 @@ function buildCodexRelaySource(workspaceRoot) {
 init_checkout_root();
 var CODEX_HOOK_REVIEW_HELP = "Codex desktop: Settings > Hooks, select this project, expand each event and Trust the Errata hook. CLI users can use /hooks.";
 function writeRelay(file2, source) {
-  if (existsSync35(file2) && readFileSync37(file2, "utf8") === source) return;
+  if (existsSync35(file2) && readFileSync36(file2, "utf8") === source) return;
   const temp = `${file2}.${process.pid}.tmp`;
   try {
     writeFileSync27(temp, source, { encoding: "utf8", mode: 384 });
     renameSync5(temp, file2);
   } finally {
-    if (existsSync35(temp)) unlinkSync6(temp);
+    if (existsSync35(temp)) unlinkSync5(temp);
   }
 }
 function refreshCodexRelay(root) {
   const config2 = join43(root, ".codex", "config.toml");
   if (!existsSync35(config2)) return "absent";
-  const existing = readFileSync37(config2, "utf8");
+  const existing = readFileSync36(config2, "utf8");
   if (!existing.includes(CODEX_HOOKS_BEGIN) && !existing.includes(CODEX_HOOKS_END)) return "absent";
   replaceCodexHooks(existing, "");
   const relay = join43(root, ".codex", "hooks", "errata-relay.mjs");
-  const prior = existsSync35(relay) ? readFileSync37(relay, "utf8") : "";
+  const prior = existsSync35(relay) ? readFileSync36(relay, "utf8") : "";
   if (prior && !prior.startsWith("// errata-managed: regenerated by errata install-hooks codex")) {
     throw new Error("Codex relay is not Errata-managed; preserved it. Run errata install-hooks codex to explicitly replace it.");
   }
@@ -92264,10 +92321,10 @@ function writeCodexHooks(root, port, nodePath = process.execPath) {
   const file2 = join43(dir, "config.toml");
   const relay = join43(dir, "hooks", "errata-relay.mjs");
   const block = buildCodexHooksToml(port, { nodePath, relayPath: relay });
-  const final = replaceCodexHooks(existsSync35(file2) ? readFileSync37(file2, "utf8") : "", block);
+  const final = replaceCodexHooks(existsSync35(file2) ? readFileSync36(file2, "utf8") : "", block);
   mkdirSync9(join43(dir, "hooks"), { recursive: true });
   writeRelay(relay, buildCodexRelaySource(checkoutRootOf(root)));
-  if (!existsSync35(file2) || readFileSync37(file2, "utf8") !== final) writeFileSync27(file2, final, "utf8");
+  if (!existsSync35(file2) || readFileSync36(file2, "utf8") !== final) writeFileSync27(file2, final, "utf8");
   return file2;
 }
 
@@ -92276,7 +92333,7 @@ init_checkout_root();
 function inspectCodexRelay(cwd) {
   const root = nearestGitRoot(cwd) ?? cwd;
   try {
-    const source = readFileSync38(join44(root, ".codex", "hooks", "errata-relay.mjs"), "utf8");
+    const source = readFileSync37(join44(root, ".codex", "hooks", "errata-relay.mjs"), "utf8");
     if (source === buildCodexRelaySource(checkoutRootOf(root))) {
       return { id: "codex_relay", status: "pass", detail: "Installed Codex relay matches this Errata version" };
     }
@@ -92288,7 +92345,7 @@ function inspectCodexContext(cwd) {
   const root = checkoutRootOf(nearestGitRoot(cwd) ?? cwd);
   try {
     const file2 = join44(root, ".errata", "context.md");
-    if (statSync10(file2).size <= 128 * 1024 && readFileSync38(file2, "utf8").trim()) {
+    if (statSync10(file2).size <= 128 * 1024 && readFileSync37(file2, "utf8").trim()) {
       return { id: "codex_context", status: "pass", detail: "Saved workspace context is readable by the relay; this does not prove live daemon freshness" };
     }
   } catch {
@@ -92464,7 +92521,7 @@ function consolidationGapMs(lastPassMs, policy) {
 
 // src/codex-hook-refresh.ts
 init_checkout_root();
-import { existsSync as existsSync36, readdirSync as readdirSync13, readFileSync as readFileSync39 } from "node:fs";
+import { existsSync as existsSync36, readdirSync as readdirSync13, readFileSync as readFileSync38 } from "node:fs";
 import { dirname as dirname13, join as join45, resolve as resolve8 } from "node:path";
 init_registry();
 function codexHookRoots(roots) {
@@ -92482,7 +92539,7 @@ function codexHookRoots(roots) {
     }
     for (const name2 of names) {
       try {
-        const checkout = dirname13(readFileSync39(join45(dir, name2, "gitdir"), "utf8").trim());
+        const checkout = dirname13(readFileSync38(join45(dir, name2, "gitdir"), "utf8").trim());
         if (mainCheckoutOfWorktree(checkout) === main2) found.add(checkout);
       } catch {
       }
@@ -92504,7 +92561,7 @@ function refreshInstalledCodexRelays(roots = listWorkspaceEntries().map((entry)
 }
 
 // src/claude-statusline.ts
-import { existsSync as existsSync37, mkdirSync as mkdirSync10, readFileSync as readFileSync40, writeFileSync as writeFileSync28 } from "node:fs";
+import { existsSync as existsSync37, mkdirSync as mkdirSync10, readFileSync as readFileSync39, writeFileSync as writeFileSync28 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
 import { dirname as dirname14, join as join46 } from "node:path";
 var STATUSLINE_RELAY_SOURCE = String.raw`// errata-managed: regenerated by errata init / install-hooks claude
@@ -92565,7 +92622,7 @@ function ensureUserStatusLine(opts) {
   let settings = {};
   if (existsSync37(settingsPath)) {
     try {
-      const parsed = JSON.parse(readFileSync40(settingsPath, "utf8"));
+      const parsed = JSON.parse(readFileSync39(settingsPath, "utf8"));
       if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return "unreadable";
       settings = parsed;
     } catch {
@@ -92578,7 +92635,7 @@ function ensureUserStatusLine(opts) {
   const ownRows = keep(settings["subagentStatusLine"]);
   if (ownMain && ownRows) return "kept-own";
   mkdirSync10(opts.relayDir, { recursive: true });
-  if (!existsSync37(relay) || readFileSync40(relay, "utf8") !== STATUSLINE_RELAY_SOURCE) {
+  if (!existsSync37(relay) || readFileSync39(relay, "utf8") !== STATUSLINE_RELAY_SOURCE) {
     writeFileSync28(relay, STATUSLINE_RELAY_SOURCE, "utf8");
   }
   const nodePath = opts.nodePath ?? process.execPath;
@@ -92611,7 +92668,7 @@ function describeStatusLineOutcome(outcome) {
 
 // src/claude-mods.ts
 import { createHash as createHash20 } from "node:crypto";
-import { cpSync as cpSync2, existsSync as existsSync38, mkdirSync as mkdirSync11, readFileSync as readFileSync41, readdirSync as readdirSync14, rmSync as rmSync4, statSync as statSync11, writeFileSync as writeFileSync29 } from "node:fs";
+import { cpSync as cpSync2, existsSync as existsSync38, mkdirSync as mkdirSync11, readFileSync as readFileSync40, readdirSync as readdirSync14, rmSync as rmSync4, statSync as statSync11, writeFileSync as writeFileSync29 } from "node:fs";
 import { delimiter as delimiter2, dirname as dirname15, join as join47, relative as relative7, resolve as resolve9, sep as sep5 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var CLAUDE_PLUGIN_DIRS_ENV = "CLAUDE_CODE_PLUGIN_DIRS";
@@ -92639,7 +92696,7 @@ function modHash(dir) {
   for (const abs of listFiles(dir).sort()) {
     h.update(relative7(dir, abs).split(sep5).join("/"));
     h.update("\0");
-    h.update(readFileSync41(abs));
+    h.update(readFileSync40(abs));
     h.update("\0");
   }
   return h.digest("hex");
@@ -92663,7 +92720,7 @@ function off(env2) {
 function readSettings(path2) {
   if (!existsSync38(path2)) return {};
   try {
-    const parsed = JSON.parse(readFileSync41(path2, "utf8"));
+    const parsed = JSON.parse(readFileSync40(path2, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
     return parsed;
   } catch {
@@ -92714,7 +92771,7 @@ function ensureClaudeMods(opts) {
     const dest = join47(modsRoot, name2);
     const hash2 = modHash(src);
     const hashFile = join47(dest, HASH_FILE);
-    if (!existsSync38(hashFile) || readFileSync41(hashFile, "utf8") !== hash2) {
+    if (!existsSync38(hashFile) || readFileSync40(hashFile, "utf8") !== hash2) {
       rmSync4(dest, { recursive: true, force: true });
       cpSync2(src, dest, { recursive: true, filter: (p) => !isEngineOwned(relative7(src, p)) });
       writeFileSync29(hashFile, hash2, "utf8");
@@ -92886,6 +92943,8 @@ export const InerrataPlugin = async (input) => {
 }
 
 // src/cli.ts
+var STOP_WAIT_MS = 3e4;
+var SHUTDOWN_DEADLINE_MS = 2e4;
 var exitCleanOnEpipe = (err2) => {
   if (err2.code === "EPIPE") process.exit(0);
   throw err2;
@@ -93138,7 +93197,7 @@ function resolveHookPort(explicit) {
   }
   const settingsPath = join48(ROOT, ".claude", "settings.json");
   try {
-    if (existsSync39(settingsPath)) return installedHookPort(readFileSync42(settingsPath, "utf8")) ?? 7891;
+    if (existsSync39(settingsPath)) return installedHookPort(readFileSync41(settingsPath, "utf8")) ?? 7891;
   } catch {
   }
   return 7891;
@@ -93303,6 +93362,8 @@ async function cmdStart() {
     console.log(`errata: workspace registered; attached to the running daemon`);
     console.log(`  workspace: ${where}`);
     console.log(`  daemon:    ${running.webUiUrl ?? "(running)"} \xB7 pid ${running.pid}`);
+    const versionNote = daemonVersionNote(running, DAEMON_VERSION);
+    if (versionNote) for (const l of versionNote) console.log(`  \u26A0 ${l}`);
     let watching = "on the daemon's next restart";
     if (running.webUiUrl) {
       try {
@@ -93326,7 +93387,7 @@ async function cmdStart() {
   if (up) {
     console.log(`  daemon:    running \xB7 pid ${up.pid} \xB7 ${up.webUiUrl ?? "(running)"}`);
     console.log(`  logs:      ${daemonLogPath()}`);
-    console.log(`  watch it:  errata dash   \xB7   check it: errata status`);
+    console.log(`  follow it: ${followLogHint()}   \xB7   check it: errata status`);
   } else {
     console.log(`  \u26A0 daemon did not come up within 12s.`);
     console.log(`    run \`errata dash\` in the foreground to see the error.`);
@@ -93438,8 +93499,10 @@ async function cmdStatus() {
   const lockPath = globalDaemonLock();
   const running = isDaemonAlive(lockPath) ? readDaemonLock(lockPath) : null;
   console.log(
-    `  daemon:    ${running ? `running \xB7 pid ${running.pid} \xB7 ${running.webUiUrl ?? "(running)"}` : "not running (run: errata start)"}`
+    `  daemon:    ${running ? `running \xB7 pid ${running.pid}${running.version ? ` \xB7 ${running.version}` : ""} \xB7 ${running.webUiUrl ?? "(running)"}` : "not running (run: errata start)"}`
   );
+  const versionNote = running ? daemonVersionNote(running, DAEMON_VERSION) : null;
+  if (versionNote) for (const l of versionNote) console.log(`             \u26A0 ${l}`);
   if (running && process.argv[1]) {
     const note = foreignDaemonNote(running, pathResolve2(process.argv[1]));
     if (note) for (const l of note) console.log(`             \u26A0 ${l}`);
@@ -93656,6 +93719,11 @@ async function cmdDoctor(args2) {
   const cfg = loadConfig();
   const report = await diagnoseInstallation(cfg, {
     ...hasCodexConfig(process.cwd()) ? { codexHooks: () => diagnoseCodexHooks(process.cwd()) } : {},
+    daemon: () => {
+      const lockPath = globalDaemonLock();
+      const lock = readDaemonLock(lockPath);
+      return daemonDoctorCheck({ lock, state: daemonLockState(lock, true), selfVersion: DAEMON_VERSION, lockPath });
+    },
     inspect: () => inspectCloudEndpoint(cfg.cloudUrl),
     authenticate: async () => {
       const me = await authedCloudClient(cfg).me();
@@ -93672,7 +93740,7 @@ async function cmdDoctor(args2) {
       const marker = check2.status === "pass" ? "\u2713" : check2.status === "warn" ? "!" : "\u2717";
       console.log(`  ${marker} ${check2.id}: ${check2.detail}`);
     }
-    if (!report.ok) {
+    if (report.checks.some((check2) => check2.status === "fail" && check2.id !== "daemon")) {
       console.log(
         "  recovery: `errata profile list`, then `errata profile use <name>`; re-login if authentication still fails."
       );
@@ -93738,7 +93806,8 @@ async function cmdUpdate(args2) {
     }
     console.log(`
 [OK] updated to ${status.latest}. Restart the daemon to run it:`);
-    console.log(`  errata stop      (autostart relaunches it at next logon, or run 'errata dash')`);
+    console.log(`  errata stop      (waits for the old daemon to exit)`);
+    console.log(`  errata start     (starts the updated one; autostart also relaunches it at next logon)`);
   } else {
     console.log(`
 [X] npm install failed (exit ${code}). Try manually:`);
@@ -94375,7 +94444,7 @@ async function cmdReview() {
     console.log("(review queue empty)");
     return;
   }
-  const queue = JSON.parse(readFileSync42(paths.reviewQueue, "utf8"));
+  const queue = JSON.parse(readFileSync41(paths.reviewQueue, "utf8"));
   if (queue.length === 0) {
     console.log("(review queue empty)");
     return;
@@ -95113,8 +95182,20 @@ async function cmdStop() {
     return;
   }
   try {
+    const lock = readDaemonLock(lockPath);
     const result = stopLockedDaemon(lockPath);
-    if (result === "signaled") console.log(`sent SIGTERM to the verified daemon process`);
+    if (result === "signaled" && lock) {
+      console.log(`sent SIGTERM to the daemon (pid ${lock.pid}); waiting for it to exit\u2026`);
+      if (await waitForDaemonExit(lock, STOP_WAIT_MS)) {
+        stopLockedDaemon(lockPath);
+        console.log(`daemon stopped \u2014 safe to start it again`);
+      } else {
+        console.warn(
+          `daemon (pid ${lock.pid}) has not exited after ${STOP_WAIT_MS / 1e3}s; it may still hold port 7891 and its stores. Check it with \`ps -p ${lock.pid}\` (Windows: \`Get-Process -Id ${lock.pid}\`) before starting again.`
+        );
+        process.exitCode = 1;
+      }
+    } else if (result === "signaled") console.log(`sent SIGTERM to the verified daemon process`);
     else if (result === "stale") console.log(`removed stale daemon lock; no process was signaled`);
     else if (result === "missing") console.log(`no daemon lock found \u2014 nothing to stop`);
     else throw new Error(`daemon lock ownership is ${result}; no process was signaled and the lock was preserved`);
@@ -95212,13 +95293,13 @@ async function cmdInstallHooks(args2) {
   }
 }
 async function installOpencodePlugin(port) {
-  const { mkdirSync: mkdirSync12, existsSync: existsSync40, readFileSync: readFileSync43, writeFileSync: writeFileSync30 } = await import("node:fs");
+  const { mkdirSync: mkdirSync12, existsSync: existsSync40, readFileSync: readFileSync42, writeFileSync: writeFileSync30 } = await import("node:fs");
   const { join: join49 } = await import("node:path");
   const dir = join49(ROOT, ".opencode", "plugin");
   if (!existsSync40(dir)) mkdirSync12(dir, { recursive: true });
   const file2 = join49(dir, "inerrata.js");
   if (existsSync40(file2)) {
-    const head2 = readFileSync43(file2, "utf8").split("\n")[0] ?? "";
+    const head2 = readFileSync42(file2, "utf8").split("\n")[0] ?? "";
     if (head2.trim() !== OPENCODE_PLUGIN_MARKER) {
       console.error(`refusing to overwrite ${file2}: not an errata-managed plugin (line 1 lacks the marker)`);
       process.exit(2);
@@ -95229,7 +95310,7 @@ async function installOpencodePlugin(port) {
   let cfg = { $schema: "https://opencode.ai/config.json" };
   if (existsSync40(cfgFile)) {
     try {
-      cfg = JSON.parse(readFileSync43(cfgFile, "utf8"));
+      cfg = JSON.parse(readFileSync42(cfgFile, "utf8"));
     } catch {
       console.error(`refusing to touch invalid JSON at ${cfgFile} \u2014 fix it and re-run`);
       process.exit(2);
@@ -95275,7 +95356,7 @@ function installClaudeMods() {
   }
 }
 async function installClaudeHooks(port) {
-  const { mkdirSync: mkdirSync12, existsSync: existsSync40, readFileSync: readFileSync43, writeFileSync: writeFileSync30 } = await import("node:fs");
+  const { mkdirSync: mkdirSync12, existsSync: existsSync40, readFileSync: readFileSync42, writeFileSync: writeFileSync30 } = await import("node:fs");
   const { join: join49 } = await import("node:path");
   const dir = join49(ROOT, ".claude");
   if (!existsSync40(dir)) mkdirSync12(dir, { recursive: true });
@@ -95283,7 +95364,7 @@ async function installClaudeHooks(port) {
   let settings = {};
   if (existsSync40(file2)) {
     try {
-      settings = JSON.parse(readFileSync43(file2, "utf8"));
+      settings = JSON.parse(readFileSync42(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -95349,7 +95430,7 @@ async function installClaudeHooks(port) {
   console.log(`  endpoint: http://127.0.0.1:${port}/api/hook`);
 }
 async function installClaudeMcpConfig() {
-  const { mkdirSync: mkdirSync12, existsSync: existsSync40, readFileSync: readFileSync43, writeFileSync: writeFileSync30 } = await import("node:fs");
+  const { mkdirSync: mkdirSync12, existsSync: existsSync40, readFileSync: readFileSync42, writeFileSync: writeFileSync30 } = await import("node:fs");
   const { join: join49, dirname: dirname16 } = await import("node:path");
   const file2 = join49(ROOT, ".mcp.json");
   const dir = dirname16(file2);
@@ -95357,7 +95438,7 @@ async function installClaudeMcpConfig() {
   let cfg = {};
   if (existsSync40(file2)) {
     try {
-      cfg = JSON.parse(readFileSync43(file2, "utf8"));
+      cfg = JSON.parse(readFileSync42(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -95371,7 +95452,7 @@ async function installClaudeMcpConfig() {
   console.log(`  Tools: errata.search / locate / neighbors / callers_of / what_uses / show / similar`);
 }
 async function installCursorMcpConfig() {
-  const { mkdirSync: mkdirSync12, existsSync: existsSync40, readFileSync: readFileSync43, writeFileSync: writeFileSync30 } = await import("node:fs");
+  const { mkdirSync: mkdirSync12, existsSync: existsSync40, readFileSync: readFileSync42, writeFileSync: writeFileSync30 } = await import("node:fs");
   const { join: join49 } = await import("node:path");
   const dir = join49(ROOT, ".cursor");
   if (!existsSync40(dir)) mkdirSync12(dir, { recursive: true });
@@ -95379,7 +95460,7 @@ async function installCursorMcpConfig() {
   let cfg = {};
   if (existsSync40(file2)) {
     try {
-      cfg = JSON.parse(readFileSync43(file2, "utf8"));
+      cfg = JSON.parse(readFileSync42(file2, "utf8"));
     } catch {
       console.error(`refusing to overwrite invalid JSON at ${file2}`);
       process.exit(2);
@@ -95582,7 +95663,21 @@ function installLogTimestamps() {
     };
   }
 }
+function followLogHint() {
+  const log = daemonLogPath();
+  return process.platform === "win32" ? `Get-Content -Wait "${log}"` : `tail -f "${log}"`;
+}
 async function cmdDash(args2) {
+  const running = readDaemonLock(globalDaemonLock());
+  if (running && daemonLockState(running, true) === "running") {
+    console.log(
+      `errata daemon already running \xB7 pid ${running.pid}${running.version ? ` \xB7 ${running.version}` : ""}${running.webUiUrl ? ` \xB7 ${running.webUiUrl}` : ""}`
+    );
+    console.log(`  follow it:  ${followLogHint()}`);
+    console.log(`  check it:   errata status`);
+    console.log(`  restart it: errata stop, then errata start`);
+    return;
+  }
   process.title = "errata-daemon";
   installLogTimestamps();
   refreshExistingCodexHooks();
@@ -95952,6 +96047,11 @@ async function cmdDash(args2) {
   const shutdown = async (signal) => {
     console.log(`
 shutting down\u2026 (${signal})`);
+    setTimeout(() => {
+      console.warn(`[errata] shutdown exceeded ${SHUTDOWN_DEADLINE_MS / 1e3}s \u2014 forcing exit`);
+      releaseOwnLock(globalDaemonLock());
+      process.exit(1);
+    }, SHUTDOWN_DEADLINE_MS).unref();
     clearInterval(interval);
     clearInterval(nightlyInterval);
     if (quiesceTimer) clearTimeout(quiesceTimer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inerrata-corporation/errata",
-  "version": "2.0.18-dev.3597",
+  "version": "2.0.18-dev.3612",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {