@wrongstack/tools 0.270.0 → 0.272.0

package/dist/index.js

@@ -1,17 +1,17 @@
-import * as fs4 from 'node:fs/promises';
-import { toErrorMessage } from '@wrongstack/core/utils';
+import * as fs7 from 'node:fs/promises';
+import * as Core from '@wrongstack/core';
+import { toErrorMessage, atomicWrite, unifiedDiff, detectNewlineStyle, normalizeToLf, toStyle, compileGlob, expectDefined, buildChildEnv, isPrivateIPv4, isPrivateIPv6, loadPlan, setPlanItemStatus, savePlan, loadTasks, saveTasks, mutatePlan, clearPlan, getPlanTemplate, addPlanItem, deriveTodosFromPlanItem, removePlanItem, mutateTasks, formatTaskList, formatPlan, assessCommitSafety, recordPackageAction, detectPackageEcosystem, computeTaskItemProgress, wstackGlobalRoot, resolveWstackPaths, truncate } from '@wrongstack/core';
 import * as path from 'node:path';
 import { resolve, sep, dirname, join } from 'node:path';
-import * as Core from '@wrongstack/core';
-import { atomicWrite, unifiedDiff, detectNewlineStyle, normalizeToLf, toStyle, compileGlob, expectDefined, buildChildEnv, isPrivateIPv4, isPrivateIPv6, loadPlan, setPlanItemStatus, savePlan, loadTasks, saveTasks, mutatePlan, clearPlan, getPlanTemplate, addPlanItem, deriveTodosFromPlanItem, removePlanItem, mutateTasks, formatTaskList, formatPlan, assessCommitSafety, recordPackageAction, detectPackageEcosystem, computeTaskItemProgress, wstackGlobalRoot, resolveWstackPaths, truncate } from '@wrongstack/core';
-import { spawn, execFileSync, spawnSync } from 'node:child_process';
-import * as os from 'node:os';
-import * as fs7 from 'node:fs';
-import { statSync, mkdirSync, createWriteStream, writeFileSync } from 'node:fs';
+import { spawn, execFileSync } from 'node:child_process';
+import * as os2 from 'node:os';
+import * as fs8 from 'node:fs';
+import { statSync, mkdirSync, createWriteStream } from 'node:fs';
 import * as dns from 'node:dns/promises';
 import * as net from 'node:net';
 import { Agent } from 'undici';
 import TurndownService from 'turndown';
+import { toErrorMessage as toErrorMessage$1 } from '@wrongstack/core/utils';
 import { randomUUID } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
