@sema-agent/core 7.47.0 → 7.49.0

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

@@ -1,12 +1,15 @@
 import { lexShell, PARSE_FAILURE_SENTENCE, substitutionsInHeredocBody, literalTextOf, literalTildeSpelling, } from "../../shell/lex.js";
-import { programTextOf, readOfText, readsOf, renamed, rewritten, settledFieldsOf, spelledWithHome, isArithmeticBody, unreadableSentenceOf } from "./shell-read-word.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, parameterBodySubstitutions, projectSegment, valueOf, } from "./shell-read-bindings.js";
-import { 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, 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 { 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",
@@ -22,21 +25,26 @@ export const READ_CANDIDATE_PROVENANCES = Object.freeze([
     "object_path",
 ]);
 const NESTING_MAX = 4;
-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();
     {
@@ -51,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) => planShellReads(text, decl, depth + 1, kind === "substitution" ? { initial: (name) => table.stateOf(name), boundAnywhere, homeTouched: table.homeTouched, inherited: table.inherited } : laterStart);
+    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) => [{ from: `${lexed.segments[si - 1].text.trim()} |` }]);
     const factsAt = (si, table) => {
         tables[si] ??= table;
-        const piped = si > 0 && lexed.segments[si].connector === "|" ? pipedTextOf(lexed.segments[si - 1], projected[si - 1].argv) : undefined;
-        return (facts[si] ??= segmentFacts(lexed.segments[si], projected[si], decl, table, nestedPlanner(table), piped));
+        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 = [{ base: decl.cwd, skippedCd: -1 }];
-    let baseLost = false;
-    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;
@@ -87,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];
@@ -144,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];
@@ -166,58 +160,65 @@ 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);
         }
     }
     const planned = facts.map((f) => f);
-    const inert = depth === 0 && unreadable === undefined && planned.every(segmentOpensNothing);
-    const settled = inert ? planned.map((f) => ({ ...f, reads: f.reads.filter((c) => c.provenance !== "env_assignment") })) : planned;
+    const inert = depth === 0 && unreadable === undefined && planned.every((f) => (f.readings ?? [f]).every(segmentOpensNothing));
+    const settled = inert ? planned.map((f) => ({ ...f, reads: f.reads.filter((c) => c.provenance !== "env_assignment"), ...(f.readings !== undefined ? { readings: f.readings.map((g) => ({ ...g, reads: g.reads.filter((c) => c.provenance !== "env_assignment") })) } : {}) })) : planned;
     shape.grouped = projected.some((p) => p.grouped);
-    shape.backgrounded = lexed.segments.some((s) => s.connector === "&") || settled.some((f) => f.backgrounds === true);
+    shape.backgrounded = lexed.segments.some((s) => s.connector === "&") || settled.some((f) => (f.readings ?? [f]).some((g) => g.backgrounds === true));
     shape.strayRedirection = projected.some((p) => p.argv.length === 0 && p.redirects.length > 0);
     const segments = [];
     for (let si = 0; si < settled.length; si++) {
-        const f = settled[si];
-        if (f.empty)
+        const threaded = settled[si];
+        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 } : {}) };
         };
