@sema-agent/core 7.45.0 → 7.47.0

package/dist/tools/fs/bash-readonly-classifier.js

@@ -1,6 +1,8 @@
 import { isAbsoluteForFamily, isAbsolutePathForm, isBlockedDevicePath, isShellRootedSpellingUnmapped, joinForFamily, nativeUncSpellingOf, normalizeAbsPathLexically, win32NamespaceScreen, pathFamilyOf } from "./safety.js";
 import { PARSE_FAILURE_SENTENCE, UNRESOLVED_SENTENCE, argvOf, lexShell, literalTildeSpelling, } from "../../shell/lex.js";
-import { COMMAND_LAUNCHERS, NOT_AUTO_ALLOWED, SHELL_BLOCK_WORDS, argvReentryUnjudged, isBareControlWord, programBasename, programPositionRefusalSentence, readProgramPosition, } from "./bash-program-position.js";
+import { textBindsHome } from "./shell-read-bindings.js";
+import { NOT_AUTO_ALLOWED, argvReentryUnjudged, isBareControlWord, programPositionRefusalSentence, readProgramPosition, } from "./bash-program-position.js";
+import { BLOCK_WORD_NAMES, attachedStdinFile, declaresOption, firstOperandSlot, opensNoOperand, programDelivery, programRow, programTextReadings, readArgRoles, readArgs, readProgramTextLanguage, runsShellText, selectedOptions, slotValueCandidates, suppliesFirstOperandSlot, takesSeparatedDatum, valuesAreLiteral, writeReadings, writesPath, } from "./program-read-model.js";
 export const BASH_READONLY_DEFAULT_ALLOW = [
     "ls", "cat", "head", "tail", "wc", "pwd", "echo", "whoami", "uname",
     "grep", "cut", "tr", "basename", "dirname", "stat", "du", "df", "which",
@@ -121,7 +123,7 @@ export function strictResidualRefusal(lexed, source, opts = {}) {
             }
         }
     }
