@wrongstack/tools 0.307.1 → 0.308.1

package/dist/pack.js

@@ -1031,8 +1031,8 @@ async function* spawnStream(opts) {
   try {
     for (; ; ) {
       while (queue.length === 0) {
-        await new Promise((resolve23) => {
-          waiter = resolve23;
+        await new Promise((resolve24) => {
+          waiter = resolve24;
         });
       }
       const chunk = queue.shift();
@@ -1135,9 +1135,9 @@ async function detectPackageManager(cwd, stopAt) {
   return "npm";
 }
 async function detectPackageManagerInDir(dir) {
-  const fs43 = await import("node:fs/promises");
+  const fs44 = await import("node:fs/promises");
   try {
-    const raw = await fs43.readFile(path3.join(dir, "package.json"), "utf8");
+    const raw = await fs44.readFile(path3.join(dir, "package.json"), "utf8");
     const declared = JSON.parse(raw).packageManager;
     if (typeof declared === "string") {
       const name = declared.split("@")[0] ?? "";
@@ -1156,7 +1156,7 @@ async function detectPackageManagerInDir(dir) {
   ];
   for (const [file, manager] of lockfiles) {
     try {
-      await fs43.stat(`${dir}/${file}`);
+      await fs44.stat(`${dir}/${file}`);
       return manager;
     } catch {
     }
@@ -4137,15 +4137,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 path49 of after) {
-    if (!beforeSet.has(path49)) changed.add(path49);
+  for (const path50 of after) {
+    if (!beforeSet.has(path50)) changed.add(path50);
   }
-  for (const path49 of before) {
-    if (!afterSet.has(path49)) changed.add(path49);
+  for (const path50 of before) {
+    if (!afterSet.has(path50)) changed.add(path50);
   }
   if (beforeSizes && afterSizes) {
-    for (const path49 of after) {
-      if (beforeSizes.get(path49) !== afterSizes.get(path49)) changed.add(path49);
+    for (const path50 of after) {
+      if (beforeSizes.get(path50) !== afterSizes.get(path50)) changed.add(path50);
     }
   }
   return [...changed].sort();
@@ -5640,7 +5640,7 @@ async function syncGoParse(filePath, content, lang) {
     }
     const goBinary = resolveWin32Command("go");
     const goResult = await new Promise(
-      (resolve23, reject) => {
+      (resolve24, reject) => {
         let settled = false;
         const proc = spawn5(goBinary, ["run", scriptPath], {
           stdio: ["pipe", "pipe", "pipe"],
@@ -5669,7 +5669,7 @@ async function syncGoParse(filePath, content, lang) {
           if (settled) return;
           settled = true;
           clearTimeout(timer);
-          resolve23({ code: code2, stdout: stdout2 });
+          resolve24({ code: code2, stdout: stdout2 });
         });
       }
     );
@@ -6345,7 +6345,7 @@ async function resolvePython() {
   return null;
 }
 function commandIsAvailable(command) {
-  return new Promise((resolve23) => {
+  return new Promise((resolve24) => {
     let settled = false;
     const proc = spawn6(command, ["--version"], {
       stdio: "ignore",
@@ -6355,7 +6355,7 @@ function commandIsAvailable(command) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve23(available);
+      resolve24(available);
     };
     const timer = setTimeout(() => {
       proc.kill("SIGKILL");
@@ -6367,7 +6367,7 @@ function commandIsAvailable(command) {
   });
 }
 function spawnPyParser(pyBinary, scriptPath, filePath, content) {
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve24, reject) => {
     let settled = false;
     const proc = spawn6(pyBinary, [scriptPath, filePath], {
       stdio: ["pipe", "pipe", "pipe"],
@@ -6396,7 +6396,7 @@ function spawnPyParser(pyBinary, scriptPath, filePath, content) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve23({ code, stdout });
+      resolve24({ code, stdout });
     });
   });
 }
@@ -8604,6 +8604,18 @@ function parseKillCommand(command) {
         originalCommand: command
       };
     }
+    const wmicPidMatch = normalized.match(
+      /^wmic\s+process\s+where\s+['"]?processid\s*=\s*['"]?(\d+)/i
+    );
+    if (wmicPidMatch?.[1]) {
+      return {
+        pid: parseInt(wmicPidMatch[1], 10),
+        signal: "FORCE",
+        isGroupKill: false,
+        isAllKill: false,
+        originalCommand: command
+      };
+    }
     const killScriptMatch = normalized.match(SCRIPT_KILL_RE);
     if (killScriptMatch) {
       return {
@@ -8723,7 +8735,9 @@ async function isKillProtected(kill) {
     return protectedPids.length > 0;
   }
   if (kill.pid !== void 0) {
-    return registry.shouldBlockKill(kill.pid);
+    if (await registry.shouldBlockKill(kill.pid)) return true;
+    if (kill.pid === process.pid || kill.pid === process.ppid) return true;
+    return false;
   }
   return false;
 }
@@ -8770,8 +8784,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";
@@ -9230,10 +9244,10 @@ var bashTool = {
         queue.push(c);
       }
     };
-    const next = () => new Promise((resolve23) => {
+    const next = () => new Promise((resolve24) => {
       const c = queue.shift();
-      if (c) resolve23(c);
-      else resolveNext = resolve23;
+      if (c) resolve24(c);
+      else resolveNext = resolve24;
     });
     let lastFlush = Date.now();
     const flush = () => {
@@ -9696,11 +9710,11 @@ var BrowserArtifactStore = class {
 };
 async function hashFile(target) {
   const hash = createHash3("sha256");
-  await new Promise((resolve23, reject) => {
+  await new Promise((resolve24, reject) => {
     const stream = createReadStream(target);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.once("error", reject);
-    stream.once("end", resolve23);
+    stream.once("end", resolve24);
   });
   return hash.digest("hex");
 }
@@ -9850,7 +9864,7 @@ var BrowserNetworkGuardProxy = class {
   async start() {
     if (this.url) return this.url;
     if (this.startPromise) return this.startPromise;
-    this.startPromise = new Promise((resolve23, reject) => {
+    this.startPromise = new Promise((resolve24, reject) => {
       const onError = (error) => {
         this.server.off("listening", onListening);
         reject(error);
@@ -9863,7 +9877,7 @@ var BrowserNetworkGuardProxy = class {
           return;
         }
         this.url = `http://127.0.0.1:${address.port}`;
-        resolve23(this.url);
+        resolve24(this.url);
       };
       this.server.once("error", onError);
       this.server.once("listening", onListening);
@@ -9878,7 +9892,7 @@ var BrowserNetworkGuardProxy = class {
     for (const socket of this.sockets) socket.destroy();
     this.sockets.clear();
     if (!this.server.listening) return;
-    await new Promise((resolve23) => this.server.close(() => resolve23()));
+    await new Promise((resolve24) => this.server.close(() => resolve24()));
   }
   async forwardHttp(request2, response) {
     try {
@@ -10451,7 +10465,7 @@ function pushBounded(target, value, limit) {
 }
 async function abortable(signal, operation, onAbort) {
   signal.throwIfAborted();
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve24, reject) => {
     let settled = false;
     let aborting = false;
     const finish = (fn) => {
@@ -10469,7 +10483,7 @@ async function abortable(signal, operation, onAbort) {
     signal.addEventListener("abort", abort, { once: true });
     operation().then(
       (value) => {
-        if (!aborting) finish(() => resolve23(value));
+        if (!aborting) finish(() => resolve24(value));
       },
       (err) => {
         if (!aborting) finish(() => reject(err));
@@ -13996,8 +14010,8 @@ function isProjectIndexServerHealth(value) {
   return typeof health.checkedAt === "number" && typeof health.uptimeMs === "number" && typeof memory?.rss === "number" && typeof memory.heapUsed === "number" && typeof memory.heapTotal === "number" && typeof memory.external === "number" && typeof health.clients === "number" && typeof health.activeRequests === "number" && typeof health.activeWrites === "number" && typeof health.queuedWrites === "number" && typeof health.pendingExternalFiles === "number" && typeof health.watchingExternal === "boolean" && typeof activity?.indexing === "boolean" && typeof activity.currentFile === "number" && typeof activity.totalFiles === "number" && typeof activity.generation === "number";
 }
 function delay(ms) {
-  return new Promise((resolve23) => {
-    const timer = setTimeout(resolve23, ms);
+  return new Promise((resolve24) => {
+    const timer = setTimeout(resolve24, ms);
     timer.unref?.();
   });
 }
@@ -14203,7 +14217,7 @@ var ProjectServerConnection = class {
       return Promise.reject(new Error("codebase-index server connection is not available"));
     }
     const id = this.nextId++;
-    return new Promise((resolve23, reject) => {
+    return new Promise((resolve24, reject) => {
       const timer = setTimeout(() => {
         const entry = this.pending.get(id);
         if (!entry) return;
@@ -14226,7 +14240,7 @@ var ProjectServerConnection = class {
         entry.reject(cancellationError(signal));
       } : void 0;
       this.pending.set(id, {
-        resolve: resolve23,
+        resolve: resolve24,
         reject,
         timer,
         signal,
@@ -14295,7 +14309,7 @@ var ProjectServerConnection = class {
     this.binaryBuffer = [];
     this.useBinary = false;
     this.textDecoder = null;
-    return new Promise((resolve23, reject) => {
+    return new Promise((resolve24, reject) => {
       const socket = net3.createConnection(this.endpoint);
       this.socket = socket;
       const timer = setTimeout(() => {
@@ -14307,7 +14321,7 @@ var ProjectServerConnection = class {
         clearTimeout(timer);
         this.connectResolve = null;
         this.connectReject = null;
-        resolve23();
+        resolve24();
       };
       const finishReject = (error) => {
         clearTimeout(timer);
@@ -15321,9 +15335,9 @@ var ParserWorkerPool = class {
     for (let i = 0; i < files.length; i++) {
       chunks[i % workerCount].push(files[i]);
     }
-    return new Promise((resolve23, reject) => {
+    return new Promise((resolve24, reject) => {
       this.pending.set(batchId, {
-        resolve: resolve23,
+        resolve: resolve24,
         reject,
         accumulated: [],
         expectedWorkers: workerCount,
@@ -15354,10 +15368,10 @@ var ParserWorkerPool = class {
     await Promise.allSettled(
       workers.map(
         (w) => Promise.race([
-          new Promise((resolve23) => {
-            w.once("exit", () => resolve23());
+          new Promise((resolve24) => {
+            w.once("exit", () => resolve24());
           }),
-          new Promise((resolve23) => setTimeout(() => resolve23(), 2e3))
+          new Promise((resolve24) => setTimeout(() => resolve24(), 2e3))
         ]).then(() => {
           if (!w.threadId) return;
           return w.terminate().catch(() => {
@@ -15418,7 +15432,7 @@ function shouldUseParserWorkerPool(candidateFileCount, parseBatchCount) {
   return !isFrugalPerf() && candidateFileCount >= WORKER_POOL_THRESHOLD && parseBatchCount > 1;
 }
 function yieldEventLoop() {
-  return new Promise((resolve23) => setImmediate(resolve23));
+  return new Promise((resolve24) => setImmediate(resolve24));
 }
 function throwIfAborted(signal) {
   if (!signal?.aborted) return;
@@ -15450,7 +15464,7 @@ function normalizeComparablePath(value) {
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function gitOutput(projectRoot, args) {
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve24, reject) => {
     execFile(
       "git",
       ["-C", projectRoot, ...args],
@@ -15461,7 +15475,7 @@ function gitOutput(projectRoot, args) {
       },
       (error, stdout) => {
         if (error) reject(error);
-        else resolve23(Buffer.isBuffer(stdout) ? stdout : Buffer.from(stdout));
+        else resolve24(Buffer.isBuffer(stdout) ? stdout : Buffer.from(stdout));
       }
     );
   });
@@ -16237,7 +16251,7 @@ function callIndexOp(op, args, opts) {
       opts.signal.reason instanceof Error ? opts.signal.reason : new Error("Indexing cancelled")
     );
   }
-  return new Promise((resolve23, reject) => {
+  return new Promise((resolve24, reject) => {
     const id = nextRpcId++;
     const timer = setTimeout(() => {
       pending.delete(id);
@@ -16259,7 +16273,7 @@ function callIndexOp(op, args, opts) {
     pending.set(id, {
       resolve: (v) => {
         cleanup();
-        resolve23(v);
+        resolve24(v);
       },
       reject: (e) => {
         cleanup();
@@ -19792,7 +19806,7 @@ function findGitDir(cwd) {
   return null;
 }
 function runGit(args, cwd, signal) {
-  return new Promise((resolve23) => {
+  return new Promise((resolve24) => {
     let stdout = "";
     let stderr = "";
     const child = spawn7("git", args, {
@@ -19808,8 +19822,8 @@ function runGit(args, cwd, signal) {
     child.stderr?.on("data", (c) => {
       stderr += c.toString();
     });
-    child.on("close", (code) => resolve23({ stdout, stderr, exitCode: code ?? 0 }));
-    child.on("error", (e) => resolve23({ stdout: "", stderr: e.message, exitCode: 1 }));
+    child.on("close", (code) => resolve24({ stdout, stderr, exitCode: code ?? 0 }));
+    child.on("error", (e) => resolve24({ stdout: "", stderr: e.message, exitCode: 1 }));
   });
 }
 async function fileDiff(input, ctx, _signal) {
@@ -21024,6 +21038,40 @@ var RULES = [
     },
     reason: "Remove-Item with -Recurse -Force"
   },
+  // ----- Windows PowerShell Disk & Volume destruction -----
+  {
+    id: "powershell-disk-volume-destroy",
+    level: "destructive",
+    test: (cmd, args) => {
+      if (cmd !== "powershell" && cmd !== "pwsh") return false;
+      return args.some(
+        (a) => /^(?:Format-Volume|Clear-Disk|Initialize-Disk|Remove-Partition|Clear-Volume)(?:\s|$)/i.test(a)
+      );
+    },
+    reason: "PowerShell disk/volume partition destruction"
+  },
+  // ----- Windows PowerShell System Restart / Shutdown -----
+  {
+    id: "powershell-stop-restart-computer",
+    level: "destructive",
+    test: (cmd, args) => {
+      if (cmd !== "powershell" && cmd !== "pwsh") return false;
+      return args.some((a) => /^(?:Stop-Computer|Restart-Computer)(?:\s|$)/i.test(a));
+    },
+    reason: "PowerShell system shutdown or restart"
+  },
+  // ----- Windows PowerShell ExecutionPolicy / Payload evasion -----
+  {
+    id: "powershell-execution-policy-bypass",
+    level: "caution",
+    test: (cmd, args) => {
+      if (cmd !== "powershell" && cmd !== "pwsh") return false;
+      return args.some(
+        (a) => /Set-ExecutionPolicy\s+(?:Bypass|Unrestricted)|-(?:EncodedCommand|enc)\b/i.test(a)
+      );
+    },
+    reason: "PowerShell execution policy bypass or encoded command"
+  },
   // ----- find -exec / -ok / -execdir -----
   {
     id: "find-exec",
@@ -22444,7 +22492,7 @@ var execTool = {
   }
 };
 function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
-  return new Promise((resolve23) => {
+  return new Promise((resolve24) => {
     let stdout = "";
     let stderr = "";
     let killed = false;
@@ -22452,7 +22500,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
     const finish = (result) => {
       if (resolvedOnce.value) return;
       resolvedOnce.value = true;
-      resolve23(result);
+      resolve24(result);
     };
     const startedAt = Date.now();
     let stdoutBytes = 0;
@@ -23128,10 +23176,10 @@ function parseFormatterCounts(fixer, output) {
   };
 }
 async function detectFixer(cwd) {
-  const fs43 = await import("node:fs/promises");
+  const fs44 = await import("node:fs/promises");
   const exists = async (file) => {
     try {
-      await fs43.stat(`${cwd}/${file}`);
+      await fs44.stat(`${cwd}/${file}`);
       return true;
     } catch {
       return false;
@@ -23154,7 +23202,7 @@ async function detectFixer(cwd) {
     if (await exists(cfg)) return "prettier";
   }
   try {
-    const raw = await fs43.readFile(`${cwd}/package.json`, "utf8");
+    const raw = await fs44.readFile(`${cwd}/package.json`, "utf8");
     const pkg = JSON.parse(raw);
     if (pkg["prettier"] !== void 0) return "prettier";
   } catch {
@@ -23422,7 +23470,7 @@ function buildArgs(input) {
   }
 }
 function runGit2(args, cwd, signal) {
-  return new Promise((resolve23) => {
+  return new Promise((resolve24) => {
     let stdout = "";
     let stderr = "";
     const child = spawn9("git", args, {
@@ -23443,7 +23491,7 @@ function runGit2(args, cwd, signal) {
       }
     });
     child.on("error", (err) => {
-      resolve23({
+      resolve24({
         command: args[0],
         stdout: normalizeCommandOutput(stdout),
         stderr: err.message,
@@ -23452,7 +23500,7 @@ function runGit2(args, cwd, signal) {
       });
     });
     child.on("close", (code) => {
-      resolve23({
+      resolve24({
         command: args[0],
         stdout: normalizeCommandOutput(stdout),
         stderr: normalizeCommandOutput(stderr),
@@ -23865,7 +23913,7 @@ var grepTool = {
 };
 var rgAvailabilityCache;
 function detectRg() {
-  rgAvailabilityCache ??= new Promise((resolve23) => {
+  rgAvailabilityCache ??= new Promise((resolve24) => {
     try {
       const p = spawn10("rg", ["--version"], {
         env: buildChildEnv5(),
@@ -23873,10 +23921,10 @@ function detectRg() {
         signal: AbortSignal.timeout(1e4),
         windowsHide: true
       });
-      p.on("error", () => resolve23(false));
-      p.on("close", (code) => resolve23(code === 0));
+      p.on("error", () => resolve24(false));
+      p.on("close", (code) => resolve24(code === 0));
     } catch {
-      resolve23(false);
+      resolve24(false);
     }
   });
   return rgAvailabilityCache;
@@ -24918,60 +24966,60 @@ function jmespathSearch(data, query) {
 }
 function validateJsonSchema(data, schema) {
   const errors = [];
-  function check(value, s, path49) {
+  function check(value, s, path50) {
     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(`${path49}: expected integer, got ${actualType}`);
+        if (!Number.isInteger(value)) errors.push(`${path50}: expected integer, got ${actualType}`);
       } else if (expectedType !== actualType) {
-        errors.push(`${path49}: expected ${expectedType}, got ${actualType}`);
+        errors.push(`${path50}: expected ${expectedType}, got ${actualType}`);
       }
     }
     if (typeof value === "string" && s["format"] === "uri" && value) {
       try {
         new URL(value);
       } catch {
-        errors.push(`${path49}: not a valid URI`);
+        errors.push(`${path50}: not a valid URI`);
       }
     }
     if (typeof value === "string" && s["pattern"]) {
       const compiled = compileUserRegex(s["pattern"], "");
       if (!compiled.ok) {
-        errors.push(`${path49}: invalid schema pattern \u2014 ${compiled.reason}`);
+        errors.push(`${path50}: invalid schema pattern \u2014 ${compiled.reason}`);
       } else if (!compiled.regex.test(capSubject(value))) {
-        errors.push(`${path49}: does not match pattern ${s["pattern"]}`);
+        errors.push(`${path50}: does not match pattern ${s["pattern"]}`);
       }
     }
     if (typeof value === "string" && s["minLength"] !== void 0 && value.length < s["minLength"]) {
-      errors.push(`${path49}: string too short (min ${s["minLength"]})`);
+      errors.push(`${path50}: string too short (min ${s["minLength"]})`);
     }
     if (typeof value === "string" && s["maxLength"] !== void 0 && value.length > s["maxLength"]) {
-      errors.push(`${path49}: string too long (max ${s["maxLength"]})`);
+      errors.push(`${path50}: string too long (max ${s["maxLength"]})`);
     }
     if (typeof value === "number" && s["minimum"] !== void 0 && value < s["minimum"]) {
-      errors.push(`${path49}: below minimum ${s["minimum"]}`);
+      errors.push(`${path50}: below minimum ${s["minimum"]}`);
     }
     if (typeof value === "number" && s["maximum"] !== void 0 && value > s["maximum"]) {
-      errors.push(`${path49}: above maximum ${s["maximum"]}`);
+      errors.push(`${path50}: 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"], `${path49}[${i}]`);
+        check(value[i], s["items"], `${path50}[${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, `${path49}.${k}`);
+        check(value[k], propSchema, `${path50}.${k}`);
       }
     }
   }
   check(data, schema, "$");
   return { valid: errors.length === 0, errors };
 }
-function simpleQuery(data, path49) {
-  const parts = path49.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+function simpleQuery(data, path50) {
+  const parts = path50.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
   let current = data;
   for (const part of parts) {
     if (current === null || current === void 0) return void 0;
@@ -27643,7 +27691,7 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
     };
   }
   args.push("--timestamps", service);
-  return new Promise((resolve23) => {
+  return new Promise((resolve24) => {
     let stdout = "";
     let stderr = "";
     const MAX = 2e5;
@@ -27659,7 +27707,7 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve23(result);
+      resolve24(result);
     };
     const child = spawn11("docker", args, {
       cwd,
@@ -27704,7 +27752,7 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
 }
 var DOCKER_LOGS_TIMEOUT_MS = 3e3;
 var MAX_TAIL_LINES = 1e5;
-async function fileLogs(path49, lines, filterRe) {
+async function fileLogs(path50, lines, filterRe) {
   const { createInterface } = await import("node:readline");
   const { createReadStream: createReadStream2 } = await import("node:fs");
   const entries = [];
@@ -27713,7 +27761,7 @@ async function fileLogs(path49, lines, filterRe) {
   let writeIdx = 0;
   let totalLines = 0;
   const rl = createInterface({
-    input: createReadStream2(path49),
+    input: createReadStream2(path50),
     crlfDelay: Number.POSITIVE_INFINITY
   });
   for await (const line of rl) {
@@ -27734,7 +27782,7 @@ async function fileLogs(path49, lines, filterRe) {
     if (parsed) entries.push(parsed);
   }
   return {
-    source: path49,
+    source: path50,
     entries,
     total: entries.length,
     truncated: totalLines > effLines,
@@ -27876,7 +27924,7 @@ var outdatedTool = {
   }
 };
 function runOutdated(manager, args, cwd, signal) {
-  return new Promise((resolve23) => {
+  return new Promise((resolve24) => {
     let stdout = "";
     let stderr = "";
     const MAX = 1e5;
@@ -27901,10 +27949,10 @@ function runOutdated(manager, args, cwd, signal) {
     });
     child.on("close", (code) => {
       const result = parseOutdatedOutput(stdout, code ?? 0);
-      resolve23(result);
+      resolve24(result);
     });
     child.on("error", (e) => {
-      resolve23({
+      resolve24({
         exit_code: 1,
         packages: [],
         total: 0,
@@ -28223,7 +28271,7 @@ function runPatch(args, cwd, signal, fallback) {
   });
 }
 function runPatchProcess(command, args, cwd, signal) {
-  return new Promise((resolve23) => {
+  return new Promise((resolve24) => {
     let stdout = "";
     let stderr = "";
     const env = { ...buildChildEnv8(), LANG: "C", LC_ALL: "C" };
@@ -28242,11 +28290,11 @@ function runPatchProcess(command, args, cwd, signal) {
     });
     child.on(
       "close",
-      (code) => resolve23({ exitCode: code ?? 1, stdout, stderr, unavailable: false })
+      (code) => resolve24({ exitCode: code ?? 1, stdout, stderr, unavailable: false })
     );
     child.on(
       "error",
-      (e) => resolve23({
+      (e) => resolve24({
         exitCode: 1,
         stdout: "",
         stderr: e.message,
@@ -29035,9 +29083,428 @@ function mkResult(plan, ok, message, todos) {
   return result;
 }
 
+// src/pwsh.ts
+import { spawn as spawn14 } from "node:child_process";
+import * as fs36 from "node:fs";
+import * as os10 from "node:os";
+import * as path43 from "node:path";
+import { StringDecoder as StringDecoder3 } from "node:string_decoder";
+import {
+  emitProcessCompleted as emitProcessCompleted4,
+  emitProcessOutput as emitProcessOutput4,
+  emitProcessStarted as emitProcessStarted4
+} from "@wrongstack/core/observability";
+init_output_spool();
+init_util();
+init_process_registry();
+init_win32_resolve();
+var MAX_OUTPUT4 = 32768;
+var DEFAULT_TIMEOUT_MS4 = 3e5;
+var STREAM_FLUSH_INTERVAL_MS2 = 200;
+var STREAM_FLUSH_BYTES2 = 4 * 1024;
+var MAX_QUEUE_CHUNKS2 = 500;
+var PWSH_TOOL_DESCRIPTION = "Execute a PowerShell command (`pwsh -Command`) in a fresh process on Windows and return its stdout/stderr. Stateless per call: pass `workdir` instead of using `cd`.";
+var PWSH_TOOL_USAGE_HINT = "Best practices & sandbox protocol for pwsh:\n- **Stateless**: No cwd, variables, or functions persist between calls. Use `workdir` to set the directory.\n- **Paths & Environs**: Use native Windows paths (`C:\\...`) and read env vars via `$env:NAME` (and `$env:DSH_*`).\n- **Exit Codes**: Non-zero exits are reported as `[exit code: N]`. On Windows, a force-killed command settles as exit code 1 (interruption).\n- **Background**: Set `run_in_background: true` for long-running processes (returns job id; manage via job_output/job_kill).\n- **Sandboxing**: Under read-only sandbox, pwsh runs in `ConstrainedLanguage` mode (prefer cmdlets, basic types; .NET reflection and COM fail). Workspace-write runs in `FullLanguage`.\n- **Escalation**: If denied by policy (`[sandbox: file access denied]`), retry once with `sandbox_permissions` plus a one-sentence `justification`.";
+function wrapPwshCommand(command) {
+  const bootstrap = "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8;$ProgressPreference = 'SilentlyContinue';$ConfirmPreference = 'None';$WhatIfPreference = $false";
+  return `${bootstrap}
+$ErrorActionPreference = 'Stop'
+${command}
+if ($LASTEXITCODE -is [int]) { exit $LASTEXITCODE }`;
+}
+var pwshTool = {
+  name: "pwsh",
+  category: "Shell",
+  description: PWSH_TOOL_DESCRIPTION,
+  usageHint: PWSH_TOOL_USAGE_HINT,
+  selection: {
+    doNotUseWhen: "the command is an allowlisted single binary (node, git, pnpm, tsc) needing no shell expansion or pipelines.",
+    useInstead: ["exec"]
+  },
+  permission: "confirm",
+  mutating: true,
+  riskTier: "destructive",
+  icon: "terminal",
+  subjectKey: "command",
+  capabilities: ["shell.arbitrary"],
+  timeoutMs: 61e4,
+  maxOutputBytes: MAX_OUTPUT4,
+  estimatedDurationMs: 3e4,
+  inputSchema: {
+    type: "object",
+    properties: {
+      command: {
+        type: "string",
+        description: "The exact PowerShell command or script block to run."
+      },
+      workdir: {
+        type: "string",
+        description: "Absolute or project-relative path to the working directory for this command. Defaults to session working directory."
+      },
+      timeout_ms: {
+        type: "integer",
+        description: "Optional timeout for this specific command in milliseconds (default 300000, max 600000)."
+      },
+      run_in_background: {
+        type: "boolean",
+        description: "If true, launch the process in the background and return the job ID / PID immediately."
+      },
+      background: {
+        type: "boolean",
+        description: "Alias for run_in_background."
+      },
+      sandbox_permissions: {
+        type: "string",
+        description: "Escalation mode if retrying a sandbox-denied command (e.g., workspace-write)."
+      },
+      justification: {
+        type: "string",
+        description: "One-sentence justification when retrying a denied command with sandbox_permissions."
+      }
+    },
+    required: ["command"]
+  },
+  async execute(input, ctx, opts) {
+    let final;
+    const executeStream = pwshTool.executeStream;
+    if (!executeStream) throw new Error("pwshTool: stream execution unavailable");
+    for await (const ev of executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("pwsh: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
+    if (!input?.command) throw new Error("pwsh: command is required");
+    const isBackground = !!(input.run_in_background || input.background);
+    const registry = getProcessRegistry();
+    if (!registry.beforeCall(isBackground)) {
+      yield {
+        type: "final",
+        output: {
+          output: "",
+          exit_code: 1,
+          timed_out: false,
+          pid: null,
+          error: "pwsh: circuit breaker open \u2014 too many consecutive failures or slow calls. Use /kill to inspect or /kill reset to recover."
+        }
+      };
+      return;
+    }
+    const killCheck = await checkAndBlockKillCommand(input.command);
+    if (killCheck.blocked) {
+      yield {
+        type: "final",
+        output: {
+          output: "",
+          exit_code: 1,
+          timed_out: false,
+          pid: null,
+          error: `pwsh: ${killCheck.reason}`
+        }
+      };
+      return;
+    }
+    const isWin5 = os10.platform() === "win32";
+    const bin = isWin5 ? resolvePowerShell("pwsh.exe") : "pwsh";
+    const args = shellArgs("pwsh");
+    const stdinBody = wrapPwshCommand(input.command);
+    const env = buildChildEnv2(ctx.session?.id);
+    let targetCwd = ctx.workingDir ?? ctx.projectRoot;
+    if (input.workdir) {
+      const resolved = path43.isAbsolute(input.workdir) ? input.workdir : path43.resolve(ctx.projectRoot, input.workdir);
+      if (fs36.existsSync(resolved)) {
+        targetCwd = resolved;
+      }
+    }
+    const startedAt = Date.now();
+    const detached = !isWin5;
+    if (isBackground) {
+      const child2 = spawn14(bin, args, {
+        cwd: targetCwd,
+        env,
+        detached,
+        stdio: ["pipe", "ignore", "ignore"],
+        windowsHide: true
+      });
+      if (child2.stdin) {
+        child2.stdin.write(stdinBody);
+        child2.stdin.end();
+      }
+      const pid2 = child2.pid;
+      if (typeof pid2 === "number") {
+        registry.register({
+          pid: pid2,
+          name: "pwsh",
+          command: redactCommand(input.command),
+          startedAt: Date.now(),
+          sessionId: ctx.session?.id,
+          child: child2,
+          processGroupLeader: detached && child2.pid === pid2,
+          background: true
+        });
+        child2.on("close", () => registry.unregister(pid2));
+        child2.on("error", () => {
+          registry.unregister(pid2);
+          registry.afterCall(Date.now() - startedAt, true, isBackground);
+        });
+        child2.unref();
+        const jobId = `job_${pid2}`;
+        ctx.recordSideEffect?.({
+          toolUseId: `pwsh-bg-${Date.now()}`,
+          toolName: "pwsh",
+          ts: (/* @__PURE__ */ new Date()).toISOString(),
+          input: { command: redactCommand(input.command), background: true },
+          outcome: `started background job ${jobId} (PID: ${pid2})`,
+          risk: "shell"
+        });
+        yield {
+          type: "final",
+          output: {
+            output: `Background job started: ${jobId} (PID: ${pid2})
+Working directory: ${targetCwd}`,
+            exit_code: null,
+            timed_out: false,
+            pid: pid2,
+            job_id: jobId
+          }
+        };
+        return;
+      }
+      yield {
+        type: "final",
+        output: {
+          output: "",
+          exit_code: 1,
+          timed_out: false,
+          pid: null,
+          error: "pwsh: failed to obtain PID for background process"
+        }
+      };
+      return;
+    }
+    const spool = createOutputSpool({ tool: "pwsh", thresholdBytes: MAX_OUTPUT4 });
+    const child = spawn14(bin, args, {
+      cwd: targetCwd,
+      env,
+      detached,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const pid = child.pid;
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let telemetryCompleted = false;
+    emitProcessStarted4({
+      ...pid !== void 0 ? { pid } : {},
+      parentPid: process.pid,
+      command: redactCommand(`${bin} ${args.join(" ")}`),
+      args: redactCommand(args.join(" ")).split(" ").filter(Boolean),
+      cwd: targetCwd,
+      background: false,
+      startedAt: new Date(startedAt).toISOString()
+    });
+    const completeForeground = (exitCode, sig) => {
+      if (telemetryCompleted) return;
+      telemetryCompleted = true;
+      emitProcessCompleted4({
+        ...pid !== void 0 ? { pid } : {},
+        exitCode,
+        ...sig ? { signal: sig } : {},
+        durationMs: Date.now() - startedAt,
+        stdoutBytes,
+        stderrBytes,
+        timedOut,
+        endedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    };
+    if (typeof pid === "number") {
+      registry.register({
+        pid,
+        name: "pwsh",
+        command: redactCommand(input.command),
+        startedAt: Date.now(),
+        sessionId: ctx.session?.id,
+        child,
+        processGroupLeader: detached && child.pid === pid
+      });
+    }
+    if (child.stdin) {
+      child.stdin.write(stdinBody);
+      child.stdin.end();
+    }
+    const timeoutMs = Math.min(
+      Math.max(1e3, input.timeout_ms ?? DEFAULT_TIMEOUT_MS4),
+      6e5
+    );
+    let timedOut = false;
+    const timers = [];
+    const killWithTimeout = (timeout) => {
+      if (isWin5) {
+        if (typeof child.pid === "number" && child.exitCode === null) {
+          const attempted = registry.kill(child.pid, { force: true, graceMs: timeout });
+          if (!attempted) {
+            try {
+              child.kill();
+            } catch {
+            }
+          }
+        }
+        return;
+      }
+      if (typeof child.pid === "number") {
+        registry.kill(child.pid, { graceMs: timeout });
+      } else {
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+      }
+    };
+    const timer = setTimeout(() => {
+      timedOut = true;
+      killWithTimeout(2e3);
+    }, timeoutMs);
+    timers.push(timer);
+    const onAbort = () => killWithTimeout(2e3);
+    if (opts.signal.aborted) onAbort();
+    else opts.signal.addEventListener("abort", onAbort, { once: true });
+    const queue = [];
+    let resolveNext = null;
+    const push = (c) => {
+      if (resolveNext) {
+        const r = resolveNext;
+        resolveNext = null;
+        r(c);
+      } else {
+        queue.push(c);
+      }
+    };
+    const next = () => new Promise((resolve24) => {
+      const c = queue.shift();
+      if (c) resolve24(c);
+      else resolveNext = resolve24;
+    });
+    let buf = "";
+    let pending2 = "";
+    let lastFlush = Date.now();
+    const flush = () => {
+      if (pending2.length === 0) return null;
+      const text = pending2;
+      pending2 = "";
+      lastFlush = Date.now();
+      return text;
+    };
+    let paused = false;
+    const pauseIfFlooded = () => {
+      if (!paused && queue.length >= MAX_QUEUE_CHUNKS2) {
+        paused = true;
+        child.stdout?.pause();
+        child.stderr?.pause();
+      }
+    };
+    const resumeIfDrained = () => {
+      if (paused && queue.length < MAX_QUEUE_CHUNKS2) {
+        paused = false;
+        child.stdout?.resume();
+        child.stderr?.resume();
+      }
+    };
+    const stdoutDecoder = new StringDecoder3("utf8");
+    const stderrDecoder = new StringDecoder3("utf8");
+    const onData = (chunk, stream) => {
+      const text = (stream === "stdout" ? stdoutDecoder : stderrDecoder).write(chunk);
+      if (stream === "stdout") stdoutBytes += chunk.byteLength;
+      else stderrBytes += chunk.byteLength;
+      emitProcessOutput4({ pid: pid ?? 0, stream, chunk });
+      if (buf.length < MAX_OUTPUT4) {
+        buf += text.slice(0, MAX_OUTPUT4 - buf.length);
+      }
+      spool.write(text);
+      pending2 += text;
+      push({ kind: "data", text });
+      pauseIfFlooded();
+    };
+    child.stdout?.on("data", (chunk) => onData(chunk, "stdout"));
+    child.stderr?.on("data", (chunk) => onData(chunk, "stderr"));
+    child.on("error", (err) => {
+      for (const t of timers) clearTimeout(t);
+      registry.afterCall(Date.now() - startedAt, true);
+      completeForeground(1);
+      push({ kind: "error", err });
+    });
+    child.on("close", (code, signal) => {
+      for (const t of timers) clearTimeout(t);
+      if (typeof pid === "number") registry.unregister(pid);
+      registry.afterCall(Date.now() - startedAt, code !== 0 && code !== null);
+      completeForeground(timedOut ? 124 : code ?? (signal ? 1 : 0), signal ?? void 0);
+      const tail = stdoutDecoder.end() + stderrDecoder.end();
+      if (tail) {
+        if (buf.length < MAX_OUTPUT4) buf += tail.slice(0, MAX_OUTPUT4 - buf.length);
+        spool.write(tail);
+        pending2 += tail;
+      }
+      push({ kind: "end", code });
+    });
+    try {
+      while (true) {
+        const c = await next();
+        resumeIfDrained();
+        if (c.kind === "error") throw c.err;
+        if (c.kind === "end") {
+          const remainder = flush();
+          if (remainder !== null) {
+            yield { type: "partial_output", text: remainder };
+          }
+          const spooled = spool.finalize();
+          let formattedOutput = normalizeCommandOutput(buf);
+          if (c.code !== null && c.code !== 0 && !timedOut) {
+            if (!formattedOutput.includes(`[exit code: ${c.code}]`)) {
+              formattedOutput = formattedOutput ? `${formattedOutput}
+[exit code: ${c.code}]` : `[exit code: ${c.code}]`;
+            }
+          }
+          const hint = !timedOut && typeof c.code === "number" && c.code !== 0 ? diagnoseBashism(input.command, "pwsh") : void 0;
+          const danger = detectDanger("pwsh", [input.command]);
+          const cautionText = danger.level === "caution" && danger.reasons.length > 0 ? `
+[caution: ${danger.reasons.join("; ")}]` : "";
+          const finalResultText = formattedOutput + (spooled ? spoolNote(spooled) : "") + (hint ? `
+
+${hint}` : "") + cautionText;
+          ctx.recordSideEffect?.({
+            toolUseId: `pwsh-${Date.now()}`,
+            toolName: "pwsh",
+            ts: (/* @__PURE__ */ new Date()).toISOString(),
+            input: { command: redactCommand(input.command) },
+            outcome: timedOut ? `timed out (exit ${c.code})` : `exit ${c.code}`,
+            risk: "shell"
+          });
+          yield {
+            type: "final",
+            output: {
+              output: finalResultText,
+              exit_code: timedOut ? 1 : c.code,
+              timed_out: timedOut,
+              pid
+            }
+          };
+          return;
+        }
+        const now = Date.now();
+        if (pending2.length >= STREAM_FLUSH_BYTES2 || now - lastFlush >= STREAM_FLUSH_INTERVAL_MS2) {
+          const text = flush();
+          if (text) yield { type: "partial_output", text };
+        }
+      }
+    } finally {
+      for (const t of timers) clearTimeout(t);
+    }
+  }
+};
+
 // src/read.ts
 init_util();
-import * as fs36 from "node:fs/promises";
+import * as fs37 from "node:fs/promises";
 import { FsError, ToolValidationError as ToolValidationError8 } from "@wrongstack/core/types";
 import { toErrorMessage as toErrorMessage15 } from "@wrongstack/core/utils";
 var ADVANCED_MODE_META_KEY = "tools.read.advancedMode";
@@ -29097,7 +29564,7 @@ var readTool = {
     const shouldIncludeSymbols = input.includeSymbols === true || input.includeSymbols !== false && ctx.meta[ADVANCED_MODE_META_KEY] === true;
     let stat21;
     try {
-      stat21 = await fs36.stat(absPath);
+      stat21 = await fs37.stat(absPath);
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") {
@@ -29149,7 +29616,7 @@ var readTool = {
         ...symResult2?.symbols ? { symbols: symResult2.symbols } : {}
       };
     }
-    const buf = await fs36.readFile(absPath);
+    const buf = await fs37.readFile(absPath);
     if (isBinaryBuffer(buf)) {
       throw new FsError({
         message: `read: "${input.path}" appears to be binary`,
@@ -29315,9 +29782,9 @@ ${interesting.join("\n")}` : "symbols/imports: (none detected)"
 }
 
 // src/replace.ts
-import { spawn as spawn14 } from "node:child_process";
-import * as fs37 from "node:fs/promises";
-import * as path43 from "node:path";
+import { spawn as spawn15 } from "node:child_process";
+import * as fs38 from "node:fs/promises";
+import * as path44 from "node:path";
 import { ToolValidationError as ToolValidationError9 } from "@wrongstack/core/types";
 import {
   atomicWrite as atomicWrite4,
@@ -29400,14 +29867,14 @@ var replaceTool = {
     const dryRun = input.dry_run ?? true;
     const filesInput = Array.isArray(input.files) ? input.files.join(",") : input.files;
     const fileList = await resolveFiles2(filesInput, ctx, globRe);
-    const realRoot = await fs37.realpath(ctx.projectRoot).catch(() => ctx.projectRoot);
+    const realRoot = await fs38.realpath(ctx.projectRoot).catch(() => ctx.projectRoot);
     const results = [];
     let totalReplacements = 0;
     let diffBytesUsed = 0;
     let diffsOmitted = 0;
     let diffsTruncated = 0;
     for (const absPath of fileList) {
-      const lstat2 = await fs37.lstat(absPath).catch((err) => {
+      const lstat2 = await fs38.lstat(absPath).catch((err) => {
         if (err.code === "ENOENT") return null;
         throw err;
       });
@@ -29415,17 +29882,17 @@ var replaceTool = {
       if (lstat2.isSymbolicLink()) continue;
       let realPath;
       try {
-        realPath = await fs37.realpath(absPath);
+        realPath = await fs38.realpath(absPath);
       } catch {
         continue;
       }
-      const rel = path43.relative(realRoot, realPath);
-      if (rel.startsWith("..") || path43.isAbsolute(rel)) continue;
-      const stat21 = await fs37.stat(realPath).catch(() => null);
+      const rel = path44.relative(realRoot, realPath);
+      if (rel.startsWith("..") || path44.isAbsolute(rel)) continue;
+      const stat21 = await fs38.stat(realPath).catch(() => null);
       if (!stat21?.isFile()) continue;
       let content;
       try {
-        const buf = await fs37.readFile(realPath);
+        const buf = await fs38.readFile(realPath);
         if (isBinaryBuffer(buf)) continue;
         content = buf.toString("utf8");
       } catch {
@@ -29448,7 +29915,7 @@ var replaceTool = {
       if (!dryRun) {
         const newContent = toStyle2(newContentLf, style);
         await atomicWrite4(realPath, newContent, { mode: stat21.mode & 511 });
-        const written = await fs37.stat(realPath).catch(() => null);
+        const written = await fs38.stat(realPath).catch(() => null);
         if (written) {
           ctx.recordRead?.(realPath, written.mtimeMs, "write", sha256hex(newContent));
         }
@@ -29548,8 +30015,8 @@ async function resolveFiles2(filesInput, ctx, extraGlob) {
   const resolved = [];
   for (const p of parts) {
     const absPath = await safeResolveReal(p, ctx);
-    if (extraGlob && !passesExtraGlob(extraGlob, path43.basename(absPath), absPath)) continue;
-    const stat21 = await fs37.stat(absPath).catch(() => null);
+    if (extraGlob && !passesExtraGlob(extraGlob, path44.basename(absPath), absPath)) continue;
+    const stat21 = await fs38.stat(absPath).catch(() => null);
     if (stat21?.isFile()) {
       resolved.push(absPath);
     }
@@ -29563,7 +30030,7 @@ async function globFiles(pattern, base, extraGlob) {
       const { promise } = spawnRgFind(pattern, base);
       const files = await promise;
       if (extraGlob) {
-        return files.filter((f) => passesExtraGlob(extraGlob, path43.basename(f), f));
+        return files.filter((f) => passesExtraGlob(extraGlob, path44.basename(f), f));
       }
       return files;
     } catch {
@@ -29573,24 +30040,24 @@ async function globFiles(pattern, base, extraGlob) {
 }
 var rgAvailabilityCache2;
 function checkRg() {
-  rgAvailabilityCache2 ??= new Promise((resolve23) => {
+  rgAvailabilityCache2 ??= new Promise((resolve24) => {
     try {
-      const p = spawn14("rg", ["--version"], {
+      const p = spawn15("rg", ["--version"], {
         env: buildChildEnv9(),
         stdio: "ignore",
         windowsHide: true
       });
-      p.on("error", () => resolve23(false));
-      p.on("close", (code) => resolve23(code === 0));
+      p.on("error", () => resolve24(false));
+      p.on("close", (code) => resolve24(code === 0));
     } catch {
-      resolve23(false);
+      resolve24(false);
     }
   });
   return rgAvailabilityCache2;
 }
 function spawnRgFind(pattern, base) {
   const args = ["--files", "--glob", pattern, base];
-  const child = spawn14("rg", args, {
+  const child = spawn15("rg", args, {
     signal: AbortSignal.timeout(3e4),
     env: buildChildEnv9(),
     stdio: ["ignore", "pipe", "pipe"],
@@ -29609,10 +30076,10 @@ function spawnRgFind(pattern, base) {
     }
   });
   return {
-    promise: new Promise((resolve23, reject) => {
+    promise: new Promise((resolve24, reject) => {
       child.on("error", reject);
       child.on("close", () => {
-        resolve23(buf.split("\n").filter(Boolean));
+        resolve24(buf.split("\n").filter(Boolean));
       });
     })
   };
@@ -29623,15 +30090,15 @@ async function globNative(pattern, base, extraGlob) {
   const walk = async (dir) => {
     let entries;
     try {
-      entries = await fs37.readdir(dir, { withFileTypes: true });
+      entries = await fs38.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (DEFAULT_IGNORE4.includes(e.name)) continue;
-      const full = path43.join(dir, e.name);
+      const full = path44.join(dir, e.name);
       try {
-        const stat21 = await fs37.lstat(full);
+        const stat21 = await fs38.lstat(full);
         if (stat21.isSymbolicLink()) continue;
       } catch {
         continue;
@@ -29655,8 +30122,8 @@ async function globNative(pattern, base, extraGlob) {
 
 // src/scaffold.ts
 init_util();
-import * as fs38 from "node:fs/promises";
-import * as path44 from "node:path";
+import * as fs39 from "node:fs/promises";
+import * as path45 from "node:path";
 import { atomicWrite as atomicWrite5 } from "@wrongstack/core/utils";
 var BUILT_IN_TEMPLATES = {
   "npm-package": {
@@ -29807,16 +30274,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 = path44.join(cwd, resolvedPath);
-    const root = path44.resolve(ctx.projectRoot);
-    const target = path44.resolve(joinedPath);
-    const rel = path44.relative(root, target);
-    if (rel.startsWith("..") || path44.isAbsolute(rel)) {
+    const joinedPath = path45.join(cwd, resolvedPath);
+    const root = path45.resolve(ctx.projectRoot);
+    const target = path45.resolve(joinedPath);
+    const rel = path45.relative(root, target);
+    if (rel.startsWith("..") || path45.isAbsolute(rel)) {
       throw new Error(`scaffold: generated path "${resolvedPath}" would escape project root`);
     }
     const fullPath = target;
     if (!dryRun) {
-      await fs38.mkdir(path44.dirname(fullPath), { recursive: true });
+      await fs39.mkdir(path45.dirname(fullPath), { recursive: true });
       await atomicWrite5(fullPath, substituteVars(content, name, vars));
     }
     files.push(resolvedPath);
@@ -30262,8 +30729,8 @@ function decodeHtmlEntities(text) {
 }
 
 // src/security-ast-scan-tool.ts
-import * as fs39 from "node:fs/promises";
-import * as path45 from "node:path";
+import * as fs40 from "node:fs/promises";
+import * as path46 from "node:path";
 import { toErrorMessage as toErrorMessage17 } from "@wrongstack/core/utils";
 var SECRET_PATTERNS = [
   { name: "AWS Access Key", regex: /\b(AKIA[0-9A-Z]{16})\b/ },
@@ -30430,9 +30897,9 @@ var securityAstScanTool = {
       let targetFile = input.file ?? "inline-code.ts";
       let content = input.content;
       if (!content && input.file) {
-        const absPath = path45.isAbsolute(input.file) ? input.file : path45.resolve(projectRoot, input.file);
-        targetFile = path45.relative(projectRoot, absPath).replace(/\\/g, "/");
-        content = await fs39.readFile(absPath, "utf8");
+        const absPath = path46.isAbsolute(input.file) ? input.file : path46.resolve(projectRoot, input.file);
+        targetFile = path46.relative(projectRoot, absPath).replace(/\\/g, "/");
+        content = await fs40.readFile(absPath, "utf8");
       }
       if (!content) {
         return {
@@ -30480,7 +30947,7 @@ var securityAstScanTool = {
 };
 
 // src/set-working-dir.ts
-import * as fs40 from "node:fs/promises";
+import * as fs41 from "node:fs/promises";
 import { toErrorMessage as toErrorMessage18 } from "@wrongstack/core/utils";
 var setWorkingDirTool = {
   name: "set_working_dir",
@@ -30520,7 +30987,7 @@ var setWorkingDirTool = {
     }
     let isDirectory = false;
     try {
-      isDirectory = (await fs40.stat(resolved)).isDirectory();
+      isDirectory = (await fs41.stat(resolved)).isDirectory();
     } catch {
       isDirectory = false;
     }
@@ -31055,7 +31522,7 @@ ${formatTaskList2(file.tasks)}` : file.tasks.length > 0 ? formatTaskList2(file.t
 init_spawn_stream();
 init_util();
 init_legacy_bridge();
-import * as path46 from "node:path";
+import * as path47 from "node:path";
 var testTool = {
   name: "test",
   category: "Code Quality",
@@ -31162,7 +31629,7 @@ async function detectRunner(cwd) {
   const candidates = ["vitest.config.ts", "jest.config.js", ".mocharc.json"];
   for (const f of candidates) {
     try {
-      await stat21(path46.join(cwd, f));
+      await stat21(path47.join(cwd, f));
       if (f.includes("vitest")) return "vitest";
       if (f.includes("jest")) return "jest";
       if (f.includes("mocha")) return "mocha";
@@ -31539,8 +32006,8 @@ var toolUseTool = {
 
 // src/tree.ts
 init_util();
-import * as fs41 from "node:fs/promises";
-import * as path47 from "node:path";
+import * as fs42 from "node:fs/promises";
+import * as path48 from "node:path";
 import { DEFAULT_WALK_IGNORE_DIRS as DEFAULT_WALK_IGNORE_DIRS4, expectDefined as expectDefined10 } from "@wrongstack/core/utils";
 var DEFAULT_IGNORE5 = /* @__PURE__ */ new Set([
   ...DEFAULT_WALK_IGNORE_DIRS4,
@@ -31703,7 +32170,7 @@ var treeTool = {
 async function walkDir(dir, depth, opts) {
   opts.signal.throwIfAborted();
   if (opts.retention.truncated) return;
-  const entries = await fs41.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const entries = await fs42.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;
@@ -31745,7 +32212,7 @@ async function walkDir(dir, depth, opts) {
     opts.retention.outputBytes += lineBytes;
     if (entry.isDirectory() && (opts.maxDepth === 0 || depth < opts.maxDepth)) {
       const childPrefix = opts.prefix + connector;
-      await walkDir(path47.join(dir, entry.name), depth + 1, {
+      await walkDir(path48.join(dir, entry.name), depth + 1, {
         ...opts,
         prefix: childPrefix,
         isLast
@@ -31758,7 +32225,7 @@ async function walkDir(dir, depth, opts) {
 init_spawn_stream();
 init_util();
 init_legacy_bridge();
-import * as path48 from "node:path";
+import * as path49 from "node:path";
 var typecheckTool = {
   name: "typecheck",
   category: "Code Quality",
@@ -31870,8 +32337,8 @@ async function findTsConfig(cwd) {
   const candidates = ["tsconfig.json", "tsconfig.base.json"];
   for (const f of candidates) {
     try {
-      const s = await stat21(path48.join(cwd, f));
-      if (s.isFile()) return path48.join(cwd, f);
+      const s = await stat21(path49.join(cwd, f));
+      if (s.isFile()) return path49.join(cwd, f);
     } catch {
     }
   }
@@ -31879,7 +32346,7 @@ async function findTsConfig(cwd) {
 }
 
 // src/write.ts
-import * as fs42 from "node:fs/promises";
+import * as fs43 from "node:fs/promises";
 import { ToolValidationError as ToolValidationError11 } from "@wrongstack/core/types";
 import {
   atomicWrite as atomicWrite6,
@@ -31956,14 +32423,14 @@ async function prepareWrite(input, ctx) {
   let existed = false;
   let prev = "";
   try {
-    const stat21 = await fs42.stat(absPath);
+    const stat21 = await fs43.stat(absPath);
     existed = stat21.isFile();
     if (existed) {
       if (!ctx.hasRead(absPath)) {
-        prev = await fs42.readFile(absPath, "utf8");
+        prev = await fs43.readFile(absPath, "utf8");
         ctx.recordRead(absPath, stat21.mtimeMs, "write", sha256hex(prev));
       } else {
-        prev = await fs42.readFile(absPath, "utf8");
+        prev = await fs43.readFile(absPath, "utf8");
       }
     }
   } catch (err) {
@@ -31984,7 +32451,7 @@ async function finishWrite(input, ctx, prepared, signal) {
   const rawDiff = prepared.existed ? unifiedDiff3(prepared.prev, content, { fromFile: input.path, toFile: input.path }) : `+++ ${input.path}
 + (new file, ${content.split("\n").length} lines)`;
   const { text: diff, truncated: diffTruncated } = truncateDiffPayload(rawDiff, MAX_DIFF_BYTES3);
-  const stat21 = await fs42.stat(prepared.absPath);
+  const stat21 = await fs43.stat(prepared.absPath);
   ctx.recordRead(prepared.absPath, stat21.mtimeMs, "write", sha256hex(content));
   ctx.session.recordFileChange({
     path: prepared.absPath,
@@ -32059,6 +32526,7 @@ var builtinTools = [
   grepTool,
   bashTool,
   execTool,
+  pwshTool,
   fetchTool,
   searchTool,
   todoTool,