@sema-agent/core 7.47.0 → 7.49.0

package/dist/tools/fs/shell-read-workdir.js

@@ -0,0 +1,281 @@
+import { argvOf, lexShell } from "../../shell/lex.js";
+import { shellWordsOf } from "../../shell/shell-words.js";
+import { resolveOperandLexically } from "./bash-readonly-classifier.js";
+import { readProgramPosition } from "./bash-program-position.js";
+import { valueOf } from "./shell-read-bindings.js";
+import { evalDefinedFunctions, functionCallOf } from "./shell-read-functions.js";
+import { codeBodies } from "./shell-reentry-text.js";
+import { isAbsoluteForFamily } from "./safety.js";
+const TEXT_RUNNING_PROGRAMS = new Set(["eval", "source", "."]);
+const BASE_CANDIDATE_MAX = 256;
+const tableSays = (name, at, ctx) => ctx.textBinds(name) || at.table.commandSets.has(name);
+export class WorkdirThread {
+    readable;
+    candidates;
+    lostAt = false;
+    floors;
+    physical;
+    movedAt = -1;
+    constructor(start, readable, startsPhysical = false) {
+        this.readable = readable;
+        this.physical = startsPhysical;
+        this.lostAt = start === "unmodelled";
+        this.candidates = start === "unmodelled" ? [] : start.map((c) => (typeof c === "string" ? { base: c, skippedCd: -1, ...(readable && isAbsoluteForFamily("own", c) ? { pwd: c } : {}), dirStack: [] } : { ...c, skippedCd: -1 }));
+    }
+    get lost() {
+        return this.lostAt;
+    }
+    get floorBases() {
+        return this.floors;
+    }
+    reachable(andRunStart) {
+        return this.candidates.filter((c) => c.skippedCd < andRunStart);
+    }
+    end() {
+        return this.lostAt ? "unmodelled" : this.candidates;
+    }
+    where(andRunStart) {
+        if (this.lostAt || !this.readable)
+            return { PWD: "unknown", OLDPWD: "unknown", movedAt: this.movedAt };
+        const reachable = this.reachable(andRunStart);
+        const values = (pick) => {
+            const out = new Set();
+            for (const c of reachable) {
+                const v = pick(c);
+                if (v === undefined)
+                    return "unknown";
+                out.add(v);
+            }
+            return [...out].map((spelled) => ({ spelled }));
+        };
+        return { PWD: values((c) => c.pwd), OLDPWD: values((c) => c.old), movedAt: this.movedAt };
+    }
+    setPhysical() {
+        this.physical = true;
+    }
+    get mayBePhysical() {
+        return this.physical;
+    }
+    lose(at, reachable, floorTargets = []) {
+        this.movedAt = Math.max(this.movedAt, at);
+        this.lostAt = true;
+        this.floors ??= [...new Set([...reachable.map((c) => c.base), ...floorTargets])];
+    }
+    shift(si, at, ctx) {
+        if (this.lostAt) {
+            if (this.floors !== undefined && this.floors.length > 0)
+                this.floors = [...new Set([...this.floors, ...floorOf(at.shift, this.reachable(at.andRunStart), ctx)])];
+            return;
+        }
+        this.movedAt = si;
+        const reachable = this.reachable(at.andRunStart);
+        const s = at.shift;
+        if (s.kind === "lost")
+            return this.lose(si, reachable);
+        if (s.kind === "stack") {
+            this.candidates = this.candidates.map(({ dirStack: _, ...c }) => c);
+            return;
+        }
+        const branched = [];
+        for (const c of this.candidates) {
+            if (c.skippedCd < at.andRunStart) {
+                const moved = this.movedFrom(c, at, ctx);
+                if (moved === "lost")
+                    return this.lose(si, reachable, floorOf(s, reachable, ctx));
+                for (const m of moved)
+                    branched.push({ ...m, skippedCd: c.skippedCd });
+            }
+            branched.push({ ...c, skippedCd: at.provable ? si : c.skippedCd });
+        }
+        const byKey = new Map();
+        for (const c of branched) {
+            const key = JSON.stringify([c.base, c.pwd, c.old, c.dirStack]);
+            const prior = byKey.get(key);
+            if (prior === undefined || c.skippedCd < prior.skippedCd)
+                byKey.set(key, c);
+        }
+        const next = [...byKey.values()];
+        if (next.length > BASE_CANDIDATE_MAX)
+            this.lose(si, reachable);
+        else
+            this.candidates = next;
+    }
+    movedFrom(c, at, ctx) {
+        const s = at.shift;
+        if (s.kind === "eval") {
+            const ran = ctx.evalEnd(s.text, c, at.table);
+            if (ran.physical)
+                this.physical = true;
+            return ran.end === "unmodelled" ? "lost" : ran.end.map((e) => (this.physical ? withoutPwd(e) : e));
+        }
+        const old = tableSays("PWD", at, ctx) ? {} : c.pwd !== undefined ? { old: c.pwd } : {};
+        const land = (base, physical, stack) => ({ base, skippedCd: c.skippedCd, ...(physical || this.physical || !this.readable ? {} : { pwd: base }), ...old, ...(stack !== undefined ? { dirStack: stack } : {}) });
+        if (s.kind === "swap" || s.kind === "pop") {
+            const top = c.dirStack?.[0];
+            if (top === undefined)
+                return "lost";
+            return [land(top, false, s.kind === "swap" ? [c.base, ...c.dirStack.slice(1)] : c.dirStack.slice(1))];
+        }
+        if (s.kind !== "cd")
+            return "lost";
+        const stack = s.push === true ? (c.dirStack === undefined ? undefined : [c.base, ...c.dirStack]) : c.dirStack;
+        const targets = targetsOf(s.target, c, at, ctx);
+        if (targets === "lost")
+            return "lost";
+        const out = [];
+        for (const t of targets) {
+            if ((s.physical || this.physical || c.pwd === undefined) && t.split("/").includes(".."))
+                return "lost";
+            const moved = resolveOperandLexically(c.base, t, ctx.homeDir);
+            if (moved === undefined)
+                return "lost";
+            out.push(land(moved, s.physical, stack));
+        }
+        return out;
+    }
+}
+const withoutPwd = ({ pwd: _, ...c }) => c;
+function floorOf(s, reachable, ctx) {
+    if (s.kind !== "cd")
+        return [];
+    if (s.target === "home")
+        return ctx.homeDir !== undefined ? [ctx.homeDir] : [];
+    if (typeof s.target === "string")
+        return [];
+    const target = s.target;
+    return [...(target.floorSpelled !== undefined ? [target.floorSpelled] : []), ...(target.expands === false ? reachable.flatMap((c) => resolveOperandLexically(c.base, target.spelled, ctx.homeDir) ?? []) : [])];
+}
+function targetsOf(target, c, at, ctx) {
+    if (target === "home")
+        return settledValues(at.table.stateOf("HOME"));
+    if (target === "previous")
+        return tableSays("OLDPWD", at, ctx) ? settledValues(at.table.stateOf("OLDPWD")) : c.old === undefined ? "lost" : [c.old];
+    if (target.expands !== false)
+        return "lost";
+    const dir = target.spelled;
+    if (!searchesCdPath(dir))
+        return [dir];
+    if (at.cdable && /^[A-Za-z_][A-Za-z0-9_]*$/.test(dir))
+        return "lost";
+    const cdPath = settledValues(at.table.stateOf("CDPATH"));
+    if (cdPath === "lost")
+        return "lost";
+    const entries = cdPath.flatMap((v) => (v === "" ? [] : v.split(":")));
+    return [...new Set([...entries.map((e) => (e === "" ? dir : `${e.replace(/\/+$/, "")}/${dir}`)), dir])];
+}
+export function searchesCdPath(dir) {
+    return dir !== "" && !isAbsoluteForFamily("own", dir) && !/^\.\.?(?:\/|$)/.test(dir) && !dir.startsWith("~");
+}
+function settledValues(state) {
+    if (state === "unknown" || state.some((v) => v.glob === true))
+        return "lost";
+    return state.map((v) => v.spelled);
+}
+export function baseShiftOf(program, args, targetOf) {
+    if (program === "cd") {
+        let physical = false;
+        let at = 0;
+        for (; at < args.length; at++) {
+            const w = args[at].folded;
+            if (w === "--") {
+                at++;
+                break;
+            }
+            if (!w.startsWith("-") || w === "-")
+                break;
+            for (const letter of w.slice(1)) {
+                if (letter === "P")
+                    physical = true;
+                else if (letter === "L")
+                    physical = false;
+                else if (letter !== "e" && letter !== "@")
+                    return { shift: { kind: "lost" }, reported: "unmodelled" };
+            }
+        }
+        if (at >= args.length)
+            return { shift: { kind: "cd", target: "home", physical }, reported: "home" };
+        if (args[at].folded === "-")
+            return { shift: { kind: "cd", target: "previous", physical }, reported: "previous" };
+        const target = targetOf(args[at]);
+        return { shift: { kind: "cd", target, physical }, reported: target };
+    }
+    if (shellWordsOf("stack_mover").has(program)) {
+        const words = args.map((a) => a.folded);
+        if (words.some((w) => w === "-n"))
+            return { shift: { kind: "stack" }, reported: "unmodelled" };
+        if (words.some((w) => /^[+-]\d+$/.test(w)) || words.some((w) => w.startsWith("-") && w !== "--"))
+            return { shift: { kind: "lost" }, reported: "unmodelled" };
+        const operand = args.find((a) => a.folded !== "--");
+        if (program === "popd")
+            return { shift: operand === undefined ? { kind: "pop" } : { kind: "lost" }, reported: "unmodelled" };
+        if (operand === undefined)
+            return { shift: { kind: "swap" }, reported: "unmodelled" };
+        return { shift: { kind: "cd", target: targetOf(operand), physical: false, push: true }, reported: targetOf(operand) };
+    }
+    if (shellWordsOf("stack_editor").has(program) && args.some((a) => a.folded.startsWith("-") || a.folded.startsWith("+")))
+        return { shift: { kind: "stack" } };
+    return undefined;
+}
+export function textMayMove(text, functions) {
+    const lexed = lexShell(text);
+    if ("parseFailure" in lexed)
+        return true;
+    return lexed.segments.some((s) => segmentMayMove(argvOf(s), functions));
+}
+const programOf = (argv) => {
+    const pos = readProgramPosition(argv);
+    return pos.program === undefined ? undefined : { name: pos.program.basename, args: argv.slice(pos.program.index + 1).map((w) => w.folded) };
+};
+const setsPhysical = (p) => p?.name === "set" && p.args.some((a, k) => /^-[A-Za-z]*P/.test(a) || (a === "-o" && p.args[k + 1] === "physical"));
+export function textSetsPhysical(text) {
+    const lexed = lexShell(text);
+    return !("parseFailure" in lexed) && lexed.segments.some((s) => setsPhysical(programOf(argvOf(s))));
+}
+export function withCommandEnvironment(table, argv) {
+    const overlay = new Map();
+    const overlaid = () => ({ ...table, stateOf: (name) => overlay.get(name) ?? table.stateOf(name) });
+    for (const k of readProgramPosition(argv).assignments) {
+        const a = argv[k].assignment;
+        if (a === undefined)
+            continue;
+        if (a.op !== "=" || a.subscript !== undefined || a.form !== "scalar" || a.value.unresolved !== undefined) {
+            overlay.set(a.name, "unknown");
+            continue;
+        }
+        const before = valueOf({ pieces: a.value.pieces }, table, true);
+        const ordered = valueOf({ pieces: a.value.pieces }, overlaid(), true);
+        overlay.set(a.name, before === "unknown" || ordered === "unknown" ? "unknown" : [...before, ...ordered.filter((v) => !before.some((b) => b.spelled === v.spelled))]);
+    }
+    return { ...overlaid(), commandSets: new Set(overlay.keys()) };
+}
+export function textCalls(text, functions) {
+    const lexed = lexShell(text);
+    if ("parseFailure" in lexed)
+        return true;
+    return lexed.segments.some((s) => functionCallOf(argvOf(s), functions) !== undefined);
+}
+export function segmentMayMove(argv, functions) {
+    const pos = readProgramPosition(argv);
+    if (pos.program === undefined)
+        return false;
+    const word = argv[pos.program.index];
+    return shellWordsOf("base_mover").has(pos.program.basename) || TEXT_RUNNING_PROGRAMS.has(pos.program.basename) || functionCallOf(argv, functions) !== undefined || word.pieces.some((p) => p.expansion !== undefined || p.literal === undefined);
+}
+export function textMovesOf(defined, argvs, inFunctionBody, inherited) {
+    const unread = new Set([...evalDefinedFunctions(argvs), ...(inherited?.unread ?? [])]);
+    const functions = new Set([...defined, ...unread, ...(inherited?.functions ?? [])]);
+    const programs = argvs.map(programOf);
+    const mayMove = argvs.map((argv) => segmentMayMove(argv, functions));
+    const bodyMoves = mayMove.some((m, si) => m && inFunctionBody(si));
+    const bodiesAt = programs.map((p) => (p === undefined ? [] : codeBodies(p.name, p.args)));
+    const mayCallAt = argvs.map((argv) => functionCallOf(argv, functions) !== undefined);
+    const runsTextAt = argvs.map((argv) => { const pos = readProgramPosition(argv); const word = pos.program === undefined ? undefined : argv[pos.program.index]; return word !== undefined && (["eval", "source", "."].includes(pos.program.basename) || word.pieces.some((p) => p.expansion !== undefined || p.literal === undefined)); });
+    const callAt = (si, table) => functionCallOf(argvs[si], functions, (name) => table.functionState(name));
+    const callsUnread = (si, table) => functionCallOf(argvs[si], unread, (name) => table.functionState(name)) !== undefined;
+    return {
+        functions, unread, mayMove, mayCallAt, runsBodyAt: mayCallAt.map((c, si) => c || runsTextAt[si] || bodiesAt[si].length > 0), bodiesAt, bodyMoves, callAt, callsUnread,
+        physicalAt: programs.map(setsPhysical),
+        cdableFrom: programs.findIndex((p) => p?.name === "shopt" && p.args.includes("-s") && p.args.includes("cdable_vars")),
+        losesBaseAt: (si, table) => (callAt(si, table) !== undefined && bodyMoves) || callsUnread(si, table) || bodiesAt[si].some((b) => bodyMoves || textMayMove(b, functions)),
+    };
+}