-    const home = opts.homeDir !== undefined && !homeMayBeRebound(source) ? opts.homeDir : undefined;
+    const home = opts.homeDir !== undefined && !textBindsHome(source) ? opts.homeDir : undefined;
     for (const w of words) {
         if (expandsDollar(w) && !(home !== undefined && homeSpelledForClassify(w, home) !== undefined))
             return reason;
@@ -159,99 +161,6 @@ export function formatOutOfRootReadApprovalOption(directory) {
     const leaf = cut >= 0 ? trimmed.slice(cut + 1) : trimmed;
     return `Yes, allow reading from ${leaf || directory}/ from this project`;
 }
-export const NO_PATH_OPERAND_COMMANDS = new Set([
-    "pwd", "echo", "printf", "whoami", "uname", "which", "tr", "basename", "dirname",
-    "cal", "uptime", "id", "groups", "nproc", "locale", "free", "true", "false", "seq", "expr", "type", "sleep",
-    "test", "[",
-]);
-export const NO_PATH_OPERAND_EVALUATORS = new Set(["test", "["]);
-export const DECLARATION_BUILTINS = new Set(["export", "declare", "typeset", "local", "readonly"]);
-export const INERT_BUILTINS = new Set(["echo", "true", "false", "pwd", ...DECLARATION_BUILTINS]);
-const MESSAGE_SLOTS = {
-    git: {
-        globalPlain: ["-p", "--paginate", "-P", "--no-pager", "--bare", "--no-replace-objects", "--literal-pathspecs", "--glob-pathspecs", "--noglob-pathspecs", "--icase-pathspecs", "--no-optional-locks"],
-        globalValue: ["-C", "-c", "--git-dir", "--work-tree", "--namespace", "--config-env", "--super-prefix"],
-        subcommands: {
-            commit: { plain: "apsnvqeioz", optional: "Su", value: "mFCct", longValue: ["message", "file", "template", "pathspec-from-file", "author", "date", "cleanup", "fixup", "squash", "trailer", "reuse-message", "reedit-message"] },
-            tag: { plain: "asfdvle", optional: "n", value: "mFu", longValue: ["message", "file", "local-user", "cleanup", "trailer", "sort", "format", "contains", "no-contains", "points-at", "merged", "no-merged"] },
-            merge: { plain: "nqve", optional: "S", value: "mFsX", longValue: ["message", "file", "strategy", "strategy-option", "into-name", "cleanup"] },
-            stash: { plain: "pkuaqS", optional: "", value: "m", longValue: ["message", "pathspec-from-file"] },
-        },
-    },
-};
-export function messageSlotWords(program, words, programIndex) {
-    const out = new Set();
-    const row = MESSAGE_SLOTS[program];
-    if (row === undefined)
-        return out;
-    let j = programIndex + 1;
-    for (; j < words.length; j++) {
-        const w = words[j].folded;
-        if (!w.startsWith("-"))
-            break;
-        if (row.globalValue.includes(w))
-            j++;
-        else if (!row.globalPlain.includes(w) && !row.globalValue.some((o) => o.startsWith("--") && w.startsWith(`${o}=`)))
-            return out;
-    }
-    const sub = row.subcommands[words[j]?.folded ?? ""];
-    if (sub === undefined)
-        return out;
-    const settled = (k) => words[k] !== undefined && words[k].expands === false;
-    let pending;
-    for (let k = j + 1; k < words.length; k++) {
-        const w = words[k].folded;
-        if (pending !== undefined) {
-            if (pending === "message" && settled(k))
-                out.add(k);
-            pending = undefined;
-            continue;
-        }
-        if (w === "--")
-            break;
-        if (!settled(k)) {
-            pending = "other";
-            continue;
-        }
-        if (!w.startsWith("-") || w === "-")
-            continue;
-        if (w.startsWith("--")) {
-            const eq = w.indexOf("=");
-            const name = w.slice(2, eq < 0 ? undefined : eq);
-            const takers = sub.longValue.filter((n) => n.startsWith(name));
-            const message = name.length > 0 && takers.length > 0 && takers.every((n) => n === "message") || name === "message";
-            if (eq >= 0) {
-                if (message)
-                    out.add(k);
-                continue;
-            }
-            if (takers.length > 0)
-                pending = message ? "message" : "other";
-            continue;
-        }
-        const letters = w.slice(1);
-        for (let i = 0; i < letters.length; i++) {
-            const c = letters[i];
-            if (sub.plain.includes(c))
-                continue;
-            if (sub.optional.includes(c))
-                break;
-            if (sub.value.includes(c)) {
-                if (i < letters.length - 1) {
-                    if (c === "m")
-                        out.add(k);
-                }
-                else
-                    pending = c === "m" ? "message" : "other";
-                break;
-            }
-            pending = "other";
-            break;
-        }
-    }
-    return out;
-}
-const XARGS_TARGETS_ACCEPTED_UNJUDGED = NO_PATH_OPERAND_COMMANDS;
 export function isPathShapedToken(tok) {
     return tok.includes("/") || tok.startsWith("~") || tok === "." || tok === "..";
 }
@@ -287,7 +196,6 @@ function spellingsOf(absolute) {
 function reheadSegment(toks, head, from = 0) {
     return { folded: [head, ...toks.folded.slice(from + 1)], raw: [head, ...toks.raw.slice(from + 1)] };
 }
-export const SHELL_REENTRY_PROGRAM_RE = /^(?:(?:ba|z|da|k|fi|a|mk|ya|pdk|c|tc)?sh|eval|source|\.|parallel)$/;
 function segmentSpellings(words, homeDir, homeRebound) {
     const folded = [];
     const raw = [];
@@ -303,6 +211,8 @@ export function expansionInWord(w) {
         const k = p.expansion?.kind;
         if (k === "parameter" || k === "command" || k === "process" || k === "arithmetic" || k === "brace")
             return true;
+        if (k === "glob" && /[$`]/.test(p.expansion?.body ?? ""))
+            return true;
         if (p.literal === undefined)
             continue;
         if (p.quotedBy === undefined && /[{}$`]/.test(p.literal))
@@ -322,437 +232,6 @@ export function globInWord(w) {
     }
     return false;
 }
-function longOptionNameOf(tok) {
-    if (!tok.startsWith("--") || tok.length === 2)
-        return undefined;
-    const body = tok.slice(2);
-    const eq = body.indexOf("=");
-    const name = eq >= 0 ? body.slice(0, eq) : body;
-    return name.length > 0 ? name : undefined;
-}
-function isLongOptionAbbrevOf(name, full) {
-    return full.startsWith(name);
-}
-export function suppliesFirstOperandSlot(slot, tok) {
-    if (tok.startsWith("--")) {
-        const long = longOptionNameOf(tok);
-        return long !== undefined && slot.suppliedByLongNames.some((full) => isLongOptionAbbrevOf(long, full));
-    }
-    return new RegExp(`^-[A-Za-z0-9]*[${slot.suppliedByLetters}]`).test(tok);
-}
-function isGrepClusterFileStdin(tok) {
-    if (tok.startsWith("--") || !/^-[A-Za-z0-9]/.test(tok))
-        return false;
-    for (let i = 1; i < tok.length; i++) {
-        const ch = tok[i];
-        if (ch === "e")
-            return false;
-        if (ch === "f")
-            return tok.slice(i + 1) === "-";
-        if (!/[A-Za-z0-9]/.test(ch))
-            return false;
-    }
-    return false;
-}
-function valueNamesAFile(kind) {
-    return kind === "path" || kind === "indirect" || kind === "form" || kind === "header" || kind === "url";
-}
-function widestValueKind(kinds) {
-    if (kinds.has("indirect"))
-        return "indirect";
-    if (kinds.has("path"))
-        return "path";
-    if (kinds.has("form"))
-        return "form";
-    if (kinds.has("header"))
-        return "header";
-    if (kinds.has("url"))
-        return "url";
-    return [...kinds][0];
-}
-const VERB_OPTION_SLOTS = {
-    head: {
-        shortValue: { c: "count", n: "count" },
-        shortPlain: "qvz",
-        longValue: { bytes: "count", lines: "count" },
-        longOptionalValue: {},
-        longPlain: ["help", "quiet", "silent", "verbose", "version", "zero-terminated"],
-    },
-    tail: {
-        shortValue: { b: "count", c: "count", n: "count", s: "count" },
-        shortPlain: "fFqvz",
-        longValue: { bytes: "count", lines: "count", "max-unchanged-stats": "count", pid: "count", "sleep-interval": "count" },
-        longOptionalValue: { follow: "label" },
-        longPlain: ["help", "quiet", "retry", "silent", "verbose", "version", "zero-terminated"],
-    },
-    cut: {
-        shortValue: { b: "count", c: "count", d: "delimiter", f: "count" },
-        shortPlain: "nsz",
-        longValue: { bytes: "count", characters: "count", delimiter: "delimiter", fields: "count", "output-delimiter": "delimiter" },
-        longOptionalValue: {},
-        longPlain: ["complement", "help", "only-delimited", "version", "zero-terminated"],
-    },
-    grep: {
-        shortValue: { A: "count", B: "count", C: "count", D: "label", d: "label", e: "pattern", f: "path", m: "count" },
-        shortPlain: "0123456789abcEFGhHiIlLnoPqrRsUvVwxyzZ",
-        longValue: {
-            "after-context": "count",
-            "before-context": "count",
-            "binary-files": "label",
-            devices: "label",
-            directories: "label",
-            exclude: "name-pattern",
-            "exclude-dir": "name-pattern",
-            "exclude-from": "path",
-            file: "path",
-            "group-separator": "label",
-            include: "name-pattern",
-            label: "label",
-            "max-count": "count",
-            regexp: "pattern",
-        },
-        longOptionalValue: { color: "label", colour: "label", context: "count" },
-        firstOperand: { kind: "pattern", suppliedByLetters: "ef", suppliedByLongNames: ["regexp", "file"] },
-        longPlain: [
-            "basic-regexp", "byte-offset", "count", "dereference-recursive", "extended-regexp",
-            "files-with-matches", "files-without-match", "fixed-strings", "help", "ignore-case", "initial-tab",
-            "invert-match", "line-buffered", "line-number", "line-regexp", "no-filename", "no-group-separator",
-            "no-messages", "null", "null-data", "only-matching", "perl-regexp", "quiet", "recursive", "silent",
-            "text", "version", "with-filename", "word-regexp",
-        ],
-    },
-    diff: {
-        shortValue: { C: "count", D: "label", F: "pattern", I: "pattern", L: "label", S: "path", U: "count", W: "count", X: "path", x: "name-pattern" },
-        shortPlain: "abBcdeEHilnNpqrstTuvwyZ",
-        longValue: {
-            exclude: "name-pattern",
-            "exclude-from": "path",
-            "from-file": "path",
-            "horizon-lines": "count",
-            ifdef: "label",
-            "ignore-matching-lines": "pattern",
-            label: "label",
-            "show-function-line": "pattern",
-            "starting-file": "path",
-            tabsize: "count",
-            "to-file": "path",
-            width: "count",
-        },
-        longOptionalValue: { color: "label", context: "count", unified: "count" },
-        longPlain: [
-            "brief", "ed", "expand-tabs", "help", "ignore-all-space", "ignore-blank-lines", "ignore-case",
-            "ignore-space-change", "ignore-tab-expansion", "ignore-trailing-space", "initial-tab", "minimal",
-            "new-file", "normal", "paginate", "recursive", "report-identical-files", "rcs", "show-c-function",
-            "side-by-side", "speed-large-files", "suppress-blank-empty", "text", "version",
-        ],
-    },
-    cmp: {
-        shortValue: { i: "count", n: "count" },
-        shortPlain: "blsv",
-        longValue: { bytes: "count", "ignore-initial": "count" },
-        longOptionalValue: {},
-        longPlain: ["help", "print-bytes", "quiet", "silent", "verbose", "version"],
-    },
-    sed: {
-        shortValue: { e: "script", f: "path" },
-        shortPlain: "nrEszu",
-        longValue: { expression: "script", file: "path", "line-length": "count" },
-        longOptionalValue: { "in-place": "label" },
-        firstOperand: { kind: "script", suppliedByLetters: "ef", suppliedByLongNames: ["expression", "file"] },
-        longPlain: [
-            "debug", "follow-symlinks", "help", "null-data", "posix", "quiet", "regexp-extended", "sandbox",
-            "separate", "silent", "unbuffered", "version", "zero-terminated",
-        ],
-    },
-    date: {
-        shortValue: { d: "count", f: "path", r: "path", s: "count" },
-        shortPlain: "uR",
-        longValue: { date: "count", file: "path", reference: "path", "rfc-3339": "count", set: "count" },
-        longOptionalValue: { "iso-8601": "label" },
-        longPlain: ["debug", "help", "rfc-822", "rfc-email", "universal", "utc", "version"],
-    },
-    tar: {
-        shortValue: { b: "count", C: "path", f: "path", T: "path", X: "path" },
-        shortPlain: "acdhjJkmOpPrStuvwWxzZ",
-        longValue: {
-            "blocking-factor": "count",
-            directory: "path",
-            exclude: "name-pattern",
-            "exclude-from": "path",
-            file: "path",
-            "files-from": "path",
-            "strip-components": "count",
-        },
-        longOptionalValue: {},
-        longPlain: [
-            "absolute-names", "append", "create", "dereference", "extract", "get", "help", "interactive",
-            "keep-old-files", "list", "preserve-permissions", "sparse", "to-stdout", "touch", "update",
-            "verbose", "verify", "version",
-        ],
-    },
-    find: {
-        shortValue: { D: "label", O: "count", f: "path" },
-        shortPlain: "HLPdsx",
-        longValue: {},
-        longOptionalValue: {},
-        longPlain: ["help", "version"],
-        dashWordValue: {
-            amin: "count", anewer: "path", atime: "count", cmin: "count", cnewer: "path", context: "label",
-            ctime: "count", fstype: "label", gid: "count", group: "label", ilname: "path", iname: "name-pattern",
-            inum: "count", ipath: "path", iregex: "name-pattern", iwholename: "path", links: "count",
-            lname: "path", maxdepth: "count", mindepth: "count", mmin: "count", mtime: "count", name: "name-pattern",
-            newer: "path", newerat: "path", neweraa: "path", neweram: "path", newerac: "path",
-            newerct: "path", newerca: "path", newercm: "path", newercc: "path",
-            newermt: "path", newerma: "path", newermm: "path", newermc: "path",
-            newerbt: "path", newerba: "path", newerbm: "path", newerbc: "path",
-            path: "path", perm: "label", printf: "label", regex: "name-pattern", regextype: "label",
-            samefile: "path", size: "count", type: "label", uid: "count", used: "count", user: "label",
-            wholename: "path", xtype: "label",
-        },
-        dashWordPlain: [
-            "and", "daystart", "depth", "empty", "executable", "false", "follow", "help", "ignore_readdir_race",
-            "mount", "noignore_readdir_race", "noleaf", "not", "nogroup", "nouser", "or", "print",
-            "print0", "prune", "quit", "readable", "true", "version", "writable", "xdev",
-        ],
-        optionsArePositionIndependent: true,
-    },
-    curl: {
-        shortValue: {
-            A: "label", b: "indirect", C: "count", c: "path", D: "path", d: "indirect", E: "path", e: "label",
-            F: "form", H: "header", K: "path", m: "count", o: "path", P: "label", Q: "label", r: "count",
-            T: "path", t: "label", U: "label", u: "label", w: "indirect", X: "label", x: "label", Y: "count",
-            y: "count", z: "path",
-        },
-        shortPlain: "#0123456aBfgGhiIjJklLMnNOpqRsSvVZ",
-        longValue: {
-            cacert: "path",
-            capath: "path",
-            cert: "path",
-            config: "path",
-            "connect-timeout": "count",
-            cookie: "indirect",
-            "cookie-jar": "path",
-            data: "indirect",
-            "data-ascii": "indirect",
-            "data-binary": "indirect",
-            "data-raw": "label",
-            "data-urlencode": "form",
-            "dump-header": "path",
-            form: "form",
-            "form-string": "label",
-            header: "header",
-            key: "path",
-            "max-time": "count",
-            "netrc-file": "path",
-            output: "path",
-            proxy: "label",
-            range: "count",
-            referer: "label",
-            request: "label",
-            resolve: "label",
-            trace: "path",
-            "time-cond": "path",
-            "trace-ascii": "path",
-            "upload-file": "path",
-            url: "url",
-            user: "label",
-            "user-agent": "label",
-            "write-out": "indirect",
-        },
-        longOptionalValue: {},
-        longPlain: [
-            "append", "compressed", "disable", "fail", "get", "globoff", "head", "help", "include", "insecure",
-            "junk-session-cookies", "list-only", "location", "manual", "netrc", "next", "no-buffer", "parallel",
-            "proxytunnel", "remote-header-name", "remote-name", "remote-time", "show-error", "silent",
-            "use-ascii", "verbose", "version",
-        ],
-    },
-};
-export function readVerbOptionSlot(name, tok) {
-    const row = VERB_OPTION_SLOTS[name];
-    if (row === undefined)
-        return undefined;
-    if (!tok.startsWith("-") || tok === "-" || tok === "--")
-        return { form: "unexplained" };
-    if (tok.startsWith("--")) {
-        const long = longOptionNameOf(tok);
-        if (long === undefined)
-            return { form: "unexplained" };
-        const eq = tok.indexOf("=");
-        const attached = eq >= 0 ? tok.slice(eq + 1) : undefined;
-        const withValue = (kind) => attached !== undefined ? { form: "attached", value: attached, kind } : { form: "separated", kind };
-        const exact = row.longValue[long];
-        if (exact !== undefined)
-            return withValue(exact);
-        const exactOptional = row.longOptionalValue[long];
-        if (exactOptional !== undefined)
-            return attached !== undefined ? { form: "attached", value: attached, kind: exactOptional } : { form: "no-value" };
-        if (row.longPlain.includes(long))
-            return attached === undefined ? { form: "no-value" } : { form: "unexplained" };
-        const valueNames = [
-            ...Object.keys(row.longValue),
-            ...(attached !== undefined ? Object.keys(row.longOptionalValue) : []),
-        ].filter((full) => isLongOptionAbbrevOf(long, full));
-        const plainNames = [
-            ...row.longPlain,
-            ...(attached === undefined ? Object.keys(row.longOptionalValue) : []),
-        ].filter((full) => isLongOptionAbbrevOf(long, full));
-        if (valueNames.length === 0)
-            return plainNames.length > 0 && attached === undefined ? { form: "no-value" } : { form: "unexplained" };
-        const kinds = new Set(valueNames.map((full) => (row.longValue[full] ?? row.longOptionalValue[full])));
-        if (attached !== undefined)
-            return { form: "attached", value: attached, kind: widestValueKind(kinds) };
-        if (plainNames.length > 0 || kinds.size !== 1)
-            return { form: "unexplained" };
-        return withValue([...kinds][0]);
-    }
-    const word = row.dashWordValue !== undefined || row.dashWordPlain !== undefined ? /^-([A-Za-z_][\w-]+)$/.exec(tok)?.[1] : undefined;
-    if (word !== undefined) {
-        if (row.shortValue[word[0]] !== undefined)
-            return { form: "unexplained" };
-        const kind = row.dashWordValue?.[word];
-        if (kind !== undefined)
-            return { form: "separated", kind };
-        if (row.dashWordPlain?.includes(word) === true)
-            return { form: "no-value" };
-        return { form: "unexplained" };
-    }
-    for (let i = 1; i < tok.length; i++) {
-        const ch = tok[i];
-        const kind = row.shortValue[ch];
-        if (kind !== undefined) {
-            const rest = tok.slice(i + 1);
-            return rest !== "" ? { form: "attached", value: rest, kind } : { form: "separated", kind };
-        }
-        if (!row.shortPlain.includes(ch))
-            return { form: "unexplained" };
-    }
-    return { form: "no-value" };
-}
-export function verbOptionsArePositionIndependent(name) {
-    return VERB_OPTION_SLOTS[name]?.optionsArePositionIndependent === true;
-}
-export function verbFirstOperandSlot(name) {
-    return VERB_OPTION_SLOTS[name]?.firstOperand;
-}
-function localFileUrlPath(value) {
-    const m = /^file:(?:\/\/[^/?#]*)?(\/[^?#]*)/i.exec(value.trim());
-    if (m === null)
-        return undefined;
-    const raw = m[1];
-    try {
-        return decodeURIComponent(raw);
-    }
-    catch {
-        return raw;
-    }
-}
-function formSpecFileNames(value) {
-    const out = [];
-    const after = (s) => {
-        const at = s.search(/[@<]/);
-        if (at !== -1 && at < s.length - 1)
-            out.push(s.slice(at + 1));
-    };
-    after(value);
-    for (const part of value.split(/[;,]/))
-        after(part);
-    return [...new Set(out)];
-}
-export function slotValueCandidates(value, kind) {
-    if (!valueNamesAFile(kind))
-        return [];
-    if (kind === "url") {
-        const local = localFileUrlPath(value);
-        return local !== undefined ? [local] : [];
-    }
-    if (kind === "form")
-        return formSpecFileNames(value).map(literalTildeSpelling);
-    const named = value.startsWith("@") && value.length > 1 ? literalTildeSpelling(value.slice(1)) : undefined;
-    if (kind === "header")
-        return named !== undefined ? [value, named] : [];
-    const out = [value];
-    if (kind === "indirect" && named !== undefined)
-        out.push(named);
-    return out;
-}
-const SEPARATED_VALUE_OPTIONS = {
-    head: { short: "cn", long: ["bytes", "lines"] },
-    tail: { short: "cns", long: ["bytes", "lines", "sleep-interval", "pid", "max-unchanged-stats"] },
-    cut: { short: "bcdf", long: ["bytes", "characters", "delimiter", "fields", "output-delimiter"] },
-    grep: {
-        ownsValueButNotSkippable: "ef",
-        short: "mABCdD",
-        long: [
-            "max-count",
-            "after-context",
-            "before-context",
-            "context",
-            "devices",
-            "directories",
-            "label",
-            "binary-files",
-            "group-separator",
-            "include",
-            "exclude",
-            "exclude-dir",
-        ],
-    },
-    cmp: { short: "ni", long: ["bytes", "ignore-initial"] },
-    diff: { short: "UCWIFxL", ownsValueButNotSkippable: "SX", long: ["unified", "context", "width", "ignore-matching-lines", "show-function-line", "exclude", "label", "horizon-lines", "tabsize"] },
-};
-function takesSeparatedValue(name, tok) {
-    const model = SEPARATED_VALUE_OPTIONS[name];
-    if (model === undefined)
-        return false;
-    if (tok.startsWith("--")) {
-        if (tok.includes("="))
-            return false;
-        const long = longOptionNameOf(tok);
-        return long !== undefined && model.long.some((full) => isLongOptionAbbrevOf(long, full));
-    }
-    if (!/^-[A-Za-z0-9]/.test(tok))
-        return false;
-    for (let i = 1; i < tok.length; i++) {
-        const ch = tok[i];
-        if ((model.ownsValueButNotSkippable ?? "").includes(ch))
-            return false;
-        if (model.short.includes(ch))
-            return i === tok.length - 1;
-        if (!/[A-Za-z0-9]/.test(ch))
-            return false;
-    }
-    return false;
-}
-const GREP_RECURSIVE_READ_FORM = {
-    discloses: "contents",
-    shortLetters: "rR",
-    valueOwners: "efmABCD",
-    longNames: ["recursive", "dereference-recursive"],
-    enumOptions: [{ shortLetter: "d", longName: "directories", recursiveValue: "recurse" }],
-    dashIsStdin: true,
-};
-export const RECURSIVE_READ_FORMS = {
-    grep: GREP_RECURSIVE_READ_FORM,
-    egrep: GREP_RECURSIVE_READ_FORM,
-    fgrep: GREP_RECURSIVE_READ_FORM,
-    ls: { discloses: "names", shortLetters: "R", longNames: ["recursive"] },
-    du: { discloses: "names", always: true },
-    find: { discloses: "names", always: true },
-    rg: { discloses: "contents", always: true, dashIsStdin: true },
-    tree: { discloses: "names", always: true },
-    ag: { discloses: "contents", always: true, dashIsStdin: true },
-    ack: { discloses: "contents", always: true, dashIsStdin: true },
-    tar: { discloses: "contents", shortLetters: "cru", valueOwners: "fCTXbg", longNames: ["create", "append", "update"], bundledModeLetters: "cru", dashIsStdin: true },
-    diff: { discloses: "contents", shortLetters: "r", valueOwners: "UCWISFXx", longNames: ["recursive"], dashIsStdin: true },
-};
-const FIND_DANGEROUS_PREDICATES = new Set([
-    "-delete", "-exec", "-execdir", "-ok", "-okdir", "-fprint", "-fprint0", "-fls", "-fprintf", "-files0-from",
-]);
-const SED_READONLY_FLAGS = new Set([
-    "-n", "--quiet", "--silent", "-E", "--regexp-extended", "-r", "-z", "--zero-terminated", "--posix",
-]);
-const SED_READONLY_CLUSTER_LETTERS = new Set(["n", "E", "r", "z"]);
 const SED_READONLY_SCRIPT_PIECE = /^(?:\d+|\d+,\d+)?p$/;
 const SED_FILE_OR_EXEC_COMMANDS = new Set(["r", "R", "w", "W", "e"]);
 const SED_PLAIN_COMMANDS = new Set(["=", "d", "D", "F", "g", "G", "h", "H", "n", "N", "p", "P", "x", "z"]);
@@ -989,103 +468,18 @@ function readSedScript(script) {
         return failed();
     return anyName() ? named() : "clean";
 }
-const SED_OPTION_DIALECTS = [
-    { separated: "efl", suffix: "iI", stopsAtFirstOperand: false },
-    { separated: "ef", suffix: "iI", stopsAtFirstOperand: true },
-];
-function sedSeparatedSuffixTaken(tok) {
-    return tok !== undefined && (tok === "" || tok.startsWith("."));
-}
-const SED_LONG_VALUE_OPTIONS = ["expression", "line-length"];
-const SED_LONG_PLAIN_OPTIONS = [
-    "debug", "follow-symlinks", "help", "in-place", "null-data", "posix", "quiet", "regexp-extended",
-    "sandbox", "separate", "silent", "unbuffered", "version", "zero-terminated",
-];
-function readSedInvocation(args, dialect) {
-    return sedReadingKind(readSedInvocationDetailed(args, dialect));
-}
-function readSedInvocationDetailed(args, dialect) {
-    const scripts = [];
-    let scriptSupplied = false;
-    let endOfOptions = false;
-    let firstOperand;
-    for (let k = 0; k < args.length; k++) {
-        const tok = args[k];
-        if (!endOfOptions && tok === "--") {
-            endOfOptions = true;
-            continue;
-        }
-        if (endOfOptions || !tok.startsWith("-") || tok === "-") {
-            if (firstOperand === undefined) {
-                firstOperand = tok;
-                if (dialect.stopsAtFirstOperand)
-                    endOfOptions = true;
-            }
-            continue;
-        }
-        if (tok.startsWith("--")) {
-            const long = longOptionNameOf(tok);
-            if (long === undefined)
-                return "unparsed";
-            const eq = tok.indexOf("=");
-            const attached = eq >= 0 ? tok.slice(eq + 1) : undefined;
-            if (isLongOptionAbbrevOf(long, "file"))
-                return "unseen";
-            if (isLongOptionAbbrevOf(long, "expression")) {
-                const value = attached ?? args[++k];
-                if (value === undefined)
-                    return "unparsed";
-                scripts.push(value);
-                scriptSupplied = true;
-                continue;
-            }
-            if (SED_LONG_VALUE_OPTIONS.some((full) => isLongOptionAbbrevOf(long, full))) {
-                if (attached === undefined)
-                    k++;
-                continue;
-            }
-            if (SED_LONG_PLAIN_OPTIONS.some((full) => isLongOptionAbbrevOf(long, full)))
-                continue;
-            return "unparsed";
-        }
-        for (let c = 1; c < tok.length; c++) {
-            const letter = tok[c];
-            if (dialect.suffix.includes(letter)) {
-                if (c + 1 === tok.length && sedSeparatedSuffixTaken(args[k + 1]))
-                    k++;
-                break;
-            }
-            if (dialect.separated.includes(letter)) {
-                const rest = tok.slice(c + 1);
-                const value = rest !== "" ? rest : args[++k];
-                if (letter === "f")
-                    return "unseen";
-                if (letter === "e") {
-                    if (value === undefined)
-                        return "unparsed";
-                    scripts.push(value);
-                    scriptSupplied = true;
-                }
-                break;
-            }
-            if (!SED_SHORT_PLAIN_LETTERS.includes(letter))
-                return "unparsed";
-        }
-    }
-    const script = scriptSupplied ? scripts.join("\n") : firstOperand;
-    if (script === undefined)
-        return "clean";
-    return readSedScript(script);
+function scriptReadings(row, args) {
+    return programTextReadings(row, args).map((r) => (r === "from-file" ? "unseen" : r === "unparsed" ? "unparsed" : r === "none" ? "clean" : readSedScript(r.text)));
 }
-const SED_SHORT_PLAIN_LETTERS = "nsuzEraHl";
-export function sedScriptSlotFiles(args) {
+export function programTextSlotFiles(row, args) {
+    if (readProgramTextLanguage(row) !== "sed")
+        return undefined;
     const reads = new Set();
     const writes = new Set();
     const commands = new Set();
     let executesPatternSpace = false;
     const kinds = [];
-    for (const dialect of SED_OPTION_DIALECTS) {
-        const reading = readSedInvocationDetailed(args, dialect);
+    for (const reading of scriptReadings(row, args)) {
         kinds.push(sedReadingKind(reading));
         if (typeof reading === "string")
             continue;
@@ -1104,335 +498,111 @@ export function sedScriptSlotFiles(args) {
             : undefined;
     return { reads: [...reads], writes: [...writes], commands: [...commands], executesPatternSpace, ...(unread !== undefined ? { unread } : {}) };
 }
-const SCRIPT_SLOT_VERBS = new Map([
-    ["sed", (args) => {
-            const readings = SED_OPTION_DIALECTS.map((dialect) => readSedInvocation(args, dialect));
-            if (readings.includes("names") || readings.includes("unseen") || readings.includes("oversized"))
-                return true;
-            return readings.every((reading) => reading === "unparsed");
-        }],
-]);
+function scriptSlotHidesNames(row, args) {
+    if (readProgramTextLanguage(row) !== "sed")
+        return false;
+    const readings = scriptReadings(row, args).map(sedReadingKind);
+    if (readings.includes("names") || readings.includes("unseen") || readings.includes("oversized"))
+        return true;
+    return readings.every((reading) => reading === "unparsed");
+}
 const INLINE_PROGRAM_TEXT = "runs its argument as an interpreted program";
 const INLINE_PROGRAM_STDIN = "reads the program it runs from its standard input";
-const INTERPRETER_BANNER_OPTIONS = new Set(["--version", "--help", "--usage", "-version", "-help"]);
-const BLANK_INLINE = {
-    longText: new Set(), longFile: new Set(), longNamesProgram: new Set(), longSupplemental: new Set(),
-    longValue: new Set(), longPlain: new Set(), fileOptionEndsOptions: false,
-    textLetters: "", fileLetters: "", separatedValueLetters: "", attachedValueLetters: "",
-    plainLetters: "", bannerLetters: "", interactiveLetters: "",
-    programOperand: { at: 0, isText: false },
-};
-const PERL_INLINE = {
-    ...BLANK_INLINE, textLetters: "eEmM", separatedValueLetters: "I", attachedValueLetters: "iCFxDV",
-    plainLetters: "nplawcsStTUWX", bannerLetters: "vVh", stdinWhenUnnamed: true,
-};
-const RUBY_INLINE = {
-    ...BLANK_INLINE, textLetters: "e", separatedValueLetters: "IrECFKT", plainLetters: "nplawcsSU",
-    bannerLetters: "vh", stdinWhenUnnamed: true,
-};
-const PYTHON_INLINE = {
-    ...BLANK_INLINE, textLetters: "c", fileLetters: "m", separatedValueLetters: "WXQ",
-    plainLetters: "uBEIsSqbdvxOtR", bannerLetters: "Vh?", interactiveLetters: "i",
-    fileOptionEndsOptions: true, stdinWhenUnnamed: true,
-};
-const NODE_INLINE = {
-    ...BLANK_INLINE, longText: new Set(["--eval", "--print"]), textLetters: "ep",
-    longValue: new Set(["--import", "--loader", "--experimental-loader", "--require", "--env-file", "--conditions", "--max-old-space-size"]),
-    longNamesProgram: new Set(["--test"]),
-    longPlain: new Set(["--inspect", "--inspect-brk", "--no-warnings", "--trace-warnings", "--watch", "--enable-source-maps", "--experimental-modules", "--no-deprecation", "--check"]),
-    separatedValueLetters: "r", plainLetters: "c", bannerLetters: "vh", interactiveLetters: "i",
-    stdinWhenUnnamed: true,
-};
-const PHP_INLINE = {
-    ...BLANK_INLINE, longText: new Set(["--run", "--process-begin", "--process-code", "--process-end"]),
-    textLetters: "rRBE", fileLetters: "fF", separatedValueLetters: "dcz", plainLetters: "nqswl",
-    bannerLetters: "vhi", interactiveLetters: "a", stdinWhenUnnamed: true,
-};
-const LUA_INLINE = {
-    ...BLANK_INLINE, textLetters: "e", separatedValueLetters: "l", bannerLetters: "vh",
-    interactiveLetters: "i", stdinWhenUnnamed: true,
-};
-const TCL_INLINE = { ...BLANK_INLINE, stdinWhenUnnamed: true };
-const EXPECT_INLINE = {
-    ...BLANK_INLINE, textLetters: "c", separatedValueLetters: "Db", plainLetters: "dN",
-    bannerLetters: "vh", interactiveLetters: "i", stdinWhenUnnamed: true,
-};
-const AWK_INLINE = {
-    ...BLANK_INLINE, longText: new Set(["--source"]), textLetters: "e",
-    longFile: new Set(["--file", "--exec"]), fileLetters: "fE", separatedValueLetters: "vF",
-    bannerLetters: "V", programOperand: { at: 0, isText: true }, stdinWhenUnnamed: false,
-};
-const JQ_INLINE = {
-    ...BLANK_INLINE, longFile: new Set(["--from-file"]), fileLetters: "f", separatedValueLetters: "L",
-    plainLetters: "nrjcsSaCMRe", bannerLetters: "h", programOperand: { at: 0, isText: true },
-    stdinWhenUnnamed: false,
-};
-const BC_INLINE = {
-    ...BLANK_INLINE, longText: new Set(["--expression"]), textLetters: "e", plainLetters: "lqsw",
-    bannerLetters: "vh", interactiveLetters: "i", programOperand: undefined, stdinWhenUnnamed: true,
-};
-const DC_INLINE = {
-    ...BLANK_INLINE, longText: new Set(["--expression"]), textLetters: "e",
-    longFile: new Set(["--file"]), fileLetters: "f", bannerLetters: "hV",
-    programOperand: undefined, stdinWhenUnnamed: true,
-};
-const SQLITE_INLINE = {
-    ...BLANK_INLINE, longText: new Set(["-cmd"]), longSupplemental: new Set(["-init"]),
-    programOperand: { at: 1, isText: true }, stdinWhenUnnamed: true,
-};
-const PSQL_INLINE = {
-    ...BLANK_INLINE, longText: new Set(["--command"]), textLetters: "c",
-    longFile: new Set(["--file"]), fileLetters: "f", separatedValueLetters: "hpUdoF",
-    plainLetters: "aeEqtxXwW", bannerLetters: "lV?", programOperand: undefined, stdinWhenUnnamed: true,
-};
-const OSASCRIPT_INLINE = {
-    ...BLANK_INLINE, textLetters: "e", separatedValueLetters: "ls", plainLetters: "i", bannerLetters: "h",
-    stdinWhenUnnamed: true,
-};
-const RSCRIPT_INLINE = {
-    ...BLANK_INLINE, textLetters: "e", bannerLetters: "h", stdinWhenUnnamed: false,
-};
-const JULIA_INLINE = {
-    ...BLANK_INLINE, longText: new Set(["--eval", "--print"]), textLetters: "eE",
-    separatedValueLetters: "JLp", plainLetters: "q", bannerLetters: "vh", interactiveLetters: "i",
-    stdinWhenUnnamed: true,
-};
-const GHCI_INLINE = {
-    ...BLANK_INLINE, textLetters: "e", separatedValueLetters: "io", programOperand: undefined,
-    stdinWhenUnnamed: true,
-};
-const GROOVY_INLINE = {
-    ...BLANK_INLINE, textLetters: "e", separatedValueLetters: "Dcl", plainLetters: "n",
-    bannerLetters: "vh", interactiveLetters: "i", stdinWhenUnnamed: false,
-};
-const BUN_INLINE = {
-    ...BLANK_INLINE, longText: new Set(["--eval", "--print"]), textLetters: "ep",
-    separatedValueLetters: "r", bannerLetters: "vh", stdinWhenUnnamed: false,
-};
-export const INTERPRETER_INLINE_PROGRAMS = new Map([
-    ["perl", PERL_INLINE],
-    ["ruby", RUBY_INLINE],
-    ["python", PYTHON_INLINE],
-    ["node", NODE_INLINE],
-    ["nodejs", NODE_INLINE],
-    ["php", PHP_INLINE],
-    ["lua", LUA_INLINE],
-    ["luajit", LUA_INLINE],
-    ["tclsh", TCL_INLINE],
-    ["wish", TCL_INLINE],
-    ["expect", EXPECT_INLINE],
-    ["awk", AWK_INLINE],
-    ["gawk", AWK_INLINE],
-    ["mawk", AWK_INLINE],
-    ["nawk", AWK_INLINE],
-    ["jq", JQ_INLINE],
-    ["bc", BC_INLINE],
-    ["dc", DC_INLINE],
-    ["sqlite", SQLITE_INLINE],
-    ["psql", PSQL_INLINE],
-    ["osascript", OSASCRIPT_INLINE],
-    ["Rscript", RSCRIPT_INLINE],
-    ["julia", JULIA_INLINE],
-    ["ghci", GHCI_INLINE],
-    ["groovy", GROOVY_INLINE],
-    ["bun", BUN_INLINE],
-]);
-export function interpreterKey(name) {
-    return name.replace(/\d+(?:\.\d+)*$/, "");
+function unjudgedProgramTextRefusal(written, clause) {
+    return `command "${written}" ${clause}, which this walk does not judge ${NOT_AUTO_ALLOWED}`;
+}
+function argumentAsProgramRefusal(written, name, args) {
+    const row = programRow(name);
+    if (row !== undefined && scriptSlotHidesNames(row, args)) {
+        return unjudgedProgramTextRefusal(written, "names files or runs commands inside its script text");
+    }
+    const delivery = programDelivery(row, args);
+    return delivery === undefined ? undefined : unjudgedProgramTextRefusal(written, delivery === "text" ? INLINE_PROGRAM_TEXT : INLINE_PROGRAM_STDIN);
+}
+function makesMoreThanARead(spec) {
+    return spec.effect === "writes" || spec.effect === "executes" || spec.delivers !== undefined || spec.selects === "edit-in-place" || writesPath(spec.value);
 }
-export function inlineProgramClause(model, args) {
+function writesWordsItIsHanded(row, args) {
+    if (row === undefined)
+        return false;
+    const operands = args.some((w) => !w.startsWith("-") || w === "-");
+    return writeReadings(row, args).some((r) => r.written.length > 0 || (r.unexplained && r.operandRole !== undefined && operands));
+}
+function inReadOnlyForm(row, flag) {
+    const plain = (spec) => spec !== undefined && spec.arity === 0 && spec.effect === "none" && spec.fillsSlot !== true;
+    const merged = (table, key) => {
+        const specs = row.grammars.map((g) => g[table][key]).filter((x) => x !== undefined);
+        return specs.length > 0 && specs.every(plain) ? specs[0] : undefined;
+    };
+    if (flag.startsWith("--"))
+        return !flag.includes("=") && merged("long", flag.slice(2)) !== undefined;
+    return /^-[A-Za-z]+$/.test(flag) && [...flag.slice(1)].every((ch) => merged("short", ch) !== undefined);
+}
+function selectsQuiet(row, flag) {
+    const quiet = (spec) => spec?.mode === "quiet";
+    if (flag.startsWith("--"))
+        return row.grammars.some((g) => quiet(g.long[flag.slice(2)]));
+    return /^-[A-Za-z]+$/.test(flag) && [...flag.slice(1)].some((ch) => row.grammars.some((g) => quiet(g.short[ch])));
+}
+function readOnlyFormReason(name, row, rest, args) {
+    for (const w of args) {
+        if (globInWord(w) || expansionInWord(w)) {
+            return `\`${name}\` is given the unquoted pattern "${w.raw}", which the shell may expand into other arguments (a file named like a flag becomes a live option) before ${name} runs ${NOT_AUTO_ALLOWED}`;
+        }
+    }
+    const flags = [];
+    const operands = [];
     let endOfOptions = false;
-    let banner = false;
-    let interactive = false;
-    let named = false;
-    let stdin = false;
-    let explained = true;
-    let operands = 0;
-    scan: for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (!endOfOptions && arg === "--") {
+    for (const t of rest) {
+        if (!endOfOptions && t === "--") {
             endOfOptions = true;
             continue;
         }
-        if (arg === "-") {
-            if (model.programOperand?.isText !== true)
-                stdin = true;
-            continue;
-        }
-        if (!endOfOptions && arg.startsWith("-")) {
-            const eq = arg.indexOf("=");
-            const whole = eq < 0 ? arg : arg.slice(0, eq);
-            const valueOf = () => (eq < 0 ? args[++i] : arg.slice(eq + 1));
-            if (model.longText.has(whole))
-                return INLINE_PROGRAM_TEXT;
-            if (model.longFile.has(whole)) {
-                if (valueOf() === "-") {
-                    stdin = true;
-                    continue;
-                }
-                named = true;
-                if (explained && model.fileOptionEndsOptions)
-                    break scan;
-                continue;
-            }
-            if (model.longNamesProgram.has(whole)) {
-                named = true;
-                continue;
-            }
-            if (model.longSupplemental.has(whole)) {
-                valueOf();
-                continue;
-            }
-            if (INTERPRETER_BANNER_OPTIONS.has(whole)) {
-                banner = true;
-                continue;
-            }
-            if (model.longValue.has(whole)) {
-                valueOf();
-                continue;
-            }
-            if (model.longPlain.has(whole))
-                continue;
-            if (arg.startsWith("--")) {
-                if (eq < 0)
-                    explained = false;
-                continue;
-            }
-            for (let k = 1; k < arg.length; k++) {
-                const ch = arg[k];
-                if (ch >= "0" && ch <= "9")
-                    continue;
-                if (model.textLetters.includes(ch))
-                    return INLINE_PROGRAM_TEXT;
-                if (model.fileLetters.includes(ch)) {
-                    const value = k + 1 < arg.length ? arg.slice(k + 1) : args[++i];
-                    if (value === "-") {
-                        stdin = true;
-                        break;
-                    }
-                    named = true;
-                    if (explained && model.fileOptionEndsOptions)
-                        break scan;
-                    break;
-                }
-                if (model.attachedValueLetters.includes(ch)) {
-                    if (model.bannerLetters.includes(ch))
-                        banner = true;
-                    break;
-                }
-                if (model.bannerLetters.includes(ch)) {
-                    banner = true;
-                    continue;
-                }
-                if (model.interactiveLetters.includes(ch)) {
-                    interactive = true;
-                    continue;
-                }
-                if (model.separatedValueLetters.includes(ch)) {
-                    if (k + 1 >= arg.length)
-                        i++;
-                    break;
-                }
-                if (!model.plainLetters.includes(ch))
-                    explained = false;
-            }
+        if (!endOfOptions && t.startsWith("-")) {
+            flags.push(t);
             continue;
         }
-        operands++;
-        if (!named && explained && model.programOperand !== undefined && operands === model.programOperand.at + 1) {
-            if (model.programOperand.isText)
-                return INLINE_PROGRAM_TEXT;
-            named = true;
-            break;
-        }
+        operands.push(t);
     }
-    if (stdin || interactive)
-        return INLINE_PROGRAM_STDIN;
-    if (named || banner)
-        return undefined;
-    return model.stdinWhenUnnamed ? INLINE_PROGRAM_STDIN : undefined;
-}
-function unjudgedProgramTextRefusal(written, clause) {
-    return `command "${written}" ${clause}, which this walk does not judge ${NOT_AUTO_ALLOWED}`;
-}
-function argumentAsProgramRefusal(written, name, args) {
-    const slot = SCRIPT_SLOT_VERBS.get(name);
-    if (slot !== undefined && slot(args)) {
-        return unjudgedProgramTextRefusal(written, "names files or runs commands inside its script text");
+    for (const f of flags)
+        if (!inReadOnlyForm(row, f))
+            return `\`${name} ${f}\` is outside the read-only ${name} form (-n plus print-only script) ${NOT_AUTO_ALLOWED}`;
+    if (!flags.some((f) => selectsQuiet(row, f)))
+        return `\`${name}\` without \`-n\` echoes its whole input — only the -n print-only form is read-classified ${NOT_AUTO_ALLOWED}`;
+    const script = operands[0];
+    if (script === undefined)
+        return `\`${name}\` with no script ${NOT_AUTO_ALLOWED}`;
+    for (const piece of script.split(";")) {
+        if (!SED_READONLY_SCRIPT_PIECE.test(piece.trim()))
+            return `\`${name}\` script "${script}" is not a pure print command (N[,M]p) ${NOT_AUTO_ALLOWED}`;
     }
-    const interpreter = INTERPRETER_INLINE_PROGRAMS.get(interpreterKey(name));
-    if (interpreter === undefined)
-        return undefined;
-    const clause = inlineProgramClause(interpreter, args);
-    return clause === undefined ? undefined : unjudgedProgramTextRefusal(written, clause);
+    return undefined;
 }
 function guardedVerbFormReason(name, toks, args) {
-    if (name === "find") {
-        for (const t of toks) {
-            if (FIND_DANGEROUS_PREDICATES.has(t)) {
-                return `\`find ${t}\` executes a command or writes a file — not a read ${NOT_AUTO_ALLOWED}`;
-            }
+    const row = programRow(name);
+    const rest = toks.slice(1);
+    if (row !== undefined && readProgramTextLanguage(row) !== undefined)
+        return readOnlyFormReason(name, row, rest, args);
+    if (row !== undefined && declaresOption(row, makesMoreThanARead)) {
+        for (const t of rest) {
+            if (selectedOptions(row, [t]).some(makesMoreThanARead))
+                return `\`${name} ${t}\` executes a command or writes a file — not a read ${NOT_AUTO_ALLOWED}`;
         }
         for (const w of args) {
             if (globInWord(w) || expansionInWord(w)) {
-                return `\`find\` is given the unquoted pattern "${w.raw}", which the shell may expand into other arguments before find runs ${NOT_AUTO_ALLOWED}`;
-            }
-        }
-        return undefined;
-    }
-    if (name === "sed") {
-        for (const w of args) {
-            if (globInWord(w) || expansionInWord(w)) {
-                return `\`sed\` is given the unquoted pattern "${w.raw}", which the shell may expand into other arguments (a file named like a flag becomes a live option) before sed runs ${NOT_AUTO_ALLOWED}`;
-            }
-        }
-        const flags = [];
-        const operands = [];
-        let endOfOptions = false;
-        for (const t of toks.slice(1)) {
-            if (!endOfOptions && t === "--") {
-                endOfOptions = true;
-                continue;
-            }
-            if (!endOfOptions && t.startsWith("-")) {
-                flags.push(t);
-                continue;
-            }
-            operands.push(t);
-        }
-        for (const f of flags) {
-            if (SED_READONLY_FLAGS.has(f))
-                continue;
-            if (/^-[A-Za-z]+$/.test(f) && f.length > 2 && [...f.slice(1)].every((ch) => SED_READONLY_CLUSTER_LETTERS.has(ch)))
-                continue;
-            return `\`sed ${f}\` is outside the read-only sed form (-n plus print-only script) ${NOT_AUTO_ALLOWED}`;
-        }
-        const quiet = flags.some((f) => f === "-n" || f === "--quiet" || f === "--silent" || (/^-[A-Za-z]+$/.test(f) && f.includes("n")));
-        if (!quiet)
-            return `\`sed\` without \`-n\` echoes its whole input — only the -n print-only form is read-classified ${NOT_AUTO_ALLOWED}`;
-        const script = operands[0];
-        if (script === undefined)
-            return `\`sed\` with no script ${NOT_AUTO_ALLOWED}`;
-        for (const piece of script.split(";")) {
-            if (!SED_READONLY_SCRIPT_PIECE.test(piece.trim())) {
-                return `\`sed\` script "${script}" is not a pure print command (N[,M]p) ${NOT_AUTO_ALLOWED}`;
-            }
-        }
-        return undefined;
-    }
-    if (name === "free") {
-        for (const t of toks.slice(1)) {
-            if (/^--seconds(=.*)?$/.test(t) || /^-[A-Za-z0-9]*s[A-Za-z0-9]*$/.test(t)) {
-                return `\`free ${t}\` repeats until killed — it never terminates on its own ${NOT_AUTO_ALLOWED}`;
+                return `\`${name}\` is given the unquoted pattern "${w.raw}", which the shell may expand into other arguments before ${name} runs ${NOT_AUTO_ALLOWED}`;
             }
         }
         return undefined;
     }
+    const repeats = rest.find((t) => selectedOptions(row, [t]).some((s) => s.mode === "repeats"));
+    if (repeats !== undefined)
+        return `\`${name} ${repeats}\` repeats until killed — it never terminates on its own ${NOT_AUTO_ALLOWED}`;
     if (name === "sleep") {
         return pollLoopSleepReason(toks);
     }
     if (name === "seq") {
-        for (const t of toks.slice(1)) {
+        for (const t of rest) {
             if (t.startsWith("-") && t !== "-" && !/^-\d/.test(t))
                 continue;
             if (!/^-?\d{1,6}$/.test(t)) {
@@ -1441,92 +611,38 @@ function guardedVerbFormReason(name, toks, args) {
         }
         return undefined;
     }
-    if (name === "diff") {
-        for (const t of toks.slice(1)) {
-            if (/^--[A-Za-z-]+=-$/.test(t) || /^-[A-Za-z]*[SX]-$/.test(t)) {
-                return `\`diff ${t}\` names stdin inside a fused option — a read this check cannot see through ${NOT_AUTO_ALLOWED}`;
-            }
-        }
-    }
     return undefined;
 }
-export function segmentSelectsRecursiveRead(name, args) {
-    const model = RECURSIVE_READ_FORMS[name];
-    if (model === undefined)
-        return false;
-    if (model.discloses !== "contents")
-        return false;
-    if (model.always === true)
-        return true;
-    if (model.bundledModeLetters !== undefined) {
-        const first = args.find((t) => t.length > 0);
-        if (first !== undefined && !first.startsWith("-") && /^[A-Za-z]+$/.test(first) && [...first].some((ch) => model.bundledModeLetters.includes(ch))) {
-            return true;
-        }
-    }
-    let endOfOptions = false;
-    for (let k = 0; k < args.length; k++) {
-        const t = args[k];
-        if (endOfOptions)
-            continue;
-        if (t === "--") {
-            const prev = k > 0 ? args[k - 1] : undefined;
-            const prevMayOwnValue = prev !== undefined && prev.startsWith("--") && prev.length > 2 && !prev.includes("=");
-            if (!prevMayOwnValue)
-                endOfOptions = true;
-            continue;
-        }
-        if (t.startsWith("--")) {
-            const long = longOptionNameOf(t);
-            if (long === undefined)
-                continue;
-            if (model.longNames?.some((full) => isLongOptionAbbrevOf(long, full)) === true)
-                return true;
-            for (const en of model.enumOptions ?? []) {
-                if (en.longName === undefined || !isLongOptionAbbrevOf(long, en.longName))
-                    continue;
-                const eq = t.indexOf("=");
-                const v = eq >= 0 ? t.slice(eq + 1) : args[k + 1];
-                if (v !== undefined && v.length > 0 && en.recursiveValue.startsWith(v.toLowerCase()))
-                    return true;
-            }
-            continue;
+function openableWordsOf(row, args) {
+    const out = [];
+    const globs = valuesAreLiteral(row, args) ? "literal" : "expanded";
+    const offer = (value, role) => {
+        const named = slotValueCandidates(value, role, globs);
+        out.push(...(named ?? [value]));
+    };
+    for (const e of readArgs(row, args.map((folded) => ({ folded })), { firstOperandSlot: true })) {
+        const t = args[e.at];
+        if (e.kind === "dash-word-operand")
+            out.push(t);
+        else if (e.kind === "value")
+            offer(t, e.role);
+        else if (e.kind === "option") {
+            if (e.reading === "speculative")
+                out.push(...attachedOptionPayloads(t));
+            else if (e.reading !== "no-value")
+                offer(literalTildeSpelling(e.reading.attached), e.reading.role);
         }
-        if (!t.startsWith("-") || t === "-")
-            continue;
-        for (let i = 1; i < t.length; i++) {
-            const ch = t[i];
-            if (model.shortLetters?.includes(ch) === true)
-                return true;
-            const en = (model.enumOptions ?? []).find((e) => e.shortLetter === ch);
-            if (en !== undefined) {
-                const v = i === t.length - 1 ? args[k + 1] : t.slice(i + 1);
-                if (v !== undefined && v.length > 0 && en.recursiveValue.startsWith(v.toLowerCase()))
-                    return true;
-                if (i === t.length - 1)
-                    k++;
-                break;
-            }
-            if (model.valueOwners?.includes(ch) === true) {
-                if (i === t.length - 1)
-                    k++;
-                break;
-            }
-            if (!/[A-Za-z0-9]/.test(ch))
-                break;
+        else if (e.kind === "operand") {
+            const role = e.slot ?? e.role;
+            if (role !== undefined)
+                offer(t, role);
+            else
+                out.push(t);
         }
     }
-    return false;
-}
-function isGrepFileStdinLongOption(tok) {
-    const eq = tok.indexOf("=");
-    if (eq < 0 || tok.slice(eq + 1) !== "-")
-        return false;
-    const name = longOptionNameOf(tok);
-    return name !== undefined && isLongOptionAbbrevOf(name, "file");
+    return out;
 }
 const CLUSTER_OPTION_CHAR = /[A-Za-z0-9]/;
-export const ASSIGNMENT_VALUE_NOT_PATHS = new Set(["make", "gmake", "bmake", "cmake", "ninja", "meson", "docker", "podman"]);
 export function argvProgramOf(words) {
     const pos = readProgramPosition(words);
     if (pos.program === undefined)
@@ -1580,26 +696,6 @@ const CLASSIFY_HOME_REREADABLE = /["$`\\\n\r]/;
 function homeSpelledForClassify(w, home) {
     return CLASSIFY_HOME_REREADABLE.test(home) ? undefined : homeExpansionOf(w, home)?.spelled;
 }
-const HOME_PLAIN_READ = /\$HOME(?![A-Za-z0-9_])|\$\{HOME\}/g;
-const HOME_NAME = /HOME(?![A-Za-z0-9_])/;
-export function homeMayBeRebound(text) {
-    const unquoted = text.replace(/\\\r?\n/g, "").replace(HOME_PLAIN_READ, " ").replace(/\$?["']|\\/g, "");
-    if (HOME_NAME.test(unquoted))
-        return true;
-    if (hasUnquotedExtglobOpener(text))
-        return true;
-    if (!unquoted.includes("printf") && !/[*?[{]/.test(unquoted))
-        return false;
-    const lexed = lexShell(text);
-    return !("parseFailure" in lexed) && lexed.segments.some((seg) => {
-        const words = argvOf(seg);
-        return printfNamesComputed(words) || words.some((w) => globMayMatchHome(w) || optionWordCarriesGlob(w) || wordHasBraceList(w));
-    });
-}
-function hasUnquotedExtglobOpener(text) {
-    const lexed = lexShell(text);
-    return "parseFailure" in lexed || extglobOpenerIn(lexed, text);
-}
 export function extglobOpenerIn(lexed, text) {
     for (const seg of lexed.segments) {
         for (const [k, tok] of seg.tokens.entries()) {
@@ -1623,147 +719,6 @@ export function extglobOpenerIn(lexed, text) {
     }
     return false;
 }
-function wordHasBraceList(w) {
-    return w.pieces.some((p) => p.expansion?.kind === "brace");
-}
-function optionWordCarriesGlob(w) {
-    if (!w.pieces.some(isGlobPiece))
-        return false;
-    const atoms = patternAtoms(w.pieces);
-    if (atoms === undefined)
-        return UNREADABLE_GLOB_IS_A_REBINDING;
-    try {
-        const reversed = atoms.slice().reverse();
-        return closureReaches(atoms, "-") && (closureReaches(reversed, "EMOH") || closureReaches(reversed, "]"));
-    }
-    catch {
-        return UNREADABLE_GLOB_IS_A_REBINDING;
-    }
-}
-const UNREADABLE_GLOB_IS_A_REBINDING = true;
-function escapeRegExp(s) {
-    return s.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
-}
-function globMayMatchHome(w) {
-    if (!w.pieces.some(isGlobPiece))
-        return false;
-    const atoms = patternAtoms(w.pieces);
-    if (atoms === undefined)
-        return UNREADABLE_GLOB_IS_A_REBINDING;
-    try {
-        if (new RegExp(`^${atoms.join("")}$`).test("HOME"))
-            return true;
-        return closureReaches(atoms, "HOME[") && closureReaches(atoms.slice().reverse(), "]");
-    }
-    catch {
-        return UNREADABLE_GLOB_IS_A_REBINDING;
-    }
-}
-function patternAtoms(pieces) {
-    const atoms = [];
-    for (const p of pieces) {
-        if (p.literal !== undefined && p.expansion === undefined) {
-            for (const ch of p.literal)
-                atoms.push(caseFoldedChar(ch));
-            continue;
-        }
-        if (isGlobPiece(p)) {
-            const body = p.expansion.body;
-            if (body === undefined) {
-                atoms.push(RUN_ATOM);
-                continue;
-            }
-            const cls = translateBracket(body);
-            if (cls === undefined)
-                return undefined;
-            atoms.push(cls);
-            continue;
-        }
-        atoms.push(RUN_ATOM);
-    }
-    return atoms;
-}
-const RUN_ATOM = ".*";
-function caseFoldedChar(ch) {
-    const lower = ch.toLowerCase();
-    const upper = ch.toUpperCase();
-    return lower !== upper ? `[${escapeRegExp(lower)}${escapeRegExp(upper)}]` : escapeRegExp(ch);
-}
-function closureReaches(atoms, target) {
-    let re = "";
-    for (let i = atoms.length - 1; i >= 0; i--)
-        re = `(?:${atoms[i]}${re})?`;
-    return new RegExp(`^${re}$`).test(target);
-}
-function scanBracketBody(body) {
-    const members = [];
-    let computed = false;
-    for (let i = 0; i < body.length; i++) {
-        const c = body[i];
-        if (c === "\\") {
-            if (i + 1 < body.length)
-                members.push({ ch: body[++i], unquoted: false });
-            continue;
-        }
-        if (c === "$" || c === "`" || c === "{")
-            computed = true;
-        members.push({ ch: c, unquoted: true });
-    }
-    return { members, computed };
-}
-function membersOpenClassExpression(members) {
-    return members.some((m, i) => m.unquoted && m.ch === "[" && members[i + 1]?.unquoted === true && (members[i + 1].ch === ":" || members[i + 1].ch === "=" || members[i + 1].ch === "."));
-}
-function translateBracket(body) {
-    if (body.includes('"') || body.includes("'"))
-        return undefined;
-    const { members, computed } = scanBracketBody(body);
-    if (computed || membersOpenClassExpression(members))
-        return undefined;
-    let i = 0;
-    let negated = false;
-    if (members[0]?.unquoted === true && (members[0].ch === "!" || members[0].ch === "^")) {
-        negated = true;
-        i = 1;
-    }
-    const first = i;
-    let cls = "";
-    for (; i < members.length; i++) {
-        const { ch, unquoted } = members[i];
-        if (ch === "-" && unquoted && i > first && i < members.length - 1) {
-            if (!negated)
-                return undefined;
-            cls += "-";
-            continue;
-        }
-        const escaped = ch.replace(/[\\\]\[^-]/g, "\\$&");
-        cls += !negated && ch.toLowerCase() !== ch.toUpperCase() ? `${escapeRegExp(ch.toLowerCase())}${escapeRegExp(ch.toUpperCase())}` : escaped;
-    }
-    return `[${negated ? "^" : ""}${cls || "\\]"}]`;
-}
-const literalWord = (w) => (w !== undefined && w.pieces.every((p) => p.literal !== undefined && p.expansion === undefined) ? w.pieces.map((p) => p.literal).join("") : undefined);
-const IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
-function printfNamesComputed(words) {
-    for (let i = 0; i < words.length; i++) {
-        const head = literalWord(words[i]);
-        if (head === undefined || programBasename(head) !== "printf")
-            continue;
-        for (let j = i + 1; j < words.length; j++) {
-            const lit = literalWord(words[j]);
-            const opt = lit ?? words[j].pieces[0]?.literal ?? "";
-            if (lit === "--" || !opt.startsWith("-v"))
-                break;
-            if (lit === undefined)
-                return true;
-            const name = lit === "-v" ? words[++j] : undefined;
-            if (lit === "-v" && name === undefined)
-                break;
-            if (!IDENTIFIER.test(lit === "-v" ? (literalWord(name) ?? "") : lit.slice(2)))
-                return true;
-        }
-    }
-    return false;
-}
 function segmentCompoundForReadonly(command, homeDir) {
     const trimmed = command.trim();
     if (!trimmed)
@@ -1776,7 +731,7 @@ export function classifyCompoundReadonlyDetailed(command, allow, boundary) {
     if ("reject" in split)
         return { reason: split.reject };
     const { segments, pipeFed } = split;
-    const homeRebound = boundary?.homeDir !== undefined && homeMayBeRebound(command);
+    const homeRebound = boundary?.homeDir !== undefined && textBindsHome(command);
     let nameRefusal;
     const unlistedSegments = new Set();
     const reheaded = new Map();
@@ -1791,7 +746,7 @@ export function classifyCompoundReadonlyDetailed(command, allow, boundary) {
             return { reason: "empty command" };
         if (written === "coproc")
             return { reason: "`coproc` backgrounds a command — a backgrounded process outlives the command" };
-        if (isBareControlWord(words, from, SHELL_BLOCK_WORDS)) {
+        if (isBareControlWord(words, from, BLOCK_WORD_NAMES)) {
             unlistedSegments.add(si);
             nameRefusal ??= `command "${written}" is not in the read-only allowlist`;
             continue;
@@ -1819,14 +774,14 @@ export function classifyCompoundReadonlyDetailed(command, allow, boundary) {
             continue;
         }
         nameRefusal ??= `command "${parsed.name}" is not in the read-only allowlist`;
-        if (SHELL_REENTRY_PROGRAM_RE.test(name))
+        if (runsShellText(name))
             return { reason: unjudgedProgramTextRefusal(parsed.name, "runs its argument as shell text") };
         if (pos.launchers.length > 0) {
             const listed = program !== undefined && (allow.has(program.basename) || program.basename === "cd");
-            if (program !== undefined && !listed && SHELL_REENTRY_PROGRAM_RE.test(program.basename)) {
+            if (program !== undefined && !listed && runsShellText(program.basename)) {
                 return { reason: `"${written}" runs "${program.basename}", which runs its argument as shell text this classifier does not read ${NOT_AUTO_ALLOWED}` };
             }
-            if (argvReentryUnjudged(pos, XARGS_TARGETS_ACCEPTED_UNJUDGED)) {
+            if (argvReentryUnjudged(pos, opensNoOperand)) {
                 return { reason: `"${written}" takes the operands of the program it runs from its standard input, which this classifier does not read ${NOT_AUTO_ALLOWED}` };
             }
             if (!listed || program === undefined)
@@ -1838,34 +793,29 @@ export function classifyCompoundReadonlyDetailed(command, allow, boundary) {
         unlistedSegments.add(si);
     }
     const HEAD_AUTO_ALLOW_MAX = 1_000_000;
-    const headBoundIsSmall = (name, toks) => {
-        if (name !== "head")
+    const byteBoundIsSmall = (row, args) => {
+        if (row === undefined)
             return false;
         let byteBound = false;
-        for (let k = 1; k < toks.length; k++) {
-            const t = toks[k];
-            if (!t.startsWith("-") || t === "-")
+        for (const e of readArgRoles(row, args)) {
+            if (e.kind === "operand" || e.kind === "end-of-options")
                 continue;
-            const inline = /^-[A-Za-z]*c(\d+)$/.exec(t) ?? /^--bytes=(\d+)$/.exec(t);
-            if (inline) {
-                if (Number(inline[1]) > HEAD_AUTO_ALLOW_MAX)
+            if (e.kind === "value" && e.spec?.bounds === "bytes") {
+                if (!/^\d+$/.test(args[e.at]) || Number(args[e.at]) > HEAD_AUTO_ALLOW_MAX)
                     return false;
                 byteBound = true;
                 continue;
             }
-            if (/^-[A-Za-z]*c$/.test(t) || t === "--bytes") {
-                const v = toks[k + 1];
-                if (v === undefined || !/^\d+$/.test(v) || Number(v) > HEAD_AUTO_ALLOW_MAX)
+            if (e.kind === "option" && typeof e.reading === "object" && e.reading.spec?.bounds === "bytes") {
+                if (!/^\d+$/.test(e.reading.attached) || Number(e.reading.attached) > HEAD_AUTO_ALLOW_MAX)
                     return false;
                 byteBound = true;
-                k++;
                 continue;
             }
             return false;
         }
         return byteBound;
     };
-    const STDIN_FILE_FLOOR = { cat: 1, grep: 2, head: 1, tail: 1, wc: 1, cut: 1, tr: Infinity, diff: 2, cmp: 2, comm: 2, sed: 2 };
     const foldedSegments = [];
     let shapeRefusal = nameRefusal;
     for (let si = 0; si < segments.length; si++) {
@@ -1881,35 +831,38 @@ export function classifyCompoundReadonlyDetailed(command, allow, boundary) {
             continue;
         foldedSegments.push(segmentTokens);
         const name = toks[0];
-        const guardReason = guardedVerbFormReason(name, toks, argWords);
+        const guardReason = guardedVerbFormReason(name, toks, argWords) ?? (writesWordsItIsHanded(programRow(name), toks.slice(1)) ? `\`${name}\` writes a file it is handed — not a read ${NOT_AUTO_ALLOWED}` : undefined);
         if (guardReason !== undefined) {
             shapeRefusal ??= guardReason;
             continue;
         }
+        const row = programRow(name);
+        const restArgs = toks.slice(1);
         if (!(pipeFed[si] ?? false)) {
-            const floor = STDIN_FILE_FLOOR[name];
-            const restArgs = toks.slice(1);
-            const floorFirstOperandSlot = VERB_OPTION_SLOTS[name]?.firstOperand;
-            const floorSlotSuppliedByFlag = floorFirstOperandSlot !== undefined && restArgs.some((t) => suppliesFirstOperandSlot(floorFirstOperandSlot, t));
-            let sawNonFlagOperand = false;
-            let hasStdinDash = false;
-            let operandCount = 0;
-            let endOfOptions = false;
-            if (name !== "tr") {
+            const floor = row?.operands?.stdinBelow;
+            if (floor === "always") {
+                shapeRefusal ??= `"${name}" with no file argument reads stdin and would block until the tool timeout ${NOT_AUTO_ALLOWED}`;
+                continue;
+            }
+            if (floor !== undefined) {
+                const floorFirstOperandSlot = firstOperandSlot(row);
+                const floorSlotSuppliedByFlag = floorFirstOperandSlot !== undefined && restArgs.some((t) => suppliesFirstOperandSlot(floorFirstOperandSlot, t));
+                let sawNonFlagOperand = false;
+                let hasStdinDash = false;
+                let operandCount = 0;
+                let endOfOptions = false;
                 for (let k = 0; k < restArgs.length; k++) {
                     const t = restArgs[k];
-                    if (endOfOptions) {
-                    }
-                    else if (t === "--") {
-                        endOfOptions = true;
-                        continue;
-                    }
-                    else if (takesSeparatedValue(name, t)) {
-                        k++;
-                        continue;
-                    }
-                    else {
-                        if (name === "grep" && (isGrepClusterFileStdin(t) || isGrepFileStdinLongOption(t))) {
+                    if (!endOfOptions) {
+                        if (t === "--") {
+                            endOfOptions = true;
+                            continue;
+                        }
+                        if (takesSeparatedDatum(row, t)) {
+                            k++;
+                            continue;
+                        }
+                        if (attachedStdinFile(row, t)) {
                             hasStdinDash = true;
                             break;
                         }
@@ -1926,31 +879,24 @@ export function classifyCompoundReadonlyDetailed(command, allow, boundary) {
                         break;
                     }
                 }
-            }
-            if (floor !== undefined && hasStdinDash) {
-                shapeRefusal ??= `"${name}" reads stdin via an explicit "-" argument and would block until the tool timeout ${NOT_AUTO_ALLOWED}`;
-                continue;
-            }
-            if (floor !== undefined && operandCount < floor) {
-                shapeRefusal ??= `"${name}" with no file argument reads stdin and would block until the tool timeout ${NOT_AUTO_ALLOWED}`;
-                continue;
+                if (hasStdinDash) {
+                    shapeRefusal ??= `"${name}" reads stdin via an explicit "-" argument and would block until the tool timeout ${NOT_AUTO_ALLOWED}`;
+                    continue;
+                }
+                if (operandCount < floor) {
+                    shapeRefusal ??= `"${name}" with no file argument reads stdin and would block until the tool timeout ${NOT_AUTO_ALLOWED}`;
+                    continue;
+                }
             }
         }
-        if (name === "tail" && toks.slice(1).some((t) => t === "--follow" || t.startsWith("--follow=") || /^[-+][^\s]*[fF]/.test(t))) {
-            shapeRefusal ??= "`tail` in follow mode never terminates " + NOT_AUTO_ALLOWED;
+        if (selectedOptions(row, restArgs).some((o) => o.mode === "follows")) {
+            shapeRefusal ??= `\`${name}\` in follow mode never terminates ${NOT_AUTO_ALLOWED}`;
             continue;
         }
         const GENERATOR_DEVICES = new Set(["/dev/zero", "/dev/random", "/dev/urandom", "/dev/full"]);
-        const deviceCandidates = [];
-        for (const t of toks.slice(1)) {
-            if (t.startsWith("-") && t !== "-") {
-                deviceCandidates.push(...attachedOptionPayloads(t));
-                continue;
-            }
-            deviceCandidates.push(t);
-        }
+        const deviceCandidates = openableWordsOf(row, restArgs);
         const deviceArgs = deviceCandidates.map((t) => resolveOperandLexically(undefined, t, boundary?.homeDir) ?? normalizeAbsPathLexically(t)).filter(isBlockedDevicePath);
-        const rescuedByHead = headBoundIsSmall(name, toks) && deviceArgs.every((d) => GENERATOR_DEVICES.has(d));
+        const rescuedByHead = byteBoundIsSmall(row, restArgs) && deviceArgs.every((d) => GENERATOR_DEVICES.has(d));
         if (!rescuedByHead && deviceArgs.length > 0) {
             shapeRefusal ??= "reads a device/special file that is either unbounded (/dev/zero, /dev/stdin, /proc/<pid>/fd/0, … — blocks the pipeline until the tool timeout) or process-private (/proc/<pid>/environ, /proc/<pid>/mem, …) " + NOT_AUTO_ALLOWED;
         }
@@ -1960,8 +906,6 @@ export function classifyCompoundReadonlyDetailed(command, allow, boundary) {
         shapeRefusal ??= `multiple directory changes in one command require approval for clarity ${NOT_AUTO_ALLOWED}`;
     return shapeRefusal !== undefined ? { reason: shapeRefusal } : {};
 }
-export const UNMODELLED_BASE_MOVERS = new Set(["pushd", "popd"]);
-export const COMMAND_LAUNCHERS_FOR_TEST = COMMAND_LAUNCHERS;
 export function classifyCompoundReadonly(command, allow, boundary) {
     return classifyCompoundReadonlyDetailed(command, allow, boundary).reason;
 }
@@ -2055,7 +999,7 @@ export function classifyBoundedReadonlyPollLoopDetailed(command, allow, boundary
     if (beats > POLL_LOOP_MAX_BEATS) {
         return { reason: `the loop runs ${beats} iterations, above the ${POLL_LOOP_MAX_BEATS}-iteration cap for auto-allow` };
     }
-    const homeRebound = boundary?.homeDir !== undefined && homeMayBeRebound(command);
+    const homeRebound = boundary?.homeDir !== undefined && textBindsHome(command);
     const bodies = shape.body.map((b) => ({ ...b, spelled: segmentSpellings(b.words, boundary?.homeDir, homeRebound).raw }));
     for (const b of bodies) {
         if (b.segment.connector !== ";" || b.segment.tokens.some((t) => t.kind !== "word") || b.spelled.some((raw) => POLL_BODY_HARD_REJECT.test(raw))) {