reasonix 0.25.0 → 0.25.1

package/dist/cli/index.js

@@ -1737,8 +1737,8 @@ function computeWait(attempt, initial, cap, retryAfter) {
 }
 function sleep(ms, signal) {
   if (ms <= 0) return Promise.resolve();
-  return new Promise((resolve11, reject) => {
-    const timer = setTimeout(resolve11, ms);
+  return new Promise((resolve12, reject) => {
+    const timer = setTimeout(resolve12, ms);
     if (signal) {
       const onAbort = () => {
         clearTimeout(timer);
@@ -2209,7 +2209,7 @@ function matchesTool(hook, toolName) {
 }
 var HOOK_OUTPUT_CAP_BYTES = 256 * 1024;
 function defaultSpawner(input) {
-  return new Promise((resolve11) => {
+  return new Promise((resolve12) => {
     const child = spawn(input.command, {
       cwd: input.cwd,
       shell: true,
@@ -2254,7 +2254,7 @@ function defaultSpawner(input) {
     child.stderr.on("data", (chunk) => onChunk("stderr", chunk));
     child.once("error", (err) => {
       clearTimeout(timer);
-      resolve11({
+      resolve12({
         exitCode: null,
         stdout: Buffer.concat(stdoutChunks).toString("utf8"),
         stderr: Buffer.concat(stderrChunks).toString("utf8"),
@@ -2265,7 +2265,7 @@ function defaultSpawner(input) {
     });
     child.once("close", (code) => {
       clearTimeout(timer);
-      resolve11({
+      resolve12({
         exitCode: code,
         stdout: Buffer.concat(stdoutChunks).toString("utf8").trim(),
         stderr: Buffer.concat(stderrChunks).toString("utf8").trim(),
@@ -4093,8 +4093,8 @@ var CacheFirstLoop = class {
             }
           );
           for (let k = 0; k < budget3; k++) {
-            const sample = queue.shift() ?? await new Promise((resolve11) => {
-              waiter = resolve11;
+            const sample = queue.shift() ?? await new Promise((resolve12) => {
+              waiter = resolve12;
             });
             yield {
               turn: this._turn,
@@ -6335,9 +6335,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 existsSync5, statSync as statSync3 } from "fs";
-import * as pathMod3 from "path";
+import * as pathMod4 from "path";
 
 // src/tools/jobs.ts
 import { spawn as spawn2 } from "child_process";
@@ -6627,6 +6627,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 quote2 = null;
+  let atTokenStart = true;
+  while (i < cmd.length) {
+    const ch = cmd[i];
+    if (quote2) {
+      if (ch === quote2) quote2 = null;
+      else if (ch === "\\" && quote2 === '"' && i + 1 < cmd.length) i++;
+      i++;
+      atTokenStart = false;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote2 = 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 quote2 = 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 (quote2) {
+      if (ch === quote2) {
+        quote2 = null;
+      } else if (ch === "\\" && quote2 === '"' && i + 1 < segStr.length) {
+        cur += segStr[++i] ?? "";
+        curHasContent = true;
+      } else {
+        cur += ch;
+        curHasContent = true;
+      }
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote2 = 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 (quote2) throw new Error(`unclosed ${quote2} 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 stdin5 = 0;
+  let stdout4 = 0;
+  let stderr = 0;
+  for (const r of redirects) {
+    if (r.kind === "<") stdin5++;
+    else if (r.kind === ">" || r.kind === ">>") stdout4++;
+    else if (r.kind === "2>" || r.kind === "2>>" || r.kind === "2>&1") stderr++;
+    else if (r.kind === "&>") {
+      stdout4++;
+      stderr++;
+    }
+  }
+  if (stdin5 > 1) throw new UnsupportedSyntaxError("multiple `<` stdin redirects in one segment");
+  if (stdout4 > 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 env2 = { ...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: env2,
+        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((resolve12) => {
+          c.once("error", () => resolve12(null));
+          c.once("close", (code) => resolve12(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;
@@ -6798,17 +7209,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,
@@ -6826,10 +7251,10 @@ async function runCommand(cmd, opts) {
   };
   const { bin, args, spawnOverrides } = prepareSpawn(argv);
   const effectiveSpawnOpts = { ...spawnOpts, ...spawnOverrides };
-  return await new Promise((resolve11, reject) => {
+  return await new Promise((resolve12, reject) => {
     let child;
     try {
-      child = spawn3(bin, args, effectiveSpawnOpts);
+      child = spawn4(bin, args, effectiveSpawnOpts);
     } catch (err) {
       reject(err);
       return;
@@ -6880,7 +7305,7 @@ async function runCommand(cmd, opts) {
       const output = buf.length > maxChars ? `${buf.slice(0, maxChars)}
 
 [\u2026 truncated ${buf.length - maxChars} chars \u2026]` : buf;
-      resolve11({ exitCode: code, output, timedOut });
+      resolve12({ exitCode: code, output, timedOut });
     });
   });
 }
@@ -6902,16 +7327,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 env2 = opts.env ?? process.env;
   const pathExt = (env2.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 = (env2.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;
     }
   }
@@ -6981,8 +7406,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) {
@@ -7001,7 +7426,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 jobs2 = opts.jobs ?? new JobRegistry();
@@ -7012,7 +7437,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
@@ -7021,14 +7446,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",
@@ -7040,7 +7465,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));
@@ -7404,11 +7829,11 @@ ${i + 1}. ${r.title}`);
 
 // src/env.ts
 import { readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 function loadDotenv(path6 = ".env") {
   let raw;
   try {
-    raw = readFileSync7(resolve5(process.cwd(), path6), "utf8");
+    raw = readFileSync7(resolve6(process.cwd(), path6), "utf8");
   } catch {
     return;
   }
@@ -8193,7 +8618,7 @@ var McpClient = class {
     const id = this.nextId++;
     const frame = { jsonrpc: "2.0", id, method, params };
     let abortHandler = null;
-    const promise = new Promise((resolve11, reject) => {
+    const promise = new Promise((resolve12, reject) => {
       const timeout = setTimeout(() => {
         this.pending.delete(id);
         if (abortHandler && signal) signal.removeEventListener("abort", abortHandler);
@@ -8202,7 +8627,7 @@ var McpClient = class {
         );
       }, this.requestTimeoutMs);
       this.pending.set(id, {
-        resolve: resolve11,
+        resolve: resolve12,
         reject,
         timeout
       });
@@ -8284,7 +8709,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 = [];
@@ -8299,14 +8724,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: env2,
         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: env2,
         cwd: opts.cwd,
         stdio: ["pipe", "pipe", "inherit"]
@@ -8325,12 +8750,12 @@ var StdioTransport = class {
   }
   async send(message) {
     if (this.closed) throw new Error("MCP transport is closed");
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       const line = `${JSON.stringify(message)}
 `;
       this.child.stdin.write(line, "utf8", (err) => {
         if (err) reject(err);
-        else resolve11();
+        else resolve12();
       });
     });
   }
@@ -8341,8 +8766,8 @@ var StdioTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve11) => {
-        this.waiters.push(resolve11);
+      const next = await new Promise((resolve12) => {
+        this.waiters.push(resolve12);
       });
       if (next === null) return;
       yield next;
@@ -8411,8 +8836,8 @@ var SseTransport = class {
   constructor(opts) {
     this.url = opts.url;
     this.headers = opts.headers ?? {};
-    this.endpointReady = new Promise((resolve11, reject) => {
-      this.resolveEndpoint = resolve11;
+    this.endpointReady = new Promise((resolve12, reject) => {
+      this.resolveEndpoint = resolve12;
       this.rejectEndpoint = reject;
     });
     this.endpointReady.catch(() => void 0);
@@ -8439,8 +8864,8 @@ var SseTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve11) => {
-        this.waiters.push(resolve11);
+      const next = await new Promise((resolve12) => {
+        this.waiters.push(resolve12);
       });
       if (next === null) return;
       yield next;
@@ -8626,8 +9051,8 @@ var StreamableHttpTransport = class {
         continue;
       }
       if (this.closed) return;
-      const next = await new Promise((resolve11) => {
-        this.waiters.push(resolve11);
+      const next = await new Promise((resolve12) => {
+        this.waiters.push(resolve12);
       });
       if (next === null) return;
       yield next;
@@ -8798,7 +9223,7 @@ async function trySection(load) {
 
 // src/code/edit-blocks.ts
 import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync10, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname6, resolve as resolve6 } from "path";
+import { dirname as dirname6, resolve as resolve7 } 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 = [];
@@ -8816,8 +9241,8 @@ function parseEditBlocks(text) {
   return out;
 }
 function applyEditBlock(block2, rootDir) {
-  const absRoot = resolve6(rootDir);
-  const absTarget = resolve6(absRoot, block2.path);
+  const absRoot = resolve7(rootDir);
+  const absTarget = resolve7(absRoot, block2.path);
   if (absTarget !== absRoot && !absTarget.startsWith(`${absRoot}${sep()}`)) {
     return {
       path: block2.path,
@@ -8870,7 +9295,7 @@ function applyEditBlocks(blocks, rootDir) {
   return blocks.map((b) => applyEditBlock(b, rootDir));
 }
 function toWholeFileEditBlock(path6, content, rootDir) {
-  const abs = resolve6(rootDir, path6);
+  const abs = resolve7(rootDir, path6);
   let search = "";
   if (existsSync7(abs)) {
     try {
@@ -8882,13 +9307,13 @@ function toWholeFileEditBlock(path6, content, rootDir) {
   return { path: path6, search, replace: content, offset: 0 };
 }
 function snapshotBeforeEdits(blocks, rootDir) {
-  const absRoot = resolve6(rootDir);
+  const absRoot = resolve7(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 = resolve6(absRoot, b.path);
+    const abs = resolve7(absRoot, b.path);
     if (!existsSync7(abs)) {
       snapshots.push({ path: b.path, prevContent: null });
       continue;
@@ -8902,9 +9327,9 @@ function snapshotBeforeEdits(blocks, rootDir) {
   return snapshots;
 }
 function restoreSnapshots(snapshots, rootDir) {
-  const absRoot = resolve6(rootDir);
+  const absRoot = resolve7(rootDir);
   return snapshots.map((snap) => {
-    const abs = resolve6(absRoot, snap.path);
+    const abs = resolve7(absRoot, snap.path);
     if (abs !== absRoot && !abs.startsWith(`${absRoot}${sep()}`)) {
       return {
         path: snap.path,
@@ -11082,10 +11507,10 @@ function render(element, opts = {}) {
   let resolveExit = () => {
   };
   let exitError;
-  const exitPromise = new Promise((resolve11, reject) => {
+  const exitPromise = new Promise((resolve12, reject) => {
     resolveExit = () => {
       if (exitError) reject(exitError);
-      else resolve11();
+      else resolve12();
     };
   });
   let destroyed = false;
@@ -11189,16 +11614,16 @@ var JsonlEventSink = class {
     this.buffered++;
   }
   flush() {
-    return new Promise((resolve11) => {
-      if (this.buffered === 0) return resolve11();
+    return new Promise((resolve12) => {
+      if (this.buffered === 0) return resolve12();
       this.stream.uncork();
       this.buffered = 0;
-      resolve11();
+      resolve12();
     });
   }
   close() {
-    return new Promise((resolve11) => {
-      this.stream.end(() => resolve11());
+    return new Promise((resolve12) => {
+      this.stream.end(() => resolve12());
     });
   }
 };
@@ -13748,7 +14173,7 @@ import { existsSync as existsSync18, readFileSync as readFileSync18, statSync as
 import { join as join17 } from "path";
 
 // src/index/semantic/ollama-launcher.ts
-import { spawn as spawn5, spawnSync as spawnSync2 } from "child_process";
+import { spawn as spawn6, spawnSync as spawnSync2 } from "child_process";
 import { setTimeout as sleep2 } from "timers/promises";
 function findOllamaBinary() {
   const cmd = process.platform === "win32" ? "where" : "which";
@@ -13773,7 +14198,7 @@ async function checkOllamaStatus(modelName, baseUrl) {
 }
 async function startOllamaDaemon(opts = {}) {
   const timeoutMs = opts.timeoutMs ?? 15e3;
-  const child = spawn5("ollama", ["serve"], {
+  const child = spawn6("ollama", ["serve"], {
     detached: true,
     stdio: "ignore",
     windowsHide: true
@@ -13790,8 +14215,8 @@ async function startOllamaDaemon(opts = {}) {
   return { ready: false, pid };
 }
 async function pullOllamaModel(modelName, opts = {}) {
-  return new Promise((resolve11) => {
-    const child = spawn5("ollama", ["pull", modelName], {
+  return new Promise((resolve12) => {
+    const child = spawn6("ollama", ["pull", modelName], {
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true
     });
@@ -13802,8 +14227,8 @@ async function pullOllamaModel(modelName, opts = {}) {
     }
     streamLines(child.stdout, (l) => opts.onLine?.(l, "stdout"));
     streamLines(child.stderr, (l) => opts.onLine?.(l, "stderr"));
-    child.once("exit", (code) => resolve11(code ?? -1));
-    child.once("error", () => resolve11(-1));
+    child.once("exit", (code) => resolve12(code ?? -1));
+    child.once("error", () => resolve12(-1));
   });
 }
 function streamLines(stream, cb) {
@@ -15056,7 +15481,7 @@ var MAX_BODY_BYTES = 256 * 1024;
 async function readBody(req) {
   let total = 0;
   const chunks = [];
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     req.on("data", (chunk) => {
       total += chunk.length;
       if (total > MAX_BODY_BYTES) {
@@ -15066,7 +15491,7 @@ async function readBody(req) {
       }
       chunks.push(chunk);
     });
-    req.on("end", () => resolve11(Buffer.concat(chunks).toString("utf8")));
+    req.on("end", () => resolve12(Buffer.concat(chunks).toString("utf8")));
     req.on("error", reject);
   });
 }
@@ -15143,7 +15568,7 @@ function startDashboardServer(ctx, opts = {}) {
   const token = opts.token ?? mintToken();
   const host = opts.host ?? "127.0.0.1";
   const port = opts.port ?? 0;
-  return new Promise((resolve11, reject) => {
+  return new Promise((resolve12, reject) => {
     const server = createServer((req, res) => {
       dispatch(req, res, ctx, token).catch((err) => {
         if (!res.headersSent) {
@@ -15164,7 +15589,7 @@ function startDashboardServer(ctx, opts = {}) {
         server.close(() => doneResolve());
         setTimeout(() => server.closeAllConnections?.(), 1e3).unref();
       });
-      resolve11({ url, token, port: finalPort, close });
+      resolve12({ url, token, port: finalPort, close });
     });
   });
 }
@@ -23484,7 +23909,7 @@ function resolvePreset(name) {
 // src/cli/commands/doctor.ts
 import { existsSync as existsSync22, statSync as statSync12 } from "fs";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname16, join as join20, resolve as resolve7 } from "path";
+import { dirname as dirname16, join as join20, resolve as resolve8 } from "path";
 async function runDoctorChecks(projectRoot) {
   return Promise.all([
     checkApiKey(),
@@ -23766,7 +24191,7 @@ async function checkProject(projectRoot) {
 }
 async function doctorCommand() {
   loadDotenv();
-  const projectRoot = resolve7(process.cwd());
+  const projectRoot = resolve8(process.cwd());
   console.log(`${color(`reasonix ${VERSION}  \xB7  doctor`, "1")}  (cwd: ${projectRoot})`);
   console.log(`  home: ${homedir10()}`);
   console.log("");
@@ -24285,9 +24710,9 @@ var handlers3 = { dashboard: dashboard2 };
 // src/code/checkpoints.ts
 import { existsSync as existsSync24, mkdirSync as mkdirSync13, readFileSync as readFileSync23, rmSync as rmSync2, writeFileSync as writeFileSync12 } from "fs";
 import { homedir as homedir11 } from "os";
-import { dirname as dirname17, join as join21, relative as relative4, resolve as resolve8, sep as sep3 } from "path";
+import { dirname as dirname17, join as join21, relative as relative4, resolve as resolve9, sep as sep3 } from "path";
 function sanitizeRoot(rootDir) {
-  return resolve8(rootDir).replace(/[\\/:]+/g, "_").replace(/^_+/, "");
+  return resolve9(rootDir).replace(/[\\/:]+/g, "_").replace(/^_+/, "");
 }
 function storeRoot(rootDir) {
   return join21(homedir11(), ".reasonix", "sessions", sanitizeRoot(rootDir), "checkpoints");
@@ -24332,7 +24757,7 @@ function loadCheckpoint(rootDir, id) {
   }
 }
 function createCheckpoint(opts) {
-  const absRoot = resolve8(opts.rootDir);
+  const absRoot = resolve9(opts.rootDir);
   const id = `cp-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
   const files = [];
   let bytes = 0;
@@ -24340,7 +24765,7 @@ function createCheckpoint(opts) {
   for (const p of opts.paths) {
     if (seen.has(p)) continue;
     seen.add(p);
-    const abs = resolve8(absRoot, p);
+    const abs = resolve9(absRoot, p);
     if (abs !== absRoot && !abs.startsWith(`${absRoot}${sep3}`)) continue;
     const rel = relative4(absRoot, abs).split(sep3).join("/");
     if (existsSync24(abs)) {
@@ -24389,14 +24814,14 @@ function findCheckpoint(rootDir, idOrName) {
 }
 function restoreCheckpoint(rootDir, id) {
   const cp = loadCheckpoint(rootDir, id);
-  const absRoot = resolve8(rootDir);
+  const absRoot = resolve9(rootDir);
   const result = { restored: [], removed: [], skipped: [] };
   if (!cp) {
     result.skipped.push({ path: "(checkpoint)", reason: `not found: ${id}` });
     return result;
   }
   for (const f of cp.files) {
-    const abs = resolve8(absRoot, f.path);
+    const abs = resolve9(absRoot, f.path);
     if (abs !== absRoot && !abs.startsWith(`${absRoot}${sep3}`)) {
       result.skipped.push({ path: f.path, reason: "path escapes rootDir" });
       continue;
@@ -24782,7 +25207,7 @@ var handlers4 = {
 
 // src/cli/ui/slash/handlers/init.ts
 import { existsSync as existsSync25 } from "fs";
-import * as pathMod4 from "path";
+import * as pathMod5 from "path";
 var INIT_PROMPT = [
   "# Task: Initialize REASONIX.md",
   "",
@@ -24846,7 +25271,7 @@ var init = (args, _loop, ctx) => {
     return { info: t("handlers.init.codeOnly") };
   }
   const force = (args[0] ?? "").toLowerCase() === "force";
-  const target = pathMod4.join(ctx.codeRoot, "REASONIX.md");
+  const target = pathMod5.join(ctx.codeRoot, "REASONIX.md");
   if (existsSync25(target) && !force) {
     return {
       info: [
@@ -27529,11 +27954,11 @@ function AppInner({
     if (key.escape && busy) {
       if (abortedThisTurn.current) return;
       abortedThisTurn.current = true;
-      const resolve11 = editReviewResolveRef.current;
-      if (resolve11) {
+      const resolve12 = editReviewResolveRef.current;
+      if (resolve12) {
         editReviewResolveRef.current = null;
         setPendingEditReview(null);
-        resolve11({ choice: "reject" });
+        resolve12({ choice: "reject" });
       }
       if (activeLoopRef.current) stopLoop();
       loop2.abort();
@@ -27940,11 +28365,11 @@ function AppInner({
           handleStagedInputSubmitRef.current(text ?? "", { plan: plan3, mode: choice }).catch(() => void 0);
         },
         resolveEditReview: (choice) => {
-          const resolve11 = editReviewResolveRef.current;
-          if (resolve11) {
+          const resolve12 = editReviewResolveRef.current;
+          if (resolve12) {
             editReviewResolveRef.current = null;
             setPendingEditReview(null);
-            resolve11({ choice, denyContext: void 0 });
+            resolve12({ choice, denyContext: void 0 });
           }
         },
         resolveReviseConfirm: (choice) => {
@@ -28994,10 +29419,10 @@ Continue executing from the next pending step. Call mark_step_complete after eac
       {
         block: pendingEditReview,
         onChoose: (choice, denyContext) => {
-          const resolve11 = editReviewResolveRef.current;
-          if (resolve11) {
+          const resolve12 = editReviewResolveRef.current;
+          if (resolve12) {
             editReviewResolveRef.current = null;
-            resolve11({ choice, denyContext });
+            resolve12({ choice, denyContext });
           }
         }
       }
@@ -29359,10 +29784,10 @@ async function chatCommand(opts) {
 
 // src/cli/commands/code.tsx
 import { readFileSync as readFileSync24 } from "fs";
-import { basename as basename2, resolve as resolve9 } from "path";
+import { basename as basename2, resolve as resolve10 } from "path";
 async function codeCommand(opts = {}) {
   const { codeSystemPrompt: codeSystemPrompt2 } = await import("./prompt-YUL7CYKY.js");
-  const rootDir = resolve9(opts.dir ?? process.cwd());
+  const rootDir = resolve10(opts.dir ?? process.cwd());
   const session = opts.noSession ? void 0 : `code-${sanitizeName(basename2(rootDir))}`;
   const tools = new ToolRegistry();
   const jobs2 = new JobRegistry();
@@ -29400,7 +29825,7 @@ async function codeCommand(opts = {}) {
     process.stderr.write("--system-append is empty \u2014 no prompt text will be appended\n");
   }
   if (opts.systemAppendFile) {
-    const filePath = resolve9(opts.systemAppendFile);
+    const filePath = resolve10(opts.systemAppendFile);
     try {
       systemAppendFileContents = readFileSync24(filePath, "utf8");
     } catch (err) {
@@ -29433,7 +29858,7 @@ async function codeCommand(opts = {}) {
 }
 
 // src/cli/commands/commit.ts
-import { spawn as spawn6, spawnSync as spawnSync4 } from "child_process";
+import { spawn as spawn7, spawnSync as spawnSync4 } from "child_process";
 import { mkdtempSync, readFileSync as readFileSync25, unlinkSync as unlinkSync6, writeFileSync as writeFileSync13 } from "fs";
 import { tmpdir } from "os";
 import { join as join23 } from "path";
@@ -29612,7 +30037,7 @@ function editInExternal(initial) {
   return cleaned || null;
 }
 function commitWithMessage(message) {
-  const child = spawn6("git", ["commit", "-F", "-"], {
+  const child = spawn7("git", ["commit", "-F", "-"], {
     stdio: ["pipe", "inherit", "inherit"]
   });
   child.stdin.write(message);
@@ -30204,7 +30629,7 @@ function mapReplacer(_key, value) {
 }
 
 // src/cli/commands/index.ts
-import { resolve as resolve10 } from "path";
+import { resolve as resolve11 } from "path";
 
 // src/index/semantic/preflight.ts
 import { stdin as stdin3, stdout as stdout2 } from "process";
@@ -30278,7 +30703,7 @@ async function confirm(question, defaultYes) {
 
 // src/cli/commands/index.ts
 async function indexCommand(opts = {}) {
-  const root = resolve10(opts.dir ?? process.cwd());
+  const root = resolve11(opts.dir ?? process.cwd());
   const tty2 = process.stderr.isTTY === true && process.stdin.isTTY === true;
   const model2 = opts.model ?? process.env.REASONIX_EMBED_MODEL ?? "nomic-embed-text";
   const preflightOk = await ollamaPreflight({
@@ -31904,7 +32329,7 @@ async function setupCommand(_opts = {}) {
 }
 
 // src/cli/commands/update.ts
-import { spawn as spawn7 } from "child_process";
+import { spawn as spawn8 } from "child_process";
 function planUpdate(input) {
   const diff = compareVersions(input.current, input.latest);
   if (diff > 0) {
@@ -31934,13 +32359,13 @@ function planUpdate(input) {
   };
 }
 function defaultSpawn(argv) {
-  return new Promise((resolve11, reject) => {
-    const child = spawn7(argv[0], argv.slice(1), {
+  return new Promise((resolve12, reject) => {
+    const child = spawn8(argv[0], argv.slice(1), {
       stdio: "inherit",
       shell: process.platform === "win32"
     });
     child.once("error", reject);
-    child.once("exit", (code) => resolve11(code ?? 1));
+    child.once("exit", (code) => resolve12(code ?? 1));
   });
 }
 async function updateCommand(opts = {}) {