@sema-agent/core 7.48.0 → 7.49.0

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

@@ -1,6 +1,7 @@
 import { hasWin32AliasedComponent, normalizeAbsPathLexically, withinAnyRoot } from "./safety.js";
 import { globInWord } from "./bash-readonly-classifier.js";
 import { readOfText } from "./shell-read-word.js";
+import { skipsRootsContainment } from "./containment-face.js";
 export const SHELL_READ_FINDINGS = Object.freeze(["deny_hit", "outside_roots", "unestablishable", "declined", "identity_changed", "none"]);
 export const SHELL_READ_SEATS = Object.freeze(["full_shell", "readonly", "rejudge"]);
 export const SHELL_READ_FINDING_RANK = {
@@ -37,11 +38,11 @@ export function judgeRead(read, boundary) {
             const folded = normalizeAbsPathLexically(view);
             const pattern = writeTarget ? boundary.writeDenyMatch(folded) : boundary.denyMatch(folded, walked);
             if (pattern !== null)
-                return { read, kind: "deny_hit", deny: { pattern, matchedView: folded, ...(writeTarget ? { face: "write" } : {}) }, containment: containmentOf(read, boundary) };
+                return { read, kind: "deny_hit", deny: { pattern, matchedView: folded, ...(writeTarget ? { face: "write" } : {}) }, containment: writeTarget ? writeContainmentOf(read, boundary) : containmentOf(read, boundary) };
         }
     }
     if (writeTarget)
-        return { read, kind: "none", containment: containmentOf(read, boundary) };
+        return judgeWrite(read, boundary);
     const containment = containmentOf(read, boundary);
     if (read.candidate.denyOnly === true)
         return { read, kind: "none", containment };
@@ -72,19 +73,45 @@ function containmentOf(read, boundary) {
         return "unknown";
     return withinAnyRoot(boundary.roots, read.target) ? "inside" : "outside";
 }
+const NULL_DEVICE = "/dev/null";
+function writeContainmentOf(read, boundary) {
+    const device = read.written?.seat === "landing" && read.candidate.expands === false && read.candidate.spelled === NULL_DEVICE;
+    if (read.written === undefined || read.candidate.denyOnly === true || device)
+        return "open";
+    const roots = boundary.writeRoots;
+    if (roots === undefined || read.target === undefined)
+        return "unknown";
+    return withinAnyRoot(roots, read.target) ? "inside" : "outside";
+}
+function judgeWrite(read, boundary) {
+    const containment = writeContainmentOf(read, boundary);
+    if (containment === "open")
+        return { read, kind: "none", containment };
+    if (read.established === "unestablishable" || boundary.writeRoots === undefined)
+        return { read, kind: "unestablishable", containment };
+    return { read, kind: containment === "outside" && !skipsRootsContainment(boundary.writeFace) ? "outside_roots" : "none", containment };
+}
 export function stationGuards(boundary) {
     return boundary.face !== "open" || boundary.denyMatch !== undefined;
 }
+export function writeFaceGuards(boundary) {
+    return !skipsRootsContainment(boundary.writeFace) || boundary.writeDenyMatch !== undefined;
+}
+export function anyFaceGuards(boundary) {
+    return stationGuards(boundary) || writeFaceGuards(boundary);
+}
 export function foldShellReadFindings(judged) {
     let best = { finding: "none" };
     let unestablished = false;
     const raise = (next) => {
         if (next.finding === "unestablishable" || next.finding === "declined") {
-            if (!judged.guards)
+            const face = next.witness?.read.candidate.face;
+            if (!(next.witness === undefined ? judged.guards || judged.writeGuards : face === "write" ? judged.writeGuards : judged.guards))
                 return;
             unestablished = true;
         }
-        if (SHELL_READ_FINDING_RANK[next.finding] > SHELL_READ_FINDING_RANK[best.finding])
+        const rank = SHELL_READ_FINDING_RANK[next.finding] - SHELL_READ_FINDING_RANK[best.finding];
+        if (rank > 0 || (rank === 0 && next.witness?.read.candidate.face === "write" && best.witness?.read.candidate.face !== "write"))
             best = next;
     };
     const walk = (j, denyOnly) => {
@@ -125,6 +152,7 @@ export function judgeEstablishedPlan(plan, established, boundary, nestedOf) {
             nested: segment.nested.map(nestedOf),
         })),
         guards: stationGuards(boundary),
+        writeGuards: writeFaceGuards(boundary),
     };
 }
 export function allFindings(judged) {
@@ -208,5 +236,6 @@ export function rejudge(judged, boundary) {
             nested: s.nested.map((n) => rejudge(n, boundary)),
         })),
         guards: stationGuards(boundary),
+        writeGuards: writeFaceGuards(boundary),
     };
 }

package/dist/tools/fs/shell-read-plan.d.ts

