@sema-agent/core 7.44.0 → 7.46.0

package/dist/core/shell-wrapper-table.d.ts

@@ -11,7 +11,10 @@
  * caller asks a person) instead of guessing its arity, because a wrong guess names the option's VALUE
  * or an operand as the program — a phantom run no deny matches. Three adversarial rounds found exactly
  * that shape behind every "unknown is value-less" reading; the closed sets end the family rather than
- * the instance. Growing a row is a data edit with upstream's manual page as its source.
+ * the instance. The table is the PROJECTION of the program read model's rows
+ * ({@link import("./shell-wrapper-projection.js").shellWrapperProjection}) written
+ * out with its literal type: a launcher fact is edited in its row (one table of program facts, read by the binary gate
+ * and by the read station alike), and `test/shell-wrapper-table-projection.test.ts` keeps the two equal.
  *
  * Per row: `valueFlags` — options whose value is the NEXT word (`-u root`; the attached `-uroot` and
  * `--user=root` spellings are one word and need no row); `flags` — value-less options, including those
@@ -56,26 +59,26 @@ export declare const SHELL_WRAPPER_TABLE: {
         readonly commandString: readonly [];
     };
     readonly env: {
-        readonly valueFlags: readonly ["-u", "-C", "-a", "-P", "--unset", "--chdir", "--argv0"];
-        readonly flags: readonly ["-i", "-0", "-v", "--ignore-environment", "--null", "--debug", "--list-signal-handling", "--default-signal", "--ignore-signal", "--block-signal", "--help", "--version"];
-        readonly commandString: readonly ["-S", "--split-string"];
+        readonly valueFlags: readonly ["--argv0", "--chdir", "--unset", "-C", "-P", "-a", "-u"];
+        readonly flags: readonly ["--debug", "--default-signal", "--help", "--ignore-environment", "--ignore-signal", "--list-signal-handling", "--version", "-i", "-v"];
+        readonly commandString: readonly ["--split-string", "-S"];
         readonly bareDash: true;
         readonly assignments: true;
     };
     readonly sudo: {
-        readonly valueFlags: readonly ["-u", "-g", "-U", "-C", "-D", "-h", "-p", "-r", "-R", "-t", "-T", "--user", "--group", "--other-user", "--close-from", "--chdir", "--host", "--prompt", "--role", "--chroot", "--type", "--command-timeout", "-a", "--auth-type"];
-        readonly flags: readonly ["-A", "-b", "-E", "-H", "-i", "-K", "-k", "-l", "-n", "-P", "-S", "-s", "-V", "-v", "--askpass", "--background", "--preserve-env", "--set-home", "--login", "--remove-timestamp", "--reset-timestamp", "--list", "--non-interactive", "--preserve-groups", "--stdin", "--shell", "--version", "--validate", "--bell", "--help"];
+        readonly valueFlags: readonly ["--auth-type", "--chdir", "--chroot", "--close-from", "--command-timeout", "--group", "--host", "--other-user", "--prompt", "--role", "--type", "--user", "-C", "-D", "-R", "-T", "-U", "-a", "-g", "-h", "-p", "-r", "-t", "-u"];
+        readonly flags: readonly ["--askpass", "--background", "--bell", "--help", "--list", "--login", "--non-interactive", "--preserve-env", "--preserve-groups", "--remove-timestamp", "--reset-timestamp", "--set-home", "--shell", "--stdin", "--validate", "--version", "-A", "-E", "-H", "-K", "-P", "-S", "-V", "-b", "-i", "-k", "-l", "-n", "-s", "-v"];
         readonly commandString: readonly [];
         readonly assignments: true;
     };
     readonly doas: {
-        readonly valueFlags: readonly ["-a", "-u", "-C"];
+        readonly valueFlags: readonly ["-C", "-a", "-u"];
         readonly flags: readonly ["-L", "-n", "-s"];
         readonly commandString: readonly [];
     };
     readonly pkexec: {
         readonly valueFlags: readonly ["--user"];
-        readonly flags: readonly ["--disable-internal-agent", "--keep-cwd", "--version", "--help"];
+        readonly flags: readonly ["--disable-internal-agent", "--help", "--keep-cwd", "--version"];
         readonly commandString: readonly [];
     };
     readonly nohup: {
@@ -84,29 +87,29 @@ export declare const SHELL_WRAPPER_TABLE: {
         readonly commandString: readonly [];
     };
     readonly time: {
-        readonly valueFlags: readonly ["-o", "--output", "-f", "--format"];
-        readonly flags: readonly ["-p", "-a", "-v", "-q", "--append", "--portability", "--verbose", "--quiet", "--help", "--version"];
+        readonly valueFlags: readonly ["--format", "--output", "-f", "-o"];
+        readonly flags: readonly ["--append", "--help", "--portability", "--quiet", "--verbose", "--version", "-a", "-p", "-q", "-v"];
         readonly commandString: readonly [];
     };
     readonly nice: {
-        readonly valueFlags: readonly ["-n", "--adjustment"];
+        readonly valueFlags: readonly ["--adjustment", "-n"];
         readonly flags: readonly ["--help", "--version"];
         readonly commandString: readonly [];
     };
     readonly timeout: {
-        readonly valueFlags: readonly ["-k", "-s", "--kill-after", "--signal"];
-        readonly flags: readonly ["-v", "--foreground", "--preserve-status", "--verbose", "--help", "--version"];
+        readonly valueFlags: readonly ["--kill-after", "--signal", "-k", "-s"];
+        readonly flags: readonly ["--foreground", "--help", "--preserve-status", "--verbose", "--version", "-v"];
         readonly commandString: readonly [];
         readonly duration: true;
     };
     readonly stdbuf: {
-        readonly valueFlags: readonly ["-i", "-o", "-e", "--input", "--output", "--error"];
+        readonly valueFlags: readonly ["--error", "--input", "--output", "-e", "-i", "-o"];
         readonly flags: readonly ["--help", "--version"];
         readonly commandString: readonly [];
     };
     readonly xargs: {
-        readonly valueFlags: readonly ["-n", "-L", "-P", "-I", "-d", "-s", "-a", "-E", "--max-args", "--max-procs", "--delimiter", "--max-chars", "--arg-file", "--process-slot-var"];
-        readonly flags: readonly ["-0", "-r", "-t", "-x", "-p", "-o", "--null", "--no-run-if-empty", "--verbose", "--exit", "--interactive", "--open-tty", "--show-limits", "--help", "--version", "--replace", "--eof", "--max-lines"];
+        readonly valueFlags: readonly ["--arg-file", "--delimiter", "--max-args", "--max-chars", "--max-procs", "--process-slot-var", "-E", "-I", "-L", "-P", "-a", "-d", "-n", "-s"];
+        readonly flags: readonly ["--eof", "--exit", "--help", "--interactive", "--max-lines", "--no-run-if-empty", "--null", "--open-tty", "--replace", "--show-limits", "--verbose", "--version", "-0", "-o", "-p", "-r", "-t", "-x"];
         readonly attached: readonly ["-i", "-l"];
         readonly commandString: readonly [];
     };
@@ -117,57 +120,58 @@ export declare const SHELL_WRAPPER_TABLE: {
         readonly viaShell: true;
     };
     readonly ionice: {
-        readonly valueFlags: readonly ["-c", "-n", "-p", "-P", "-u", "--class", "--classdata", "--pid", "--pgid", "--uid"];
-        readonly flags: readonly ["-t", "--ignore", "-h", "--help", "-V", "--version"];
+        readonly valueFlags: readonly ["--class", "--classdata", "--pgid", "--pid", "--uid", "-P", "-c", "-n", "-p", "-u"];
+        readonly flags: readonly ["--help", "--ignore", "--version", "-V", "-h", "-t"];
         readonly commandString: readonly [];
     };
     readonly setsid: {
         readonly valueFlags: readonly [];
-        readonly flags: readonly ["-c", "-f", "-w", "--ctty", "--fork", "--wait", "--help", "--version"];
+        readonly flags: readonly ["--ctty", "--fork", "--help", "--version", "--wait", "-c", "-f", "-w"];
         readonly commandString: readonly [];
     };
     readonly taskset: {
         readonly valueFlags: readonly [];
-        readonly flags: readonly ["-a", "-p", "-c", "--all-tasks", "--pid", "--cpu-list", "--help", "--version"];
+        readonly flags: readonly ["--all-tasks", "--cpu-list", "--help", "--pid", "--version", "-a", "-c", "-p"];
         readonly commandString: readonly [];
         readonly positional: RegExp;
     };
     readonly chrt: {
-        readonly valueFlags: readonly ["-p", "--pid", "-T", "-P", "-D", "--sched-runtime", "--sched-period", "--sched-deadline"];
-        readonly flags: readonly ["-b", "-f", "-i", "-o", "-r", "-d", "-m", "-a", "-R", "-v", "--batch", "--fifo", "--idle", "--other", "--rr", "--deadline", "--max", "--all-tasks", "--reset-on-fork", "--verbose", "--help", "--version"];
+        readonly valueFlags: readonly ["--pid", "--sched-deadline", "--sched-period", "--sched-runtime", "-D", "-P", "-T", "-p"];
+        readonly flags: readonly ["--all-tasks", "--batch", "--deadline", "--fifo", "--help", "--idle", "--max", "--other", "--reset-on-fork", "--rr", "--verbose", "--version", "-R", "-a", "-b", "-d", "-f", "-i", "-m", "-o", "-r", "-v"];
         readonly commandString: readonly [];
         readonly positional: RegExp;
     };
     readonly strace: {
-        readonly valueFlags: readonly ["-e", "-o", "-p", "-s", "-E", "-P", "-S", "-a", "-b", "-I", "-u", "-X", "-O", "-U", "--output", "--trace", "--expr", "--attach", "--string-limit", "--env", "--trace-path", "--columns", "--user", "--interruptible", "--detach-on", "--const-print-style", "--summary-sort-by", "--summary-syscall-overhead", "--summary-columns"];
-        readonly flags: readonly ["-f", "-ff", "-c", "-C", "-d", "-D", "-h", "-i", "-k", "-q", "-qq", "-r", "-t", "-tt", "-ttt", "-T", "-v", "-V", "-w", "-x", "-xx", "-y", "-yy", "-z", "-Z", "-F", "--follow-forks", "--summary-only", "--summary", "--debug", "--help", "--version"];
+        readonly valueFlags: readonly ["--attach", "--columns", "--const-print-style", "--detach-on", "--env", "--expr", "--interruptible", "--output", "--string-limit", "--summary-columns", "--summary-sort-by", "--summary-syscall-overhead", "--trace", "--trace-path", "--user", "-E", "-I", "-O", "-P", "-S", "-U", "-X", "-a", "-b", "-e", "-o", "-p", "-s", "-u"];
+        readonly flags: readonly ["--debug", "--follow-forks", "--help", "--summary", "--summary-only", "--version", "-C", "-D", "-F", "-T", "-V", "-Z", "-c", "-d", "-f", "-h", "-i", "-k", "-q", "-r", "-t", "-v", "-w", "-x", "-y", "-z"];
         readonly commandString: readonly [];
     };
     readonly ltrace: {
-        readonly valueFlags: readonly ["-a", "-A", "-e", "-l", "-n", "-o", "-p", "-s", "-u", "-x", "-D", "-F", "--align", "--config", "--debug", "--indent", "--library", "--output", "--string-max", "-w", "--where"];
-        readonly flags: readonly ["-c", "-C", "-f", "-i", "-L", "-r", "-S", "-t", "-tt", "-ttt", "-T", "-V", "--demangle", "--help", "--version"];
+        readonly valueFlags: readonly ["--align", "--config", "--debug", "--indent", "--library", "--output", "--string-max", "--where", "-A", "-D", "-F", "-a", "-e", "-l", "-n", "-o", "-p", "-s", "-u", "-w", "-x"];
+        readonly flags: readonly ["--demangle", "--help", "--version", "-C", "-L", "-S", "-T", "-V", "-c", "-f", "-i", "-r", "-t"];
         readonly commandString: readonly [];
     };
     readonly flock: {
-        readonly valueFlags: readonly ["-w", "-E", "--timeout", "--wait", "--conflict-exit-code"];
-        readonly flags: readonly ["-s", "-x", "-u", "-n", "-o", "-F", "--shared", "--exclusive", "--unlock", "--nonblock", "--nb", "--close", "--no-fork", "--verbose", "--help", "--version"];
-        readonly commandString: readonly ["-c", "--command"];
+        readonly valueFlags: readonly ["--conflict-exit-code", "--timeout", "--wait", "-E", "-w"];
+        readonly flags: readonly ["--close", "--exclusive", "--help", "--nb", "--no-fork", "--nonblock", "--shared", "--unlock", "--verbose", "--version", "-F", "-n", "-o", "-s", "-u", "-x"];
+        readonly commandString: readonly ["--command", "-c"];
         readonly positional: RegExp;
     };
     readonly script: {
         readonly valueFlags: readonly [];
         readonly flags: readonly [];
-        readonly commandString: readonly ["-c", "--command"];
+        readonly commandString: readonly ["--command", "-c"];
         readonly viaShell: true;
     };
     readonly unshare: {
-        readonly valueFlags: readonly ["-R", "-w", "-S", "-G", "--setuid", "--setgid", "--root", "--wd", "--propagation", "--setgroups", "--monotonic", "--boottime", "--map-user", "--map-group"];
-        readonly flags: readonly ["-m", "-u", "-i", "-n", "-p", "-U", "-C", "-T", "-f", "-r", "-c", "--mount", "--uts", "--ipc", "--net", "--pid", "--user", "--cgroup", "--time", "--fork", "--map-root-user", "--map-current-user", "--kill-child", "--mount-proc", "--keep-caps", "--help", "--version"];
+        readonly valueFlags: readonly ["--boottime", "--map-group", "--map-user", "--monotonic", "--propagation", "--root", "--setgid", "--setgroups", "--setuid", "--wd", "-G", "-R", "-S", "-w"];
+        readonly flags: readonly ["--cgroup", "--fork", "--help", "--ipc", "--keep-caps", "--kill-child", "--map-current-user", "--map-root-user", "--mount", "--mount-proc", "--net", "--pid", "--time", "--user", "--uts", "--version", "-C", "-T", "-U", "-c", "-f", "-i", "-m", "-n", "-p", "-r", "-u"];
         readonly commandString: readonly [];
     };
     readonly nsenter: {
-        readonly valueFlags: readonly ["-t", "-S", "-G", "--target", "--setuid", "--setgid"];
-        readonly flags: readonly ["-a", "-m", "-u", "-i", "-n", "-p", "-U", "-C", "-T", "-r", "-w", "-F", "-Z", "--all", "--mount", "--uts", "--ipc", "--net", "--pid", "--user", "--cgroup", "--time", "--root", "--wd", "--no-fork", "--preserve-credentials", "--help", "--version"];
+        readonly valueFlags: readonly ["--setgid", "--setuid", "--target", "-G", "-S", "-t"];
+        readonly flags: readonly ["--all", "--cgroup", "--help", "--ipc", "--mount", "--net", "--no-fork", "--pid", "--preserve-credentials", "--root", "--time", "--user", "--uts", "--version", "--wd", "-C", "-F", "-T", "-U", "-Z", "-a", "-i", "-m", "-n", "-p", "-u"];
+        readonly attached: readonly ["-r", "-w"];
         readonly commandString: readonly [];
     };
     readonly eval: {
@@ -266,6 +270,112 @@ export declare const SHELL_WRAPPER_TABLE: {
         readonly commandString: readonly [];
         readonly executes: readonly ["-C", "-F"];
     };
+    readonly busybox: {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+    };
+    readonly su: {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+        readonly viaShell: true;
+    };
+    readonly runuser: {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+        readonly viaShell: true;
+    };
+    readonly chroot: {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+        readonly positional: RegExp;
+    };
+    readonly setpriv: {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+    };
+    readonly numactl: {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+    };
+    readonly prlimit: {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+    };
+    readonly "systemd-run": {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+    };
+    readonly valgrind: {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+    };
+    readonly firejail: {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+    };
+    readonly bwrap: {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+    };
+    readonly ash: {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+        readonly viaShell: true;
+    };
+    readonly mksh: {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+        readonly viaShell: true;
+    };
+    readonly yash: {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+        readonly viaShell: true;
+    };
+    readonly pdksh: {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+        readonly viaShell: true;
+    };
+    readonly parallel: {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+        readonly viaShell: true;
+    };
+    readonly alias: {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+        readonly viaShell: true;
+    };
+    readonly mapfile: {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+        readonly executes: readonly ["-C"];
+    };
+    readonly readarray: {
+        readonly valueFlags: readonly [];
+        readonly flags: readonly [];
+        readonly commandString: readonly [];
+        readonly executes: readonly ["-C"];
+    };
 };
 export type ShellWrapperName = keyof typeof SHELL_WRAPPER_TABLE;
 /** The shape of one row (see the table's contract). */

package/dist/core/shell-wrapper-table.js

@@ -1,30 +1,31 @@
+import { declaresOption, programRows } from "../tools/fs/program-read-model.js";
 export const SHELL_WRAPPER_TABLE = {
     command: { valueFlags: [], flags: ["-p"], commandString: [] },
     builtin: { valueFlags: [], flags: [], commandString: [] },
     noglob: { valueFlags: [], flags: [], commandString: [] },
     nocorrect: { valueFlags: [], flags: [], commandString: [] },
     exec: { valueFlags: ["-a"], flags: ["-c", "-l"], commandString: [] },
-    env: { valueFlags: ["-u", "-C", "-a", "-P", "--unset", "--chdir", "--argv0"], flags: ["-i", "-0", "-v", "--ignore-environment", "--null", "--debug", "--list-signal-handling", "--default-signal", "--ignore-signal", "--block-signal", "--help", "--version"], commandString: ["-S", "--split-string"], bareDash: true, assignments: true },
-    sudo: { valueFlags: ["-u", "-g", "-U", "-C", "-D", "-h", "-p", "-r", "-R", "-t", "-T", "--user", "--group", "--other-user", "--close-from", "--chdir", "--host", "--prompt", "--role", "--chroot", "--type", "--command-timeout", "-a", "--auth-type"], flags: ["-A", "-b", "-E", "-H", "-i", "-K", "-k", "-l", "-n", "-P", "-S", "-s", "-V", "-v", "--askpass", "--background", "--preserve-env", "--set-home", "--login", "--remove-timestamp", "--reset-timestamp", "--list", "--non-interactive", "--preserve-groups", "--stdin", "--shell", "--version", "--validate", "--bell", "--help"], commandString: [], assignments: true },
-    doas: { valueFlags: ["-a", "-u", "-C"], flags: ["-L", "-n", "-s"], commandString: [] },
-    pkexec: { valueFlags: ["--user"], flags: ["--disable-internal-agent", "--keep-cwd", "--version", "--help"], commandString: [] },
+    env: { valueFlags: ["--argv0", "--chdir", "--unset", "-C", "-P", "-a", "-u"], flags: ["--debug", "--default-signal", "--help", "--ignore-environment", "--ignore-signal", "--list-signal-handling", "--version", "-i", "-v"], commandString: ["--split-string", "-S"], bareDash: true, assignments: true },
+    sudo: { valueFlags: ["--auth-type", "--chdir", "--chroot", "--close-from", "--command-timeout", "--group", "--host", "--other-user", "--prompt", "--role", "--type", "--user", "-C", "-D", "-R", "-T", "-U", "-a", "-g", "-h", "-p", "-r", "-t", "-u"], flags: ["--askpass", "--background", "--bell", "--help", "--list", "--login", "--non-interactive", "--preserve-env", "--preserve-groups", "--remove-timestamp", "--reset-timestamp", "--set-home", "--shell", "--stdin", "--validate", "--version", "-A", "-E", "-H", "-K", "-P", "-S", "-V", "-b", "-i", "-k", "-l", "-n", "-s", "-v"], commandString: [], assignments: true },
+    doas: { valueFlags: ["-C", "-a", "-u"], flags: ["-L", "-n", "-s"], commandString: [] },
+    pkexec: { valueFlags: ["--user"], flags: ["--disable-internal-agent", "--help", "--keep-cwd", "--version"], commandString: [] },
     nohup: { valueFlags: [], flags: ["--help", "--version"], commandString: [] },
-    time: { valueFlags: ["-o", "--output", "-f", "--format"], flags: ["-p", "-a", "-v", "-q", "--append", "--portability", "--verbose", "--quiet", "--help", "--version"], commandString: [] },
-    nice: { valueFlags: ["-n", "--adjustment"], flags: ["--help", "--version"], commandString: [] },
-    timeout: { valueFlags: ["-k", "-s", "--kill-after", "--signal"], flags: ["-v", "--foreground", "--preserve-status", "--verbose", "--help", "--version"], commandString: [], duration: true },
-    stdbuf: { valueFlags: ["-i", "-o", "-e", "--input", "--output", "--error"], flags: ["--help", "--version"], commandString: [] },
-    xargs: { valueFlags: ["-n", "-L", "-P", "-I", "-d", "-s", "-a", "-E", "--max-args", "--max-procs", "--delimiter", "--max-chars", "--arg-file", "--process-slot-var"], flags: ["-0", "-r", "-t", "-x", "-p", "-o", "--null", "--no-run-if-empty", "--verbose", "--exit", "--interactive", "--open-tty", "--show-limits", "--help", "--version", "--replace", "--eof", "--max-lines"], attached: ["-i", "-l"], commandString: [] },
+    time: { valueFlags: ["--format", "--output", "-f", "-o"], flags: ["--append", "--help", "--portability", "--quiet", "--verbose", "--version", "-a", "-p", "-q", "-v"], commandString: [] },
+    nice: { valueFlags: ["--adjustment", "-n"], flags: ["--help", "--version"], commandString: [] },
+    timeout: { valueFlags: ["--kill-after", "--signal", "-k", "-s"], flags: ["--foreground", "--help", "--preserve-status", "--verbose", "--version", "-v"], commandString: [], duration: true },
+    stdbuf: { valueFlags: ["--error", "--input", "--output", "-e", "-i", "-o"], flags: ["--help", "--version"], commandString: [] },
+    xargs: { valueFlags: ["--arg-file", "--delimiter", "--max-args", "--max-chars", "--max-procs", "--process-slot-var", "-E", "-I", "-L", "-P", "-a", "-d", "-n", "-s"], flags: ["--eof", "--exit", "--help", "--interactive", "--max-lines", "--no-run-if-empty", "--null", "--open-tty", "--replace", "--show-limits", "--verbose", "--version", "-0", "-o", "-p", "-r", "-t", "-x"], attached: ["-i", "-l"], commandString: [] },
     watch: { valueFlags: [], flags: [], commandString: [], viaShell: true },
-    ionice: { valueFlags: ["-c", "-n", "-p", "-P", "-u", "--class", "--classdata", "--pid", "--pgid", "--uid"], flags: ["-t", "--ignore", "-h", "--help", "-V", "--version"], commandString: [] },
-    setsid: { valueFlags: [], flags: ["-c", "-f", "-w", "--ctty", "--fork", "--wait", "--help", "--version"], commandString: [] },
-    taskset: { valueFlags: [], flags: ["-a", "-p", "-c", "--all-tasks", "--pid", "--cpu-list", "--help", "--version"], commandString: [], positional: /^(?:0x)?[\da-f]+$|^[\d,:-]+$/i },
-    chrt: { valueFlags: ["-p", "--pid", "-T", "-P", "-D", "--sched-runtime", "--sched-period", "--sched-deadline"], flags: ["-b", "-f", "-i", "-o", "-r", "-d", "-m", "-a", "-R", "-v", "--batch", "--fifo", "--idle", "--other", "--rr", "--deadline", "--max", "--all-tasks", "--reset-on-fork", "--verbose", "--help", "--version"], commandString: [], positional: /^\d+$/ },
-    strace: { valueFlags: ["-e", "-o", "-p", "-s", "-E", "-P", "-S", "-a", "-b", "-I", "-u", "-X", "-O", "-U", "--output", "--trace", "--expr", "--attach", "--string-limit", "--env", "--trace-path", "--columns", "--user", "--interruptible", "--detach-on", "--const-print-style", "--summary-sort-by", "--summary-syscall-overhead", "--summary-columns"], flags: ["-f", "-ff", "-c", "-C", "-d", "-D", "-h", "-i", "-k", "-q", "-qq", "-r", "-t", "-tt", "-ttt", "-T", "-v", "-V", "-w", "-x", "-xx", "-y", "-yy", "-z", "-Z", "-F", "--follow-forks", "--summary-only", "--summary", "--debug", "--help", "--version"], commandString: [] },
-    ltrace: { valueFlags: ["-a", "-A", "-e", "-l", "-n", "-o", "-p", "-s", "-u", "-x", "-D", "-F", "--align", "--config", "--debug", "--indent", "--library", "--output", "--string-max", "-w", "--where"], flags: ["-c", "-C", "-f", "-i", "-L", "-r", "-S", "-t", "-tt", "-ttt", "-T", "-V", "--demangle", "--help", "--version"], commandString: [] },
-    flock: { valueFlags: ["-w", "-E", "--timeout", "--wait", "--conflict-exit-code"], flags: ["-s", "-x", "-u", "-n", "-o", "-F", "--shared", "--exclusive", "--unlock", "--nonblock", "--nb", "--close", "--no-fork", "--verbose", "--help", "--version"], commandString: ["-c", "--command"], positional: /^/ },
-    script: { valueFlags: [], flags: [], commandString: ["-c", "--command"], viaShell: true },
-    unshare: { valueFlags: ["-R", "-w", "-S", "-G", "--setuid", "--setgid", "--root", "--wd", "--propagation", "--setgroups", "--monotonic", "--boottime", "--map-user", "--map-group"], flags: ["-m", "-u", "-i", "-n", "-p", "-U", "-C", "-T", "-f", "-r", "-c", "--mount", "--uts", "--ipc", "--net", "--pid", "--user", "--cgroup", "--time", "--fork", "--map-root-user", "--map-current-user", "--kill-child", "--mount-proc", "--keep-caps", "--help", "--version"], commandString: [] },
-    nsenter: { valueFlags: ["-t", "-S", "-G", "--target", "--setuid", "--setgid"], flags: ["-a", "-m", "-u", "-i", "-n", "-p", "-U", "-C", "-T", "-r", "-w", "-F", "-Z", "--all", "--mount", "--uts", "--ipc", "--net", "--pid", "--user", "--cgroup", "--time", "--root", "--wd", "--no-fork", "--preserve-credentials", "--help", "--version"], commandString: [] },
+    ionice: { valueFlags: ["--class", "--classdata", "--pgid", "--pid", "--uid", "-P", "-c", "-n", "-p", "-u"], flags: ["--help", "--ignore", "--version", "-V", "-h", "-t"], commandString: [] },
+    setsid: { valueFlags: [], flags: ["--ctty", "--fork", "--help", "--version", "--wait", "-c", "-f", "-w"], commandString: [] },
+    taskset: { valueFlags: [], flags: ["--all-tasks", "--cpu-list", "--help", "--pid", "--version", "-a", "-c", "-p"], commandString: [], positional: /^(?:0x)?[\da-f]+$|^[\d,:-]+$/i },
+    chrt: { valueFlags: ["--pid", "--sched-deadline", "--sched-period", "--sched-runtime", "-D", "-P", "-T", "-p"], flags: ["--all-tasks", "--batch", "--deadline", "--fifo", "--help", "--idle", "--max", "--other", "--reset-on-fork", "--rr", "--verbose", "--version", "-R", "-a", "-b", "-d", "-f", "-i", "-m", "-o", "-r", "-v"], commandString: [], positional: /^\d+$/ },
+    strace: { valueFlags: ["--attach", "--columns", "--const-print-style", "--detach-on", "--env", "--expr", "--interruptible", "--output", "--string-limit", "--summary-columns", "--summary-sort-by", "--summary-syscall-overhead", "--trace", "--trace-path", "--user", "-E", "-I", "-O", "-P", "-S", "-U", "-X", "-a", "-b", "-e", "-o", "-p", "-s", "-u"], flags: ["--debug", "--follow-forks", "--help", "--summary", "--summary-only", "--version", "-C", "-D", "-F", "-T", "-V", "-Z", "-c", "-d", "-f", "-h", "-i", "-k", "-q", "-r", "-t", "-v", "-w", "-x", "-y", "-z"], commandString: [] },
+    ltrace: { valueFlags: ["--align", "--config", "--debug", "--indent", "--library", "--output", "--string-max", "--where", "-A", "-D", "-F", "-a", "-e", "-l", "-n", "-o", "-p", "-s", "-u", "-w", "-x"], flags: ["--demangle", "--help", "--version", "-C", "-L", "-S", "-T", "-V", "-c", "-f", "-i", "-r", "-t"], commandString: [] },
+    flock: { valueFlags: ["--conflict-exit-code", "--timeout", "--wait", "-E", "-w"], flags: ["--close", "--exclusive", "--help", "--nb", "--no-fork", "--nonblock", "--shared", "--unlock", "--verbose", "--version", "-F", "-n", "-o", "-s", "-u", "-x"], commandString: ["--command", "-c"], positional: /^/ },
+    script: { valueFlags: [], flags: [], commandString: ["--command", "-c"], viaShell: true },
+    unshare: { valueFlags: ["--boottime", "--map-group", "--map-user", "--monotonic", "--propagation", "--root", "--setgid", "--setgroups", "--setuid", "--wd", "-G", "-R", "-S", "-w"], flags: ["--cgroup", "--fork", "--help", "--ipc", "--keep-caps", "--kill-child", "--map-current-user", "--map-root-user", "--mount", "--mount-proc", "--net", "--pid", "--time", "--user", "--uts", "--version", "-C", "-T", "-U", "-c", "-f", "-i", "-m", "-n", "-p", "-r", "-u"], commandString: [] },
+    nsenter: { valueFlags: ["--setgid", "--setuid", "--target", "-G", "-S", "-t"], flags: ["--all", "--cgroup", "--help", "--ipc", "--mount", "--net", "--no-fork", "--pid", "--preserve-credentials", "--root", "--time", "--user", "--uts", "--version", "--wd", "-C", "-F", "-T", "-U", "-Z", "-a", "-i", "-m", "-n", "-p", "-u"], attached: ["-r", "-w"], commandString: [] },
     eval: { valueFlags: [], flags: [], commandString: [], viaShell: true },
     source: { valueFlags: [], flags: [], commandString: [], viaShell: true },
     ".": { valueFlags: [], flags: [], commandString: [], viaShell: true },
@@ -41,8 +42,27 @@ export const SHELL_WRAPPER_TABLE = {
     find: { valueFlags: [], flags: [], commandString: [], executes: ["-exec", "-execdir", "-ok", "-okdir"] },
     compgen: { valueFlags: [], flags: [], commandString: [], executes: ["-C", "-F"] },
     complete: { valueFlags: [], flags: [], commandString: [], executes: ["-C", "-F"] },
+    busybox: { valueFlags: [], flags: [], commandString: [] },
+    su: { valueFlags: [], flags: [], commandString: [], viaShell: true },
+    runuser: { valueFlags: [], flags: [], commandString: [], viaShell: true },
+    chroot: { valueFlags: [], flags: [], commandString: [], positional: /^/ },
+    setpriv: { valueFlags: [], flags: [], commandString: [] },
+    numactl: { valueFlags: [], flags: [], commandString: [] },
+    prlimit: { valueFlags: [], flags: [], commandString: [] },
+    "systemd-run": { valueFlags: [], flags: [], commandString: [] },
+    valgrind: { valueFlags: [], flags: [], commandString: [] },
+    firejail: { valueFlags: [], flags: [], commandString: [] },
+    bwrap: { valueFlags: [], flags: [], commandString: [] },
+    ash: { valueFlags: [], flags: [], commandString: [], viaShell: true },
+    mksh: { valueFlags: [], flags: [], commandString: [], viaShell: true },
+    yash: { valueFlags: [], flags: [], commandString: [], viaShell: true },
+    pdksh: { valueFlags: [], flags: [], commandString: [], viaShell: true },
+    parallel: { valueFlags: [], flags: [], commandString: [], viaShell: true },
+    alias: { valueFlags: [], flags: [], commandString: [], viaShell: true },
+    mapfile: { valueFlags: [], flags: [], commandString: [], executes: ["-C"] },
+    readarray: { valueFlags: [], flags: [], commandString: [], executes: ["-C"] },
 };
-export const VARIABLE_OPERAND_BUILTINS = new Set(["printf", "unset", "read", "mapfile", "readarray", "declare", "typeset", "local", "export", "readonly", "test", "[", "[["]);
+export const VARIABLE_OPERAND_BUILTINS = new Set(programRows().filter((row) => row.operands?.rest?.kind === "binds-name" || declaresOption(row, (spec) => spec.value?.kind === "binds-name")).map((row) => row.key));
 export function evaluatesOperand(run) {
     if (!VARIABLE_OPERAND_BUILTINS.has(run[0]?.text ?? ""))
         return false;

package/dist/core/skill-grant.d.ts

@@ -76,8 +76,16 @@ export declare function parkedSkillApprovalRefusal(row: {
     readonly args: unknown;
     readonly boundGrantDigest?: string;
 }, args: unknown, skills: readonly SkillGrantSource[], skillToolName: string, site?: "claim" | "execution"): string | undefined;
-/** A resume's skills read ONCE: each definition copied with its two lists, so the parked Skill approval's binding and the
- *  resumed leg's prepare read one value — a later edit to the caller's own objects or arrays reaches neither. */
+/**
+ * A skill's table (`allowed-tools` / `disallowed-tools`) READ ONCE, the one reading every later reader takes instead of the host's
+ * value: absent (`undefined`, or `null` — a frontmatter's empty key) is no table; a list is its dense copy (by index, no iterator
+ * of the host's runs; a member that is not a string stays as it is); a value that is not a list, or a list whose read throws, is
+ * ONE entry that reads as nothing ({@link nonListValueLabel}), so each table applies the law it already has to an entry that reads
+ * as nothing — a deny table keeps its Skill from activating, an allow table is announced and grants nothing. A string is not spread.
+ */
+export declare function readSkillTable(value: unknown): string[] | undefined;
+/** A resume's skills read ONCE: each definition copied with its two tables ({@link readSkillTable}), so the parked Skill approval's
+ *  binding and the resumed leg's prepare read one value — a later edit to the caller's own objects or arrays reaches neither. */
 export declare function detachSkillLists<T extends SkillGrantSource>(skills: readonly T[]): T[];
 /** Does this skill declare a list (either, non-empty)? The one test of "the Skill card is asked for this skill". */
 export declare function declaresSkillLists(skill: Pick<SkillGrantSource, "allowedTools" | "disallowedTools">): boolean;

package/dist/core/skill-grant.js

@@ -3,7 +3,8 @@ import { parsePermissionRule } from "./permission-rules.js";
 import { mountedToolPermissionSeat } from "./mode-policy.js";
 import { inlineUntrusted } from "./untrusted-text.js";
 import { boundInputHashOf } from "./canonical-json.js";
-import { allowingRows, autoStripped, compileAllowEntry, compileAllowList, inertEntryPhrase, judgeAllowEntries } from "./allow-entry.js";
+import { readToolNameList } from "../agents/tool-filter.js";
+import { allowingRows, autoStripped, compileAllowEntry, compileAllowList, inertEntryPhrase, judgeAllowEntries, nonListValueLabel, nonStringMemberLabel, renderListEntry } from "./allow-entry.js";
 export const SKILL_GRANT_ORIGINS = Object.freeze(["model", "user", "inherited"]);
 const FROZEN_SKILL_GRANT_ORIGINS = new Set(["model", "inherited"]);
 export function skillNamedBy(args, skills) {
@@ -12,6 +13,8 @@ export function skillNamedBy(args, skills) {
 }
 function skillGrantBinding(skill) {
     const canonical = (entries) => [...new Set((entries ?? []).map((e) => {
+            if (typeof e !== "string")
+                return nonStringMemberLabel(e);
             const p = parsePermissionRule(e);
             return p.ruleContent === undefined ? p.toolName : `${p.toolName}(${p.ruleContent})`;
         }))].sort();
@@ -44,8 +47,21 @@ export function parkedSkillApprovalRefusal(row, args, skills, skillToolName, sit
         ? `${why} — refusing pre-CAS (nothing ran; the checkpoint stays pending). Decide this checkpoint as deny and re-activate it: the new card shows the current lists.`
         : `The approved Skill call was not executed: ${why}. This approval is spent — to use "${chosen}", have the model activate it again: the new card shows its lists.`;
 }
+export function readSkillTable(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    const read = readToolNameList(value);
+    return read.kind === "entries" ? read.entries : [nonListValueLabel(read)];
+}
 export function detachSkillLists(skills) {
-    return skills.map((s) => (typeof s === "object" && s !== null ? { ...s, ...(Array.isArray(s.allowedTools) ? { allowedTools: [...s.allowedTools] } : {}), ...(Array.isArray(s.disallowedTools) ? { disallowedTools: [...s.disallowedTools] } : {}) } : s));
+    return skills.map((s) => {
+        if (typeof s !== "object" || s === null)
+            return s;
+        const { allowedTools: rawAllowed, disallowedTools: rawDenied, ...rest } = s;
+        const allowedTools = readSkillTable(rawAllowed);
+        const disallowedTools = readSkillTable(rawDenied);
+        return { ...rest, ...(allowedTools !== undefined ? { allowedTools } : {}), ...(disallowedTools !== undefined ? { disallowedTools } : {}) };
+    });
 }
 export function declaresSkillLists(skill) {
     return (skill.allowedTools?.length ?? 0) > 0 || (skill.disallowedTools?.length ?? 0) > 0;
@@ -74,7 +90,7 @@ export function skillDenyDecision(hit) {
         action: "deny",
         message: hit.readsAsNothing !== undefined
             ? skillDenyUnreadable(hit.skill, hit.readsAsNothing, "activation").message
-            : `the active skill "${inlineUntrusted(hit.skill, 120)}" lists this tool in disallowed-tools (${hit.entries.map((e) => inlineUntrusted(e, 200)).join(", ")}) — refused for the rest of this run`,
+            : `the active skill "${inlineUntrusted(hit.skill, 120)}" lists this tool in disallowed-tools (${hit.entries.map(renderListEntry).join(", ")}) — refused for the rest of this run`,
         decisionReason: "skill",
     };
 }
@@ -88,7 +104,7 @@ export function skillRowRefusal(lane, req) {
 export function skillAllowDecision(hit, updatedInput) {
     return {
         action: "allow",
-        message: `the active skill "${inlineUntrusted(hit.skill, 120)}" lists this tool in allowed-tools (${hit.entries.map((e) => inlineUntrusted(e, 200)).join(", ")})`,
+        message: `the active skill "${inlineUntrusted(hit.skill, 120)}" lists this tool in allowed-tools (${hit.entries.map(renderListEntry).join(", ")})`,
         decisionReason: "skill",
         ...(updatedInput !== undefined ? { updatedInput } : {}),
     };

package/dist/core/synthetic-read-verdict.d.ts

@@ -50,6 +50,7 @@
  * visibility probe from a model's call.
  */
 import type { ToolCallRequest, ToolCallFace, ToolPolicy } from "./tool-policy.js";
+import type { CallTargetStamp } from "./effective-path-target.js";
 import { type SkillGrantLane } from "./skill-grant.js";
 import type { OrgGateVerdict, PersistedRuleAnswer } from "./hooks.js";
 /** The layers the judge consults, as named in its verdicts. */
@@ -81,6 +82,8 @@ export interface SyntheticReadLayers {
     orgRuleLane?: {
         adjudicate: (req: ToolCallRequest) => Promise<OrgGateVerdict>;
     };
+    /** The leg's target-reading stamp: the probe's request carries a reading of its target, as the live gate's does. */
+    stampCallTarget?: CallTargetStamp;
     /** The run's signal, for the engine's own layers. */
     signal?: AbortSignal;
 }

package/dist/core/synthetic-read-verdict.js

@@ -15,13 +15,15 @@ export function createSyntheticReadJudge(layers) {
     return async (call, face, budget) => {
         const deadlineAt = budget?.deadlineAt ?? Date.now() + ORG_ADJUDICATION_TIMEOUT_MS;
         const left = () => Math.max(0, Math.min(ORG_ADJUDICATION_TIMEOUT_MS, deadlineAt - Date.now()));
-        const req = {
+        const probe = {
             toolName: "Read",
             args: { file_path: call.file_path, ...(call.offset !== undefined ? { offset: call.offset } : {}), ...(call.limit !== undefined ? { limit: call.limit } : {}) },
             toolCallId: syntheticReadProbeId(face),
             ...(call.cwd !== undefined ? { cwd: call.cwd } : {}),
             ...(call.face !== undefined ? { face: call.face } : {}),
         };
+        const stamped = layers.stampCallTarget?.(probe, layers.signal);
+        const req = stamped !== undefined ? await stamped : probe;
         let unanswered;
         const cannot = (layer, cause, reason) => {
             unanswered ??= { verdict: "unanswerable", layer, cause, reason };

package/dist/core/task-notification.d.ts

@@ -32,10 +32,21 @@ export declare const SYSTEM_INJECTION_PRIORITIES: readonly SystemInjectionPriori
 export declare function isSystemInjectionPriority(value: unknown): value is SystemInjectionPriority;
 /** The ONE reading of a steer's priority: a parked row or an accepted input that carries none means `"next"`
  *  (the default the live admission has always applied) — so a retry that spells the default and a row parked
- *  without it are the same instruction, whichever side normalized. */
+ *  without it are the same instruction, whichever side normalized. A tier outside the closed set throws
+ *  (`steering.invalid_content`, the sentence names the set); `null` is such a tier, not an absent one. */
 export declare function steerPriorityOf(x: {
     readonly priority?: SystemInjectionPriority;
 }): SystemInjectionPriority;
+/** The two queues a person's input rides on a live run: the `steer` lane (the running turn's next boundary) and the
+ *  `followUp` lane (the run's would-otherwise-stop seat). They are also the two families of the stranded-input account — an
+ *  input's account is the one of the lane it was queued on (`USER_INPUT_UNDRAINED_FAMILIES`). */
+export type UserInputLane = "steer" | "followUp";
+/** The ONE reading of "which lane carries this tier": `"later"` rides the follow-up lane (never folded into work in
+ *  progress), `"next"` and `"now"` ride the steer lane (`"now"` additionally cuts the running turn). Both injection
+ *  seats — the steer verb and the notification lane — branch on it. A parked row that carries no tier reads through
+ *  {@link steerPriorityOf} first: `injectionLaneOf(steerPriorityOf(row))`. A tier outside the closed set throws
+ *  (`steering.invalid_content`, the same check and sentence as {@link steerPriorityOf}). */
+export declare function injectionLaneOf(priority: SystemInjectionPriority): UserInputLane;
 export interface TaskNotificationPayload {
     task_id: string;
     /** design/144 §2: `"external"` is CORE-MINTED ONLY — `TaskStream.notify()` casts it onto every

package/dist/core/task-notification.js

@@ -10,8 +10,20 @@ export const SYSTEM_INJECTION_PRIORITIES = ["now", "next", "later"];
 export function isSystemInjectionPriority(value) {
     return typeof value === "string" && SYSTEM_INJECTION_PRIORITIES.includes(value);
 }
+function requireSystemInjectionPriority(value) {
+    if (isSystemInjectionPriority(value))
+        return value;
+    const shown = typeof value === "string" ? JSON.stringify(value.length > 24 ? `${value.slice(0, 24)}…` : value) : value === null ? "null" : typeof value;
+    const refusal = new Error(`a steer priority must be one of ${SYSTEM_INJECTION_PRIORITIES.join("/")}, got ${shown}`);
+    refusal.code = "steering.invalid_content";
+    throw refusal;
+}
 export function steerPriorityOf(x) {
-    return x.priority ?? "next";
+    return x.priority === undefined ? "next" : requireSystemInjectionPriority(x.priority);
+}
+const LANE_OF_PRIORITY = { now: "steer", next: "steer", later: "followUp" };
+export function injectionLaneOf(priority) {
+    return LANE_OF_PRIORITY[requireSystemInjectionPriority(priority)];
 }
 const TASK_NOTIFICATION_TAGS = [
     "task-notification",