@sema-agent/core 7.45.0 → 7.47.0

package/dist/core/runner/resume-checkpoint-screen.js

@@ -1,8 +1,10 @@
 import { persistedReadDenyEntryProblem } from "../../tools/fs/read-deny.js";
+import { isAbsolutePathForm } from "../../tools/fs/safety.js";
 import { isAskOrigin } from "../ask-origin.js";
 import { CHECKPOINT_FEATURES, CheckpointError, checkpointVersionOf, MAX_SUPPORTED_CHECKPOINT_VERSION, realApprovalOrgFact } from "../checkpoint-store.js";
 import { constraintChainDigest, constraintChainEntryOfSuppliedLayer } from "../tool-policy.js";
 import { readFrozenSkillGrants } from "../skill-grant.js";
+import { chainInstallationGaps, chainInstallationRefusal } from "./child-tree.js";
 export function resumeCheckpointScreen(input) {
     const { cp, resumeSignal, internals, runner } = input;
     const { realApproval: realApprovalRow, face: faceRow, f012: f012Row } = CHECKPOINT_FEATURES;
@@ -49,6 +51,11 @@ export function resumeCheckpointScreen(input) {
         }
         if (readFrozenSkillGrants(cp.state.skillGrants) === undefined)
             throw new CheckpointError("checkpoint.invalid_outcome", "this checkpoint carries a skill-grant section (state.skillGrants) that does not read as grant rows under this engine — a damaged section, or a row an earlier release wrote whose entry this release reads as nothing (an entry with a surrounding space, say) — refusing to resume without the grant rows and refusals it carries; the checkpoint stays pending: finish it on a worker of the release that parked it, or expire it", { reason: "skill_grants_damaged" });
+        for (const field of ["handsRoot", "handsHome", "handsCwd"]) {
+            const coordinate = cp.state[field];
+            if (coordinate !== undefined && (typeof coordinate !== "string" || !isAbsolutePathForm(coordinate)))
+                throw new CheckpointError("checkpoint.invalid_outcome", `this checkpoint's state.${field} is not an absolute path — refusing to resume a row whose hands' coordinates are damaged (corruption guard), the checkpoint stays pending`, { reason: "hands_coordinates_damaged" });
+        }
     }
     if (realApprovalOrgFact(preCasGateBit) !== undefined && runner.deps.permissionRuleStore?.partitions.org !== true) {
         throw new CheckpointError("checkpoint.unsupported_version", `this checkpoint's approval was minted under organization governance (org ${String(realApprovalOrgFact(preCasGateBit))}, routed as ${String(preCasGateBit?.origin)}) and this worker has no org adjudication wiring (its permission-rule store carries no org partition) — a governed approval may only be redeemed where governance can be enforced; the checkpoint stays pending, resume it on an org-wired worker`, { reason: "governed_unwired" });
@@ -106,6 +113,12 @@ export function resumeCheckpointScreen(input) {
             }
         }
     }
+    const resupplied = (internals?.inheritedGate?.parentConstraints ?? []).map((pc) => pc.policy);
+    if (resupplied.length > 0) {
+        const gaps = chainInstallationGaps(resupplied, { live: internals?.inheritedGate?.pathRuleInstallations, seed: cp.state.inheritedGate?.pathRuleInstallations }, (p) => p);
+        if (gaps.length > 0)
+            throw chainInstallationRefusal(gaps, true);
+    }
     const resumeInternals = internals?.inheritedGate?.parentConstraints !== undefined
         ? {
             ...internals,

package/dist/core/runner/run-leg.js

@@ -614,7 +614,8 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
     }
     const executedArgs = humanRewrite !== undefined ? resolvedArgs : screened !== undefined ? screened.args : resolvedArgs;
     const unseen = !deepJsonEqual(executedArgs, pendingAction.args);
