reasonix 0.25.0 → 0.25.1

package/dist/index.js

@@ -47,8 +47,8 @@ function computeWait(attempt, initial, cap, retryAfter) {
 }
 function sleep(ms, signal) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve9, reject) => {
-    const timer = setTimeout(resolve9, ms);
+  return new Promise((resolve10, reject) => {
+    const timer = setTimeout(resolve10, ms);
     if (signal) {
       const onAbort = () => {
         clearTimeout(timer);
@@ -523,7 +523,7 @@ function matchesTool(hook, toolName) {
 }
 var HOOK_OUTPUT_CAP_BYTES = 256 * 1024;
 function defaultSpawner(input) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const child = spawn(input.command, {
       cwd: input.cwd,
       shell: true,
@@ -568,7 +568,7 @@ function defaultSpawner(input) {
     child.stderr.on("data", (chunk) => onChunk("stderr", chunk));
     child.once("error", (err) => {
       clearTimeout(timer);
-      resolve9({
+      resolve10({
         exitCode: null,
         stdout: Buffer.concat(stdoutChunks).toString("utf8"),
         stderr: Buffer.concat(stderrChunks).toString("utf8"),
@@ -579,7 +579,7 @@ function defaultSpawner(input) {
     });
     child.once("close", (code) => {
       clearTimeout(timer);
-      resolve9({
+      resolve10({
         exitCode: code,
         stdout: Buffer.concat(stdoutChunks).toString("utf8").trim(),
         stderr: Buffer.concat(stderrChunks).toString("utf8").trim(),
@@ -2310,8 +2310,8 @@ var CacheFirstLoop = class {
             }
           );
           for (let k = 0; k < budget; k++) {
-            const sample = queue.shift() ?? await new Promise((resolve9) => {
-              waiter = resolve9;
+            const sample = queue.shift() ?? await new Promise((resolve10) => {
+              waiter = resolve10;
             });
             yield {
               turn: this._turn,
@@ -5367,9 +5367,9 @@ function forkRegistryExcluding(parent, exclude) {
 }
 
 // src/tools/shell.ts
-import { spawn as spawn3, spawnSync } from "child_process";
+import { spawn as spawn4, spawnSync } from "child_process";
 import { existsSync as existsSync8, statSync as statSync4 } from "fs";
-import * as pathMod3 from "path";
+import * as pathMod4 from "path";
 
 // src/tools/jobs.ts
 import { spawn as spawn2 } from "child_process";
@@ -5659,6 +5659,417 @@ function snapshot(job) {
   };
 }
 
+// src/tools/shell-chain.ts
+import { spawn as spawn3 } from "child_process";
+import { closeSync, openSync } from "fs";
+import * as pathMod3 from "path";
+var UnsupportedSyntaxError = class extends Error {
+  constructor(detail) {
+    super(`run_command: ${detail}`);
+    this.name = "UnsupportedSyntaxError";
+  }
+};
+function splitOnChainOps(cmd) {
+  const segs = [];
+  const ops = [];
+  let segStart = 0;
+  let i = 0;
+  let quote = null;
+  let atTokenStart = true;
+  while (i < cmd.length) {
+    const ch = cmd[i];
+    if (quote) {
+      if (ch === quote) quote = null;
+      else if (ch === "\\" && quote === '"' && i + 1 < cmd.length) i++;
+      i++;
+      atTokenStart = false;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      i++;
+      atTokenStart = false;
+      continue;
+    }
+    if (ch === " " || ch === "	") {
+      i++;
+      atTokenStart = true;
+      continue;
+    }
+    if (atTokenStart) {
+      let op = null;
+      let opLen = 0;
+      const next = cmd[i + 1];
+      if (ch === "|" && next === "|") {
+        op = "||";
+        opLen = 2;
+      } else if (ch === "&" && next === "&") {
+        op = "&&";
+        opLen = 2;
+      } else if (ch === "|") {
+        op = "|";
+        opLen = 1;
+      } else if (ch === ";") {
+        op = ";";
+        opLen = 1;
+      }
+      if (op !== null) {
+        segs.push(cmd.slice(segStart, i));
+        ops.push(op);
+        i += opLen;
+        segStart = i;
+        atTokenStart = true;
+        continue;
+      }
+    }
+    i++;
+    atTokenStart = false;
+  }
+  segs.push(cmd.slice(segStart));
+  return { segs, ops };
+}
+function parseSegment(segStr) {
+  const argv = [];
+  const redirects = [];
+  let cur = "";
+  let curHasContent = false;
+  let pending = null;
+  let quote = null;
+  const flush = () => {
+    if (!curHasContent && cur.length === 0) return;
+    if (pending) {
+      redirects.push({ kind: pending, target: cur });
+      pending = null;
+    } else {
+      argv.push(cur);
+    }
+    cur = "";
+    curHasContent = false;
+  };
+  let i = 0;
+  while (i < segStr.length) {
+    const ch = segStr[i];
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else if (ch === "\\" && quote === '"' && i + 1 < segStr.length) {
+        cur += segStr[++i] ?? "";
+        curHasContent = true;
+      } else {
+        cur += ch;
+        curHasContent = true;
+      }
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      curHasContent = true;
+      i++;
+      continue;
+    }
+    if (ch === " " || ch === "	") {
+      flush();
+      i++;
+      continue;
+    }
+    if (cur.length === 0 && !curHasContent) {
+      const remaining = segStr.slice(i);
+      let matched = null;
+      if (remaining.startsWith("2>&1")) matched = { op: "2>&1", len: 4 };
+      else if (remaining.startsWith("&>")) matched = { op: "&>", len: 2 };
+      else if (remaining.startsWith("2>>")) matched = { op: "2>>", len: 3 };
+      else if (remaining.startsWith("2>")) matched = { op: "2>", len: 2 };
+      else if (remaining.startsWith(">>")) matched = { op: ">>", len: 2 };
+      else if (remaining.startsWith(">")) matched = { op: ">", len: 1 };
+      else if (remaining.startsWith("<<")) {
+        throw new UnsupportedSyntaxError(
+          `shell operator "<<" is not supported \u2014 heredoc / here-string is not implemented; pass input via a "<" file or the binary's --input flag`
+        );
+      } else if (remaining.startsWith("<")) matched = { op: "<", len: 1 };
+      if (matched) {
+        if (pending !== null) {
+          throw new UnsupportedSyntaxError(
+            `redirect "${pending}" is missing a target file before "${matched.op}"`
+          );
+        }
+        if (matched.op === "2>&1") {
+          redirects.push({ kind: "2>&1", target: "" });
+        } else {
+          pending = matched.op;
+        }
+        i += matched.len;
+        continue;
+      }
+      if (ch === "&") {
+        throw new UnsupportedSyntaxError(
+          'shell operator "&" is not supported \u2014 background runs need run_background, not run_command. Wrap a literal `&` arg in quotes.'
+        );
+      }
+    }
+    cur += ch;
+    curHasContent = true;
+    i++;
+  }
+  if (quote) throw new Error(`unclosed ${quote} in command`);
+  flush();
+  if (pending) throw new UnsupportedSyntaxError(`redirect "${pending}" is missing a target file`);
+  if (argv.length === 0 && redirects.length > 0) {
+    throw new UnsupportedSyntaxError(
+      "redirect without a command \u2014 segment must have at least one program argument"
+    );
+  }
+  validateRedirectFds(redirects);
+  return { argv, redirects };
+}
+function validateRedirectFds(redirects) {
+  let stdin = 0;
+  let stdout = 0;
+  let stderr = 0;
+  for (const r of redirects) {
+    if (r.kind === "<") stdin++;
+    else if (r.kind === ">" || r.kind === ">>") stdout++;
+    else if (r.kind === "2>" || r.kind === "2>>" || r.kind === "2>&1") stderr++;
+    else if (r.kind === "&>") {
+      stdout++;
+      stderr++;
+    }
+  }
+  if (stdin > 1) throw new UnsupportedSyntaxError("multiple `<` stdin redirects in one segment");
+  if (stdout > 1)
+    throw new UnsupportedSyntaxError(
+      "multiple stdout redirects in one segment (`>` / `>>` / `&>` conflict)"
+    );
+  if (stderr > 1)
+    throw new UnsupportedSyntaxError(
+      "multiple stderr redirects in one segment (`2>` / `2>>` / `&>` / `2>&1` conflict)"
+    );
+}
+function parseCommandChain(cmd) {
+  const { segs, ops } = splitOnChainOps(cmd);
+  const segments = [];
+  for (let i = 0; i < segs.length; i++) {
+    const trimmed = segs[i].trim();
+    if (trimmed.length === 0) {
+      const op = i === 0 ? ops[0] : ops[i - 1];
+      throw new UnsupportedSyntaxError(
+        i === 0 ? `empty segment before "${op}"` : i === segs.length - 1 ? `chain ends with "${op}"` : `empty segment between "${ops[i - 1]}" and "${ops[i]}"`
+      );
+    }
+    segments.push(parseSegment(trimmed));
+  }
+  if (ops.length === 0 && segments[0].redirects.length === 0) return null;
+  return { segments, ops };
+}
+function chainAllowed(chain, isAllowed2) {
+  for (const seg of chain.segments) {
+    if (!isAllowed2(seg.argv.join(" "))) return false;
+  }
+  return true;
+}
+function groupChain(chain) {
+  const groups = [{ segments: [chain.segments[0]], opBefore: null }];
+  for (let i = 0; i < chain.ops.length; i++) {
+    const op = chain.ops[i];
+    const next = chain.segments[i + 1];
+    if (op === "|") {
+      groups[groups.length - 1].segments.push(next);
+    } else {
+      groups.push({ segments: [next], opBefore: op });
+    }
+  }
+  return groups;
+}
+async function runChain(chain, opts) {
+  const groups = groupChain(chain);
+  const buf = new OutputBuffer(opts.maxOutputChars * 2 * 4);
+  const deadline = Date.now() + opts.timeoutSec * 1e3;
+  let lastExit = 0;
+  let timedOut = false;
+  for (const group of groups) {
+    if (group.opBefore === "&&" && lastExit !== 0) continue;
+    if (group.opBefore === "||" && lastExit === 0) continue;
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      timedOut = true;
+      break;
+    }
+    const result = await runPipeGroup(group.segments, {
+      cwd: opts.cwd,
+      timeoutMs: remainingMs,
+      buf,
+      signal: opts.signal
+    });
+    lastExit = result.exitCode;
+    if (result.timedOut) {
+      timedOut = true;
+      break;
+    }
+    if (opts.signal?.aborted) break;
+  }
+  const output = buf.toString();
+  const truncated = output.length > opts.maxOutputChars ? `${output.slice(0, opts.maxOutputChars)}
+
+[\u2026 truncated ${output.length - opts.maxOutputChars} chars \u2026]` : output;
+  return { exitCode: lastExit, output: truncated, timedOut };
+}
+function openRedirects(redirects, cwd) {
+  let stdinFd = null;
+  let stdoutFd = null;
+  let stderrFd = null;
+  let mergeStderrToStdout = false;
+  let bothFd = null;
+  const toClose = [];
+  const open = (target, flags) => {
+    const resolved = pathMod3.resolve(cwd, target);
+    const fd = openSync(resolved, flags);
+    toClose.push(fd);
+    return fd;
+  };
+  for (const r of redirects) {
+    if (r.kind === "<") stdinFd = open(r.target, "r");
+    else if (r.kind === ">") stdoutFd = open(r.target, "w");
+    else if (r.kind === ">>") stdoutFd = open(r.target, "a");
+    else if (r.kind === "2>") stderrFd = open(r.target, "w");
+    else if (r.kind === "2>>") stderrFd = open(r.target, "a");
+    else if (r.kind === "&>") {
+      bothFd = open(r.target, "w");
+      stdoutFd = bothFd;
+      stderrFd = bothFd;
+    } else if (r.kind === "2>&1") {
+      mergeStderrToStdout = true;
+    }
+  }
+  return { stdinFd, stdoutFd, stderrFd, mergeStderrToStdout, toClose };
+}
+async function runPipeGroup(segments, opts) {
+  const env = { ...process.env, PYTHONIOENCODING: "utf-8", PYTHONUTF8: "1" };
+  const children = [];
+  const allFds = [];
+  let timedOut = false;
+  const killAll = () => {
+    for (const c of children) killProcessTree2(c);
+  };
+  const killTimer = setTimeout(() => {
+    timedOut = true;
+    killAll();
+  }, opts.timeoutMs);
+  const onAbort = () => killAll();
+  if (opts.signal?.aborted) {
+    onAbort();
+  } else {
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
+  }
+  try {
+    for (let i = 0; i < segments.length; i++) {
+      const isFirst = i === 0;
+      const isLast = i === segments.length - 1;
+      const seg = segments[i];
+      const io = openRedirects(seg.redirects, opts.cwd);
+      allFds.push(...io.toClose);
+      const { bin, args, spawnOverrides } = prepareSpawn(seg.argv);
+      const stdoutSpec = io.stdoutFd !== null ? io.stdoutFd : "pipe";
+      const stderrSpec = io.stderrFd !== null ? io.stderrFd : io.mergeStderrToStdout ? stdoutSpec : "pipe";
+      const stdinSpec = io.stdinFd !== null ? io.stdinFd : isFirst ? "ignore" : "pipe";
+      const spawnOpts = {
+        cwd: opts.cwd,
+        shell: false,
+        windowsHide: true,
+        env,
+        stdio: [stdinSpec, stdoutSpec, stderrSpec],
+        ...spawnOverrides
+      };
+      let child;
+      try {
+        child = spawn3(bin, args, spawnOpts);
+      } catch (err) {
+        for (const fd of allFds) tryClose(fd);
+        killAll();
+        clearTimeout(killTimer);
+        opts.signal?.removeEventListener("abort", onAbort);
+        throw err;
+      }
+      children.push(child);
+      if (!isFirst && io.stdinFd === null) {
+        const prev = children[i - 1];
+        prev.stdout?.on("error", () => {
+        });
+        child.stdin?.on("error", () => {
+        });
+        const prevMergesStderr = segments[i - 1].redirects.some((r) => r.kind === "2>&1") && !!prev.stderr;
+        if (prevMergesStderr && prev.stderr) {
+          prev.stderr.on("error", () => {
+          });
+          let openSources = 2;
+          const closeIfDone = () => {
+            if (--openSources === 0) child.stdin?.end();
+          };
+          prev.stdout?.pipe(child.stdin, { end: false });
+          prev.stderr.pipe(child.stdin, { end: false });
+          prev.stdout?.once("end", closeIfDone);
+          prev.stderr.once("end", closeIfDone);
+        } else {
+          prev.stdout?.pipe(child.stdin);
+        }
+      }
+      if (child.stderr && io.stderrFd === null && !(io.mergeStderrToStdout && !isLast)) {
+        child.stderr.on("data", (chunk) => opts.buf.push(toBuf(chunk)));
+      }
+      if (isLast && child.stdout && io.stdoutFd === null) {
+        child.stdout.on("data", (chunk) => opts.buf.push(toBuf(chunk)));
+        if (io.mergeStderrToStdout && child.stderr && io.stderrFd === null) {
+          child.stderr.removeAllListeners("data");
+          child.stderr.on("data", (chunk) => opts.buf.push(toBuf(chunk)));
+        }
+      }
+    }
+    const exits = await Promise.all(
+      children.map(
+        (c) => new Promise((resolve10) => {
+          c.once("error", () => resolve10(null));
+          c.once("close", (code) => resolve10(code));
+        })
+      )
+    );
+    return { exitCode: exits[exits.length - 1] ?? null, timedOut };
+  } finally {
+    for (const fd of allFds) tryClose(fd);
+    clearTimeout(killTimer);
+    opts.signal?.removeEventListener("abort", onAbort);
+  }
+}
+function tryClose(fd) {
+  try {
+    closeSync(fd);
+  } catch {
+  }
+}
+function toBuf(chunk) {
+  return typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+}
+var OutputBuffer = class {
+  constructor(cap) {
+    this.cap = cap;
+  }
+  cap;
+  chunks = [];
+  bytes = 0;
+  push(b) {
+    if (this.bytes >= this.cap) return;
+    const remaining = this.cap - this.bytes;
+    if (b.length > remaining) {
+      this.chunks.push(b.subarray(0, remaining));
+      this.bytes = this.cap;
+    } else {
+      this.chunks.push(b);
+      this.bytes += b.length;
+    }
+  }
+  toString() {
+    return smartDecodeOutput(Buffer.concat(this.chunks));
+  }
+};
+
 // src/tools/shell.ts
 function killProcessTree2(child) {
   if (!child.pid || child.killed) return;
@@ -5830,17 +6241,31 @@ function isAllowed(cmd, extra = []) {
   }
   return false;
 }
+function isCommandAllowed(cmd, extra = []) {
+  let chain;
+  try {
+    chain = parseCommandChain(cmd);
+  } catch {
+    return false;
+  }
+  if (chain === null) return isAllowed(cmd, extra);
+  return chainAllowed(chain, (seg) => isAllowed(seg, extra));
+}
 async function runCommand(cmd, opts) {
+  const timeoutSec = opts.timeoutSec ?? DEFAULT_TIMEOUT_SEC;
+  const maxChars = opts.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
   const argv = tokenizeCommand(cmd);
   if (argv.length === 0) throw new Error("run_command: empty command");
-  const operator = detectShellOperator(cmd);
-  if (operator !== null) {
-    throw new Error(
-      `run_command: shell operator "${operator}" is not supported \u2014 this tool spawns one process, no shell expansion. Split into separate run_command calls and combine the output in your reasoning (e.g. instead of \`grep foo *.ts | wc -l\`, call \`grep -c foo *.ts\` or two separate commands). To pass "${operator}" as a literal argument, wrap it in quotes.`
-    );
+  const chain = parseCommandChain(cmd);
+  if (chain !== null) {
+    return await runChain(chain, {
+      cwd: opts.cwd,
+      timeoutSec,
+      maxOutputChars: maxChars,
+      signal: opts.signal
+    });
   }
-  const timeoutMs = (opts.timeoutSec ?? DEFAULT_TIMEOUT_SEC) * 1e3;
-  const maxChars = opts.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
+  const timeoutMs = timeoutSec * 1e3;
   const spawnOpts = {
     cwd: opts.cwd,
     shell: false,
@@ -5858,10 +6283,10 @@ async function runCommand(cmd, opts) {
   };
   const { bin, args, spawnOverrides } = prepareSpawn(argv);
   const effectiveSpawnOpts = { ...spawnOpts, ...spawnOverrides };
-  return await new Promise((resolve9, reject) => {
+  return await new Promise((resolve10, reject) => {
     let child;
     try {
-      child = spawn3(bin, args, effectiveSpawnOpts);
+      child = spawn4(bin, args, effectiveSpawnOpts);
     } catch (err) {
       reject(err);
       return;
@@ -5912,7 +6337,7 @@ async function runCommand(cmd, opts) {
       const output = buf.length > maxChars ? `${buf.slice(0, maxChars)}
 
 [\u2026 truncated ${buf.length - maxChars} chars \u2026]` : buf;
-      resolve9({ exitCode: code, output, timedOut });
+      resolve10({ exitCode: code, output, timedOut });
     });
   });
 }
@@ -5934,16 +6359,16 @@ function resolveExecutable(cmd, opts = {}) {
   const platform = opts.platform ?? process.platform;
   if (platform !== "win32") return cmd;
   if (!cmd) return cmd;
-  if (cmd.includes("/") || cmd.includes("\\") || pathMod3.isAbsolute(cmd)) return cmd;
-  if (pathMod3.extname(cmd)) return cmd;
+  if (cmd.includes("/") || cmd.includes("\\") || pathMod4.isAbsolute(cmd)) return cmd;
+  if (pathMod4.extname(cmd)) return cmd;
   const env = opts.env ?? process.env;
   const pathExt = (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").map((e) => e.trim()).filter(Boolean);
-  const delimiter2 = opts.pathDelimiter ?? (platform === "win32" ? ";" : pathMod3.delimiter);
+  const delimiter2 = opts.pathDelimiter ?? (platform === "win32" ? ";" : pathMod4.delimiter);
   const pathDirs = (env.PATH ?? "").split(delimiter2).filter(Boolean);
   const isFile = opts.isFile ?? defaultIsFile;
   for (const dir of pathDirs) {
     for (const ext of pathExt) {
-      const full = pathMod3.win32.join(dir, cmd + ext);
+      const full = pathMod4.win32.join(dir, cmd + ext);
       if (isFile(full)) return full;
     }
   }
@@ -6013,8 +6438,8 @@ function withUtf8Codepage(cmdline) {
 function isBareWindowsName(s) {
   if (!s) return false;
   if (s.includes("/") || s.includes("\\")) return false;
-  if (pathMod3.isAbsolute(s)) return false;
-  if (pathMod3.extname(s)) return false;
+  if (pathMod4.isAbsolute(s)) return false;
+  if (pathMod4.extname(s)) return false;
   return true;
 }
 function quoteForCmdExe(arg) {
@@ -6033,7 +6458,7 @@ var NeedsConfirmationError = class extends Error {
   }
 };
 function registerShellTools(registry, opts) {
-  const rootDir = pathMod3.resolve(opts.rootDir);
+  const rootDir = pathMod4.resolve(opts.rootDir);
   const timeoutSec = opts.timeoutSec ?? DEFAULT_TIMEOUT_SEC;
   const maxOutputChars = opts.maxOutputChars ?? DEFAULT_MAX_OUTPUT_CHARS;
   const jobs = opts.jobs ?? new JobRegistry();
@@ -6044,7 +6469,7 @@ function registerShellTools(registry, opts) {
   const isAllowAll = typeof opts.allowAll === "function" ? opts.allowAll : () => opts.allowAll === true;
   registry.register({
     name: "run_command",
-    description: "Run a shell command in the project root and return its combined stdout+stderr.\n\nConstraints (read these before the first call):\n\u2022 ONE process per call, NO shell expansion. `&&`, `||`, `|`, `;`, `>`, `<`, `2>&1` are all rejected up-front \u2014 split into separate calls and combine results in reasoning. Example: instead of `grep foo *.ts | wc -l`, use `grep -c foo *.ts`; instead of `cd sub && npm test`, use `npm test --prefix sub` (or whatever --cwd flag the binary accepts).\n\u2022 `cd` DOES NOT PERSIST between calls \u2014 each call spawns a fresh process rooted at the project. If a tool needs a subdirectory, pass it via the tool's own flag (`npm --prefix`, `cargo -C`, `git -C`, `pytest tests/\u2026`), NOT via a preceding `cd`.\n\u2022 Avoid commands with unbounded output (`netstat -ano`, `find /`, etc.) \u2014 they waste tokens. Filter at source: `netstat -ano -p TCP`, `find src -name '*.ts'`, `grep -c`, `wc -l`.\n\nCommon read-only inspection and test/lint/typecheck commands run immediately; anything that could mutate state, install dependencies, or touch the network is refused until the user confirms it in the TUI. Prefer this over asking the user to run a command manually \u2014 after edits, run the project's tests to verify.",
+    description: "Run a shell command in the project root and return its combined stdout+stderr.\n\nConstraints (read these before the first call):\n\u2022 Chain operators `|`, `||`, `&&`, `;` ARE supported \u2014 parsed natively, no shell invoked, so semantics are identical on Windows / macOS / Linux. Each chain segment is allowlist-checked individually: `git status | grep main` runs if both halves are allowed.\n\u2022 File redirects ARE supported: `>` truncate, `>>` append, `<` stdin from file, `2>` / `2>>` stderr to file, `2>&1` merge stderr\u2192stdout, `&>` both to file. Targets resolve relative to the project root. At most one redirect per fd per segment.\n\u2022 Background `&`, heredoc `<<`, command substitution `$(\u2026)`, subshells `(\u2026)`, and process substitution `<(\u2026)` are NOT supported. Wrap a literal `&` arg in quotes; for input use a `<` file or the binary's own --input flag.\n\u2022 Env-var expansion `$VAR` is NOT performed \u2014 `$VAR` is passed as a literal string. Use the binary's own --env flag or substitute the value yourself.\n\u2022 `cd` DOES NOT PERSIST between calls \u2014 each call spawns a fresh process rooted at the project. If a tool needs a subdirectory, pass it via the tool's own flag (`npm --prefix`, `cargo -C`, `git -C`, `pytest tests/\u2026`), NOT via a preceding `cd`.\n\u2022 Glob patterns (`*.ts`) are passed through as literal arguments \u2014 no shell expansion. Use `grep -r`, `rg`, `find -name`, etc.\n\u2022 Avoid commands with unbounded output (`netstat -ano`, `find /`, etc.) \u2014 they waste tokens. Filter at source: `netstat -ano -p TCP`, `find src -name '*.ts'`, `grep -c`, `wc -l`.\n\nCommon read-only inspection and test/lint/typecheck commands run immediately; anything that could mutate state, install dependencies, or touch the network is refused until the user confirms it in the TUI. Prefer this over asking the user to run a command manually \u2014 after edits, run the project's tests to verify.",
     // Plan-mode gate: allow allowlisted commands through (git status,
     // cargo check, ls, grep …) so the model can actually investigate
     // during planning. Anything that would otherwise trigger a
@@ -6053,14 +6478,14 @@ function registerShellTools(registry, opts) {
       if (isAllowAll()) return true;
       const cmd = typeof args?.command === "string" ? args.command.trim() : "";
       if (!cmd) return false;
-      return isAllowed(cmd, getExtraAllowed());
+      return isCommandAllowed(cmd, getExtraAllowed());
     },
     parameters: {
       type: "object",
       properties: {
         command: {
           type: "string",
-          description: 'Full command line. Tokenized with POSIX-ish quoting; no shell expansion. Pipes (`|`), redirects (`>`, `<`, `2>`), and `&&`/`||` chaining are rejected with an error \u2014 split into separate calls instead. To pass an operator character as a literal argument (e.g. a regex), wrap it in quotes: `grep "a|b" file.txt`.'
+          description: 'Full command line. POSIX-ish quoting. Chain operators `|`, `||`, `&&`, `;` and file redirects `>` / `>>` / `<` / `2>` / `2>>` / `2>&1` / `&>` work natively (no shell). Background `&`, heredoc `<<`, env-var expansion `$VAR`, and command substitution `$(\u2026)` are rejected (or passed through as literal in the case of `$VAR`). To pass an operator character as a literal argument (e.g. a regex), wrap it in quotes: `grep "a|b" file.txt`.'
         },
         timeoutSec: {
           type: "integer",
@@ -6072,7 +6497,7 @@ function registerShellTools(registry, opts) {
     fn: async (args, ctx) => {
       const cmd = args.command.trim();
       if (!cmd) throw new Error("run_command: empty command");
-      if (!isAllowAll() && !isAllowed(cmd, getExtraAllowed())) {
+      if (!isAllowAll() && !isCommandAllowed(cmd, getExtraAllowed())) {
         throw new NeedsConfirmationError(cmd);
       }
       const effectiveTimeout = Math.max(1, Math.min(600, args.timeoutSec ?? timeoutSec));
@@ -6436,11 +6861,11 @@ ${i + 1}. ${r.title}`);
 
 // src/env.ts
 import { readFileSync as readFileSync9 } from "fs";
-import { resolve as resolve7 } from "path";
+import { resolve as resolve8 } from "path";
 function loadDotenv(path2 = ".env") {
   let raw;
   try {
-    raw = readFileSync9(resolve7(process.cwd(), path2), "utf8");
+    raw = readFileSync9(resolve8(process.cwd(), path2), "utf8");
   } catch {
     return;
   }
@@ -7194,7 +7619,7 @@ var McpClient = class {
     const id = this.nextId++;
     const frame = { jsonrpc: "2.0", id, method, params };
     let abortHandler = null;
-    const promise = new Promise((resolve9, reject) => {
+    const promise = new Promise((resolve10, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
         if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
@@ -7203,7 +7628,7 @@ var McpClient = class {
         );
       }, this.requestTimeoutMs);
       this.pending.set(id, {
-        resolve: resolve9,
+        resolve: resolve10,
         reject,
         timeout
       });
@@ -7285,7 +7710,7 @@ var McpClient = class {
 };
 
 // src/mcp/stdio.ts
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 var StdioTransport = class {
   child;
   queue = [];
@@ -7300,14 +7725,14 @@ var StdioTransport = class {
         opts.command,
         ...(opts.args ?? []).map((a) => quoteArg(a, process.platform === "win32"))
       ].join(" ");
-      this.child = spawn4(line, [], {
+      this.child = spawn5(line, [], {
         env,
         cwd: opts.cwd,
         stdio: ["pipe", "pipe", "inherit"],
         shell: true
       });
     } else {
-      this.child = spawn4(opts.command, opts.args ?? [], {
+      this.child = spawn5(opts.command, opts.args ?? [], {
         env,
         cwd: opts.cwd,
         stdio: ["pipe", "pipe", "inherit"]
@@ -7326,12 +7751,12 @@ var StdioTransport = class {
   }
   async send(message) {
     if (this.closed) throw new Error("MCP transport is closed");
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       const line = `${JSON.stringify(message)}
 `;
       this.child.stdin.write(line, "utf8", (err) => {
         if (err) reject(err);
-        else resolve9();
+        else resolve10();
       });
     });
   }
@@ -7342,8 +7767,8 @@ var StdioTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve9) => {
-        this.waiters.push(resolve9);
+      const next = await new Promise((resolve10) => {
+        this.waiters.push(resolve10);
       });
       if (next === null) return;
       yield next;
@@ -7412,8 +7837,8 @@ var SseTransport = class {
   constructor(opts) {
     this.url = opts.url;
     this.headers = opts.headers ?? {};
-    this.endpointReady = new Promise((resolve9, reject) => {
-      this.resolveEndpoint = resolve9;
+    this.endpointReady = new Promise((resolve10, reject) => {
+      this.resolveEndpoint = resolve10;
       this.rejectEndpoint = reject;
     });
     this.endpointReady.catch(() => void 0);
@@ -7440,8 +7865,8 @@ var SseTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve9) => {
-        this.waiters.push(resolve9);
+      const next = await new Promise((resolve10) => {
+        this.waiters.push(resolve10);
       });
       if (next === null) return;
       yield next;
@@ -7627,8 +8052,8 @@ var StreamableHttpTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve9) => {
-        this.waiters.push(resolve9);
+      const next = await new Promise((resolve10) => {
+        this.waiters.push(resolve10);
       });
       if (next === null) return;
       yield next;
@@ -7799,7 +8224,7 @@ async function trySection(load) {
 
 // src/code/edit-blocks.ts
 import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync12, unlinkSync as unlinkSync3, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname5, resolve as resolve8 } from "path";
+import { dirname as dirname5, resolve as resolve9 } from "path";
 var BLOCK_RE = /^(\S[^\n]*)\n<{7} SEARCH\n([\s\S]*?)\n?={7}\n([\s\S]*?)\n?>{7} REPLACE/gm;
 function parseEditBlocks(text) {
   const out = [];
@@ -7817,8 +8242,8 @@ function parseEditBlocks(text) {
   return out;
 }
 function applyEditBlock(block, rootDir) {
-  const absRoot = resolve8(rootDir);
-  const absTarget = resolve8(absRoot, block.path);
+  const absRoot = resolve9(rootDir);
+  const absTarget = resolve9(absRoot, block.path);
   if (absTarget !== absRoot && !absTarget.startsWith(`${absRoot}${sep()}`)) {
     return {
       path: block.path,
@@ -7871,13 +8296,13 @@ function applyEditBlocks(blocks, rootDir) {
   return blocks.map((b) => applyEditBlock(b, rootDir));
 }
 function snapshotBeforeEdits(blocks, rootDir) {
-  const absRoot = resolve8(rootDir);
+  const absRoot = resolve9(rootDir);
   const seen = /* @__PURE__ */ new Set();
   const snapshots = [];
   for (const b of blocks) {
     if (seen.has(b.path)) continue;
     seen.add(b.path);
-    const abs = resolve8(absRoot, b.path);
+    const abs = resolve9(absRoot, b.path);
     if (!existsSync10(abs)) {
       snapshots.push({ path: b.path, prevContent: null });
       continue;
@@ -7891,9 +8316,9 @@ function snapshotBeforeEdits(blocks, rootDir) {
   return snapshots;
 }
 function restoreSnapshots(snapshots, rootDir) {
-  const absRoot = resolve8(rootDir);
+  const absRoot = resolve9(rootDir);
   return snapshots.map((snap) => {
-    const abs = resolve8(absRoot, snap.path);
+    const abs = resolve9(absRoot, snap.path);
     if (abs !== absRoot && !abs.startsWith(`${absRoot}${sep()}`)) {
       return {
         path: snap.path,