@agentdocumentformat/cli 0.7.2

package/dist/chunks/chunk-7MTRVW2U.mjs

@@ -0,0 +1,3103 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  META_PROTECTION_LEVELS,
+  SETTABLE_STATES
+} from "./chunk-WFQUVXML.mjs";
+import {
+  __esm
+} from "./chunk-M2RX3S2T.mjs";
+
+// src/main/runtime/execution-context.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+function withSource(source, agentIdOrFn, maybeFn) {
+  let agentId = typeof agentIdOrFn == "function" ? void 0 : agentIdOrFn, fn = typeof agentIdOrFn == "function" ? agentIdOrFn : maybeFn, parent = store.getStore(), loop = parent?.loop && (agentId === void 0 || agentId === parent.agentId) ? parent.loop : void 0;
+  return store.run(loop ? { source, agentId, loop } : { source, agentId }, fn);
+}
+function withLoop(loop, fn) {
+  let parent = store.getStore();
+  return store.run({ source: parent?.source ?? "system:unknown", agentId: parent?.agentId, loop }, fn);
+}
+function currentLoop() {
+  return store.getStore()?.loop;
+}
+function currentAgentId() {
+  return store.getStore()?.agentId;
+}
+function currentSourceOrUnknown() {
+  return store.getStore()?.source ?? "system:unknown";
+}
+var store, init_execution_context = __esm({
+  "src/main/runtime/execution-context.ts"() {
+    "use strict";
+    store = new AsyncLocalStorage();
+  }
+});
+
+// src/main/tools/shell/commands/types.ts
+var EXIT = {
+  SUCCESS: 0,
+  ERROR: 1,
+  DISABLED: 126,
+  NOT_FOUND: 127,
+  APPROVAL: 128,
+  INTERCEPTED: 130
+};
+function ok(stdout) {
+  return { exit_code: EXIT.SUCCESS, stdout, stderr: "" };
+}
+function err(stderr, code = EXIT.ERROR) {
+  return { exit_code: code, stdout: "", stderr };
+}
+
+// src/main/tools/shell/commands/filesystem.ts
+init_execution_context();
+
+// src/main/tools/built-in/mime-utils.ts
+var TEXT_MIME_PREFIXES = ["text/"], TEXT_MIME_EXACT = /* @__PURE__ */ new Set([
+  "application/json",
+  "application/xml",
+  "application/yaml",
+  "application/x-yaml",
+  "application/javascript",
+  "application/typescript",
+  "application/x-sh",
+  "application/sql",
+  "application/graphql",
+  "application/xhtml+xml",
+  "application/x-httpd-php",
+  // Line/record textual data formats — an agent that writes these expects
+  // `cat`/`head`/coreutils to see the bytes, not a binary placeholder.
+  "application/x-ndjson",
+  "application/ndjson",
+  "application/csv",
+  "application/x-yaml",
+  "application/toml"
+]);
+function isTextMime(mime) {
+  return mime ? TEXT_MIME_PREFIXES.some((p) => mime.startsWith(p)) || /\+(json|xml|yaml)$/.test(mime) ? !0 : TEXT_MIME_EXACT.has(mime) : !1;
+}
+var VISION_MIMES = /* @__PURE__ */ new Set([
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp"
+]);
+function isVisionMime(mime) {
+  return mime ? VISION_MIMES.has(mime) : !1;
+}
+var AUDIO_INPUT_MIMES = /* @__PURE__ */ new Set([
+  "audio/wav",
+  "audio/mpeg",
+  "audio/mp3",
+  "audio/aiff",
+  "audio/aac",
+  "audio/ogg",
+  "audio/flac",
+  "audio/x-m4a",
+  "audio/webm"
+]);
+function isAudioInputMime(mime) {
+  return mime ? AUDIO_INPUT_MIMES.has(mime) : !1;
+}
+var VIDEO_INPUT_MIMES = /* @__PURE__ */ new Set([
+  "video/mp4",
+  "video/mpeg",
+  "video/quicktime",
+  "video/webm"
+]);
+function isVideoInputMime(mime) {
+  return mime ? VIDEO_INPUT_MIMES.has(mime) : !1;
+}
+var AUDIO_FORMAT_MAP = {
+  "audio/wav": "wav",
+  "audio/mpeg": "mp3",
+  "audio/mp3": "mp3",
+  "audio/aiff": "aiff",
+  "audio/aac": "aac",
+  "audio/ogg": "ogg",
+  "audio/flac": "flac",
+  "audio/x-m4a": "m4a",
+  "audio/webm": "webm"
+};
+function mimeToAudioFormat(mime) {
+  return AUDIO_FORMAT_MAP[mime] ?? "wav";
+}
+function formatSize(bytes) {
+  return bytes < 1024 ? `${bytes} B` : bytes < 1048576 ? `${(bytes / 1024).toFixed(1)} KB` : `${(bytes / 1048576).toFixed(1)} MB`;
+}
+var MIME_TO_EXT = {
+  "image/png": ".png",
+  "image/jpeg": ".jpg",
+  "image/gif": ".gif",
+  "image/webp": ".webp",
+  "image/svg+xml": ".svg",
+  "image/bmp": ".bmp",
+  "image/tiff": ".tiff",
+  "audio/mpeg": ".mp3",
+  "audio/wav": ".wav",
+  "audio/ogg": ".ogg",
+  "audio/webm": ".webm",
+  "video/mp4": ".mp4",
+  "video/webm": ".webm",
+  "application/pdf": ".pdf",
+  "application/json": ".json",
+  "text/plain": ".txt",
+  "text/html": ".html",
+  "text/css": ".css"
+};
+function mimeToExt(mimeType) {
+  return MIME_TO_EXT[mimeType] ?? ".bin";
+}
+
+// src/main/tools/shell/commands/fs-read-helper.ts
+function isMediaMime(mime) {
+  return isVisionMime(mime) || isAudioInputMime(mime) || isVideoInputMime(mime);
+}
+function isTextRow(row) {
+  return isTextMime(row.mime_type);
+}
+async function shellReadFileRow(toolRegistry, workspace, path, options) {
+  let input = { path };
+  options?.start_line !== void 0 && (input.start_line = options.start_line), options?.end_line !== void 0 && (input.end_line = options.end_line);
+  let result = await toolRegistry.executeTool("fs_read", input, workspace);
+  if (result.isError)
+    return [null, result.content];
+  try {
+    let row = JSON.parse(result.content);
+    return [{
+      content: row.content ?? "",
+      mime_type: row.mime_type,
+      size: row.size,
+      path: row.path ?? path
+    }, null];
+  } catch {
+    return [null, "Failed to parse fs_read result"];
+  }
+}
+async function shellReadFile(toolRegistry, workspace, path, options) {
+  let input = { path };
+  options?.start_line !== void 0 && (input.start_line = options.start_line), options?.end_line !== void 0 && (input.end_line = options.end_line);
+  let result = await toolRegistry.executeTool("fs_read", input, workspace);
+  if (result.isError)
+    return [null, result.content];
+  try {
+    return [JSON.parse(result.content).content ?? "", null];
+  } catch {
+    return [null, "Failed to parse fs_read result"];
+  }
+}
+
+// src/main/tools/shell/commands/filesystem.ts
+function vfsPath(p) {
+  return p === "." || p === "./" || p === "/" ? "" : p.replace(/^\.\//, "").replace(/^\//, "");
+}
+var catHandler = {
+  name: "cat",
+  summary: "Read file contents",
+  helpText: [
+    "cat <path>           Read file contents",
+    "cat -n <path>        With line numbers",
+    "cat --text <path>    Force text output even if the MIME says binary",
+    "",
+    "Options:",
+    "  -n                 Show line numbers",
+    "  --text             Decode as UTF-8 text regardless of MIME classification"
+  ].join(`
+`),
+  category: "filesystem",
+  resolvedTools: ["fs_read"],
+  async execute(ctx) {
+    let showLineNumbers = !!ctx.flags.n, forceText = !!ctx.flags.text, paths = ctx.args;
+    if (paths.length === 0)
+      return ctx.stdin ? ok(ctx.stdin) : err("cat: missing file path");
+    let outputs = [], media = [];
+    for (let rawPath of paths) {
+      let path = vfsPath(rawPath), [row, error] = await shellReadFileRow(ctx.toolRegistry, ctx.workspace, path);
+      if (error !== null) return err(`cat: ${error}`);
+      if (isMediaMime(row.mime_type)) {
+        let mime = row.mime_type, limits = ctx.config.limits ?? {}, maxSize = mime.startsWith("image/") ? limits.max_image_size_bytes ?? 5242880 : mime.startsWith("audio/") ? limits.max_audio_size_bytes ?? 10485760 : limits.max_video_size_bytes ?? 10485760;
+        if (row.size !== void 0 && row.size > maxSize) {
+          outputs.push(`[${mime}: ${row.path ?? path}, ${row.size} bytes \u2014 too large to attach (limit ${maxSize} bytes)]`);
+          continue;
+        }
+        media.push({ path: row.path ?? path, mime_type: mime });
+        let kind = mime.startsWith("image/") ? "image" : mime.startsWith("audio/") ? "audio" : "video";
+        outputs.push(`[${kind}: ${row.path ?? path} (${mime})${row.size ? `, ${row.size} bytes` : ""} \u2014 attached for viewing if your model supports this modality]`);
+        continue;
+      }
+      if (!isTextRow(row)) {
+        if (forceText) {
+          let decoded = Buffer.from(row.content, "base64").toString("utf8");
+          outputs.push(showLineNumbers ? decoded.split(`
+`).map((l, i) => `${String(i + 1).padStart(6)}  ${l}`).join(`
+`) : decoded);
+          continue;
+        }
+        outputs.push(`[binary: ${row.path ?? path}${row.size ? `, ${row.size} bytes` : ""}${row.mime_type ? `, ${row.mime_type}` : ""} \u2014 not shown; use \`cat --text\` if this is text]`);
+        continue;
+      }
+      if (showLineNumbers) {
+        let lines = row.content.split(`
+`);
+        outputs.push(lines.map((l, i) => `${String(i + 1).padStart(6)}  ${l}`).join(`
+`));
+      } else
+        outputs.push(row.content);
+    }
+    let result = ok(outputs.join(`
+`));
+    return media.length > 0 && (result.media = media), result;
+  }
+}, LS_MAX_ENTRIES = 500, lsHandler = {
+  name: "ls",
+  summary: "List files",
+  helpText: [
+    "ls [prefix...]       List files (multiple args merged, deduped)",
+    "ls -l [prefix...]    Long format (size, dates, protected)",
+    "",
+    "Options:",
+    "  -l                 Long listing format",
+    "",
+    "Output is ONE JSON array, not one line per file \u2014 piping to head/tail",
+    "slices nothing. Slice with jq: ls | jq -r '.[].path'  or  ls | jq '.[0:3]'",
+    "",
+    "Each arg is a path prefix (exact file OR directory-ish prefix); results",
+    "are merged and deduped, so `ls *.md` (shell-expanded) lists every match.",
+    'An arg matching nothing prints "ls: <arg>: No such file or directory" on',
+    "stderr; exit 2 only if NO arg matched. Stdout is always one JSON array.",
+    "",
+    `Long listings are capped at ${LS_MAX_ENTRIES} files; the cap is reported on stderr.`
+  ].join(`
+`),
+  category: "filesystem",
+  resolvedTools: ["fs_list"],
+  async execute(ctx) {
+    let long = !!ctx.flags.l, prefixes = ctx.args.length > 0 ? ctx.args.map((a) => vfsPath(a)) : [""], merged = [], seen = /* @__PURE__ */ new Set(), missing = [];
+    for (let i = 0; i < prefixes.length; i++) {
+      let result = await ctx.toolRegistry.executeTool("fs_list", {
+        prefix: prefixes[i],
+        include_metadata: long,
+        _full: !0
+      }, ctx.workspace);
+      if (result.isError) return err(`ls: ${result.content}`);
+      let rows;
+      try {
+        let parsed = JSON.parse(result.content);
+        rows = Array.isArray(parsed) ? parsed : [];
+      } catch {
+        return err("ls: unexpected fs_list output (not a JSON array)");
+      }
+      if (rows.length === 0 && ctx.args.length > 0) {
+        missing.push(ctx.args[i]);
+        continue;
+      }
+      for (let row of rows) {
+        let key = row && typeof row == "object" && typeof row.path == "string" ? row.path : JSON.stringify(row);
+        seen.has(key) || (seen.add(key), merged.push(row));
+      }
+    }
+    let notes = missing.map((m) => `ls: ${m}: No such file or directory`);
+    return merged.length > LS_MAX_ENTRIES && (notes.push(`ls: showing first ${LS_MAX_ENTRIES} of ${merged.length} files \u2014 narrow the prefix or slice with jq`), merged.length = LS_MAX_ENTRIES), {
+      exit_code: ctx.args.length > 0 && merged.length === 0 ? 2 : EXIT.SUCCESS,
+      stdout: JSON.stringify(merged),
+      stderr: notes.join(`
+`)
+    };
+  }
+}, rmHandler = {
+  name: "rm",
+  summary: "Delete a file",
+  helpText: "rm <path>            Delete a file from the VFS",
+  category: "filesystem",
+  resolvedTools: ["fs_delete"],
+  async execute(ctx) {
+    if (ctx.args.length === 0) return err("rm: missing file path");
+    for (let rawPath of ctx.args) {
+      let path = vfsPath(rawPath), result = await ctx.toolRegistry.executeTool("fs_delete", { path }, ctx.workspace);
+      if (result.isError) return err(`rm: ${result.content}`);
+    }
+    return ok("");
+  }
+}, cpHandler = {
+  name: "cp",
+  summary: "Copy a file",
+  helpText: "cp <src> <dst>       Copy a file",
+  category: "filesystem",
+  resolvedTools: ["fs_read", "fs_write"],
+  async execute(ctx) {
+    if (ctx.args.length < 2) return err("cp: usage: cp <src> <dst>");
+    let src = vfsPath(ctx.args[0]), dst = vfsPath(ctx.args[1]), [content, readErr] = await shellReadFile(ctx.toolRegistry, ctx.workspace, src);
+    if (readErr) return err(`cp: ${readErr}`);
+    let write = await ctx.toolRegistry.executeTool("fs_write", { mode: "write", path: dst, content }, ctx.workspace);
+    return write.isError ? err(`cp: ${write.content}`) : ok("");
+  }
+}, mvHandler = {
+  name: "mv",
+  summary: "Move/rename a file",
+  helpText: [
+    "mv <src> <dst>       Move or rename a file",
+    "",
+    "A rename preserves content, so mv needs fs_read + fs_write \u2014 not the",
+    "destructive fs_delete. Protected sources (read_only/no_delete) still",
+    "require a HIL override before the old path is released."
+  ].join(`
+`),
+  category: "filesystem",
+  // A rename preserves content — the honest capability set is read-the-source
+  // + write-the-destination, NOT the destructive fs_delete: gating mv on
+  // delete priced "rename" the same as "destroy", so an agent without
+  // fs_delete couldn't rename anything. The delete-like half (releasing a
+  // PROTECTED src path) is covered by the inline protection/HIL check below,
+  // which fails closed / asks the human exactly as before.
+  // (Previously []: fully ungated, a permission-escalation seam.)
+  resolvedTools: ["fs_read", "fs_write"],
+  async execute(ctx) {
+    if (ctx.args.length < 2) return err("mv: usage: mv <src> <dst>");
+    let src = vfsPath(ctx.args[0]), dst = vfsPath(ctx.args[1]), protection = ctx.workspace.getFileProtection(src), wasProtected = protection === "read_only" || protection === "no_delete", bypass = null;
+    if (wasProtected)
+      if (ctx.authorized)
+        bypass = "authorized";
+      else {
+        let gate = ctx.gate;
+        if (!gate?.onProtectionBlocked || gate.authorized)
+          return err(`mv: cannot move "${src}": file is protected (${protection}).`);
+        let decision = await gate.onProtectionBlocked(
+          "fs_delete",
+          { path: src },
+          {
+            kind: "file_protection",
+            target: src,
+            level: protection,
+            description: `Move "${src}" \u2014 file is protected (${protection})`
+          },
+          gate.command ?? `mv ${src} ${dst}`
+        );
+        if (!decision.approved) {
+          let fb = decision.feedback?.trim();
+          return err(`mv: cannot move "${src}": file is protected (${protection}). Override rejected by the user.${fb ? ` Feedback: ${fb}` : ""} Do not retry.`, EXIT.INTERCEPTED);
+        }
+        bypass = "human-approved";
+      }
+    try {
+      if (!ctx.workspace.renameInternalFile(src, dst)) return err(`mv: ${src}: no such file`);
+      if (bypass) {
+        let reason = bypass === "human-approved" ? "human-approved override" : `authorized code bypass (${currentSourceOrUnknown()})`;
+        return ctx.workspace.insertLog?.(
+          "warn",
+          "protection",
+          "bypass",
+          src,
+          `Moved protected file "${src}" (${protection}) \u2014 ${reason}`
+        ), ok(`Moved "${src}" (\u26A0 protection override: ${protection}, ${bypass}).`);
+      }
+      return ok("");
+    } catch (e) {
+      return err(`mv: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+}, touchHandler = {
+  name: "touch",
+  summary: "Create an empty file",
+  helpText: "touch <path>         Create an empty file (only if it doesn't exist)",
+  category: "filesystem",
+  resolvedTools: ["fs_write"],
+  async execute(ctx) {
+    if (ctx.args.length === 0) return err("touch: missing file path");
+    for (let rawPath of ctx.args) {
+      let path = vfsPath(rawPath);
+      if (!ctx.workspace.fileExists(path)) {
+        let result = await ctx.toolRegistry.executeTool("fs_write", { mode: "write", path, content: "" }, ctx.workspace);
+        if (result.isError) return err(`touch: ${result.content}`);
+      }
+    }
+    return ok("");
+  }
+}, findHandler = {
+  name: "find",
+  summary: "Find files by pattern",
+  helpText: [
+    "find [path]                List files (optionally under a path)",
+    "find [path] -name <glob>   Find files whose basename matches a glob",
+    "",
+    "Options:",
+    "  -name <glob>       Glob with * and ? (* never crosses a / segment).",
+    '                     Quote the glob ("*.md") so find does the matching;',
+    "                     an unquoted glob is expanded by the shell first."
+  ].join(`
+`),
+  category: "filesystem",
+  resolvedTools: [],
+  // reads the VFS list directly, like grep -r
+  async execute(ctx) {
+    let raw = ctx.rawArgs ?? ctx.args, positionals = [], patterns = [];
+    for (let i = 0; i < raw.length; i++) {
+      let tok = raw[i];
+      if (tok === "-name" || tok === "--name") {
+        let before = patterns.length;
+        for (; i + 1 < raw.length && !raw[i + 1].startsWith("-"); ) patterns.push(raw[++i]);
+        if (patterns.length === before) return err('find: -name requires a pattern (quote it: -name "*.md")');
+      } else {
+        if (tok.startsWith("-") && tok.length > 1)
+          return err(`find: unsupported option ${tok} \u2014 usage: find [path] [-name <glob>]`);
+        positionals.push(tok);
+      }
+    }
+    let prefix = vfsPath(positionals[0] ?? ""), paths = ctx.workspace.listFiles().map((f) => f.path);
+    if (prefix && (paths = paths.filter((p) => p === prefix || p.startsWith(prefix + "/"))), patterns.length > 0) {
+      let matchers = patterns.map((g) => ({
+        regex: new RegExp("^" + g.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]") + "$"),
+        // A pattern containing / (e.g. a shell-pre-expanded full path) matches
+        // the whole path; a plain glob matches the basename (GNU -name).
+        fullPath: g.includes("/")
+      }));
+      paths = paths.filter((p) => matchers.some((m) => m.regex.test(m.fullPath ? p : p.split("/").pop() ?? p)));
+    }
+    return ok(paths.join(`
+`));
+  }
+};
+function formatSize2(bytes) {
+  return bytes < 1024 ? `${bytes}` : bytes < 1024 * 1024 ? `${(bytes / 1024).toFixed(1)}K` : bytes < 1024 * 1024 * 1024 ? `${(bytes / (1024 * 1024)).toFixed(1)}M` : `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}G`;
+}
+var duHandler = {
+  name: "du",
+  summary: "Show file sizes",
+  helpText: [
+    "du [path]            Show disk usage of files",
+    "",
+    "Options:",
+    "  -h                 Human-readable sizes (default)"
+  ].join(`
+`),
+  category: "filesystem",
+  resolvedTools: [],
+  async execute(ctx) {
+    let prefix = vfsPath(ctx.args[0] ?? ""), files = ctx.workspace.listFiles();
+    if (prefix && (files = files.filter((f) => f.path.startsWith(prefix))), files.length === 0) return ok("");
+    files.sort((a, b) => b.size - a.size);
+    let total = files.reduce((sum, f) => sum + f.size, 0), lines = files.map((f) => `${formatSize2(f.size)}	${f.path}`);
+    return lines.push(`${formatSize2(total)}	total`), ok(lines.join(`
+`));
+  }
+}, chmodHandler = {
+  name: "chmod",
+  summary: "Set file protection",
+  helpText: [
+    "chmod +p <path>              Protect a file (default level: read_only)",
+    "chmod +p=read_only <path>    Protect: no writes, no deletion",
+    "chmod +p=no_delete <path>    Protect: writable, but cannot be deleted",
+    "chmod -p <path>              Remove protection",
+    "",
+    "Protection levels: read_only (no writes or deletion), no_delete",
+    "(writable but not deletable), none (unprotected). Plain +p defaults to",
+    "read_only. Removing or changing an EXISTING protection pauses for a",
+    "human (HIL) override approval; raising protection on an unprotected",
+    "file needs none.",
+    "",
+    "adf files have no unix modes \u2014 numeric (644) and symbolic (u+x) modes",
+    "are not supported. +p/-p is the whole interface."
+  ].join(`
+`),
+  category: "filesystem",
+  resolvedTools: ["fs_write"],
+  async execute(ctx) {
+    let usage = "chmod: usage: chmod [+p[=read_only|no_delete]|-p] <path>", mode = ctx.flags.p === !0 ? "-p" : ctx.args[0], pathArg = ctx.flags.p === !0 ? ctx.args[0] : ctx.args[1];
+    if (!mode || !pathArg) return err(usage);
+    let target;
+    if (mode === "-p")
+      target = "none";
+    else if (mode === "+p")
+      target = "read_only";
+    else if (mode.startsWith("+p=")) {
+      let level = mode.slice(3);
+      if (level !== "read_only" && level !== "no_delete")
+        return err(`chmod: invalid protection level "${level}". Use +p=read_only or +p=no_delete (or -p to unprotect)`);
+      target = level;
+    } else return /^[0-7]{1,4}$/.test(mode) || /^[ugoa]*[+\-=][rwxXstugo]+$/.test(mode) ? err("chmod: only +p (protect) and -p (unprotect) are supported \u2014 adf files have no unix modes") : err(`chmod: invalid mode "${mode}". Use +p, +p=read_only, +p=no_delete, or -p`);
+    let path = vfsPath(pathArg), current = ctx.workspace.getFileProtection(path);
+    if (current === null) return err(`chmod: ${pathArg}: No such file or directory`);
+    if (current === target) return ok("");
+    let wasProtected = current === "read_only" || current === "no_delete", bypass = null;
+    if (wasProtected)
+      if (ctx.authorized)
+        bypass = "authorized";
+      else {
+        let gate = ctx.gate;
+        if (!gate?.onProtectionBlocked || gate.authorized)
+          return err(`chmod: cannot change protection of "${path}": file is protected (${current}).`);
+        let decision = await gate.onProtectionBlocked(
+          "fs_write",
+          { path, protection: target },
+          {
+            kind: "file_protection",
+            target: path,
+            level: current,
+            description: `Change protection of "${path}" (currently ${current})`
+          },
+          gate.command ?? `chmod ${mode} ${pathArg}`
+        );
+        if (!decision.approved) {
+          let fb = decision.feedback?.trim();
+          return err(`chmod: cannot change protection of "${path}": file is protected (${current}). Override rejected by the user.${fb ? ` Feedback: ${fb}` : ""} Do not retry.`, EXIT.INTERCEPTED);
+        }
+        bypass = "human-approved";
+      }
+    try {
+      if (ctx.workspace.setFileProtection(path, target), bypass) {
+        let reason = bypass === "human-approved" ? "human-approved override" : `authorized code bypass (${currentSourceOrUnknown()})`;
+        return ctx.workspace.insertLog?.(
+          "warn",
+          "protection",
+          "bypass",
+          path,
+          `Changed protection of "${path}" (${current} -> ${target}) \u2014 ${reason}`
+        ), ok(`Changed protection of "${path}" to ${target} (\u26A0 protection override: ${current}, ${bypass}).`);
+      }
+      return ok("");
+    } catch (e) {
+      return err(`chmod: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+}, headHandler = {
+  name: "head",
+  summary: "Show first N lines",
+  helpText: [
+    "head [-N] [file]     Show first N lines (default 10)",
+    "",
+    "Options:",
+    "  -n <N>             Number of lines (or -N shorthand)",
+    "  -c <N>             First N BYTES instead of lines (UTF-8 byte slice;",
+    "                     a multi-byte char cut at the boundary becomes U+FFFD).",
+    "                     Takes precedence over -n if both are given."
+  ].join(`
+`),
+  category: "filesystem",
+  resolvedTools: ["fs_read"],
+  valueFlags: /* @__PURE__ */ new Set(["n", "c"]),
+  async execute(ctx) {
+    if (ctx.flags.c !== void 0) {
+      let raw = ctx.flags.c;
+      if (typeof raw != "string" || !/^\d+$/.test(raw))
+        return err("head: -c requires a plain byte count (e.g. head -c 80 file); suffixes (K/M) and negative counts are not supported");
+      let bytes = parseInt(raw, 10), content = ctx.stdin;
+      if (ctx.args.length > 0) {
+        let [fileContent, error] = await shellReadFile(ctx.toolRegistry, ctx.workspace, vfsPath(ctx.args[0]));
+        if (error) return err(`head: ${error}`);
+        content = fileContent;
+      }
+      return content ? ok(Buffer.from(content, "utf8").subarray(0, bytes).toString("utf8")) : ok("");
+    }
+    let n = 10;
+    ctx.flags.n && typeof ctx.flags.n == "string" && (n = parseInt(ctx.flags.n, 10));
+    for (let key of Object.keys(ctx.flags))
+      /^\d+$/.test(key) && (n = parseInt(key, 10));
+    let text = ctx.stdin;
+    if (ctx.args.length > 0) {
+      let [content, error] = await shellReadFile(ctx.toolRegistry, ctx.workspace, vfsPath(ctx.args[0]), { end_line: n });
+      return error ? err(`head: ${error}`) : ok(content);
+    }
+    if (!text) return ok("");
+    let lines = text.split(`
+`);
+    return ok(lines.slice(0, n).join(`
+`));
+  }
+}, tailHandler = {
+  name: "tail",
+  summary: "Show last N lines",
+  helpText: [
+    "tail [-N] [file]     Show last N lines (default 10)",
+    "",
+    "Options:",
+    "  -n <N>             Number of lines (or -N shorthand); -n +N starts at line N",
+    "  -c <N>             Last N BYTES instead of lines; -c +N starts at byte N",
+    "                     (UTF-8 byte slice; a multi-byte char cut at the",
+    "                     boundary becomes U+FFFD). Takes precedence over -n."
+  ].join(`
+`),
+  category: "filesystem",
+  resolvedTools: ["fs_read"],
+  valueFlags: /* @__PURE__ */ new Set(["n", "c"]),
+  async execute(ctx) {
+    if (ctx.flags.c !== void 0) {
+      let raw = ctx.flags.c;
+      if (typeof raw != "string" || !/^\+?\d+$/.test(raw))
+        return err("tail: -c requires a plain byte count (e.g. tail -c 80 file); suffixes (K/M) and negative counts are not supported");
+      let fromByte = raw.startsWith("+"), bytes = parseInt(raw, 10), content = ctx.stdin;
+      if (ctx.args.length > 0) {
+        let [fileContent, error] = await shellReadFile(ctx.toolRegistry, ctx.workspace, vfsPath(ctx.args[0]));
+        if (error) return err(`tail: ${error}`);
+        content = fileContent;
+      }
+      if (!content) return ok("");
+      let buf = Buffer.from(content, "utf8"), sliced = fromByte ? buf.subarray(Math.max(0, bytes - 1)) : bytes <= 0 ? buf.subarray(buf.length) : buf.subarray(Math.max(0, buf.length - bytes));
+      return ok(sliced.toString("utf8"));
+    }
+    let n = 10, fromLine = !1;
+    if (typeof ctx.flags.n == "string") {
+      let raw = ctx.flags.n;
+      fromLine = raw.startsWith("+"), n = parseInt(raw, 10);
+    }
+    for (let key of Object.keys(ctx.flags))
+      /^\d+$/.test(key) && (n = parseInt(key, 10));
+    if (isNaN(n)) return err("tail: invalid number of lines");
+    let text = ctx.stdin;
+    if (ctx.args.length > 0) {
+      let [content, error] = await shellReadFile(ctx.toolRegistry, ctx.workspace, vfsPath(ctx.args[0]));
+      if (error) return err(`tail: ${error}`);
+      text = content;
+    }
+    if (!text) return ok("");
+    let lines = text.split(`
+`);
+    return lines.length > 0 && lines[lines.length - 1] === "" && lines.pop(), fromLine ? ok(lines.slice(Math.max(0, n - 1)).join(`
+`)) : n <= 0 ? ok("") : ok(lines.slice(-n).join(`
+`));
+  }
+}, mkdirHandler = {
+  name: "mkdir",
+  summary: "No-op: the VFS is flat, directories are implicit",
+  helpText: [
+    "mkdir [-p] <path>    No-op. The VFS has no directory objects \u2014 a path like",
+    "                     archive/notes.md is just a name, so write it directly."
+  ].join(`
+`),
+  category: "filesystem",
+  resolvedTools: [],
+  async execute(ctx) {
+    return ctx.args.length === 0 && ctx.flags.p === void 0 ? err("mkdir: missing operand") : {
+      exit_code: 0,
+      stdout: "",
+      stderr: "mkdir: nothing to do \u2014 the VFS is flat; directory names are just part of the path (write archive/file.md directly)"
+    };
+  }
+}, filesystemHandlers = [
+  catHandler,
+  lsHandler,
+  rmHandler,
+  cpHandler,
+  mvHandler,
+  touchHandler,
+  findHandler,
+  duHandler,
+  chmodHandler,
+  headHandler,
+  tailHandler,
+  mkdirHandler
+];
+
+// src/main/tools/shell/commands/wasi-applet-adapter.ts
+import { readFileSync } from "fs";
+import { Worker } from "node:worker_threads";
+
+// src/main/tools/shell/commands/locate-resource.ts
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+function locate(segments) {
+  let starts = [];
+  typeof __dirname < "u" && starts.push(__dirname), starts.push(process.cwd());
+  for (let start of starts) {
+    let dir = start;
+    for (let i = 0; i < 8; i++) {
+      let candidate = join(dir, ...segments);
+      if (existsSync(candidate)) return candidate;
+      let parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  throw new Error(`not found: ${segments.join("/")}`);
+}
+
+// src/main/tools/shell/commands/wasi-applet-adapter.ts
+function locateWasm() {
+  return locate(["resources", "wasm", "coreutils.wasm"]);
+}
+function locateShim() {
+  return locate(["node_modules", "@bjorn3", "browser_wasi_shim", "dist", "index.js"]);
+}
+var modulePromise = null;
+function getModule() {
+  return modulePromise || (modulePromise = WebAssembly.compile(readFileSync(locateWasm()))), modulePromise;
+}
+var WORKER_SRC = `
+const { parentPort, workerData } = require('node:worker_threads')
+const { WASI, File, Directory, OpenFile, PreopenDirectory, ConsoleStdout, WASIProcExit } = require(workerData.shimPath)
+
+function buildTree(files) {
+  const enc = new TextEncoder()
+  const root = new Map()
+  for (const [path, content] of Object.entries(files)) {
+    const segments = String(path).split('/').filter(Boolean)
+    if (segments.length === 0) continue
+    const bytes = typeof content === 'string' ? enc.encode(content) : content
+    let dir = root, conflict = false
+    for (let i = 0; i < segments.length - 1; i++) {
+      const existing = dir.get(segments[i])
+      if (existing instanceof Directory) { dir = existing.contents; continue }
+      // Don't overwrite a File with a Directory (path 'a' and 'a/b' collide) \u2014
+      // skip the conflicting entry rather than corrupt the earlier one.
+      if (existing !== undefined) { conflict = true; break }
+      const next = new Directory(new Map())
+      dir.set(segments[i], next)
+      dir = next.contents
+    }
+    if (conflict) continue
+    const leaf = segments[segments.length - 1]
+    if (dir.get(leaf) instanceof Directory) continue
+    dir.set(leaf, new File(bytes))
+  }
+  return root
+}
+
+;(async () => {
+  const { wasmModule, applet, argv, stdin, files } = workerData
+  let stdout = '', stderr = ''
+  const od = new TextDecoder(), ed = new TextDecoder()
+  const fds = [
+    new OpenFile(new File(new TextEncoder().encode(stdin))),
+    new ConsoleStdout((b) => { stdout += od.decode(b, { stream: true }) }),
+    new ConsoleStdout((b) => { stderr += ed.decode(b, { stream: true }) }),
+    new PreopenDirectory('.', buildTree(files)),
+  ]
+  const wasi = new WASI(['coreutils', applet, ...argv], [], fds, { debug: false })
+  const instance = await WebAssembly.instantiate(wasmModule, { wasi_snapshot_preview1: wasi.wasiImport })
+  let exitCode = 0
+  try { exitCode = wasi.start(instance) }
+  catch (e) { if (e instanceof WASIProcExit) exitCode = e.code; else throw e }
+  // Flush any bytes held back by a multibyte sequence at a chunk boundary.
+  stdout += od.decode(); stderr += ed.decode()
+  parentPort.postMessage({ stdout, stderr, exitCode })
+})().catch((e) => parentPort.postMessage({ error: String((e && e.message) || e) }))
+`, MAX_CONCURRENT_WORKERS = 8, activeWorkers = 0, workerQueue = [];
+function acquireSlot() {
+  return activeWorkers < MAX_CONCURRENT_WORKERS ? (activeWorkers++, Promise.resolve()) : new Promise((resolve) => workerQueue.push(resolve));
+}
+function releaseSlot() {
+  let next = workerQueue.shift();
+  next ? next() : activeWorkers--;
+}
+async function runApplet(applet, argv, stdin, files = {}, opts = {}) {
+  let wasmModule = await getModule(), shimPath = locateShim(), timeoutMs = opts.timeoutMs && opts.timeoutMs > 0 ? opts.timeoutMs : 6e4;
+  return await acquireSlot(), new Promise((resolve) => {
+    let worker;
+    try {
+      worker = new Worker(WORKER_SRC, {
+        eval: !0,
+        workerData: { wasmModule, applet, argv, stdin, files, shimPath }
+      });
+    } catch (e) {
+      releaseSlot(), resolve({ stdout: "", stderr: `${applet}: worker start failed: ${e instanceof Error ? e.message : String(e)}`, exitCode: 1 });
+      return;
+    }
+    let settled = !1, finish = (r) => {
+      settled || (settled = !0, clearTimeout(timer), worker.terminate(), releaseSlot(), resolve(r));
+    }, timer = setTimeout(
+      () => finish({ stdout: "", stderr: `${applet}: timed out after ${Math.round(timeoutMs / 1e3)}s`, exitCode: 124 }),
+      timeoutMs
+    );
+    if (worker.once("message", (m) => {
+      m?.error ? finish({ stdout: "", stderr: `${applet}: ${m.error}`, exitCode: 1 }) : finish({ stdout: m.stdout ?? "", stderr: m.stderr ?? "", exitCode: m.exitCode ?? 0 });
+    }), worker.once("error", (e) => finish({ stdout: "", stderr: `${applet}: ${e.message}`, exitCode: 1 })), opts.signal) {
+      let onAbort = () => finish({ stdout: "", stderr: `${applet}: aborted`, exitCode: 130 });
+      opts.signal.aborted ? onAbort() : opts.signal.addEventListener("abort", onAbort, { once: !0 });
+    }
+  });
+}
+
+// src/main/tools/shell/commands/regex-worker.ts
+import { Worker as Worker2 } from "node:worker_threads";
+var OFFLOAD_MIN_BYTES = 64 * 1024;
+function mayBacktrack(source) {
+  if (/\\[1-9]/.test(source)) return !0;
+  let groupStarts = [];
+  for (let i = 0; i < source.length; i++) {
+    let c = source[i];
+    if (c === "\\") {
+      i++;
+      continue;
+    }
+    if (c === "[") {
+      for (i++, source[i] === "^" && i++, source[i] === "]" && i++; i < source.length && source[i] !== "]"; )
+        source[i] === "\\" && i++, i++;
+      continue;
+    }
+    if (c === "(") {
+      groupStarts.push(i);
+      continue;
+    }
+    if (c === ")") {
+      let start = groupStarts.pop();
+      if (start === void 0) continue;
+      let next = source[i + 1];
+      if ((next === "*" || next === "+" || next === "{") && /[*+{|]/.test(source.slice(start + 1, i)))
+        return !0;
+    }
+  }
+  return !1;
+}
+var WORKER_SRC2 = `
+const { parentPort } = require('node:worker_threads')
+
+function scan(re, line) {
+  const out = []
+  if (!re.global) {
+    const m = re.exec(line)
+    if (m) out.push({ index: m.index, match: m[0], groups: m.slice(1) })
+    return out
+  }
+  re.lastIndex = 0
+  let m
+  while ((m = re.exec(line)) !== null) {
+    out.push({ index: m.index, match: m[0], groups: m.slice(1) })
+    if (m[0] === '') re.lastIndex++
+  }
+  return out
+}
+
+parentPort.on('message', (job) => {
+  try {
+    if (job.kind === 'select') {
+      const re = new RegExp(job.source, job.flags)
+      const oRe = job.pieces ? new RegExp(job.source, job.flags.includes('g') ? job.flags : job.flags + 'g') : null
+      const idx = []
+      const pieces = oRe ? [] : null
+      for (let i = 0; i < job.lines.length && idx.length < job.maxCount; i++) {
+        const line = job.lines[i]
+        if (re.test(line) !== job.invert) {
+          idx.push(i)
+          if (pieces) pieces.push((line.match(oRe) || []).filter((s) => s.length > 0))
+        }
+      }
+      parentPort.postMessage({ id: job.id, ok: true, value: { idx, pieces } })
+    } else {
+      const re = new RegExp(job.source, job.flags)
+      const matches = job.lines.map((line) => scan(re, line))
+      parentPort.postMessage({ id: job.id, ok: true, value: matches })
+    }
+  } catch (e) {
+    parentPort.postMessage({ id: job.id, ok: false, message: String((e && e.message) || e) })
+  }
+})
+`, MAX_WORKERS = 4, idleWorkers = [], liveWorkers = 0, waiters = [], jobSeq = 0;
+function spawn() {
+  let w = new Worker2(WORKER_SRC2, { eval: !0 });
+  w.unref();
+  let drop = () => {
+    let at = idleWorkers.indexOf(w);
+    at >= 0 && (idleWorkers.splice(at, 1), liveWorkers--);
+  };
+  return w.on("error", drop), w.on("exit", drop), w;
+}
+function acquire() {
+  let w = idleWorkers.pop();
+  if (w)
+    return w.ref(), Promise.resolve(w);
+  if (liveWorkers < MAX_WORKERS) {
+    liveWorkers++;
+    let fresh = spawn();
+    return fresh.ref(), Promise.resolve(fresh);
+  }
+  return new Promise((resolve) => waiters.push(resolve));
+}
+function release(w) {
+  let next = waiters.shift();
+  if (w) {
+    if (next) {
+      next(w);
+      return;
+    }
+    w.unref(), idleWorkers.push(w);
+    return;
+  }
+  if (liveWorkers--, next) {
+    liveWorkers++;
+    let fresh = spawn();
+    fresh.ref(), next(fresh);
+  }
+}
+async function run(job, opts) {
+  let timeoutMs = opts.timeoutMs && opts.timeoutMs > 0 ? opts.timeoutMs : 6e4, worker = await acquire();
+  return new Promise((resolve) => {
+    let settled = !1, onMessage = (m) => {
+      settled || (settled = !0, clearTimeout(timer), worker.off("message", onMessage), worker.off("error", onError), opts.signal?.removeEventListener("abort", onAbort), release(worker), m?.ok ? resolve({ ok: !0, value: m.value }) : resolve({ ok: !1, reason: "error", message: m?.message ?? "regex worker failed" }));
+    }, kill = (reason, message) => {
+      settled || (settled = !0, clearTimeout(timer), worker.off("message", onMessage), worker.off("error", onError), opts.signal?.removeEventListener("abort", onAbort), worker.terminate(), release(null), resolve({ ok: !1, reason, message }));
+    }, onError = (e) => kill("error", e.message), onAbort = () => kill("aborted", "aborted"), timer = setTimeout(
+      () => kill("timeout", `timed out after ${Math.round(timeoutMs / 1e3)}s`),
+      timeoutMs
+    );
+    if (worker.on("message", onMessage), worker.on("error", onError), opts.signal) {
+      if (opts.signal.aborted) {
+        onAbort();
+        return;
+      }
+      opts.signal.addEventListener("abort", onAbort, { once: !0 });
+    }
+    worker.postMessage({ ...job, id: ++jobSeq });
+  });
+}
+function selectLines(job, opts = {}) {
+  return run({ kind: "select", ...job }, opts);
+}
+function execLines(job, opts = {}) {
+  return run({ kind: "exec", ...job }, opts);
+}
+
+// src/main/tools/shell/commands/text.ts
+function regexFailure(cmd, reason, message) {
+  return err(`${cmd}: ${message}`, reason === "timeout" ? 124 : reason === "aborted" ? 130 : 1);
+}
+function vfsPath2(p) {
+  return p === "." || p === "./" || p === "/" ? "" : p.replace(/^\.\//, "").replace(/^\//, "");
+}
+function interpretEscapes(s) {
+  return s.replace(/\\n/g, `
+`).replace(/\\t/g, "	").replace(/\\r/g, "\r").replace(/\\\\/g, "\\");
+}
+async function coreutilsExec(applet, ctx, opts = { fileArgs: !0 }) {
+  let files = {}, argv = [...ctx.rawArgs ?? ctx.args];
+  if ((/* @__PURE__ */ new Set(["sort", "shuf"])).has(applet)) {
+    let badFlag = argv.find((a) => /^-o/.test(a) || /^--o/.test(a));
+    if (badFlag)
+      return err(`${applet}: writing to a file (${badFlag}) is not supported in the sandbox \u2014 redirect stdout instead (e.g. \`${applet} ... > out.txt\`)`);
+  }
+  if (opts.fileArgs)
+    for (let i = 0; i < argv.length; i++) {
+      let tok = argv[i];
+      if (tok.startsWith("-")) continue;
+      let norm = vfsPath2(tok);
+      if (!norm) continue;
+      let [row, readErr] = await shellReadFileRow(ctx.toolRegistry, ctx.workspace, norm);
+      readErr === null && (files[norm] = isTextRow(row) ? row.content : Buffer.from(row.content, "base64"), argv[i] = norm);
+    }
+  try {
+    let { stdout, stderr, exitCode } = await runApplet(applet, argv, ctx.stdin || "", files, {
+      timeoutMs: ctx.config.limits?.execution_timeout_ms,
+      signal: ctx.signal
+    });
+    return exitCode !== 0 ? { exit_code: exitCode, stdout, stderr: stderr.trim() || `${applet}: exit ${exitCode}` } : ok(stdout);
+  } catch (e) {
+    return err(`${applet}: ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function splitLines(text) {
+  let lines = text.split(`
+`);
+  return lines.length > 0 && lines[lines.length - 1] === "" && lines.pop(), lines;
+}
+var GREP_KNOWN_FLAGS = /* @__PURE__ */ new Set([
+  "i",
+  "v",
+  "c",
+  "n",
+  "r",
+  "R",
+  "o",
+  "F",
+  "w",
+  "x",
+  "l",
+  "q",
+  "m",
+  "E",
+  "e",
+  "h",
+  "H",
+  "A",
+  "B",
+  "C",
+  "include",
+  "exclude"
+]), grepHandler = {
+  name: "grep",
+  summary: "Filter lines matching a pattern",
+  helpText: [
+    "grep <pattern> [file]   Filter lines matching a regex (ERE-style, JS regex)",
+    "",
+    "Supported: -i case-insensitive, -v invert, -c count, -n line numbers,",
+    "  -r recursive (VFS), -o only-matching, -F fixed string, -w word match,",
+    "  -x whole-line, -l files-with-matches, -q quiet, -m <N> max matches,",
+    "  -e <pat>, -A/-B/-C <N> context, --include/--exclude=<glob>.",
+    "Unsupported flags (e.g. -P) are rejected, not ignored. Regex is JS/ERE:",
+    "  -P (PCRE) is not supported, and BRE escapes are REJECTED rather than",
+    "  silently matching nothing \u2014 write | ( ) { } + ? unescaped (plain `grep`",
+    "  on a real system is BRE, so \\| habits produce zero matches here)."
+  ].join(`
+`),
+  category: "text",
+  resolvedTools: [],
+  // pure text operation; -r uses fs_list + fs_read
+  valueFlags: /* @__PURE__ */ new Set(["A", "B", "C", "m", "e"]),
+  async execute(ctx) {
+    let unknown = Object.keys(ctx.flags).filter((f) => !GREP_KNOWN_FLAGS.has(f));
+    if (unknown.length > 0)
+      return err(`grep: unsupported option${unknown.length > 1 ? "s" : ""}: ${unknown.map((f) => (f.length === 1 ? "-" : "--") + f).join(", ")}`);
+    let patternFromE = typeof ctx.flags.e == "string" ? ctx.flags.e : void 0, pattern = patternFromE ?? ctx.args[0];
+    if (pattern === void 0) return err("grep: missing pattern");
+    let fileArgs = patternFromE ? ctx.args : ctx.args.slice(1), ignoreCase = !!ctx.flags.i, invert = !!ctx.flags.v, count = !!ctx.flags.c, showNumbers = !!ctx.flags.n, recursive = !!ctx.flags.r || !!ctx.flags.R, onlyMatching = !!ctx.flags.o, listFiles = !!ctx.flags.l, quiet = !!ctx.flags.q, maxCount = typeof ctx.flags.m == "string" ? parseInt(ctx.flags.m, 10) : 1 / 0, afterCtx = typeof ctx.flags.A == "string" ? parseInt(ctx.flags.A, 10) : 0, beforeCtx = typeof ctx.flags.B == "string" ? parseInt(ctx.flags.B, 10) : 0, aroundCtx = typeof ctx.flags.C == "string" ? parseInt(ctx.flags.C, 10) : 0, ctxBefore = aroundCtx || beforeCtx, ctxAfter = aroundCtx || afterCtx;
+    if (!ctx.flags.F) {
+      let bre = pattern.match(/\\[|(){}+?]/g);
+      if (bre) {
+        let seen = [...new Set(bre)], ere = seen.map((s) => `${s} \u2192 ${s[1]}`).join(", ");
+        return err(
+          `grep: ${seen.join(" ")} is BRE syntax; this grep is ERE/JS where it means a LITERAL character and would match nothing. Write ${ere}. For a literal character use a bracket class ([|]) or -F with the bare character (-F takes no escapes).`
+        );
+      }
+    }
+    let src = ctx.flags.F ? escapeRegExp(pattern) : pattern;
+    ctx.flags.w && (src = `(?<![A-Za-z0-9_])(?:${src})(?![A-Za-z0-9_])`), ctx.flags.x && (src = `^(?:${src})$`);
+    let lineRe, oRe = null;
+    try {
+      lineRe = new RegExp(src, ignoreCase ? "i" : ""), onlyMatching && (oRe = new RegExp(src, ignoreCase ? "ig" : "g"));
+    } catch (e) {
+      return err(`grep: invalid pattern: ${e instanceof Error ? e.message : String(pattern)}`);
+    }
+    let globToRe = (g) => g ? new RegExp("^" + g.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".") + "$") : void 0, includeRe = globToRe(typeof ctx.flags.include == "string" ? ctx.flags.include : void 0), excludeRe = globToRe(typeof ctx.flags.exclude == "string" ? ctx.flags.exclude : void 0), noFilename = !!ctx.flags.h, forceFilename = !!ctx.flags.H, reFlags = ignoreCase ? "i" : "", wantPieces = onlyMatching && !listFiles && !quiet && !count, offloadPattern = mayBacktrack(src), timeoutMs = ctx.config.limits?.execution_timeout_ms, select = async (lines2, bytes) => {
+      if (!offloadPattern && bytes <= OFFLOAD_MIN_BYTES) {
+        let idx = [], pieces = wantPieces ? [] : null;
+        for (let i = 0; i < lines2.length && idx.length < maxCount; i++)
+          lineRe.test(lines2[i]) !== invert && (idx.push(i), pieces && oRe && pieces.push((lines2[i].match(oRe) ?? []).filter((m) => m.length > 0)));
+        return { idx, pieces };
+      }
+      let r = await selectLines(
+        { source: src, flags: reFlags, lines: lines2, invert, maxCount, pieces: wantPieces },
+        { timeoutMs, signal: ctx.signal }
+      );
+      return r.ok ? r.value : { failure: regexFailure("grep", r.reason, r.message) };
+    }, emit = (line, prefix, out2, pieces) => {
+      if (wantPieces && pieces) {
+        for (let m of pieces) out2.push(`${prefix}${m}`);
+        return;
+      }
+      out2.push(`${prefix}${line}`);
+    };
+    if (recursive || fileArgs.length > 1 || fileArgs.length === 1 && (listFiles || recursive)) {
+      let startPath = vfsPath2(fileArgs[0] ?? ""), all = ctx.workspace.listFiles(), files = recursive ? startPath ? all.filter((f) => f.path.startsWith(startPath)) : all : all.filter((f) => fileArgs.map(vfsPath2).includes(f.path));
+      includeRe && (files = files.filter((f) => includeRe.test(f.path.split("/").pop() ?? f.path))), excludeRe && (files = files.filter((f) => !excludeRe.test(f.path.split("/").pop() ?? f.path)));
+      let withName = forceFilename || !noFilename, out2 = [], counts = [], matchedFiles = [], anyMatch = !1;
+      for (let file of files) {
+        if (file.mime_type && !isTextMime(file.mime_type)) continue;
+        let [content, readErr] = await shellReadFile(ctx.toolRegistry, ctx.workspace, file.path);
+        if (readErr) continue;
+        let lines2 = splitLines(content), sel2 = await select(lines2, content?.length ?? 0);
+        if ("failure" in sel2) return sel2.failure;
+        let fileMatches = sel2.idx.length;
+        if (fileMatches > 0 && (anyMatch = !0), !listFiles && !quiet && !count)
+          for (let k = 0; k < sel2.idx.length; k++) {
+            let i = sel2.idx[k], prefix = `${withName ? `${file.path}:` : ""}${showNumbers ? `${i + 1}:` : ""}`;
+            emit(lines2[i], prefix, out2, sel2.pieces ? sel2.pieces[k] : null);
+          }
+        count && counts.push(`${withName ? `${file.path}:` : ""}${fileMatches}`), fileMatches > 0 && matchedFiles.push(file.path);
+      }
+      return quiet ? { exit_code: anyMatch ? 0 : 1, stdout: "", stderr: "" } : listFiles ? matchedFiles.length > 0 ? ok(matchedFiles.join(`
+`)) : { exit_code: 1, stdout: "", stderr: "" } : count ? { exit_code: anyMatch ? 0 : 1, stdout: counts.join(`
+`), stderr: "" } : anyMatch ? ok(out2.join(`
+`)) : { exit_code: 1, stdout: "", stderr: "" };
+    }
+    let text = ctx.stdin;
+    if (fileArgs.length === 1) {
+      let [content, readErr] = await shellReadFile(ctx.toolRegistry, ctx.workspace, vfsPath2(fileArgs[0]));
+      if (readErr) return err(`grep: ${fileArgs[0]}: No such file or directory`);
+      text = content;
+    }
+    if (!text)
+      return { exit_code: 1, stdout: !quiet && count ? "0" : "", stderr: "" };
+    let lines = splitLines(text), sel = await select(lines, text.length);
+    if ("failure" in sel) return sel.failure;
+    let matchIdx = sel.idx;
+    if (quiet) return { exit_code: matchIdx.length > 0 ? 0 : 1, stdout: "", stderr: "" };
+    if (count) return { exit_code: matchIdx.length > 0 ? 0 : 1, stdout: String(matchIdx.length), stderr: "" };
+    if (matchIdx.length === 0) return { exit_code: 1, stdout: "", stderr: "" };
+    let out = [];
+    if (ctxBefore === 0 && ctxAfter === 0) {
+      for (let k = 0; k < matchIdx.length; k++) {
+        let i = matchIdx[k];
+        emit(lines[i], showNumbers ? `${i + 1}:` : "", out, sel.pieces ? sel.pieces[k] : null);
+      }
+      return ok(out.join(`
+`));
+    }
+    let included = /* @__PURE__ */ new Set();
+    for (let idx of matchIdx)
+      for (let j = Math.max(0, idx - ctxBefore); j <= Math.min(lines.length - 1, idx + ctxAfter); j++) included.add(j);
+    let lastPrinted = -2;
+    for (let idx of [...included].sort((a, b) => a - b))
+      lastPrinted >= 0 && idx > lastPrinted + 1 && out.push("--"), out.push(`${showNumbers ? `${idx + 1}:` : ""}${lines[idx]}`), lastPrinted = idx;
+    return ok(out.join(`
+`));
+  }
+};
+function renderSedReplacement(template, matchArgs) {
+  let offsetIdx = matchArgs.findIndex((a) => typeof a == "number"), groups = offsetIdx > 0 ? matchArgs.slice(0, offsetIdx) : [matchArgs[0]], out = "";
+  for (let i = 0; i < template.length; i++) {
+    let c = template[i];
+    if (c === "\\") {
+      let n = template[i + 1];
+      if (n === void 0) {
+        out += "\\";
+        break;
+      }
+      n >= "0" && n <= "9" ? out += String(groups[Number(n)] ?? "") : n === "&" ? out += "&" : n === "n" ? out += `
+` : n === "t" ? out += "	" : out += n, i++;
+    } else c === "&" ? out += String(groups[0] ?? "") : out += c;
+  }
+  return out;
+}
+function applySedMatches(line, matches, template) {
+  if (matches.length === 0) return line;
+  let out = "", pos = 0;
+  for (let m of matches)
+    out += line.slice(pos, m.index) + renderSedReplacement(template, [m.match, ...m.groups, m.index, line]), pos = m.index + m.match.length;
+  return out + line.slice(pos);
+}
+var SED_KNOWN_FLAGS = /* @__PURE__ */ new Set(["i", "E", "r"]), sedHandler = {
+  name: "sed",
+  summary: "Stream editor (s/// substitution)",
+  helpText: [
+    "sed 's/old/new/[gi]' [file]   Regex substitution (JS/ERE regex)",
+    "sed -i 's/old/new/' <file>     In-place edit",
+    "",
+    "Replacement: & = whole match, \\1..\\9 = capture groups, \\n \\t supported.",
+    "Options: -i in-place, -E/-r extended regex (default). Addresses (1p, /re/d)",
+    "and -n are NOT supported \u2014 they error rather than silently misbehave."
+  ].join(`
+`),
+  category: "text",
+  resolvedTools: ["fs_read", "fs_write"],
+  async execute(ctx) {
+    if (ctx.args.length === 0) return err("sed: missing expression");
+    let unknown = Object.keys(ctx.flags).filter((f) => !SED_KNOWN_FLAGS.has(f));
+    if (unknown.length > 0)
+      return err(`sed: unsupported option${unknown.length > 1 ? "s" : ""}: ${unknown.map((f) => (f.length === 1 ? "-" : "--") + f).join(", ")} (only s/// substitution is supported)`);
+    let inPlace = !!ctx.flags.i, expr = ctx.args[0], match = expr.match(/^s(.)(.+?)\1(.*?)\1([gi]*)$/);
+    if (!match) return err(`sed: unsupported expression "${expr}" \u2014 only s/old/new/[gi] is supported`);
+    let [, , pattern, rawReplacement, flags] = match, reFlags = (flags.includes("i") ? "i" : "") + (flags.includes("g") ? "g" : ""), regex;
+    try {
+      regex = new RegExp(pattern, reFlags);
+    } catch (e) {
+      return err(`sed: invalid pattern: ${e instanceof Error ? e.message : pattern}`);
+    }
+    let replacer = (...matchArgs) => renderSedReplacement(rawReplacement, matchArgs), text = ctx.stdin || "", filePath = null;
+    if (ctx.args.length > 1) {
+      filePath = vfsPath2(ctx.args[1]);
+      let [sedContent, sedErr] = await shellReadFile(ctx.toolRegistry, ctx.workspace, filePath);
+      if (sedErr) return err(`sed: ${filePath}: No such file or directory`);
+      text = sedContent;
+    } else if (!text)
+      return ok("");
+    let lines = text.split(`
+`), result;
+    if (!mayBacktrack(pattern) && text.length <= OFFLOAD_MIN_BYTES)
+      result = lines.map((line) => line.replace(regex, replacer)).join(`
+`);
+    else {
+      let r = await execLines(
+        { source: pattern, flags: reFlags, lines },
+        { timeoutMs: ctx.config.limits?.execution_timeout_ms, signal: ctx.signal }
+      );
+      if (!r.ok) return regexFailure("sed", r.reason, r.message);
+      result = lines.map((line, i) => applySedMatches(line, r.value[i], rawReplacement)).join(`
+`);
+    }
+    if (inPlace && filePath) {
+      let writeResult = await ctx.toolRegistry.executeTool("fs_write", { mode: "write", path: filePath, content: result }, ctx.workspace);
+      return writeResult.isError ? err(`sed: ${writeResult.content}`) : ok("");
+    }
+    return ok(result);
+  }
+}, sortHandler = {
+  name: "sort",
+  summary: "Sort lines",
+  helpText: [
+    "sort [file ...]     Sort lines (real GNU-compatible sort via WASM)",
+    "",
+    "Common options: -r reverse, -n numeric, -u unique, -k <N> key field,",
+    "-t <sep> field separator, -f ignore case, -h human-numeric, -V version sort."
+  ].join(`
+`),
+  category: "text",
+  resolvedTools: ["fs_read"],
+  valueFlags: /* @__PURE__ */ new Set(["k", "t"]),
+  async execute(ctx) {
+    return coreutilsExec("sort", ctx);
+  }
+}, uniqHandler = {
+  name: "uniq",
+  summary: "Deduplicate adjacent lines",
+  helpText: [
+    "uniq [file]         Remove adjacent duplicate lines (real coreutils)",
+    "",
+    "Common options: -c count, -d only-duplicates, -i ignore case,",
+    "-f <N> skip fields, -s <N> skip chars."
+  ].join(`
+`),
+  category: "text",
+  resolvedTools: ["fs_read"],
+  valueFlags: /* @__PURE__ */ new Set(["f", "s", "w"]),
+  async execute(ctx) {
+    return coreutilsExec("uniq", ctx);
+  }
+}, wcHandler = {
+  name: "wc",
+  summary: "Count lines, words, characters",
+  helpText: [
+    "wc [file ...]       Count lines, words, bytes (real coreutils)",
+    "",
+    "Common options: -l lines, -w words, -c bytes, -m chars, -L max line length."
+  ].join(`
+`),
+  category: "text",
+  resolvedTools: ["fs_read"],
+  async execute(ctx) {
+    return coreutilsExec("wc", ctx);
+  }
+}, cutHandler = {
+  name: "cut",
+  summary: "Extract fields from lines",
+  helpText: [
+    "cut -d<delim> -f<N> [file]  Extract fields/chars (real coreutils)",
+    "",
+    "Common options: -d <delim> delimiter, -f <list> fields (1,3-5, 2-),",
+    "-c <list> characters, -b <list> bytes."
+  ].join(`
+`),
+  category: "text",
+  resolvedTools: ["fs_read"],
+  valueFlags: /* @__PURE__ */ new Set(["d", "f", "c", "b"]),
+  async execute(ctx) {
+    return coreutilsExec("cut", ctx);
+  }
+}, trHandler = {
+  name: "tr",
+  summary: "Translate characters",
+  helpText: [
+    "tr <set1> [set2]     Translate/delete characters (real coreutils)",
+    "",
+    "Supports ranges (a-z), classes ([:digit:]), -d delete, -s squeeze, -c complement."
+  ].join(`
+`),
+  category: "text",
+  resolvedTools: [],
+  async execute(ctx) {
+    return coreutilsExec("tr", ctx, { fileArgs: !1 });
+  }
+}, teeHandler = {
+  name: "tee",
+  summary: "Write to file and pass through",
+  helpText: "tee <path>           Write stdin to file AND pass to stdout",
+  category: "text",
+  resolvedTools: ["fs_write"],
+  async execute(ctx) {
+    if (ctx.args.length === 0) return err("tee: missing file path");
+    let path = vfsPath2(ctx.args[0]), text = ctx.stdin || "";
+    return await ctx.toolRegistry.executeTool("fs_write", { mode: "write", path, content: text }, ctx.workspace), ok(text);
+  }
+};
+function fileArgsResolveTools(args) {
+  return args.some((a) => a.type !== "literal" || !a.value.startsWith("-")) ? ["fs_read"] : [];
+}
+async function readFileArgsOrStdin(cmd, ctx) {
+  if (ctx.args.length === 0) return [ctx.stdin || "", null];
+  let parts = [];
+  for (let rawPath of ctx.args) {
+    let [content, readErr] = await shellReadFile(ctx.toolRegistry, ctx.workspace, vfsPath2(rawPath));
+    if (readErr !== null) return [null, err(`${cmd}: ${readErr}`)];
+    parts.push(content);
+  }
+  return [parts.join(""), null];
+}
+var revHandler = {
+  name: "rev",
+  summary: "Reverse each line",
+  helpText: "rev [file ...]       Reverse characters in each line (files or stdin)",
+  category: "text",
+  resolvedTools: [],
+  resolveToolsFromArgs: fileArgsResolveTools,
+  async execute(ctx) {
+    let [text, readError] = await readFileArgsOrStdin("rev", ctx);
+    return readError !== null ? readError : text ? ok(text.split(`
+`).map((l) => l.split("").reverse().join("")).join(`
+`)) : ok("");
+  }
+}, tacHandler = {
+  name: "tac",
+  summary: "Reverse line order",
+  helpText: "tac [file ...]       Print lines in reverse order (files or stdin)",
+  category: "text",
+  resolvedTools: [],
+  resolveToolsFromArgs: fileArgsResolveTools,
+  async execute(ctx) {
+    let [text, readError] = await readFileArgsOrStdin("tac", ctx);
+    return readError !== null ? readError : text ? ok(splitLines(text).reverse().join(`
+`)) : ok("");
+  }
+};
+function lineDiff(a, b) {
+  let n = a.length, m = b.length, ops = [];
+  if ((n + 1) * (m + 1) > 4e6) {
+    let maxLen = Math.max(n, m);
+    for (let i2 = 0; i2 < maxLen; i2++)
+      i2 < n && i2 < m && a[i2] === b[i2] ? ops.push({ t: " ", line: a[i2] }) : (i2 < n && ops.push({ t: "-", line: a[i2] }), i2 < m && ops.push({ t: "+", line: b[i2] }));
+    return ops;
+  }
+  let width = m + 1, dp = new Uint32Array((n + 1) * width);
+  for (let i2 = n - 1; i2 >= 0; i2--)
+    for (let j2 = m - 1; j2 >= 0; j2--)
+      dp[i2 * width + j2] = a[i2] === b[j2] ? dp[(i2 + 1) * width + j2 + 1] + 1 : Math.max(dp[(i2 + 1) * width + j2], dp[i2 * width + j2 + 1]);
+  let i = 0, j = 0;
+  for (; i < n && j < m; )
+    a[i] === b[j] ? (ops.push({ t: " ", line: a[i] }), i++, j++) : dp[(i + 1) * width + j] >= dp[i * width + j + 1] ? ops.push({ t: "-", line: a[i++] }) : ops.push({ t: "+", line: b[j++] });
+  for (; i < n; ) ops.push({ t: "-", line: a[i++] });
+  for (; j < m; ) ops.push({ t: "+", line: b[j++] });
+  return ops;
+}
+function formatUnifiedDiff(file1, file2, ops, context = 3) {
+  let oldAt = [], newAt = [], ol = 1, nl = 1;
+  for (let op of ops)
+    oldAt.push(ol), newAt.push(nl), op.t !== "+" && ol++, op.t !== "-" && nl++;
+  let changed = ops.map((op, idx) => op.t === " " ? -1 : idx).filter((x) => x >= 0), ranges = [], start = Math.max(0, changed[0] - context), end = Math.min(ops.length - 1, changed[0] + context);
+  for (let c of changed.slice(1))
+    c - context <= end + 1 || (ranges.push([start, end]), start = Math.max(0, c - context)), end = Math.min(ops.length - 1, c + context);
+  ranges.push([start, end]);
+  let out = [`--- ${file1}`, `+++ ${file2}`];
+  for (let [rs, re] of ranges) {
+    let oldCount = 0, newCount = 0;
+    for (let k = rs; k <= re; k++)
+      ops[k].t !== "+" && oldCount++, ops[k].t !== "-" && newCount++;
+    out.push(`@@ -${oldAt[rs]},${oldCount} +${newAt[rs]},${newCount} @@`);
+    for (let k = rs; k <= re; k++) out.push(`${ops[k].t}${ops[k].line}`);
+  }
+  return out.join(`
+`);
+}
+var DIFF_KNOWN_FLAGS = /* @__PURE__ */ new Set(["u", "q"]), diffHandler = {
+  name: "diff",
+  summary: "Compare two files",
+  helpText: [
+    "diff <file1> <file2>  Compare files (unified-style output)",
+    "",
+    "Exit codes (bash semantics): 0 = identical (no output), 1 = files differ,",
+    "2 = error (missing file, unsupported option).",
+    "Options: -u accepted (output is already unified-style), -q report-only."
+  ].join(`
+`),
+  category: "text",
+  resolvedTools: ["fs_read"],
+  async execute(ctx) {
+    let unknown = Object.keys(ctx.flags).filter((f) => !DIFF_KNOWN_FLAGS.has(f));
+    if (unknown.length > 0)
+      return err(`diff: unsupported option${unknown.length > 1 ? "s" : ""}: ${unknown.map((f) => (f.length === 1 ? "-" : "--") + f).join(", ")}`, 2);
+    if (ctx.args.length < 2) return err("diff: usage: diff <file1> <file2>", 2);
+    let path1 = vfsPath2(ctx.args[0]), path2 = vfsPath2(ctx.args[1]), [row1, err1] = await shellReadFileRow(ctx.toolRegistry, ctx.workspace, path1);
+    if (err1 !== null) return err(`diff: ${ctx.args[0]}: ${err1}`, 2);
+    let [row2, err2] = await shellReadFileRow(ctx.toolRegistry, ctx.workspace, path2);
+    if (err2 !== null) return err(`diff: ${ctx.args[1]}: ${err2}`, 2);
+    if (!isTextRow(row1) || !isTextRow(row2))
+      return isTextRow(row1) === isTextRow(row2) && row1.content === row2.content ? ok("") : { exit_code: 1, stdout: `Binary files ${path1} and ${path2} differ`, stderr: "" };
+    if (row1.content === row2.content) return ok("");
+    if (ctx.flags.q) return { exit_code: 1, stdout: `Files ${path1} and ${path2} differ`, stderr: "" };
+    let ops = lineDiff(splitLines(row1.content), splitLines(row2.content));
+    return ops.some((o) => o.t !== " ") ? { exit_code: 1, stdout: formatUnifiedDiff(path1, path2, ops), stderr: "" } : { exit_code: 1, stdout: `Files ${path1} and ${path2} differ only in a trailing newline`, stderr: "" };
+  }
+};
+function shellQuote(s) {
+  return "'" + s.split("'").join("'\\''") + "'";
+}
+var xargsHandler = {
+  name: "xargs",
+  summary: "Build and run a command from stdin",
+  helpText: [
+    "xargs <cmd> [args]   Append whitespace-split stdin items as arguments",
+    "xargs -n N <cmd>     Same, but run one invocation per batch of N items",
+    "xargs -I {} <cmd>    Run command once per input LINE, substituting {}",
+    "",
+    "Options:",
+    "  -I <placeholder>   Per-line substitution mode (e.g. -I {})",
+    "  -n <count>         Batch mode: split stdin items into groups of <count>",
+    "                     and run the command once per group, sequentially.",
+    "                     Later batches still run if one fails; the exit code is",
+    "                     the HIGHEST batch exit code (real xargs collapses any",
+    "                     failure to 123 \u2014 we keep the real code instead). A",
+    "                     batch blocked by tool gating (exit 126/130) stops the",
+    "                     remaining batches. Cannot be combined with -I.",
+    "",
+    "Default mode (no -I/-n) follows real xargs: stdin is split on whitespace and",
+    "the items are appended to the command \u2014 but as ONE invocation (real xargs",
+    "batches by ARG_MAX; use -n for explicit batching). Items are passed as",
+    "literal arguments; {} is only special with -I.",
+    "Example: ls | jq -r '.[].path' | xargs -n 10 rm"
+  ].join(`
+`),
+  category: "text",
+  resolvedTools: [],
+  // resolved at runtime based on target command
+  valueFlags: /* @__PURE__ */ new Set(["I", "n"]),
+  async execute(ctx) {
+    if (ctx.args.length === 0) return err("xargs: missing command");
+    let cmdName = ctx.args[0], cmdArgs = ctx.args.slice(1), text = ctx.stdin || "", batchSize;
+    if ("n" in ctx.flags) {
+      if (ctx.flags.I !== void 0)
+        return err("xargs: -n cannot be combined with -I (real xargs silently ignores -n here; we refuse instead \u2014 -I already runs one invocation per line, so drop -n)");
+      let rawFlag = ctx.flags.n, raw = Array.isArray(rawFlag) ? rawFlag[rawFlag.length - 1] : rawFlag;
+      if (raw === !0) return err("xargs: -n requires a count (e.g. -n 2)");
+      let n = /^-?\d+$/.test(String(raw)) ? parseInt(String(raw), 10) : NaN;
+      if (!Number.isInteger(n) || n <= 0)
+        return err(`xargs: -n: invalid number '${raw}'`);
+      batchSize = n;
+    }
+    if (!text) return ok("");
+    let { parse } = await import("./parser-JVY2PWSM.mjs"), { executeNode } = await import("./pipeline-executor-BHBSJX2K.mjs"), subCtx = {
+      workspace: ctx.workspace,
+      toolRegistry: ctx.toolRegistry,
+      config: ctx.config,
+      env: ctx.env,
+      gate: ctx.gate,
+      // forward gating to the spawned sub-command
+      signal: ctx.signal,
+      // forward abort so a cancelled shell stops xargs
+      depth: (ctx.depth ?? 0) + 1
+    };
+    if (ctx.flags.I !== void 0) {
+      let placeholder = typeof ctx.flags.I == "string" ? ctx.flags.I : "{}", lines = text.split(`
+`).filter((l) => l), outputs2 = [];
+      for (let line of lines) {
+        let resolvedArgs = cmdArgs.map((a) => a === placeholder ? line : a.split(placeholder).join(line)), fullCmd = `${cmdName} ${resolvedArgs.map((a) => `"${a}"`).join(" ")}`, ast = parse(fullCmd), result = await executeNode(ast, "", subCtx);
+        if (ctx.signal?.aborted) return err("xargs: aborted", 130);
+        if (result.exit_code !== 0) return result;
+        result.stdout && outputs2.push(result.stdout);
+      }
+      return ok(outputs2.join(`
+`));
+    }
+    let items = text.split(/\s+/).filter(Boolean), size = batchSize ?? items.length, outputs = [], errors = [], worstExit = 0;
+    for (let i = 0; i < items.length; i += size) {
+      if (ctx.signal?.aborted) return err("xargs: aborted", 130);
+      let batch = items.slice(i, i + size), fullCmd = [cmdName, ...cmdArgs.map(shellQuote), ...batch.map(shellQuote)].join(" "), ast = parse(fullCmd), result = await executeNode(ast, "", subCtx);
+      if (ctx.signal?.aborted) return err("xargs: aborted", 130);
+      if (result.stdout && outputs.push(result.stdout), result.stderr && errors.push(result.stderr), worstExit = Math.max(worstExit, result.exit_code), result.exit_code === 126 || result.exit_code === 130)
+        return { exit_code: result.exit_code, stdout: outputs.join(""), stderr: errors.join(`
+`) };
+    }
+    return { exit_code: worstExit, stdout: outputs.join(""), stderr: errors.join(`
+`) };
+  }
+}, seqHandler = {
+  name: "seq",
+  summary: "Generate number sequence",
+  helpText: [
+    "seq <last>           Print 1 to last",
+    "seq <first> <last>   Print first to last",
+    "seq <first> <inc> <last>  Print with increment"
+  ].join(`
+`),
+  category: "text",
+  resolvedTools: [],
+  async execute(ctx) {
+    let nums0 = (ctx.rawArgs ?? ctx.args).filter((t) => /^-?\d+(\.\d+)?$/.test(t)).map(Number), first = 1, inc = 1, last = 1;
+    if (nums0.length === 1)
+      last = nums0[0];
+    else if (nums0.length === 2)
+      first = nums0[0], last = nums0[1];
+    else if (nums0.length >= 3)
+      first = nums0[0], inc = nums0[1], last = nums0[2];
+    else
+      return err("seq: missing operand");
+    if (isNaN(first) || isNaN(inc) || isNaN(last) || inc === 0) return err("seq: invalid arguments");
+    let maxItems = 1e5, estimated = Math.floor((last - first) / inc) + 1;
+    if (estimated > maxItems)
+      return err(`seq: range too large (${estimated} items > ${maxItems} limit)`);
+    let nums = [];
+    if (inc > 0)
+      for (let i = first; i <= last; i += inc) nums.push(i);
+    else
+      for (let i = first; i >= last; i += inc) nums.push(i);
+    return ok(nums.join(`
+`));
+  }
+}, printfHandler = {
+  name: "printf",
+  summary: "Format and print text",
+  helpText: [
+    "printf <format> [args...]  Format and print text",
+    "",
+    "Supports: %s (string), %d (integer), %f (float), %% (literal %)",
+    "Escape sequences: \\n, \\t, \\r, \\\\"
+  ].join(`
+`),
+  category: "text",
+  resolvedTools: [],
+  async execute(ctx) {
+    if (ctx.args.length === 0) return err("printf: missing format string");
+    let fmt = interpretEscapes(ctx.args[0]), fmtArgs = ctx.args.slice(1);
+    if ((fmt.match(/%[sdfe]/g) ?? []).length === 0) return ok(fmt);
+    let out = "", argIdx = 0;
+    do
+      out += fmt.replace(/%([sdfe%])/g, (match, spec) => {
+        if (spec === "%") return "%";
+        let arg = fmtArgs[argIdx++] ?? "";
+        switch (spec) {
+          case "s":
+            return arg;
+          case "d":
+            return String(parseInt(arg, 10) || 0);
+          case "f":
+          case "e":
+            return String(parseFloat(arg) || 0);
+          default:
+            return match;
+        }
+      });
+    while (argIdx < fmtArgs.length);
+    return ok(out);
+  }
+}, textHandlers = [
+  grepHandler,
+  sedHandler,
+  sortHandler,
+  uniqHandler,
+  wcHandler,
+  cutHandler,
+  trHandler,
+  teeHandler,
+  revHandler,
+  tacHandler,
+  diffHandler,
+  xargsHandler,
+  seqHandler,
+  printfHandler
+];
+
+// src/main/tools/shell/commands/jq-wasm-adapter.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { Worker as Worker3 } from "node:worker_threads";
+function locateJqEntry() {
+  return locate(["node_modules", "jq-wasm", "dist", "index.cjs"]);
+}
+function locateJqWasm() {
+  return locate(["node_modules", "jq-wasm", "dist", "build", "jq.wasm"]);
+}
+var modulePromise2 = null;
+function getModule2() {
+  return modulePromise2 || (modulePromise2 = WebAssembly.compile(readFileSync2(locateJqWasm()))), modulePromise2;
+}
+var WORKER_SRC3 = `
+const { parentPort, workerData } = require('node:worker_threads')
+;(async () => {
+  const { entryPath, wasmModule, input, filter, flags } = workerData
+  const jq = require(entryPath)
+  const handle = await jq.loadJq({ wasmModule })
+  const r = await handle.raw(input, filter, flags)
+  parentPort.postMessage({ stdout: r.stdout, stderr: r.stderr, exitCode: r.exitCode })
+})().catch((e) => parentPort.postMessage({ error: String((e && e.message) || e) }))
+`, MAX_CONCURRENT_WORKERS2 = 4, activeWorkers2 = 0, workerQueue2 = [];
+function acquireSlot2() {
+  return activeWorkers2 < MAX_CONCURRENT_WORKERS2 ? (activeWorkers2++, Promise.resolve()) : new Promise((resolve) => workerQueue2.push(resolve));
+}
+function releaseSlot2() {
+  let next = workerQueue2.shift();
+  next ? next() : activeWorkers2--;
+}
+async function runJq(input, filter, flags = [], opts = {}) {
+  let wasmModule = await getModule2(), entryPath = locateJqEntry(), timeoutMs = opts.timeoutMs && opts.timeoutMs > 0 ? opts.timeoutMs : 6e4;
+  return await acquireSlot2(), new Promise((resolve) => {
+    let worker;
+    try {
+      worker = new Worker3(WORKER_SRC3, {
+        eval: !0,
+        workerData: { entryPath, wasmModule, input, filter, flags }
+      });
+    } catch (e) {
+      releaseSlot2(), resolve({ stdout: "", stderr: `jq: worker start failed: ${e instanceof Error ? e.message : String(e)}`, exitCode: 1 });
+      return;
+    }
+    let settled = !1, finish = (r) => {
+      settled || (settled = !0, clearTimeout(timer), worker.terminate(), releaseSlot2(), resolve(r));
+    }, timer = setTimeout(
+      () => finish({ stdout: "", stderr: `jq: timed out after ${Math.round(timeoutMs / 1e3)}s`, exitCode: 124 }),
+      timeoutMs
+    );
+    if (worker.once("message", (m) => {
+      m?.error ? finish({ stdout: "", stderr: `jq: ${m.error}`, exitCode: 1 }) : finish({ stdout: m.stdout ?? "", stderr: m.stderr ?? "", exitCode: m.exitCode ?? 0 });
+    }), worker.once("error", (e) => finish({ stdout: "", stderr: `jq: ${e.message}`, exitCode: 1 })), opts.signal) {
+      let onAbort = () => finish({ stdout: "", stderr: "jq: aborted", exitCode: 130 });
+      opts.signal.aborted ? onAbort() : opts.signal.addEventListener("abort", onAbort, { once: !0 });
+    }
+  });
+}
+
+// src/main/tools/shell/commands/structured.ts
+var JQ_PASSTHROUGH_FLAGS = [
+  ["r", "-r"],
+  ["s", "-s"],
+  ["c", "-c"],
+  ["n", "-n"],
+  ["e", "-e"],
+  ["j", "-j"],
+  ["R", "-R"],
+  ["S", "-S"],
+  ["a", "-a"],
+  ["slurp", "-s"],
+  ["raw-input", "-R"],
+  ["raw-output", "-r"],
+  ["sort-keys", "-S"],
+  ["compact-output", "-c"],
+  ["null-input", "-n"],
+  ["tab", "--tab"],
+  ["ascii-output", "-a"]
+], jqHandler = {
+  name: "jq",
+  summary: "JSON processor",
+  helpText: [
+    "jq '<expr>'          Process JSON with jq expression",
+    "",
+    "Full jq 1.8.2 (real jq via WebAssembly): def, foreach, label/break,",
+    "multi-document input, @base64/@uri/@sh, and everything else jq supports.",
+    "",
+    "Options (standard jq flags pass through):",
+    "  -r raw output   -R raw input   -s slurp   -S sort keys",
+    "  -c compact      -n null input  -e exit status  -j join  -a ascii",
+    "  --tab           long forms: --raw-input/--raw-output/--sort-keys/\u2026"
+  ].join(`
+`),
+  category: "data",
+  resolvedTools: [],
+  async execute(ctx) {
+    let expression = ctx.args[0];
+    for (let key of ["slurp", "tab"])
+      expression === void 0 && typeof ctx.flags[key] == "string" && (expression = ctx.flags[key]);
+    if (expression === void 0) return err("jq: missing expression");
+    let extraPositionals = ctx.args.slice(1);
+    if (extraPositionals.length > 0)
+      return err(`jq: file arguments not supported (${extraPositionals.join(", ")}) \u2014 pipe the file instead: \`cat ${extraPositionals[0]} | jq '${expression}'\``);
+    let flags = JQ_PASSTHROUGH_FLAGS.filter(([key]) => !!ctx.flags[key]).map(([, cliFlag]) => cliFlag), dedupedFlags = [...new Set(flags)], nullInput = dedupedFlags.includes("-n"), text = ctx.stdin || "";
+    if (!text && !nullInput) return err("jq: no input");
+    let { stdout, stderr, exitCode } = await runJq(text, expression, dedupedFlags, {
+      timeoutMs: ctx.config.limits?.execution_timeout_ms,
+      signal: ctx.signal
+    });
+    return exitCode !== 0 ? {
+      exit_code: exitCode,
+      stdout,
+      stderr: stderr.trim() || `jq: exit ${exitCode}`
+    } : ok(stdout);
+  }
+};
+function isReadQuery(sql) {
+  let first = sql.trimStart().split(/\s/)[0].toUpperCase();
+  return ["SELECT", "WITH", "EXPLAIN"].includes(first);
+}
+function isDbPath(arg) {
+  return /\.(adf|db|sqlite)$/i.test(arg) || /^:.*:$/.test(arg);
+}
+function splitStatements(sql) {
+  let stmts = [], current = "", inString = !1, quote = "";
+  for (let i = 0; i < sql.length; i++) {
+    let ch = sql[i];
+    if (inString)
+      current += ch, ch === quote && (i + 1 < sql.length && sql[i + 1] === quote ? (current += sql[i + 1], i++) : inString = !1);
+    else if (ch === "'" || ch === '"')
+      inString = !0, quote = ch, current += ch;
+    else if (ch === ";") {
+      let trimmed2 = current.trim();
+      trimmed2 && stmts.push(trimmed2), current = "";
+    } else
+      current += ch;
+  }
+  let trimmed = current.trim();
+  return trimmed && stmts.push(trimmed), stmts;
+}
+function parseRows(content) {
+  try {
+    let parsed = JSON.parse(content);
+    if (Array.isArray(parsed) && parsed.length > 0 && typeof parsed[0] == "object") return parsed;
+  } catch {
+  }
+  return null;
+}
+function formatOutput(content, format) {
+  let rows = parseRows(content);
+  if (!rows) return content;
+  let cols = Object.keys(rows[0]);
+  if (format === "csv") {
+    let csvEscape = (v) => {
+      let s = v == null ? "" : String(v);
+      return s.includes(",") || s.includes('"') || s.includes(`
+`) ? `"${s.replace(/"/g, '""')}"` : s;
+    }, lines = [cols.join(",")];
+    for (let row of rows)
+      lines.push(cols.map((c) => csvEscape(row[c])).join(","));
+    return lines.join(`
+`);
+  }
+  let widths = cols.map((c) => c.length), stringRows = rows.map(
+    (row) => cols.map((c, i) => {
+      let s = row[c] === null || row[c] === void 0 ? "NULL" : String(row[c]);
+      return widths[i] = Math.max(widths[i], s.length), s;
+    })
+  ), header = cols.map((c, i) => c.padEnd(widths[i])).join("  "), sep = widths.map((w) => "-".repeat(w)).join("  "), body = stringRows.map((r) => r.map((s, i) => s.padEnd(widths[i])).join("  ")).join(`
+`);
+  return `${header}
+${sep}
+${body}`;
+}
+var sqlite3Handler = {
+  name: "sqlite3",
+  summary: "Execute SQL queries",
+  helpText: [
+    'sqlite3 "<sql>"         Query the agent database',
+    'sqlite3 --exec "<sql>"  Force write mode',
+    `sqlite3 "SELECT * FROM t WHERE k = ?" --params '["v"]'  Bind parameters`,
+    "",
+    "Auto-detects SELECT/WITH/EXPLAIN as reads (db_query),",
+    "INSERT/UPDATE/DELETE/CREATE/DROP as writes (db_execute).",
+    "PRAGMA is not supported. Multiple statements separated by ; are supported.",
+    "Database path arguments are ignored (always uses agent DB).",
+    "",
+    "Options:",
+    "  --exec             Force execute mode (INSERT/UPDATE/DELETE)",
+    "  --params '[...]'   JSON array of values to bind to ? placeholders",
+    "  --csv              CSV output",
+    "  --json             JSON output"
+  ].join(`
+`),
+  category: "data",
+  resolvedTools: ["db_query", "db_execute"],
+  async execute(ctx) {
+    let execFlag = ctx.flags.exec, jsonFlag = ctx.flags.json, csvFlag = ctx.flags.csv, forceExec = !!execFlag, format = csvFlag ? "csv" : jsonFlag ? "json" : "table", params;
+    if (ctx.flags.params !== void 0) {
+      let raw = ctx.flags.params;
+      try {
+        let parsed = JSON.parse(typeof raw == "string" ? raw : "[]");
+        if (!Array.isArray(parsed)) return err(`sqlite3: --params must be a JSON array, e.g. --params '["a", 1]'`);
+        params = parsed;
+      } catch {
+        return err(`sqlite3: invalid --params JSON: ${String(raw)}`);
+      }
+    }
+    let sqlParts = [];
+    for (let flag of [execFlag, jsonFlag, csvFlag])
+      typeof flag == "string" && sqlParts.push(flag);
+    for (let a of ctx.args)
+      isDbPath(a) || sqlParts.push(a);
+    sqlParts.length === 0 && ctx.stdin && sqlParts.push(ctx.stdin.trim());
+    let rawSql = sqlParts.join("; ");
+    if (!rawSql) return err("sqlite3: missing SQL query");
+    let statements = splitStatements(rawSql);
+    if (statements.length === 0) return err("sqlite3: empty SQL");
+    let outputs = [];
+    for (let sql of statements) {
+      let toolName = !forceExec && isReadQuery(sql) ? "db_query" : "db_execute", toolInput = { sql };
+      params !== void 0 && (toolInput.params = params);
+      let result = await ctx.toolRegistry.executeTool(toolName, toolInput, ctx.workspace);
+      if (result.isError) {
+        let msg = result.content;
+        return msg.includes("restricted") || msg.includes("not allowed") ? err(`sqlite3: ${msg}
+Note: Only adf_* tables are accessible. Use "sqlite3 'SELECT name FROM sqlite_master WHERE type=\\'table\\''" to list tables.`) : err(`sqlite3: ${msg}`);
+      }
+      result.content && outputs.push(result.content);
+    }
+    let combined = outputs.join(`
+`);
+    return format === "json" || !combined ? ok(combined) : ok(formatOutput(combined, format));
+  }
+}, structuredHandlers = [jqHandler, sqlite3Handler];
+
+// src/main/tools/shell/commands/messaging.ts
+function discoveryScope(ctx) {
+  return ctx.flags.local !== void 0 ? "local" : "all";
+}
+var MSG_SUBCOMMAND_TOOLS = [
+  ["read", "msg_read"],
+  ["list", "msg_list"],
+  ["agents", "agent_discover"],
+  ["update", "msg_update"],
+  ["archive", "msg_update"],
+  ["delete", "msg_update"]
+];
+function staticArgValue(arg) {
+  return arg.type === "literal" ? arg.value : arg.type === "quoted" && arg.parts.every((p) => p.type === "literal") ? arg.parts.map((p) => p.value).join("") : null;
+}
+var msgHandler = {
+  name: "msg",
+  summary: "Send, read, and manage messages",
+  helpText: [
+    'msg <to> "body"           Send a message (to = did:key:\u2026, type:id, or a local handle)',
+    'echo "body" | msg <to>    Send with piped body',
+    "msg --read [--status S] [--limit N]  Read inbox (default: unread; also read|archived)",
+    "msg --list                List message counts",
+    "msg --agents [--local]    List discoverable agents (mesh-wide; --local = this runtime only)",
+    "msg --update <ids> --status <read|archived|delete>  Update message status",
+    "msg --archive <ids>       Archive messages",
+    "msg --delete <ids>        Delete messages (archives first, then deletes)",
+    "",
+    "Heredoc:",
+    "  msg <to> <<TAG",
+    "  subject: Report ready",
+    "  attach: data/report.md",
+    "  ---",
+    "  Here is the body text.",
+    "  TAG",
+    "",
+    "Flags: --address, --attach, --subject, --thread, --parent"
+  ].join(`
+`),
+  category: "messaging",
+  // Tools are resolved per-subcommand below — a static ['msg_send'] would gate
+  // `msg --read` on msg_send instead of msg_read.
+  resolvedTools: [],
+  resolveToolsFromArgs(args) {
+    let present = /* @__PURE__ */ new Set();
+    for (let arg of args) {
+      let v = staticArgValue(arg);
+      if (v === "--") break;
+      !v || !v.startsWith("--") || present.add(v.slice(2).split("=")[0]);
+    }
+    for (let [flag, tool] of MSG_SUBCOMMAND_TOOLS)
+      if (present.has(flag)) return [tool];
+    return ["msg_send"];
+  },
+  async execute(ctx) {
+    if (ctx.flags.h !== void 0 || ctx.flags.help !== void 0) return ok(msgHandler.helpText);
+    if (ctx.flags.read !== void 0) return msgRead(ctx);
+    if (ctx.flags.list !== void 0) return msgList(ctx);
+    if (ctx.flags.agents !== void 0) return msgListAgents(ctx);
+    if (ctx.flags.update !== void 0) return msgUpdate(ctx);
+    if (ctx.flags.archive !== void 0) return msgArchive(ctx);
+    if (ctx.flags.delete !== void 0) return msgDelete(ctx);
+    if (ctx.args.length === 0) return err("msg: missing recipient");
+    if (ctx.args[0] === "send" && (ctx.flags.to !== void 0 || ctx.flags.content !== void 0))
+      return err('msg: there is no `send` subcommand and no --to/--content flags \u2014 the recipient and body are positional: msg <to> "body" (or pipe/heredoc the body). See msg -h.');
+    let to = ctx.args[0], body = ctx.args.slice(1).join(" ");
+    if (!body && ctx.stdin && (body = ctx.stdin), !body) return err("msg: missing message body");
+    let subject = ctx.flags.subject, attachments, attachFlag = ctx.flags.attach;
+    if (typeof attachFlag == "string" ? attachments = [attachFlag] : Array.isArray(attachFlag) && (attachments = attachFlag), body.includes("---")) {
+      let parts = body.split("---"), headerLines = parts[0].split(`
+`), bodyPart = parts.slice(1).join("---").trim();
+      for (let line of headerLines) {
+        let trimmed = line.trim();
+        trimmed.toLowerCase().startsWith("subject:") ? subject = trimmed.slice(8).trim() : trimmed.toLowerCase().startsWith("attach:") && (attachments || (attachments = []), attachments.push(trimmed.slice(7).trim()));
+      }
+      body = bodyPart;
+    }
+    let input = {
+      recipient: to,
+      content: body
+    };
+    subject && (input.subject = subject), attachments?.length && (input.attachments = attachments), ctx.flags.address && (input.address = ctx.flags.address), ctx.flags.thread && (input.thread_id = ctx.flags.thread), ctx.flags.parent && (input.parent_id = ctx.flags.parent);
+    let result = await ctx.toolRegistry.executeTool("msg_send", input, ctx.workspace);
+    return result.isError ? err(`msg: ${result.content}`) : ok(result.content);
+  }
+}, MSG_READ_STATUSES = ["unread", "read", "archived"], MSG_UPDATE_STATUSES = ["read", "archived", "delete"];
+async function msgRead(ctx) {
+  let status = typeof ctx.flags.status == "string" ? ctx.flags.status : "unread";
+  if (!MSG_READ_STATUSES.includes(status))
+    return err(`msg --read: invalid --status "${status}". Valid: ${MSG_READ_STATUSES.join(", ")}.`);
+  let limit = ctx.flags.limit ? parseInt(String(ctx.flags.limit), 10) : 50, input = { status, limit }, result = await ctx.toolRegistry.executeTool("msg_read", input, ctx.workspace);
+  return result.isError ? err(`msg --read: ${result.content}`) : ok(result.content);
+}
+async function msgList(ctx) {
+  let result = await ctx.toolRegistry.executeTool("msg_list", {}, ctx.workspace);
+  return result.isError ? err(`msg --list: ${result.content}`) : ok(result.content);
+}
+async function msgListAgents(ctx) {
+  let result = await ctx.toolRegistry.executeTool("agent_discover", { scope: discoveryScope(ctx) }, ctx.workspace);
+  return result.isError ? err(`msg --agents: ${result.content}`) : ok(result.content);
+}
+async function msgUpdate(ctx) {
+  let ids = typeof ctx.flags.update == "string" ? ctx.flags.update : ctx.args[0];
+  if (!ids) return err("msg --update: missing message IDs");
+  let status = ctx.flags.status;
+  if (!status) return err(`msg --update: missing --status (${MSG_UPDATE_STATUSES.join(", ")})`);
+  if (!MSG_UPDATE_STATUSES.includes(status))
+    return err(`msg --update: invalid --status "${status}". Valid: ${MSG_UPDATE_STATUSES.join(", ")}.`);
+  let idList = ids.split(",").map((id) => id.trim()), result = await ctx.toolRegistry.executeTool("msg_update", { message_ids: idList, status }, ctx.workspace);
+  return result.isError ? err(`msg --update: ${result.content}`) : ok(result.content);
+}
+async function msgArchive(ctx) {
+  let ids = typeof ctx.flags.archive == "string" ? ctx.flags.archive : ctx.args[0];
+  if (!ids) return err("msg --archive: missing message IDs");
+  let idList = ids.split(",").map((id) => id.trim()), result = await ctx.toolRegistry.executeTool("msg_update", { message_ids: idList, status: "archived" }, ctx.workspace);
+  return result.isError ? err(`msg --archive: ${result.content}`) : ok(result.content);
+}
+async function msgDelete(ctx) {
+  let ids = typeof ctx.flags.delete == "string" ? ctx.flags.delete : ctx.args[0];
+  if (!ids) return err("msg --delete: missing message IDs");
+  let idList = ids.split(",").map((id) => id.trim()), archived = await ctx.toolRegistry.executeTool("msg_update", { message_ids: idList, status: "archived" }, ctx.workspace);
+  if (archived.isError) return err(`msg --delete (archive step): ${archived.content}`);
+  let result = await ctx.toolRegistry.executeTool("msg_update", { message_ids: idList, status: "delete" }, ctx.workspace);
+  return result.isError ? err(`msg --delete: ${result.content}`) : ok(result.content);
+}
+var whoHandler = {
+  name: "who",
+  summary: "List discoverable agents",
+  helpText: "who [--local]        List discoverable agents, mesh-wide by default (alias for msg --agents). --local = this runtime only",
+  category: "messaging",
+  resolvedTools: ["agent_discover"],
+  async execute(ctx) {
+    let result = await ctx.toolRegistry.executeTool("agent_discover", { scope: discoveryScope(ctx) }, ctx.workspace);
+    return result.isError ? err(`who: ${result.content}`) : ok(result.content);
+  }
+}, pingHandler = {
+  name: "ping",
+  summary: "Check agent reachability",
+  helpText: "ping <recipient>     Check if an agent is reachable mesh-wide (by handle or DID)",
+  category: "messaging",
+  resolvedTools: ["agent_discover"],
+  async execute(ctx) {
+    if (ctx.args.length === 0) return err("ping: missing recipient");
+    let target = ctx.args[0], agents = await ctx.toolRegistry.executeTool("agent_discover", { scope: "all" }, ctx.workspace);
+    if (agents.isError) return err(`ping: ${agents.content}`);
+    let cards = null;
+    try {
+      let parsed = JSON.parse(agents.content);
+      Array.isArray(parsed) && (cards = parsed);
+    } catch {
+    }
+    return !cards || cards.length === 0 ? ok(`${target}: not found (no agents reachable from this runtime)`) : cards.find((c) => c.handle === target || c.did === target) ? ok(`${target}: reachable`) : ok(`${target}: not found (not among the ${cards.length} discoverable agent${cards.length === 1 ? "" : "s"})`);
+  }
+}, messagingHandlers = [msgHandler, whoHandler, pingHandler];
+
+// src/main/tools/shell/commands/networking.ts
+function vfsPath3(p) {
+  return p === "." || p === "./" || p === "/" ? "" : p.replace(/^\.\//, "").replace(/^\//, "");
+}
+function staticArgValue2(arg) {
+  return arg.type === "literal" ? arg.value : arg.type === "quoted" && arg.parts.length === 1 && arg.parts[0].type === "literal" ? arg.parts[0].value : null;
+}
+var curlHandler = {
+  name: "curl",
+  aliases: ["wget"],
+  summary: "HTTP requests",
+  helpText: [
+    "curl <url>                   GET request",
+    "curl -X POST -d 'data' <url> POST with body",
+    'curl -H "Header: Value" <url> Custom headers',
+    "curl -o <path> <url>         Save response BODY to file",
+    "",
+    "This is a wrapper over the sys_fetch tool, not real curl. Default stdout",
+    "is a JSON envelope {status,statusText,headers,body}, NOT the raw body.",
+    "Idioms:  curl -s url | jq -r .body     curl -s url | jq .status",
+    'Binary responses carry a base64 body plus "_body_encoding": "base64".',
+    "",
+    "Options:",
+    "  -X <method>                HTTP method",
+    "  -H <header>                Add header (repeatable)",
+    "  -d <data>                  Request body",
+    "  -o <path>                  Save the raw response body (only) to a VFS",
+    "                             file; a one-line saved note goes to stderr",
+    "                             unless -s. Base64 bodies are saved as-is.",
+    "  -O <path>                  Same as -o (wget compat)",
+    "  -s                         Silent: suppress the -o saved note",
+    "  -w <fmt>                   Write-out after the output; supports ONLY",
+    "                             %{http_code} (plus \\n/\\t/\\r escapes) \u2014",
+    "                             any other %{var} is an error",
+    "  -v                         NOT supported (errors) \u2014 the envelope already",
+    "                             has it: curl -s url | jq '{status,headers}'"
+  ].join(`
+`),
+  category: "network",
+  resolvedTools: ["sys_fetch"],
+  // -o/-O writes the response into the VFS via fs_write — surface that to the
+  // pre-gate so disabling fs_write actually blocks `curl -o` (it previously
+  // wrote ungated). Matches -o, -O, and the attached form -opath; a flag we
+  // can't see statically (e.g. a variable) stays sys_fetch-only.
+  resolveToolsFromArgs(args) {
+    return args.some((a) => {
+      let v = staticArgValue2(a);
+      return v !== null && /^-[oO]/.test(v);
+    }) ? ["fs_write"] : [];
+  },
+  valueFlags: /* @__PURE__ */ new Set(["X", "H", "d", "o", "O", "w"]),
+  async execute(ctx) {
+    let url = ctx.args[ctx.args.length - 1];
+    if (!url) return err("curl: missing URL");
+    let method = ctx.flags.X ?? (ctx.flags.d ? "POST" : "GET"), body = ctx.flags.d, outputPath = ctx.flags.o ?? ctx.flags.O, silent = !!ctx.flags.s, verbose = !!ctx.flags.v, writeOut = typeof ctx.flags.w == "string" ? ctx.flags.w : void 0, headers = {}, headerFlag = ctx.flags.H;
+    if (headerFlag) {
+      let headerList = Array.isArray(headerFlag) ? headerFlag : [headerFlag];
+      for (let h of headerList) {
+        let colonIdx = h.indexOf(":");
+        colonIdx > 0 && (headers[h.slice(0, colonIdx).trim()] = h.slice(colonIdx + 1).trim());
+      }
+    }
+    let requestBody = body ?? (ctx.stdin || void 0), input = {
+      url,
+      method: method.toUpperCase()
+    };
+    if (Object.keys(headers).length > 0 && (input.headers = headers), requestBody && (input.body = requestBody), verbose)
+      return err("curl: -v is not supported in adf_shell \u2014 the default stdout envelope already carries it: curl -s url | jq '{status,headers}'");
+    let result = await ctx.toolRegistry.executeTool("sys_fetch", input, ctx.workspace);
+    if (result.isError) return err(`curl: ${result.content}`);
+    let envelope = null;
+    try {
+      let parsed = JSON.parse(result.content);
+      parsed && typeof parsed == "object" && (envelope = parsed);
+    } catch {
+    }
+    let writeOutText = "";
+    if (writeOut !== void 0) {
+      if (!envelope || typeof envelope.status != "number")
+        return err("curl: -w: response envelope has no status to report");
+      let unsupported = [];
+      if (writeOutText = writeOut.replace(/%\{([^}]*)\}/g, (_m, name) => name === "http_code" ? String(envelope.status) : (unsupported.push(name), "")).replace(/\\n/g, `
+`).replace(/\\t/g, "	").replace(/\\r/g, "\r"), unsupported.length > 0)
+        return err(`curl: -w: %{${unsupported[0]}} is not supported in adf_shell \u2014 only %{http_code} is`);
+    }
+    if (outputPath) {
+      let normalizedPath = vfsPath3(outputPath);
+      if (normalizedPath === "dev/null")
+        return { exit_code: 0, stdout: writeOutText, stderr: "" };
+      if (normalizedPath === "dev/stdout" || normalizedPath === "dev/stderr")
+        return err(`curl: -o ${outputPath} is not supported in adf_shell \u2014 omit -o and pipe stdout instead`);
+      let fileContent = envelope && typeof envelope.body == "string" ? envelope.body : result.content, write = await ctx.toolRegistry.executeTool("fs_write", {
+        mode: "write",
+        path: normalizedPath,
+        content: fileContent
+      }, ctx.workspace);
+      return write.isError ? err(`curl: -o ${outputPath}: ${write.content}`) : {
+        exit_code: 0,
+        stdout: writeOutText,
+        // Real curl keeps stdout clean and reports progress on stderr; -s silences it.
+        stderr: silent ? "" : `curl: saved response body to ${outputPath} (${Buffer.byteLength(fileContent, "utf8")} bytes)`
+      };
+    }
+    return ok(result.content + writeOutText);
+  }
+}, networkingHandlers = [curlHandler];
+
+// src/main/tools/shell/commands/timers.ts
+function parseDuration(input) {
+  let match = input.match(/^(\d+)(s|m|h|d)$/);
+  if (!match) return null;
+  let [, num, unit] = match, n = parseInt(num, 10);
+  switch (unit) {
+    case "s":
+      return n * 1e3;
+    case "m":
+      return n * 60 * 1e3;
+    case "h":
+      return n * 60 * 60 * 1e3;
+    case "d":
+      return n * 24 * 60 * 60 * 1e3;
+    default:
+      return null;
+  }
+}
+var atHandler = {
+  name: "at",
+  summary: "Schedule a timer",
+  helpText: [
+    'at "<iso_time>" <lambda>         One-shot at absolute time',
+    "at --delay <duration> <lambda>   One-shot after delay (30s, 5m, 1h, 2d)",
+    "at --every <duration> <lambda>   Recurring interval",
+    'at --cron "<expr>" <lambda>      Cron expression (5-field)',
+    "",
+    "Options:",
+    "  --scope system                 System scope (default: agent)",
+    '  --payload "<data>"             Attach payload string'
+  ].join(`
+`),
+  category: "timers",
+  resolvedTools: ["sys_set_timer"],
+  async execute(ctx) {
+    let scope = ctx.flags.scope ?? "agent", payload = ctx.flags.payload, delay = ctx.flags.delay, every = ctx.flags.every, cron = ctx.flags.cron, lambda = ctx.args[ctx.args.length - 1];
+    if (!lambda) return err("at: missing lambda path");
+    let input = { scope: [scope] };
+    if (payload && (input.payload = payload), delay) {
+      let ms = parseDuration(delay);
+      if (ms === null) return err(`at: invalid duration: ${delay}`);
+      input.schedule = { type: "delay", delay_ms: ms }, input.lambda = lambda;
+    } else if (every) {
+      let ms = parseDuration(every);
+      if (ms === null) return err(`at: invalid duration: ${every}`);
+      input.schedule = { type: "interval", every_ms: ms }, input.lambda = lambda;
+    } else if (cron)
+      input.schedule = { type: "cron", cron }, input.lambda = lambda;
+    else if (ctx.args.length >= 2) {
+      let isoTime = ctx.args[0], ms = new Date(isoTime).getTime();
+      if (isNaN(ms)) return err(`at: invalid ISO time: ${isoTime}`);
+      input.schedule = { type: "once", at: ms }, input.lambda = lambda;
+    } else
+      return err("at: specify --delay, --every, --cron, or an ISO time");
+    let result = await ctx.toolRegistry.executeTool("sys_set_timer", input, ctx.workspace);
+    return result.isError ? err(`at: ${result.content}`) : ok(result.content);
+  }
+}, crontabHandler = {
+  name: "crontab",
+  summary: "Manage timers",
+  helpText: [
+    "crontab -l           List active timers",
+    "crontab -l --all     Also list expired/completed timers (alias: --expired, -a)",
+    "crontab -d <id>      Delete a timer"
+  ].join(`
+`),
+  category: "timers",
+  resolvedTools: ["sys_list_timers", "sys_delete_timer"],
+  valueFlags: /* @__PURE__ */ new Set(["d"]),
+  async execute(ctx) {
+    if (ctx.flags.l !== void 0) {
+      let includeExpired = ctx.flags.all !== void 0 || ctx.flags.expired !== void 0 || ctx.flags.a === !0, result = await ctx.toolRegistry.executeTool(
+        "sys_list_timers",
+        includeExpired ? { include_expired: !0 } : {},
+        ctx.workspace
+      );
+      if (result.isError) return err(`crontab: ${result.content}`);
+      let content = includeExpired ? result.content : result.content.replace(/pass include_expired: true to (?:list|see) them/g, "run `crontab -l --all` to list them");
+      return ok(content);
+    }
+    if (ctx.flags.d !== void 0) {
+      let timerId = typeof ctx.flags.d == "string" ? ctx.flags.d : ctx.args[0];
+      if (!timerId) return err("crontab -d: missing timer ID");
+      let id = Number(timerId);
+      if (!Number.isInteger(id) || id <= 0) return err(`crontab -d: invalid timer id "${timerId}" (expected a positive integer)`);
+      let result = await ctx.toolRegistry.executeTool("sys_delete_timer", { id }, ctx.workspace);
+      return result.isError ? err(`crontab: ${result.content}`) : ok(result.content);
+    }
+    return err("crontab: use -l to list or -d <id> to delete");
+  }
+}, timerHandlers = [atHandler, crontabHandler];
+
+// src/main/tools/shell/commands/code.ts
+var CODE_DELEGATING_TOOLS = /* @__PURE__ */ new Set(["sys_lambda", "sys_code", "sys_create_adf"]), UNWRAP = /* @__PURE__ */ Symbol("baseRegistry");
+function baseRegistry(registry2) {
+  return registry2[UNWRAP] ?? registry2;
+}
+function authorizedRegistry(registry2) {
+  let base = baseRegistry(registry2);
+  return new Proxy(base, {
+    get(target, prop, receiver) {
+      return prop === UNWRAP ? target : prop === "executeTool" ? (name, input, ws) => {
+        let injected = CODE_DELEGATING_TOOLS.has(name) ? input : { ...input ?? {}, _authorized: !0 };
+        return target.executeTool(name, injected, ws);
+      } : Reflect.get(target, prop, receiver);
+    }
+  });
+}
+var nodeHandler = {
+  name: "node",
+  summary: "Execute inline JavaScript/TypeScript",
+  helpText: [
+    'node -e "<code>"     Execute inline code via sys_code',
+    'node -p "<expr>"     Evaluate expression and print its value',
+    "",
+    "The code runs in a sandboxed environment with access to adf.* methods.",
+    "Top-level await is supported in both -e code and -p expressions."
+  ].join(`
+`),
+  category: "code",
+  resolvedTools: ["sys_code"],
+  valueFlags: /* @__PURE__ */ new Set(["e", "p"]),
+  async execute(ctx) {
+    let code, printExpr = !1;
+    if (typeof ctx.flags.p == "string" ? (code = ctx.flags.p, printExpr = !0) : typeof ctx.flags.e == "string" ? code = ctx.flags.e : ctx.args.length > 0 && (code = ctx.args.join(" ")), !code) return err('node: usage: node -e "<code>" or node -p "<expr>"');
+    printExpr && (code = `const __p_value = await (async () => (
+` + code + `
+))(); console.log(typeof __p_value === "string" ? __p_value : (JSON.stringify(__p_value, null, 2) ?? String(__p_value)))`);
+    let envVars = ctx.env.listAll();
+    envVars.length > 0 && (code = envVars.map((v) => `process.env[${JSON.stringify(v.key)}] = ${JSON.stringify(v.value)};`).join(" ") + " " + code);
+    let result = await ctx.toolRegistry.executeTool("sys_code", { code }, ctx.workspace);
+    return result.isError ? err(`node: ${result.content}`) : ok(result.content);
+  }
+};
+function coerceArgValue(v) {
+  if (typeof v == "boolean") return v;
+  if (v === "true") return !0;
+  if (v === "false") return !1;
+  if (/^-?(?:0|[1-9]\d*)(?:\.\d+)?$/.test(v)) {
+    let n = Number(v);
+    if (Number.isFinite(n) && String(n) === v) return n;
+  }
+  return v;
+}
+function flagsToArgs(flags) {
+  let out = {};
+  for (let [key, val] of Object.entries(flags))
+    key !== "args" && (out[key] = Array.isArray(val) ? val.map(coerceArgValue) : coerceArgValue(val));
+  return out;
+}
+var scriptHandler = {
+  name: "./",
+  summary: "Execute VFS script or lambda",
+  helpText: [
+    "./<path>                       Execute script, calls main()",
+    "./<path> <function>            Call specific function",
+    './<path> <fn> --key value      Named args \u2192 { key: "value" } (repeat a flag \u2192 array)',
+    "./<path> <fn> --args '{}'      Exact JSON args (nested objects/arrays, precise types)",
+    'echo "data" | ./<path>         Pass stdin as { stdin: "data" }',
+    "",
+    "Named --key flags are coerced: 3 \u2192 number, true/false \u2192 boolean, else string.",
+    "--args (JSON) and --key flags merge; named flags win on key collision.",
+    "",
+    ".sh files: parsed as one script \u2014 heredocs and multi-line chains work;",
+    "           bash-like: failures do not stop the script unless chained with &&",
+    ".ts/.js files: dispatch to sys_lambda"
+  ].join(`
+`),
+  category: "code",
+  resolvedTools: ["sys_lambda"],
+  async execute(ctx) {
+    let scriptPath = ctx.args[0];
+    if (!scriptPath) return err("./: missing script path");
+    let path = scriptPath.startsWith("./") ? scriptPath.slice(2) : scriptPath;
+    if (path.endsWith(".sh"))
+      return executeShellScript(path, ctx);
+    let fnName = ctx.args[1], argsStr = ctx.flags.args, input = { source: fnName ? `${path}:${fnName}` : path }, base = {};
+    if (argsStr) {
+      let parsed;
+      try {
+        parsed = JSON.parse(argsStr);
+      } catch {
+        return err(`./: invalid JSON args: ${argsStr}`);
+      }
+      if (typeof parsed != "object" || parsed === null || Array.isArray(parsed))
+        return err(`./: --args must be a JSON object, e.g. --args '{"key":"value"}'`);
+      base = parsed;
+    }
+    let named = flagsToArgs(ctx.flags), merged = { ...base, ...named };
+    Object.keys(merged).length > 0 ? input.args = ctx.stdin ? { stdin: ctx.stdin, ...merged } : merged : ctx.stdin && (input.args = { stdin: ctx.stdin });
+    let result = await ctx.toolRegistry.executeTool("sys_lambda", input, ctx.workspace);
+    return result.isError ? err(`./${path}: ${result.content}`) : ok(result.content);
+  }
+};
+async function executeShellScript(path, ctx) {
+  let [scriptContent, readErr] = await shellReadFile(ctx.toolRegistry, ctx.workspace, path);
+  if (readErr !== null) return err(`./${path}: ${readErr}`);
+  let source = scriptContent.replace(/^#![^\n]*\n?/, ""), authorized = !1;
+  try {
+    authorized = ctx.workspace.isFileAuthorized(path);
+  } catch {
+  }
+  let gate = { ...ctx.gate ?? {}, authorized }, base = baseRegistry(ctx.toolRegistry), toolRegistry = gate.authorized ? authorizedRegistry(base) : base, { parse } = await import("./parser-JVY2PWSM.mjs"), { executeNode, MAX_SHELL_DEPTH } = await import("./pipeline-executor-BHBSJX2K.mjs"), depth = (ctx.depth ?? 0) + 1;
+  if (depth > MAX_SHELL_DEPTH)
+    return err(`./${path}: script nesting too deep (${MAX_SHELL_DEPTH}) \u2014 possible infinite recursion`);
+  try {
+    let ast = parse(source);
+    return await executeNode(ast, ctx.stdin || "", {
+      workspace: ctx.workspace,
+      toolRegistry,
+      config: ctx.config,
+      env: ctx.env,
+      gate,
+      signal: ctx.signal,
+      // forward abort so a cancelled shell stops the script
+      depth
+    });
+  } catch (e) {
+    return err(`./${path}: parse error: ${e instanceof Error ? e.message : String(e)}`);
+  }
+}
+var codeHandlers = [nodeHandler, scriptHandler];
+
+// src/main/tools/shell/executor/preflight.ts
+function resolveCommandTools(cmd) {
+  let tools = [], handler = getCommand(cmd.name);
+  handler && (tools.push(...handler.resolvedTools), handler.resolveToolsFromArgs && tools.push(...handler.resolveToolsFromArgs(cmd.args)));
+  for (let r of cmd.redirects)
+    (r.type === "out" || r.type === "append") && tools.push("fs_write"), r.type === "in" && tools.push("fs_read");
+  return [...new Set(tools)];
+}
+function evaluateToolNames(toolNames, config) {
+  let disabled = [], approvalRequired = [], intercepted = [];
+  for (let toolName of toolNames) {
+    let decl = findDeclaration(toolName, config), serverRestricted = mcpServerIsRestricted(toolName, config);
+    if (matchesToolCallTrigger(toolName, config) && intercepted.push(toolName), !decl) {
+      serverRestricted && approvalRequired.push(toolName);
+      continue;
+    }
+    if (!decl.enabled) {
+      disabled.push(toolName);
+      continue;
+    }
+    (decl.restricted || serverRestricted) && approvalRequired.push(toolName);
+  }
+  return {
+    disabled: [...new Set(disabled)],
+    approvalRequired: [...new Set(approvalRequired)],
+    intercepted: [...new Set(intercepted)],
+    resolvedTools: toolNames
+  };
+}
+function evaluateCommand(cmd, config) {
+  return evaluateToolNames(resolveCommandTools(cmd), config);
+}
+async function enforceToolGate(evalr, gate, config, command) {
+  if (!gate.authorized) {
+    if (evalr.disabled.length > 0) {
+      let tools = evalr.disabled.join(", ");
+      return { exit_code: EXIT.DISABLED, stdout: "", stderr: `${tools} is disabled \u2014 this command needs the ${tools} tool${evalr.disabled.length > 1 ? "s" : ""} enabled in the agent's tool config` };
+    }
+    if (evalr.approvalRequired.length > 0) {
+      if (!gate.onApprovalRequired)
+        return { exit_code: EXIT.INTERCEPTED, stdout: "", stderr: `Tools [${evalr.approvalRequired.join(", ")}] require approval but no approval handler is configured.` };
+      for (let tool of evalr.approvalRequired)
+        if (!await gate.onApprovalRequired(tool, command)) return { exit_code: EXIT.INTERCEPTED, stdout: "", stderr: `Tool "${tool}" was rejected by the user.` };
+    }
+  }
+  return null;
+}
+function notifyToolCallObservers(intercepted, gate, config, command) {
+  if (intercepted.length === 0 || !gate.onToolCallIntercepted) return;
+  let argsStr = JSON.stringify({ command, intercepted_by: intercepted }), origin = config.id ? `agent:${config.name}:${config.id}` : `agent:${config.name}`;
+  for (let tool of intercepted)
+    try {
+      gate.onToolCallIntercepted(tool, argsStr, "", origin);
+    } catch {
+    }
+}
+function findDeclaration(name, config) {
+  return config.tools.find((t) => t.name === name);
+}
+function mcpServerIsRestricted(toolName, config) {
+  if (!toolName.startsWith("mcp_")) return !1;
+  let owner;
+  for (let server of config.mcp?.servers ?? [])
+    toolName.startsWith(`mcp_${server.name}_`) && (!owner || server.name.length > owner.name.length) && (owner = server);
+  return owner?.restricted === !0;
+}
+function matchesToolCallTrigger(toolName, config) {
+  let cfg = config.triggers?.on_tool_call;
+  if (!cfg?.enabled) return !1;
+  let targets = cfg.targets ?? [];
+  for (let target of targets)
+    if (target.filter?.tools) {
+      for (let pattern of target.filter.tools)
+        if (new RegExp("^" + pattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$").test(toolName)) return !0;
+    }
+  return !1;
+}
+
+// src/main/tools/shell/commands/mcp.ts
+function coerceFlag(value, type) {
+  if (typeof value != "string") return value;
+  switch (type) {
+    case "number":
+    case "integer": {
+      let n = Number(value);
+      return Number.isNaN(n) ? value : n;
+    }
+    case "boolean":
+      return value === "true" ? !0 : value === "false" ? !1 : value;
+    case "object":
+    case "array":
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    default:
+      return value;
+  }
+}
+function pickStdinParam(props, required) {
+  for (let name of ["content", "text", "body", "message", "prompt", "query", "input", "sql"])
+    if (name in props) return name;
+  return required.find((r) => props[r]?.type === "string" || props[r]?.type === void 0) ?? "content";
+}
+var mcpHandler = {
+  name: "mcp",
+  summary: "MCP tool discovery and invocation",
+  helpText: [
+    "mcp --list                         List MCP servers",
+    "mcp <server> --list                List tools on server",
+    "mcp <server> <tool> -h             Show tool schema",
+    "mcp <server> <tool> [--flags]      Invoke tool with args",
+    "",
+    "Examples:",
+    '  mcp github create_issue --title "Bug" --body "Details"',
+    '  cat data.md | mcp slack send_message --channel "#reports"'
+  ].join(`
+`),
+  category: "mcp",
+  // resolvedTools stays [] and there is NO resolveToolsFromArgs: the server/
+  // tool names are only known after arg resolution (they may be quoted, a
+  // variable, or a substitution), so the executor's static pre-gate cannot see
+  // the real tool. mcp self-gates on the resolved tool name below instead —
+  // static resolution here would let `mcp "github" create_issue` be gated as a
+  // different/phantom tool while the real restricted one runs.
+  resolvedTools: [],
+  async execute(ctx) {
+    if (ctx.flags.list !== void 0 && ctx.args.length === 0)
+      return listServers(ctx);
+    if (ctx.args.length === 0) return err("mcp: usage: mcp <server> <tool> [--flags]");
+    let server = ctx.args[0];
+    if (ctx.flags.list !== void 0)
+      return listServerTools(server, ctx);
+    if (ctx.args.length < 2) return err(`mcp: usage: mcp ${server} <tool> [--flags]`);
+    let tool = ctx.args[1], mcpToolName = `mcp_${server}_${tool}`;
+    if (ctx.flags.h !== void 0 || ctx.flags.help !== void 0)
+      return showToolHelp(mcpToolName, ctx);
+    let observed = [];
+    if (ctx.gate) {
+      let evalr = evaluateToolNames([mcpToolName], ctx.config), blocked = await enforceToolGate(evalr, ctx.gate, ctx.config, ctx.gate.command ?? `mcp ${server} ${tool}`);
+      if (blocked) return blocked;
+      observed = evalr.intercepted;
+    }
+    let schema = ctx.toolRegistry.get(mcpToolName)?.toProviderFormat().input_schema, props = schema?.properties ?? {}, toolArgs = {};
+    for (let [key, value] of Object.entries(ctx.flags))
+      key === "h" || key === "help" || key === "list" || key.startsWith("_") || (toolArgs[key] = coerceFlag(value, props[key]?.type));
+    if (ctx.stdin) {
+      let target = pickStdinParam(props, schema?.required ?? []);
+      target in toolArgs || (toolArgs[target] = ctx.stdin);
+    }
+    let result = await ctx.toolRegistry.executeTool(mcpToolName, toolArgs, ctx.workspace);
+    return ctx.gate && notifyToolCallObservers(observed, ctx.gate, ctx.config, ctx.gate.command ?? `mcp ${server} ${tool}`), result.isError ? err(`mcp ${server} ${tool}: ${result.content}`) : ok(result.content);
+  }
+};
+function listServers(ctx) {
+  let allTools = ctx.toolRegistry.getAll(), servers = /* @__PURE__ */ new Set();
+  for (let tool of allTools)
+    if (tool.name.startsWith("mcp_")) {
+      let parts = tool.name.split("_");
+      parts.length >= 3 && servers.add(parts[1]);
+    }
+  return servers.size === 0 ? ok("No MCP servers connected.") : ok([...servers].sort().join(`
+`));
+}
+function listServerTools(server, ctx) {
+  let allTools = ctx.toolRegistry.getAll(), prefix = `mcp_${server}_`, tools = allTools.filter((t) => t.name.startsWith(prefix)).map((t) => `${t.name.slice(prefix.length).padEnd(30)} ${t.description.slice(0, 60)}`);
+  return tools.length === 0 ? ok(`No tools found for server: ${server}`) : ok(tools.join(`
+`));
+}
+function showToolHelp(mcpToolName, ctx) {
+  let tool = ctx.toolRegistry.get(mcpToolName);
+  if (!tool) return err(`Unknown MCP tool: ${mcpToolName}`);
+  let schema = tool.toProviderFormat(), lines = [
+    schema.description || "(no description)",
+    "",
+    "Parameters:"
+  ], inputSchema = schema.input_schema, props = inputSchema.properties ?? {}, required = new Set(inputSchema.required ?? []);
+  for (let [name, prop] of Object.entries(props)) {
+    let req = required.has(name) ? " (required)" : "", desc = prop.description ?? "";
+    lines.push(`  --${name.padEnd(20)} ${prop.type ?? "any"}${req} ${desc}`);
+  }
+  return ok(lines.join(`
+`));
+}
+var mcpHandlers = [mcpHandler];
+
+// src/main/tools/shell/commands/status.ts
+function staticArgValue3(arg) {
+  if (!arg) return null;
+  if (arg.type === "literal") return arg.value;
+  if (arg.type === "quoted") {
+    let out = "";
+    for (let part of arg.parts) {
+      let v = staticArgValue3(part);
+      if (v === null) return null;
+      out += v;
+    }
+    return out;
+  }
+  return null;
+}
+var psHandler = {
+  name: "ps",
+  summary: "List tasks",
+  helpText: [
+    "ps                   List pending/running tasks",
+    "ps --all             List all tasks (including completed)"
+  ].join(`
+`),
+  category: "process",
+  resolvedTools: ["db_query"],
+  async execute(ctx) {
+    let sql = !!ctx.flags.all ? "SELECT id, tool, status, origin, created_at FROM adf_tasks ORDER BY created_at DESC" : "SELECT id, tool, status, origin, created_at FROM adf_tasks WHERE status IN ('pending', 'running') ORDER BY created_at DESC", result = await ctx.toolRegistry.executeTool("db_query", { sql }, ctx.workspace);
+    return result.isError ? err(`ps: ${result.content}`) : ok(result.content || "No tasks.");
+  }
+}, killHandler = {
+  name: "kill",
+  summary: "Cancel a task",
+  helpText: "kill <task_id>       Cancel a pending/running task",
+  category: "process",
+  resolvedTools: ["db_execute"],
+  async execute(ctx) {
+    if (ctx.args.length === 0) return err("kill: missing task ID");
+    let taskId = ctx.args[0], result = await ctx.toolRegistry.executeTool("db_execute", {
+      sql: "UPDATE adf_tasks SET status = 'cancelled' WHERE id = ? AND status IN ('pending', 'running')",
+      params: [taskId]
+    }, ctx.workspace);
+    return result.isError ? err(`kill: ${result.content}`) : ok(`Task ${taskId} cancelled.`);
+  }
+}, waitHandler = {
+  name: "wait",
+  summary: "Wait for a task to complete",
+  helpText: "wait <task_id>       Block until task reaches terminal state",
+  category: "process",
+  resolvedTools: ["db_query"],
+  async execute(ctx) {
+    if (ctx.args.length === 0) return err("wait: missing task ID");
+    let taskId = ctx.args[0], maxWait = 3e4, start = Date.now(), pollInterval = 500;
+    for (; Date.now() - start < maxWait; ) {
+      let result = await ctx.toolRegistry.executeTool("db_query", {
+        sql: "SELECT status FROM adf_tasks WHERE id = ?",
+        params: [taskId]
+      }, ctx.workspace);
+      if (result.isError) return err(`wait: ${result.content}`);
+      try {
+        let parsed = JSON.parse(result.content), rows = Array.isArray(parsed) ? parsed : parsed?.rows ?? [];
+        if (rows.length > 0) {
+          let status = rows[0]?.status ?? rows[0];
+          if (status === "completed" || status === "failed" || status === "cancelled")
+            return ok(`Task ${taskId}: ${status}`);
+        }
+      } catch {
+        if (result.content.includes("completed") || result.content.includes("failed") || result.content.includes("cancelled"))
+          return ok(result.content);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    return err(`wait: timed out after ${maxWait / 1e3}s`);
+  }
+}, whoamiHandler = {
+  name: "whoami",
+  summary: "Show agent identity",
+  helpText: "whoami               Display name, DID, state, description, owner",
+  category: "identity",
+  resolvedTools: [],
+  async execute(ctx) {
+    let config = ctx.config, lines = [
+      `Name:        ${config.name ?? "unknown"}`,
+      `State:       ${config.state ?? "unknown"}`,
+      `Description: ${config.description ?? ""}`
+    ];
+    try {
+      let did = ctx.env.resolve("AGENT_DID");
+      did && lines.splice(1, 0, `DID:         ${did}`);
+    } catch {
+    }
+    return ok(lines.join(`
+`));
+  }
+}, configHandler = {
+  name: "config",
+  summary: "View or update agent config",
+  helpText: [
+    "config               Show full agent configuration",
+    "config set <path> <value>  Update a config field",
+    "config tools         List ALL tools (incl. hidden/absorbed): name, state, summary",
+    "config tools <name|pattern>  Full schema(s) for matching tools \u2014 use before",
+    "                     writing lambda code that calls adf.<tool>(...)",
+    "config card          Show signed agent card",
+    "config provider      Show LLM provider status/usage"
+  ].join(`
+`),
+  category: "identity",
+  // Arg-dependent gating: read subcommands (bare config / tools / card /
+  // provider) only need sys_get_config; only `config set` needs
+  // sys_update_config. Gating reads on the write tool made `config get` exit
+  // 126 whenever sys_update_config was disabled — and made
+  // `config set tools.sys_update_config.enabled true` impossible to bootstrap.
+  resolvedTools: [],
+  resolveToolsFromArgs(args) {
+    let sub = staticArgValue3(args[0]);
+    return sub === "set" ? ["sys_update_config"] : sub === null && args.length > 0 ? ["sys_get_config", "sys_update_config"] : ["sys_get_config"];
+  },
+  async execute(ctx) {
+    if (ctx.args[0] === "tools") return configTools(ctx);
+    if (ctx.args[0] === "card" || ctx.args[0] === "provider") {
+      let section = ctx.args[0] === "card" ? "card" : "provider_status", result2 = await ctx.toolRegistry.executeTool("sys_get_config", { section }, ctx.workspace);
+      return result2.isError ? err(`config: ${result2.content}`) : ok(result2.content);
+    }
+    if (ctx.args[0] === "set") {
+      if (ctx.args.length < 3) return err("config: usage: config set <path> <value>");
+      let path = ctx.args[1], value = ctx.args[2];
+      try {
+        value = JSON.parse(ctx.args[2]);
+      } catch {
+      }
+      let result2 = await ctx.toolRegistry.executeTool("sys_update_config", {
+        path,
+        value
+      }, ctx.workspace);
+      return result2.isError ? err(`config: ${result2.content}`) : ok(result2.content);
+    }
+    let result = await ctx.toolRegistry.executeTool("sys_get_config", {}, ctx.workspace);
+    return result.isError ? err(`config: ${result.content}`) : ok(result.content);
+  }
+};
+async function configTools(ctx) {
+  let result = await ctx.toolRegistry.executeTool("sys_get_config", { section: "tools" }, ctx.workspace);
+  if (result.isError) return err(`config tools: ${result.content}`);
+  let tools;
+  try {
+    tools = JSON.parse(result.content).tools ?? [];
+  } catch {
+    return err("config tools: failed to parse tool discovery");
+  }
+  let query = ctx.args[1]?.toLowerCase();
+  if (query) {
+    let matches = tools.filter((t) => t.name.toLowerCase().includes(query));
+    return matches.length === 0 ? err(`config tools: no tool matching "${ctx.args[1]}"`) : ok(JSON.stringify(matches.map((t) => ({
+      name: t.name,
+      enabled: t.enabled,
+      visible: t.visible,
+      restricted: t.restricted,
+      source: t.source,
+      description: t.description,
+      schema: t.schema
+    })), null, 2));
+  }
+  let lines = tools.map((t) => {
+    let state = [
+      t.enabled ? null : "disabled",
+      t.enabled && !t.visible ? "hidden" : null,
+      t.restricted ? "restricted" : null
+    ].filter(Boolean).join(","), summary = (t.description.split(/[.\n]/)[0] ?? "").slice(0, 80);
+    return `${t.name.padEnd(28)} ${(state || "on").padEnd(20)} ${summary}`;
+  });
+  return lines.push(""), lines.push("`config tools <name>` for full schema \u2014 needed before calling adf.<tool>(...) from code."), ok(lines.join(`
+`));
+}
+var statusHandler = {
+  name: "status",
+  summary: "Show agent status summary",
+  helpText: "status               State, token usage, budget remaining",
+  category: "identity",
+  resolvedTools: ["sys_get_config"],
+  async execute(ctx) {
+    let config = ctx.config, lines = [
+      `Agent:     ${config.name ?? "unknown"}`,
+      `State:     ${config.state ?? "unknown"}`,
+      `Model:     ${config.model?.provider ?? ""}/${config.model?.model_id ?? ""}`,
+      `Autonomy:  ${config.autonomous ? "enabled" : "disabled"}`
+    ];
+    return config.limits?.token_budget && lines.push(`Budget:    ${config.limits.token_budget} tokens`), ok(lines.join(`
+`));
+  }
+}, stateHandler = {
+  name: "state",
+  summary: "Show or set your state (setting ends the turn)",
+  helpText: [
+    "state                Print your current state",
+    "state idle           Yield; stay responsive to all triggers",
+    "state hibernate      Deep idle \u2014 timers and direct messages only",
+    "state off            Full shutdown \u2014 only a human brings you back",
+    "",
+    "Setting a state ends the turn when the whole invocation finishes, so it",
+    'chains: `meta set status "shipped" && state idle`. Commands after it still',
+    "run \u2014 put it last. A `state` inside $(...) is a subshell side effect and is",
+    "discarded. Reading the state needs no tool; setting it needs sys_set_state."
+  ].join(`
+`),
+  category: "identity",
+  resolvedTools: [],
+  // Bare `state` is a read off config — gating it on sys_set_state would make
+  // the agent unable to see its own state whenever the tool is disabled.
+  resolveToolsFromArgs(args) {
+    if (args.length === 0) return [];
+    let first = staticArgValue3(args[0]);
+    return first !== null && first.startsWith("-") ? [] : ["sys_set_state"];
+  },
+  async execute(ctx) {
+    if (ctx.args.length === 0) return ok(String(ctx.config.state ?? "unknown"));
+    let target = ctx.args[0], valid = SETTABLE_STATES;
+    if (ctx.args.length > 1 || !valid.includes(target))
+      return err(`state: usage: state [${valid.join("|")}] \u2014 active and suspended are runtime-managed`);
+    let result = await ctx.toolRegistry.executeTool("sys_set_state", { state: target }, ctx.workspace);
+    return result.isError ? err(`state: ${result.content}`) : result.endTurn ? {
+      exit_code: 0,
+      stdout: `state: ${target} (turn ends)`,
+      stderr: "",
+      end_turn: !0,
+      target_state: target
+    } : ok(`state: ${target}`);
+  }
+}, envHandler = {
+  name: "env",
+  summary: "List environment variables",
+  helpText: "env                  List all environment variables (sensitive values redacted)",
+  category: "identity",
+  resolvedTools: [],
+  async execute(ctx) {
+    let vars = ctx.env.listAll();
+    if (vars.length === 0) return ok("No environment variables set.");
+    let lines = vars.map((v) => {
+      let redacted = v.source === "identity" ? "***" : v.value;
+      return `${v.key}=${redacted}`;
+    });
+    return ok(lines.join(`
+`));
+  }
+}, exportHandler = {
+  name: "export",
+  summary: "Set an environment variable",
+  helpText: [
+    "export KEY=value     Write to adf_identity (plain, non-encrypted)",
+    'export KEY="value"   Same with quoted value'
+  ].join(`
+`),
+  category: "identity",
+  resolvedTools: [],
+  async execute(ctx) {
+    if (ctx.args.length === 0) return err("export: usage: export KEY=value");
+    let assignment = ctx.args.join(" "), eqIdx = assignment.indexOf("=");
+    if (eqIdx <= 0) return err("export: invalid format. Use KEY=value");
+    let key = assignment.slice(0, eqIdx).trim(), value = assignment.slice(eqIdx + 1).trim();
+    (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) && (value = value.slice(1, -1)), ctx.env.export(key, value);
+    try {
+      ctx.workspace.setIdentity(key.toLowerCase(), value);
+    } catch {
+    }
+    return ok("");
+  }
+}, pwdHandler = {
+  name: "pwd",
+  summary: "Print working directory",
+  helpText: "pwd                  Always / (VFS root)",
+  category: "identity",
+  resolvedTools: [],
+  async execute(ctx) {
+    return ok("/");
+  }
+}, dateHandler = {
+  name: "date",
+  summary: "Print current date/time",
+  helpText: [
+    "date                 Print current date/time (ISO 8601)",
+    "date +<format>       Strftime-style: %Y, %m, %d, %H, %M, %S, %s"
+  ].join(`
+`),
+  category: "identity",
+  resolvedTools: [],
+  async execute(ctx) {
+    let now = /* @__PURE__ */ new Date(), fmt = ctx.args[0];
+    if (fmt && fmt.startsWith("+")) {
+      let pattern = fmt.slice(1), pad = (n) => String(n).padStart(2, "0"), result = pattern.replace(/%Y/g, String(now.getFullYear())).replace(/%m/g, pad(now.getMonth() + 1)).replace(/%d/g, pad(now.getDate())).replace(/%H/g, pad(now.getHours())).replace(/%M/g, pad(now.getMinutes())).replace(/%S/g, pad(now.getSeconds())).replace(/%s/g, String(Math.floor(now.getTime() / 1e3)));
+      return ok(result);
+    }
+    return ok(now.toISOString());
+  }
+}, trueHandler = {
+  name: "true",
+  summary: "Return success (exit 0)",
+  helpText: "true                 Always exits 0",
+  category: "general",
+  resolvedTools: [],
+  async execute() {
+    return { exit_code: 0, stdout: "", stderr: "" };
+  }
+}, falseHandler = {
+  name: "false",
+  summary: "Return failure (exit 1)",
+  helpText: "false                Always exits 1",
+  category: "general",
+  resolvedTools: [],
+  async execute() {
+    return { exit_code: 1, stdout: "", stderr: "" };
+  }
+}, sleepHandler = {
+  name: "sleep",
+  summary: "Pause for N seconds",
+  helpText: "sleep <seconds>      Pause execution",
+  category: "general",
+  resolvedTools: [],
+  async execute(ctx) {
+    let secs = parseFloat(ctx.args[0] ?? "0");
+    if (isNaN(secs) || secs < 0) return err("sleep: invalid duration");
+    let ms = Math.min(secs * 1e3, 6e4);
+    return await new Promise((resolve) => setTimeout(resolve, ms)), ok("");
+  }
+}, statusHandlers = [
+  psHandler,
+  killHandler,
+  waitHandler,
+  whoamiHandler,
+  configHandler,
+  statusHandler,
+  stateHandler,
+  envHandler,
+  exportHandler,
+  pwdHandler,
+  dateHandler,
+  trueHandler,
+  falseHandler,
+  sleepHandler
+];
+
+// src/main/tools/shell/commands/meta.ts
+var metaHandler = {
+  name: "meta",
+  summary: "Read and write adf_meta key-value pairs",
+  helpText: [
+    "meta                                Same as `meta list`",
+    "meta list                           List all key-value pairs (with protection)",
+    "meta get <key>                      Get value for a key",
+    "meta set <key> <value> [protection] Set a key-value pair (agent keys only)",
+    "meta incr <key> <delta>             Atomically add to a numeric counter",
+    "meta delete <key>                   Delete a key (agent keys only)",
+    "",
+    "Subcommands: get, set, incr, list, delete \u2014 there is no `meta status` etc.",
+    "Use incr for counters: `meta set` reads-then-writes, so two concurrent",
+    "tasks lose an update (and an increment-protected key then rejects the",
+    "lower write). `meta incr tokens 1200` cannot race.",
+    "Values with spaces need no quotes on set: meta set greeting hello world",
+    "Protection levels: none (default), readonly, increment",
+    "Protection is set at creation and cannot be changed by the agent."
+  ].join(`
+`),
+  category: "identity",
+  resolvedTools: ["sys_get_meta", "sys_set_meta", "sys_delete_meta"],
+  async execute(ctx) {
+    let sub = ctx.args[0] ?? "list";
+    switch (sub) {
+      case "get": {
+        if (!ctx.args[1]) return err("meta get: missing key");
+        let result = await ctx.toolRegistry.executeTool("sys_get_meta", { key: ctx.args[1] }, ctx.workspace);
+        return result.isError ? err(`meta: ${result.content}`) : ok(result.content);
+      }
+      case "set": {
+        if (!ctx.args[1] || ctx.args[2] === void 0) return err("meta set: usage: meta set <key> <value> [protection]");
+        let lastArg = ctx.args[ctx.args.length - 1], isProtection = ctx.args.length > 3 && META_PROTECTION_LEVELS.includes(lastArg), value = isProtection ? ctx.args.slice(2, -1).join(" ") : ctx.args.slice(2).join(" "), protection = isProtection ? lastArg : void 0, toolInput = { key: ctx.args[1], value };
+        protection && (toolInput.protection = protection);
+        let result = await ctx.toolRegistry.executeTool("sys_set_meta", toolInput, ctx.workspace);
+        return result.isError ? err(`meta: ${result.content}`) : ok(result.content);
+      }
+      case "incr": {
+        if (!ctx.args[1] || ctx.args[2] === void 0) return err("meta incr: usage: meta incr <key> <delta>");
+        let delta = Number(ctx.args[2]);
+        if (!Number.isFinite(delta)) return err(`meta incr: delta must be a number, got "${ctx.args[2]}"`);
+        let result = await ctx.toolRegistry.executeTool("sys_set_meta", { key: ctx.args[1], value: String(delta), inc: !0 }, ctx.workspace);
+        return result.isError ? err(`meta: ${result.content}`) : ok(result.content);
+      }
+      case "delete": {
+        if (!ctx.args[1]) return err("meta delete: missing key");
+        let result = await ctx.toolRegistry.executeTool("sys_delete_meta", { key: ctx.args[1] }, ctx.workspace);
+        return result.isError ? err(`meta: ${result.content}`) : ok(result.content);
+      }
+      case "list": {
+        let result = await ctx.toolRegistry.executeTool("sys_get_meta", {}, ctx.workspace);
+        return result.isError ? err(`meta: ${result.content}`) : ok(result.content);
+      }
+      default:
+        return err([
+          `meta: unknown subcommand "${sub}". Valid subcommands:`,
+          "  meta list                           List all key-value pairs",
+          "  meta get <key>                      Get value for a key",
+          "  meta set <key> <value> [protection] Set a key-value pair",
+          "  meta incr <key> <delta>             Atomically add to a counter",
+          "  meta delete <key>                   Delete a key"
+        ].join(`
+`));
+    }
+  }
+}, metaHandlers = [metaHandler];
+
+// src/main/tools/built-in/loop-reset-tools.ts
+var LOOP_RESET_TOOLS = /* @__PURE__ */ new Set(["loop_compact", "loop_clear"]), INDIRECT_EFFECT = {
+  loop_compact: "it would report compaction started while nothing is summarized or cleared",
+  loop_clear: "it would delete the loop rows while the live session keeps sending them, desyncing the two"
+};
+function loopResetRefusal(tool, via) {
+  let effect = INDIRECT_EFFECT[tool] ?? "it would not take effect";
+  return `${tool} only works as a direct tool call \u2014 the runtime completes the loop reset after the turn by matching the top-level tool name. Invoked through ${via}, ${effect}. Call the ${tool} tool directly instead.`;
+}
+
+// src/main/tools/shell/commands/adf.ts
+function staticArgValue4(arg) {
+  return arg.type === "literal" ? arg.value : arg.type === "quoted" && arg.parts.every((p) => p.type === "literal") ? arg.parts.map((p) => p.value).join("") : null;
+}
+var adfHandler = {
+  name: "adf",
+  summary: "Invoke any tool by name with JSON input",
+  helpText: [
+    "adf <tool_name> ['<json>']   Invoke a tool directly with a JSON input object",
+    "",
+    "The generic tool-bus door: reaches tools that have no dedicated shell",
+    "command (chat_info, fs_transfer, compute_exec, ...). Input is ONE JSON",
+    `object argument \u2014 single-quote it: adf agent_discover '{"scope":"all"}'.`,
+    "Omitted input defaults to {}. Fetch a tool's schema first: config tools <name>.",
+    "",
+    "Rules (violations fail with the reason):",
+    "- The tool name must be a literal \u2014 variables/substitutions are refused.",
+    '- Top-level input keys starting with "_" are reserved for the runtime.',
+    "- adf_shell cannot be invoked through adf (recursion) \u2014 run the command directly.",
+    "- loop_compact / loop_clear cannot be invoked through adf \u2014 they only take effect",
+    "  as direct tool calls; call them as tools instead."
+  ].join(`
+`),
+  category: "general",
+  resolvedTools: [],
+  resolveToolsFromArgs(args) {
+    let first = args[0];
+    if (!first) return [];
+    let name = staticArgValue4(first);
+    if (name === null)
+      throw new Error("adf: tool name must be a literal \u2014 write the tool name directly, e.g. adf chat_info '{}'");
+    return name.startsWith("-") ? [] : [name];
+  },
+  async execute(ctx) {
+    if (ctx.flags.h !== void 0 || ctx.flags.help !== void 0) return ok(adfHandler.helpText);
+    if (ctx.args.length === 0) return err(adfHandler.helpText);
+    let strayFlags = Object.keys(ctx.flags);
+    if (strayFlags.length > 0)
+      return err(`adf: unexpected flag -${strayFlags[0].length > 1 ? "-" : ""}${strayFlags[0]} \u2014 pass tool input as ONE single-quoted JSON argument: adf <tool> '<json>'`);
+    if (ctx.args.length > 2)
+      return err("adf: expected at most one JSON argument \u2014 single-quote it so it stays one argument: adf <tool> '<json>'");
+    let tool = ctx.args[0];
+    if (tool === "adf_shell")
+      return err("adf: refusing to invoke adf_shell through adf (recursive shell) \u2014 run the command directly");
+    if (LOOP_RESET_TOOLS.has(tool))
+      return err(`adf: ${loopResetRefusal(tool, "adf_shell")}`);
+    let raw = ctx.args[1] ?? "{}", input;
+    try {
+      input = JSON.parse(raw);
+    } catch (e) {
+      return err(`adf: invalid JSON input: ${e instanceof Error ? e.message : String(e)} \u2014 single-quote the JSON: adf ${tool} '{"key":"value"}'`);
+    }
+    if (input === null || typeof input != "object" || Array.isArray(input))
+      return err(`adf: input must be a JSON object, e.g. adf ${tool} '{"key":"value"}'`);
+    let reserved = Object.keys(input).filter((k) => k.startsWith("_"));
+    if (reserved.length > 0)
+      return err(`adf: input key${reserved.length > 1 ? "s" : ""} ${reserved.map((k) => `"${k}"`).join(", ")} refused \u2014 underscore-prefixed params are runtime-injected privileges and cannot be passed from the shell`);
+    let result = await ctx.toolRegistry.executeTool(tool, input, ctx.workspace);
+    if (result.isError) return err(`adf ${tool}: ${result.content}`);
+    if (result.endTurn) {
+      let targetState;
+      try {
+        let parsed = JSON.parse(result.content);
+        typeof parsed?.target_state == "string" && (targetState = parsed.target_state);
+      } catch {
+      }
+      return {
+        exit_code: 0,
+        stdout: result.content,
+        stderr: "",
+        end_turn: !0,
+        ...targetState ? { target_state: targetState } : {}
+      };
+    }
+    return ok(result.content);
+  }
+}, adfHandlers = [adfHandler];
+
+// src/main/tools/shell/commands/help.ts
+var CATEGORY_ORDER = [
+  "filesystem",
+  "text",
+  "data",
+  "messaging",
+  "network",
+  "timers",
+  "code",
+  "process",
+  "identity",
+  "mcp",
+  "general"
+], CATEGORY_LABELS = {
+  filesystem: "Filesystem",
+  text: "Text",
+  data: "Data",
+  messaging: "Messaging",
+  network: "Network",
+  timers: "Timers",
+  code: "Code",
+  process: "Process",
+  identity: "Identity",
+  mcp: "MCP",
+  general: "General"
+}, helpHandler = {
+  name: "help",
+  summary: "List all commands or get help for a specific command",
+  helpText: [
+    "help              List all available commands grouped by category",
+    "help <command>    Show detailed help for a command",
+    "<command> -h      Same as help <command>"
+  ].join(`
+`),
+  category: "general",
+  resolvedTools: [],
+  async execute(ctx) {
+    if (ctx.args.length > 0) {
+      let { getCommand: getCommand2 } = await import("./commands-DTEKM4ZL.mjs"), handler = getCommand2(ctx.args[0]);
+      return handler ? ok(handler.helpText) : ok(`Unknown command: ${ctx.args[0]}`);
+    }
+    let commands = getAllCommands(), grouped = /* @__PURE__ */ new Map();
+    for (let cmd of commands) {
+      if (cmd.name === "help") continue;
+      let list = grouped.get(cmd.category) ?? [];
+      list.push(cmd), grouped.set(cmd.category, list);
+    }
+    let lines = [];
+    for (let cat of CATEGORY_ORDER) {
+      let cmds = grouped.get(cat);
+      if (!cmds || cmds.length === 0) continue;
+      let label = CATEGORY_LABELS[cat].padEnd(12), names = cmds.map((c) => {
+        let aliases = c.aliases ? ` (${c.aliases.join(", ")})` : "";
+        return c.name + aliases;
+      }).join(", ");
+      lines.push(`${label} ${names}`);
+    }
+    return lines.push(""), lines.push("jq is real jq 1.8.2; sort/uniq/wc/cut/tr are real GNU coreutils (WASM)."), lines.push("Use <command> -h for details. `config tools [name]` shows tool schemas."), lines.push("Run saved scripts: ./script.sh (shell) or ./script.ts (lambda)."), lines.push("Pipelines exit with the LAST stage's code (no pipefail) \u2014 to branch on a"), lines.push("failed/gated producer, use `cmd 2>err.txt; echo $?` rather than piping it."), ok(lines.join(`
+`));
+  }
+};
+
+// src/main/tools/shell/commands/index.ts
+var registry = /* @__PURE__ */ new Map();
+function registerAll(handlers) {
+  for (let handler of handlers)
+    if (registry.set(handler.name, handler), handler.aliases)
+      for (let alias of handler.aliases)
+        registry.set(alias, handler);
+}
+registerAll(filesystemHandlers);
+registerAll(textHandlers);
+registerAll(structuredHandlers);
+registerAll(messagingHandlers);
+registerAll(networkingHandlers);
+registerAll(timerHandlers);
+registerAll(codeHandlers);
+registerAll(mcpHandlers);
+registerAll(statusHandlers);
+registerAll(metaHandlers);
+registerAll(adfHandlers);
+registerAll([helpHandler]);
+function getCommand(name) {
+  return registry.get(name);
+}
+function getAllCommands() {
+  let seen = /* @__PURE__ */ new Set(), result = [];
+  for (let handler of registry.values())
+    seen.has(handler.name) || (seen.add(handler.name), result.push(handler));
+  return result;
+}
+function hasCommand(name) {
+  return registry.has(name);
+}
+
+export {
+  withSource,
+  withLoop,
+  currentLoop,
+  currentAgentId,
+  currentSourceOrUnknown,
+  init_execution_context,
+  isTextMime,
+  isVisionMime,
+  isAudioInputMime,
+  isVideoInputMime,
+  mimeToAudioFormat,
+  formatSize,
+  mimeToExt,
+  EXIT,
+  err,
+  shellReadFile,
+  evaluateToolNames,
+  evaluateCommand,
+  enforceToolGate,
+  notifyToolCallObservers,
+  LOOP_RESET_TOOLS,
+  loopResetRefusal,
+  registry,
+  getCommand,
+  getAllCommands,
+  hasCommand
+};