@@ -57,13 +57,13 @@ function safeResolve(input, ctx) {
 async function assertRealInsideRoot(absPath, ctx) {
   if (ctx.allowOutsideProjectRoot) return;
   const realRoots = await Promise.all(
-    allowedRoots(ctx).map((r) => fs4.realpath(r).catch(() => path.resolve(r)))
+    allowedRoots(ctx).map((r) => fs7.realpath(r).catch(() => path.resolve(r)))
   );
   let probe = absPath;
   for (; ; ) {
     let real;
     try {
-      real = await fs4.realpath(probe);
+      real = await fs7.realpath(probe);
     } catch (err) {
       if (err.code === "ENOENT") {
         const parent = path.dirname(probe);
@@ -210,7 +210,7 @@ var readTool = {
     const absPath = await safeResolveReal(input.path, ctx);
     let stat11;
     try {
-      stat11 = await fs4.stat(absPath);
+      stat11 = await fs7.stat(absPath);
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") throw new Error(`read: file not found "${input.path}"`);
@@ -235,7 +235,7 @@ var readTool = {
         note: "Repeated read suppressed to save tokens."
       };
     }
-    const buf = await fs4.readFile(absPath);
+    const buf = await fs7.readFile(absPath);
     if (isBinaryBuffer(buf)) {
       throw new Error(`read: "${input.path}" appears to be binary`);
     }
@@ -369,14 +369,14 @@ var writeTool = {
     let existed = false;
     let prev = "";
     try {
-      const stat12 = await fs4.stat(absPath);
+      const stat12 = await fs7.stat(absPath);
       existed = stat12.isFile();
       if (existed) {
         if (!ctx.hasRead(absPath)) {
-          prev = await fs4.readFile(absPath, "utf8");
+          prev = await fs7.readFile(absPath, "utf8");
           ctx.recordRead(absPath, stat12.mtimeMs);
         } else {
-          prev = await fs4.readFile(absPath, "utf8");
+          prev = await fs7.readFile(absPath, "utf8");
         }
       }
     } catch (err) {
@@ -387,7 +387,7 @@ var writeTool = {
     await atomicWrite(absPath, input.content);
     const diff = existed ? unifiedDiff(prev, input.content, { fromFile: input.path, toFile: input.path }) : `+++ ${input.path}
 + (new file, ${input.content.split("\n").length} lines)`;
-    const stat11 = await fs4.stat(absPath);
+    const stat11 = await fs7.stat(absPath);
     ctx.recordRead(absPath, stat11.mtimeMs);
     ctx.session.recordFileChange({
       path: absPath,
@@ -429,7 +429,7 @@ var editTool = {
     if (input.new_string === void 0) throw new Error("edit: new_string is required");
     if (input.old_string === "") throw new Error("edit: old_string cannot be empty");
     const absPath = await safeResolveReal(input.path, ctx);
-    const stat11 = await fs4.stat(absPath).catch((err) => {
+    const stat11 = await fs7.stat(absPath).catch((err) => {
       if (err.code === "ENOENT") {
         throw new Error(`edit: file "${input.path}" does not exist. Use \`write\` instead.`);
       }
@@ -437,8 +437,8 @@ var editTool = {
     });
     if (!stat11.isFile()) throw new Error(`edit: "${input.path}" is not a regular file`);
     const autoRead = !ctx.hasRead(absPath);
-    const original = await fs4.readFile(absPath, "utf8");
-    const updated = await fs4.stat(absPath);
+    const original = await fs7.readFile(absPath, "utf8");
+    const updated = await fs7.stat(absPath);
     const mtimeTolerance = process.platform === "win32" ? 2e3 : 1;
     const lastReadMtime = ctx.lastReadMtime(absPath);
     if (lastReadMtime !== void 0 && updated.mtimeMs > lastReadMtime + mtimeTolerance) {
@@ -484,7 +484,7 @@ var editTool = {
     const newFileLf = input.replace_all ? fileLf.split(oldLf).join(newLf) : fileLf.replace(oldLf, newLf);
     const newFile = toStyle(newFileLf, style);
     await atomicWrite(absPath, newFile, { mode: updated.mode & 511 });
-    const written = await fs4.stat(absPath);
+    const written = await fs7.stat(absPath);
     ctx.recordRead(absPath, written.mtimeMs);
     ctx.session.recordFileChange({
       path: absPath,
@@ -618,11 +618,11 @@ var replaceTool = {
     const dryRun = input.dry_run ?? false;
     const filesInput = Array.isArray(input.files) ? input.files.join(",") : input.files;
     const fileList = await resolveFiles(filesInput, ctx, globRe);
-    const realRoot = await fs4.realpath(ctx.projectRoot).catch(() => ctx.projectRoot);
+    const realRoot = await fs7.realpath(ctx.projectRoot).catch(() => ctx.projectRoot);
     const results = [];
     let totalReplacements = 0;
     for (const absPath of fileList) {
-      const lstat2 = await fs4.lstat(absPath).catch((err) => {
+      const lstat2 = await fs7.lstat(absPath).catch((err) => {
         if (err.code === "ENOENT") return null;
         throw err;
       });
@@ -630,17 +630,17 @@ var replaceTool = {
       if (lstat2.isSymbolicLink()) continue;
       let realPath;
       try {
-        realPath = await fs4.realpath(absPath);
+        realPath = await fs7.realpath(absPath);
       } catch {
         continue;
       }
       const rel = path.relative(realRoot, realPath);
       if (rel.startsWith("..") || path.isAbsolute(rel)) continue;
-      const stat11 = await fs4.stat(realPath).catch(() => null);
+      const stat11 = await fs7.stat(realPath).catch(() => null);
       if (!stat11 || !stat11.isFile()) continue;
       let content;
       try {
-        const buf = await fs4.readFile(realPath);
+        const buf = await fs7.readFile(realPath);
         if (isBinaryBuffer(buf)) continue;
         content = buf.toString("utf8");
       } catch {
@@ -692,7 +692,7 @@ async function resolveFiles(filesInput, ctx, extraGlob) {
   const resolved = [];
   for (const p of parts) {
     const absPath = safeResolve(p, ctx);
-    const stat11 = await fs4.stat(absPath).catch(() => null);
+    const stat11 = await fs7.stat(absPath).catch(() => null);
     if (stat11?.isFile()) {
       resolved.push(absPath);
     }
@@ -748,7 +748,7 @@ async function globNative(pattern, base, extraGlob) {
   const walk = async (dir) => {
     let entries;
     try {
-      entries = await fs4.readdir(dir, { withFileTypes: true });
+      entries = await fs7.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -756,7 +756,7 @@ async function globNative(pattern, base, extraGlob) {
       if (DEFAULT_IGNORE.includes(e.name)) continue;
       const full = path.join(dir, e.name);
       try {
-        const stat11 = await fs4.lstat(full);
+        const stat11 = await fs7.lstat(full);
         if (stat11.isSymbolicLink()) continue;
       } catch {
         continue;
@@ -822,7 +822,7 @@ var globTool = {
       }
       let entries;
       try {
-        entries = await fs4.readdir(dir, { withFileTypes: true });
+        entries = await fs7.readdir(dir, { withFileTypes: true });
       } catch {
         return;
       }
@@ -838,7 +838,7 @@ var globTool = {
         } else if (e.isFile()) {
           if (re.test(rel) || re.test(name)) {
             try {
-              const st = await fs4.stat(full);
+              const st = await fs7.stat(full);
               results.push({ rel: full, mtime: st.mtimeMs });
               if (results.length >= limit) {
                 truncated = true;
@@ -857,13 +857,14 @@ var globTool = {
 };
 async function readGitignore(dir) {
   try {
-    const raw = await fs4.readFile(path.join(dir, ".gitignore"), "utf8");
+    const raw = await fs7.readFile(path.join(dir, ".gitignore"), "utf8");
     return raw.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
   } catch {
     return [];
   }
 }
 var DEFAULT_IGNORE3 = ["node_modules", ".git", "dist", "build", ".next", "coverage"];
+var NATIVE_SCAN_CONCURRENCY = 32;
 var grepTool = {
   name: "grep",
   category: "Search",
@@ -1091,14 +1092,52 @@ async function runNative(input, base, mode, limit, signal) {
   const fileMatches = /* @__PURE__ */ new Map();
   let total = 0;
   let stopped = false;
+  const scanFile = async (full, name) => {
+    if (stopped || signal.aborted) return;
+    if (globRe && !globRe.test(name) && !globRe.test(full)) return;
+    if (globRe) globRe.lastIndex = 0;
+    try {
+      const stat11 = await fs7.stat(full);
+      if (stat11.size > 1e6 || stopped || signal.aborted) return;
+      const head = await fs7.readFile(full);
+      if (isBinaryBuffer(head) || stopped || signal.aborted) return;
+      const text = head.toString("utf8");
+      const lines = text.split(/\r?\n/);
+      let fileHits = 0;
+      for (let i = 0; i < lines.length; i++) {
+        if (stopped || signal.aborted) break;
+        const ln = capSubject(lines[i] ?? "");
+        re.lastIndex = 0;
+        if (re.test(ln)) {
+          fileHits++;
+          total++;
+          if (mode === "content" && matches.length < limit) {
+            matches.push(`${full}:${i + 1}:${ln}`);
+          }
+        }
+      }
+      if (fileHits > 0) {
+        fileMatches.set(full, fileHits);
+        if (mode === "files_with_matches" && matches.length < limit) {
+          matches.push(full);
+        }
+        if (mode === "count" && matches.length < limit) {
+          matches.push(`${full}:${fileHits}`);
+        }
+      }
+      if (matches.length >= limit) stopped = true;
+    } catch {
+    }
+  };
   const walk = async (dir) => {
     if (stopped || signal.aborted) return;
     let entries;
     try {
-      entries = await fs4.readdir(dir, { withFileTypes: true });
+      entries = await fs7.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
+    const files = [];
     for (const e of entries) {
       if (stopped) return;
       if (DEFAULT_IGNORE3.includes(e.name)) continue;
@@ -1107,41 +1146,10 @@ async function runNative(input, base, mode, limit, signal) {
       if (e.isDirectory()) {
         await walk(full);
       } else if (e.isFile()) {
-        if (globRe && !globRe.test(e.name) && !globRe.test(full)) continue;
-        if (globRe) globRe.lastIndex = 0;
-        try {
-          const stat11 = await fs4.stat(full);
-          if (stat11.size > 1e6) continue;
-          const head = await fs4.readFile(full);
-          if (isBinaryBuffer(head)) continue;
-          const text = head.toString("utf8");
-          const lines = text.split(/\r?\n/);
-          let fileHits = 0;
-          for (let i = 0; i < lines.length; i++) {
-            const ln = capSubject(lines[i] ?? "");
-            re.lastIndex = 0;
-            if (re.test(ln)) {
-              fileHits++;
-              total++;
-              if (mode === "content" && matches.length < limit) {
-                matches.push(`${full}:${i + 1}:${ln}`);
-              }
-            }
-          }
-          if (fileHits > 0) {
-            fileMatches.set(full, fileHits);
-            if (mode === "files_with_matches" && matches.length < limit) {
-              matches.push(full);
-            }
-            if (mode === "count" && matches.length < limit) {
-              matches.push(`${full}:${fileHits}`);
-            }
-          }
-          if (matches.length >= limit) stopped = true;
-        } catch {
-        }
+        files.push({ full, name: e.name });
       }
     }
+    await mapWithConcurrency(files, NATIVE_SCAN_CONCURRENCY, ({ full, name }) => scanFile(full, name));
   };
   await walk(base);
   return {
@@ -1151,6 +1159,20 @@ async function runNative(input, base, mode, limit, signal) {
     used: "native"
   };
 }
+async function mapWithConcurrency(items, concurrency, fn) {
+  if (items.length === 0) return;
+  let next = 0;
+  const workerCount = Math.min(Math.max(1, concurrency), items.length);
+  const workers = Array.from({ length: workerCount }, async () => {
+    for (; ; ) {
+      const idx = next++;
+      if (idx >= items.length) return;
+      const item = items[idx];
+      if (item !== void 0) await fn(item);
+    }
+  });
+  await Promise.all(workers);
+}
 var SPOOL_RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
 var SPOOL_WRITE_HWM_BYTES = 4 * 1024 * 1024;
 var sweepStarted = false;
@@ -1162,13 +1184,13 @@ function sweepOldSpoolFiles(dir) {
   sweepStarted = true;
   void (async () => {
     try {
-      const now = Date.now();
-      for (const name of await fs4.readdir(dir)) {
+      const now2 = Date.now();
+      for (const name of await fs7.readdir(dir)) {
         if (!name.endsWith(".log")) continue;
         const p = path.join(dir, name);
         try {
-          const st = await fs4.stat(p);
-          if (now - st.mtimeMs > SPOOL_RETENTION_MS) await fs4.unlink(p);
+          const st = await fs7.stat(p);
+          if (now2 - st.mtimeMs > SPOOL_RETENTION_MS) await fs7.unlink(p);
         } catch {
         }
       }
@@ -1323,10 +1345,10 @@ var CircuitBreaker = class {
    */
   snapshot() {
     this._checkStateTransition();
-    const now = Date.now();
+    const now2 = Date.now();
     let cooldownRemaining = null;
     if (this.openedAt !== null && this.state === "open") {
-      const elapsed = now - this.openedAt;
+      const elapsed = now2 - this.openedAt;
       cooldownRemaining = Math.max(0, this.cooldownMs - elapsed);
     }
     return {
@@ -1366,7 +1388,7 @@ var CircuitBreaker = class {
    */
   afterCall(durationMs, failed, bypass = false) {
     if (bypass || !this.enabled) return;
-    const now = Date.now();
+    const now2 = Date.now();
     if (this.state === "half-open") {
       if (failed) {
         this._trip();
@@ -1375,12 +1397,12 @@ var CircuitBreaker = class {
       this._reset();
       return;
     }
-    this._pruneWindow(now);
+    this._pruneWindow(now2);
     const slow = durationMs >= this.slowCallThresholdMs;
-    this.window.push({ at: now, failed, slow });
+    this.window.push({ at: now2, failed, slow });
     if (failed) {
       this.consecutiveFailures++;
-      this.lastFailureAt = now;
+      this.lastFailureAt = now2;
       if (this.consecutiveFailures >= this.maxConsecutiveFailures) {
         this._trip();
       }
@@ -1388,7 +1410,7 @@ var CircuitBreaker = class {
     }
     this.consecutiveFailures = 0;
     if (slow) {
-      this.lastSlowAt = now;
+      this.lastSlowAt = now2;
       const slowCount = this.window.filter((c) => c.slow).length;
       if (slowCount >= this.maxSlowCalls) {
         this._trip();
@@ -1438,8 +1460,8 @@ var CircuitBreaker = class {
       this.openedAt = null;
     }
   }
-  _pruneWindow(now) {
-    const cutoff = now - this.windowMs;
+  _pruneWindow(now2) {
+    const cutoff = now2 - this.windowMs;
     this.window = this.window.filter((c) => c.at >= cutoff);
   }
 };
@@ -1477,10 +1499,13 @@ function redactCommand(cmd) {
 var DEFAULT_GRACE_MS = 2e3;
 function killWin32Tree(pid) {
   try {
-    spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
+    const child = spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
       stdio: "ignore",
       windowsHide: true
-    }).unref();
+    });
+    child.on("error", () => {
+    });
+    child.unref();
     return true;
   } catch {
     return false;
@@ -1682,7 +1707,7 @@ var ProcessRegistryImpl = class {
     if (p.killed) return true;
     if (p.protected) return false;
     const { force = false, graceMs = DEFAULT_GRACE_MS } = opts;
-    const isWin3 = os.platform() === "win32";
+    const isWin3 = os2.platform() === "win32";
     if (isWin3) {
       const liveRealChild = p.child.exitCode === null && typeof p.child.pid === "number";
       if (liveRealChild && killWin32Tree(pid)) {
@@ -1772,6 +1797,566 @@ function getProcessRegistry() {
 function _resetProcessRegistry() {
   _registry = void 0;
 }
+var REGISTRY_FILE = ".wrongstack/process-registry.json";
+var HEARTBEAT_INTERVAL_MS = 5e3;
+var STALE_THRESHOLD_MS = 3e4;
+var LOCKFILE = ".wrongstack/.process-registry.lock";
+function generateInstanceId() {
+  const hostname4 = os2.hostname();
+  const pid = process.pid;
+  const random = Math.random().toString(36).slice(2, 8);
+  return `${hostname4}:${pid}:${random}`;
+}
+async function acquireLock(lockfilePath, timeoutMs = 5e3) {
+  const start = Date.now();
+  const pidStr = String(process.pid);
+  const hostStr = os2.hostname();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      await fs7.writeFile(lockfilePath, `${pidStr}:${hostStr}:${Date.now()}`, { flag: "wx" });
+      return async () => {
+        try {
+          await fs7.unlink(lockfilePath);
+        } catch {
+        }
+      };
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        try {
+          const content = await fs7.readFile(lockfilePath, "utf-8");
+          const parts = content.split(":");
+          const lockPidStr = parts[0] ?? "0";
+          const lockPid = parseInt(lockPidStr, 10);
+          if (process.platform !== "win32") {
+            try {
+              process.kill(lockPid, 0);
+            } catch {
+              await fs7.unlink(lockfilePath);
+              continue;
+            }
+          }
+        } catch {
+          try {
+            await fs7.unlink(lockfilePath);
+          } catch {
+          }
+        }
+        await new Promise((r) => setTimeout(r, 100));
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw new Error(`Failed to acquire lock after ${timeoutMs}ms`);
+}
+async function readRegistryFile(filePath) {
+  try {
+    const content = await fs7.readFile(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (parsed.instances && Array.isArray(parsed.instances)) {
+      parsed.instances = new Map(parsed.instances);
+    }
+    return parsed;
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return {
+        version: 1,
+        instances: /* @__PURE__ */ new Map(),
+        protectedPatterns: ["wrongstack", "node"],
+        lastCleanup: Date.now()
+      };
+    }
+    throw err;
+  }
+}
+async function writeRegistryFile(filePath, data) {
+  const tmpPath = `${filePath}.tmp.${process.pid}`;
+  const content = JSON.stringify(data, (_k, v) => {
+    if (v instanceof Map) {
+      return Array.from(v.entries());
+    }
+    return v;
+  }, 2);
+  await fs7.writeFile(tmpPath, content, "utf-8");
+  await fs7.rename(tmpPath, filePath);
+}
+var PersistentProcessRegistry = class {
+  instanceId;
+  registryPath;
+  lockPath;
+  baseRegistry;
+  heartbeatInterval = null;
+  isShuttingDown = false;
+  constructor(baseRegistry) {
+    this.instanceId = generateInstanceId();
+    const homeDir = os2.homedir();
+    this.registryPath = path.join(homeDir, REGISTRY_FILE);
+    this.lockPath = path.join(homeDir, LOCKFILE);
+    this.baseRegistry = baseRegistry ?? getProcessRegistry();
+    this.ensureDirectory().catch((err) => {
+      console.error("PersistentProcessRegistry: failed to create .wrongstack dir", err);
+    });
+  }
+  async ensureDirectory() {
+    const dir = path.dirname(this.registryPath);
+    try {
+      await fs7.mkdir(dir, { recursive: true });
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+  }
+  /**
+   * Start the heartbeat and periodic cleanup tasks.
+   */
+  start() {
+    if (this.heartbeatInterval) return;
+    this.syncToPersistent();
+    this.heartbeatInterval = setInterval(() => {
+      this.heartbeat();
+    }, HEARTBEAT_INTERVAL_MS);
+    this.heartbeatInterval.unref?.();
+    setInterval(() => {
+      this.cleanupStaleEntries();
+    }, STALE_THRESHOLD_MS).unref?.();
+    this.registerMainProcess();
+    process.on("exit", () => this.syncToPersistent());
+  }
+  /**
+   * Stop the heartbeat and clean up.
+   */
+  stop() {
+    this.isShuttingDown = true;
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    this.syncToPersistent();
+  }
+  /**
+   * Register the main WrongStack process as protected.
+   */
+  registerMainProcess() {
+    const mainPid = process.pid;
+    this.updatePersistentEntry({
+      pid: mainPid,
+      name: "wrongstack-main",
+      command: process.argv.slice(0, 3).join(" "),
+      startedAt: Date.now(),
+      lastHeartbeat: Date.now(),
+      instanceId: this.instanceId,
+      hostname: os2.hostname(),
+      protected: true,
+      spawnMode: "main",
+      parentPid: process.ppid,
+      platform: process.platform
+    });
+  }
+  /**
+   * Register a spawned child process with the persistent registry.
+   */
+  registerChildProcess(pid, name, command, sessionId, spawnMode = "spawn") {
+    const entry = {
+      pid,
+      name,
+      command,
+      startedAt: Date.now(),
+      lastHeartbeat: Date.now(),
+      instanceId: this.instanceId,
+      hostname: os2.hostname(),
+      protected: true,
+      // All WrongStack child processes are protected by default
+      spawnMode,
+      parentPid: process.pid,
+      platform: process.platform
+    };
+    if (sessionId) {
+      entry.sessionId = sessionId;
+    }
+    this.updatePersistentEntry(entry);
+  }
+  /**
+   * Update or add an entry in the persistent registry.
+   */
+  async updatePersistentEntry(entry) {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      data.instances.set(String(entry.pid), entry);
+      this.baseRegistry.register({
+        pid: entry.pid,
+        name: entry.name,
+        command: entry.command,
+        startedAt: entry.startedAt,
+        sessionId: entry.sessionId,
+        protected: entry.protected,
+        child: null
+        // Main process has no child handle
+      });
+      await writeRegistryFile(this.registryPath, data);
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Unregister a process from the persistent registry.
+   */
+  async unregister(pid) {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      data.instances.delete(String(pid));
+      await writeRegistryFile(this.registryPath, data);
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Send heartbeat to mark all this instance's processes as alive.
+   */
+  heartbeat() {
+    if (this.isShuttingDown) return;
+    this.syncToPersistent();
+  }
+  /**
+   * Sync this instance's processes to the persistent registry.
+   */
+  async syncToPersistent() {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      const now2 = Date.now();
+      const updatedInstances = /* @__PURE__ */ new Map();
+      for (const [_pidStr, entry] of data.instances) {
+        if (entry.instanceId === this.instanceId) {
+          entry.lastHeartbeat = now2;
+        }
+        if (entry.instanceId === this.instanceId || now2 - entry.lastHeartbeat < STALE_THRESHOLD_MS) {
+          updatedInstances.set(_pidStr, entry);
+        }
+      }
+      data.instances = updatedInstances;
+      data.lastCleanup = now2;
+      await writeRegistryFile(this.registryPath, data);
+    } catch (err) {
+      console.error("PersistentProcessRegistry: sync failed", err);
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Remove entries for processes that are no longer running.
+   */
+  async cleanupStaleEntries() {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      const now2 = Date.now();
+      const stalePids = [];
+      for (const [_pidStr, entry] of data.instances) {
+        const age = now2 - entry.lastHeartbeat;
+        if (age > STALE_THRESHOLD_MS) {
+          try {
+            if (process.platform !== "win32") {
+              process.kill(entry.pid, 0);
+            } else {
+              console.log(`PersistentProcessRegistry: checking stale pid ${entry.pid} (${age}ms old)`);
+            }
+          } catch {
+            stalePids.push(_pidStr);
+          }
+        }
+      }
+      if (stalePids.length > 0) {
+        for (const pidStr of stalePids) {
+          data.instances.delete(pidStr);
+        }
+        await writeRegistryFile(this.registryPath, data);
+      }
+    } catch (err) {
+      console.error("PersistentProcessRegistry: cleanup failed", err);
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Check if a PID belongs to a WrongStack process and should be protected.
+   */
+  async isProtectedPid(pid) {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      const entry = data.instances.get(String(pid));
+      if (!entry) return false;
+      if (Date.now() - entry.lastHeartbeat > STALE_THRESHOLD_MS) {
+        return false;
+      }
+      return entry.protected;
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Get all protected PIDs from all WrongStack instances.
+   */
+  async getAllProtectedPids() {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      const now2 = Date.now();
+      const protectedPids = [];
+      for (const [_pidStr, entry] of data.instances) {
+        if (entry.protected && now2 - entry.lastHeartbeat < STALE_THRESHOLD_MS) {
+          protectedPids.push(entry.pid);
+        }
+      }
+      return protectedPids;
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Get complete status of all tracked processes across all instances.
+   */
+  async getGlobalStatus() {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      const now2 = Date.now();
+      const instances = /* @__PURE__ */ new Map();
+      let protectedCount = 0;
+      let staleCount = 0;
+      for (const [_pidStr, entry] of data.instances) {
+        const instanceEntries = instances.get(entry.instanceId) ?? [];
+        instanceEntries.push(entry);
+        instances.set(entry.instanceId, instanceEntries);
+        if (entry.protected) protectedCount++;
+        if (now2 - entry.lastHeartbeat > STALE_THRESHOLD_MS) staleCount++;
+      }
+      return {
+        instances,
+        totalProcesses: data.instances.size,
+        protectedCount,
+        staleCount
+      };
+    } finally {
+      await release();
+    }
+  }
+  /**
+   * Get the instance ID for this process.
+   */
+  getInstanceId() {
+    return this.instanceId;
+  }
+  /**
+   * Check if a kill command should be blocked.
+   * Returns true if the kill should be blocked (target is a WrongStack process).
+   */
+  async shouldBlockKill(pid) {
+    const protectedPids = await this.getAllProtectedPids();
+    return protectedPids.includes(pid);
+  }
+  /**
+   * Add a pattern-based protection rule.
+   * Processes whose command matches any protected pattern are protected.
+   */
+  async addProtectedPattern(pattern) {
+    const release = await acquireLock(this.lockPath);
+    try {
+      const data = await readRegistryFile(this.registryPath);
+      if (!data.protectedPatterns.includes(pattern)) {
+        data.protectedPatterns.push(pattern);
+        await writeRegistryFile(this.registryPath, data);
+      }
+    } finally {
+      await release();
+    }
+  }
+};
+var _persistentRegistry;
+function getPersistentProcessRegistry() {
+  if (!_persistentRegistry) {
+    _persistentRegistry = new PersistentProcessRegistry();
+  }
+  return _persistentRegistry;
+}
+function resetPersistentProcessRegistry() {
+  if (_persistentRegistry) {
+    _persistentRegistry.stop();
+    _persistentRegistry = void 0;
+  }
+}
+
+// src/bash-kill-guard.ts
+function extractKillCommand(command) {
+  const normalized = command.replace(/\s+/g, " ").trim();
+  const shellCMatch = normalized.match(
+    /^(?:\/\w+)?\/?(?:bin|usr)\/(?:ba)?sh\s+-[c]\s+['"](.+?)['"]$/
+  );
+  if (shellCMatch?.[1]) {
+    const inner = shellCMatch[1].trim();
+    return isKillRelatedCommand(inner) ? inner : null;
+  }
+  const shellCUnquoted = normalized.match(
+    /^(?:\/\w+)?\/?(?:bin|usr)\/(?:ba)?sh\s+-[c]\s+(kill(?:\s+-[a-zA-Z]+)?(?:\s+\d+)+)$/
+  );
+  if (shellCUnquoted?.[1]) {
+    return shellCUnquoted[1];
+  }
+  return null;
+}
+function isKillRelatedCommand(cmd) {
+  const normalized = cmd.toLowerCase().replace(/\s+/g, " ").trim();
+  if (/^kill(\s|$)/.test(normalized)) return true;
+  if (/^(pkill|killall|pgrep|skill)\s/.test(normalized)) return true;
+  if (/^taskkill\s/i.test(normalized)) return true;
+  if (/^tskill\s/i.test(normalized)) return true;
+  if (/^\/proc\/\d+\/(?:kill|fd)/.test(normalized)) return true;
+  return false;
+}
+function parseKillCommand(command) {
+  const normalized = command.replace(/\s+/g, " ").trim();
+  const simpleMatch = normalized.match(/^kill\s+(?:(-[a-zA-Z]+)\s+)?(\d+|-?\d+)$/);
+  if (simpleMatch) {
+    const signal = simpleMatch[1] ?? "-TERM";
+    const pidOrGroup = simpleMatch[2];
+    if (!pidOrGroup) return null;
+    const isGroupKill = pidOrGroup.startsWith("-");
+    const pid = isGroupKill ? parseInt(pidOrGroup.slice(1), 10) : parseInt(pidOrGroup, 10);
+    return {
+      pid,
+      signal: signal.slice(1),
+      isGroupKill,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
+  const pkillMatch = normalized.match(/^pkill\s+(?:(-[a-zA-Z]+)\s+)?(.+)$/);
+  if (pkillMatch?.[2]) {
+    const name = pkillMatch[2];
+    const signalMatch = pkillMatch[1];
+    return {
+      name,
+      signal: signalMatch ? signalMatch.slice(1) : "TERM",
+      isGroupKill: false,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
+  const killallMatch = normalized.match(/^killall\s+(?:(-[a-zA-Z]+)\s+)?(.+)$/);
+  if (killallMatch?.[2]) {
+    const name = killallMatch[2];
+    const signalMatch = killallMatch[1];
+    return {
+      name,
+      signal: signalMatch ? signalMatch.slice(1) : "TERM",
+      isGroupKill: false,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
+  const pgrepMatch = normalized.match(/^pgrep\s+(.+)$/);
+  if (pgrepMatch) {
+    return null;
+  }
+  const taskkillMatch = normalized.match(/^taskkill\s+(?:\/[a-zA-Z]+\s+)*\/PID\s+(\d+)/i);
+  if (taskkillMatch?.[1]) {
+    const pidStr = taskkillMatch[1];
+    return {
+      pid: parseInt(pidStr, 10),
+      signal: normalized.includes("/F") ? "FORCE" : "TERM",
+      isGroupKill: false,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
+  const tskillMatch = normalized.match(/^tskill\s+(\d+)/i);
+  if (tskillMatch?.[1]) {
+    const pidStr = tskillMatch[1];
+    return {
+      pid: parseInt(pidStr, 10),
+      signal: "TERM",
+      isGroupKill: false,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
+  return null;
+}
+async function getProtectedEntries() {
+  const registry = getPersistentProcessRegistry();
+  const status = await registry.getGlobalStatus();
+  const entries = [];
+  for (const instanceEntries of status.instances.values()) {
+    for (const entry of instanceEntries) {
+      if (entry.protected && Date.now() - entry.lastHeartbeat < 3e4) {
+        entries.push(entry);
+      }
+    }
+  }
+  return entries;
+}
+async function isKillProtected(kill) {
+  const registry = getPersistentProcessRegistry();
+  if (kill.name) {
+    const entries = await getProtectedEntries();
+    const killNameLower = kill.name.toLowerCase();
+    for (const entry of entries) {
+      if (entry.name && entry.name.toLowerCase().includes(killNameLower)) {
+        return true;
+      }
+    }
+    if (killNameLower.includes("wrongstack")) {
+      return true;
+    }
+    if (killNameLower.includes("node") && entries.length > 0) {
+      return true;
+    }
+    return false;
+  }
+  if (kill.isGroupKill) {
+    const protectedPids = await registry.getAllProtectedPids();
+    return protectedPids.length > 0;
+  }
+  if (kill.pid !== void 0) {
+    return registry.shouldBlockKill(kill.pid);
+  }
+  return false;
+}
+async function checkAndBlockKillCommand(command) {
+  const normalized = command.replace(/\s+/g, " ").trim();
+  const killCmd = extractKillCommand(normalized) || (isKillRelatedCommand(normalized) ? normalized : null);
+  if (!killCmd) {
+    return { blocked: false };
+  }
+  const parsed = parseKillCommand(killCmd);
+  if (!parsed) {
+    if (killCmd.includes("kill") && /kill\s+.*\|/.test(killCmd)) {
+      return {
+        blocked: true,
+        reason: `Blocked: complex kill pipeline detected \u2014 "${killCmd.slice(0, 50)}..."`
+      };
+    }
+    return { blocked: false };
+  }
+  if (await isKillProtected(parsed)) {
+    let target;
+    if (parsed.name) {
+      target = `process name "${parsed.name}"`;
+    } else if (parsed.pid !== void 0) {
+      target = `PID ${parsed.pid}`;
+    } else {
+      target = "(unknown target)";
+    }
+    const signal = parsed.signal ? ` (${parsed.signal})` : "";
+    const groupNote = parsed.isGroupKill ? " (process group)" : "";
+    return {
+      blocked: true,
+      reason: `Blocked: kill${signal} ${target}${groupNote} targets a protected WrongStack process.`
+    };
+  }
+  return { blocked: false };
+}
 
 // src/bash.ts
 var MAX_OUTPUT = 32768;
@@ -1841,6 +2426,20 @@ var bashTool = {
       };
       return;
     }
+    const killCheck = await checkAndBlockKillCommand(input.command);
+    if (killCheck.blocked) {
+      yield {
+        type: "final",
+        output: {
+          output: "",
+          exit_code: 1,
+          timed_out: false,
+          pid: null,
+          error: killCheck.reason || "Kill command blocked: targets a protected WrongStack process."
+        }
+      };
+      return;
+    }
     const PIPE_TO_SHELL_PATTERN = /\|\s*(sh|bash|ksh|zsh|fish|cmd|powershell|pwsh)/i;
     if (PIPE_TO_SHELL_PATTERN.test(input.command)) {
       console.warn(JSON.stringify({
@@ -1853,7 +2452,7 @@ var bashTool = {
       }));
     }
     const timeoutMs = Math.max(1, Math.min(input.timeout_ms ?? DEFAULT_TIMEOUT_MS, 6e5));
-    const isWin3 = os.platform() === "win32";
+    const isWin3 = os2.platform() === "win32";
     const shell = (() => {
       const explicit = process.env[isWin3 ? "WRONGSTACK_COMSPEC" : "WRONGSTACK_SHELL"];
       if (explicit) return explicit;
@@ -2105,8 +2704,8 @@ var bashTool = {
           };
           return;
         }
-        const now = Date.now();
-        if (pending2.length >= STREAM_FLUSH_BYTES || now - lastFlush >= STREAM_FLUSH_INTERVAL_MS) {
+        const now2 = Date.now();
+        if (pending2.length >= STREAM_FLUSH_BYTES || now2 - lastFlush >= STREAM_FLUSH_INTERVAL_MS) {
           const text = flush();
           if (text) yield { type: "partial_output", text };
         }
@@ -2138,7 +2737,7 @@ function resolveWin32Command(cmd) {
     for (const ext of pathext) {
       const full = `${base}${ext}`;
       try {
-        fs7.accessSync(full, fs7.constants.X_OK);
+        fs8.accessSync(full, fs8.constants.X_OK);
         return full;
       } catch {
       }
@@ -2453,8 +3052,8 @@ if (ALLOW_PRIVATE && !process.env["CI"]) {
   );
 }
 var combineSignals = (signals) => AbortSignal.any(signals);
-function guardedLookup(hostname, options, callback) {
-  dns.lookup(hostname, { all: true }).then((records) => {
+function guardedLookup(hostname4, options, callback) {
+  dns.lookup(hostname4, { all: true }).then((records) => {
     const family = options?.family;
     const byFamily = family === 4 || family === 6 ? records.filter((r) => r.family === family) : records;
     const list = byFamily.length > 0 ? byFamily : records;
@@ -2481,7 +3080,7 @@ function guardedLookup(hostname, options, callback) {
     const first = list.at(0);
     if (!first) {
       callback(
-        Object.assign(new Error(`fetch: no address for ${hostname}`), { code: "ENOTFOUND" })
+        Object.assign(new Error(`fetch: no address for ${hostname4}`), { code: "ENOTFOUND" })
       );
       return;
     }
@@ -2595,7 +3194,13 @@ var fetchTool = {
     const timer = setTimeout(() => ctrl.abort(new Error("fetch timeout")), TIMEOUT_MS);
     const combined = combineSignals([opts.signal, ctrl.signal]);
     try {
-      const res = await guardedFetch(input.url, 5, combined);
+      let res;
+      try {
+        res = await guardedFetch(input.url, 5, combined);
+      } catch (err) {
+        if (opts.signal.aborted) throw err;
+        throw describeFetchError(err, input.url, ctrl.signal.aborted);
+      }
       const ct = res.headers.get("content-type") ?? "application/octet-stream";
       if (/^image\/|^audio\/|^video\/|application\/octet-stream/.test(ct)) {
         throw new Error(`fetch: refusing to read binary content-type "${ct}"`);
@@ -2651,9 +3256,9 @@ var fetchTool = {
     }
   }
 };
-async function assertNotPrivate(hostname) {
+async function assertNotPrivate(hostname4) {
   if (ALLOW_PRIVATE) return;
-  const host = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+  const host = hostname4.startsWith("[") && hostname4.endsWith("]") ? hostname4.slice(1, -1) : hostname4;
   if (host === "localhost" || host.endsWith(".localhost")) {
     throw new Error("fetch: blocked localhost target");
   }
@@ -2680,6 +3285,23 @@ async function assertNotPrivate(hostname) {
     }
   }
 }
+function describeFetchError(err, url, timedOut) {
+  if (timedOut) {
+    return new Error(`fetch: GET ${url} timed out after ${TIMEOUT_MS}ms`);
+  }
+  const parts = [];
+  const seen = /* @__PURE__ */ new Set();
+  let cur = err;
+  while (cur instanceof Error && !seen.has(cur)) {
+    seen.add(cur);
+    const code = cur.code;
+    const label = code ? `${code}: ${cur.message}` : cur.message;
+    if (label && label !== "fetch failed" && !parts.includes(label)) parts.push(label);
+    cur = cur.cause;
+  }
+  const detail = parts.length > 0 ? parts.join(" \u2192 ") : "fetch failed";
+  return new Error(`fetch: GET ${url} failed \u2014 ${detail}`);
+}
 function prettyJson(s) {
   try {
     return JSON.stringify(JSON.parse(s), null, 2);
@@ -2773,7 +3395,7 @@ async function duckduckgoSearch(query2, num, signal) {
       truncated: results.length >= num
     };
   } catch (err) {
-    console.log(JSON.stringify({ level: "debug", event: "search_failed", query: query2, error: toErrorMessage(err) }));
+    console.log(JSON.stringify({ level: "debug", event: "search_failed", query: query2, error: toErrorMessage$1(err) }));
     return {
       query: query2,
       results: [{ title: "Search unavailable", url: "", snippet: "Could not reach DuckDuckGo" }],
@@ -3232,7 +3854,7 @@ var planTool = {
         const lastSep = Math.max(taskPath.lastIndexOf("/"), taskPath.lastIndexOf("\\"));
         taskPath = lastSep >= 0 ? taskPath.slice(0, lastSep + 1) + "backlog.tasks.json" : "backlog.tasks.json";
       }
-      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const now2 = (/* @__PURE__ */ new Date()).toISOString();
       try {
         const taskFile = await mutateTasks(taskPath, sessionId, (f) => {
           f.tasks.push({
@@ -3242,8 +3864,8 @@ var planTool = {
             type: "feature",
             priority: "medium",
             status: "pending",
-            createdAt: now,
-            updatedAt: now
+            createdAt: now2,
+            updatedAt: now2
           });
           return f;
         });
@@ -3589,12 +4211,12 @@ var patchTool = {
         };
       }
     }
-    const tmpDir = await fs4.mkdtemp(path.join(os.tmpdir(), ".wstack_patch_"));
+    const tmpDir = await fs7.mkdtemp(path.join(os2.tmpdir(), ".wstack_patch_"));
     try {
-      await fs4.chmod(tmpDir, 448).catch(() => {
+      await fs7.chmod(tmpDir, 448).catch(() => {
       });
       const patchFile = path.join(tmpDir, "in.diff");
-      await fs4.writeFile(patchFile, input.patch, { mode: 384 });
+      await fs7.writeFile(patchFile, input.patch, { mode: 384 });
       const args = [`-p${strip}`, "--merge", ...dryRun ? ["--dry-run"] : [], "-i", patchFile];
       const result = await runPatch(args, dir, opts.signal);
       if (result.exitCode !== 0 && !dryRun) {
@@ -3615,7 +4237,7 @@ var patchTool = {
         message: result.stdout || "patch applied"
       };
     } finally {
-      await fs4.rm(tmpDir, { recursive: true, force: true }).catch(() => {
+      await fs7.rm(tmpDir, { recursive: true, force: true }).catch(() => {
       });
     }
   }
@@ -3697,7 +4319,7 @@ var jsonTool = {
     let raw;
     if (input.file) {
       try {
-        raw = await fs4.readFile(input.file, "utf8");
+        raw = await fs7.readFile(input.file, "utf8");
       } catch {
         return { data: null, formatted: "", type: "unknown", error: `Could not read file` };
       }
@@ -3736,8 +4358,8 @@ var jsonTool = {
     };
   }
 };
-function query(data, path20) {
-  const parts = path20.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+function query(data, path21) {
+  const parts = path21.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
   let current = data;
   for (const part of parts) {
     if (current === null || current === void 0) return void 0;
@@ -3912,9 +4534,9 @@ async function fileDiff(input, ctx, _signal) {
   const results = [];
   for (const file of files) {
     const absPath = safeResolve(file, ctx);
-    const stat11 = await fs4.stat(absPath).catch(() => null);
+    const stat11 = await fs7.stat(absPath).catch(() => null);
     if (!stat11?.isFile()) continue;
-    const content = await fs4.readFile(absPath, "utf8");
+    const content = await fs7.readFile(absPath, "utf8");
     const lines = content.split(/\r?\n/);
     results.push(formatWithLineNumbers(file, lines));
   }
@@ -4071,7 +4693,7 @@ var treeTool = {
   }
 };
 async function walkDir(dir, depth, opts) {
-  const entries = await fs4.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs7.readdir(dir, { withFileTypes: true }).catch(() => []);
   const filtered = entries.filter((e) => {
     if (!opts.showHidden && e.name.startsWith(".")) return false;
     if (opts.exclude.has(e.name)) return false;
@@ -4206,8 +4828,10 @@ async function* spawnStream(opts) {
     queue.push({ kind: "close", data: "", code: 124 });
     wake();
   };
-  if (opts.signal.aborted) onAbort();
-  else opts.signal.addEventListener("abort", onAbort, { once: true });
+  if (isWin2) {
+    if (opts.signal.aborted) onAbort();
+    else opts.signal.addEventListener("abort", onAbort, { once: true });
+  }
   let exitCode = 0;
   let spawnFailed = false;
   try {
@@ -4251,7 +4875,7 @@ async function* spawnStream(opts) {
     };
   } finally {
     spool.finalize();
-    opts.signal.removeEventListener("abort", onAbort);
+    if (isWin2) opts.signal.removeEventListener("abort", onAbort);
     child.stdout?.off("data", onOut);
     child.stderr?.off("data", onErr);
     child.stdout?.destroy();
@@ -5202,7 +5826,7 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
 }
 var DOCKER_LOGS_TIMEOUT_MS = 3e3;
 var MAX_TAIL_LINES = 1e5;
-async function fileLogs(path20, lines, filterRe, stream) {
+async function fileLogs(path21, lines, filterRe, stream) {
   const { createInterface } = await import('node:readline');
   const { createReadStream } = await import('node:fs');
   const entries = [];
@@ -5211,7 +5835,7 @@ async function fileLogs(path20, lines, filterRe, stream) {
   let writeIdx = 0;
   let totalLines = 0;
   const rl = createInterface({
-    input: createReadStream(path20),
+    input: createReadStream(path21),
     crlfDelay: Number.POSITIVE_INFINITY
   });
   for await (const line of rl) {
@@ -5232,7 +5856,7 @@ async function fileLogs(path20, lines, filterRe, stream) {
     if (parsed) entries.push(parsed);
   }
   return {
-    source: path20,
+    source: path21,
     entries,
     total: entries.length,
     truncated: totalLines > effLines,
@@ -5317,7 +5941,7 @@ var documentTool = {
     const fileList = input.files ? await resolveFiles2(Array.isArray(input.files) ? input.files.join(",") : input.files, cwd) : input.path ? [safeResolve(input.path, ctx)] : [];
     for (const absPath of fileList) {
       try {
-        const content = await fs4.readFile(absPath, "utf8");
+        const content = await fs7.readFile(absPath, "utf8");
         filesProcessed++;
         const processed = processFile(
           content,
@@ -5353,7 +5977,7 @@ async function resolveFiles2(filesInput, cwd) {
   for (const f of files) {
     const absPath = f.trim().startsWith("/") ? f.trim() : `${cwd}/${f.trim()}`;
     try {
-      const stat11 = await fs4.stat(absPath);
+      const stat11 = await fs7.stat(absPath);
       if (stat11.isFile()) resolved.push(absPath);
     } catch {
     }
@@ -5577,7 +6201,7 @@ async function handleBuiltIn(name, templateFiles, cwd, ctx, dryRun, vars) {
     }
     const fullPath = target;
     if (!dryRun) {
-      await fs4.mkdir(path.dirname(fullPath), { recursive: true });
+      await fs7.mkdir(path.dirname(fullPath), { recursive: true });
       await atomicWrite(fullPath, substituteVars(content, name, vars));
     }
     files.push(resolvedPath);
@@ -6245,6 +6869,531 @@ ${mode.description}`
     }
   };
 }
+var ProcessGuardian = class {
+  registry;
+  config;
+  protectedProcesses = /* @__PURE__ */ new Map();
+  heartbeatTimer = null;
+  isRunning = false;
+  instanceId;
+  constructor(config = {}) {
+    this.registry = getPersistentProcessRegistry();
+    this.config = {
+      heartbeatIntervalMs: config.heartbeatIntervalMs ?? 5e3,
+      autoResurrect: config.autoResurrect ?? false,
+      // Disabled by default
+      maxResurrectionAttempts: config.maxResurrectionAttempts ?? 3,
+      protectedPatterns: config.protectedPatterns ?? ["node", "wrongstack"]
+    };
+    this.instanceId = this.registry.getInstanceId();
+  }
+  /**
+   * Start the guardian - begins monitoring and registration.
+   */
+  start() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    this.registerProcess(process.pid, "wrongstack-main");
+    this.registerExistingChildren();
+    this.heartbeatTimer = setInterval(() => {
+      this.heartbeat();
+    }, this.config.heartbeatIntervalMs);
+    this.heartbeatTimer.unref?.();
+    this.setupProcessHandlers();
+    console.log(JSON.stringify({
+      level: "info",
+      event: "process_guardian.started",
+      instanceId: this.instanceId,
+      mainPid: process.pid,
+      hostname: os2.hostname(),
+      platform: process.platform
+    }));
+  }
+  /**
+   * Stop the guardian gracefully.
+   */
+  stop() {
+    if (!this.isRunning) return;
+    this.isRunning = false;
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    this.registry.stop();
+    console.log(JSON.stringify({
+      level: "info",
+      event: "process_guardian.stopped",
+      instanceId: this.instanceId,
+      mainPid: process.pid
+    }));
+  }
+  /**
+   * Register a process with the guardian.
+   */
+  registerProcess(pid, name) {
+    this.protectedProcesses.set(pid, {
+      pid,
+      name,
+      lastSeen: Date.now(),
+      resurrectionAttempts: 0
+    });
+    this.registry.registerChildProcess(pid, name, name, void 0, "spawn");
+    console.log(JSON.stringify({
+      level: "info",
+      event: "process_guardian.registered",
+      pid,
+      name,
+      instanceId: this.instanceId
+    }));
+  }
+  /**
+   * Unregister a process (e.g., when it exits normally).
+   */
+  unregisterProcess(pid) {
+    this.protectedProcesses.delete(pid);
+    this.registry.unregister(pid).catch((err) => {
+      console.error(JSON.stringify({
+        level: "error",
+        event: "process_guardian.unregister_failed",
+        pid,
+        error: err.message
+      }));
+    });
+  }
+  /**
+   * Register all child processes that already exist.
+   */
+  registerExistingChildren() {
+    this.syncWithProcessRegistry();
+  }
+  /**
+   * Sync protected processes with the base ProcessRegistry.
+   */
+  syncWithProcessRegistry() {
+  }
+  /**
+   * Heartbeat - updates timestamps and checks for anomalies.
+   */
+  heartbeat() {
+    const now2 = Date.now();
+    for (const [_pid, proc] of this.protectedProcesses) {
+      proc.lastSeen = now2;
+    }
+    if (Math.random() < 0.1) {
+      console.log(JSON.stringify({
+        level: "debug",
+        event: "process_guardian.heartbeat",
+        protectedCount: this.protectedProcesses.size,
+        instanceId: this.instanceId
+      }));
+    }
+  }
+  /**
+   * Set up process-level event handlers.
+   */
+  setupProcessHandlers() {
+    process.on("exit", (code) => {
+      console.log(JSON.stringify({
+        level: "info",
+        event: "process_guardian.process_exiting",
+        pid: process.pid,
+        code,
+        instanceId: this.instanceId
+      }));
+      this.stop();
+    });
+    process.on("uncaughtException", (err) => {
+      console.error(JSON.stringify({
+        level: "error",
+        event: "process_guardian.uncaught_exception",
+        error: err.message,
+        stack: err.stack,
+        instanceId: this.instanceId
+      }));
+    });
+    process.on("unhandledRejection", (reason) => {
+      console.error(JSON.stringify({
+        level: "error",
+        event: "process_guardian.unhandled_rejection",
+        reason: String(reason),
+        instanceId: this.instanceId
+      }));
+    });
+    process.on("SIGTERM", (origin) => {
+      console.log(JSON.stringify({
+        level: "warn",
+        event: "process_guardian.sigterm_received",
+        origin,
+        pid: process.pid,
+        instanceId: this.instanceId,
+        message: "SIGTERM received but ignored - use graceful shutdown instead"
+      }));
+    });
+    process.on("SIGHUP", () => {
+      console.log(JSON.stringify({
+        level: "warn",
+        event: "process_guardian.sighup_received",
+        pid: process.pid,
+        instanceId: this.instanceId,
+        message: "SIGHUP received but ignored - WrongStack continues running"
+      }));
+    });
+  }
+  /**
+   * Check if a PID is protected by this guardian.
+   */
+  isProtected(pid) {
+    return this.protectedProcesses.has(pid);
+  }
+  /**
+   * Get all PIDs protected by this guardian.
+   */
+  getProtectedPids() {
+    return Array.from(this.protectedProcesses.keys());
+  }
+  /**
+   * Get status information for monitoring.
+   */
+  getStatus() {
+    return {
+      instanceId: this.instanceId,
+      mainPid: process.pid,
+      protectedCount: this.protectedProcesses.size,
+      platform: os2.platform(),
+      hostname: os2.hostname(),
+      uptime: process.uptime()
+    };
+  }
+};
+var _guardian;
+function getProcessGuardian() {
+  if (!_guardian) {
+    _guardian = new ProcessGuardian();
+  }
+  return _guardian;
+}
+function startProcessGuardian(config) {
+  const guardian = new ProcessGuardian(config);
+  guardian.start();
+  _guardian = guardian;
+  return guardian;
+}
+function stopProcessGuardian() {
+  if (_guardian) {
+    _guardian.stop();
+    _guardian = void 0;
+  }
+}
+var IDLE_THRESHOLD_MS = 2 * 6e4;
+var STALE_THRESHOLD_MS2 = 5 * 6e4;
+function now() {
+  return Date.now();
+}
+function formatAge(ms) {
+  if (ms < 1e3) return "0s";
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h`;
+  const days = Math.floor(hours / 24);
+  return `${days}d`;
+}
+function formatUptime(ms) {
+  return formatAge(ms);
+}
+function matchGlob(pattern, value) {
+  const regexPattern = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  try {
+    const regex = new RegExp(`^${regexPattern}$`, "i");
+    return regex.test(value);
+  } catch {
+    return false;
+  }
+}
+async function listInstances(options = {}) {
+  const { includeStale = false, hostname: hostname4, status } = options;
+  const timestamp = now();
+  const registry = getPersistentProcessRegistry();
+  const globalStatus = await registry.getGlobalStatus();
+  const instances = [];
+  const instanceMap = globalStatus.instances;
+  for (const [instanceId, processes] of instanceMap) {
+    if (processes.length === 0) continue;
+    const mainProc = processes.find((p) => p.spawnMode === "main");
+    const firstProc = processes.at(0);
+    const mainPid = mainProc?.pid ?? firstProc?.pid ?? 0;
+    const hostname_ = firstProc?.hostname ?? os2.hostname();
+    const startedAt = Math.min(...processes.map((p) => p.startedAt));
+    const lastActivity = Math.max(...processes.map((p) => p.lastHeartbeat));
+    const age = timestamp - lastActivity;
+    let instanceStatus = "stale";
+    if (age < IDLE_THRESHOLD_MS) instanceStatus = "active";
+    else if (age < STALE_THRESHOLD_MS2) instanceStatus = "idle";
+    const sessionIds = /* @__PURE__ */ new Set();
+    for (const proc of processes) {
+      if (proc.sessionId) {
+        sessionIds.add(proc.sessionId);
+      }
+    }
+    if (!includeStale && instanceStatus === "stale") continue;
+    if (hostname4 && !matchGlob(hostname4, hostname_)) continue;
+    if (status && status !== "all" && instanceStatus !== status) continue;
+    instances.push({
+      instanceId,
+      hostname: hostname_,
+      mainPid,
+      startedAt,
+      lastActivity,
+      status: instanceStatus,
+      processCount: processes.length,
+      processes,
+      sessionIds
+    });
+  }
+  instances.sort((a, b) => b.lastActivity - a.lastActivity);
+  return instances;
+}
+async function getInstanceCount() {
+  const instances = await listInstances({ includeStale: true });
+  const byHostname = /* @__PURE__ */ new Map();
+  let active = 0;
+  let idle = 0;
+  let stale = 0;
+  for (const inst of instances) {
+    const current = byHostname.get(inst.hostname) ?? 0;
+    byHostname.set(inst.hostname, current + 1);
+    switch (inst.status) {
+      case "active":
+        active++;
+        break;
+      case "idle":
+        idle++;
+        break;
+      case "stale":
+        stale++;
+        break;
+    }
+  }
+  return {
+    total: instances.length,
+    active,
+    idle,
+    stale,
+    byHostname
+  };
+}
+async function getGlobalProcessStatus() {
+  const timestamp = now();
+  const registry = getPersistentProcessRegistry();
+  const globalStatus = await registry.getGlobalStatus();
+  const instances = await listInstances({ includeStale: true });
+  const localInstanceId = registry.getInstanceId();
+  const localInstance = instances.find((i) => i.instanceId === localInstanceId);
+  let localProtectedCount = 0;
+  if (localInstance) {
+    localProtectedCount = localInstance.processes.filter((p) => p.protected).length;
+  }
+  let activeInstanceCount = 0;
+  for (const inst of instances) {
+    if (inst.status === "active") activeInstanceCount++;
+  }
+  return {
+    localInstance: localInstance ? {
+      instanceId: localInstance.instanceId,
+      mainPid: localInstance.mainPid,
+      protectedCount: localProtectedCount,
+      platform: process.platform,
+      hostname: localInstance.hostname,
+      uptime: timestamp - localInstance.startedAt
+    } : {
+      instanceId: localInstanceId,
+      mainPid: process.pid,
+      protectedCount: 0,
+      platform: process.platform,
+      hostname: os2.hostname(),
+      uptime: 0
+    },
+    allInstances: instances.map((inst) => ({
+      instanceId: inst.instanceId,
+      hostname: inst.hostname,
+      mainPid: inst.mainPid,
+      processes: inst.processes,
+      startedAt: inst.startedAt,
+      lastActivity: inst.lastActivity
+    })),
+    summary: {
+      totalProcesses: globalStatus.totalProcesses,
+      protectedCount: globalStatus.protectedCount,
+      staleCount: globalStatus.staleCount,
+      instanceCount: instances.length,
+      activeInstanceCount
+    },
+    timestamp
+  };
+}
+async function formatGlobalStatus() {
+  const status = await getGlobalProcessStatus();
+  const lines = [];
+  lines.push("=== WrongStack Global Process Status ===");
+  lines.push(`Updated: ${new Date(status.timestamp).toISOString()}`);
+  lines.push("");
+  lines.push("Summary:");
+  lines.push(`  Total processes: ${status.summary.totalProcesses}`);
+  lines.push(`  Protected: ${status.summary.protectedCount}`);
+  lines.push(`  Stale entries: ${status.summary.staleCount}`);
+  lines.push(`  Instances: ${status.summary.instanceCount} (${status.summary.activeInstanceCount} active)`);
+  lines.push("");
+  lines.push(`This instance (${status.localInstance.instanceId}):`);
+  lines.push(`  Main PID: ${status.localInstance.mainPid}`);
+  lines.push(`  Protected processes: ${status.localInstance.protectedCount}`);
+  lines.push(`  Platform: ${status.localInstance.platform} (${status.localInstance.hostname})`);
+  lines.push(`  Uptime: ${formatUptime(status.localInstance.uptime)}`);
+  lines.push("");
+  for (const instance of status.allInstances) {
+    if (instance.instanceId === status.localInstance.instanceId) continue;
+    const age = Math.round((status.timestamp - instance.lastActivity) / 1e3);
+    lines.push(`Instance ${instance.instanceId} (${instance.hostname}):`);
+    for (const proc of instance.processes) {
+      const procAge = formatAge(status.timestamp - proc.startedAt);
+      const heartbeatAge = formatAge(status.timestamp - proc.lastHeartbeat);
+      const protected_ = proc.protected ? "[P]" : "   ";
+      lines.push(
+        `  ${protected_} ${String(proc.pid).padStart(6)}  ${proc.name.padEnd(20)} started ${procAge.padStart(8)}  heartbeat ${heartbeatAge.padStart(6)}  ${proc.spawnMode}`
+      );
+    }
+    lines.push(`  Last activity: ${age}s ago`);
+    lines.push("");
+  }
+  lines.push("Legend:");
+  lines.push("  [P] = Protected (cannot be killed via bash)");
+  lines.push("  main = Main WrongStack process");
+  lines.push("  spawn = Spawned child process");
+  lines.push("  fork = Forked process (e.g., worker threads)");
+  return lines.join("\n");
+}
+async function formatInstanceList(options = {}) {
+  const instances = await listInstances(options);
+  const count = await getInstanceCount();
+  const lines = [];
+  lines.push("=== WrongStack Instances ===");
+  lines.push(`Total: ${count.total} instances (${count.active} active, ${count.idle} idle, ${count.stale} stale)`);
+  lines.push("");
+  if (count.byHostname.size > 1) {
+    lines.push("By hostname:");
+    for (const [host, num] of count.byHostname) {
+      lines.push(`  ${host}: ${num} instance${num !== 1 ? "s" : ""}`);
+    }
+    lines.push("");
+  }
+  if (instances.length === 0) {
+    lines.push("No instances found matching the filter.");
+    return lines.join("\n");
+  }
+  lines.push("INSTANCES:");
+  lines.push("  " + [
+    "STATUS".padEnd(7),
+    "HOSTNAME".padEnd(16),
+    "MAIN PID".padEnd(9),
+    "PROCS".padEnd(6),
+    "SESSIONS".padEnd(8),
+    "UPTIME".padEnd(8),
+    "LAST ACTIVITY"
+  ].join("  "));
+  lines.push("  " + "-".repeat(80));
+  for (const inst of instances) {
+    const uptime = formatAge(Date.now() - inst.startedAt);
+    const lastAct = formatAge(Date.now() - inst.lastActivity);
+    const statusIcon = inst.status === "active" ? "[*]" : inst.status === "idle" ? "[-]" : "[ ]";
+    lines.push(
+      "  " + [
+        `${statusIcon} ${inst.status}`.padEnd(7),
+        inst.hostname.padEnd(16),
+        String(inst.mainPid).padEnd(9),
+        String(inst.processCount).padEnd(6),
+        String(inst.sessionIds.size).padEnd(8),
+        uptime.padEnd(8),
+        `${lastAct} ago`
+      ].join("  ")
+    );
+  }
+  lines.push("");
+  lines.push("Use /ps full for detailed process listing per instance.");
+  return lines.join("\n");
+}
+async function formatInstanceSummary() {
+  const count = await getInstanceCount();
+  const instances = await listInstances({ includeStale: false });
+  if (instances.length === 0) {
+    return "No active WrongStack instances.";
+  }
+  const lines = [];
+  lines.push(`${count.total} instance${count.total !== 1 ? "s" : ""}`);
+  const byStatus = /* @__PURE__ */ new Map();
+  for (const inst of instances) {
+    byStatus.set(inst.status, (byStatus.get(inst.status) ?? 0) + 1);
+  }
+  const parts = [];
+  if (byStatus.get("active")) parts.push(`${byStatus.get("active")} active`);
+  if (byStatus.get("idle")) parts.push(`${byStatus.get("idle")} idle`);
+  if (byStatus.get("stale")) parts.push(`${byStatus.get("stale")} stale`);
+  lines.push(`(${parts.join(", ")})`);
+  const totalProcs = instances.reduce((sum, inst) => sum + inst.processCount, 0);
+  lines.push(`${totalProcs} total processes`);
+  return lines.join(" ");
+}
+function createGlobalPsSlashCommand() {
+  return {
+    name: "ps",
+    description: "List all WrongStack instances and their processes",
+    async handler(input) {
+      try {
+        const trimmed = input.trim();
+        const parts = trimmed.split(/\s+/);
+        const sub = parts[0]?.toLowerCase() ?? "";
+        if (sub === "list" || sub === "ls" || sub === "") {
+          const output = await formatInstanceList();
+          return { message: output };
+        }
+        if (sub === "summary" || sub === "sum") {
+          const output = await formatInstanceSummary();
+          return { message: output };
+        }
+        if (sub === "full" || sub === "detail") {
+          const output = await formatGlobalStatus();
+          return { message: output };
+        }
+        if (sub === "count" || sub === "num") {
+          const count = await getInstanceCount();
+          return {
+            message: `${count.total} instance${count.total !== 1 ? "s" : ""} (${count.active} active, ${count.idle} idle, ${count.stale} stale)`
+          };
+        }
+        if (sub === "hostname" || sub === "host") {
+          const pattern = parts.slice(1).join(" ");
+          if (!pattern) {
+            return { message: "Usage: /ps hostname <pattern> (e.g., /ps hostname workstation*)" };
+          }
+          const output = await formatInstanceList({ hostname: pattern });
+          return { message: output };
+        }
+        if (sub === "status" || sub === "state") {
+          const filterStatus = parts[1]?.toLowerCase();
+          if (!["active", "idle", "stale", "all"].includes(filterStatus ?? "")) {
+            return { message: "Usage: /ps status <active|idle|stale|all>" };
+          }
+          const output = await formatInstanceList({ status: filterStatus });
+          return { message: output };
+        }
+        return { message: "Usage: /ps [list|summary|count|full|hostname <pattern>|status <state>]" };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return { message: `Error getting process status: ${message}` };
+      }
+    }
+  };
+}
 
 // src/codebase-index/circuit-breaker.ts
 var CircuitOpenError = class extends Error {
@@ -6483,7 +7632,7 @@ function loadDatabaseSync() {
     DatabaseSyncCtor = req("node:sqlite").DatabaseSync;
   } catch (err) {
     throw new Error(
-      `The codebase index needs Node's built-in SQLite (node:sqlite), available since Node 22.5. This runtime doesn't provide it: ${toErrorMessage(err)}`
+      `The codebase index needs Node's built-in SQLite (node:sqlite), available since Node 22.5. This runtime doesn't provide it: ${toErrorMessage$1(err)}`
     );
   }
   return DatabaseSyncCtor;
@@ -6553,7 +7702,7 @@ var IndexStore = class {
   }
   constructor(projectRoot, opts = {}) {
     this.indexDir = resolveIndexDir(projectRoot, opts.indexDir);
-    fs7.mkdirSync(this.indexDir, { recursive: true });
+    fs8.mkdirSync(this.indexDir, { recursive: true });
     const Database = loadDatabaseSync();
     this.db = new Database(path.join(this.indexDir, DB_FILE));
     try {
@@ -6632,33 +7781,53 @@ var IndexStore = class {
     }
   }
   // ─── Symbol CRUD ─────────────────────────────────────────────────────────────
-  insertSymbols(symbols, nextId) {
+  /**
+   * Insert symbols, assigning IDs atomically inside `BEGIN IMMEDIATE` /
+   * `COMMIT`. The ID allocation (`SELECT MAX(id)`) and all `INSERT`s share
+   * the same transaction, preventing UNIQUE constraint violations when two
+   * processes index concurrently (each would see a different `MAX(id)` and
+   * neither can insert with the other's IDs).
+   *
+   * @returns The symbols array with `id` fields populated so the caller can
+   *          use them for refs without re-reading from the DB.
+   */
+  insertSymbols(symbols) {
     return this.runWithRetry(() => {
-      const stmt = this.db.prepare(
-        `INSERT INTO symbols(id, lang, kind, name, file, line, col, signature, doc_comment, scope, text, file_fk)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-      );
-      const ftsStmt = this.ftsAvailable ? this.db.prepare("INSERT INTO symbols_fts(rowid, text) VALUES (?, ?)") : null;
-      let id = nextId;
-      for (const s of symbols) {
-        stmt.run(
-          id,
-          s.lang,
-          s.kind,
-          s.name,
-          s.file,
-          s.line,
-          s.col,
-          s.signature,
-          s.docComment,
-          s.scope,
-          s.text,
-          s.file
+      this.db.exec("BEGIN IMMEDIATE");
+      try {
+        const maxRows = this.db.prepare("SELECT MAX(id) AS m FROM symbols").all();
+        let nextId = (maxRows[0]?.m ?? 0) + 1;
+        const stmt = this.db.prepare(
+          `INSERT INTO symbols(id, lang, kind, name, file, line, col, signature, doc_comment, scope, text, file_fk)
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
         );
-        ftsStmt?.run(id, buildIndexableText(s.name, s.signature, s.docComment));
-        id++;
+        const ftsStmt = this.ftsAvailable ? this.db.prepare("INSERT INTO symbols_fts(rowid, text) VALUES (?, ?)") : null;
+        const result = [];
+        for (const s of symbols) {
+          const id = nextId++;
+          stmt.run(
+            id,
+            s.lang,
+            s.kind,
+            s.name,
+            s.file,
+            s.line,
+            s.col,
+            s.signature,
+            s.docComment,
+            s.scope,
+            s.text,
+            s.file
+          );
+          ftsStmt?.run(id, buildIndexableText(s.name, s.signature, s.docComment));
+          result.push({ ...s, id });
+        }
+        this.db.exec("COMMIT");
+        return result;
+      } catch (err) {
+        this.db.exec("ROLLBACK");
+        throw err;
       }
-      return id;
     });
   }
   deleteSymbolsForFile(file) {
@@ -7016,7 +8185,7 @@ var IndexStore = class {
   sizeBytes() {
     const dbPath = path.join(this.indexDir, DB_FILE);
     try {
-      return fs7.statSync(dbPath).size;
+      return fs8.statSync(dbPath).size;
     } catch {
       return 0;
     }
@@ -7212,10 +8381,10 @@ function detectLang(file) {
   if (idx < 0) return null;
   return extToLang(file.slice(idx));
 }
-function parseSymbols2(opts) {
+async function parseSymbols2(opts) {
   const { file, content, lang } = opts;
   try {
-    return syncGoParse(file, content, lang);
+    return await syncGoParse(file, content, lang);
   } catch {
     return { file, lang, symbols: [], mtimeMs: Date.now() };
   }
@@ -7452,19 +8621,34 @@ func formatType(t ast.Expr) string {
 	}
 }
 `;
-function syncGoParse(filePath, content, lang) {
-  const tmpDir = path.join(os.tmpdir(), "ws-go-parse");
+async function syncGoParse(filePath, content, lang) {
+  const tmpDir = path.join(os2.tmpdir(), "ws-go-parse");
   try {
-    mkdirSync(tmpDir, { recursive: true });
+    await fs7.mkdir(tmpDir, { recursive: true });
     const scriptPath = path.join(tmpDir, "parse.go");
-    writeFileSync(scriptPath, GO_PARSE_SCRIPT, "utf8");
-    const stdout = execFileSync("go", ["run", scriptPath], {
-      input: content,
-      timeout: 15e3,
-      encoding: "utf8",
+    await fs7.writeFile(scriptPath, GO_PARSE_SCRIPT, "utf8");
+    const proc = spawn("go", ["run", scriptPath], {
+      stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true
     });
-    if (!stdout.trim()) {
+    let stdout = "";
+    proc.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    proc.stdin?.write(content);
+    proc.stdin?.end();
+    const { code } = await Promise.race([
+      new Promise((resolve6) => {
+        proc.on("close", (c) => resolve6({ code: c }));
+      }),
+      new Promise(
+        (_, reject) => setTimeout(() => {
+          proc.kill("SIGKILL");
+          reject(new Error("timeout"));
+        }, 15e3)
+      )
+    ]).catch(() => ({ code: -1 }));
+    if (code !== 0 || !stdout.trim()) {
       return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
     }
     const raw = JSON.parse(stdout.trim());
@@ -7486,10 +8670,10 @@ function syncGoParse(filePath, content, lang) {
     return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
   }
 }
-function parseSymbols3(opts) {
+async function parseSymbols3(opts) {
   const { file, lang } = opts;
   try {
-    return syncPyParse(file, lang);
+    return await syncPyParse(file, lang);
   } catch {
     return { file, lang, symbols: [], mtimeMs: Date.now() };
   }
@@ -7698,18 +8882,32 @@ visitor.visit(tree)
 
 print(json.dumps([s.to_dict() for s in syms]))
 `;
-function syncPyParse(filePath, lang) {
+async function syncPyParse(filePath, lang) {
   try {
-    const tmpDir = path.join(os.tmpdir(), "ws-py-parse");
-    mkdirSync(tmpDir, { recursive: true });
+    const tmpDir = path.join(os2.tmpdir(), "ws-py-parse");
+    await fs7.mkdir(tmpDir, { recursive: true });
     const scriptPath = path.join(tmpDir, "parse.py");
-    writeFileSync(scriptPath, PY_PARSE_SCRIPT, "utf8");
-    const stdout = execFileSync("python", [scriptPath, filePath], {
-      timeout: 15e3,
-      encoding: "utf8",
+    await fs7.writeFile(scriptPath, PY_PARSE_SCRIPT, "utf8");
+    const proc = spawn("python", [scriptPath, filePath], {
+      stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true
     });
-    if (!stdout.trim()) {
+    let stdout = "";
+    proc.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    const { code } = await Promise.race([
+      new Promise((resolve6) => {
+        proc.on("close", (c) => resolve6({ code: c }));
+      }),
+      new Promise(
+        (_, reject) => setTimeout(() => {
+          proc.kill("SIGKILL");
+          reject(new Error("timeout"));
+        }, 15e3)
+      )
+    ]).catch(() => ({ code: -1 }));
+    if (code !== 0 || !stdout.trim()) {
       return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
     }
     const raw = JSON.parse(stdout.trim());
@@ -7731,11 +8929,11 @@ function syncPyParse(filePath, lang) {
     return { file: filePath, lang, symbols: [], mtimeMs: Date.now() };
   }
 }
-function parseSymbols4(opts) {
+async function parseSymbols4(opts) {
   const { file, content, lang } = opts;
   const nativeAvailable = checkNativeParser();
   if (nativeAvailable) {
-    const result = tryNativeParse(file, content);
+    const result = await tryNativeParse(file, content);
     if (result) return result;
   }
   return regexParse({ file, content, lang });
@@ -7765,25 +8963,34 @@ function checkNativeParser() {
     return false;
   }
 }
-function tryNativeParse(file, content) {
+async function tryNativeParse(file, content) {
   try {
     const toolsDir = path.join(process.cwd(), "tools");
     const crateDir = path.join(toolsDir, "syn-parser");
     const tmpFile = path.join(crateDir, "src", "input.rs");
-    writeFileSync(tmpFile, content, "utf8");
-    const result = spawnSync(
-      "cargo",
-      ["run", "--manifest-path", path.join(toolsDir, "Cargo.toml")],
-      {
-        cwd: process.cwd(),
-        encoding: "utf8",
-        timeout: 15e3,
-        stdio: ["pipe", "pipe", "pipe"],
-        windowsHide: true
-      }
-    );
-    if (result.status === 0 && result.stdout) {
-      const symbols = JSON.parse(result.stdout);
+    await fs7.writeFile(tmpFile, content, "utf8");
+    const proc = spawn("cargo", ["run", "--manifest-path", path.join(toolsDir, "Cargo.toml")], {
+      cwd: process.cwd(),
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true
+    });
+    let stdout = "";
+    proc.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    const { code } = await Promise.race([
+      new Promise((resolve6) => {
+        proc.on("close", (c) => resolve6({ code: c }));
+      }),
+      new Promise(
+        (_, reject) => setTimeout(() => {
+          proc.kill("SIGKILL");
+          reject(new Error("timeout"));
+        }, 15e3)
+      )
+    ]).catch(() => ({ code: -1 }));
+    if (code === 0 && stdout.trim()) {
+      const symbols = JSON.parse(stdout.trim());
       return {
         file,
         lang: "rs",
@@ -8252,7 +9459,7 @@ function compileGitignore(lines) {
 async function loadGitignoreMatcher(projectRoot) {
   let lines = [];
   try {
-    const raw = await fs4.readFile(path.join(projectRoot, ".gitignore"), "utf8");
+    const raw = await fs7.readFile(path.join(projectRoot, ".gitignore"), "utf8");
     lines = raw.split("\n");
   } catch {
   }
@@ -8310,7 +9517,7 @@ async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
     }
     let entries;
     try {
-      entries = await fs4.readdir(dir, { withFileTypes: true });
+      entries = await fs7.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -8408,7 +9615,7 @@ async function runIndexerWithStore(store, opts) {
       batchFiles.map(async (file) => {
         let stat11;
         try {
-          stat11 = await fs4.stat(file, statOpts);
+          stat11 = await fs7.stat(file, statOpts);
         } catch (e) {
           if (isAbortError(e)) throw e;
           return { file, stat: null, lang: "", parsed: null, error: `stat error: ${e instanceof Error ? e.message : String(e)}` };
@@ -8422,7 +9629,7 @@ async function runIndexerWithStore(store, opts) {
         }
         let content;
         try {
-          content = await fs4.readFile(file, { encoding: "utf8", signal });
+          content = await fs7.readFile(file, { encoding: "utf8", signal });
         } catch (e) {
           if (isAbortError(e)) throw e;
           return { file, stat: stat11, lang, parsed: null, error: `read error: ${e instanceof Error ? e.message : String(e)}` };
@@ -8472,9 +9679,7 @@ async function runIndexerWithStore(store, opts) {
         filesIndexed++;
         continue;
       }
-      const nextId = store.getMaxSymbolId() + 1;
-      const symbolsWithIds = parsed.symbols.map((s, i) => ({ ...s, id: nextId + i }));
-      store.insertSymbols(symbolsWithIds, nextId);
+      const symbolsWithIds = store.insertSymbols(parsed.symbols);
       const count = symbolsWithIds.length;
       symbolsIndexed += count;
       langStats[lang] = (langStats[lang] ?? 0) + count;
@@ -8503,7 +9708,7 @@ async function runIndexerWithStore(store, opts) {
   }
   for (const [file_] of existingMeta) {
     try {
-      await fs4.stat(file_);
+      await fs7.stat(file_);
     } catch {
       store.deleteFile(file_);
     }
@@ -8618,7 +9823,7 @@ function resolveWorkerUrl() {
   for (const rel of ["./worker.js", "./codebase-index/worker.js"]) {
     try {
       const url = new URL(rel, import.meta.url);
-      if (url.protocol === "file:" && fs7.existsSync(fileURLToPath(url))) return url;
+      if (url.protocol === "file:" && fs8.existsSync(fileURLToPath(url))) return url;
     } catch {
     }
   }
@@ -8776,10 +9981,10 @@ function debounceKey(indexDir, file) {
 function isIndexableFile(filePath) {
   return detectLang(filePath) !== null;
 }
-function isUniqueConstraintError(err) {
+function isRecoverableConstraintError(err) {
   if (err instanceof Error) {
     const msg = err.message.toLowerCase();
-    return msg.includes("unique constraint") || msg.includes("UNIQUE constraint");
+    return msg.includes("unique constraint") || msg.includes("constraint failed");
   }
   return false;
 }
@@ -8812,7 +10017,7 @@ async function runStartupIndex(opts) {
     return result;
   } catch (err) {
     _lastError = err instanceof Error ? err.message : String(err);
-    if (isUniqueConstraintError(err) && !opts.force) {
+    if (isRecoverableConstraintError(err) && !opts.force) {
       _lastError = null;
       const rebuildResult = await runStartupIndex({
         ...opts,
@@ -9114,11 +10319,11 @@ var setWorkingDirTool = {
     } catch (err) {
       return {
         current: ctx.workingDir,
-        error: toErrorMessage(err)
+        error: toErrorMessage$1(err)
       };
     }
     try {
-      await fs4.access(resolved);
+      await fs7.access(resolved);
     } catch {
       try {
         ctx.setWorkingDir(previous);
@@ -9289,11 +10494,11 @@ var taskTool = {
                 }
               }
             }
-            const now = (/* @__PURE__ */ new Date()).toISOString();
+            const now2 = (/* @__PURE__ */ new Date()).toISOString();
             f.tasks = input.tasks.map((t) => ({
               ...t,
-              createdAt: t.createdAt || now,
-              updatedAt: now
+              createdAt: t.createdAt || now2,
+              updatedAt: now2
             }));
             break;
           }
@@ -9317,7 +10522,7 @@ var taskTool = {
                 return f;
               }
             }
-            const now = (/* @__PURE__ */ new Date()).toISOString();
+            const now2 = (/* @__PURE__ */ new Date()).toISOString();
             const newTask = {
               id: `task_${Date.now()}_${randomUUID().slice(0, 8)}`,
               title: t.title,
@@ -9329,8 +10534,8 @@ var taskTool = {
               assignee: t.assignee,
               estimateHours: t.estimateHours,
               tags: t.tags,
-              createdAt: now,
-              updatedAt: now
+              createdAt: now2,
+              updatedAt: now2
             };
             f.tasks.push(newTask);
             break;
@@ -9756,6 +10961,6 @@ var TOOL_ICON_CONFIG = {
 };
 var FALLBACK_ICON = "fallback";
 
-export { CircuitBreaker, CircuitOpenError, FALLBACK_ICON, IndexCircuitBreaker, IndexTimeoutError, OPTIONAL_TOOLS, TIER1_TOOLS, TIER2_TOOLS, TIER3_TOOLS, TOOL_ICON_CONFIG, TOOL_ICON_MAP, _resetProcessRegistry, auditTool, bashTool, batchToolUseTool, builtinTools, builtinToolsPack, cancelPendingReindexes, codebaseIndexStats, codebaseIndexTool, codebaseSearchTool, codebaseStatsTool, createModeTool, diffTool, documentTool, editTool, enqueueReindex, execTool, fetchTool, forgetTool, formatTool, getIndexState, getProcessRegistry, getToolIcon, gitTool, globTool, grepTool, indexCircuitBreaker, installTool, isIndexReady, isIndexableFile, isIndexing, jsonTool, lintTool, logsTool, onIndexStateChange, outdatedTool, patchTool, planTool, readTool, relatedMemoryTool, rememberTool, replaceTool, resetIndexCircuitBreaker, runStartupIndex, scaffoldTool, searchCodebaseIndex, searchMemoryTool, searchTool, shutdownCodebaseIndexHost, testTool, todoTool, toolHelpTool, toolSearchTool, toolUseTool, treeTool, typecheckTool, writeTool };
+export { CircuitBreaker, CircuitOpenError, FALLBACK_ICON, IndexCircuitBreaker, IndexTimeoutError, OPTIONAL_TOOLS, TIER1_TOOLS, TIER2_TOOLS, TIER3_TOOLS, TOOL_ICON_CONFIG, TOOL_ICON_MAP, _resetProcessRegistry, auditTool, bashTool, batchToolUseTool, builtinTools, builtinToolsPack, cancelPendingReindexes, codebaseIndexStats, codebaseIndexTool, codebaseSearchTool, codebaseStatsTool, createGlobalPsSlashCommand, createModeTool, diffTool, documentTool, editTool, enqueueReindex, execTool, fetchTool, forgetTool, formatGlobalStatus, formatInstanceList, formatInstanceSummary, formatTool, getIndexState, getInstanceCount, getPersistentProcessRegistry, getProcessGuardian, getProcessRegistry, getToolIcon, gitTool, globTool, grepTool, indexCircuitBreaker, installTool, isIndexReady, isIndexableFile, isIndexing, jsonTool, lintTool, listInstances, logsTool, onIndexStateChange, outdatedTool, patchTool, planTool, readTool, relatedMemoryTool, rememberTool, replaceTool, resetIndexCircuitBreaker, resetPersistentProcessRegistry, runStartupIndex, scaffoldTool, searchCodebaseIndex, searchMemoryTool, searchTool, shutdownCodebaseIndexHost, startProcessGuardian, stopProcessGuardian, testTool, todoTool, toolHelpTool, toolSearchTool, toolUseTool, treeTool, typecheckTool, writeTool };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map