@sema-agent/core 7.55.0 → 7.57.0

package/dist/tools/fs/program-read-model.js

@@ -404,6 +404,8 @@ export function slotValueCandidates(value, role, globs = "expanded") {
         return [value];
     if (role.kind !== "path")
         return [];
+    if (role.programEnv === true && value.includes("%q{"))
+        return undefined;
     if (role.kind === "path" && role.programGlob === true && globs === "expanded") {
         const values = programGlobExpansions(value);
         if (values === undefined)
@@ -782,13 +784,16 @@ function scanOptions(row, args, one) {
     const values = [];
     const operands = [];
     const select = (spec, name) => { specs.push(spec); names.push(name); };
+    const permutes = row.grammars[0]?.afterFirstOperand === "options";
     let endOfOptions = false;
+    let undeclared = false;
     for (let k = 0; k < args.length; k++) {
         const t = args[k];
         if (endOfOptions) {
             operands.push(k);
             continue;
         }
+        const certain = one && (operands.length === 0 || permutes);
         const traditional = k === 0 || !one ? obsolete.filter((o) => o.signs.includes(t[0] ?? "") && /^.\d+[A-Za-z]*$/.test(t)) : [];
         if (traditional.length > 0) {
             for (const o of traditional)
@@ -827,6 +832,7 @@ function scanOptions(row, args, one) {
             const eq = t.indexOf("=");
             const exact = longs.get(name);
             const hits = exact !== undefined ? [[name, exact]] : [...longs].filter(([full, m]) => isLongOptionSpellingOf(name, full, m.abbreviable));
+            undeclared ||= certain && hits.length === 0;
             for (const [full, m] of hits)
                 select(m.spec, `--${full}`);
             const [full, only] = hits[0] ?? [];
@@ -849,6 +855,7 @@ function scanOptions(row, args, one) {
         for (let i = 1; i < t.length; i++) {
             const m = shorts.get(t[i]);
             if (m === undefined) {
+                undeclared ||= certain;
                 if (/[A-Za-z0-9]/.test(t[i]))
                     continue;
                 break;
@@ -864,7 +871,10 @@ function scanOptions(row, args, one) {
             break;
         }
     }
-    return { specs, names, values, operands };
+    return { specs, names, values, operands, undeclared };
+}
+export function rowRefusesArgv(row, args) {
+    return row.optionsComplete === true && implementationsOf(row).every((view) => scanOptions(view, args, true).undeclared);
 }
 export function writesPath(role) {
     return role?.kind === "path" && WRITING_EFFECTS.has(role.effect);

package/dist/tools/fs/program-read-model.rows.js

@@ -33,6 +33,7 @@ const OBJECT_PATH = { kind: "object-path" };
 const text = (language) => ({ kind: "program-text", language });
 const file = (language) => ({ kind: "program-file", language });
 const WALKS = { walks: true };
+const REBASES = { rebases: true };
 const SWITCH = { arity: 0 };
 const QUERY = { arity: 0, mode: "queries" };
 const val = (value, extra = {}) => ({ arity: 1, ...(value !== undefined ? { value } : {}), ...extra });
@@ -164,8 +165,8 @@ const date = {
 };
 const tar = {
     key: "tar",
-    grammars: [grammar({ b: val(COUNT), C: val(NAMES, WALKS), f: val(READ), T: val(READ, { delivers: "operands" }), X: val(READ), g: val(), ...switches("adhjJkmOpPStvwWxzZ"), ...switches("cru", { selects: "traversal" }) }, {
-            "blocking-factor": val(COUNT), directory: val(NAMES, WALKS), exclude: val(NAME_PATTERN), "exclude-from": val(READ), file: val(READ), "files-from": val(READ, { delivers: "operands" }), "strip-components": val(COUNT),
+    grammars: [grammar({ b: val(COUNT), C: val(NAMES, REBASES), f: val(READ), T: val(READ, { delivers: "operands" }), X: val(READ), g: val(), ...switches("adhjJkmOpPStvwWxzZ"), ...switches("cru", { selects: "traversal" }) }, {
+            "blocking-factor": val(COUNT), directory: val(NAMES, REBASES), exclude: val(NAME_PATTERN), "exclude-from": val(READ), file: val(READ), "files-from": val(READ, { delivers: "operands" }), "strip-components": val(COUNT),
             ...longSwitches(["absolute-names", "dereference", "extract", "get", "interactive", "keep-old-files", "list", "preserve-permissions", "sparse", "to-stdout", "touch", "verbose", "verify"]), ...BANNERS,
             ...longSwitches(["append", "create", "update"], { selects: "traversal" }),
         })],
@@ -176,6 +177,7 @@ const find = {
     key: "find",
     grammars: implementations(grammar({ D: val(LABEL), O: val(COUNT), f: val(NAMES), ...switches("HLPdsx") }, BANNERS, {
         afterFirstOperand: "options",
+        acceptsAbbreviations: false,
         dashWords: {
             amin: val(COUNT), anewer: val(NAMES), atime: val(COUNT), cmin: val(COUNT), cnewer: val(NAMES), context: val(LABEL),
             ctime: val(COUNT), fstype: val(LABEL), gid: val(COUNT), group: val(LABEL), ilname: val(NAMES), iname: val(NAME_PATTERN),
@@ -306,7 +308,7 @@ function interpreterGrammar(language, g) {
         put(s, val(file(language), { fillsSlot: true, ...(g.fileEndsOptions === true ? { endsOptions: true } : {}) }));
     for (const s of g.longText ?? [])
         put(s, val(text(language), { fillsSlot: true }));
-    return { dialect: "any", short, long, dashWords, afterFirstOperand: "either" };
+    return { dialect: "any", short, long, dashWords, afterFirstOperand: "either", ...(g.exactLongNames === true ? { acceptsAbbreviations: false } : {}) };
 }
 const interpreter = (key, language, g, program, stdinWhenUnnamed, extra = {}, departures) => ({
     key,
@@ -317,9 +319,9 @@ const interpreter = (key, language, g, program, stdinWhenUnnamed, extra = {}, de
     witness: BINARY,
     ...extra,
 });
-const PERL = { text: "eEmM", separated: "I", attached: "iCFxDV", plain: "nplawcsStTUWX", banner: "vVh" };
-const RUBY = { text: "e", separated: "IrECKT", attached: "F", plain: "nplawcsSU", banner: "vh" };
-const PYTHON = { text: "c", module: "m", separated: "WXQ", plain: "uBEIsSqbdvxOtR", banner: "Vh?", interactive: "i", fileEndsOptions: true };
+const PERL = { text: "eEmM", separated: "I", attached: "iCFxDV", plain: "nplawcsStTUWX", banner: "vVh", exactLongNames: true };
+const RUBY = { text: "e", separated: "IrECKT", attached: "F", plain: "nplawcsSU", banner: "vh", exactLongNames: true };
+const PYTHON = { text: "c", module: "m", separated: "WXQ", plain: "uBEIsSqbdvxOtR", banner: "Vh?", interactive: "i", fileEndsOptions: true, exactLongNames: true };
 const NODE = {
     longText: ["--eval", "--print"], text: "ep",
     longModules: ["--import", "--loader", "--experimental-loader", "--require"],
@@ -327,25 +329,25 @@ const NODE = {
     longAttached: ["--max-old-space-size"],
     longNamesProgram: ["--test"],
     longPlain: ["--inspect", "--inspect-brk", "--no-warnings", "--trace-warnings", "--watch", "--enable-source-maps", "--experimental-modules", "--no-deprecation", "--check"],
-    modules: "r", plain: "c", banner: "vh", interactive: "i",
+    modules: "r", plain: "c", banner: "vh", interactive: "i", exactLongNames: true,
 };
-const PHP = { longText: ["--run", "--process-begin", "--process-code", "--process-end"], text: "rRBE", file: "fF", separated: "dcz", plain: "nqswl", banner: "vhi", interactive: "a" };
+const PHP = { longText: ["--run", "--process-begin", "--process-code", "--process-end"], text: "rRBE", file: "fF", separated: "dcz", plain: "nqswl", banner: "vhi", interactive: "a", exactLongNames: true };
 const LUA = { text: "e", separated: "l", banner: "vh", interactive: "i" };
 const EXPECT = { text: "c", separated: "Db", plain: "dN", banner: "vh", interactive: "i" };
 const AWK = { longText: ["--source"], text: "e", longFile: ["--file", "--exec"], file: "fE", separated: "F", assignment: "v", banner: "V" };
 const POSIX_AWK = { file: "f", separated: "F", assignment: "v" };
 const AWK_IMPLEMENTATIONS = { gnu: {}, bsd: { lacks: ["-E", "--file", "--exec", "--source"] } };
-const JQ = { longFile: ["--from-file"], file: "f", separated: "L", plain: "nrjcsSaCMRe", banner: "h" };
+const JQ = { longFile: ["--from-file"], file: "f", separated: "L", plain: "nrjcsSaCMRe", banner: "h", exactLongNames: true };
 const BC = { longText: ["--expression"], text: "e", plain: "lqsw", banner: "vh", interactive: "i" };
 const DC = { longText: ["--expression"], text: "e", longFile: ["--file"], file: "f", banner: "hV" };
-const SQLITE = { longText: ["-cmd"], longSupplemental: ["-init"] };
+const SQLITE = { longText: ["-cmd"], longSupplemental: ["-init"], exactLongNames: true };
 const PSQL = { longText: ["--command"], text: "c", longFile: ["--file"], file: "f", separated: "hpUdoF", plain: "aeEqtxXwW", banner: "lV?" };
 const OSASCRIPT = { text: "e", separated: "ls", plain: "i", banner: "h" };
 const RSCRIPT = { text: "e", banner: "h" };
 const JULIA = { longText: ["--eval", "--print"], text: "eE", separated: "JLp", plain: "q", banner: "vh", interactive: "i" };
 const GHCI = { text: "e", separated: "io" };
 const GROOVY = { text: "e", separated: "Dcl", plain: "n", banner: "vh", interactive: "i" };
-const BUN = { longText: ["--eval", "--print"], text: "ep", modules: "r", banner: "vh" };
+const BUN = { longText: ["--eval", "--print"], text: "ep", modules: "r", banner: "vh", exactLongNames: true };
 const launcher = (key, spec = {}, g, extra = {}) => ({
     key,
     grammars: g === undefined ? [] : [g],
@@ -396,6 +398,47 @@ const SU_OPTIONS = {
     programs: ["-m", "-p", "--preserve-environment"],
 };
 const SU = launcherGrammar(SU_OPTIONS, { stepsDashDash: true });
+const VALGRIND_FLAGS = [
+    "trace-children", "trace-children-skip", "trace-children-skip-by-arg", "child-silent-after-fork", "vgdb", "vgdb-stop-at", "track-fds", "time-stamp",
+    "xml", "xml-user-comment", "demangle", "error-limit", "exit-on-first-error", "error-markers", "show-error-list", "keep-debuginfo", "show-below-main",
+    "default-suppressions", "gen-suppressions", "dsymutil", "xtree-memory", "fullpath-after", "allow-mismatched-debuginfo", "smc-check", "read-inline-info",
+    "read-var-info", "run-libc-freeres", "run-cxx-freeres", "fair-sched", "sigill-diagnostics", "show-emwarns", "vgdb-shadow-registers", "sim-hints",
+    "kernel-variant", "soname-synonyms", "resync-filter", "tool",
+    "leak-check", "leak-resolution", "show-leak-kinds", "errors-for-leak-kinds", "leak-check-heuristics", "show-reachable", "show-possibly-lost", "xtree-leak",
+    "undef-value-errors", "track-origins", "partial-loads-ok", "expensive-definedness-checks", "workaround-gcc296-bugs", "ignore-ranges", "ignore-range-below-sp",
+    "malloc-fill", "free-fill", "keep-stacktraces", "show-mismatched-frees",
+];
+const VALGRIND_COUNTS = [
+    "vgdb-error", "log-fd", "xml-fd", "num-callers", "error-exitcode", "input-fd", "max-stackframe", "main-stacksize", "alignment", "redzone-size",
+    "max-threads", "merge-recursive-frames", "num-transtab-sectors", "avg-transtab-entry-size", "valgrind-stacksize", "vgdb-poll",
+    "unw-stack-scan-thresh", "unw-stack-scan-frames", "freelist-vol", "freelist-big-blocks",
+];
+const VALGRIND_OUTPUT_FILES = ["log-file", "xml-file", "xtree-memory-file", "xtree-leak-file", "callgrind-out-file", "cachegrind-out-file", "massif-out-file", "dhat-out-file"];
+const VALGRIND_WRITE = { kind: "path", effect: "write", programEnv: true };
+const VALGRIND_READ = { kind: "path", effect: "read", programEnv: true };
+const VALGRIND = launcherGrammar({
+    switches: ["-q", "-v", "-s", "--quiet", "--verbose", "-h", "--help", "--help-debug", "--help-dyn-options", "--version"],
+    banners: ["-h", "--help", "--help-debug", "--help-dyn-options", "--version"],
+    optional: {
+        ...Object.fromEntries(VALGRIND_FLAGS.map((n) => [`--${n}`, LABEL])),
+        ...Object.fromEntries(VALGRIND_COUNTS.map((n) => [`--${n}`, COUNT])),
+        ...Object.fromEntries(VALGRIND_OUTPUT_FILES.map((n) => [`--${n}`, VALGRIND_WRITE])),
+        "--suppressions": VALGRIND_READ,
+    },
+}, { acceptsAbbreviations: false, stepsDashDash: true });
+const SETPRIV = launcherGrammar({
+    switches: ["--nnp", "--no-new-privs", "--clear-groups", "--keep-groups", "--init-groups", "--reset-env", "-d", "--dump", "-h", "--help", "-V", "--version"],
+    banners: ["-d", "--dump", "-h", "--help", "-V", "--version"],
+    values: Object.fromEntries(["ambient-caps", "inh-caps", "bounding-set", "ruid", "euid", "rgid", "egid", "reuid", "regid", "groups", "securebits", "pdeathsig", "selinux-label", "apparmor-profile"].map((n) => [`--${n}`, LABEL])),
+}, { stepsDashDash: true });
+const CHROOT_GRAMMARS = implementations(launcherGrammar({ switches: ["--skip-chdir", "--help", "--version"], values: { "--userspec": LABEL, "--groups": LABEL, "-u": LABEL, "-g": LABEL, "-G": LABEL } }, { stepsDashDash: true }), { lacks: ["-u", "-g", "-G"] }, { lacks: ["--skip-chdir", "--help", "--version", "--userspec", "--groups"] });
+const PRLIMIT_RESOURCES = { c: "core", d: "data", e: "nice", f: "fsize", i: "sigpending", l: "memlock", m: "rss", n: "nofile", q: "msgqueue", r: "rtprio", s: "stack", t: "cpu", u: "nproc", v: "as", x: "locks", y: "rttime" };
+const PRLIMIT = launcherGrammar({
+    switches: ["--noheadings", "--raw", "--verbose", "-h", "--help", "-V", "--version"],
+    banners: ["-h", "--help", "-V", "--version"],
+    values: { "-p": COUNT, "--pid": COUNT, "-o": LABEL, "--output": LABEL },
+    optional: Object.fromEntries(Object.entries(PRLIMIT_RESOURCES).flatMap(([letter, name]) => [[`-${letter}`, LABEL], [`--${name}`, LABEL]])),
+}, { stepsDashDash: true });
 const SU_LINUX_ONLY = [...SU_OPTIONS.switches, ...Object.keys(SU_OPTIONS.values), ...SU_OPTIONS.shellText, ...SU_OPTIONS.programs].filter((s) => !["-f", "-l", "-m"].includes(s));
 const launchers = [
     { key: "env", grammars: implementations(launcherGrammar({
@@ -427,8 +470,8 @@ const launchers = [
     launcher("pkexec", { whenNoProgram: "shell" }, launcherGrammar({ switches: ["--disable-internal-agent", "--keep-cwd", "--version", "--help"], values: { "--user": LABEL } }), { witness: PRIVILEGED }),
     { key: "su", grammars: implementations(SU, { afterFirstOperand: "options" }, { lacks: SU_LINUX_ONLY, afterFirstOperand: "operands" }), launcher: { shellText: "user", asUser: { home: "target", loginWith: ["-l", "--login"] } }, witness: PRIVILEGED },
     { key: "runuser", grammars: [launcherGrammar({ ...SU_OPTIONS, values: { ...SU_OPTIONS.values, "-u": LABEL, "--user": LABEL } }, { afterFirstOperand: "options", stepsDashDash: true })], launcher: { shellText: "user", programWith: ["-u", "--user"], asUser: { home: "target", loginWith: ["-l", "--login"] } }, witness: PRIVILEGED },
-    launcher("chroot", { requiredOperands: 1, whenNoProgram: "shell" }, undefined, { witness: PRIVILEGED }),
-    launcher("setpriv", {}, undefined, { witness: PRIVILEGED }),
+    { key: "chroot", grammars: CHROOT_GRAMMARS, launcher: { requiredOperands: 1, whenNoProgram: "shell" }, witness: PRIVILEGED },
+    launcher("setpriv", {}, SETPRIV, { witness: PRIVILEGED }),
     launcher("nohup", {}, grammar({}, BANNERS, { stepsDashDash: true })),
     { key: "nice", grammars: implementations(grammar({ n: val(COUNT) }, { adjustment: val(COUNT), ...BANNERS }, { stepsDashDash: true }), {}, { lacks: ["--adjustment", "--help", "--version"] }), launcher: { negativeIntegerIsOwnArgument: true }, witness: BINARY },
     launcher("ionice", {}, launcherGrammar({
@@ -470,7 +513,7 @@ const launchers = [
     }), { witness: LINUX_NAMESPACE }),
     launcher("script", { shellText: "joined" }, launcherGrammar({ shellText: ["-c", "--command"] }), { witness: SHELL_TEXT_LAUNCHER }),
     launcher("numactl", {}, undefined, { witness: LINUX_NAMESPACE }),
-    launcher("prlimit", {}, undefined, { witness: LINUX_NAMESPACE }),
+    launcher("prlimit", {}, PRLIMIT, { witness: LINUX_NAMESPACE }),
     launcher("systemd-run", {}, undefined, { witness: { declared: "hands the program to a service manager" } }),
     launcher("strace", {}, launcherGrammar({
         switches: ["-f", "-c", "-C", "-d", "-D", "-h", "-i", "-k", "-q", "-r", "-t", "-T", "-v", "-V", "-w", "-x", "-y", "-z", "-Z", "-F", "--follow-forks", "--summary-only", "--summary", "--debug", "--help", "--version"],
@@ -486,7 +529,7 @@ const launchers = [
         banners: ["-V"],
         values: { "-a": COUNT, "-A": COUNT, "-e": LABEL, "-l": NAMES, "-n": COUNT, "-o": WRITE, "-p": COUNT, "-s": COUNT, "-u": LABEL, "-x": LABEL, "-D": LABEL, "-F": READ, "-w": COUNT, "--align": COUNT, "--config": READ, "--debug": LABEL, "--indent": COUNT, "--library": NAMES, "--output": WRITE, "--string-max": COUNT, "--where": COUNT },
     }), { witness: LINUX_NAMESPACE }),
-    launcher("valgrind"),
+    launcher("valgrind", {}, VALGRIND),
     launcher("firejail", { whenNoProgram: "shell" }, undefined, { witness: LINUX_NAMESPACE }),
     launcher("bwrap", {}, undefined, { witness: LINUX_NAMESPACE }),
 ];
@@ -507,12 +550,25 @@ const GIT_GREP = {
     traversal: { discloses: "contents", always: true },
 };
 const gitObjectSubcommand = (short = {}, long = {}) => ({ grammar: grammar(short, long), operands: { rest: OBJECT_PATH } });
+const GIT_RUNS_LATER = [
+    ...["core.pager", "core.editor", "sequence.editor", "core.sshcommand", "core.gitproxy", "core.askpass", "core.alternaterefscommand",
+        "diff.external", "diff.*.command", "diff.*.textconv", "merge.*.driver", "filter.*.clean", "filter.*.smudge", "filter.*.process",
+        "difftool.*.cmd", "difftool.*.path", "mergetool.*.cmd", "mergetool.*.path", "interactive.difffilter",
+        "gpg.program", "gpg.*.program", "gpg.ssh.defaultkeycommand", "browser.*.cmd", "browser.*.path", "man.*.cmd", "man.*.path",
+        "guitool.*.cmd", "instaweb.httpd", "trailer.*.cmd", "trailer.*.command", "uploadpack.packobjectshook", "gc.recentobjectshook",
+        "remote.*.receivepack", "remote.*.uploadpack",
+        "sendemail.*tocmd", "sendemail.*cccmd", "sendemail.*headercmd", "sendemail.*sendmailcmd", "sendemail.*smtpserver"].map((key) => ({ key })),
+    { key: "pager.*", orBoolean: true }, { key: "core.fsmonitor", orBoolean: true },
+    { key: "alias.*", bang: true }, { key: "credential.helper", prefixed: "git credential-" }, { key: "credential.*.helper", prefixed: "git credential-" },
+];
 const git = {
     key: "git",
-    grammars: [grammar({ p: SWITCH, P: SWITCH, C: val(WORKDIR), c: val() }, {
+    grammars: [grammar({ p: SWITCH, P: SWITCH, C: val(WORKDIR), c: val(undefined, { runsLater: { keys: GIT_RUNS_LATER } }) }, {
             ...longSwitches(["paginate", "no-pager", "bare", "no-replace-objects", "literal-pathspecs", "glob-pathspecs", "noglob-pathspecs", "icase-pathspecs", "no-optional-locks"]),
-            "git-dir": val(WORKDIR), "work-tree": val(WORKDIR), namespace: val(), "config-env": val(), "super-prefix": val(),
-        })],
+            "git-dir": val(WORKDIR), "work-tree": val(WORKDIR), namespace: val(), "config-env": val(undefined, { runsLater: { keys: GIT_RUNS_LATER, valueFrom: "environment" } }), "super-prefix": val(),
+            version: { arity: 0, mode: "banner" },
+        }, { acceptsAbbreviations: false })],
+    body: "option-values",
     subcommands: {
         commit: gitSubcommand("apsnvqeioz", "Su", "mFCct", ["message", "file", "template", "pathspec-from-file", "author", "date", "cleanup", "fixup", "squash", "trailer", "reuse-message", "reedit-message"]),
         tag: gitSubcommand("asfdvle", "n", "mFu", ["message", "file", "local-user", "cleanup", "trailer", "sort", "format", "contains", "no-contains", "points-at", "merged", "no-merged"]),
@@ -562,7 +618,7 @@ const CONTAINER_RUN = {
 };
 const containerRuntime = (key) => ({
     key,
-    grammars: [grammar({ H: val(LABEL), c: val(LABEL), l: val(LABEL), D: SWITCH }, { host: val(LABEL), context: val(LABEL), "log-level": val(LABEL), config: val(READ), tlscacert: val(READ), tlscert: val(READ), tlskey: val(READ), ...longSwitches(["debug", "tls", "tlsverify"]) })],
+    grammars: [grammar({ H: val(LABEL), c: val(LABEL), l: val(LABEL), D: SWITCH }, { host: val(LABEL), context: val(LABEL), "log-level": val(LABEL), config: val(READ), tlscacert: val(READ), tlscert: val(READ), tlskey: val(READ), ...longSwitches(["debug", "tls", "tlsverify"]) }, { acceptsAbbreviations: false })],
     operands: { assignmentArguments: "not-paths" },
     subcommands: { run: CONTAINER_RUN, create: CONTAINER_RUN },
     witness: { declared: "a build tool / container client: what a NAME=value argument means is the build's or the container's" },
@@ -595,8 +651,8 @@ const copyGrammars = (bsdSuffixSwitch, destination) => implementations(grammar({
 const writerRows = [
     { key: "mkdir", grammars: [], operands: { rest: CREATED, dash: "file" }, witness: BINARY },
     { key: "touch", grammars: implementations(grammar({ h: { arity: 0, writesAt: ["landing", "entry"] } }, { "no-dereference": { arity: 0, writesAt: ["landing", "entry"] } }), {}, { lacks: ["--no-dereference"] }), operands: { rest: TOUCHED, dash: "file" }, witness: BINARY },
-    { key: "rm", grammars: implementations(grammar({ ...switches("rR", { selects: "traversal" }), f: { arity: 0, mode: "forced" } }, { ...longSwitches(["recursive"], { selects: "traversal" }), force: { arity: 0, mode: "forced" } }), {}, { lacks: ["--recursive", "--force"] }), operands: { rest: REMOVED, dash: "file" }, witness: BINARY },
-    { key: "rmdir", grammars: implementations(grammar({ p: { arity: 0, effect: "writes" } }, { parents: { arity: 0, effect: "writes" } }), {}, { lacks: ["--parents"] }), operands: { rest: REMOVED, dash: "file" }, witness: BINARY },
+    { key: "rm", grammars: implementations(grammar({ ...switches("rR", { selects: "traversal" }), f: { arity: 0, mode: "forced" }, ...switches("diIvPWx", { effect: "none" }) }, { ...longSwitches(["recursive"], { selects: "traversal" }), force: { arity: 0, mode: "forced" }, ...longSwitches(["dir", "verbose", "one-file-system", "no-preserve-root", "-presume-input-tty"], { effect: "none" }), interactive: { arity: "attached", value: LABEL, effect: "none" }, "preserve-root": { arity: "attached", value: LABEL, effect: "none" }, ...BANNERS }), { lacks: ["-P", "-W", "-x"] }, { lacks: ["--recursive", "--force", "--dir", "--verbose", "--one-file-system", "--no-preserve-root", "---presume-input-tty", "--interactive", "--preserve-root", "--help", "--version"] }), operands: { rest: REMOVED, dash: "file" }, optionsComplete: true, witness: BINARY },
+    { key: "rmdir", grammars: implementations(grammar({ p: { arity: 0, effect: "writes" }, v: { arity: 0, effect: "none" } }, { parents: { arity: 0, effect: "writes" }, ...longSwitches(["verbose", "ignore-fail-on-non-empty"], { effect: "none" }), ...BANNERS }), {}, { lacks: ["--parents", "--verbose", "--ignore-fail-on-non-empty", "--help", "--version"] }), operands: { rest: REMOVED, dash: "file" }, optionsComplete: true, witness: BINARY },
     { key: "tee", grammars: [], operands: { rest: WRITE_THROUGH, dash: "file" }, witness: BINARY },
     { key: "cp", grammars: copyGrammars(true, COPY_DESTINATION), operands: { rest: COPY_SOURCE, last: COPY_DESTINATION, dash: "file" }, witness: BINARY },
     { key: "mv", grammars: copyGrammars(false, MOVE_DESTINATION), operands: { rest: MOVE_SOURCE, last: MOVE_DESTINATION, dash: "file" }, witness: BINARY },
@@ -651,6 +707,7 @@ export const PROGRAM_ROWS = [
     ...[...shellWordsOf("stack_mover")].map((key) => ({ key, grammars: [], movesBase: "stack", witness: BUILTIN_ONLY })),
     ...SHELLS.map((s) => shellRow(s, "c-option", BINARY, [SHELL_GRAMMARS[s]], "script")),
     shellRow("eval", "words", BUILTIN_ONLY), shellRow("source", "file-operand", BUILTIN_ONLY), shellRow(".", "file-operand", BUILTIN_ONLY), shellRow("parallel", "non-option-words", BINARY, [], "script"),
+    shellRow("fc", "history", BUILTIN_ONLY, [grammar({ ...switches("nr"), s: { arity: 0, effect: "executes" }, ...switches("l", { mode: "banner" }), e: val(COMMAND, { executesWhenValue: "-" }) }, {}, { afterFirstOperand: "operands" })]),
     ...codeBodyRows,
     ...[...shellWordsOf("block")].map((k) => block(k, BLOCK_GRAMMARS[k])),
 ];

package/dist/tools/fs/read-deny-home.js

@@ -5,6 +5,7 @@ import { thrownText } from "../../core/thrown-value.js";
 import { agentConfigDirTail } from "../../core/agent-config-dir.js";
 import { validatePath } from "../../core/effective-path-target.js";
 import { readDenyPatternRun, readDenyRowAnchor, readDenyRunHead } from "./read-deny.js";
+import { isAbsence } from "./shell-read-environment.js";
 export const AUXILIARY_HOME_PROBE_MS = 2_000;
 const said = new Set();
 function sayOnce(kind, line) {
@@ -75,7 +76,7 @@ async function homeSpellingsOf(env, home, signal) {
         const canonical = await env.canonicalPath(home, signal);
         if (canonical.ok)
             return { spellings: canonical.value !== home ? [home, canonical.value] : [home], canonical: canonical.value, answered: true };
-        return { spellings: [home], answered: canonical.error.code === "not_found" || canonical.error.code === "not_directory" };
+        return { spellings: [home], answered: isAbsence(canonical.error.code) };
     }
     catch {
         return { spellings: [home], answered: false };
@@ -202,7 +203,7 @@ export async function whereItsAnsweredPrefixLeads(env, at, family = pathFamilyOf
 }
 const NO_CHAIN = { ancestors: [], whole: false, unread: [] };
 const unreadChain = (at) => ({ ancestors: [], whole: false, unread: [at] });
-const identityUnread = (id) => id === undefined || (!id.ok && id.error.code !== "not_found" && id.error.code !== "not_directory" && id.error.code !== "not_supported");
+const identityUnread = (id) => id === undefined || (!id.ok && !isAbsence(id.error.code) && id.error.code !== "not_supported");
 async function chainAbove(env, identity, canonical, signal, deadline) {
     let own;
     const ancestors = [];

package/dist/tools/fs/removal-targets.d.ts

@@ -1,3 +1,4 @@
+import type { EstablishedRead } from "./shell-read-judge.js";
 import { type EstablishedPlan } from "./shell-read-establish.js";
 import type { ExecutionEnv } from "../../internal/harness-types.js";
 import type { ToolCallRequest } from "../../core/tool-policy.js";
@@ -35,8 +36,8 @@ export declare function dangerousRemovalOf(path: string, seat: RemovalSeat): Dan
  *  (`rewritten`), the operands of a removal its argv stream fills in (`stream`), or an operand relative to the directory a
  *  launcher option moved the removal into (`relocated`); or a shell handed text the engine cannot read
  *  (`unverifiable_shell_text`) — a text a program produces (`produced`: what a pipe or a `<(…)` carries, an argv a stream
- *  fills in, a substitution), or a text nobody read (`unread`: one the lexer could not read at all, {@link unreadPlan}, or a
- *  segment whose program the walk could not name, {@link programUnread}). */
+ *  fills in, a substitution), a text nobody read (`unread`: one the lexer could not read at all, {@link unreadPlan}), or a
+ *  segment whose program the walk could not name (`position`, {@link programUnread}). */
 export type RemovalFinding = (DangerousRemoval & {
     readonly guard: "dangerous_delete";
     readonly untrackedFrom?: string;
@@ -49,7 +50,7 @@ export type RemovalFinding = (DangerousRemoval & {
     readonly guard: "unverifiable_shell_text";
     readonly program: string;
     readonly text: string;
-    readonly source: "produced" | "unread";
+    readonly source: "produced" | "unread" | "position";
 };
 /**
  * The names a removal target may be built on and still be verified: a root the SHELL provides, never one a command's
@@ -62,10 +63,12 @@ export type RemovalFinding = (DangerousRemoval & {
 export declare const KNOWN_SAFE_ROOTS: readonly string[];
 /**
  * The removal findings of an established plan — ONE walk, nested plans included (a `bash -c` / `sh -c` text, a substitution
- * body), two words. For every `rm` / `rmdir` segment, each of its OPERANDS (every write target that is not one of its
- * option words: a word some implementation's reading of the program's row writes, {@link writeReadings}) as the plan
- * established it on the WRITE face (the entry the program unlinks, and the deny-floor shadow of a home word the plan did
- * not place) is judged by {@link dangerousRemovalOf}. In a recursive forced removal ({@link recursiveForce}), an operand
+ * body), two words. For every removal segment ({@link removalProgramOf}: an `rm` / `rmdir` the text names, or a program it
+ * does not settle, read as `rm`) whose argv the program does not refuse outright ({@link optionsReceived}), each of its
+ * OPERANDS (every write target that is not one of its option words: a word some implementation's reading of the
+ * program's row writes, {@link writeReadings}) as the plan established it on the WRITE face (the entry the program
+ * unlinks, and the deny-floor shadow of a home word the plan did not place) is judged by {@link dangerousRemovalOf},
+ * save one the program refuses by its own first step ({@link refusedByRemoval}: `.`, `..`). In a recursive forced removal ({@link recursiveForce}), an operand
  * the shell rewrites from a value the plan's table does not settle — a name with no value here or one set in a form the
  * table cannot read, a substitution, a parameter operator, a positional parameter — is an unverifiable target, save a
  * literal path below a known-safe root the shell still provides there ({@link belowKnownSafeRoot}); so are the operands
@@ -80,6 +83,13 @@ export declare const KNOWN_SAFE_ROOTS: readonly string[];
  * own. The read-face copy of an operand is not judged: it follows a link the removal does not follow.
  */
 export declare function removalFindingsOf(established: EstablishedPlan, seat: RemovalSeat, safeRoots?: readonly string[], enclosingRelocated?: boolean): RemovalFinding[];
+/** Does the removal program refuse this operand by its own first step — its last path component is `.` or `..`, trailing
+ *  separators stripped (POSIX `rm` step 1, which GNU, BSD and BusyBox `rm` keep; `rmdir(2)` fails on such a component
+ *  too)? It removes nothing there, wherever the name lands. The name is the one the program RECEIVES: a pattern's match
+ *  (the spelling an expansion carries beside its origin: `.*` hands it `.` and `..` beside the dotfiles, and only those two
+ *  are refused), else the word as the plan spells it; a word the shell rewrites from a value the plan does not settle
+ *  names nothing known, and is never refused here. */
+export declare function refusedByRemoval(read: EstablishedRead): boolean;
 /** Does this plan (nested plans included) run a removal program, hand a shell a script built when it runs, or hold text
  *  nobody could read ({@link unreadPlan}, {@link programUnread})? The guard establishes nothing for a command that does none. */
 export declare function planRunsRemoval(plan: EstablishedPlan["plan"]): boolean;

package/dist/tools/fs/removal-targets.js

@@ -2,11 +2,11 @@ import { planShellReads } from "./shell-read-plan.js";
 import { literalTextOf } from "../../shell/lex.js";
 import { createShellReadEstablisher, establishShellReadsLexically } from "./shell-read-establish.js";
 import { isAbsoluteForFamily, isWinFormPath, normalizeAbsPathLexically } from "./safety.js";
-import { launchedCommands, launchedReadings, reentryText, scriptFileAt, spellLaunched } from "./shell-reentry-text.js";
-import { readProgramPosition } from "./bash-program-position.js";
+import { launchedCommands, launchedReadings, reentryText, runsStoredLine, scriptFileAt, spellLaunched } from "./shell-reentry-text.js";
+import { declinedProgramSentence, readProgramPosition } from "./bash-program-position.js";
 import { bashClassifyDefaultAllow } from "./bash-readonly-classifier.js";
 import { programArgs } from "./shell-read-write-targets.js";
-import { implementationsOf, programRow, runsShellText, selectedOptions, writeReadings } from "./program-read-model.js";
+import { declaresOption, implementationsOf, programRow, rowRefusesArgv, runsShellText, selectedOptions, writeReadings } from "./program-read-model.js";
 import { inlineUntrusted } from "../../core/untrusted-text.js";
 export const SHELL_REMOVAL_COMMANDS = Object.freeze(["rm", "rmdir"]);
 const REMOVAL_COMMAND_SET = new Set(SHELL_REMOVAL_COMMANDS);
@@ -68,10 +68,19 @@ function belowKnownSafeRoot(word, safe, segment) {
     const below = rest.map((p) => p.literal).join("");
     return /^\/[^*?[\]]+$/.test(below) && !below.split("/").includes("..");
 }
-function recursiveForce(row, args) {
+function optionsReceived(row, args) {
+    const rewrittenAt = args.findIndex((w) => w.rewritten === true);
+    const asWritten = (rewrittenAt < 0 ? args : args.slice(0, rewrittenAt)).map((w) => w.spelled);
+    const present = args.filter((w) => w.vanishes !== true);
+    const chosenAt = present.findIndex((w) => w.rewritten === true);
+    const shellChooses = chosenAt >= 0 && writeReadings(row, present.slice(0, chosenAt + 1).map((w) => w.spelled)).some((r) => r.written.length === 0);
+    return { refused: rowRefusesArgv(row, asWritten), shellChooses };
+}
+function recursiveForce(row, args, shellChooses) {
     return implementationsOf(row).some((view) => {
         const selected = selectedOptions(view, args, "one-implementation");
-        return selected.some((o) => o.selects === "traversal") && selected.some((o) => o.mode === "forced");
+        const selects = (has) => selected.some(has) || (shellChooses && declaresOption(view, has));
+        return selects((o) => o.selects === "traversal") && selects((o) => o.mode === "forced");
     });
 }
 export function removalFindingsOf(established, seat, safeRoots = KNOWN_SAFE_ROOTS, enclosingRelocated = false) {
@@ -81,23 +90,27 @@ export function removalFindingsOf(established, seat, safeRoots = KNOWN_SAFE_ROOT
     const safe = new Set(safeRoots);
     for (const segment of established.plan.segments) {
         const program = segment.verb?.basename;
-        const row = program !== undefined && REMOVAL_COMMAND_SET.has(program) ? programRow(program) : undefined;
-        if (program !== undefined && row !== undefined) {
-            const args = programArgs(segment);
-            const spelled = args.map((w) => w.spelled);
+        const removal = removalProgramOf(segment);
+        const args = removal === undefined ? [] : programArgs(segment);
+        const spelled = args.map((w) => w.spelled);
+        const received = removal === undefined ? undefined : optionsReceived(removal.row, args);
+        if (removal !== undefined && received?.refused === false) {
+            const { row, named } = removal;
             const removed = new Set(writeReadings(row, spelled).flatMap((r) => r.written.map((w) => w.at)));
             const options = new Set(args.filter((_, at) => !removed.has(at)).map((w) => w.raw));
-            const forced = recursiveForce(row, spelled);
+            const forced = recursiveForce(row, spelled, received.shellChooses);
             if (forced && segment.reentry === "argv")
-                out.push({ guard: "unverifiable_delete", program, operand: segment.text.trim(), source: "stream" });
+                out.push({ guard: "unverifiable_delete", program: removal.program, operand: segment.text.trim(), source: "stream" });
             const relocated = enclosingRelocated || readProgramPosition(segment.argv).launcherMovesBase;
             for (const read of established.reads.get(segment) ?? []) {
-                if (read.candidate.face !== "write" || options.has(read.candidate.raw))
+                if ((named && read.candidate.face !== "write") || read.candidate.provenance === "program_path" || options.has(read.candidate.raw))
+                    continue;
+                if (refusedByRemoval(read))
                     continue;
                 const kind = removalKindOf(read, seat);
                 if (kind !== undefined) {
                     const untracked = read.candidate.bases === "unmodelled" ? established.plan.segments.find((s) => s.bases === "unmodelled")?.text.trim() : undefined;
-                    out.push({ guard: "dangerous_delete", kind, program, operand: read.candidate.raw, target: read.target ?? read.candidate.floorSpelled ?? read.candidate.spelled, ...(untracked !== undefined ? { untrackedFrom: untracked } : {}) });
+                    out.push({ guard: "dangerous_delete", kind, program: removal.program, operand: read.candidate.raw, target: read.target ?? read.candidate.floorSpelled ?? read.candidate.spelled, ...(untracked !== undefined ? { untrackedFrom: untracked } : {}) });
                     continue;
                 }
                 if (!forced || read.established !== "unestablishable" || (read.candidate.expands !== "unresolvable" && !relocated))
@@ -105,14 +118,14 @@ export function removalFindingsOf(established, seat, safeRoots = KNOWN_SAFE_ROOT
                 const word = segment.argv.find((w) => w.raw === read.candidate.raw);
                 if (word !== undefined && belowKnownSafeRoot(word, safe, segment))
                     continue;
-                out.push({ guard: "unverifiable_delete", program, operand: read.candidate.raw, source: read.candidate.expands === "unresolvable" ? "rewritten" : "relocated" });
+                out.push({ guard: "unverifiable_delete", program: removal.program, operand: read.candidate.raw, source: read.candidate.expands === "unresolvable" ? "rewritten" : "relocated" });
             }
         }
         const script = runtimeScriptOf(segment);
         if (script !== undefined && program !== undefined)
             out.push({ guard: "unverifiable_shell_text", program, text: script, source: "produced" });
         if (programUnread(segment))
-            out.push({ guard: "unverifiable_shell_text", program: segment.launcherChain[0] ?? segment.text.trim(), text: segment.text.trim(), source: "unread" });
+            out.push({ guard: "unverifiable_shell_text", program: segment.launcherChain[0] ?? segment.text.trim(), text: segment.text.trim(), source: "position" });
         const handedRelocated = enclosingRelocated || readProgramPosition(segment.argv).launcherMovesBase;
         for (const nested of segment.nested) {
             if (unreadPlan(nested)) {
@@ -143,7 +156,7 @@ function runtimeScriptOf(segment) {
         const source = file === undefined ? undefined : argv[file];
         if (source !== undefined && source.pieces.length === 1 && source.pieces[0].expansion?.kind === "process")
             return source.raw;
-        if (pos.argvFromStdin)
+        if (pos.argvFromStdin || runsStoredLine(program.basename, argv.map((w) => w.folded)))
             return segment.text.trim();
     }
     const named = pos.program !== undefined && pos.refusal === undefined ? [{ shell: program.basename, words: segment.argv.slice(pos.program.index + 1).map((_, k) => spell(pos.program.index + 1 + k)) }] : [];
@@ -157,8 +170,21 @@ function runtimeScriptOf(segment) {
 }
 const unreadPlan = (plan) => plan.unreadable !== undefined && plan.segments.length === 0;
 const programUnread = (s) => s.declines.includes("unreadable_program_position");
+const programNameUnsettled = (s) => s.verb !== undefined && s.reads.some((c) => c.provenance === "program_path" && c.expands === "unresolvable");
+const RM_REMOVAL_ROW = programRow("rm");
+function removalProgramOf(s) {
+    const basename = s.verb?.basename;
+    const row = basename !== undefined && REMOVAL_COMMAND_SET.has(basename) ? programRow(basename) : undefined;
+    if (row !== undefined)
+        return { program: basename, row, named: true };
+    return programNameUnsettled(s) && RM_REMOVAL_ROW !== undefined ? { program: s.verb.name, row: RM_REMOVAL_ROW, named: false } : undefined;
+}
+export function refusedByRemoval(read) {
+    const name = read.established === "expansion" ? read.spellings.find((s) => s !== read.origin) : read.candidate.expands === "unresolvable" ? undefined : read.candidate.spelled;
+    return name !== undefined && /(?:^|\/)\.\.?\/*$/.test(name);
+}
 export function planRunsRemoval(plan) {
-    return unreadPlan(plan) || plan.segments.some((s) => (s.verb !== undefined && REMOVAL_COMMAND_SET.has(s.verb.basename)) || runtimeScriptOf(s) !== undefined || programUnread(s) || s.nested.some(planRunsRemoval));
+    return unreadPlan(plan) || plan.segments.some((s) => removalProgramOf(s) !== undefined || runtimeScriptOf(s) !== undefined || programUnread(s) || s.nested.some(planRunsRemoval));
 }
 const DANGEROUS_REMOVAL_SENTENCE = {
     filesystem_root: (p, t) => `\`${p}\` would remove the filesystem root (${t})`,
@@ -172,8 +198,9 @@ const UNVERIFIABLE_REMOVAL_SENTENCE = {
     relocated: (p, o) => `\`${p}\` recursive+force target ${o} is relative to a directory a launcher option moved the program into, which this command does not settle — the deleted path cannot be verified from this command`,
 };
 const UNREADABLE_TEXT_SENTENCE = {
-    produced: (p, t) => `\`${p}\` runs shell text that is built only when the command runs (${t}) — the text this shell will run cannot be read by the engine, so whether it removes anything is unknown`,
-    unread: (p, t) => `\`${p}\` runs shell text this guard cannot read (${t}) — the text this shell will run cannot be read by the engine, so whether it removes anything is unknown`,
+    produced: (p, t) => `\`${p}\` runs shell text that is built only when the command runs (${inlineUntrusted(t, 200)}) — the text this shell will run cannot be read by the engine, so whether it removes anything is unknown; write the text into the command itself (a \`-c\` string, a here-document or a here-string) and the engine reads it as it reads any command`,
+    unread: (p, t) => `\`${p}\` runs shell text this guard cannot read (${inlineUntrusted(t, 200)}) — the text this shell will run cannot be read by the engine, so whether it removes anything is unknown`,
+    position: (_p, t) => inlineUntrusted(declinedProgramSentence(t), 400),
 };
 function verdictOf(findings) {
     for (const f of findings) {
@@ -187,7 +214,7 @@ function verdictOf(findings) {
             return { guard: f.guard, text: UNVERIFIABLE_REMOVAL_SENTENCE[f.source](f.program, inlineUntrusted(f.operand, 200)) };
     for (const f of findings)
         if (f.guard === "unverifiable_shell_text")
-            return { guard: f.guard, text: UNREADABLE_TEXT_SENTENCE[f.source](f.program, inlineUntrusted(f.text, 200)) };
+            return { guard: f.guard, text: UNREADABLE_TEXT_SENTENCE[f.source](f.program, f.text) };
     return undefined;
 }
 const REMOVAL_RESOLVE_TIMEOUT_MS = 10_000;

package/dist/tools/fs/search.d.ts

@@ -1,5 +1,6 @@
 import type { ExecutionEnv } from "../../internal/harness-types.js";
 import { type HomeViewsCarrier } from "./read-deny-home.js";
+import { type FsGlob } from "./fs-glob.js";
 /** The JS scanner's own output ceiling, in bytes of emitted content rows. Pinned to the
  *  ripgrep leg's figure ({@link MAX_EXEC_OUTPUT_BYTES}, the exec pipe's rolling-tail bound) so the two
  *  legs cannot disagree about how much one search may return; see the collection site in {@link jsGrep}
@@ -56,6 +57,15 @@ export declare function splitGlobParam(glob: string): string[];
  * Exported for direct injection testing.
  */
 export declare function shellQuote(s: string): string;
+/** Out-parameter for {@link compileGlobToken}: set to `true` when a glob-syntax construct
+ *  could NOT be compiled and silently fell back to matching the metacharacter LITERALLY. Only the
+ *  glob-syntax lane (`glob = true`) can set it; the gitignore lane has no such syntax to fail at. */
+export interface GlobCompileReport {
+    degraded: boolean;
+}
+/** Compile a gitignore/glob token to a matcher tested against a relative posix path. The matcher is the engine in
+ *  `fs-glob.ts`: its cost is bounded by the token's length times the path's, whatever the arrangement of the stars. */
+export declare function compileGlobToken(token: string, anchored: boolean, glob?: boolean, report?: GlobCompileReport): FsGlob;
 /**
  * The tokens of a `glob` argument that this engine CANNOT compile as glob syntax, i.e. the ones whose
  * metacharacter would silently degrade to a literal match.