-        segments.push({
-            text: f.text,
-            connector: f.connector,
-            argv: f.argv,
-            launcherChain: f.launcherChain,
-            ...(f.verb !== undefined ? { verb: f.verb } : {}),
-            ...(f.reentry !== undefined ? { reentry: f.reentry } : {}),
-            ...(f.unreadProgramText !== undefined ? { unreadProgramText: f.unreadProgramText } : {}),
-            ...(f.stdin !== undefined ? { stdin: f.stdin } : {}),
-            declines: f.declines,
-            reads: dedupe(f.reads).map(withBases),
-            redirects: f.redirects.map((r) => (r.target === undefined ? { op: r.op, direction: r.direction } : { op: r.op, direction: r.direction, target: withBases(r.target) })),
-            ...(f.baseMove !== undefined ? { baseMove: { target: typeof f.baseMove.target === "string" ? f.baseMove.target : withBases(f.baseMove.target) } } : {}),
-            bases,
-            nested: f.nested.map((n) => rebasePlan(n, decl.cwd, bases)),
-            reach: reaches[si] ?? { andJoined: false, orBroken: false, moveProvable: false },
-        });
+        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,
+                argv: f.argv,
+                launcherChain: f.launcherChain,
+                ...(f.verb !== undefined ? { verb: f.verb } : {}),
+                ...(f.reentry !== undefined ? { reentry: f.reentry } : {}),
+                ...(f.unreadProgramText !== undefined ? { unreadProgramText: f.unreadProgramText } : {}),
+                ...(f.stdin !== undefined ? { stdin: f.stdin } : {}),
+                declines: f.declines,
+                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, 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];
@@ -229,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 (head.raw === head.folded && (head.folded === "for" || head.folded === "select") && BLOCK_WORD_NAMES.has(head.folded))
+    if (loopListHeadAt(p.argv) !== undefined)
         return "head";
