@sema-agent/core 7.48.0 → 7.49.1

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 };
-}

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

@@ -5,14 +5,14 @@
  * the segment it sits in ({@link rebasePlan}), unless it starts in a working directory of its own.
  */
 import type { LexedSegment } from "../../shell/lex.js";
-import type { BindingTable, FloorValue, NameReader } from "./shell-read-bindings.js";
+import type { BindingTable, FloorValue, InheritedFunctions, NameReader } from "./shell-read-bindings.js";
 import type { TargetUser } from "./program-read-model.js";
 import type { StdinText } from "./shell-reentry-text.js";
 import type { ReadCandidate, ShellReadPlan } from "./shell-read-plan.js";
 /** Where a nested text starts its names: a substitution body inherits the table of the segment it sits in (a subshell
- *  holds every variable); a text the shell runs later or elsewhere (a code body, `eval`'s text, a child shell's `-c`)
- *  starts from the text's own start — every name unknown, `HOME` the declared home unless the enclosing text binds it
- *  anywhere. `boundAnywhere` answers for the enclosing texts. */
+ *  holds every variable of the shell that forks it); a text the shell runs later or elsewhere (a code body, `eval`'s
+ *  text, a child shell's `-c`) starts from the text's own start — every name unknown, `HOME` the declared home unless
+ *  the enclosing text binds it anywhere. `boundAnywhere` answers for the enclosing texts. */
 export interface PlanStart {
     readonly initial: NameReader;
     readonly boundAnywhere: (name: string) => boolean;
@@ -23,9 +23,30 @@ export interface PlanStart {
     /** The working directories it starts in, where they are not the enclosing segment's (a login shell starts in its user's
      *  home; `"unmodelled"` — a home the text does not settle). */
     readonly bases?: readonly string[] | "unmodelled";
+    /** The thread of the shell that runs the text, where the text runs in that shell or a fork of it ({@link HeldThread}). */
+    readonly thread?: HeldThread;
+    /** What the shell around the text holds where the text runs in that shell or a fork of it — a literal `eval` text, a
+     *  substitution body, a text run later (a `trap` action): each function and builtin key as it stands there
+     *  ({@link InheritedFunctions}). A text a new process runs (a child shell's `-c`) holds none: every builtin enabled, no function. */
+    readonly names?: InheritedFunctions;
     /** What arrives on its own standard input (the input of the shell running it). */
     readonly stdin?: readonly StdinText[];
 }
+/** The thread of the shell that runs a text, at the segment that hands it on: a literal `eval` text is not a new plan but the next
+ *  segment of the same thread, so it starts in all of it and hands the working directory and the physical mode back; a substitution
+ *  body (a fork) and a text run later start in what the shell holds and hand nothing back. `functions`: the names a call may mean
+ *  (the shell's definition heads and the ones an `eval` text defines), `unread` those whose bodies the nested plan has not read — an
+ *  `eval` text reads the shell's bodies through the names they bind, every other text has none of them in front of it. */
+export interface HeldThread {
+    readonly physical: boolean;
+    readonly functions: ReadonlySet<string>;
+    readonly unread: ReadonlySet<string>;
+}
+/** What a shell holds at a segment, for a text that runs in it or in a fork of it ({@link PlanStart.names}): each function and builtin key
+ *  as it stands there, and the names a call to one of its functions may change — the ones the text reads a call of: an `eval` text names
+ *  the shell's functions (`bound`: what a call to one of them changes); a substitution body and a text run later read none of their bodies
+ *  (the shell's functions are {@link HeldThread.unread} there: a call to one makes every name unknown), so they name none. */
+export declare function heldAt(table: BindingTable, bound?: InheritedFunctions["bound"]): InheritedFunctions;
 /** What a segment says of the start of a text it hands a shell to run later: the deny floors of the words it holds as
  *  written, the user the shell runs as ({@link TargetUser}), and the shell's standard input. */
 export interface NestedStart {
@@ -52,6 +73,8 @@ export declare function stdinFeeds(segments: readonly LexedSegment[], start: rea
  * $(cat secret)`), so its relative candidates are re-based onto the ENCLOSING segment's bases — every base the
  * nested text derived from the start is carried over by prefix, an unsettled enclosing base leaves every
  * relative candidate unplaced, and absolute candidates are untouched. Recursive: a nested plan's own nested plans
- * derive from the same start.
+ * derive from the same start. A candidate left unplaced is judged where the text stood when it lost track (its floor,
+ * {@link ReadCandidate.floorBases}): the places the nested text was in move with it like its bases, and an enclosing segment that
+ * lost its base itself hands on its own floor (`floor`).
  */
-export declare function rebasePlan(plan: ShellReadPlan, from: string, to: ReadCandidate["bases"]): ShellReadPlan;
+export declare function rebasePlan(plan: ShellReadPlan, from: string, to: ReadCandidate["bases"], floor?: readonly string[]): ShellReadPlan;

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

@@ -1,3 +1,7 @@
+const NO_NAMES = new Set();
+export function heldAt(table, bound = NO_NAMES) {
+    return { start: (key) => table.stateOf(key), bound };
+}
 const ROOT_HOMES = ["/root", "/var/root"];
 export function startedAt(later, at) {
     if (at === undefined)
@@ -58,24 +62,27 @@ export function stdinFeeds(segments, start, piped) {
     };
     return fedAt;
 }
-export function rebasePlan(plan, from, to) {
+export function rebasePlan(plan, from, to, floor) {
     if (to !== "unmodelled" && to.length === 1 && to[0] === from)
         return plan;
     const fromSep = from.endsWith("/") || from.endsWith("\\") ? from : `${from}/`;
-    const moveBase = (b) => {
-        if (to === "unmodelled")
-            return [];
+    const moveInto = (into, b) => {
         if (b === from)
-            return [...to];
+            return [...into];
         if (b.startsWith(fromSep))
-            return to.map((t) => `${t.endsWith("/") || t.endsWith("\\") ? t : `${t}/`}${b.slice(fromSep.length)}`);
+            return into.map((t) => `${t.endsWith("/") || t.endsWith("\\") ? t : `${t}/`}${b.slice(fromSep.length)}`);
         return [b];
     };
+    const moveBase = (b) => (to === "unmodelled" ? [] : moveInto(to, b));
+    const floorAt = to === "unmodelled" ? floor : to;
+    const moveFloor = (bases, into) => [...new Set(bases.flatMap((b) => moveInto(into, b)))];
     const moveCandidate = (c) => {
-        if (c.bases === "unmodelled" || c.bases.length === 0)
+        if (c.bases === "unmodelled")
+            return c.floorBases === undefined || floorAt === undefined ? c : { ...c, floorBases: moveFloor(c.floorBases, floorAt) };
+        if (c.bases.length === 0)
             return c;
         if (to === "unmodelled")
-            return { ...c, bases: "unmodelled" };
+            return floor === undefined ? { ...c, bases: "unmodelled" } : { ...c, bases: "unmodelled", floorBases: moveFloor(c.bases, floor) };
         return { ...c, bases: [...new Set(c.bases.flatMap(moveBase))] };
     };
     return {
@@ -86,7 +93,7 @@ export function rebasePlan(plan, from, to) {
             redirects: s.redirects.map((r) => (r.target === undefined ? r : { ...r, target: moveCandidate(r.target) })),
             ...(s.baseMove !== undefined ? { baseMove: { target: typeof s.baseMove.target === "string" ? s.baseMove.target : moveCandidate(s.baseMove.target) } } : {}),
             bases: s.bases === "unmodelled" || to === "unmodelled" ? "unmodelled" : [...new Set(s.bases.flatMap(moveBase))],
-            nested: s.nested.map((n) => rebasePlan(n, from, to)),
+            nested: s.nested.map((n) => rebasePlan(n, from, to, floor)),
         })),
     };
 }

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

@@ -85,6 +85,10 @@ function overlaidTable(table, overlay) {
         isInteger: (name) => table.isInteger(name),
         ifsTouched: table.ifsTouched,
         homeTouched: table.homeTouched,
+        rebound: table.rebound,
+        providedByShell: (name) => table.providedByShell(name),
+        functionState: (name) => table.functionState(name),
+        builtinState: (name) => table.builtinState(name),
         floorOf: (name) => {
             const held = table.stateOf(name);
             return overlay.get(name) !== "unknown" || held === "unknown" ? table.floorOf(name) : [...table.floorOf(name), ...held.map(floorOf)];