@@ -24,9 +24,9 @@
  *    and here-strings are data (an UNQUOTED here-document body's substitutions are nested plans) — except to a shell
  *    whose argv names no script: what arrives on its standard input is its script, a nested plan where the text spells it;
  *  · `$(…)`, backticks and `<(…)` bodies are nested plans; a word carrying one cannot be resolved from the text;
- *  · `cd` moves the base the LATER segments resolve against, as a candidate SET (`&&` proves a move, nothing
- *    else does); `pushd`/`popd` lose the base; a loop body with a base move is replayed per LITERAL beat and
- *    otherwise loses the base for what follows.
+ *  · the working-directory thread (`shell-read-workdir.ts`) moves the base the LATER segments resolve against, as a
+ *    candidate SET (`&&` proves a move, nothing else does), and gives `PWD` / `OLDPWD` their values; a loop body with
+ *    a base move is replayed per LITERAL beat and otherwise loses the base for what follows.
  * Every ambiguity resolves toward MORE candidates, never fewer.
  */
 import { type LenientConnector, type LexedRedirect, type LexedWord } from "../../shell/lex.js";
@@ -47,6 +47,9 @@ export interface ShellReadDeclarations {
     readonly cwd: string;
     readonly roots: readonly string[];
     readonly face?: "open" | "roots";
+    /** The `CDPATH` the shell starts with (the environment's declared one, `ExecutionEnv.cdPath`; a bare relative `cd` is
+     *  searched through it): absent ⇒ none declared, read as unset; `unknown` ⇒ the text cannot know it. */
+    readonly cdPath?: readonly string[] | "unknown";
 }
 export interface ReadCandidate {
     /** The folded word (quotes removed, a literal leading tilde spelled `./~`) — a pattern's name where nothing matches. */
@@ -70,10 +73,10 @@ export interface ReadCandidate {
     /** A home word the plan does not place (the text may rebind `HOME`, it sits in a value, or it is a literal tilde the
      *  program may expand itself): spelled with the DECLARED home. The judge reads it for deny rows ONLY. */
     readonly floorSpelled?: string;
-    /** A deny-floor shadow of a `floorSpelled` spelling, established as a read and judged for deny rows only. */
+    /** Deny rows only (never containment): a `floorSpelled` shadow, or the read copy of a word the program only writes. */
     readonly denyOnly?: true;
-    /** A WRITE target of the command (a `>`-family redirection, a `sed` `w` file, the operands of a file-writing command):
-     *  established like a read and judged against the deny table's WRITE face only — never for containment, never a read. */
+    /** A WRITE target (a `>`-family redirection, a `sed` `w` file, a file-writing command's operand): established like a
+     *  read, judged on the WRITE face — the write deny rows, then the write roots where written — never as a read. */
     readonly face?: "write";
     /** A reading the station takes where no row says the program opens the word — a word of a program with no row, a
      *  role only another implementation reads — so the filesystem decides it: `containment` = the spelling always meets
@@ -129,6 +132,9 @@ export interface ShellReadSegment {
     /** Substitution bodies, unquoted here-document substitutions, and re-entered shell text, each its own plan. */
     readonly nested: readonly ShellReadPlan[];
     readonly reach: SegmentReach;
+    /** The names a change that can reach this segment touched (`BindingTable.rebound`): any other name still holds what the
+     *  shell provides here. `all`: any name may have changed. */
+    readonly rebound: ReadonlySet<string> | "all";
 }
 export interface ShellReadPlan {
     readonly segments: readonly ShellReadSegment[];

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

@@ -1,13 +1,15 @@
 import { lexShell, PARSE_FAILURE_SENTENCE, substitutionsInHeredocBody, literalTextOf, literalTildeSpelling, } from "../../shell/lex.js";
 import { programTextOf, readOfText, readsOf, rewritten, segmentReadingsOf, settledFieldsOf, spelledWithHome, isArithmeticBody, unreadableSentenceOf } from "./shell-read-word.js";
 import { assignmentArithmetic, bare, listedVerbCandidates, pathSubcommandOf, programTextSentence, pushAssignment, roleReads, subscriptOnly, unlistedWords } from "./shell-read-argv.js";
-import { ARITHMETIC_TEST_OPERATORS, BindingThread, arithmeticSubstitutions, isArithmeticCommand, bindingEffectOf, loopListHeadAt, parameterBodySubstitutions, projectSegment, valueOf, } from "./shell-read-bindings.js";
-import { isShellSyntaxWord, programBasename, programPositionRunsShell, readProgramPosition, shellScanDeclineOf, } from "./bash-program-position.js";
+import { ARITHMETIC_TEST_OPERATORS, BindingThread, arithmeticSubstitutions, isArithmeticCommand, bindingEffectOf, joinRebound, loopListHeadAt, namesBoundIn, parameterBodySubstitutions, projectSegment, valueOf, } from "./shell-read-bindings.js";
+import { commandEnvironmentNames, isShellSyntaxWord, programBasename, programPositionRunsShell, readProgramPosition, shellScanDeclineOf, } from "./bash-program-position.js";
+import { WorkdirThread, baseShiftOf, textCalls, textMayMove, textMovesOf, textSetsPhysical, withCommandEnvironment } from "./shell-read-workdir.js";
 import { POLL_LOOP_MAX_BEATS, attachedOptionPayloads, resolveOperandLexically, isPathShapedToken, programTextSlotFiles, } from "./bash-readonly-classifier.js";
-import { BLOCK_WORD_NAMES, commandLineOf, commandLineOptionSpellings, declaredAttributes, isDeclarationBuiltin, isInertBuiltin, launcherOptionPathRole, launcherOptionStep, readOptionRole, programLanguageOf, programTextOpensOf, selectedOptions, movesBaseUnfollowed, opensNoOperand, programDelivery, programRow, readArgRoles, runsShellText, } from "./program-read-model.js";
-import { isAbsolutePathForm } from "./safety.js";
-import { codeBodies, launchedInput, pipedTextOf, reentryText, scriptFileAt, stdinTextsOf } from "./shell-reentry-text.js";
-import { plannedOnce, rebasePlan, startedAt, stdinFeeds } from "./shell-read-start.js";
+import { BLOCK_WORD_NAMES, commandLineOf, commandLineOptionSpellings, declaredAttributes, isDeclarationBuiltin, isInertBuiltin, launcherOptionPathRole, launcherOptionStep, readOptionRole, programLanguageOf, programTextOpensOf, selectedOptions, movesBaseByStack, opensNoOperand, programDelivery, programRow, readArgRoles, runsShellText, } from "./program-read-model.js";
+import { shellWordsOf } from "../../shell/shell-words.js";
+import { isAbsoluteForFamily } from "./safety.js";
+import { codeBodies, launchedInput, reentryText, scriptFileAt, stdinTextsOf } from "./shell-reentry-text.js";
+import { heldAt, plannedOnce, rebasePlan, startedAt, stdinFeeds } from "./shell-read-start.js";
 export const READ_CANDIDATE_PROVENANCES = Object.freeze([
     "operand",
     "option_value",
@@ -23,22 +25,26 @@ export const READ_CANDIDATE_PROVENANCES = Object.freeze([
     "object_path",
 ]);
 const NESTING_MAX = 4;
-const LOOP_END = new Set(["done"]), COPROC = new Set(["coproc"]);
-const BASE_CANDIDATE_MAX = 256;
+const LOOP_END = shellWordsOf("loop_end"), LOOP_CONDITION = shellWordsOf("loop_condition"), COPROC = shellWordsOf("background"), RESERVED = shellWordsOf("rule_reserved");
 export function planShellReads(command, decl, depth = 0, start) {
+    return planText(command, decl, depth, start).plan;
+}
+function planText(command, decl, depth, start, from) {
     const shape = { grouped: false, backgrounded: false, strayRedirection: false };
     if (depth > NESTING_MAX)
-        return { segments: [], unreadable: `command text nested more than ${NESTING_MAX} levels deep`, shape };
+        return { plan: { segments: [], unreadable: `command text nested more than ${NESTING_MAX} levels deep`, shape }, end: "unmodelled", physical: false };
     const lexed = lexShell(command);
     if ("parseFailure" in lexed)
-        return { segments: [], unreadable: PARSE_FAILURE_SENTENCE[lexed.parseFailure.reason], shape };
+        return { plan: { segments: [], unreadable: PARSE_FAILURE_SENTENCE[lexed.parseFailure.reason], shape }, end: "unmodelled", physical: false };
     const unreadable = unreadableSentenceOf(lexed, command);
     const projected = lexed.segments.map((segment) => projectSegment(segment));
     const named = projected.map((p, si) => bindingEffectOf(lexed.segments[si], p.argv, p, () => "unknown"));
     const boundHere = (name) => named.some((e) => e.all === "unknown" || e.bindings.some((b) => b.name === name));
     const boundAnywhere = (name) => boundHere(name) || start?.boundAnywhere(name) === true;
     const declaredHome = decl.homeDir !== undefined ? [{ spelled: decl.homeDir }] : "unknown";
-    const initial = start?.initial ?? ((name) => (name === "HOME" ? declaredHome : "unknown"));
+    const declaredCdPath = decl.cdPath === "unknown" ? "unknown" : [{ spelled: (decl.cdPath ?? []).join(":") }];
+    const declared = (name, rebound) => (rebound ? "unknown" : name === "HOME" ? declaredHome : name === "CDPATH" ? declaredCdPath : "unknown");
+    const initial = start?.initial ?? ((name) => declared(name, false));
     const loopShapes = projected.map((p) => loopShapeOf(p));
     const loopEndOf = new Map();
     {
@@ -53,26 +59,35 @@ export function planShellReads(command, decl, depth = 0, start) {
             }
         });
     }
-    const names = new BindingThread(lexed.segments, named, initial, boundAnywhere, loopEndOf, start?.homeTouched === true, start?.inherited);
-    const laterStart = { initial: (name) => (name === "HOME" && !boundAnywhere("HOME") ? declaredHome : "unknown"), boundAnywhere, homeTouched: boundAnywhere("HOME"), inherited: names.inheritedAt() };
-    const nestedPlanner = (table) => (text, kind, at) => planShellReads(text, decl, depth + 1, kind === "substitution" ? { initial: (name) => table.stateOf(name), boundAnywhere, homeTouched: table.homeTouched, inherited: table.inherited } : startedAt(laterStart, at));
+    const names = new BindingThread(lexed.segments, named, initial, boundAnywhere, loopEndOf, start?.homeTouched === true, start?.inherited, start?.names);
+    const laterStart = { initial: (name) => declared(name, boundAnywhere(name)), boundAnywhere, homeTouched: boundAnywhere("HOME"), inherited: names.inheritedAt() };
+    const nestedPlanner = (table, si) => (text, kind, at) => planShellReads(text, decl, depth + 1, kind === "substitution" ? { initial: (name) => table.stateOf(name), boundAnywhere, homeTouched: table.homeTouched, inherited: table.inherited, thread: heldThread(moves.functions), names: heldAt(table) } : startedAt(kind === "now" ? { ...laterStart, inherited: { ...laterStart.inherited, rebound: joinRebound(table.inherited.rebound, commandEnvironmentNames(projected[si].argv)) }, ...(readProgramPosition(projected[si].argv).program?.basename === "eval" ? { thread: heldThread(moves.unread), names: heldAt(table, names.functionBound()) } : {}) } : { ...laterStart, thread: heldThread(moves.functions, workdir.mayBePhysical || moves.physicalAt.some(Boolean)), names: names.heldAnywhere() }, at));
     const empty = lexed.segments.map((segment, si) => segmentIsEmpty(segment, projected[si]));
     const facts = projected.map(() => undefined);
     const tables = projected.map(() => undefined);
-    const fedAt = stdinFeeds(lexed.segments, start?.stdin ?? [], (si) => (facts[si - 1] === undefined ? [projected[si - 1].argv] : (facts[si - 1].readings ?? [facts[si - 1]]).map((f) => f.argv)).map((argv) => pipedTextOf(lexed.segments[si - 1], argv)));
+    const fedAt = stdinFeeds(lexed.segments, start?.stdin ?? [], (si) => [{ from: `${lexed.segments[si - 1].text.trim()} |` }]);
     const factsAt = (si, table) => {
         tables[si] ??= table;
-        return (facts[si] ??= segmentFacts(lexed.segments[si], projected[si], decl, table, nestedPlanner(table), fedAt(si)));
+        return (facts[si] ??= segmentFacts(lexed.segments[si], projected[si], decl, table, nestedPlanner(table, si), fedAt(si)));
     };
     const basesOf = projected.map(() => new Set());
     const unmodelled = projected.map(() => false);
-    let candidates = (start?.bases !== undefined && start.bases !== "unmodelled" ? start.bases : [decl.cwd]).map((base) => ({ base, skippedCd: -1 }));
-    let baseLost = start?.bases === "unmodelled";
-    let floorBases;
-    const loseBase = (reachable, floorTarget) => {
-        baseLost = true;
-        floorBases ??= [...new Set([...reachable.map((c) => c.base), ...(floorTarget !== undefined ? [floorTarget] : [])])];
+    const moves = textMovesOf(new Set(projected.flatMap((p) => p.defines)), projected.map((p) => p.argv), (si) => names.inFunctionBody(si), start?.thread);
+    names.runsBodies(moves.runsBodyAt, moves.bodiesAt.some((b) => b.length > 0), moves.mayCallAt.map((c, si) => (c ? commandEnvironmentNames(projected[si].argv) : undefined)));
+    const workdir = new WorkdirThread(from ?? start?.bases ?? [decl.cwd], depth === 0 || start?.bases !== undefined || from !== undefined, start?.thread?.physical === true);
+    const workdirContext = {
+        ...(decl.homeDir !== undefined ? { homeDir: decl.homeDir } : {}),
+        textBinds: boundAnywhere,
+        evalEnd: (text, c, table) => {
+            if (moves.bodyMoves && textCalls(text, moves.functions))
+                return { end: "unmodelled", physical: false };
+            if (!textMayMove(text, moves.functions) && !textSetsPhysical(text))
+                return { end: [c], physical: false };
+            const ran = planText(text, decl, depth + 1, { initial: (name) => table.stateOf(name), boundAnywhere, homeTouched: table.homeTouched, inherited: table.inherited, thread: heldThread(moves.unread), names: heldAt(table, names.functionBound()) }, [c]);
+            return { end: ran.end, physical: ran.physical };
+        },
     };
+    const heldThread = (unread, physical = workdir.mayBePhysical) => ({ physical, functions: moves.functions, unread });
     let andRunStart = 0;
     let crossedAllAnd = true;
     let crossedAnyOr = false;
@@ -89,55 +104,28 @@ export function planShellReads(command, decl, depth = 0, start) {
         }
         if (empty[si]) {
             if (!replay)
-                factsAt(si, names.tableAt(si, andRunStart));
+                factsAt(si, names.tableAt(si, andRunStart, workdir.where(andRunStart)));
             return;
         }
         if (previousEmitted >= 0 && !crossedAllAnd)
             andRunStart = crossedAnyOr ? si + 1 : si;
-        const f = replay ? facts[si] : factsAt(si, names.tableAt(si, andRunStart));
-        const pipeFed = f.connector === "|" || lexed.segments[si + 1]?.connector === "|";
-        reaches[si] ??= { andJoined: previousEmitted >= 0 && crossedAllAnd, orBroken: !crossedAllAnd && crossedAnyOr, moveProvable: f.moveProvable && !replay && !pipeFed };
+        const f = replay ? facts[si] : factsAt(si, names.tableAt(si, andRunStart, workdir.where(andRunStart)));
+        const pipeFed = f.connector === "|" || lexed.segments[si + 1]?.connector === "|", call = moves.callAt(si, tables[si]);
+        reaches[si] ??= { andJoined: previousEmitted >= 0 && crossedAllAnd, orBroken: !crossedAllAnd && crossedAnyOr, moveProvable: f.moveProvable && !replay && !pipeFed && !names.runsApart(si) };
         crossedAllAnd = true;
         crossedAnyOr = false;
         previousEmitted = si;
-        const reachable = candidates.filter((c) => c.skippedCd < andRunStart);
-        if (baseLost)
+        if (workdir.lost)
             unmodelled[si] = true;
         else
-            for (const c of reachable)
+            for (const c of workdir.reachable(andRunStart))
                 basesOf[si].add(c.base);
-        const move = f.baseMove;
-        if (move === undefined || baseLost)
-            return;
-        if (typeof move.target === "string" || move.target.expands !== false) {
-            loseBase(reachable, typeof move.target !== "string" ? move.target.floorSpelled : move.target === "home" ? decl.homeDir : undefined);
-            return;
-        }
-        const target = move.target.spelled;
-        const provable = reaches[si].moveProvable;
-        const branched = [];
-        for (const c of candidates) {
-            if (c.skippedCd < andRunStart) {
-                const moved = joinBase(c.base, target, decl.homeDir);
-                if (moved === undefined) {
-                    loseBase(reachable);
-                    return;
-                }
-                branched.push({ base: moved, skippedCd: c.skippedCd });
-            }
-            branched.push({ base: c.base, skippedCd: provable ? si : c.skippedCd });
-        }
-        const byBase = new Map();
-        for (const c of branched) {
-            const prior = byBase.get(c.base);
-            if (prior === undefined || c.skippedCd < prior.skippedCd)
-                byBase.set(c.base, c);
-        }
-        const next = [...byBase.values()];
-        if (next.length > BASE_CANDIDATE_MAX)
-            loseBase(reachable);
-        else
-            candidates = next;
+        if (moves.physicalAt[si])
+            workdir.setPhysical();
+        if (f.shift !== undefined && call !== "named")
+            workdir.shift(si, { shift: f.shift, provable: reaches[si].moveProvable && call === undefined, andRunStart, table: withCommandEnvironment(tables[si], projected[si].argv), cdable: moves.cdableFrom >= 0 && si > moves.cdableFrom }, workdirContext);
+        if (moves.losesBaseAt(si, tables[si]))
+            workdir.lose(si, workdir.reachable(andRunStart));
     };
     const bind = (si) => {
         const table = tables[si];
@@ -146,12 +134,16 @@ export function planShellReads(command, decl, depth = 0, start) {
         const end = loopEndOf.get(si);
         if (end !== undefined) {
             const body = named.slice(si + 1, end);
-            names.kill(si, body.some((e) => e.all === "unknown") ? "all" : body.flatMap((e) => e.bindings.map((b) => b.name)));
+            names.kill(si, body.some((e) => e.all === "unknown") ? "all" : [...body.flatMap((e) => e.bindings.map((b) => b.name)), ...(moves.mayMove.slice(si + 1, end).some(Boolean) ? ["PWD", "OLDPWD"] : [])]);
         }
         const segment = lexed.segments[si];
-        const effect = bindingEffectOf(segment, projected[si].argv, projected[si], (w, quoted, overlay) => valueOf(w, table, quoted, overlay));
+        const effect = bindingEffectOf(segment, projected[si].argv, projected[si], (w, quoted, overlay) => valueOf(w, table, quoted, overlay), moves.callAt(si, table), (builtin) => table.builtinState(builtin));
         const { all, ...rest } = effect;
         names.apply(si, all === "reset" ? rest : effect, segment.connector === "&&" || segment.connector === "||", end);
+        if (moves.callAt(si, table) !== undefined)
+            names.kill(si, moves.callsUnread(si, table) ? "all" : names.functionBound());
+        if (moves.bodiesAt[si].length > 0)
+            names.runsLater(si, moves.bodiesAt[si].reduce((held, b) => joinRebound(held, namesBoundIn(b)), names.functionBound()));
     };
     for (let si = 0; si < projected.length; si++) {
         const shapeOfLoop = loopShapes[si];
@@ -168,17 +160,15 @@ export function planShellReads(command, decl, depth = 0, start) {
         const frame = loops.pop();
         if (frame === undefined)
             continue;
-        const body = facts.slice(frame.bodyStart, si);
-        const moves = body.some((b) => b?.baseMove !== undefined);
-        if (!moves)
+        if (!facts.slice(frame.bodyStart, si).some((b, k) => b?.shift !== undefined || (tables[frame.bodyStart + k] !== undefined && moves.losesBaseAt(frame.bodyStart + k, tables[frame.bodyStart + k]))))
             continue;
         if (frame.beats === undefined) {
             for (let k = frame.bodyStart; k < si; k++)
                 unmodelled[k] = true;
-            loseBase(candidates.filter((c) => c.skippedCd < andRunStart));
+            workdir.lose(si, workdir.reachable(andRunStart));
             continue;
         }
-        for (let beat = 1; beat < frame.beats && !baseLost; beat++) {
+        for (let beat = 1; beat < frame.beats && !workdir.lost; beat++) {
             for (let k = frame.bodyStart; k < si; k++)
                 thread(k, true);
         }
@@ -195,14 +185,19 @@ export function planShellReads(command, decl, depth = 0, start) {
         if (threaded.empty)
             continue;
         const bases = unmodelled[si] ? "unmodelled" : [...basesOf[si]];
+        const floorBases = workdir.floorBases;
         const floor = unmodelled[si] && floorBases !== undefined && floorBases.length > 0 ? floorBases : undefined;
-        const withBases = (c) => {
+        const placedAt = (at, atFloor) => (c) => {
             const relative = relativeSpelling(c.spelled);
-            const here = c.provenance === "object_path" && bases !== "unmodelled" ? [...new Set(bases.flatMap(ancestorsOf))] : bases;
-            return { ...c, bases: relative ? here : [], ...(relative && floor !== undefined ? { floorBases: floor } : {}) };
+            const here = c.provenance === "object_path" && at !== "unmodelled" ? [...new Set(at.flatMap(ancestorsOf))] : at;
+            return { ...c, bases: relative ? here : [], ...(relative && atFloor !== undefined ? { floorBases: atFloor } : {}) };
         };
+        const withBases = placedAt(bases, floor);
         const move = threaded.baseMove;
         for (const f of threaded.readings ?? [threaded]) {
+            const moved = readProgramPosition(f.argv).launcherMovesBase;
+            const programPlaced = moved ? placedAt("unmodelled", bases !== "unmodelled" ? bases : floor) : withBases;
+            const programRead = (c) => (c.provenance === "stdin_redirect" ? withBases(c) : programPlaced(c));
             segments.push({
                 text: f.text,
                 connector: f.connector,
@@ -213,16 +208,17 @@ export function planShellReads(command, decl, depth = 0, start) {
                 ...(f.unreadProgramText !== undefined ? { unreadProgramText: f.unreadProgramText } : {}),
                 ...(f.stdin !== undefined ? { stdin: f.stdin } : {}),
                 declines: f.declines,
-                reads: dedupe(f.reads).map(withBases),
+                reads: dedupe(f.reads).map(programRead),
                 redirects: f.redirects.map((r) => (r.target === undefined ? { op: r.op, direction: r.direction } : { op: r.op, direction: r.direction, target: withBases(r.target) })),
                 ...(move !== undefined ? { baseMove: { target: typeof move.target === "string" ? move.target : withBases(move.target) } } : {}),
                 bases,
-                nested: f.nested.map((n) => (f.elsewhere?.has(n) === true ? n : rebasePlan(n, decl.cwd, bases))),
+                nested: f.nested.map((n) => (f.elsewhere?.has(n) === true ? n : rebasePlan(n, decl.cwd, moved && f.shellSide?.has(n) !== true ? "unmodelled" : bases, bases === "unmodelled" ? floor : bases))),
                 reach: reaches[si] ?? { andJoined: false, orBroken: false, moveProvable: false },
+                rebound: tables[si]?.rebound ?? "all",
             });
         }
     }
-    return { segments, shape, ...(unreadable !== undefined ? { unreadable } : {}) };
+    return { plan: { segments, shape, ...(unreadable !== undefined ? { unreadable } : {}) }, end: workdir.end(), physical: workdir.mayBePhysical };
 }
 function ancestorsOf(dir) {
     const out = [dir];
@@ -234,15 +230,14 @@ function parentOf(dir) {
     return resolveOperandLexically(dir, "..", undefined) ?? dir;
 }
 function loopShapeOf(p) {
-    const head = p.argv[0];
-    if (head === undefined)
+    if (p.argv[0] === undefined)
         return undefined;
     if (loopListHeadAt(p.argv) !== undefined)
         return "head";
-    if (isShellSyntaxWord(head, LOOP_END))
+    if (isShellSyntaxWord(p.argv[0], LOOP_END))
         return "end";
     const pos = readProgramPosition(p.argv);
-    return pos.controlWords.some((i) => p.argv[i].folded === "while" || p.argv[i].folded === "until") ? "head" : undefined;
+    return pos.controlWords.some((i) => LOOP_CONDITION.has(p.argv[i].folded)) ? "head" : undefined;
 }
 function segmentIsEmpty(segment, p) {
     if (p.argv.length > 0 || p.redirects.length > 0 || segment.substitutions.length > 0)
@@ -263,19 +258,22 @@ function segmentFacts(segment, p, decl, table, nestedPlan, fed) {
     if (readings.length === 1)
         return readingFacts(segment, { ...p, argv: readings[0].argv }, decl, readings[0], nestedPlan, fed);
     const once = plannedOnce(nestedPlan);
-    const each = readings.map((reading) => readingFacts(segment, { ...p, argv: reading.argv }, decl, reading, once, fed));
+    return readInSeveral(readings.map((reading) => readingFacts(segment, { ...p, argv: reading.argv }, decl, reading, once, fed)));
+}
+function readInSeveral(each) {
     const first = each[0];
     const move = each.find((f) => f.baseMove !== undefined)?.baseMove;
     return {
         ...first,
         moveProvable: false,
         ...(move !== undefined ? { baseMove: { target: typeof move.target === "string" ? move.target : { ...move.target, expands: "unresolvable" } } } : {}),
-        readings: each,
+        ...(each.some((f) => f.shift !== undefined) ? { shift: { kind: "lost" } } : {}),
+        readings: each.flatMap((f) => f.readings ?? [f]),
     };
 }
 function readingFacts(segment, p, decl, reading, nestedPlan, fed) {
     const table = reading.table;
-    const planner = (text, kind, at) => nestedPlan(text, kind, kind === "later" ? { ...at, floors: reading.floors } : at);
+    const planner = (text, kind, at) => nestedPlan(text, kind, kind !== "substitution" ? { ...at, floors: reading.floors } : at);
     const facts = segmentFactsRead(segment, p, decl, table, planner, fed, reading.reads);
     const unresolvedRaw = new Set();
     for (const t of segment.tokens) {
@@ -297,11 +295,13 @@ function readingFacts(segment, p, decl, reading, nestedPlan, fed) {
         return [unsettle(one), ...shadows];
     };
     const move = facts.baseMove;
+    const shift = facts.shift;
     return {
         ...facts,
         reads: facts.reads.flatMap(each),
         redirects: facts.redirects.map((r) => (r.target === undefined ? r : { ...r, target: unsettle(r.target) })),
         ...(move !== undefined && typeof move.target !== "string" ? { baseMove: { target: unsettle(move.target) } } : {}),
+        ...(shift?.kind === "cd" && typeof shift.target !== "string" ? { shift: { ...shift, target: unsettle(shift.target) } } : {}),
     };
 }
 function segmentFactsRead(segment, p, decl, table, nestedPlan, fed, toks) {
@@ -343,6 +343,7 @@ function segmentFactsRead(segment, p, decl, table, nestedPlan, fed, toks) {
     }
     if (unreadableHeredoc)
         nested.push({ segments: [], unreadable: "a here-document body carries a substitution this lexer cannot delimit", shape: { grouped: false, backgrounded: false, strayRedirection: false } });
+    const shellSide = new Set(nested);
     if (isArithmeticCommand(segment))
         ctx.reentered.push(...arithmeticSubstitutions(p.argv.map((w) => w.folded).join(" "), table));
     for (const t of segment.tokens) {
@@ -365,26 +366,31 @@ function segmentFactsRead(segment, p, decl, table, nestedPlan, fed, toks) {
     };
     const done = (f) => {
         const reentered = [...new Set(ctx.reentered)];
-        for (const body of reentered)
-            nested.push(nestedPlan(body, "later"));
+        for (const body of reentered) {
+            const plan = nestedPlan(body, "later");
+            nested.push(plan);
+            shellSide.add(plan);
+        }
         return {
             ...base,
             ...f,
             ...(reentered.length > 0 ? { reentry: "shell" } : {}),
             ...(f.unreadProgramText === undefined && ctx.programText !== undefined ? { unreadProgramText: ctx.programText } : {}),
             ...(elsewhere.size > 0 ? { elsewhere } : {}),
+            ...(shellSide.size > 0 ? { shellSide } : {}),
         };
     };
     const head = toks[0]?.folded;
-    if (isShellSyntaxWord(p.argv[0], COPROC) && toks.length > 1) {
-        const tail = (from) => ({ ...p, argv: p.argv.slice(from) });
-        const first = segmentFacts(segment, tail(1), decl, table, nestedPlan, fed);
-        if (toks.length < 3)
-            return { ...first, backgrounds: true };
-        const second = segmentFacts(segment, tail(2), decl, table, nestedPlan, fed);
-        const seen = new Set(first.nested.map((n) => JSON.stringify(n.segments.map((sg) => sg.text))));
-        const extraNested = second.nested.filter((n) => !seen.has(JSON.stringify(n.segments.map((sg) => sg.text))));
-        return { ...first, ...(second.reentry === "shell" ? { reentry: second.reentry } : {}), reads: [...first.reads, ...second.reads], nested: [...first.nested, ...extraNested], backgrounds: true };
+    const pos = readProgramPosition(p.argv);
+    const coproc = pos.written !== undefined && isShellSyntaxWord(p.argv[pos.written], COPROC) ? pos.written : undefined;
+    if (coproc !== undefined && toks.length > coproc + 1) {
+        const once = plannedOnce(nestedPlan);
+        const tail = (from) => ({ ...p, argv: p.argv.slice(coproc + from) });
+        const background = (f) => ({ ...f, backgrounds: true, ...(f.readings !== undefined ? { readings: f.readings.map((g) => ({ ...g, backgrounds: true })) } : {}) });
+        const first = segmentFacts(segment, tail(1), decl, table, once, fed);
+        if (toks.length < coproc + 3 || isShellSyntaxWord(p.argv[coproc + 1], RESERVED) || readProgramPosition(tail(2).argv.slice(0, 1)).refusal !== undefined)
+            return background(first);
+        return background(readInSeveral([first, segmentFacts(segment, tail(2), decl, table, once, fed)]));
     }
     const loop = loopShapeOf(p);
     if (loopListHeadAt(p.argv) !== undefined)
@@ -398,7 +404,6 @@ function segmentFactsRead(segment, p, decl, table, nestedPlan, fed, toks) {
         }
         return done({ empty: false, launcherChain: [], declines: [], reads, moveProvable: false });
     }
-    const pos = readProgramPosition(p.argv);
     const written = pos.written;
     if (written === undefined)
         return done({ empty: segmentIsEmpty(segment, p), launcherChain: [], declines: [], reads, moveProvable: false });
@@ -482,6 +487,7 @@ function segmentFactsRead(segment, p, decl, table, nestedPlan, fed, toks) {
         }
     }
     let reentry;
+    let shift;
     if (pos.argvFromStdin)
         reentry = "argv";
     const reenterShell = (verb, argvs) => {
@@ -500,7 +506,7 @@ function segmentFactsRead(segment, p, decl, table, nestedPlan, fed, toks) {
                         script(reentryText(shell, t, s.literal), user);
         }
         for (const { text, ...at } of scripts.values()) {
-            const plan = nestedPlan(text, "later", at);
+            const plan = nestedPlan(text, "now", at);
             nested.push(plan);
             if (at.as?.login === true)
                 elsewhere.add(plan);
@@ -511,14 +517,14 @@ function segmentFactsRead(segment, p, decl, table, nestedPlan, fed, toks) {
             if (file !== undefined)
                 reads.push(bare(file, "operand"));
         }
-        return done({ empty: false, launcherChain, verb, reentry: "shell", declines, reads, moveProvable: false, ...(loopHead !== undefined ? { loopHead } : {}), ...(stdin.length > 0 ? { stdin } : {}) });
+        return done({ empty: false, launcherChain, verb, reentry: "shell", declines, reads, moveProvable: false, ...(loopHead !== undefined ? { loopHead } : {}), ...(stdin.length > 0 ? { stdin } : {}), ...(shift !== undefined ? { shift } : {}) });
     };
     if (pos.refusal !== undefined) {
         const owner = programRow(programBasename(pos.refusal.owner));
         if (pos.refusal.kind === "option_at_program_position" && owner !== undefined && commandLineOptionSpellings(owner).length > 0) {
             const text = commandStringValue(owner, toks, pos.refusal.option);
             if (text !== undefined) {
-                nested.push(nestedPlan(text.value, "later"));
+                nested.push(nestedPlan(text.value, "now"));
                 reentry = "shell";
                 unlistedWords(reads, toks, text.next, launcherIndices, "unlisted_word", ctx);
                 return done({ empty: false, launcherChain, ...(verb !== undefined ? { verb } : {}), reentry, declines, reads, moveProvable: false, ...(loopHead !== undefined ? { loopHead } : {}) });
@@ -551,6 +557,12 @@ function segmentFactsRead(segment, p, decl, table, nestedPlan, fed, toks) {
     const programRead = toks[program.index];
     if (rewritten(programRead) || isPathShapedToken(programRead.folded))
         reads.push(bare(programRead, "program_path"));
+    if (rewritten(programRead) && !programRead.word.pieces.some((p) => p.literal?.includes("/") === true))
+        shift = { kind: "lost" };
+    if (basename === "eval")
+        shift = argReads.every((r) => literalTextOf(r.word.pieces) !== undefined) && reentryText("eval", texts) !== undefined ? { kind: "eval", text: reentryText("eval", texts) } : { kind: "lost" };
+    if (basename === "source" || basename === ".")
+        shift = { kind: "lost" };
     if (runsShellText(basename))
         return reenterShell(verb, [{ shell: basename, texts, args, words: argReads }]);
     const row = programRow(basename);
@@ -559,11 +571,16 @@ function segmentFactsRead(segment, p, decl, table, nestedPlan, fed, toks) {
         reentry = "interpreter";
     const moveProvable = pos.controlWords.length === 0 && pos.launchers.length === 0 && pos.assignments.length === 0 && program.name === basename;
     let baseMove;
+    const moving = baseShiftOf(basename, argReads, (r) => bare(r, "cd_target"));
+    if (moving !== undefined)
+        shift = moving.shift;
+    if (moving?.reported !== undefined)
+        baseMove = { target: moving.reported };
     if (basename === "cd") {
-        baseMove = cdMove(argReads, reads);
+        if (typeof baseMove?.target === "object")
+            reads.push(baseMove.target);
     }
-    else if (movesBaseUnfollowed(basename)) {
-        baseMove = { target: "unmodelled" };
+    else if (movesBaseByStack(basename)) {
         unlistedWords(reads, toks, program.index, launcherIndices, "unlisted_word", ctx, program);
     }
     else if (listed) {
@@ -631,6 +648,7 @@ function segmentFactsRead(segment, p, decl, table, nestedPlan, fed, toks) {
         declines,
         reads,
         ...(baseMove !== undefined ? { baseMove } : {}),
+        ...(shift !== undefined ? { shift } : {}),
         moveProvable,
         ...(loopHead !== undefined ? { loopHead } : {}),
     });
@@ -648,10 +666,7 @@ function dedupe(reads) {
     return out;
 }
 function relativeSpelling(spelled) {
-    return !(isAbsolutePathForm(spelled) || spelled.startsWith("~"));
-}
-function joinBase(base, target, homeDir) {
-    return resolveOperandLexically(base, target, homeDir);
+    return !(isAbsoluteForFamily("own", spelled) || spelled.startsWith("~"));
 }
 function redirectFact(r, table, homeDir) {
     if (r.target === undefined)
@@ -692,13 +707,3 @@ function literalBeats(toks) {
             return undefined;
     return words.length <= POLL_LOOP_MAX_BEATS ? words.length : undefined;
 }
-function cdMove(args, reads) {
-    const target = args.find((t) => !t.folded.startsWith("-") || t.folded === "-");
-    if (target === undefined)
-        return { target: "home" };
-    if (target.folded === "-")
-        return { target: "previous" };
-    const c = bare(target, "cd_target");
-    reads.push(c);
-    return { target: c };
-}