-    if (head.raw === head.folded && head.folded === "done" && BLOCK_WORD_NAMES.has(head.folded))
+    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)
@@ -252,8 +252,29 @@ function segmentOpensNothing(f) {
     const inertProgram = program === undefined || (program.name === program.basename && isInertBuiltin(program.basename) && !(isDeclarationBuiltin(program.basename) && f.argv.slice(at + 1).some((w) => /^[-+]/.test(w.folded))));
     return inertProgram && f.argv.every((w) => !/[[\]$`]/.test(w.raw)) && f.nested.length === 0 && f.reentry === undefined && f.declines.length === 0 && f.launcherChain.length === 0 && f.redirects.every((r) => r.direction !== "in") && f.reads.every((c) => c.provenance === "env_assignment");
 }
-function segmentFacts(segment, p, decl, table, nestedPlan, piped) {
-    const facts = segmentFactsRead(segment, p, decl, table, nestedPlan, piped);
+function segmentFacts(segment, p, decl, table, nestedPlan, fed) {
+    const targets = p.redirects.flatMap((r) => (r.target === undefined ? [] : [r.target]));
+    const readings = segmentReadingsOf(p.argv, targets, table, decl.homeDir);
+    if (readings.length === 1)
+        return readingFacts(segment, { ...p, argv: readings[0].argv }, decl, readings[0], nestedPlan, fed);
+    const once = plannedOnce(nestedPlan);
+    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" } } } : {}),
+        ...(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 !== "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) {
         const w = t.kind === "word" ? t : t.kind === "redirect" ? t.target : undefined;
@@ -269,20 +290,23 @@ function segmentFacts(segment, p, decl, table, nestedPlan, piped) {
     };
     const unsettle = (c) => floor((unresolvedRaw.has(c.raw) || (homeWithheld && c.spelled.startsWith("~"))) && c.expands !== "unresolvable" ? { ...c, expands: "unresolvable" } : c);
     const each = (c) => {
-        const { alternatives, floors, ...one } = c;
-        const shadows = (floors ?? []).map((v) => ({ spelled: v.spelled, raw: one.raw, provenance: one.provenance, expands: v.glob === true ? "glob" : false, denyOnly: true }));
-        return [...[one, ...(alternatives ?? []).map((a) => ({ ...renamed(one, a.spelled), ...a }))].map(unsettle), ...shadows];
+        const { floors, ...one } = c;
+        const shadows = (floors ?? []).map((v) => ({ spelled: v.spelled, ...(v.pattern !== undefined ? { pattern: v.pattern } : {}), raw: one.raw, provenance: one.provenance, expands: v.glob === true ? "glob" : false, denyOnly: true }));
+        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.alternatives !== undefined ? { ...each(move.target)[0], expands: "unresolvable" } : move.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, piped) {
+function segmentFactsRead(segment, p, decl, table, nestedPlan, fed, toks) {
     const nested = [];
+    const elsewhere = new Set();
     const ctx = { table, reentered: [], programTextSeen: false };
     const arithmetic = segment.tokens.flatMap((t) => (t.kind === "word" ? t : t.kind === "redirect" ? t.target : undefined)?.pieces ?? []).flatMap((q) => (q.expansion?.kind === "arithmetic" && q.expansion.body !== undefined && isArithmeticBody(q.expansion.body) ? [q.expansion.body] : []));
     const count = (list, body) => list.filter((b) => b === body).length;
@@ -319,6 +343,7 @@ function segmentFactsRead(segment, p, decl, table, nestedPlan, piped) {
     }
     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) {
@@ -339,33 +364,38 @@ function segmentFactsRead(segment, p, decl, table, nestedPlan, piped) {
         redirects,
         nested,
     };
-    const toks = readsOf(p.argv, table, decl.homeDir);
     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 (head === "coproc" && toks[0].raw === head && toks.length > 1) {
-        const tail = (from) => ({ ...p, argv: p.argv.slice(from) });
-        const first = segmentFacts(segment, tail(1), decl, table, nestedPlan, piped);
-        if (toks.length < 3)
-            return { ...first, backgrounds: true };
-        const second = segmentFacts(segment, tail(2), decl, table, nestedPlan, piped);
-        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 (head !== undefined && toks[0].raw === head && BLOCK_WORD_NAMES.has(head)) {
-        if (loop === "head")
-            return done({ empty: false, launcherChain: [], declines: [], reads, moveProvable: false, loopHead: { beats: literalBeats(toks) } });
+    if (loopListHeadAt(p.argv) !== undefined)
+        return done({ empty: false, launcherChain: [], declines: [], reads, moveProvable: false, loopHead: { beats: literalBeats(toks) } });
+    if (head !== undefined && isShellSyntaxWord(p.argv[0], BLOCK_WORD_NAMES)) {
         if (head === "[[") {
             toks.forEach((r, i) => {
                 if (ARITHMETIC_TEST_OPERATORS.has(toks[i - 1]?.folded ?? "") || ARITHMETIC_TEST_OPERATORS.has(toks[i + 1]?.folded ?? "") || toks[i - 1]?.folded === "-v")
@@ -374,7 +404,6 @@ function segmentFactsRead(segment, p, decl, table, nestedPlan, piped) {
         }
         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 });
@@ -413,7 +442,7 @@ function segmentFactsRead(segment, p, decl, table, nestedPlan, piped) {
                 if (!w.startsWith("-") || w === "-")
                     break;
                 const step = launcherOptionStep(row, w);
-                if (step === undefined)
+                if (step === undefined || (step === 2 && j + 1 >= chainEnd))
                     break;
                 if (step === 2) {
                     const role = launcherOptionPathRole(row, w);
@@ -458,28 +487,44 @@ function segmentFactsRead(segment, p, decl, table, nestedPlan, piped) {
         }
     }
     let reentry;
+    let shift;
     if (pos.argvFromStdin)
         reentry = "argv";
     const reenterShell = (verb, argvs) => {
-        const stdin = stdinTextsOf(segment, piped);
-        const scripts = argvs.flatMap(({ shell, texts: t, args: a }) => [reentryText(shell, t), reentryText(shell, a), ...stdin.map((s) => (s.literal === undefined ? undefined : reentryText(shell, t, s.literal)))]);
-        for (const t of new Set(scripts))
-            if (t !== undefined)
-                nested.push(nestedPlan(t, "later"));
+        const stdin = stdinTextsOf(segment, fed);
+        const scripts = new Map();
+        const script = (text, at) => { if (text !== undefined)
+            scripts.set(JSON.stringify([text, at]), { ...at, text }); };
+        for (const { shell, texts: t, args: a, as } of argvs) {
+            const user = as !== undefined ? { as } : {};
+            const argvText = [reentryText(shell, t), reentryText(shell, a)];
+            for (const text of argvText)
+                script(text, { ...user, ...(stdin.length > 0 ? { stdin } : {}) });
+            if (argvText.every((text) => text === undefined))
+                for (const s of stdin)
+                    if (s.literal !== undefined)
+                        script(reentryText(shell, t, s.literal), user);
+        }
+        for (const { text, ...at } of scripts.values()) {
+            const plan = nestedPlan(text, "now", at);
+            nested.push(plan);
+            if (at.as?.login === true)
+                elsewhere.add(plan);
+        }
         for (const { shell, args: a, words } of argvs) {
             const at = shell === "source" || shell === "." ? a.findIndex((w) => !w.startsWith("-") || w === "-") : scriptFileAt(shell, a);
             const file = at === undefined ? undefined : words[at];
             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 commandLine = commandLineOptionSpellings(programRow(programBasename(pos.refusal.owner)));
-        if (pos.refusal.kind === "option_at_program_position" && commandLine.length > 0) {
-            const text = commandStringValue(commandLine, toks, pos.refusal.option);
+        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 } : {}) });
@@ -512,6 +557,12 @@ function segmentFactsRead(segment, p, decl, table, nestedPlan, piped) {
     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);
@@ -520,11 +571,16 @@ function segmentFactsRead(segment, p, decl, table, nestedPlan, piped) {
         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) {
@@ -592,42 +648,11 @@ function segmentFactsRead(segment, p, decl, table, nestedPlan, piped) {
         declines,
         reads,
         ...(baseMove !== undefined ? { baseMove } : {}),
+        ...(shift !== undefined ? { shift } : {}),
         moveProvable,
         ...(loopHead !== undefined ? { loopHead } : {}),
     });
 }
-function rebasePlan(plan, from, to) {
-    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 [];
-        if (b === from)
-            return [...to];
-        if (b.startsWith(fromSep))
-            return to.map((t) => `${t.endsWith("/") || t.endsWith("\\") ? t : `${t}/`}${b.slice(fromSep.length)}`);
-        return [b];
-    };
-    const moveCandidate = (c) => {
-        if (c.bases === "unmodelled" || c.bases.length === 0)
-            return c;
-        if (to === "unmodelled")
-            return { ...c, bases: "unmodelled" };
-        return { ...c, bases: [...new Set(c.bases.flatMap(moveBase))] };
-    };
-    return {
-        ...plan,
-        segments: plan.segments.map((s) => ({
-            ...s,
-            reads: s.reads.map(moveCandidate),
-            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)),
-        })),
-    };
-}
 function dedupe(reads) {
     const seen = new Set();
     const out = [];
@@ -641,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)
@@ -655,21 +677,15 @@ function redirectFact(r, table, homeDir) {
         return { op: r.op, direction: "in" };
     return { op: r.op, direction: "out", target: bare(readsOf([r.target], table, homeDir)[0], "write_redirect_target") };
 }
-function commandStringValue(options, toks, option) {
+function commandStringValue(row, toks, option) {
     const at = toks.findIndex((r) => r.folded === option);
-    if (at < 0)
+    const line = at < 0 ? undefined : commandLineOf(row, option);
+    if (line === undefined)
         return undefined;
-    for (const spelling of options) {
-        if (option === spelling) {
-            const value = toks[at + 1] === undefined ? undefined : programTextOf(toks[at + 1]);
-            return value === undefined ? undefined : { value, next: at + 2 };
-        }
-        if (spelling.startsWith("--") && option.startsWith(`${spelling}=`))
-            return { value: option.slice(spelling.length + 1), next: at + 1 };
-        if (!spelling.startsWith("--") && option.startsWith(spelling) && option.length > spelling.length)
-            return { value: option.slice(spelling.length), next: at + 1 };
-    }
-    return undefined;
+    if (line !== "next")
+        return { value: line.attached, next: at + 1 };
+    const value = toks[at + 1] === undefined ? undefined : programTextOf(toks[at + 1]);
+    return value === undefined ? undefined : { value, next: at + 2 };
 }
 function literalBeats(toks) {
     const at = toks.findIndex((r) => r.folded === "in");
@@ -691,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 };
-}