-    const beltReq = () => ({ toolName: pendingAction.toolName, args: executedArgs, toolCallId: pendingAction.toolCallId, ...callFaceSeat(parkedRowLiveFace(prepared.toolRosterDeltas.current, pendingAction)), budget: beltBudget, ...(prepared.cwdRef !== undefined ? { cwd: prepared.cwdRef.current } : {}), ...(prepared.handsRoot !== undefined ? { root: prepared.handsRoot } : {}), ...advertisedWritableRootsSeat(prepared.advertisedWritableDirs) });
+    let beltReading;
+    const beltReq = () => ({ toolName: pendingAction.toolName, args: executedArgs, toolCallId: pendingAction.toolCallId, ...callFaceSeat(parkedRowLiveFace(prepared.toolRosterDeltas.current, pendingAction)), budget: beltBudget, ...(prepared.cwdRef !== undefined ? { cwd: prepared.cwdRef.current } : {}), ...(prepared.handsRoot !== undefined ? { root: prepared.handsRoot } : {}), ...advertisedWritableRootsSeat(prepared.advertisedWritableDirs), ...(beltReading !== undefined ? { targetReading: beltReading } : {}) });
     const unjudgeable = unseen ? chainCannotJudge(resume.cp.state.inheritedGate) : undefined;
     if (unjudgeable !== undefined) {
         const chainDenial = formatHookFeedback(`The approved tool call "${pendingAction.toolName}" was not executed: its input changed after the approval and the inherited ancestor chain cannot judge the changed input (${unjudgeable}). This approval is spent — the call has to be re-issued.`, prepared.reminderMark);
@@ -627,6 +628,9 @@ async function resolvePendingCall(runner, prepared, resume, emit, emitCommitted,
         resourceSpentMicroUsd: prepared.resourceLedger?.spentMicroUsd ?? 0,
         suspendCount: resume.cp.suspendCount ?? 0,
     };
+    const beltStamped = prepared.stampCallTarget?.(beltReq(), prepared.abortController.signal);
+    if (beltStamped !== undefined)
+        beltReading = (await beltStamped).targetReading;
     if (unseen && prepared.basePolicyForResumeEdit) {
         const rechecked = refuseOutOfContractDecision(await prepared.basePolicyForResumeEdit.check(beltReq(), prepared.abortController.signal));
         const personUnanswered = policyCannotAnswer(rechecked, outcome.hostDecision.decidedBy);

package/dist/core/runner/runtask.js

@@ -45,7 +45,7 @@ import { streamLifecycleVerbs } from "./stream-lifecycle-verbs.js";
 import { streamHaltVerbs } from "./stream-halt-verbs.js";
 import { streamModeVerb } from "./stream-mode-verb.js";
 import { runNotificationLane } from "./run-notification-lane.js";
-import { assertNoRetiredRunnerDeps } from "./retired-runner-deps.js";
+import { assertRunnerDepsDoors } from "./construction-doors.js";
 import { runLeg } from "./run-leg.js";
 import { runTerminalAdoption } from "./run-terminal-adoption.js";
 import { runSettleAndTeardown } from "./run-settle-and-teardown.js";
@@ -77,7 +77,7 @@ export class Runner {
     static PARENT_CONSTRAINT_REGISTRY_CAP = 1024;
     depsSeat;
     constructor(deps) {
-        assertNoRetiredRunnerDeps(deps);
+        assertRunnerDepsDoors(deps);
         const runner = this;
         this.depsSeat = { get deps() { return runner.deps; } };
         this.deps = withDeploymentAllowedTools(deps);

package/dist/core/runner/sub-agent-deny-lists.d.ts

@@ -3,7 +3,7 @@
  * list a deployment writes — the task's own definitions (`TaskSpec.agents`), the definitions a mounted delegation tool carries
  * (the `authored` faces — the engine's built-ins name tools of other vocabularies and are not judged) and its tool-level list.
  * Universe = the task's assembled roster plus every mounted delegation tool's pool, names and aliases; a pool the engine cannot
- * list (an `extraTools` factory) turns the refusals that need a roster into host notices. A tool's own lists are judged where
+ * list (an `extraTools` factory with no declared roster) turns the refusals that need a roster into host notices. A tool's own lists are judged where
  * the tool is mounted: only a tool a deployment mounted (depth 0) publishes them (`authored`, `agentToolLevelAllowTools`, `agentToolLevelDenyTools`), the
  * engine's nested copy for a delegated child carries neither.
  *

package/dist/core/runner/write-protection-station.d.ts

@@ -33,8 +33,9 @@ export interface LegWriteProtection extends WriteProtectionMount {
 export declare function mountWriteProtection(input: {
     /** borrowed-readonly — the deployment seats: the table (`writeProtectedPaths`; absent ⇒ the default
      *  table, `[]` ⇒ opted out), the data root the memory library is materialized under
-     *  (`memoryEngineDir`; absent ⇒ the resolver's env/default chain) and the operator sink. */
-    deps: Pick<RunnerDeps, "writeProtectedPaths" | "memoryEngineDir" | "onNotice">;
+     *  (`memoryEngineDir`; absent ⇒ the resolver's env/default chain), the configuration root the host
+     *  declared (`agentConfigDir`) and the operator sink. */
+    deps: Pick<RunnerDeps, "writeProtectedPaths" | "memoryEngineDir" | "agentConfigDir" | "onNotice">;
     /** The HANDS' environment, or `undefined` with no hands — the driver's own predicate, not a second
      *  reading of the env seats, so the judge sees exactly the environment the write tools do. */
     env: ExecutionEnv | undefined;

package/dist/core/runner/write-protection-station.js

@@ -6,6 +6,7 @@ export function mountWriteProtection(input) {
     const announced = new Set();
     const matcher = compileWriteProtection(input.deps.writeProtectedPaths, {
         ...(input.deps.memoryEngineDir !== undefined ? { dataRoot: input.deps.memoryEngineDir } : {}),
+        ...(input.deps.agentConfigDir !== undefined ? { agentConfigDir: input.deps.agentConfigDir } : {}),
         ...(input.env !== undefined ? { env: input.env } : {}),
         rootPath: input.rootPath,
         onViewAbsent: (absence) => {

package/dist/core/runner-deps.d.ts

@@ -227,6 +227,20 @@ export interface RunnerDeps {
      * ignored). Same deployment-only seat, clamp argument and checkpoint posture as the tiers key.
      */
     readDenyBuiltinExclude?: readonly string[];
+    /**
+     * Where the host keeps the agent's configuration directory when it is not `<home>/.sema` — an ABSOLUTE path of an
+     * existing directory, resolved by the host (the engine reads no environment variable for it). The rows of the
+     * `agent-config` tier that name that directory (`~/.sema/settings.json`, `~/.sema/settings.local.json`,
+     * `~/.sema/engine-data/.env`, `~/.sema/config-lkg-*.json`) are then ALSO placed at the same files below this root, so the model can neither read
+     * nor (through the write-protection table and a wired `createSensitivePathPolicy({ agentConfigDir })`) rewrite the
+     * relocated settings; the default `~/.sema` location stays refused. Rows of the home's dotted family (`~/.sema.*`)
+     * and the external tools' files are not part of the directory and stay anchored at the home. A symlink the root is
+     * reached through is followed (the target is guarded too). ABSENT = today's behaviour, the literal `~/.sema` under
+     * the declared and account homes. A value that is not a string, is empty or relative, or names no existing directory
+     * refuses `new Runner` with `config.agent_config_dir_invalid` — never read as absent. DEPLOYMENT seat only (no
+     * TaskSpec twin) and fixed at construction: `swapDeps` does not carry it.
+     */
+    agentConfigDir?: string;
     /**
      * backlog #286 (#279 — CC 2.1.233 `DANGEROUS_FILES`/`DANGEROUS_DIRECTORIES`/
      * `DANGEROUS_DIRECTORY_PATHS` parity): the WRITE-protection table. DEFAULT-ON: a path-confinable

package/dist/core/sensitive-path-policy.d.ts

@@ -155,6 +155,14 @@ export declare function createSensitivePathPolicy(opts: {
      * gate and the transcript gate keep speaking about the same directory.
      */
     dataRoot?: string;
+    /**
+     * The host's configuration root when it keeps the agent's configuration directory somewhere other than the home's
+     * `.sema` — the same absolute directory it hands the Runner (`RunnerDeps.agentConfigDir`). Every pattern that opens with
+     * the `.sema` segment (`.sema/settings.json`, `.sema/hooks`, …) then also guards the same tail below this root; the
+     * patterns themselves keep guarding every `.sema` anywhere. Absent ⇒ the list is judged as it stands. A value that is not
+     * the absolute path of an existing directory throws (`config.agent_config_dir_invalid`).
+     */
+    agentConfigDir?: string;
     /** Override the guarded tool set (default: `Write`, `Edit`, `MultiEdit`-legacy → Edit, `NotebookEdit`). */
     tools?: string[];
 }): ToolPolicy;

package/dist/core/sensitive-path-policy.js

@@ -2,6 +2,7 @@ import { homedir } from "node:os";
 import { isAbsolute, join, resolve } from "node:path";
 import { canonicalizeTarget, expandHomeTilde, isAbsoluteForFamily, isWinFormPath, pathFamilyOf, writeTargetPath } from "../tools/fs/safety.js";
 import { compileSegmentPattern, matchSegmentPatterns, READ_FACE_BUILTIN_DENY_TABLE, readDenyPatternRun } from "../tools/fs/read-deny.js";
+import { agentConfigDirSegments, agentConfigDirTail, checkedAgentConfigDir } from "./agent-config-dir.js";
 import { isProtectedWrite, protectivePathTargetOf } from "./tool-registry.js";
 import { pathTargetBaseOf } from "./effective-path-target.js";
 import { symlinkChainHops } from "./path-identity.js";
@@ -32,6 +33,7 @@ export const RECOMMENDED_SENSITIVE_PATTERNS = [
     ".mcp.json",
     ".ai-agent/.env",
     ".sema/engine-data/.env",
+    ".sema/config-lkg-*.json",
     ".codex/config.toml",
     ".cursor/mcp.json",
     ".continue/config.json",
@@ -115,6 +117,19 @@ function matchSensitive(canonicalKey, compiled, aliasResolved) {
 }
 export function createSensitivePathPolicy(opts) {
     const compiled = compilePatterns(opts.patterns);
+    const configRoot = checkedAgentConfigDir(opts.agentConfigDir, "createSensitivePathPolicy agentConfigDir");
+    const configRows = configRoot === undefined ? [] : opts.patterns.flatMap((raw) => {
+        const tail = agentConfigDirTail(raw, !CASE_INSENSITIVE_FS);
+        return tail === undefined ? [] : [{ raw, tail }];
+    });
+    const configTwins = async (signal) => {
+        if (configRoot === undefined || configRows.length === 0)
+            return [];
+        const fold = CASE_INSENSITIVE_FS ? "ascii" : "none";
+        const lower = (segs) => (CASE_INSENSITIVE_FS ? segs.map((seg) => seg.replace(/[A-Z]/g, (c) => c.toLowerCase())) : segs);
+        const anchors = [configRoot, ...(await canonicalDataRootKeys(opts.env, [configRoot], signal))].map((root) => lower(agentConfigDirSegments(root)));
+        return configRows.map(({ raw, tail }) => ({ ...(compileSegmentPattern(tail, fold) ?? { raw, segments: [], foldAscii: CASE_INSENSITIVE_FS }), raw, anchors, rootedOnly: true }));
+    };
     const dataRootPaths = dataRootSpellings(opts.dataRoot);
     const guardedByName = opts.tools !== undefined ? new Set(opts.tools) : undefined;
     const family = (cwd) => pathFamilyOf({ root: opts.rootPath, cwd: cwd ?? opts.env.cwd });
@@ -130,12 +145,13 @@ export function createSensitivePathPolicy(opts) {
         }
         if (relative === "")
             return { kind: "clear" };
-        const hit = matchSensitive(relative ?? canon.key, compiled, canon.aliasResolved === true);
+        const twins = await configTwins(signal);
+        const hit = matchSensitive(relative ?? canon.key, [...compiled, ...twins], canon.aliasResolved === true);
         if (hit)
             return { kind: "hit", pattern: hit, via: "target" };
         if (relative === null) {
             for (const hop of await symlinkChainHops(opts.env, path, signal, fam, base)) {
-                const viaHop = matchSensitive(hop, compiled, false);
+                const viaHop = matchSensitive(hop, [...compiled, ...twins], false);
                 if (viaHop)
                     return { kind: "hit", pattern: viaHop, via: "chain" };
             }

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

@@ -0,0 +1,11 @@
+import type { ShellWrapperRow } from "./shell-wrapper-table.js";
+/**
+ * The PROJECTION {@link import("./shell-wrapper-table.js").SHELL_WRAPPER_TABLE} is: the second lexer's view of the program read model's rows (`program-read-model.ts`
+ * — one table of program facts, read through the binary gate). A launcher row's options by arity (a value word, a
+ * switch or an attached-only value, a command string), its required operand (a duration, or the spelling it must have),
+ * its bare-dash switch and its `NAME=value` operands; a row that runs its operands, or a code body, as shell input
+ * (`viaShell`); an option that runs a command (`executes`). The table is this projection written out (its
+ * literal type is the export's), and `test/shell-wrapper-table-projection.test.ts` pins it equal — a launcher fact is
+ * edited in its row, never here.
+ */
+export declare function shellWrapperProjection(): Record<string, ShellWrapperRow>;

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

@@ -0,0 +1,56 @@
+import { programRows } from "../tools/fs/program-read-model.js";
+import { DURATION_SPELLING } from "../tools/fs/program-read-model.rows.js";
+export function shellWrapperProjection() {
+    const out = {};
+    for (const row of programRows()) {
+        const projected = projectRow(row);
+        if (projected !== undefined)
+            out[row.key] = projected;
+    }
+    return out;
+}
+function spellings(row) {
+    const out = new Map();
+    for (const g of row.grammars) {
+        const add = (spelling, spec) => {
+            const e = out.get(spelling) ?? { spec, arities: new Set() };
+            e.arities.add(spec.arity);
+            out.set(spelling, e);
+        };
+        for (const [l, spec] of Object.entries(g.short))
+            add(`-${l}`, spec);
+        for (const [n, spec] of Object.entries(g.long))
+            add(`--${n}`, spec);
+        for (const [n, spec] of Object.entries(g.dashWords ?? {}))
+            add(`-${n}`, spec);
+    }
+    return [...out].map(([spelling, e]) => ({ spelling, spec: e.spec, arity: e.arities.size === 1 ? [...e.arities][0] : "disputed" }));
+}
+const runsCommand = (spec) => spec.effect === "executes" || spec.value?.kind === "shell-text" || spec.value?.kind === "command";
+function projectRow(row) {
+    const sorted = (xs) => [...new Set(xs)].sort();
+    const all = spellings(row);
+    const viaShell = row.reentry?.kind === "shell" || row.launcher?.shellText !== undefined || row.body === "first-operand" || row.body === "assignment-values" || (row.operands?.rest?.kind === "program-text" && row.operands.rest.language === "arithmetic");
+    if (row.launcher === undefined) {
+        if (viaShell)
+            return { valueFlags: [], flags: [], commandString: [], viaShell: true };
+        const executes = sorted(all.filter((o) => runsCommand(o.spec)).map((o) => o.spelling));
+        return executes.length > 0 ? { valueFlags: [], flags: [], commandString: [], executes } : undefined;
+    }
+    const commandString = sorted(all.filter((o) => o.spec.value?.kind === "shell-text").map((o) => o.spelling));
+    const values = all.filter((o) => o.spec.value?.kind !== "shell-text");
+    const attached = sorted(values.filter((o) => o.arity === "attached" && !o.spelling.startsWith("--")).map((o) => o.spelling));
+    const required = row.launcher.requiredOperands ?? 0;
+    const duration = required > 0 && row.launcher.requiredOperandSpelling === DURATION_SPELLING;
+    return {
+        valueFlags: sorted(values.filter((o) => o.arity === 1).map((o) => o.spelling)),
+        flags: sorted(values.filter((o) => o.arity === 0 || (o.arity === "attached" && o.spelling.startsWith("--"))).map((o) => o.spelling)),
+        ...(attached.length > 0 ? { attached } : {}),
+        commandString,
+        ...(required > 0 && !duration ? { positional: row.launcher.requiredOperandSpelling ?? /^/ } : {}),
+        ...(duration ? { duration: true } : {}),
+        ...(row.launcher.bareDash === true ? { bareDash: true } : {}),
+        ...(row.launcher.assignmentOperands === true ? { assignments: true } : {}),
+        ...(viaShell ? { viaShell: true } : {}),
+    };
+}

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 ["--group", "--shell", "--supp-group", "--whitelist-environment", "-G", "-g", "-s", "-w"];
+        readonly flags: readonly ["--fast", "--help", "--login", "--no-pty", "--preserve-environment", "--pty", "--version", "-P", "-T", "-V", "-f", "-h", "-l", "-m", "-p"];
+        readonly commandString: readonly ["--command", "--session-command", "-c"];
+        readonly viaShell: true;
+    };
+    readonly runuser: {
+        readonly valueFlags: readonly ["--group", "--shell", "--supp-group", "--user", "--whitelist-environment", "-G", "-g", "-s", "-u", "-w"];
+        readonly flags: readonly ["--fast", "--help", "--login", "--no-pty", "--preserve-environment", "--pty", "--version", "-P", "-T", "-V", "-f", "-h", "-l", "-m", "-p"];
+        readonly commandString: readonly ["--command", "--session-command", "-c"];
+        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). */