package/dist/tools/fs/shell-read-write-targets.d.ts

@@ -5,7 +5,8 @@
  * writes, the operands an option made edited in place, a copy's destination and its children, an in-place edit's
  * backups), at the seats the role and the selected options name ({@link WriteSeat}: the directory entry, or where the
  * path lands). The establisher (`shell-read-establish.ts`) places what this module names; the judge reads the result
- * on the deny table's write face. No table of programs or options lives here: what a program writes is its row's.
+ * on the write face (the write deny rows, then the write roots). No table of programs or options lives here: what a
+ * program writes is its row's.
  */
 import type { ReadCandidate, ShellReadSegment } from "./shell-read-plan.js";
 import { type WriteSeat } from "./program-read-model.js";
@@ -47,5 +48,7 @@ export interface JudgedCandidate {
 }
 /** Every candidate a segment hands the judge: its reads minus the write targets, plus its `cd` target (the plan already
  *  lists it among the reads), plus its WRITE targets for the write face ({@link writeTargetsOf}), plus the deny-floor
- *  shadow of every unplaced home word ({@link denyFloorShadowsOf}) on both faces. */
+ *  shadow of every unplaced home word ({@link denyFloorShadowsOf}) on both faces. A word the program only writes keeps
+ *  its read copy for the read deny rows alone (`denyOnly`): whether it lands inside the write roots — or cannot be placed
+ *  at all — is the write face's question, never a read's. */
 export declare function judgedCandidatesOf(segment: ShellReadSegment): readonly JudgedCandidate[];

