@wrongstack/tools 0.308.0 → 0.308.1

package/dist/index.js

@@ -1034,8 +1034,8 @@ async function* spawnStream(opts) {
   try {
     for (; ; ) {
       while (queue.length === 0) {
-        await new Promise((resolve24) => {
-          waiter = resolve24;
+        await new Promise((resolve25) => {
+          waiter = resolve25;
         });
       }
       const chunk = queue.shift();
@@ -1138,9 +1138,9 @@ async function detectPackageManager(cwd, stopAt) {
   return "npm";
 }
 async function detectPackageManagerInDir(dir) {
-  const fs44 = await import("node:fs/promises");
+  const fs45 = await import("node:fs/promises");
   try {
-    const raw = await fs44.readFile(path3.join(dir, "package.json"), "utf8");
+    const raw = await fs45.readFile(path3.join(dir, "package.json"), "utf8");
     const declared = JSON.parse(raw).packageManager;
     if (typeof declared === "string") {
       const name = declared.split("@")[0] ?? "";
@@ -1159,7 +1159,7 @@ async function detectPackageManagerInDir(dir) {
   ];
   for (const [file, manager] of lockfiles) {
     try {
-      await fs44.stat(`${dir}/${file}`);
+      await fs45.stat(`${dir}/${file}`);
       return manager;
     } catch {
     }
@@ -4140,15 +4140,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 path50 of after) {
-    if (!beforeSet.has(path50)) changed.add(path50);
+  for (const path51 of after) {
+    if (!beforeSet.has(path51)) changed.add(path51);
   }
-  for (const path50 of before) {
-    if (!afterSet.has(path50)) changed.add(path50);
+  for (const path51 of before) {
+    if (!afterSet.has(path51)) changed.add(path51);
   }
   if (beforeSizes && afterSizes) {
-    for (const path50 of after) {
-      if (beforeSizes.get(path50) !== afterSizes.get(path50)) changed.add(path50);
+    for (const path51 of after) {
+      if (beforeSizes.get(path51) !== afterSizes.get(path51)) changed.add(path51);
     }
   }
   return [...changed].sort();
@@ -5643,7 +5643,7 @@ async function syncGoParse(filePath, content, lang) {
     }
     const goBinary = resolveWin32Command("go");
     const goResult = await new Promise(
-      (resolve24, reject) => {
+      (resolve25, reject) => {
         let settled = false;
         const proc = spawn5(goBinary, ["run", scriptPath], {
           stdio: ["pipe", "pipe", "pipe"],
@@ -5672,7 +5672,7 @@ async function syncGoParse(filePath, content, lang) {
           if (settled) return;
           settled = true;
           clearTimeout(timer);
-          resolve24({ code: code2, stdout: stdout2 });
+          resolve25({ code: code2, stdout: stdout2 });
         });
       }
     );
@@ -6348,7 +6348,7 @@ async function resolvePython() {
   return null;
 }
 function commandIsAvailable(command) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     let settled = false;
     const proc = spawn6(command, ["--version"], {
       stdio: "ignore",
@@ -6358,7 +6358,7 @@ function commandIsAvailable(command) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve24(available);
+      resolve25(available);
     };
     const timer = setTimeout(() => {
       proc.kill("SIGKILL");
@@ -6370,7 +6370,7 @@ function commandIsAvailable(command) {
   });
 }
 function spawnPyParser(pyBinary, scriptPath, filePath, content) {
-  return new Promise((resolve24, reject) => {
+  return new Promise((resolve25, reject) => {
     let settled = false;
     const proc = spawn6(pyBinary, [scriptPath, filePath], {
       stdio: ["pipe", "pipe", "pipe"],
@@ -6399,7 +6399,7 @@ function spawnPyParser(pyBinary, scriptPath, filePath, content) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve24({ code, stdout });
+      resolve25({ code, stdout });
     });
   });
 }
@@ -7788,6 +7788,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",
@@ -8108,8 +8142,8 @@ function normalizeShell(value) {
   if (v === "pwsh" || v === "pwsh.exe") return "pwsh";
   return void 0;
 }
-function resolveSessionShell(platform6, env, deps = {}) {
-  if (platform6 !== "win32") return void 0;
+function resolveSessionShell(platform7, env, deps = {}) {
+  if (platform7 !== "win32") return void 0;
   const override = normalizeShell(env.get("WRONGSTACK_SHELL"));
   if (override) return override;
   const hasBinary = deps.hasBinary ?? ((bin) => resolveWin32Command(bin) !== bin);
@@ -8119,11 +8153,11 @@ function resolveSessionShell(platform6, env, deps = {}) {
 }
 function ensureSessionShell(opts = {}) {
   const env = opts.env ?? process.env;
-  const platform6 = opts.platform ?? process.platform;
-  if (platform6 !== "win32") return void 0;
+  const platform7 = opts.platform ?? process.platform;
+  if (platform7 !== "win32") return void 0;
   const existing = normalizeShell(env["WRONGSTACK_SHELL"]);
   if (existing) return existing;
-  const chosen = resolveSessionShell(platform6, { get: (k) => env[k] }, { hasBinary: opts.hasBinary }) ?? "cmd";
+  const chosen = resolveSessionShell(platform7, { get: (k) => env[k] }, { hasBinary: opts.hasBinary }) ?? "cmd";
   env["WRONGSTACK_SHELL"] = chosen;
   return chosen;
 }
@@ -8989,6 +9023,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 {
@@ -9108,7 +9154,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;
 }
@@ -9155,8 +9203,8 @@ async function checkAndBlockKillCommand(command) {
 
 // src/_shell-pick.ts
 var POSIX_DEFAULT = "cmd";
-function pickShell(platform6, command, env) {
-  if (platform6 !== "win32") return POSIX_DEFAULT;
+function pickShell(platform7, command, env) {
+  if (platform7 !== "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";
@@ -9615,10 +9663,10 @@ var bashTool = {
         queue.push(c);
       }
     };
-    const next = () => new Promise((resolve24) => {
+    const next = () => new Promise((resolve25) => {
       const c = queue.shift();
-      if (c) resolve24(c);
-      else resolveNext = resolve24;
+      if (c) resolve25(c);
+      else resolveNext = resolve25;
     });
     let lastFlush = Date.now();
     const flush = () => {
@@ -10071,11 +10119,11 @@ var BrowserArtifactStore = class {
 };
 async function hashFile(target) {
   const hash = createHash3("sha256");
-  await new Promise((resolve24, reject) => {
+  await new Promise((resolve25, reject) => {
     const stream = createReadStream(target);
     stream.on("data", (chunk) => hash.update(chunk));
     stream.once("error", reject);
-    stream.once("end", resolve24);
+    stream.once("end", resolve25);
   });
   return hash.digest("hex");
 }
@@ -10230,7 +10278,7 @@ var BrowserNetworkGuardProxy = class {
   async start() {
     if (this.url) return this.url;
     if (this.startPromise) return this.startPromise;
-    this.startPromise = new Promise((resolve24, reject) => {
+    this.startPromise = new Promise((resolve25, reject) => {
       const onError = (error) => {
         this.server.off("listening", onListening);
         reject(error);
@@ -10243,7 +10291,7 @@ var BrowserNetworkGuardProxy = class {
           return;
         }
         this.url = `http://127.0.0.1:${address.port}`;
-        resolve24(this.url);
+        resolve25(this.url);
       };
       this.server.once("error", onError);
       this.server.once("listening", onListening);
@@ -10258,7 +10306,7 @@ var BrowserNetworkGuardProxy = class {
     for (const socket of this.sockets) socket.destroy();
     this.sockets.clear();
     if (!this.server.listening) return;
-    await new Promise((resolve24) => this.server.close(() => resolve24()));
+    await new Promise((resolve25) => this.server.close(() => resolve25()));
   }
   async forwardHttp(request2, response) {
     try {
@@ -10831,7 +10879,7 @@ function pushBounded(target, value, limit) {
 }
 async function abortable(signal, operation, onAbort) {
   signal.throwIfAborted();
-  return new Promise((resolve24, reject) => {
+  return new Promise((resolve25, reject) => {
     let settled = false;
     let aborting = false;
     const finish = (fn) => {
@@ -10849,7 +10897,7 @@ async function abortable(signal, operation, onAbort) {
     signal.addEventListener("abort", abort, { once: true });
     operation().then(
       (value) => {
-        if (!aborting) finish(() => resolve24(value));
+        if (!aborting) finish(() => resolve25(value));
       },
       (err) => {
         if (!aborting) finish(() => reject(err));
@@ -14387,8 +14435,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((resolve24) => {
-    const timer = setTimeout(resolve24, ms);
+  return new Promise((resolve25) => {
+    const timer = setTimeout(resolve25, ms);
     timer.unref?.();
   });
 }
@@ -14594,7 +14642,7 @@ var ProjectServerConnection = class {
       return Promise.reject(new Error("codebase-index server connection is not available"));
     }
     const id = this.nextId++;
-    return new Promise((resolve24, reject) => {
+    return new Promise((resolve25, reject) => {
       const timer = setTimeout(() => {
         const entry = this.pending.get(id);
         if (!entry) return;
@@ -14617,7 +14665,7 @@ var ProjectServerConnection = class {
         entry.reject(cancellationError(signal));
       } : void 0;
       this.pending.set(id, {
-        resolve: resolve24,
+        resolve: resolve25,
         reject,
         timer,
         signal,
@@ -14686,7 +14734,7 @@ var ProjectServerConnection = class {
     this.binaryBuffer = [];
     this.useBinary = false;
     this.textDecoder = null;
-    return new Promise((resolve24, reject) => {
+    return new Promise((resolve25, reject) => {
       const socket = net3.createConnection(this.endpoint);
       this.socket = socket;
       const timer = setTimeout(() => {
@@ -14698,7 +14746,7 @@ var ProjectServerConnection = class {
         clearTimeout(timer);
         this.connectResolve = null;
         this.connectReject = null;
-        resolve24();
+        resolve25();
       };
       const finishReject = (error) => {
         clearTimeout(timer);
@@ -15747,9 +15795,9 @@ var ParserWorkerPool = class {
     for (let i = 0; i < files.length; i++) {
       chunks[i % workerCount].push(files[i]);
     }
-    return new Promise((resolve24, reject) => {
+    return new Promise((resolve25, reject) => {
       this.pending.set(batchId, {
-        resolve: resolve24,
+        resolve: resolve25,
         reject,
         accumulated: [],
         expectedWorkers: workerCount,
@@ -15780,10 +15828,10 @@ var ParserWorkerPool = class {
     await Promise.allSettled(
       workers.map(
         (w) => Promise.race([
-          new Promise((resolve24) => {
-            w.once("exit", () => resolve24());
+          new Promise((resolve25) => {
+            w.once("exit", () => resolve25());
           }),
-          new Promise((resolve24) => setTimeout(() => resolve24(), 2e3))
+          new Promise((resolve25) => setTimeout(() => resolve25(), 2e3))
         ]).then(() => {
           if (!w.threadId) return;
           return w.terminate().catch(() => {
@@ -15844,7 +15892,7 @@ function shouldUseParserWorkerPool(candidateFileCount, parseBatchCount) {
   return !isFrugalPerf() && candidateFileCount >= WORKER_POOL_THRESHOLD && parseBatchCount > 1;
 }
 function yieldEventLoop() {
-  return new Promise((resolve24) => setImmediate(resolve24));
+  return new Promise((resolve25) => setImmediate(resolve25));
 }
 function throwIfAborted(signal) {
   if (!signal?.aborted) return;
@@ -15876,7 +15924,7 @@ function normalizeComparablePath(value) {
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function gitOutput(projectRoot, args) {
-  return new Promise((resolve24, reject) => {
+  return new Promise((resolve25, reject) => {
     execFile(
       "git",
       ["-C", projectRoot, ...args],
@@ -15887,7 +15935,7 @@ function gitOutput(projectRoot, args) {
       },
       (error, stdout) => {
         if (error) reject(error);
-        else resolve24(Buffer.isBuffer(stdout) ? stdout : Buffer.from(stdout));
+        else resolve25(Buffer.isBuffer(stdout) ? stdout : Buffer.from(stdout));
       }
     );
   });
@@ -16687,7 +16735,7 @@ function callIndexOp(op, args, opts) {
       opts.signal.reason instanceof Error ? opts.signal.reason : new Error("Indexing cancelled")
     );
   }
-  return new Promise((resolve24, reject) => {
+  return new Promise((resolve25, reject) => {
     const id = nextRpcId++;
     const timer = setTimeout(() => {
       pending.delete(id);
@@ -16709,7 +16757,7 @@ function callIndexOp(op, args, opts) {
     pending.set(id, {
       resolve: (v) => {
         cleanup();
-        resolve24(v);
+        resolve25(v);
       },
       reject: (e) => {
         cleanup();
@@ -20279,7 +20327,7 @@ function findGitDir(cwd) {
   return null;
 }
 function runGit(args, cwd, signal) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     let stdout = "";
     let stderr = "";
     const child = spawn7("git", args, {
@@ -20295,8 +20343,8 @@ function runGit(args, cwd, signal) {
     child.stderr?.on("data", (c) => {
       stderr += c.toString();
     });
-    child.on("close", (code) => resolve24({ stdout, stderr, exitCode: code ?? 0 }));
-    child.on("error", (e) => resolve24({ stdout: "", stderr: e.message, exitCode: 1 }));
+    child.on("close", (code) => resolve25({ stdout, stderr, exitCode: code ?? 0 }));
+    child.on("error", (e) => resolve25({ stdout: "", stderr: e.message, exitCode: 1 }));
   });
 }
 async function fileDiff(input, ctx, _signal) {
@@ -22611,7 +22659,7 @@ var execTool = {
   }
 };
 function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     let stdout = "";
     let stderr = "";
     let killed = false;
@@ -22619,7 +22667,7 @@ function runCommand(cmd, args, cwd, timeout, signal, sessionId, danger) {
     const finish = (result) => {
       if (resolvedOnce.value) return;
       resolvedOnce.value = true;
-      resolve24(result);
+      resolve25(result);
     };
     const startedAt = Date.now();
     let stdoutBytes = 0;
@@ -23295,10 +23343,10 @@ function parseFormatterCounts(fixer, output) {
   };
 }
 async function detectFixer(cwd) {
-  const fs44 = await import("node:fs/promises");
+  const fs45 = await import("node:fs/promises");
   const exists = async (file) => {
     try {
-      await fs44.stat(`${cwd}/${file}`);
+      await fs45.stat(`${cwd}/${file}`);
       return true;
     } catch {
       return false;
@@ -23321,7 +23369,7 @@ async function detectFixer(cwd) {
     if (await exists(cfg)) return "prettier";
   }
   try {
-    const raw = await fs44.readFile(`${cwd}/package.json`, "utf8");
+    const raw = await fs45.readFile(`${cwd}/package.json`, "utf8");
     const pkg = JSON.parse(raw);
     if (pkg["prettier"] !== void 0) return "prettier";
   } catch {
@@ -23589,7 +23637,7 @@ function buildArgs(input) {
   }
 }
 function runGit2(args, cwd, signal) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     let stdout = "";
     let stderr = "";
     const child = spawn9("git", args, {
@@ -23610,7 +23658,7 @@ function runGit2(args, cwd, signal) {
       }
     });
     child.on("error", (err) => {
-      resolve24({
+      resolve25({
         command: args[0],
         stdout: normalizeCommandOutput(stdout),
         stderr: err.message,
@@ -23619,7 +23667,7 @@ function runGit2(args, cwd, signal) {
       });
     });
     child.on("close", (code) => {
-      resolve24({
+      resolve25({
         command: args[0],
         stdout: normalizeCommandOutput(stdout),
         stderr: normalizeCommandOutput(stderr),
@@ -24032,7 +24080,7 @@ var grepTool = {
 };
 var rgAvailabilityCache;
 function detectRg() {
-  rgAvailabilityCache ??= new Promise((resolve24) => {
+  rgAvailabilityCache ??= new Promise((resolve25) => {
     try {
       const p = spawn10("rg", ["--version"], {
         env: buildChildEnv5(),
@@ -24040,10 +24088,10 @@ function detectRg() {
         signal: AbortSignal.timeout(1e4),
         windowsHide: true
       });
-      p.on("error", () => resolve24(false));
-      p.on("close", (code) => resolve24(code === 0));
+      p.on("error", () => resolve25(false));
+      p.on("close", (code) => resolve25(code === 0));
     } catch {
-      resolve24(false);
+      resolve25(false);
     }
   });
   return rgAvailabilityCache;
@@ -25085,60 +25133,60 @@ function jmespathSearch(data, query) {
 }
 function validateJsonSchema(data, schema) {
   const errors = [];
-  function check(value, s, path50) {
+  function check(value, s, path51) {
     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(`${path50}: expected integer, got ${actualType}`);
+        if (!Number.isInteger(value)) errors.push(`${path51}: expected integer, got ${actualType}`);
       } else if (expectedType !== actualType) {
-        errors.push(`${path50}: expected ${expectedType}, got ${actualType}`);
+        errors.push(`${path51}: expected ${expectedType}, got ${actualType}`);
       }
     }
     if (typeof value === "string" && s["format"] === "uri" && value) {
       try {
         new URL(value);
       } catch {
-        errors.push(`${path50}: not a valid URI`);
+        errors.push(`${path51}: not a valid URI`);
       }
     }
     if (typeof value === "string" && s["pattern"]) {
       const compiled = compileUserRegex(s["pattern"], "");
       if (!compiled.ok) {
-        errors.push(`${path50}: invalid schema pattern \u2014 ${compiled.reason}`);
+        errors.push(`${path51}: invalid schema pattern \u2014 ${compiled.reason}`);
       } else if (!compiled.regex.test(capSubject(value))) {
-        errors.push(`${path50}: does not match pattern ${s["pattern"]}`);
+        errors.push(`${path51}: does not match pattern ${s["pattern"]}`);
       }
     }
     if (typeof value === "string" && s["minLength"] !== void 0 && value.length < s["minLength"]) {
-      errors.push(`${path50}: string too short (min ${s["minLength"]})`);
+      errors.push(`${path51}: string too short (min ${s["minLength"]})`);
     }
     if (typeof value === "string" && s["maxLength"] !== void 0 && value.length > s["maxLength"]) {
-      errors.push(`${path50}: string too long (max ${s["maxLength"]})`);
+      errors.push(`${path51}: string too long (max ${s["maxLength"]})`);
     }
     if (typeof value === "number" && s["minimum"] !== void 0 && value < s["minimum"]) {
-      errors.push(`${path50}: below minimum ${s["minimum"]}`);
+      errors.push(`${path51}: below minimum ${s["minimum"]}`);
     }
     if (typeof value === "number" && s["maximum"] !== void 0 && value > s["maximum"]) {
-      errors.push(`${path50}: above maximum ${s["maximum"]}`);
+      errors.push(`${path51}: 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"], `${path50}[${i}]`);
+        check(value[i], s["items"], `${path51}[${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, `${path50}.${k}`);
+        check(value[k], propSchema, `${path51}.${k}`);
       }
     }
   }
   check(data, schema, "$");
   return { valid: errors.length === 0, errors };
 }
-function simpleQuery(data, path50) {
-  const parts = path50.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+function simpleQuery(data, path51) {
+  const parts = path51.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
   let current = data;
   for (const part of parts) {
     if (current === null || current === void 0) return void 0;
@@ -28250,7 +28298,7 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
     };
   }
   args.push("--timestamps", service);
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     let stdout = "";
     let stderr = "";
     const MAX = 2e5;
@@ -28266,7 +28314,7 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve24(result);
+      resolve25(result);
     };
     const child = spawn11("docker", args, {
       cwd,
@@ -28311,7 +28359,7 @@ async function dockerLogs(service, lines, filterRe, cwd, signal, since) {
 }
 var DOCKER_LOGS_TIMEOUT_MS = 3e3;
 var MAX_TAIL_LINES = 1e5;
-async function fileLogs(path50, lines, filterRe) {
+async function fileLogs(path51, lines, filterRe) {
   const { createInterface } = await import("node:readline");
   const { createReadStream: createReadStream2 } = await import("node:fs");
   const entries = [];
@@ -28320,7 +28368,7 @@ async function fileLogs(path50, lines, filterRe) {
   let writeIdx = 0;
   let totalLines = 0;
   const rl = createInterface({
-    input: createReadStream2(path50),
+    input: createReadStream2(path51),
     crlfDelay: Number.POSITIVE_INFINITY
   });
   for await (const line of rl) {
@@ -28341,7 +28389,7 @@ async function fileLogs(path50, lines, filterRe) {
     if (parsed) entries.push(parsed);
   }
   return {
-    source: path50,
+    source: path51,
     entries,
     total: entries.length,
     truncated: totalLines > effLines,
@@ -28483,7 +28531,7 @@ var outdatedTool = {
   }
 };
 function runOutdated(manager, args, cwd, signal) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     let stdout = "";
     let stderr = "";
     const MAX = 1e5;
@@ -28508,10 +28556,10 @@ function runOutdated(manager, args, cwd, signal) {
     });
     child.on("close", (code) => {
       const result = parseOutdatedOutput(stdout, code ?? 0);
-      resolve24(result);
+      resolve25(result);
     });
     child.on("error", (e) => {
-      resolve24({
+      resolve25({
         exit_code: 1,
         packages: [],
         total: 0,
@@ -28830,7 +28878,7 @@ function runPatch(args, cwd, signal, fallback) {
   });
 }
 function runPatchProcess(command, args, cwd, signal) {
-  return new Promise((resolve24) => {
+  return new Promise((resolve25) => {
     let stdout = "";
     let stderr = "";
     const env = { ...buildChildEnv8(), LANG: "C", LC_ALL: "C" };
@@ -28849,11 +28897,11 @@ function runPatchProcess(command, args, cwd, signal) {
     });
     child.on(
       "close",
-      (code) => resolve24({ exitCode: code ?? 1, stdout, stderr, unavailable: false })
+      (code) => resolve25({ exitCode: code ?? 1, stdout, stderr, unavailable: false })
     );
     child.on(
       "error",
-      (e) => resolve24({
+      (e) => resolve25({
         exitCode: 1,
         stdout: "",
         stderr: e.message,
@@ -29642,9 +29690,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((resolve25) => {
+      const c = queue.shift();
+      if (c) resolve25(c);
+      else resolveNext = resolve25;
+    });
+    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 now2 = Date.now();
+        if (pending2.length >= STREAM_FLUSH_BYTES2 || now2 - 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";
@@ -29704,7 +30171,7 @@ var readTool = {
     const shouldIncludeSymbols = input.includeSymbols === true || input.includeSymbols !== false && ctx.meta[ADVANCED_MODE_META_KEY] === true;
     let stat22;
     try {
-      stat22 = await fs36.stat(absPath);
+      stat22 = await fs37.stat(absPath);
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") {
@@ -29756,7 +30223,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`,
@@ -29922,9 +30389,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,
@@ -30007,14 +30474,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;
       });
@@ -30022,17 +30489,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 stat22 = await fs37.stat(realPath).catch(() => null);
+      const rel = path44.relative(realRoot, realPath);
+      if (rel.startsWith("..") || path44.isAbsolute(rel)) continue;
+      const stat22 = await fs38.stat(realPath).catch(() => null);
       if (!stat22?.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 {
@@ -30055,7 +30522,7 @@ var replaceTool = {
       if (!dryRun) {
         const newContent = toStyle2(newContentLf, style);
         await atomicWrite4(realPath, newContent, { mode: stat22.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));
         }
@@ -30155,8 +30622,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 stat22 = await fs37.stat(absPath).catch(() => null);
+    if (extraGlob && !passesExtraGlob(extraGlob, path44.basename(absPath), absPath)) continue;
+    const stat22 = await fs38.stat(absPath).catch(() => null);
     if (stat22?.isFile()) {
       resolved.push(absPath);
     }
@@ -30170,7 +30637,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 {
@@ -30180,24 +30647,24 @@ async function globFiles(pattern, base, extraGlob) {
 }
 var rgAvailabilityCache2;
 function checkRg() {
-  rgAvailabilityCache2 ??= new Promise((resolve24) => {
+  rgAvailabilityCache2 ??= new Promise((resolve25) => {
     try {
-      const p = spawn14("rg", ["--version"], {
+      const p = spawn15("rg", ["--version"], {
         env: buildChildEnv9(),
         stdio: "ignore",
         windowsHide: true
       });
-      p.on("error", () => resolve24(false));
-      p.on("close", (code) => resolve24(code === 0));
+      p.on("error", () => resolve25(false));
+      p.on("close", (code) => resolve25(code === 0));
     } catch {
-      resolve24(false);
+      resolve25(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"],
@@ -30216,10 +30683,10 @@ function spawnRgFind(pattern, base) {
     }
   });
   return {
-    promise: new Promise((resolve24, reject) => {
+    promise: new Promise((resolve25, reject) => {
       child.on("error", reject);
       child.on("close", () => {
-        resolve24(buf.split("\n").filter(Boolean));
+        resolve25(buf.split("\n").filter(Boolean));
       });
     })
   };
@@ -30230,15 +30697,15 @@ async function globNative(pattern, base, extraGlob) {
   const walk2 = 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 stat22 = await fs37.lstat(full);
+        const stat22 = await fs38.lstat(full);
         if (stat22.isSymbolicLink()) continue;
       } catch {
         continue;
@@ -30262,8 +30729,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": {
@@ -30414,16 +30881,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);
@@ -30869,8 +31336,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/ },
@@ -31037,9 +31504,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 {
@@ -31087,7 +31554,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",
@@ -31127,7 +31594,7 @@ var setWorkingDirTool = {
     }
     let isDirectory = false;
     try {
-      isDirectory = (await fs40.stat(resolved)).isDirectory();
+      isDirectory = (await fs41.stat(resolved)).isDirectory();
     } catch {
       isDirectory = false;
     }
@@ -31662,7 +32129,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",
@@ -31769,7 +32236,7 @@ async function detectRunner(cwd) {
   const candidates = ["vitest.config.ts", "jest.config.js", ".mocharc.json"];
   for (const f of candidates) {
     try {
-      await stat22(path46.join(cwd, f));
+      await stat22(path47.join(cwd, f));
       if (f.includes("vitest")) return "vitest";
       if (f.includes("jest")) return "jest";
       if (f.includes("mocha")) return "mocha";
@@ -32146,8 +32613,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,
@@ -32310,7 +32777,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;
@@ -32352,7 +32819,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
@@ -32365,7 +32832,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",
@@ -32477,8 +32944,8 @@ async function findTsConfig(cwd) {
   const candidates = ["tsconfig.json", "tsconfig.base.json"];
   for (const f of candidates) {
     try {
-      const s = await stat22(path48.join(cwd, f));
-      if (s.isFile()) return path48.join(cwd, f);
+      const s = await stat22(path49.join(cwd, f));
+      if (s.isFile()) return path49.join(cwd, f);
     } catch {
     }
   }
@@ -32486,7 +32953,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,
@@ -32563,14 +33030,14 @@ async function prepareWrite(input, ctx) {
   let existed = false;
   let prev = "";
   try {
-    const stat22 = await fs42.stat(absPath);
+    const stat22 = await fs43.stat(absPath);
     existed = stat22.isFile();
     if (existed) {
       if (!ctx.hasRead(absPath)) {
-        prev = await fs42.readFile(absPath, "utf8");
+        prev = await fs43.readFile(absPath, "utf8");
         ctx.recordRead(absPath, stat22.mtimeMs, "write", sha256hex(prev));
       } else {
-        prev = await fs42.readFile(absPath, "utf8");
+        prev = await fs43.readFile(absPath, "utf8");
       }
     }
   } catch (err) {
@@ -32591,7 +33058,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 stat22 = await fs42.stat(prepared.absPath);
+  const stat22 = await fs43.stat(prepared.absPath);
   ctx.recordRead(prepared.absPath, stat22.mtimeMs, "write", sha256hex(content));
   ctx.session.recordFileChange({
     path: prepared.absPath,
@@ -32669,6 +33136,7 @@ var TIER1_TOOLS = [
 var TIER2_TOOLS = [
   replaceTool,
   execTool,
+  pwshTool,
   fetchTool,
   gitTool,
   treeTool,
@@ -32724,6 +33192,7 @@ var builtinTools = [
   grepTool,
   bashTool,
   execTool,
+  pwshTool,
   fetchTool,
   searchTool,
   todoTool,
@@ -33140,7 +33609,7 @@ var builtinToolsPack = {
 };
 
 // src/process-guardian.ts
-import * as os10 from "node:os";
+import * as os11 from "node:os";
 var ProcessGuardian = class {
   registry;
   config;
@@ -33276,7 +33745,7 @@ var ProcessGuardian = class {
         event: "process_guardian.started",
         instanceId: this.instanceId,
         mainPid: process.pid,
-        hostname: os10.hostname(),
+        hostname: os11.hostname(),
         platform: process.platform
       })
     );
@@ -33410,8 +33879,8 @@ var ProcessGuardian = class {
       instanceId: this.instanceId,
       mainPid: process.pid,
       protectedCount: this.protectedProcesses.size,
-      platform: os10.platform(),
-      hostname: os10.hostname(),
+      platform: os11.platform(),
+      hostname: os11.hostname(),
       uptime: process.uptime()
     };
   }
@@ -33441,7 +33910,7 @@ function stopProcessGuardian() {
 init_process_registry();
 
 // src/ps-slash.ts
-import * as os11 from "node:os";
+import * as os12 from "node:os";
 var IDLE_THRESHOLD_MS = 2 * 6e4;
 var STALE_THRESHOLD_MS2 = 5 * 6e4;
 function now() {
@@ -33482,7 +33951,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 ?? os11.hostname();
+    const hostname_ = firstProc?.hostname ?? os12.hostname();
     const startedAt = Math.min(...processes.map((p) => p.startedAt));
     const lastActivity = Math.max(...processes.map((p) => p.lastHeartbeat));
     const age = timestamp - lastActivity;
@@ -33570,7 +34039,7 @@ async function getGlobalProcessStatus() {
       mainPid: process.pid,
       protectedCount: 0,
       platform: process.platform,
-      hostname: os11.hostname(),
+      hostname: os12.hostname(),
       uptime: 0
     },
     allInstances: instances.map((inst) => ({
@@ -33764,8 +34233,8 @@ function createGlobalPsSlashCommand() {
 }
 
 // src/skill.ts
-import * as fs43 from "node:fs/promises";
-import * as path49 from "node:path";
+import * as fs44 from "node:fs/promises";
+import * as path50 from "node:path";
 import {
   missingRequiredRuntimeTools,
   missingRuntimeCapabilities,
@@ -33829,7 +34298,7 @@ function makeSkillTool(skillLoader) {
           field: "name"
         });
       }
-      const dir = path49.dirname(manifest.path);
+      const dir = path50.dirname(manifest.path);
       let loadedResource;
       if (input.resource?.trim()) {
         loadedResource = await loadResource(dir, input.resource.trim());
@@ -33888,15 +34357,15 @@ ${listing}${warningLine}`;
 }
 async function loadResource(skillDir, rel) {
   const norm = rel.replace(/\\/g, "/");
-  if (path49.isAbsolute(rel) || norm.split("/").some((seg) => seg === "..")) {
+  if (path50.isAbsolute(rel) || norm.split("/").some((seg) => seg === "..")) {
     throw new ToolValidationError13({
       message: `skill: invalid resource path "${rel}"`,
       field: "resource"
     });
   }
-  const absPath = path49.resolve(skillDir, rel);
-  const root = path49.resolve(skillDir);
-  if (absPath !== root && !absPath.startsWith(root + path49.sep)) {
+  const absPath = path50.resolve(skillDir, rel);
+  const root = path50.resolve(skillDir);
+  if (absPath !== root && !absPath.startsWith(root + path50.sep)) {
     throw new ToolValidationError13({
       message: `skill: resource "${rel}" escapes the skill directory`,
       field: "resource"
@@ -33905,15 +34374,15 @@ async function loadResource(skillDir, rel) {
   let realPath;
   let realRoot;
   try {
-    realRoot = await fs43.realpath(root);
-    realPath = await fs43.realpath(absPath);
+    realRoot = await fs44.realpath(root);
+    realPath = await fs44.realpath(absPath);
   } catch {
     throw new ToolValidationError13({
       message: `skill: resource "${rel}" not readable`,
       field: "resource"
     });
   }
-  if (realPath !== realRoot && !realPath.startsWith(realRoot + path49.sep)) {
+  if (realPath !== realRoot && !realPath.startsWith(realRoot + path50.sep)) {
     throw new ToolValidationError13({
       message: `skill: resource "${rel}" resolves outside the skill directory`,
       field: "resource"
@@ -33921,7 +34390,7 @@ async function loadResource(skillDir, rel) {
   }
   let buf;
   try {
-    buf = await fs43.readFile(realPath);
+    buf = await fs44.readFile(realPath);
   } catch {
     throw new ToolValidationError13({
       message: `skill: resource "${rel}" not readable`,
@@ -33950,17 +34419,17 @@ async function walk(root, dir, out) {
   if (out.length >= MAX_LISTED_RESOURCES) return;
   let entries;
   try {
-    entries = await fs43.readdir(dir, { withFileTypes: true });
+    entries = await fs44.readdir(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const e of entries) {
     if (out.length >= MAX_LISTED_RESOURCES) return;
-    const fullPath = path49.join(dir, e.name);
+    const fullPath = path50.join(dir, e.name);
     let isDir = e.isDirectory();
     if (e.isSymbolicLink()) {
       try {
-        isDir = (await fs43.stat(fullPath)).isDirectory();
+        isDir = (await fs44.stat(fullPath)).isDirectory();
       } catch {
         continue;
       }
@@ -33971,8 +34440,8 @@ async function walk(root, dir, out) {
     } else if (e.isFile()) {
       if (e.name === "SKILL.md" || e.name === "SKILL.save.md") continue;
       try {
-        const stat22 = await fs43.stat(fullPath);
-        const rel = path49.relative(root, fullPath).split(path49.sep).join("/");
+        const stat22 = await fs44.stat(fullPath);
+        const rel = path50.relative(root, fullPath).split(path50.sep).join("/");
         out.push({ path: rel, bytes: stat22.size });
       } catch {
       }
@@ -33998,6 +34467,8 @@ var TOOL_ICON_MAP = {
   // Shell/command execution
   bash: "terminal",
   exec: "terminal",
+  pwsh: "terminal",
+  powershell: "terminal",
   run: "terminal",
   command: "terminal",
   shell: "terminal",
@@ -34205,6 +34676,7 @@ export {
   OFF_ONLY_TOOLS,
   OPTIONAL_TOOLS,
   PRIMARY_LANGUAGE_PROFILES,
+  PWSH_TOOL_DESCRIPTION,
   SESSION_KANBAN_COLUMNS,
   TIER1_TOOLS,
   TIER2_TOOLS,
@@ -34332,6 +34804,7 @@ export {
   projectSessionPlanToKanban,
   projectSessionTasksToKanban,
   projectSessionTodosToKanban,
+  pwshTool,
   readTool,
   rebindSessionKanbanTask,
   recordKanbanVerificationEvidence,