@wrongstack/tools 0.289.0 → 0.291.1

package/dist/index.js

@@ -709,8 +709,8 @@ var init_process_registry = __esm({
         if (p.killed) return true;
         if (p.protected) return false;
         const { force = false, graceMs = DEFAULT_GRACE_MS } = opts;
-        const isWin4 = os.platform() === "win32";
-        if (isWin4) {
+        const isWin5 = os.platform() === "win32";
+        if (isWin5) {
           const liveRealChild = p.child.exitCode === null && typeof p.child.pid === "number";
           const directFallback = () => {
             if (p.child.exitCode === null) {
@@ -2608,8 +2608,8 @@ async function scanDirectory(directory, depth, profiles, limits, state, extraIgn
     collectFileEvidence(directory, fullPath, entry.name, profiles, state);
   }
 }
-function collectFileEvidence(directory, fullPath, basename10, profiles, state) {
-  const lower = basename10.toLowerCase();
+function collectFileEvidence(directory, fullPath, basename11, profiles, state) {
+  const lower = basename11.toLowerCase();
   const extension = path4.extname(lower);
   for (const profile of profiles) {
     const detector = profile.detectors.find(
@@ -2620,7 +2620,7 @@ function collectFileEvidence(directory, fullPath, basename10, profiles, state) {
       candidate.evidence.push({
         kind: detector.kind,
         path: fullPath,
-        value: basename10,
+        value: basename11,
         weight: detector.weight
       });
       if (detector.kind === "manifest" || detector.kind === "config") {
@@ -3937,15 +3937,15 @@ async function changedPaths(before, after, beforeSizes, afterSizes) {
   const beforeSet = new Set(before);
   const afterSet = new Set(after);
   const changed = /* @__PURE__ */ new Set();
-  for (const path33 of after) {
-    if (!beforeSet.has(path33)) changed.add(path33);
+  for (const path34 of after) {
+    if (!beforeSet.has(path34)) changed.add(path34);
   }
-  for (const path33 of before) {
-    if (!afterSet.has(path33)) changed.add(path33);
+  for (const path34 of before) {
+    if (!afterSet.has(path34)) changed.add(path34);
   }
   if (beforeSizes && afterSizes) {
-    for (const path33 of after) {
-      if (beforeSizes.get(path33) !== afterSizes.get(path33)) changed.add(path33);
+    for (const path34 of after) {
+      if (beforeSizes.get(path34) !== afterSizes.get(path34)) changed.add(path34);
     }
   }
   return [...changed].sort();
@@ -5103,8 +5103,8 @@ function normalizeShell(value) {
   if (v === "pwsh" || v === "pwsh.exe") return "pwsh";
   return void 0;
 }
-function resolveSessionShell(platform5, env, deps = {}) {
-  if (platform5 !== "win32") return void 0;
+function resolveSessionShell(platform6, env, deps = {}) {
+  if (platform6 !== "win32") return void 0;
   const override = normalizeShell(env.get("WRONGSTACK_SHELL"));
   if (override) return override;
   const hasBinary = deps.hasBinary ?? ((bin) => resolveWin32Command(bin) !== bin);
@@ -5114,11 +5114,11 @@ function resolveSessionShell(platform5, env, deps = {}) {
 }
 function ensureSessionShell(opts = {}) {
   const env = opts.env ?? process.env;
-  const platform5 = opts.platform ?? process.platform;
-  if (platform5 !== "win32") return void 0;
+  const platform6 = opts.platform ?? process.platform;
+  if (platform6 !== "win32") return void 0;
   const existing = normalizeShell(env["WRONGSTACK_SHELL"]);
   if (existing) return existing;
-  const chosen = resolveSessionShell(platform5, { get: (k) => env[k] }, { hasBinary: opts.hasBinary }) ?? "cmd";
+  const chosen = resolveSessionShell(platform6, { get: (k) => env[k] }, { hasBinary: opts.hasBinary }) ?? "cmd";
   env["WRONGSTACK_SHELL"] = chosen;
   return chosen;
 }
@@ -5693,17 +5693,18 @@ function resetPersistentProcessRegistry() {
 
 // src/bash-kill-guard.ts
 var isWin2 = os3.platform() === "win32";
+var SCRIPT_KILL_RE = /^(?:\.\\|\.\/)?(?:kill|terminate|stop)\S*\.(?:ps1|bat|cmd|sh)(?:\s|$)/i;
+var SCRIPT_KILL_RE_POSIX = /^(?:\.\/)?(?:kill|terminate|stop)\S*\.sh(?:\s|$)/i;
+var SCRIPT_KILL_FALLBACK_RE = /^\S*(?:kill|terminate|stop)\S*\.(?:ps1|bat|cmd|sh)\b/i;
 function extractKillCommand(command) {
   const normalized = command.replace(/\s+/g, " ").trim();
-  const shellCMatch = normalized.match(
-    /^(?:\S+(?:\s+\S+)?)?\s+-c\s+['"](.+?)['"]$/
-  );
-  if (shellCMatch?.[1]) {
-    const inner = shellCMatch[1].trim();
+  const shellCMatch = normalized.match(/^.+?\s+-c\s+(['"])([\s\S]+)\1$/);
+  if (shellCMatch?.[2]) {
+    const inner = shellCMatch[2].trim();
     return isKillRelatedCommand(inner) ? inner : null;
   }
   const shellCUnquoted = normalized.match(
-    /^(?:\S+(?:\s+\S+)?)?\s+-c\s+(kill(?:\s+-[a-zA-Z]+)?(?:\s+\d+)+)$/
+    /^.+?\s+-c\s+(kill(?:\s+-s\s+[a-zA-Z0-9]+|\s+-[a-zA-Z0-9]+)?\s+\d+)$/
   );
   if (shellCUnquoted?.[1]) {
     return shellCUnquoted[1];
@@ -5715,22 +5716,47 @@ function isKillRelatedCommand(cmd) {
   if (isWin2) {
     if (/^taskkill\s/i.test(normalized)) return true;
     if (/^tskill\s/i.test(normalized)) return true;
+    if (/^(stop-process|kill|stop)\s/i.test(normalized)) return true;
+    if (/^wmic\s+process\s/i.test(normalized) && /\bdelete\b/i.test(normalized)) return true;
+    if (SCRIPT_KILL_RE.test(normalized)) return true;
     return false;
   }
   if (/^kill(\s|$)/.test(normalized)) return true;
   if (/^(pkill|killall|pgrep|skill)\s/.test(normalized)) return true;
   if (/^\/proc\/\d+\/(?:kill|fd)/.test(normalized)) return true;
+  if (SCRIPT_KILL_RE_POSIX.test(normalized)) return true;
   return false;
 }
 function parseKillCommand(command) {
   const normalized = command.replace(/\s+/g, " ").trim();
   if (isWin2) {
-    const taskkillMatch = normalized.match(/^taskkill\s+(?:\/[a-zA-Z]+\s+)*\/PID\s+(\d+)/i);
-    if (taskkillMatch?.[1]) {
-      const pidStr = taskkillMatch[1];
+    const hasTaskkillForce = /(?:^|\s)\/F(?=\s|$)/i.test(normalized);
+    const isSimpleTaskkill = /^taskkill\s+/i.test(normalized) && !/[|&<>]/.test(normalized);
+    const taskkillPidMatch = isSimpleTaskkill ? normalized.match(/(?:^|\s)\/PID\s+(\d+)(?=\s|$)/i) : null;
+    if (taskkillPidMatch?.[1]) {
+      return {
+        pid: parseInt(taskkillPidMatch[1], 10),
+        signal: hasTaskkillForce ? "FORCE" : "TERM",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const taskkillImMatch = isSimpleTaskkill ? normalized.match(/(?:^|\s)\/IM\s+([^\s/]+)(?=\s|$)/i) : null;
+    if (taskkillImMatch?.[1]) {
       return {
-        pid: parseInt(pidStr, 10),
-        signal: normalized.includes("/F") ? "FORCE" : "TERM",
+        name: taskkillImMatch[1],
+        signal: hasTaskkillForce ? "FORCE" : "TERM",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const taskkillFiMatch = isSimpleTaskkill ? normalized.match(/(?:^|\s)\/FI\s+"IMAGENAME\s+eq\s+([^"]+)"(?=\s|$)/i) : null;
+    if (taskkillFiMatch?.[1]) {
+      return {
+        name: taskkillFiMatch[1],
+        signal: hasTaskkillForce ? "FORCE" : "TERM",
         isGroupKill: false,
         isAllKill: false,
         originalCommand: command
@@ -5738,18 +5764,109 @@ function parseKillCommand(command) {
     }
     const tskillMatch = normalized.match(/^tskill\s+(\d+)/i);
     if (tskillMatch?.[1]) {
-      const pidStr = tskillMatch[1];
       return {
-        pid: parseInt(pidStr, 10),
+        pid: parseInt(tskillMatch[1], 10),
         signal: "TERM",
         isGroupKill: false,
         isAllKill: false,
         originalCommand: command
       };
     }
+    const isStopProcIdCommand = /^(?:stop-process|kill)(?:\s+-(?:id|pid)\s+\d+|\s+-[a-zA-Z]+)+$/i.test(normalized);
+    const stopProcIdMatch = normalized.match(/(?:^|\s)-(?:id|pid)\s+(\d+)(?=\s|$)/i);
+    if (isStopProcIdCommand && stopProcIdMatch?.[1]) {
+      return {
+        pid: parseInt(stopProcIdMatch[1], 10),
+        signal: "FORCE",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const killSignalOptionMatch = normalized.match(/^kill\s+-s\s+([a-zA-Z0-9]+)\s+(\d+)$/i);
+    if (killSignalOptionMatch?.[1] && killSignalOptionMatch[2]) {
+      return {
+        pid: parseInt(killSignalOptionMatch[2], 10),
+        signal: killSignalOptionMatch[1].toUpperCase(),
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const killPosixMatch = normalized.match(/^kill\s+(?:(-[a-zA-Z0-9]+)\s+)?(\d+)$/);
+    if (killPosixMatch?.[2]) {
+      const sig = killPosixMatch[1] ? killPosixMatch[1].slice(1).toUpperCase() : "TERM";
+      return {
+        pid: parseInt(killPosixMatch[2], 10),
+        signal: sig,
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const stopProcNameMatch = normalized.match(
+      /^(?:stop-process|kill)\s+-(?:name|n)\s+(?:['"]([a-zA-Z0-9_.-]+)['"]|([a-zA-Z0-9_.-]+))(?:\s|$)/i
+    );
+    const stopProcName = stopProcNameMatch?.[1] ?? stopProcNameMatch?.[2];
+    if (stopProcName) {
+      return {
+        name: stopProcName,
+        signal: "FORCE",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const stopProcStandalone = normalized.match(
+      /^(?:stop-process|kill)\s+['"]?([a-zA-Z][a-zA-Z0-9_.-]+)['"]?$/i
+    );
+    if (stopProcStandalone?.[1]) {
+      return {
+        name: stopProcStandalone[1],
+        signal: "FORCE",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const wmicMatch = normalized.match(
+      /^wmic\s+process\s+where\s+['"]?(?:name\s*=\s*['"]?)([a-zA-Z0-9_.-]+)/i
+    );
+    if (wmicMatch?.[1]) {
+      return {
+        name: wmicMatch[1],
+        signal: "FORCE",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
+    const killScriptMatch = normalized.match(SCRIPT_KILL_RE);
+    if (killScriptMatch) {
+      return {
+        name: "kill-script",
+        // sentinel — isKillProtected always blocks "kill-script"
+        signal: "FORCE",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
     return null;
   }
-  const simpleMatch = normalized.match(/^kill\s+(?:(-[a-zA-Z]+)\s+)?(\d+|-?\d+)$/);
+  const signalOptionMatch = normalized.match(/^kill\s+-s\s+([a-zA-Z0-9]+)\s+(\d+|-?\d+)$/i);
+  if (signalOptionMatch?.[1] && signalOptionMatch[2]) {
+    const pidOrGroup = signalOptionMatch[2];
+    const isGroupKill = pidOrGroup.startsWith("-");
+    return {
+      pid: parseInt(isGroupKill ? pidOrGroup.slice(1) : pidOrGroup, 10),
+      signal: signalOptionMatch[1].toUpperCase(),
+      isGroupKill,
+      isAllKill: false,
+      originalCommand: command
+    };
+  }
+  const simpleMatch = normalized.match(/^kill\s+(?:(-[a-zA-Z0-9]+)\s+)?(\d+|-?\d+)$/);
   if (simpleMatch) {
     const signal = simpleMatch[1] ?? "-TERM";
     const pidOrGroup = simpleMatch[2];
@@ -5809,6 +5926,9 @@ async function getProtectedEntries() {
 }
 async function isKillProtected(kill) {
   const registry = getPersistentProcessRegistry();
+  if (kill.name === "kill-script") {
+    return true;
+  }
   if (kill.name) {
     const entries = await getProtectedEntries();
     const killNameLower = kill.name.toLowerCase();
@@ -5848,6 +5968,12 @@ async function checkAndBlockKillCommand(command) {
         reason: `Blocked: complex kill pipeline detected \u2014 "${killCmd.slice(0, 50)}..."`
       };
     }
+    if (SCRIPT_KILL_FALLBACK_RE.test(killCmd)) {
+      return {
+        blocked: true,
+        reason: `Blocked: script-based kill detected \u2014 "${killCmd.slice(0, 80)}" may target protected WrongStack processes (cannot inspect script body).`
+      };
+    }
     return { blocked: false };
   }
   if (await isKillProtected(parsed)) {
@@ -5871,8 +5997,8 @@ async function checkAndBlockKillCommand(command) {
 
 // src/_shell-pick.ts
 var POSIX_DEFAULT = "cmd";
-function pickShell(platform5, command, env) {
-  if (platform5 !== "win32") return POSIX_DEFAULT;
+function pickShell(platform6, command, env) {
+  if (platform6 !== "win32") return POSIX_DEFAULT;
   const override = env.get("WRONGSTACK_SHELL")?.trim().toLowerCase();
   if (override === "cmd" || override === "cmd.exe") return "cmd";
   if (override === "powershell" || override === "powershell.exe") return "powershell";
@@ -6076,10 +6202,10 @@ var bashTool = {
       }));
     }
     const timeoutMs = Math.max(1, Math.min(input.timeout_ms ?? DEFAULT_TIMEOUT_MS2, 6e5));
-    const isWin4 = os4.platform() === "win32";
+    const isWin5 = os4.platform() === "win32";
     let plan;
     let winShellKind;
-    if (isWin4) {
+    if (isWin5) {
       const shell2 = pickShell("win32", input.command, {
         get: (k) => process.env[k]
       });
@@ -6108,7 +6234,7 @@ var bashTool = {
     const shell = plan.bin;
     const args = plan.useStdin ? [...plan.argv] : [...plan.argv, input.command];
     const env = buildChildEnv2(ctx.session?.id);
-    const detached = !isWin4;
+    const detached = !isWin5;
     const startedAt = Date.now();
     if (input.background) {
       let buf2 = "";
@@ -6126,7 +6252,7 @@ var bashTool = {
         // apply: the child gets a hidden console that grandchildren inherit.
         // Windows children survive parent exit either way. POSIX keeps
         // detached for the process-group kill semantics.
-        detached: !isWin4,
+        detached: !isWin5,
         windowsHide: true
       });
       if (plan.useStdin) {
@@ -6237,7 +6363,7 @@ var bashTool = {
       stdio: [plan.useStdin ? "pipe" : "ignore", "pipe", "pipe"],
       detached,
       windowsHide: true,
-      ...isWin4 ? {} : { signal: opts.signal }
+      ...isWin5 ? {} : { signal: opts.signal }
     });
     if (plan.useStdin) {
       try {
@@ -6290,7 +6416,7 @@ var bashTool = {
     const timers = [];
     const spool = createOutputSpool({ tool: "bash", thresholdBytes: MAX_OUTPUT });
     function killWithTimeout(child2, timeoutMs2) {
-      if (isWin4) {
+      if (isWin5) {
         if (typeof child2.pid === "number" && child2.exitCode === null) {
           const attempted = registry.kill(child2.pid, { force: true, graceMs: timeoutMs2 });
           if (!attempted) {
@@ -6331,7 +6457,7 @@ var bashTool = {
     timers.push(timer);
     timer.unref?.();
     const onAbort = () => killWithTimeout(child, 2e3);
-    if (isWin4) {
+    if (isWin5) {
       if (opts.signal.aborted) onAbort();
       else opts.signal.addEventListener("abort", onAbort, { once: true });
     }
@@ -6445,7 +6571,7 @@ ${hint}` : ""),
     } finally {
       for (const t of timers) clearTimeout(t);
       spool.finalize();
-      if (isWin4) opts.signal.removeEventListener("abort", onAbort);
+      if (isWin5) opts.signal.removeEventListener("abort", onAbort);
       child.stdout?.off("data", onStdoutData);
       child.stderr?.off("data", onStderrData);
       child.stdout?.destroy();
@@ -8099,6 +8225,53 @@ function codebaseIndexDirOverride(ctx) {
   const v = ctx.meta?.["codebaseIndexDir"];
   return typeof v === "string" ? v : void 0;
 }
+var StorePool = class {
+  stores = /* @__PURE__ */ new Map();
+  key(projectRoot, indexDir) {
+    return `${projectRoot}\0${indexDir ?? ""}`;
+  }
+  /** Borrow a store. Creates it on first access for this key. */
+  acquire(projectRoot, opts) {
+    const k = this.key(projectRoot, opts?.indexDir);
+    let store = this.stores.get(k);
+    if (!store) {
+      store = new IndexStore(projectRoot, { indexDir: opts?.indexDir });
+      this.stores.set(k, store);
+    }
+    return store;
+  }
+  /** Return the store to the pool. The connection stays warm for subsequent
+   * operations on the same (projectRoot, indexDir). */
+  release(_store) {
+  }
+  /** Close every pooled connection and drain the pool. Call on shutdown. */
+  closeAll() {
+    for (const store of this.stores.values()) {
+      try {
+        store.close();
+      } catch {
+      }
+    }
+    this.stores.clear();
+  }
+  /** Remove one store from the pool. Used by tests that need isolation. */
+  evict(projectRoot, indexDir) {
+    const k = this.key(projectRoot, indexDir);
+    const store = this.stores.get(k);
+    if (store) {
+      try {
+        store.close();
+      } catch {
+      }
+      this.stores.delete(k);
+    }
+  }
+  /** True when the pool holds a connection for the given key. */
+  has(projectRoot, indexDir) {
+    return this.stores.has(this.key(projectRoot, indexDir));
+  }
+};
+var indexStorePool = new StorePool();
 var warningSilenced = false;
 function silenceSqliteExperimentalWarning() {
   if (warningSilenced) return;
@@ -8316,7 +8489,7 @@ var IndexStore = class _IndexStore {
     return this.runWithRetry(() => {
       this.db.exec("BEGIN IMMEDIATE");
       try {
-        const maxRows = this.db.prepare("SELECT MAX(id) AS m FROM symbols").all();
+        const maxRows = this.stmt("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)
@@ -8588,7 +8761,7 @@ var IndexStore = class _IndexStore {
     return { results, total: candidates.length };
   }
   getAllIndexable() {
-    return this.db.prepare("SELECT id, text FROM symbols").all().map(({ id, text }) => ({ id, text }));
+    return this.stmt("SELECT id, text FROM symbols").all().map(({ id, text }) => ({ id, text }));
   }
   /**
    * Largest symbol id currently in the table (0 when empty). New ids must be
@@ -8598,7 +8771,7 @@ var IndexStore = class _IndexStore {
    * `symbols.id`). Ids may have gaps — that is fine.
    */
   getMaxSymbolId() {
-    const rows = this.db.prepare("SELECT MAX(id) AS m FROM symbols").all();
+    const rows = this.stmt("SELECT MAX(id) AS m FROM symbols").all();
     return rows[0]?.m ?? 0;
   }
   // ─── Stats ───────────────────────────────────────────────────────────────────
@@ -8606,14 +8779,14 @@ var IndexStore = class _IndexStore {
     const sizeBytes = this.sizeBytes();
     const lastRows = this.db.prepare("SELECT value FROM metadata WHERE key = 'last_indexed'").all();
     const lastIndexed = lastRows.length ? Number(lastRows[0]?.value) : null;
-    const totalRows = this.db.prepare("SELECT COUNT(*) FROM symbols").all();
+    const totalRows = this.stmt("SELECT COUNT(*) FROM symbols").all();
     const totalSymbols = totalRows[0] ? Number(totalRows[0]["COUNT(*)"]) : 0;
-    const fileRows = this.db.prepare("SELECT COUNT(*) FROM files").all();
+    const fileRows = this.stmt("SELECT COUNT(*) FROM files").all();
     const totalFiles = fileRows[0] ? Number(fileRows[0]["COUNT(*)"]) : 0;
-    const langRows = this.db.prepare("SELECT lang, COUNT(*) FROM symbols GROUP BY lang").all();
+    const langRows = this.stmt("SELECT lang, COUNT(*) FROM symbols GROUP BY lang").all();
     const byLang = {};
     for (const row of langRows) byLang[row.lang] = Number(row["COUNT(*)"]);
-    const kindRows = this.db.prepare("SELECT kind, COUNT(*) FROM symbols GROUP BY kind").all();
+    const kindRows = this.stmt("SELECT kind, COUNT(*) FROM symbols GROUP BY kind").all();
     const byKind = {};
     for (const row of kindRows) byKind[row.kind] = Number(row["COUNT(*)"]);
     return {
@@ -8645,11 +8818,14 @@ var IndexStore = class _IndexStore {
     this.runWithRetry(() => {
       this.db.exec("BEGIN IMMEDIATE");
       try {
-        this.db.exec("DELETE FROM refs");
-        this.db.exec("DELETE FROM symbols");
-        this.db.exec("DELETE FROM files");
-        if (this.ftsAvailable) this.db.exec("DELETE FROM symbols_fts");
+        this.db.exec("DROP TABLE IF EXISTS refs");
+        this.db.exec("DROP TABLE IF EXISTS symbols");
+        this.db.exec("DROP TABLE IF EXISTS files");
+        this.db.exec("DROP TABLE IF EXISTS metadata");
+        if (this.ftsAvailable) this.db.exec("DROP TABLE IF EXISTS symbols_fts");
         this.db.exec("COMMIT");
+        this.stmtCache.clear();
+        this.initSchema();
       } catch (err) {
         this.db.exec("ROLLBACK");
         throw err;
@@ -8734,7 +8910,7 @@ var IndexStore = class _IndexStore {
           ).run(...options.deleteForFiles);
           this.db.prepare(`DELETE FROM symbols WHERE file IN (${placeholders})`).run(...options.deleteForFiles);
         }
-        const maxRows = this.db.prepare("SELECT MAX(id) AS m FROM symbols").all();
+        const maxRows = this.stmt("SELECT MAX(id) AS m FROM symbols").all();
         let nextId = (maxRows[0]?.m ?? 0) + 1;
         const symStmt = this.db.prepare(
           `INSERT INTO symbols(id, lang, kind, name, file, line, col, signature, doc_comment, scope, text, file_fk)
@@ -8918,7 +9094,7 @@ var IndexStore = class _IndexStore {
    * symbol resolved in package B). Node metadata includes symbol/file counts.
    */
   getPackageGraph() {
-    const symbols = this.db.prepare("SELECT file, id, name, kind, lang, line FROM symbols ORDER BY id").all();
+    const symbols = this.db.prepare("SELECT file, id FROM symbols ORDER BY id").all();
     const pkgNodes = /* @__PURE__ */ new Map();
     const fileToPkg = /* @__PURE__ */ new Map();
     const symbolToPkg = /* @__PURE__ */ new Map();
@@ -9009,15 +9185,18 @@ var IndexStore = class _IndexStore {
    * derived from cross-file symbol references within the package.
    */
   getFileGraph(packageFilter) {
-    const allSymbols = this.db.prepare("SELECT file, id, name, kind, lang, line FROM symbols ORDER BY id").all();
-    const pkgSyms = allSymbols.filter(
-      (s) => (_IndexStore.derivePackage(s.file) ?? "(root)") === packageFilter
-    );
-    if (pkgSyms.length === 0) return { nodes: [], edges: [] };
+    const allFiles = this.db.prepare("SELECT DISTINCT file FROM symbols").all();
+    const pkgFilePaths = allFiles.filter((f) => (_IndexStore.derivePackage(f.file) ?? "(root)") === packageFilter).map((f) => f.file);
+    const localFiles = new Set(pkgFilePaths);
+    if (localFiles.size === 0) return { nodes: [], edges: [] };
+    const filePlaceholders = [...localFiles].map(() => "?").join(",");
+    const pkgSyms = this.db.prepare(
+      `SELECT file, id, name, kind, lang, line FROM symbols WHERE file IN (${filePlaceholders}) ORDER BY id`
+    ).all(...pkgFilePaths);
     const fileNodes = /* @__PURE__ */ new Map();
     const symToFile = /* @__PURE__ */ new Map();
     const fileStats = /* @__PURE__ */ new Map();
-    for (const s of allSymbols) {
+    for (const s of pkgSyms) {
       symToFile.set(s.id, s.file);
       const current = fileStats.get(s.file);
       fileStats.set(s.file, {
@@ -9025,8 +9204,6 @@ var IndexStore = class _IndexStore {
         lang: current?.lang ?? s.lang
       });
     }
-    const localFiles = new Set(pkgSyms.map((s) => s.file));
-    const indexedFiles = new Set(allSymbols.map((s) => s.file));
     const ensureFileNode = (file) => {
       if (fileNodes.has(file)) return;
       const stats = fileStats.get(file);
@@ -9044,11 +9221,32 @@ var IndexStore = class _IndexStore {
     for (const file of localFiles) {
       ensureFileNode(file);
     }
+    const indexedFiles = new Set(allFiles.map((f) => f.file));
     const refRows = this.db.prepare(
       `SELECT r.from_id, r.to_id, r.call_type
        FROM refs r
-       WHERE r.to_id IS NOT NULL`
-    ).all();
+       WHERE (r.from_id IN (SELECT id FROM symbols WHERE file IN (${filePlaceholders}))
+           OR r.to_id IN (SELECT id FROM symbols WHERE file IN (${filePlaceholders})))
+         AND r.to_id IS NOT NULL`
+    ).all(...pkgFilePaths, ...pkgFilePaths);
+    const knownSymIds = new Set(pkgSyms.map((s) => s.id));
+    const crossRefIds = /* @__PURE__ */ new Set();
+    for (const r of refRows) {
+      if (!knownSymIds.has(r.from_id)) crossRefIds.add(r.from_id);
+      if (!knownSymIds.has(r.to_id)) crossRefIds.add(r.to_id);
+    }
+    if (crossRefIds.size > 0) {
+      const crossPlaceholders = [...crossRefIds].map(() => "?").join(",");
+      const extras = this.db.prepare(
+        `SELECT id, file FROM symbols WHERE id IN (${crossPlaceholders})`
+      ).all(...crossRefIds);
+      for (const x of extras) {
+        symToFile.set(x.id, x.file);
+        if (!fileStats.has(x.file)) {
+          fileStats.set(x.file, { count: 0, lang: "ts" });
+        }
+      }
+    }
     const edgeMap = /* @__PURE__ */ new Map();
     for (const r of refRows) {
       if (r.call_type === "import") continue;
@@ -9070,8 +9268,9 @@ var IndexStore = class _IndexStore {
     const importRows = this.db.prepare(
       `SELECT r.from_id, r.to_name
        FROM refs r
-       WHERE r.call_type = 'import'`
-    ).all();
+       WHERE r.call_type = 'import'
+         AND r.from_id IN (SELECT id FROM symbols WHERE file IN (${filePlaceholders}))`
+    ).all(...pkgFilePaths);
     for (const r of importRows) {
       const fromFile = symToFile.get(r.from_id);
       if (!fromFile || !localFiles.has(fromFile)) continue;
@@ -9113,12 +9312,11 @@ var IndexStore = class _IndexStore {
    * derived from intra-file and cross-file symbol references (who calls whom).
    */
   getSymbolGraph(fileFilter) {
-    const allSymbols = this.db.prepare(
-      "SELECT id, name, kind, lang, file, line, signature, scope FROM symbols ORDER BY file, line, id"
-    ).all();
-    const syms = allSymbols.filter((symbol) => symbol.file === fileFilter);
+    const syms = this.db.prepare(
+      "SELECT id, name, kind, lang, file, line, signature, scope FROM symbols WHERE file = ? ORDER BY line, id"
+    ).all(fileFilter);
     if (syms.length === 0) return { nodes: [], edges: [] };
-    const symById = new Map(allSymbols.map((symbol) => [symbol.id, symbol]));
+    const symById = new Map(syms.map((symbol) => [symbol.id, symbol]));
     const relatedIds = new Set(syms.map((symbol) => symbol.id));
     const toGraphNode = (s) => ({
       id: `sym:${s.id}`,
@@ -9174,6 +9372,15 @@ var IndexStore = class _IndexStore {
         refType: bestType
       });
     }
+    const loadedIds = new Set(syms.map((s) => s.id));
+    const missingIds = [...relatedIds].filter((id) => !loadedIds.has(id));
+    if (missingIds.length > 0) {
+      const placeholders = missingIds.map(() => "?").join(",");
+      const extras = this.db.prepare(
+        `SELECT id, name, kind, lang, file, line, signature, scope FROM symbols WHERE id IN (${placeholders})`
+      ).all(...missingIds);
+      for (const s of extras) symById.set(s.id, s);
+    }
     const nodes = [...relatedIds].map((id) => symById.get(id)).filter((symbol) => symbol !== void 0).sort((a, b) => {
       const aExternal = a.file === fileFilter ? 0 : 1;
       const bExternal = b.file === fileFilter ? 0 : 1;
@@ -9199,6 +9406,7 @@ import { Worker } from "node:worker_threads";
 import { expectDefined as expectDefined6 } from "@wrongstack/core";
 import * as fs14 from "node:fs/promises";
 import * as path19 from "node:path";
+import { availableParallelism } from "node:os";
 import { compileGlob as compileGlob2 } from "@wrongstack/core";
 
 // src/codebase-index/ts-parser.ts
@@ -9255,8 +9463,7 @@ function extToLang(ext) {
       return null;
   }
 }
-function getSignature(node, sourceFile) {
-  const printer = ts.createPrinter({});
+function getSignature(printer, node, sourceFile) {
   const raw = printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
   return raw.replace(/\s+/g, " ").slice(0, 500);
 }
@@ -9275,28 +9482,14 @@ function getJsDoc(node, sourceFile) {
   }
   return "";
 }
-function hasFunctionLikeAncestor(node) {
-  let current = node.parent;
-  while (current) {
-    if (ts.isFunctionLike(current)) return true;
-    current = current.parent;
-  }
-  return false;
-}
-function buildScope(node) {
-  const parts = [];
-  let current = node.parent;
-  while (current) {
-    if (ts.isClassDeclaration(current) || ts.isInterfaceDeclaration(current) || ts.isEnumDeclaration(current) || ts.isTypeAliasDeclaration(current)) {
-      parts.unshift(current.name?.text ?? "Anon");
-    } else if (ts.isMethodDeclaration(current) || ts.isGetAccessor(current) || ts.isSetAccessor(current) || ts.isPropertyDeclaration(current) || ts.isFunctionDeclaration(current)) {
-      if (current.name && ts.isIdentifier(current.name)) {
-        parts.unshift(current.name.text);
-      }
+function pushScopeName(node, parts) {
+  if (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isEnumDeclaration(node) || ts.isTypeAliasDeclaration(node)) {
+    parts.push(node.name?.text ?? "Anon");
+  } else if (ts.isMethodDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node) || ts.isPropertyDeclaration(node) || ts.isFunctionDeclaration(node)) {
+    if (node.name && ts.isIdentifier(node.name)) {
+      parts.push(node.name.text);
     }
-    current = current.parent;
   }
-  return parts.join(".");
 }
 function parseSymbols(opts) {
   const { file, content, lang } = opts;
@@ -9307,45 +9500,39 @@ function parseSymbols(opts) {
     return { file, lang, symbols: [], mtimeMs: Date.now() };
   }
   const symbols = [];
-  function visit(node) {
+  const refs = [];
+  const printer = ts.createPrinter({});
+  function visit(node, funcDepth, scopeParts) {
     const kind = kindOf(node);
     if (kind) {
-      if ((kind === "const" || kind === "let" || kind === "var" || kind === "parameter") && hasFunctionLikeAncestor(node)) {
-        ts.forEachChild(node, visit);
-        return;
+      if ((kind === "const" || kind === "let" || kind === "var" || kind === "parameter") && funcDepth > 0) {
+      } else {
+        const nameNode = node.name;
+        if (!nameNode || !ts.isIdentifier(nameNode)) {
+          return;
+        }
+        const name = nameNode.text;
+        const pos2 = nameNode.getStart(sourceFile);
+        const { line: line2, character } = sourceFile.getLineAndCharacterOfPosition(pos2);
+        const scope = scopeParts.join(".");
+        const signature = getSignature(printer, node, sourceFile);
+        const docComment = getJsDoc(node, sourceFile);
+        const text = [name, signature, docComment].filter(Boolean).join(" | ");
+        symbols.push({
+          id: 0,
+          lang,
+          kind,
+          name,
+          file,
+          line: line2 + 1,
+          col: character,
+          signature,
+          docComment,
+          scope,
+          text
+        });
       }
-      const nameNode = node.name;
-      if (!nameNode || !ts.isIdentifier(nameNode)) return;
-      const name = nameNode.text;
-      const pos = nameNode.getStart(sourceFile);
-      const { line, character } = sourceFile.getLineAndCharacterOfPosition(pos);
-      const scope = buildScope(node);
-      const signature = getSignature(node, sourceFile);
-      const docComment = getJsDoc(node, sourceFile);
-      const text = [name, signature, docComment].filter(Boolean).join(" | ");
-      symbols.push({
-        id: 0,
-        lang,
-        kind,
-        name,
-        file,
-        line: line + 1,
-        col: character,
-        signature,
-        docComment,
-        scope,
-        text
-      });
     }
-    ts.forEachChild(node, visit);
-  }
-  visit(sourceFile);
-  const refs = extractRefs(sourceFile);
-  return { file, lang, symbols, refs, mtimeMs: Date.now() };
-}
-function extractRefs(sourceFile) {
-  const refs = [];
-  function visit(node) {
     const pos = node.getStart(sourceFile);
     const { line } = sourceFile.getLineAndCharacterOfPosition(pos);
     const lineNum = line + 1;
@@ -9370,10 +9557,14 @@ function extractRefs(sourceFile) {
       const moduleName = getModuleName(node);
       if (moduleName) refs.push({ fromId: 0, toName: moduleName, callType: "import", line: lineNum });
     }
-    ts.forEachChild(node, visit);
+    const scopeIdx = scopeParts.length;
+    pushScopeName(node, scopeParts);
+    const childFuncDepth = ts.isFunctionLike(node) ? funcDepth + 1 : funcDepth;
+    ts.forEachChild(node, (child) => visit(child, childFuncDepth, scopeParts));
+    scopeParts.length = scopeIdx;
   }
-  visit(sourceFile);
-  return deduplicateRefs(refs);
+  visit(sourceFile, 0, []);
+  return { file, lang, symbols, refs: deduplicateRefs(refs), mtimeMs: Date.now() };
 }
 function getTypeName(name) {
   if (ts.isIdentifier(name)) return name.text;
@@ -10258,9 +10449,9 @@ function parseSymbols5(opts) {
 function regexParse2(opts) {
   const { file, content, lang } = opts;
   const symbols = [];
-  const basename10 = path17.basename(file).toLowerCase();
-  const isPackageJson = basename10 === "package.json";
-  const isTsconfig = basename10 === "tsconfig.json" || basename10 === "tsconfig.build.json";
+  const basename11 = path17.basename(file).toLowerCase();
+  const isPackageJson = basename11 === "package.json";
+  const isTsconfig = basename11 === "tsconfig.json" || basename11 === "tsconfig.build.json";
   const isJsonSchema = content.includes("$schema") || content.includes("$id") || content.includes("$ref");
   const isOpenApi = content.includes("openapi") || content.includes("swagger");
   const lines = content.split("\n");
@@ -10655,7 +10846,7 @@ async function loadGitignoreMatcher(projectRoot) {
 
 // src/codebase-index/indexer.ts
 var YIELD_EVERY_N = 50;
-var PARALLEL_BATCH = 20;
+var PARALLEL_BATCH = Math.min(availableParallelism() * 4, 40);
 function yieldEventLoop() {
   return new Promise((resolve15) => setImmediate(resolve15));
 }
@@ -10833,11 +11024,14 @@ async function runIndexerWithStore(store, opts) {
   if (!force) {
     for (const meta of store.getAllFileMetas()) existingMeta.set(meta.file, meta);
   }
+  let filesSinceLastYield = 0;
   for (let batchStart = 0; batchStart < files.length; batchStart += PARALLEL_BATCH) {
     const batchEnd = Math.min(batchStart + PARALLEL_BATCH, files.length);
     const batchFiles = files.slice(batchStart, batchEnd);
     opts.onProgress?.(batchEnd, files.length);
-    if (batchStart > 0 && batchStart % YIELD_EVERY_N === 0) {
+    filesSinceLastYield += batchFiles.length;
+    if (filesSinceLastYield >= YIELD_EVERY_N) {
+      filesSinceLastYield = 0;
       await yieldEventLoop();
       throwIfAborted(signal);
     }
@@ -11048,7 +11242,7 @@ async function indexService(args, hooks = {}) {
   });
 }
 function searchService(args) {
-  const store = new IndexStore(args.projectRoot, { indexDir: args.indexDir });
+  const store = indexStorePool.acquire(args.projectRoot, { indexDir: args.indexDir });
   try {
     return store.searchRanked(
       args.query,
@@ -11061,39 +11255,39 @@ function searchService(args) {
       args.limit
     );
   } finally {
-    store.close();
+    indexStorePool.release(store);
   }
 }
 function statsService(args) {
-  const store = new IndexStore(args.projectRoot, { indexDir: args.indexDir });
+  const store = indexStorePool.acquire(args.projectRoot, { indexDir: args.indexDir });
   try {
     return store.getStats();
   } finally {
-    store.close();
+    indexStorePool.release(store);
   }
 }
 function packageGraphService(args) {
-  const store = new IndexStore(args.projectRoot, { indexDir: args.indexDir });
+  const store = indexStorePool.acquire(args.projectRoot, { indexDir: args.indexDir });
   try {
     return store.getPackageGraph();
   } finally {
-    store.close();
+    indexStorePool.release(store);
   }
 }
 function fileGraphService(args) {
-  const store = new IndexStore(args.projectRoot, { indexDir: args.indexDir });
+  const store = indexStorePool.acquire(args.projectRoot, { indexDir: args.indexDir });
   try {
     return store.getFileGraph(args.packageFilter);
   } finally {
-    store.close();
+    indexStorePool.release(store);
   }
 }
 function symbolGraphService(args) {
-  const store = new IndexStore(args.projectRoot, { indexDir: args.indexDir });
+  const store = indexStorePool.acquire(args.projectRoot, { indexDir: args.indexDir });
   try {
     return store.getSymbolGraph(args.fileFilter);
   } finally {
-    store.close();
+    indexStorePool.release(store);
   }
 }
 
@@ -11210,10 +11404,19 @@ function terminateWorker(reason) {
   if (w) void w.terminate().catch(() => {
   });
 }
-function shutdownCodebaseIndexHost() {
+async function shutdownCodebaseIndexHost() {
   cancelPendingReindexes();
-  terminateWorker(new Error("codebase-index host shut down"));
+  indexStorePool.closeAll();
+  const w = worker;
+  worker = null;
+  failAllPending(new Error("codebase-index host shut down"));
   workerUnavailable = false;
+  if (w) {
+    try {
+      await w.terminate();
+    } catch {
+    }
+  }
 }
 function callIndexOp(op, args, opts) {
   const w = ensureWorker();
@@ -13212,7 +13415,244 @@ init_output_spool();
 init_util();
 init_process_registry();
 init_win32_resolve();
-var isWin3 = process.platform === "win32";
+
+// src/exec-kill-guard.ts
+import * as os7 from "node:os";
+import * as path24 from "node:path";
+var isWin3 = os7.platform() === "win32";
+async function checkExecKillCommand(cmd, args) {
+  if (!cmd) return { blocked: false };
+  const cmdLower = cmd.toLowerCase().trim();
+  const fullCommand = [cmdLower, ...args].join(" ").replace(/\s+/g, " ").trim();
+  if (isWin3) {
+    if (cmdLower === "taskkill" || cmdLower === "taskkill.exe") {
+      const hasForce = args.some((a) => a.toUpperCase() === "/F" || a.toUpperCase() === "-F");
+      const signal = hasForce ? "FORCE" : "TERM";
+      for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a.toUpperCase() === "/IM" || a.toUpperCase() === "-IM") {
+          const nameArg = args[i + 1];
+          if (nameArg) {
+            const result = await checkKillTarget({ name: nameArg, signal, cmd: fullCommand });
+            if (result.blocked) return result;
+          }
+        }
+      }
+      for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a.toUpperCase() === "/PID" || a.toUpperCase() === "-PID") {
+          const pidArg = args[i + 1];
+          if (pidArg && /^\d+$/.test(pidArg)) {
+            const result = await checkKillTarget({
+              pid: parseInt(pidArg, 10),
+              signal,
+              cmd: fullCommand
+            });
+            if (result.blocked) return result;
+          }
+        }
+      }
+      for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a.toUpperCase() === "/FI" || a.toUpperCase() === "-FI") {
+          const filterArg = args[i + 1];
+          if (filterArg) {
+            const nameMatch = filterArg.match(/IMAGENAME\s+eq\s+"?([^"\s]+)/i);
+            if (nameMatch?.[1]) {
+              const result = await checkKillTarget({ name: nameMatch[1], signal, cmd: fullCommand });
+              if (result.blocked) return result;
+            }
+          }
+        }
+      }
+      return { blocked: false };
+    }
+    if (cmdLower === "powershell" || cmdLower === "powershell.exe" || cmdLower === "pwsh" || cmdLower === "pwsh.exe" || cmdLower === "cmd" || cmdLower === "cmd.exe") {
+      const shellFlagIndex = args.findIndex((arg) => {
+        const lower = arg.toLowerCase();
+        return lower === "-c" || lower === "-command" || lower === "/c";
+      });
+      if (shellFlagIndex >= 0) {
+        const innerTokens = tokenizeShellCommand(args.slice(shellFlagIndex + 1).join(" "));
+        const innerCommand = innerTokens[0];
+        if (innerCommand) {
+          const result = await checkExecKillCommand(innerCommand, innerTokens.slice(1));
+          if (result.blocked) return result;
+        }
+      }
+    }
+    if (cmdLower === "stop-process" || cmdLower === "kill") {
+      for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "-Name" || a === "-n") {
+          const nameArg = args[i + 1]?.replace(/^['"]|['"]$/g, "");
+          if (nameArg) {
+            const result = await checkKillTarget({
+              name: nameArg,
+              signal: "FORCE",
+              cmd: fullCommand
+            });
+            if (result.blocked) return result;
+          }
+        }
+        if (a === "-Id" || a === "-PID" || a === "-pid") {
+          const pidArg = args[i + 1];
+          if (pidArg && /^\d+$/.test(pidArg)) {
+            const result = await checkKillTarget({
+              pid: parseInt(pidArg, 10),
+              signal: "FORCE",
+              cmd: fullCommand
+            });
+            if (result.blocked) return result;
+          }
+        }
+      }
+      const firstNonFlag = args.find((a) => !a.startsWith("-"));
+      if (firstNonFlag) {
+        const name = firstNonFlag.replace(/^['"]|['"]$/g, "");
+        const result = await checkKillTarget({ name, signal: "TERM", cmd: fullCommand });
+        if (result.blocked) return result;
+      }
+    }
+    if (cmdLower === "wmic" || cmdLower === "wmic.exe") {
+      const joined = args.join(" ").toLowerCase();
+      if (/\bprocess\b/.test(joined) && /\bdelete\b/.test(joined)) {
+        const nameMatch = joined.match(/name\s*=\s*['"]?([^'"]+)/);
+        if (nameMatch?.[1]) {
+          const result = await checkKillTarget({
+            name: nameMatch[1].trim(),
+            signal: "FORCE",
+            cmd: fullCommand
+          });
+          if (result.blocked) return result;
+        }
+        return {
+          blocked: true,
+          reason: "Blocked: wmic process delete targets all matched processes \u2014 would include protected WrongStack processes."
+        };
+      }
+    }
+    if (cmdLower === "node" || cmdLower === "node.exe") {
+      if (args.includes("-e") || args.includes("--eval")) {
+        const evalIdx = args.indexOf("-e") !== -1 ? args.indexOf("-e") : args.indexOf("--eval");
+        const evalCode = args[evalIdx + 1] ?? "";
+        if (/\bprocess\.kill\s*\(/.test(evalCode)) {
+          const pidMatch = evalCode.match(/process\.kill\s*\(\s*(\d+)/);
+          if (pidMatch?.[1]) {
+            const pid = parseInt(pidMatch[1], 10);
+            const result = await checkKillTarget({ pid, signal: "SIGTERM", cmd: fullCommand });
+            if (result.blocked) return result;
+          }
+          return {
+            blocked: true,
+            reason: "Blocked: node -e with process.kill() \u2014 would target protected WrongStack process(es)."
+          };
+        }
+      }
+    }
+  } else {
+    if (cmdLower === "kill") {
+      for (const a of args) {
+        const num = a.replace(/^-/, "");
+        if (/^\d+$/.test(num)) {
+          const pid = parseInt(num, 10);
+          const result = await checkKillTarget({ pid, signal: "SIGTERM", cmd: fullCommand });
+          if (result.blocked) return result;
+        }
+      }
+    }
+    if (cmdLower === "pkill" || cmdLower === "killall") {
+      const firstNonFlag = args.find((a) => !a.startsWith("-"));
+      if (firstNonFlag) {
+        const result = await checkKillTarget({
+          name: firstNonFlag,
+          signal: "SIGTERM",
+          cmd: fullCommand
+        });
+        if (result.blocked) return result;
+      }
+    }
+  }
+  return { blocked: false };
+}
+function tokenizeShellCommand(command) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  for (const char of command.trim()) {
+    if (quote) {
+      if (char === quote) quote = null;
+      else current += char;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+    } else if (/\s/.test(char)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current) tokens.push(current);
+  return tokens;
+}
+async function checkKillTarget(target) {
+  const registry = getPersistentProcessRegistry();
+  if (target.pid !== void 0) {
+    const blocked = await registry.shouldBlockKill(target.pid);
+    if (blocked) {
+      return {
+        blocked: true,
+        reason: `Blocked: kill ${target.signal} PID ${target.pid} targets a protected WrongStack process (${target.cmd.slice(0, 80)}).`
+      };
+    }
+    if (target.pid === process.pid) {
+      return {
+        blocked: true,
+        reason: "Blocked: cannot kill the current WrongStack process."
+      };
+    }
+    if (target.pid === process.ppid) {
+      return {
+        blocked: true,
+        reason: "Blocked: cannot kill the parent terminal hosting WrongStack."
+      };
+    }
+    return { blocked: false };
+  }
+  if (target.name) {
+    const nameLower = target.name.toLowerCase().replace(/\.exe$/, "");
+    if (nameLower.includes("wrongstack")) {
+      return {
+        blocked: true,
+        reason: `Blocked: kill ${target.signal} '${target.name}' targets a WrongStack process name.`
+      };
+    }
+    const currentImage = path24.basename(process.execPath).toLowerCase().replace(/\.exe$/, "");
+    const targetsNodeRuntime = nameLower === "node" || nameLower.startsWith("node");
+    if (targetsNodeRuntime && currentImage === "node") {
+      return {
+        blocked: true,
+        reason: `Blocked: kill ${target.signal} '${target.name}' would kill the active WrongStack node.exe runtime.`
+      };
+    }
+    const protectedPids = await registry.getAllProtectedPids();
+    if (protectedPids.length > 0 && targetsNodeRuntime) {
+      return {
+        blocked: true,
+        reason: `Blocked: kill ${target.signal} '${target.name}' would kill all node.exe processes including active WrongStack instance(s).`
+      };
+    }
+    return { blocked: false };
+  }
+  return { blocked: false };
+}
+
+// src/exec.ts
+var isWin4 = process.platform === "win32";
 var DEFAULT_ALLOWED_COMMANDS = /* @__PURE__ */ new Set([
   // JS / TS toolchain
   "node",
@@ -14017,6 +14457,19 @@ var execTool = {
     const args = (input.args ?? []).slice(0, MAX_ARGS);
     const timeout = Math.max(1, Math.min(input.timeout ?? DEFAULT_TIMEOUT_MS3, DEFAULT_TIMEOUT_MS3));
     const danger = detectDanger(cmd, args, dangerBypass);
+    const killCheck = await checkExecKillCommand(cmd, args);
+    if (killCheck.blocked) {
+      return {
+        command: cmd,
+        args,
+        stdout: "",
+        stderr: killCheck.reason ?? "Kill command blocked: targets a protected WrongStack process.",
+        exitCode: 1,
+        truncated: false,
+        allowed: false,
+        danger
+      };
+    }
     const argError = validateArgs(cmd, args);
     if (argError) {
       return {
@@ -14067,7 +14520,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
     let timedOut = false;
     const spool = createOutputSpool({ tool: `exec-${cmd}`, thresholdBytes: MAX_OUTPUT2 });
     const resolved = resolveWin32Command(cmd);
-    const needsShell = isWin3 && (resolved.endsWith(".cmd") || resolved.endsWith(".bat"));
+    const needsShell = isWin4 && (resolved.endsWith(".cmd") || resolved.endsWith(".bat"));
     const shim = needsShell ? buildWin32CmdShimInvocation(resolved, args) : null;
     const spawnCmd = shim?.command ?? resolved;
     const spawnArgs = shim?.args ?? args;
@@ -14092,7 +14545,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
         env: buildChildEnv2(sessionId),
         stdio: ["ignore", "pipe", "pipe"],
         windowsHide: true,
-        ...isWin3 ? {} : { signal },
+        ...isWin4 ? {} : { signal },
         ...shim ? { windowsVerbatimArguments: shim.windowsVerbatimArguments } : {}
       });
     } catch (err) {
@@ -14131,7 +14584,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
       const isAbort = err && err.code === "ABORT_ERR";
       const stderrText = isAbort ? `Aborted: ${err.message}` : err.message;
       clearTimeout(timer);
-      if (isWin3) signal.removeEventListener("abort", onAbort);
+      if (isWin4) signal.removeEventListener("abort", onAbort);
       if (typeof pid === "number") registry.unregister(pid);
       registry.afterCall(Date.now() - startedAt, true);
       spool.finalize();
@@ -14164,7 +14617,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
       if (typeof pid === "number") registry.kill(pid, { force: true });
       else child.kill("SIGTERM");
     };
-    if (isWin3) {
+    if (isWin4) {
       if (signal.aborted) onAbort();
       else signal.addEventListener("abort", onAbort, { once: true });
     }
@@ -14184,7 +14637,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      if (isWin3) signal.removeEventListener("abort", onAbort);
+      if (isWin4) signal.removeEventListener("abort", onAbort);
       if (typeof pid === "number") registry.unregister(pid);
       const durationMs = Date.now() - startedAt;
       const exitCode = killed ? 124 : code ?? 1;
@@ -14995,7 +15448,7 @@ function runGit2(args, cwd, signal) {
 
 // src/glob.ts
 import * as fs20 from "node:fs/promises";
-import * as path24 from "node:path";
+import * as path25 from "node:path";
 import { compileGlob as compileGlob3 } from "@wrongstack/core";
 
 // src/_concurrency.ts
@@ -15099,7 +15552,7 @@ var globTool = {
         if (DEFAULT_IGNORE2.includes(name)) continue;
         if (ignored.includes(name)) continue;
         const rel = relPrefix ? `${relPrefix}/${name}` : name;
-        const full = path24.join(dir, name);
+        const full = path25.join(dir, name);
         if (e.isDirectory()) {
           subdirs.push({ full, rel });
         } else if (e.isFile()) {
@@ -15143,7 +15596,7 @@ var globTool = {
 };
 async function readGitignore(dir) {
   try {
-    const raw = await fs20.readFile(path24.join(dir, ".gitignore"), "utf8");
+    const raw = await fs20.readFile(path25.join(dir, ".gitignore"), "utf8");
     return raw.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#"));
   } catch {
     return [];
@@ -15154,7 +15607,7 @@ async function readGitignore(dir) {
 import { expectDefined as expectDefined7 } from "@wrongstack/core";
 import { spawn as spawn10 } from "node:child_process";
 import * as fs21 from "node:fs/promises";
-import * as path25 from "node:path";
+import * as path26 from "node:path";
 import { buildChildEnv as buildChildEnv5, compileGlob as compileGlob4, ToolValidationError as ToolValidationError4 } from "@wrongstack/core";
 
 // src/_regex.ts
@@ -15547,7 +16000,7 @@ async function runNative(input, base, mode, limit, signal) {
       if (stopped) return;
       if (DEFAULT_IGNORE3.includes(e.name)) continue;
       if (e.isSymbolicLink()) continue;
-      const full = path25.join(dir, e.name);
+      const full = path26.join(dir, e.name);
       if (e.isDirectory()) {
         subdirs.push(full);
       } else if (e.isFile()) {
@@ -16135,56 +16588,56 @@ function jmespathSearch(data, query) {
 }
 function validateJsonSchema(data, schema) {
   const errors = [];
-  function check(value, s, path33) {
+  function check(value, s, path34) {
     if (s["type"]) {
       const expectedType = s["type"];
       const actualType = Array.isArray(value) ? "array" : value === null ? "null" : typeof value;
       if (expectedType === "integer") {
-        if (!Number.isInteger(value)) errors.push(`${path33}: expected integer, got ${actualType}`);
+        if (!Number.isInteger(value)) errors.push(`${path34}: expected integer, got ${actualType}`);
       } else if (expectedType !== actualType) {
-        errors.push(`${path33}: expected ${expectedType}, got ${actualType}`);
+        errors.push(`${path34}: expected ${expectedType}, got ${actualType}`);
       }
     }
     if (typeof value === "string" && s["format"] === "uri" && value) {
       try {
         new URL(value);
       } catch {
-        errors.push(`${path33}: not a valid URI`);
+        errors.push(`${path34}: not a valid URI`);
       }
     }
     if (typeof value === "string" && s["pattern"]) {
       const re = new RegExp(s["pattern"]);
-      if (!re.test(value)) errors.push(`${path33}: does not match pattern ${s["pattern"]}`);
+      if (!re.test(value)) errors.push(`${path34}: does not match pattern ${s["pattern"]}`);
     }
     if (typeof value === "string" && s["minLength"] !== void 0 && value.length < s["minLength"]) {
-      errors.push(`${path33}: string too short (min ${s["minLength"]})`);
+      errors.push(`${path34}: string too short (min ${s["minLength"]})`);
     }
     if (typeof value === "string" && s["maxLength"] !== void 0 && value.length > s["maxLength"]) {
-      errors.push(`${path33}: string too long (max ${s["maxLength"]})`);
+      errors.push(`${path34}: string too long (max ${s["maxLength"]})`);
     }
     if (typeof value === "number" && s["minimum"] !== void 0 && value < s["minimum"]) {
-      errors.push(`${path33}: below minimum ${s["minimum"]}`);
+      errors.push(`${path34}: below minimum ${s["minimum"]}`);
     }
     if (typeof value === "number" && s["maximum"] !== void 0 && value > s["maximum"]) {
-      errors.push(`${path33}: above maximum ${s["maximum"]}`);
+      errors.push(`${path34}: above maximum ${s["maximum"]}`);
     }
     if (Array.isArray(value) && s["items"] && Array.isArray(s["items"])) {
       for (let i = 0; i < value.length; i++) {
-        check(value[i], s["items"], `${path33}[${i}]`);
+        check(value[i], s["items"], `${path34}[${i}]`);
       }
     }
     if (typeof value === "object" && value !== null && !Array.isArray(value) && s["properties"]) {
       const props = s["properties"];
       for (const [k, propSchema] of Object.entries(props)) {
-        check(value[k], propSchema, `${path33}.${k}`);
+        check(value[k], propSchema, `${path34}.${k}`);
       }
     }
   }
   check(data, schema, "$");
   return { valid: errors.length === 0, errors };
 }
-function simpleQuery(data, path33) {
-  const parts = path33.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+function simpleQuery(data, path34) {
+  const parts = path34.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
   let current = data;
   for (const part of parts) {
     if (current === null || current === void 0) return void 0;
@@ -16252,7 +16705,7 @@ import {
   duplicateBoard,
   exportBoardAsMarkdown,
   exportBoardToTaskGraph,
-  generateBoardFromDescription,
+  createBoardFromText,
   getBoard as getBoard2,
   getKanbanOrchestrationSnapshot,
   getKanbanQueueHealth,
@@ -16287,7 +16740,7 @@ import {
 
 // src/session-kanban.ts
 import { watch } from "node:fs";
-import { basename as basename9, dirname as dirname13 } from "node:path";
+import { basename as basename10, dirname as dirname13 } from "node:path";
 import {
   deserializeTaskGraph,
   GlobalMailbox,
@@ -16317,12 +16770,17 @@ var SESSION_KANBAN_COLUMNS = [
 ];
 var boardQueue = /* @__PURE__ */ new Map();
 var boardEnsures = /* @__PURE__ */ new Map();
+var pendingMirrors = /* @__PURE__ */ new Map();
+var activeMirrors = /* @__PURE__ */ new Set();
 var bindings = /* @__PURE__ */ new WeakMap();
 var suppressedTodoMirrors = /* @__PURE__ */ new WeakSet();
 var activeSessionBoards = /* @__PURE__ */ new Map();
 function boardKey(projectRoot, sessionId) {
   return `${projectRoot}\0${sessionId}`;
 }
+function mirrorKey(projectRoot, sessionId, sourceSystem) {
+  return `${boardKey(projectRoot, sessionId)}\0${sourceSystem}`;
+}
 function sessionTag(sessionId) {
   return `session:${sessionId}`;
 }
@@ -16458,6 +16916,43 @@ async function projectGraph(projectRoot, sessionId, graph, sourceSystem) {
     return result?.board ?? null;
   });
 }
+function queueLatestMirror(projectRoot, sessionId, graph, sourceSystem) {
+  if (!projectRoot || !sessionId || process.env[MIRROR_DISABLED_ENV] === "0") return;
+  const key = mirrorKey(projectRoot, sessionId, sourceSystem);
+  pendingMirrors.set(key, { projectRoot, sessionId, graph, sourceSystem });
+  if (activeMirrors.has(key)) return;
+  activeMirrors.add(key);
+  void (async () => {
+    try {
+      for (; ; ) {
+        const pending2 = pendingMirrors.get(key);
+        if (!pending2) break;
+        pendingMirrors.delete(key);
+        try {
+          await projectGraph(
+            pending2.projectRoot,
+            pending2.sessionId,
+            pending2.graph,
+            pending2.sourceSystem
+          );
+        } catch {
+        }
+      }
+    } finally {
+      activeMirrors.delete(key);
+      const pending2 = pendingMirrors.get(key);
+      if (pending2) {
+        pendingMirrors.delete(key);
+        queueLatestMirror(
+          pending2.projectRoot,
+          pending2.sessionId,
+          pending2.graph,
+          pending2.sourceSystem
+        );
+      }
+    }
+  })();
+}
 function todoListToSerializedGraph(todos, sessionId) {
   const nodes = todos.map((todo, index) => ({
     id: todo.id,
@@ -16608,13 +17103,28 @@ Reassess your current plan before continuing; do not rely on the initial todo sn
   }
 }
 function mirrorSessionTodosToKanban(projectRoot, todos, sessionId) {
-  fireAndForget(projectSessionTodosToKanban(projectRoot, todos, sessionId));
+  queueLatestMirror(
+    projectRoot,
+    sessionId,
+    todoListToSerializedGraph(todos, sessionId),
+    "session-todo"
+  );
 }
 function mirrorSessionTasksToKanban(projectRoot, tasks, sessionId) {
-  fireAndForget(projectSessionTasksToKanban(projectRoot, tasks, sessionId));
+  queueLatestMirror(
+    projectRoot,
+    sessionId,
+    taskFileToSerializedGraph(tasks, sessionId),
+    "session-task"
+  );
 }
 function mirrorSessionPlanToKanban(projectRoot, items, sessionId) {
-  fireAndForget(projectSessionPlanToKanban(projectRoot, items, sessionId));
+  queueLatestMirror(
+    projectRoot,
+    sessionId,
+    planFileToSerializedGraph(items, sessionId),
+    "session-plan"
+  );
 }
 function attachSessionKanbanMirror(context) {
   const existing = bindings.get(context);
@@ -16712,8 +17222,8 @@ function attachSessionKanbanMirror(context) {
         const name = filename?.toString();
         const currentPlanPath = context.meta["plan.path"];
         const currentTaskPath = context.meta["task.path"];
-        const planName = typeof currentPlanPath === "string" ? basename9(currentPlanPath) : "";
-        const taskName = typeof currentTaskPath === "string" ? basename9(currentTaskPath) : "";
+        const planName = typeof currentPlanPath === "string" ? basename10(currentPlanPath) : "";
+        const taskName = typeof currentTaskPath === "string" ? basename10(currentTaskPath) : "";
         if (name && name !== planName && name !== taskName) return;
         if (timer) clearTimeout(timer);
         timer = setTimeout(() => fireAndForget(refreshFiles()), 60);
@@ -17158,7 +17668,7 @@ var kanbanTool = {
           }
           case "generate_board": {
             if (!input.description) return fail("generate_board requires description.");
-            const boardInput = generateBoardFromDescription({
+            const boardInput = createBoardFromText({
               description: input.description,
               ...input.title !== void 0 ? { title: input.title } : {},
               ...input.context !== void 0 ? { context: input.context } : {},
@@ -17543,20 +18053,31 @@ var kanbanTool = {
             if (!input.boardId || !input.taskId)
               return fail("mark_assignment requires boardId and taskId.");
             const assignmentStatus = input.assignmentStatus ?? (input.status === "completed" ? "completed" : input.error ? "failed" : void 0);
-            const board = await updateTaskAssignment(projectRoot, input.boardId, input.taskId, {
-              ...assignmentStatus !== void 0 ? { status: assignmentStatus } : {},
-              ...input.subagentId !== void 0 ? { subagentId: input.subagentId } : {},
-              ...input.runTaskId !== void 0 ? { runTaskId: input.runTaskId } : {},
-              ...input.lastResult !== void 0 ? { lastResult: input.lastResult } : {},
-              ...input.error !== void 0 ? { error: input.error } : {},
-              ...input.agentId !== void 0 ? { agentId: input.agentId } : {},
-              ...input.leaseId !== void 0 ? { leaseId: input.leaseId } : {},
-              ...input.claimedAt !== void 0 ? { claimedAt: input.claimedAt } : {},
-              ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
-              ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {},
-              ...input.attempt !== void 0 ? { attempt: input.attempt } : {},
-              ...input.maxAttempts !== void 0 ? { maxAttempts: input.maxAttempts } : {}
-            });
+            const board = await updateTaskAssignment(
+              projectRoot,
+              input.boardId,
+              input.taskId,
+              {
+                ...assignmentStatus !== void 0 ? { status: assignmentStatus } : {},
+                ...input.subagentId !== void 0 ? { subagentId: input.subagentId } : {},
+                ...input.runTaskId !== void 0 ? { runTaskId: input.runTaskId } : {},
+                ...input.lastResult !== void 0 ? { lastResult: input.lastResult } : {},
+                ...input.error !== void 0 ? { error: input.error } : {},
+                ...input.agentId !== void 0 ? { agentId: input.agentId } : {},
+                ...input.leaseId !== void 0 ? { leaseId: input.leaseId } : {},
+                ...input.claimedAt !== void 0 ? { claimedAt: input.claimedAt } : {},
+                ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
+                ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {},
+                ...input.attempt !== void 0 ? { attempt: input.attempt } : {},
+                ...input.maxAttempts !== void 0 ? { maxAttempts: input.maxAttempts } : {}
+              },
+              // Ownership fence: when expectedLeaseId is supplied, the write is
+              // applied only if the current assignment still holds this lease.
+              // This prevents a recovered+reassigned stale worker's terminal
+              // mark_assignment from overwriting the successor's state. The check
+              // is atomic inside updateTaskAssignment's mutateBoard lock.
+              input.expectedLeaseId !== void 0 ? { expectedLeaseId: input.expectedLeaseId } : {}
+            );
             return board ? okBoard(board, "Assignment updated.") : fail("Task not found.");
           }
           case "heartbeat_assignment": {
@@ -17565,7 +18086,13 @@ var kanbanTool = {
             }
             const board = await heartbeatTaskAssignment(projectRoot, input.boardId, input.taskId, {
               ...input.heartbeatAt !== void 0 ? { heartbeatAt: input.heartbeatAt } : {},
-              ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {}
+              ...input.leaseExpiresAt !== void 0 ? { leaseExpiresAt: input.leaseExpiresAt } : {},
+              // Ownership fence: when expectedLeaseId is supplied, the renewal
+              // is applied only if the current assignment still holds this lease.
+              // This prevents a recovered+reassigned stale worker's heartbeat
+              // from renewing the successor's lease. The check is atomic inside
+              // heartbeatTaskAssignment's mutateBoard lock.
+              ...input.expectedLeaseId !== void 0 ? { expectedLeaseId: input.expectedLeaseId } : {}
             });
             return board ? okBoard(board, "Assignment heartbeat updated.") : fail("Task assignment not found.");
           }
@@ -18156,7 +18683,7 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
 }
 var DOCKER_LOGS_TIMEOUT_MS = 3e3;
 var MAX_TAIL_LINES = 1e5;
-async function fileLogs(path33, lines, filterRe, stream) {
+async function fileLogs(path34, lines, filterRe, stream) {
   const { createInterface } = await import("node:readline");
   const { createReadStream: createReadStream2 } = await import("node:fs");
   const entries = [];
@@ -18165,7 +18692,7 @@ async function fileLogs(path33, lines, filterRe, stream) {
   let writeIdx = 0;
   let totalLines = 0;
   const rl = createInterface({
-    input: createReadStream2(path33),
+    input: createReadStream2(path34),
     crlfDelay: Number.POSITIVE_INFINITY
   });
   for await (const line of rl) {
@@ -18186,7 +18713,7 @@ async function fileLogs(path33, lines, filterRe, stream) {
     if (parsed) entries.push(parsed);
   }
   return {
-    source: path33,
+    source: path34,
     entries,
     total: entries.length,
     truncated: totalLines > effLines,
@@ -18417,8 +18944,8 @@ function parseOutdatedOutput(json2, exitCode) {
 init_util();
 import { spawn as spawn13 } from "node:child_process";
 import * as fs23 from "node:fs/promises";
-import * as os7 from "node:os";
-import * as path26 from "node:path";
+import * as os8 from "node:os";
+import * as path27 from "node:path";
 import { buildChildEnv as buildChildEnv8 } from "@wrongstack/core";
 var patchTool = {
   name: "patch",
@@ -18454,9 +18981,9 @@ var patchTool = {
     for (const t of targets) {
       const stripped = stripPathComponents(t, strip);
       if (!stripped) continue;
-      const candidate = path26.resolve(dir, stripped);
-      const rel = path26.relative(ctx.projectRoot, candidate);
-      if (rel.startsWith("..") || path26.isAbsolute(rel)) {
+      const candidate = path27.resolve(dir, stripped);
+      const rel = path27.relative(ctx.projectRoot, candidate);
+      if (rel.startsWith("..") || path27.isAbsolute(rel)) {
         return {
           applied: 0,
           rejected: 1,
@@ -18473,11 +19000,11 @@ var patchTool = {
         beforeContents.set(target, await readTextForTracking(target));
       }
     }
-    const tmpDir = await fs23.mkdtemp(path26.join(os7.tmpdir(), ".wstack_patch_"));
+    const tmpDir = await fs23.mkdtemp(path27.join(os8.tmpdir(), ".wstack_patch_"));
     try {
       await fs23.chmod(tmpDir, 448).catch(() => {
       });
-      const patchFile = path26.join(tmpDir, "in.diff");
+      const patchFile = path27.join(tmpDir, "in.diff");
       await fs23.writeFile(patchFile, input.patch, { mode: 384 });
       const args = [`-p${strip}`, "--merge", ...dryRun ? ["--dry-run"] : [], "-i", patchFile];
       const result = await runPatch(args, dir, opts.signal);
@@ -19063,7 +19590,7 @@ ${interesting.join("\n")}` : "symbols/imports: (none detected)"
 import { expectDefined as expectDefined8 } from "@wrongstack/core";
 import { spawn as spawn14 } from "node:child_process";
 import * as fs25 from "node:fs/promises";
-import * as path27 from "node:path";
+import * as path28 from "node:path";
 import {
   atomicWrite as atomicWrite3,
   buildChildEnv as buildChildEnv9,
@@ -19152,8 +19679,8 @@ var replaceTool = {
       } catch {
         continue;
       }
-      const rel = path27.relative(realRoot, realPath);
-      if (rel.startsWith("..") || path27.isAbsolute(rel)) continue;
+      const rel = path28.relative(realRoot, realPath);
+      if (rel.startsWith("..") || path28.isAbsolute(rel)) continue;
       const stat18 = await fs25.stat(realPath).catch(() => null);
       if (!stat18?.isFile()) continue;
       let content;
@@ -19282,7 +19809,7 @@ async function globNative(pattern, base, extraGlob) {
     }
     for (const e of entries) {
       if (DEFAULT_IGNORE4.includes(e.name)) continue;
-      const full = path27.join(dir, e.name);
+      const full = path28.join(dir, e.name);
       try {
         const stat18 = await fs25.lstat(full);
         if (stat18.isSymbolicLink()) continue;
@@ -19309,7 +19836,7 @@ async function globNative(pattern, base, extraGlob) {
 // src/scaffold.ts
 init_util();
 import * as fs26 from "node:fs/promises";
-import * as path28 from "node:path";
+import * as path29 from "node:path";
 import { atomicWrite as atomicWrite4 } from "@wrongstack/core";
 var BUILT_IN_TEMPLATES = {
   "npm-package": {
@@ -19459,16 +19986,16 @@ async function handleBuiltIn(name, templateFiles, cwd, ctx, dryRun, vars) {
   let filesCreated = 0;
   for (const [filePath, content] of Object.entries(templateFiles)) {
     const resolvedPath = substituteVars(filePath, name, vars);
-    const joinedPath = path28.join(cwd, resolvedPath);
-    const root = path28.resolve(ctx.projectRoot);
-    const target = path28.resolve(joinedPath);
-    const rel = path28.relative(root, target);
-    if (rel.startsWith("..") || path28.isAbsolute(rel)) {
+    const joinedPath = path29.join(cwd, resolvedPath);
+    const root = path29.resolve(ctx.projectRoot);
+    const target = path29.resolve(joinedPath);
+    const rel = path29.relative(root, target);
+    if (rel.startsWith("..") || path29.isAbsolute(rel)) {
       throw new Error(`scaffold: generated path "${resolvedPath}" would escape project root`);
     }
     const fullPath = target;
     if (!dryRun) {
-      await fs26.mkdir(path28.dirname(fullPath), { recursive: true });
+      await fs26.mkdir(path29.dirname(fullPath), { recursive: true });
       await atomicWrite4(fullPath, substituteVars(content, name, vars));
     }
     files.push(resolvedPath);
@@ -20325,7 +20852,7 @@ ${formatTaskList2(file.tasks)}` : file.tasks.length > 0 ? formatTaskList2(file.t
 init_spawn_stream();
 init_util();
 init_legacy_bridge();
-import * as path29 from "node:path";
+import * as path30 from "node:path";
 var testTool = {
   name: "test",
   category: "Code Quality",
@@ -20432,7 +20959,7 @@ async function detectRunner(cwd) {
   const candidates = ["vitest.config.ts", "jest.config.js", ".mocharc.json"];
   for (const f of candidates) {
     try {
-      await stat18(path29.join(cwd, f));
+      await stat18(path30.join(cwd, f));
       if (f.includes("vitest")) return "vitest";
       if (f.includes("jest")) return "jest";
       if (f.includes("mocha")) return "mocha";
@@ -20903,7 +21430,7 @@ var toolUseTool = {
 init_util();
 import { expectDefined as expectDefined10 } from "@wrongstack/core";
 import * as fs28 from "node:fs/promises";
-import * as path30 from "node:path";
+import * as path31 from "node:path";
 var DEFAULT_IGNORE5 = [
   "node_modules",
   ".git",
@@ -21074,7 +21601,7 @@ async function walkDir(dir, depth, opts) {
     opts.lines.push(opts.prefix + branch + displayName);
     if (entry.isDirectory() && (opts.maxDepth === 0 || depth < opts.maxDepth)) {
       const childPrefix = opts.prefix + connector;
-      await walkDir(path30.join(dir, entry.name), depth + 1, {
+      await walkDir(path31.join(dir, entry.name), depth + 1, {
         ...opts,
         prefix: childPrefix,
         isLast
@@ -21087,7 +21614,7 @@ async function walkDir(dir, depth, opts) {
 init_spawn_stream();
 init_util();
 init_legacy_bridge();
-import * as path31 from "node:path";
+import * as path32 from "node:path";
 var typecheckTool = {
   name: "typecheck",
   category: "Code Quality",
@@ -21190,8 +21717,8 @@ async function findTsConfig(cwd) {
   const candidates = ["tsconfig.json", "tsconfig.base.json"];
   for (const f of candidates) {
     try {
-      const s = await stat18(path31.join(cwd, f));
-      if (s.isFile()) return path31.join(cwd, f);
+      const s = await stat18(path32.join(cwd, f));
+      if (s.isFile()) return path32.join(cwd, f);
     } catch {
     }
   }
@@ -21724,7 +22251,7 @@ var builtinToolsPack = {
 };
 
 // src/process-guardian.ts
-import * as os8 from "node:os";
+import * as os9 from "node:os";
 var ProcessGuardian = class {
   registry;
   config;
@@ -21763,7 +22290,7 @@ var ProcessGuardian = class {
       event: "process_guardian.started",
       instanceId: this.instanceId,
       mainPid: process.pid,
-      hostname: os8.hostname(),
+      hostname: os9.hostname(),
       platform: process.platform
     }));
   }
@@ -21952,8 +22479,8 @@ var ProcessGuardian = class {
       instanceId: this.instanceId,
       mainPid: process.pid,
       protectedCount: this.protectedProcesses.size,
-      platform: os8.platform(),
-      hostname: os8.hostname(),
+      platform: os9.platform(),
+      hostname: os9.hostname(),
       uptime: process.uptime()
     };
   }
@@ -21982,7 +22509,7 @@ function stopProcessGuardian() {
 init_process_registry();
 
 // src/ps-slash.ts
-import * as os9 from "node:os";
+import * as os10 from "node:os";
 var IDLE_THRESHOLD_MS = 2 * 6e4;
 var STALE_THRESHOLD_MS2 = 5 * 6e4;
 function now() {
@@ -22023,7 +22550,7 @@ async function listInstances(options = {}) {
     const mainProc = processes.find((p) => p.spawnMode === "main");
     const firstProc = processes.at(0);
     const mainPid = mainProc?.pid ?? firstProc?.pid ?? 0;
-    const hostname_ = firstProc?.hostname ?? os9.hostname();
+    const hostname_ = firstProc?.hostname ?? os10.hostname();
     const startedAt = Math.min(...processes.map((p) => p.startedAt));
     const lastActivity = Math.max(...processes.map((p) => p.lastHeartbeat));
     const age = timestamp - lastActivity;
@@ -22111,7 +22638,7 @@ async function getGlobalProcessStatus() {
       mainPid: process.pid,
       protectedCount: 0,
       platform: process.platform,
-      hostname: os9.hostname(),
+      hostname: os10.hostname(),
       uptime: 0
     },
     allInstances: instances.map((inst) => ({
@@ -22296,7 +22823,7 @@ function createGlobalPsSlashCommand() {
 
 // src/skill.ts
 import * as fs30 from "node:fs/promises";
-import * as path32 from "node:path";
+import * as path33 from "node:path";
 import {
   SKILL_LIMITS,
   stripFrontmatter,
@@ -22343,7 +22870,7 @@ function makeSkillTool(skillLoader) {
           field: "name"
         });
       }
-      const dir = path32.dirname(manifest.path);
+      const dir = path33.dirname(manifest.path);
       let loadedResource;
       if (input.resource?.trim()) {
         loadedResource = await loadResource(dir, input.resource.trim());
@@ -22393,15 +22920,15 @@ ${listing}`;
 }
 async function loadResource(skillDir, rel) {
   const norm = rel.replace(/\\/g, "/");
-  if (path32.isAbsolute(rel) || norm.split("/").some((seg) => seg === "..")) {
+  if (path33.isAbsolute(rel) || norm.split("/").some((seg) => seg === "..")) {
     throw new ToolValidationError10({
       message: `skill: invalid resource path "${rel}"`,
       field: "resource"
     });
   }
-  const absPath = path32.resolve(skillDir, rel);
-  const root = path32.resolve(skillDir);
-  if (absPath !== root && !absPath.startsWith(root + path32.sep)) {
+  const absPath = path33.resolve(skillDir, rel);
+  const root = path33.resolve(skillDir);
+  if (absPath !== root && !absPath.startsWith(root + path33.sep)) {
     throw new ToolValidationError10({
       message: `skill: resource "${rel}" escapes the skill directory`,
       field: "resource"
@@ -22442,7 +22969,7 @@ async function walk(root, dir, out) {
   }
   for (const e of entries) {
     if (out.length >= MAX_LISTED_RESOURCES) return;
-    const fullPath = path32.join(dir, e.name);
+    const fullPath = path33.join(dir, e.name);
     let isDir = e.isDirectory();
     if (e.isSymbolicLink()) {
       try {
@@ -22458,7 +22985,7 @@ async function walk(root, dir, out) {
       if (e.name === "SKILL.md" || e.name === "SKILL.save.md") continue;
       try {
         const stat18 = await fs30.stat(fullPath);
-        const rel = path32.relative(root, fullPath).split(path32.sep).join("/");
+        const rel = path33.relative(root, fullPath).split(path33.sep).join("/");
         out.push({ path: rel, bytes: stat18.size });
       } catch {
       }
@@ -22681,6 +23208,7 @@ export {
   builtinTools,
   builtinToolsPack,
   cancelPendingReindexes,
+  checkExecKillCommand,
   codebaseIndexStats,
   codebaseIndexTool,
   codebaseSearchTool,