package/dist/tools/fs/shell-read-write-targets.js

@@ -29,6 +29,7 @@ function writeOwnersOf(segment) {
 }
 function writeTargetsOf(segment) {
     const out = [];
+    const writeOnly = new Set();
     const write = (c, seats, written, child, onlyIfExists) => void out.push({ candidate: { ...c, face: "write" }, ...(seats !== undefined ? { seats } : {}), ...(written !== undefined ? { written } : {}), ...(child === true ? { child } : {}), ...(onlyIfExists !== undefined ? { onlyIfExists } : {}) });
     for (const r of segment.redirects)
         if (r.direction === "out" && r.target !== undefined)
@@ -48,9 +49,12 @@ function writeTargetsOf(segment) {
             continue;
         const placed = owners.filter((o) => o.words.some((w) => w.raw === c.raw));
         const fallback = placed.length === 0 ? owners.filter((o) => o.program) : [];
+        let only = placed.length > 0;
         for (const o of [...placed, ...fallback]) {
-            if (o.readings.length === 0)
+            if (o.readings.length === 0) {
+                only = false;
                 continue;
+            }
             const at = new Set(o.words.flatMap((w, i) => (w.raw === c.raw ? [i] : [])));
             const roles = [];
             let readings = 0;
@@ -64,8 +68,11 @@ function writeTargetsOf(segment) {
                 readings += 1;
                 unexplained ||= unplaced;
             }
-            if (roles.length === 0)
+            if (roles.length === 0) {
+                only = false;
                 continue;
+            }
+            only &&= !unexplained && readings === o.all.length && roles.every((role) => role.effect !== "edit-in-place" && role.writtenAt === undefined);
             const stated = roles.some((role) => (o.override ?? role.seats) !== undefined);
             const seats = stated ? [...new Set(roles.flatMap((role) => o.override ?? role.seats ?? ["landing"]))] : undefined;
             const written = unexplained || roles.some((role) => role.writtenAt === undefined) ? undefined : [...new Set(roles.flatMap((role) => role.writtenAt ?? []))];
@@ -74,13 +81,15 @@ function writeTargetsOf(segment) {
             if (roles.some((role) => role.effect === "edit-in-place") && c.expands === false)
                 edited.set(o, [...(edited.get(o) ?? []), { candidate: c, ...(speculative !== undefined ? { onlyIfExists: speculative } : {}) }]);
         }
+        if (only)
+            writeOnly.add(c);
     }
     for (const o of owners) {
         for (const c of copyDestinationChildren(segment, o.words, o.readings))
             write(c, ["landing", "entry"], undefined, true);
         out.push(...backupTargetsOf(edited.get(o) ?? [], o.readings, o.override));
     }
-    return out;
+    return { targets: out, writeOnly };
 }
 function backupTargetsOf(edited, readings, override) {
     const suffixes = [...new Set(readings.flatMap((r) => r.suffixes))];
@@ -114,8 +123,8 @@ function copyDestinationChildren(segment, words, readings) {
     return [...children.values()];
 }
 export function judgedCandidatesOf(segment) {
-    const reads = segment.reads.filter((c) => c.provenance !== "write_redirect_target");
-    const writes = writeTargetsOf(segment);
+    const { targets: writes, writeOnly } = writeTargetsOf(segment);
+    const reads = segment.reads.flatMap((c) => (c.provenance === "write_redirect_target" ? [] : [writeOnly.has(c) ? { ...c, denyOnly: true } : c]));
     const plain = (cs) => cs.map((candidate) => ({ candidate }));
     return [...plain(reads), ...plain(denyFloorShadowsOf(reads)), ...writes, ...plain(denyFloorShadowsOf(writes.map((w) => w.candidate)))];
 }

package/dist/tools/fs/shell-reentry-text.d.ts

@@ -6,6 +6,7 @@
  */
 import { type LexedSegment, type LexedWord } from "../../shell/lex.js";
 import { type ProgramPosition } from "./bash-program-position.js";
+import { type TargetUser } from "./program-read-model.js";
 import type { BoundValue } from "./shell-read-bindings.js";
 /**
  * The code bodies a builtin keeps among its operands, one per body; empty for every other program. The program read
@@ -52,6 +53,8 @@ export interface LaunchedCommand {
         readonly spelled: string;
     };
     readonly args: readonly LaunchedArg[];
+    /** The user the launcher runs it as, where its row says it runs another ({@link targetUserOf}). */
+    readonly as?: TargetUser;
 }
 /**
  * What a launcher that runs a program named by no word of its own runs ({@link readProgramPosition}'s `runsShell`: the
@@ -79,11 +82,11 @@ export declare function launchedReadings(argv: readonly LexedWord[], command: La
     readonly shell?: string;
     readonly line?: string;
 };
-/** What a launcher runs ({@link launchedCommands}, {@link launchedReadings}), as a reader of the command line reads it:
- *  each shell's argv in two spellings — `texts` (a word's literal value, else `spell.text`) and `args` (`spell.folded`) —
- *  with the argv index each position stands for (`words`), one argv per reading of the values its words may take
- *  (`spell.values`, {@link spellLaunched}); the word naming a shell (`su -s /bin/bash`, `programWords`); and each command
- *  line a program that is no shell runs (`lines`, once each). */
+/** What a launcher runs ({@link launchedCommands}, {@link launchedReadings}), as a reader of the command line reads it in
+ *  one reading of its names: each shell's argv in two spellings — `texts` (a word's literal value, else `spell.text`) and
+ *  `args` (`spell.folded`) — with the argv index each position stands for (`words`), its words' fields read off
+ *  `spell.values` ({@link spellLaunched}) and the user it runs as (`as`); the word naming a shell (`su -s /bin/bash`,
+ *  `programWords`); and each command line a program that is no shell runs (`lines`, once each). */
 export declare function launchedInput(argv: readonly LexedWord[], pos: ProgramPosition, spell: {
     readonly text: (k: number) => string;
     readonly folded: (k: number) => string;
@@ -94,6 +97,7 @@ export declare function launchedInput(argv: readonly LexedWord[], pos: ProgramPo
         readonly texts: readonly string[];
         readonly args: readonly string[];
         readonly words: readonly (number | undefined)[];
+        readonly as?: TargetUser;
     }[];
     readonly programWords: readonly number[];
     readonly lines: readonly string[];
@@ -107,34 +111,30 @@ export interface LaunchedSpelling {
     readonly values?: (at: number) => readonly BoundValue[] | undefined;
 }
 /**
- * The argv a launched shell is handed ({@link launchedCommands}), spelled as `spell` spells the command line's words — one
- * argv per reading of the values its words may take. A word an escaping launcher joins (`sudo -s CMD…`) is handed as the
- * launcher hands it: each FIELD the command line's shell gives the launcher, escaped ({@link sudoEscaped}) — the field a
- * literal word spells, or each field the shell established for a word it rewrites first (`X='#'; sudo -s rm -r "$X" d`
- * hands `rm -r \# d`: the value is an operand, never a comment), a pattern's literal characters escaped and its pattern
- * characters bare ({@link launchedSpellingOf}). A word whose fields the reader does not know is handed AS WRITTEN: the
- * launched shell re-reads the expansion with the command line's quoting, so the word stays one argument (an unknown there)
- * and its neighbours stay theirs (`"#$Y" d` is never `#$Y d`). A reading gives each distinct word spelling one value — the
- * same word spelled twice expands alike — and words with several values are read in every combination of them (a value in
- * the program's position meets each operand); past {@link LAUNCHED_READINGS_MAX}
- * combinations reading `i` hands each word its `i`-th value (its last where it holds fewer) — every value of every word is
- * still read, the same word spelled twice takes one value per reading as the shell expands it, and the readings stay as
- * many as one word's values: their cost is linear in the command, whatever its length.
+ * The argv a launched shell is handed ({@link launchedCommands}), spelled as `spell` spells the command line's words in ONE
+ * reading of their names (the plan reads a segment once per combination of its names' values, `segmentReadingsOf` in
+ * shell-read-word.ts — a word's value here is its value in that reading). A word an escaping launcher joins (`sudo -s
+ * CMD…`) is handed as the launcher hands it: the FIELD the command line's shell gives the launcher, escaped
+ * ({@link sudoEscaped}) — the field a literal word spells, or the field the shell established for a word it rewrites first
+ * (`X='#'; sudo -s rm -r "$X" d` hands `rm -r \# d`: the value is an operand, never a comment), a pattern's literal
+ * characters escaped and its pattern characters bare ({@link launchedSpellingOf}). A word whose field the reader does not
+ * know is handed AS WRITTEN: the launched shell re-reads the expansion with the command line's quoting, so the word stays
+ * one argument (an unknown there) and its neighbours stay theirs (`"#$Y" d` is never `#$Y d`). Any other launcher hands a
+ * word's text as `spell.word` spells it.
  */
-export declare function spellLaunched(argv: readonly LexedWord[], args: readonly LaunchedArg[], spell: LaunchedSpelling): string[][];
+export declare function spellLaunched(argv: readonly LexedWord[], args: readonly LaunchedArg[], spell: LaunchedSpelling): string[];
 /** The argv index of the SCRIPT FILE a shell runs where its argv carries no text ({@link scriptSourceOf}). */
 export declare function scriptFileAt(basename: string, args: readonly string[]): number | undefined;
 /** One text that may arrive on a segment's standard input: `from` = its source as written (a here-document's body,
- *  `<<<WORD`, `<FILE`, `<&N`, the segment the pipe comes from); `literal` = the text, where the command spells it. */
+ *  `<<<WORD`, `<FILE`, `<&N`, the segment the pipe comes from); `literal` = the text, where the command spells it — a
+ *  here-document or here-string written in the command; never a pipe's text, which a program PRODUCES. */
 export interface StdinText {
     readonly from: string;
     readonly literal?: string;
 }
 /** What may arrive on a segment's standard input: each here-document (its descriptor is not read: every one counts) —
  *  its body, literal when quoted or when nothing in it expands — each here-string (literal when its word is), `<` file
- *  or `<&` descriptor written to no other descriptor, and the pipe it is reached through (`piped`) unless one of those
- *  three replaces it. */
-export declare function stdinTextsOf(segment: LexedSegment, piped: StdinText | undefined): StdinText[];
-/** What one segment (its argv) writes into the pipe after it: the text a printer spells ({@link printedText}) when its
- *  program word and every argument are literal, else only the segment as written. */
-export declare function pipedTextOf(segment: LexedSegment, argv: readonly LexedWord[]): StdinText;
+ *  or `<&` descriptor written to no other descriptor, and what it inherits (`fed`: the pipe it is reached through, the
+ *  pipe or the input of the group it stands in, the input of the shell running its text) unless one of those three
+ *  replaces it. */
+export declare function stdinTextsOf(segment: LexedSegment, fed: readonly StdinText[]): StdinText[];

package/dist/tools/fs/shell-reentry-text.js

@@ -1,6 +1,6 @@
 import { literalHeredocBody, literalTextOf } from "../../shell/lex.js";
 import { programBasename, readProgramPosition } from "./bash-program-position.js";
-import { implementationsOf, printedText, programRow, readArgRoles, selectedOptions } from "./program-read-model.js";
+import { implementationRejects, implementationsOf, programRow, readArgRoles, selectedOptions, targetUserOf } from "./program-read-model.js";
 import { namesStandardInput } from "./safety.js";
 export function codeBodies(basename, args) {
     const row = programRow(basename);
@@ -77,17 +77,27 @@ export function launchedCommands(argv, pos = readProgramPosition(argv)) {
     const row = programRow(programBasename(argv[runs.launcher].folded));
     const words = argv.slice(runs.from).map((w) => w.folded);
     const at = (k) => runs.from + k;
-    if (words.length === 0 || row?.launcher === undefined)
-        return [{ args: [] }];
-    if (row.launcher.shellText === "user")
+    if (row?.launcher?.shellText === "user")
         return userCommands(row, words, at);
+    const user = row === undefined ? undefined : targetUserOf(row, argv.slice(runs.launcher + 1, runs.from).map((w) => w.folded));
+    const as = user !== undefined ? { as: user } : {};
+    if (words.length === 0 || row?.launcher === undefined)
+        return [{ args: [], ...as }];
     if (row.launcher.shellText === "joined") {
-        const joined = words.flatMap((w, k) => (w.startsWith("-") ? [] : [at(k)]));
-        const attached = readArgRoles(row, words).flatMap((e) => (e.kind === "option" ? roleValue(e, "shell-text", words, at) ?? [] : []));
-        const texts = [...(joined.length === 0 ? [] : [{ joined }]), ...attached];
-        return texts.length === 0 ? [{ args: [] }] : texts.map((t) => ({ args: [{ fixed: "-c" }, t] }));
+        const texts = new Map();
+        for (const view of implementationsOf(row)) {
+            const events = readArgRoles(view, words);
+            const first = events.find((e) => e.kind === "operand" || e.kind === "dash-word-operand")?.at ?? words.length;
+            if (implementationRejects(row, view, words.slice(0, first)))
+                continue;
+            const joined = words.slice(first).map((_, k) => at(first + k));
+            const values = events.flatMap((e) => (e.kind === "option" || (e.kind === "value" && e.at < first) ? roleValue(e, "shell-text", words, at) ?? [] : []));
+            for (const t of [...(joined.length === 0 ? [] : [{ joined }]), ...values])
+                texts.set(JSON.stringify(t), t);
+        }
+        return texts.size === 0 ? [{ args: [], ...as }] : [...texts.values()].map((t) => ({ args: [{ fixed: "-c" }, t], ...as }));
     }
-    return [{ args: [{ fixed: "-c" }, { joined: words.map((_, k) => at(k)), escaped: true }] }];
+    return [{ args: [{ fixed: "-c" }, { joined: words.map((_, k) => at(k)), escaped: true }], ...as }];
 }
 function roleValue(e, kind, words, at) {
     if (e.kind === "value" && e.role?.kind === kind)
@@ -109,16 +119,18 @@ function userCommands(row, words, at) {
         const named = own.flatMap((e) => valued(e, "command") ?? []).at(-1);
         const fromEnvironment = selectedOptions(view, stops ? words.slice(0, end) : words, "one-implementation").some((o) => o.mode === "names-program");
         const program = named !== undefined ? { program: named } : fromEnvironment ? { program: { spelled: "\"$SHELL\"" } } : {};
+        const target = targetUserOf(view, stops ? words.slice(0, end) : words.filter((_, k) => k !== user), { name: user === undefined ? "root" : words[user], dash: operands[0]?.dash !== undefined });
+        const runs = { ...program, ...(target !== undefined ? { as: target } : {}) };
         if (stops) {
-            out.push({ ...program, args: user === undefined ? [] : words.slice(user + 1).map((_, k) => ({ at: at(user + 1 + k) })) });
+            out.push({ ...runs, args: user === undefined ? [] : words.slice(user + 1).map((_, k) => ({ at: at(user + 1 + k) })) });
             continue;
         }
         const rest = operands.filter((e) => user !== undefined && e.at > user).map((e) => ({ at: at(e.at) }));
         const texts = own.flatMap((e) => valued(e, "shell-text") ?? []);
         if (texts.length === 0)
-            out.push({ ...program, args: rest });
+            out.push({ ...runs, args: rest });
         for (const text of texts)
-            out.push({ ...program, args: [{ fixed: "-c" }, text, ...rest] });
+            out.push({ ...runs, args: [{ fixed: "-c" }, text, ...rest] });
     }
     return out;
 }
@@ -155,12 +167,10 @@ export function launchedInput(argv, pos, spell) {
         if (line === undefined && c.program !== undefined && "at" in c.program && c.program.from === undefined)
             programWords.push(c.program.at);
         const words = c.args.map((x) => ("at" in x && x.from === undefined ? x.at : undefined));
-        const args = asArgs(c.args);
-        return asTexts(c.args).map((texts, i) => ({ shell, texts, args: args[i], words }));
+        return [{ shell, texts: asTexts(c.args), args: asArgs(c.args), words, ...(c.as !== undefined ? { as: c.as } : {}) }];
     });
     return { shells, programWords, lines: [...lines] };
 }
-const LAUNCHED_READINGS_MAX = 64;
 function sudoEscaped(field) {
     return field.replace(/[^A-Za-z0-9_$-]/gu, (c) => `\\${c}`);
 }
@@ -168,20 +178,14 @@ function launchedSpellingOf(v) {
     return v.glob === true ? v.parts.map((p) => (p.pattern ? p.text : sudoEscaped(p.text))).join("") : sudoEscaped(v.spelled);
 }
 export function spellLaunched(argv, args, spell) {
-    const choicesOf = (k) => {
+    const field = (k) => {
         const literal = literalTextOf(argv[k].pieces);
         if (literal !== undefined)
-            return [sudoEscaped(literal)];
+            return sudoEscaped(literal);
         const values = spell.values?.(k);
-        return values === undefined ? [argv[k].raw] : values.map(launchedSpellingOf);
+        return values?.length === 1 ? launchedSpellingOf(values[0]) : argv[k].raw;
     };
-    const choices = new Map(args.flatMap((a) => ("joined" in a && a.escaped === true ? a.joined : [])).map((k) => [k, choicesOf(k)]));
-    const distinct = new Map([...choices].map(([k, c]) => [argv[k].raw, c]));
-    const combinations = [...distinct.values()].reduce((n, c) => n * c.length, 1);
-    const readings = combinations <= LAUNCHED_READINGS_MAX
-        ? [...distinct].reduce((acc, [w, c]) => acc.flatMap((r) => c.map((x) => new Map(r).set(w, x))), [new Map()]).map((r) => new Map([...choices.keys()].map((k) => [k, r.get(argv[k].raw)])))
-        : Array.from({ length: [...choices.values()].reduce((n, c) => Math.max(n, c.length), 1) }, (_, i) => new Map([...choices].map(([k, c]) => [k, c[Math.min(i, c.length - 1)]])));
-    return readings.map((reading) => args.map((a) => ("fixed" in a ? a.fixed : "at" in a ? spell.word(a.at, a.from ?? 0) : a.joined.map((k) => (a.escaped === true ? reading.get(k) : spell.word(k, 0))).join(" "))));
+    return args.map((a) => ("fixed" in a ? a.fixed : "at" in a ? spell.word(a.at, a.from ?? 0) : a.joined.map((k) => (a.escaped === true ? field(k) : spell.word(k, 0))).join(" ")));
 }
 export function scriptFileAt(basename, args) {
     const row = programRow(basename);
@@ -198,7 +202,7 @@ function scriptSourceOf(row, args) {
         return { stdin: true };
     return { file: first.at, stdin: options.some((e) => e.kind === "option" && e.reading === "speculative") };
 }
-export function stdinTextsOf(segment, piped) {
+export function stdinTextsOf(segment, fed) {
     const out = [];
     let replacesPipe = false;
     for (const t of segment.tokens) {
@@ -212,12 +216,5 @@ export function stdinTextsOf(segment, piped) {
             replacesPipe = true;
         }
     }
-    return piped === undefined || replacesPipe ? out : [piped, ...out];
-}
-export function pipedTextOf(segment, argv) {
-    const from = `${segment.text.trim()} |`;
-    const pos = readProgramPosition(argv);
-    const program = pos.program;
-    const literal = program === undefined || pos.refusal !== undefined || literalTextOf(argv[program.index].pieces) === undefined ? undefined : printedText(programRow(program.basename), argv.slice(program.index + 1).map((w) => literalTextOf(w.pieces)));
-    return literal === undefined ? { from } : { from, literal };
+    return replacesPipe ? out : [...fed, ...out];
 }

package/dist/tools/task-list.d.ts

@@ -96,8 +96,7 @@ export interface TaskListStore {
 export declare function normalizeTaskShape<T>(item: T): T;
 export declare function assertJsonMetadata(value: unknown, path?: string): void;
 /**
- * RB-274 — the contract's `list` order, mirroring the CC-compat backend's `orderIds`
- * (`stores/cc/task-list-store.ts`): numeric ids ascending (CC's own task order), any non-numeric id
+ * RB-274 — the contract's `list` order: numeric ids ascending (CC's own task order), any non-numeric id
  * after them, lexicographically. Ties broken lexicographically so the comparator is total (and the
  * order therefore stable across repeated calls, which the contract also requires).
  */

package/dist/tools/web.js

@@ -67,7 +67,7 @@ function assessGrounding(text, bytes) {
     return { level: low ? "low" : "ok", textChars, bytes, textRatio: Math.round(textRatio * 1000) / 1000 };
 }
 function recoveryToolRuledOut(ctx, toolName) {
-    if (ctx.excludeTools?.includes(toolName) ?? false)
+    if (ctx.toolSelector !== undefined && !ctx.toolSelector.admits({ name: toolName }))
         return true;
     const deferred = ctx.deferTools?.includes(toolName) ?? false;
     const pinnedInline = ctx.alwaysLoadTools?.includes(toolName) ?? false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "7.47.0",
+  "version": "7.49.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",
@@ -72,6 +72,7 @@
     "handoff:diff": "node scripts/dist-handoff-diff.mjs",
     "post-ship": "node scripts/post-ship.mjs",
     "gate:debts:rc": "node scripts/verify-debts.mjs --rc-gate",
+    "gate:rulings": "node scripts/rulings-gate.mjs --require-comms",
     "gate:error-surface": "node scripts/verify-error-surface.mjs",
     "gate:criteria": "node scripts/criteria-lint.mjs",
     "gate:reminder-literal": "node scripts/verify-reminder-literal.mjs",
@@ -89,7 +90,9 @@
     "gate:child-clamp-seats": "node scripts/verify-child-clamp-seats.mjs",
     "gate:spawn-sites": "node scripts/verify-spawn-sites.mjs",
     "gate:point-free-callbacks": "node scripts/verify-point-free-callbacks.mjs",
+    "gate:weak-identity": "node scripts/gate-weak-identity.mjs",
     "gate:docs-tool-names": "node scripts/verify-docs-tool-names.mjs",
+    "gate:credential-vocabulary": "node scripts/verify-credential-vocabulary.mjs",
     "gate:comment-ratio": "vitest run test/comment-ratio-ratchet.test.ts",
     "gate:negative-controls": "vitest run test/gate-negative-controls.test.ts",
     "gate:memory-ga": "node scripts/gate-memory-distillation-ga.mjs",