@sema-agent/core 7.53.0 → 7.54.0

package/dist/internal/llm.js

@@ -1 +1 @@
-export { createAssistantMessageEventStream, DATA_LABEL_UNSAFE, ensureToolTurnInvariants, isTextBlock, MODEL_OUTPUT_INVALID_CAUSES, quoteDataLabel, renderContentBlock, renderUserAttachmentView, snapshotActorAssertion, stampStreamDrops, streamDropsOf, stripEngineMetadata, TOOL_TURN_INCOMPLETE_CAUSES, TOOL_TURN_REPAIR_DROPS, userAttachmentOf } from "../engine/llm/index.js";
+export { createAssistantMessageEventStream, DATA_LABEL_UNSAFE, ensureToolTurnInvariants, findToolByName, isTextBlock, MODEL_OUTPUT_INVALID_CAUSES, quoteDataLabel, renderContentBlock, renderUserAttachmentView, snapshotActorAssertion, stampStreamDrops, streamDropsOf, stripEngineMetadata, TOOL_TURN_INCOMPLETE_CAUSES, TOOL_TURN_REPAIR_DROPS, userAttachmentOf } from "../engine/llm/index.js";

package/dist/orchestration/run-workflow-tool.d.ts

@@ -192,6 +192,9 @@ export interface RunWorkflowToolDeps {
      *  the ladder/gate placement. Absent ⇒ nothing extra travels (the rootSessionId chain is the
      *  placement root through prepare's mint middle segment). */
     placementRoot?: string;
+    /** The host run tree's cross-boundary token (`RunInternals.crossBoundaryTree`), riding deps for the same auto-mounted-ctx reason as
+     *  `rootSessionId` above; handed to the workflow run so every workflow-spawned agent joins the host tree's state. */
+    crossBoundaryTree?: import("../core/cross-boundary-taint.js").CrossBoundaryTreeToken;
     /** Process-local unified task registry. When present, RunWorkflow returns `task_id === runId` with a `w*` id. */
     taskRegistry?: TaskRegistry;
     /** design/115 P2 core slice: run-local task-notification sink for SDK event + live model XML injection.

package/dist/orchestration/run-workflow-tool.js

@@ -494,6 +494,7 @@ async function mountRunWorkflowTool(d) {
                     ...(d.originatingSessionId !== undefined ? { originatingSessionId: d.originatingSessionId } : {}),
                     ...((ctx.rootSessionId ?? d.rootSessionId ?? d.originatingSessionId) !== undefined ? { rootSessionId: ctx.rootSessionId ?? d.rootSessionId ?? d.originatingSessionId } : {}),
                     ...((ctx.placementRoot ?? d.placementRoot) !== undefined ? { placementRoot: ctx.placementRoot ?? d.placementRoot } : {}),
+                    ...((ctx.crossBoundaryTreeForChildren ?? d.crossBoundaryTree) !== undefined ? { crossBoundaryTree: ctx.crossBoundaryTreeForChildren ?? d.crossBoundaryTree } : {}),
                     ...(workflowTaskId !== undefined ? { runId: workflowTaskId } : {}),
                     journalStore: d.journalStore,
                     ...(resumeFromRunId !== undefined ? { resumeFromRunId } : {}),

package/dist/orchestration/workflow-governance.d.ts

@@ -92,7 +92,7 @@ export interface WorkflowAgentSpec extends ScriptClampSeats {
  * restricting value, an add-only row through the row's script and entry laws. A row marked inherited-only (its
  * restricting value switches off an operator-side record) is outside this set and is stripped like any other key.
  */
-export declare const WHITELIST_KEYS: readonly ("thinking" | "systemPrompt" | "objective" | "images" | "limits" | ScriptSeat | "modelName")[];
+export declare const WHITELIST_KEYS: readonly ("objective" | "images" | "thinking" | "systemPrompt" | "limits" | ScriptSeat | "modelName")[];
 /**
  * #505 ② — ACCEPTED ALIAS SPELLINGS on the spec: `alias → the {@link WHITELIST_KEYS} member it means`.
  *

package/dist/orchestration/workflow.d.ts

@@ -359,6 +359,9 @@ export interface RunWorkflowOptions {
      *  placed at the ladder/gate root. Absent ⇒ nothing extra travels (the rootSessionId chain is the
      *  placement root through prepare's mint middle segment). */
     placementRoot?: string;
+    /** The host run tree's cross-boundary token (`RunInternals.crossBoundaryTree`, threaded by the run-workflow tool): every
+     *  workflow-spawned agent joins the tree it names, so a bit a workflow agent sets is read by the host and its siblings. */
+    crossBoundaryTree?: import("../core/cross-boundary-taint.js").CrossBoundaryTreeToken;
     /** design/149 — the PROCESS-level child observer (same seam as
      *  {@link import("../core/types.js").RunnerDeps.onBackgroundChildEvent}). When set, every workflow
      *  agent emits spawn/tick/terminal {@link import("../core/types.js").BackgroundChildEvent} frames with a

package/dist/orchestration/workflow.js

@@ -120,7 +120,7 @@ export function applyWorkflowAgentType(spec, agentType, registry) {
     if (out.memoryPersistenceCapable === undefined && def.memoryPersistenceCapable !== undefined)
         out.memoryPersistenceCapable = def.memoryPersistenceCapable;
     if (def.allowTools !== undefined || def.denyTools !== undefined) {
-        const perType = createAllowDenyPolicy({ ...(def.allowTools ? { allow: def.allowTools } : {}), ...(def.denyTools ? { deny: deniedToolNamesOf(`workflow agentType "${def.name}"`, def.denyTools) } : {}), scope: "narrowing" });
+        const perType = createAllowDenyPolicy({ ...(def.allowTools ? { allow: def.allowTools } : {}), ...(def.denyTools ? { deny: deniedToolNamesOf(`workflow agentType "${def.name}"`, def.denyTools) } : {}) });
         out.toolPolicy = out.toolPolicy ? combinePolicies(out.toolPolicy, perType) : perType;
     }
     return out;
@@ -725,6 +725,7 @@ export function startWorkflow(runner, fn, opts = {}, internals) {
         ...(agentCeiling !== undefined ? { toolCeiling: agentCeiling } : {}),
         ...((opts.rootSessionId ?? opts.originatingSessionId) !== undefined ? { rootSessionId: opts.rootSessionId ?? opts.originatingSessionId } : {}),
         ...(opts.placementRoot !== undefined ? { placementRoot: opts.placementRoot } : {}),
+        ...(opts.crossBoundaryTree !== undefined ? { crossBoundaryTree: opts.crossBoundaryTree } : {}),
         ...(opts.originatingSessionId !== undefined ? { parentSessionId: opts.originatingSessionId } : {}),
     };
     const captureFloorSeatsNow = async () => {

package/dist/prompt-assembly/catalog/schema.d.ts

@@ -33,6 +33,9 @@ export interface BandRow {
  *  task (`TaskSpec.promptRole`); absent ⇒ `general`. */
 export declare const HOST_ROLES: readonly ["general", "code", "coordinator", "cowork"];
 export type HostRole = (typeof HOST_ROLES)[number];
+/** Membership test for {@link HostRole} — the one reading of "is this a role base the engine selects": the task door
+ *  (`TaskSpec.promptRole`) and the overlay grammar (`when.host.role`) both ask it. */
+export declare function isHostRole(v: unknown): v is HostRole;
 /** The host form: `minimal` leaves the core-behavior band out (the locked bands stay). Written only by
  *  `TaskSpec.promptForm`; absent ⇒ `standard`. */
 export declare const HOST_FORMS: readonly ["standard", "minimal"];

package/dist/prompt-assembly/catalog/schema.js

@@ -3,6 +3,9 @@ export function isWordOf(words, v) {
 }
 export const OVERLAY_OPS = Object.freeze(["replace", "append", "add", "drop"]);
 export const HOST_ROLES = Object.freeze(["general", "code", "coordinator", "cowork"]);
+export function isHostRole(v) {
+    return isWordOf(HOST_ROLES, v);
+}
 export const HOST_FORMS = Object.freeze(["standard", "minimal"]);
 export const PROMPT_TRAITS = Object.freeze(["lean_prompt", "fable_5_mitigations"]);
 export const PROMPT_FACT_NAMES = Object.freeze([

package/dist/prompt-assembly/overlay.js

@@ -3,7 +3,7 @@ import { describeFault, isPlainRecord, receive } from "../core/mods/kernel/recei
 import { egressText } from "../core/untrusted-egress.js";
 import { bandOf, isBandId } from "./bands.js";
 import { SEMA_DEFAULT_CATALOG, catalogMessage } from "./catalog/index.js";
-import { HOST_FORMS, HOST_ROLES, OVERLAY_OPS, PROMPT_FACT_NAMES, PROMPT_TRAITS, isWordOf, } from "./catalog/schema.js";
+import { HOST_FORMS, HOST_ROLES, OVERLAY_OPS, PROMPT_FACT_NAMES, PROMPT_TRAITS, isHostRole, isWordOf, } from "./catalog/schema.js";
 import { RENDERERS } from "./renderers.js";
 import { canonicalWhen } from "./select.js";
 export const OVERLAY_SOURCE_ORDER = Object.freeze(["bundled", "task", "center", "deploy"]);
@@ -125,7 +125,7 @@ function whenViolation(when) {
         if (typeof h !== "object" || h === null || Array.isArray(h))
             return `"when.host" is not an object`;
         for (const [k, v] of Object.entries(h)) {
-            if (k === "role" ? !isWordOf(HOST_ROLES, v) : k === "form" ? !isWordOf(HOST_FORMS, v) : true) {
+            if (k === "role" ? !isHostRole(v) : k === "form" ? !isWordOf(HOST_FORMS, v) : true) {
                 return `"when.host" carries ${str(k)} = ${str(v)} (role: ${HOST_ROLES.join(" | ")}; form: ${HOST_FORMS.join(" | ")})`;
             }
         }

package/dist/prompt-assembly/select.js

@@ -1,4 +1,4 @@
-import { HOST_ROLES, isWordOf } from "./catalog/schema.js";
+import { HOST_ROLES, isHostRole } from "./catalog/schema.js";
 export function promptTraitsOf(facts) {
     const traits = new Set();
     if (facts.promptProfile !== "classic")
@@ -32,7 +32,7 @@ export function resolveHost(task) {
             code: "config.prompt_selector_invalid",
         });
     };
-    const role = task.promptRole === undefined ? undefined : isWordOf(HOST_ROLES, task.promptRole) ? task.promptRole : refuse("promptRole", task.promptRole, HOST_ROLES);
+    const role = task.promptRole === undefined ? undefined : isHostRole(task.promptRole) ? task.promptRole : refuse("promptRole", task.promptRole, HOST_ROLES);
     const form = task.promptForm === undefined ? undefined : task.promptForm === "minimal" ? "minimal" : refuse("promptForm", task.promptForm, ["minimal"]);
     return Object.freeze({ ...(role !== undefined ? { role } : {}), ...(form !== undefined ? { form } : {}) });
 }

package/dist/prompts/default.d.ts

@@ -46,7 +46,7 @@ export declare const MEMORY_SAFETY = "## Memory\nWhen you save a durable note to
 export declare const MEMORY_HYGIENE = "What's worth saving \u2014 organize by topic, not by when it happened:\n- who the user is \u2014 role, expertise, durable preferences;\n- guidance the user gave on HOW to work \u2014 corrections and confirmed approaches, with the reason why;\n- ongoing goals or constraints that aren't derivable from the code or its history;\n- pointers to external resources (URLs, dashboards, tickets).\n\nHygiene:\n- Convert relative dates (\"yesterday\", \"last week\") to absolute dates, so the note stays interpretable later.\n- Before saving, check what memory already holds: update an existing note rather than writing a near-duplicate, and remove a note that turns out to be wrong.\n- Don't save what the code, its history, or this conversation already records (structure, past fixes, transient task state). If asked to remember something obvious, save what was non-obvious about it instead.";
 /**
  * The full memory guidance = safety + hygiene, in the original order. Kept as a single exported
- * constant for back-compat and for a deployment composing the no-consolidation form in one piece;
+ * constant for back-compat (RL-1336-memory-guidance) and for a deployment composing the no-consolidation form in one piece;
  * core injects none of the three (RB-482 #16). Prefer {@link MEMORY_SAFETY} / {@link MEMORY_HYGIENE}
  * when you need the split.
  */

package/dist/shell/lex.d.ts

@@ -12,7 +12,7 @@ export declare const EXPANSION_KINDS: readonly ["parameter", "command", "process
 export type ExpansionKind = (typeof EXPANSION_KINDS)[number];
 /** Why a word's value cannot be read off the text. Each member is a spelling whose value the text does not
  *  contain — never "the lexer did not look". */
-export declare const UNRESOLVED_REASONS: readonly ["ansi_c_escape", "locale_string", "parameter_text", "subscript_text", "compound_array_value"];
+export declare const UNRESOLVED_REASONS: readonly ["ansi_c_escape", "locale_string", "parameter_text", "subscript_text", "compound_array_value", "trailing_backslash"];
 export type UnresolvedReason = (typeof UNRESOLVED_REASONS)[number];
 /** The sentence a consumer hands on for an unresolved word: every reason is one a face ASKS about (the locale
  *  string included — its translation is not in the text), and a deny row is still judged on the written spelling
@@ -23,9 +23,10 @@ export declare const UNRESOLVED_SENTENCE: {
     readonly parameter_text: "a parameter expansion carries text this lexer does not read";
     readonly subscript_text: "a subscript carries text this lexer does not read";
     readonly compound_array_value: "a compound assignment value is a list this lexer does not read";
+    readonly trailing_backslash: "a backslash ends the command, which the shell versions read differently (3.2 drops it, 5 keeps it)";
 };
 /** Why a command yields no segments: bash's own syntax errors and the two constructs this lexer cannot delimit. */
-export declare const PARSE_FAILURE_REASONS: readonly ["unterminated_single_quote", "unterminated_double_quote", "unterminated_ansi_c", "unterminated_subscript", "unterminated_compound_value", "unterminated_command_substitution", "unterminated_process_substitution", "unterminated_parameter_expansion", "unterminated_heredoc", "undelimited_substitution", "redirect_without_target", "heredoc_without_delimiter", "heredoc_delimiter_expands"];
+export declare const PARSE_FAILURE_REASONS: readonly ["unterminated_single_quote", "unterminated_double_quote", "unterminated_ansi_c", "unterminated_subscript", "unterminated_compound_value", "unterminated_command_substitution", "unterminated_process_substitution", "unterminated_parameter_expansion", "unterminated_arithmetic_expansion", "unterminated_heredoc", "undelimited_substitution", "redirect_without_target", "heredoc_without_delimiter", "heredoc_delimiter_expands"];
 export type ParseFailureReason = (typeof PARSE_FAILURE_REASONS)[number];
 export declare const PARSE_FAILURE_SENTENCE: {
     readonly unterminated_single_quote: "a single-quoted word never closes";
@@ -36,6 +37,7 @@ export declare const PARSE_FAILURE_SENTENCE: {
     readonly unterminated_command_substitution: "a command substitution never terminates";
     readonly unterminated_process_substitution: "a process substitution never terminates";
     readonly unterminated_parameter_expansion: "a parameter expansion never terminates";
+    readonly unterminated_arithmetic_expansion: "an arithmetic expansion never terminates";
     readonly unterminated_heredoc: "a here-document body never terminates";
     readonly undelimited_substitution: "a command substitution carries a construct this lexer cannot delimit";
     readonly redirect_without_target: "a redirection names no target";
@@ -76,7 +78,9 @@ export interface WordPiece {
 }
 export interface WordExpansion {
     readonly kind: ExpansionKind;
-    /** `"many"` where the result is word-split (an unquoted parameter or command substitution, a brace list, a glob). */
+    /** `"many"` where the result may be zero or several words: word-split (an unquoted parameter, command or arithmetic
+     *  substitution), a brace list, a glob, or a parameter expanded once per element even in double quotes (`"$@"`,
+     *  `"${a[@]}"`, `"${!prefix@}"`). */
     readonly yields: "one" | "many";
     /** The text between the delimiters, where there is one (a substitution body, a brace list, a tilde-prefix). */
     readonly body?: string;
@@ -93,6 +97,9 @@ export interface WordExpansion {
         readonly written: string;
         readonly judged: string;
     };
+    /** The expansions a brace list or a bracket class encloses (`{${a[n]},x}`, `[$x]`): they run before the pattern is
+     *  formed. Absent when it encloses none. */
+    readonly inner?: readonly WordExpansion[];
 }
 export interface QuotedSpan {
     /** Offsets into {@link LexedWord.raw}, `[start, end)`; the quote characters belong to their span. */
@@ -154,7 +161,8 @@ export interface LexedWord {
  *  output form and `0` for an input form, is the reader's to apply). */
 export interface LexedRedirect {
     readonly kind: "redirect";
-    readonly op: "<" | ">" | ">>" | "<<<" | "&>" | "&>>" | ">&" | "<&";
+    /** `<>` opens its target for reading AND writing (creating it), on descriptor 0 unless one is written. */
+    readonly op: "<" | ">" | ">>" | "<<<" | "<>" | "&>" | "&>>" | ">&" | "<&";
     readonly fd?: number;
     readonly target?: LexedWord;
     readonly dup?: string;
@@ -192,6 +200,9 @@ export interface LexedSegment {
     readonly tokens: readonly LexedToken[];
     /** The bodies of the substitutions found in THIS segment (its words and its redirection targets), in order. */
     readonly substitutions: readonly string[];
+    /** The bodies among {@link substitutions} of a function or value substitution (`${ list; }`, `${| list; }`): their list
+     *  runs in the CURRENT shell, so what it assigns or where it moves outlives the word. Absent when there is none. */
+    readonly currentShell?: readonly string[];
 }
 export interface LexedCommand {
     readonly segments: readonly LexedSegment[];
@@ -203,6 +214,10 @@ export interface LexParseFailure {
         readonly reason: ParseFailureReason;
         readonly at: number;
     };
+    /** The segments the walk read before it stopped, the last one holding the tokens it had read when it stopped. Bash runs
+     *  each complete line before it parses the next one (`rm -r x` on line 1 runs although line 2 never closes its quote),
+     *  so a reader asking what the text MAY run reads these as runs; a reader asking what the text DOES reads the failure. */
+    readonly readBefore: readonly LexedSegment[];
 }
 /** A command: its segments, or the one reason it has none. */
 export type ShellLex = LexedCommand | LexParseFailure;
@@ -222,7 +237,7 @@ export declare const SHELL_CONTROL_PREFIXES: ReadonlySet<string>;
  * Does the `$` at `at` OPEN a quote form (`$'…'` / `$"…"`)? ONE question, asked by every walker that has to
  * answer it. Escaped means an ODD run of backslashes in front of it: `\$'y'` is a literal `$`, while `x\\$'y'`
  * is a literal backslash followed by a real ANSI-C quote. Counting the run is what a one-character peek behind
- * cannot do.
+ * cannot do. The quote may follow line continuations bash removes first (`$\<newline>"…"` is `$"…"`).
  */
 export declare function dollarOpensQuote(text: string, at: number): boolean;
 /** The `'` that CLOSES the ANSI-C quote opened at `open`, or `undefined` when none does. `\'` does not close
@@ -236,12 +251,75 @@ export declare function literalTildeSpelling(word: string): string;
 export declare function argvOf(segment: LexedSegment): readonly LexedWord[];
 /** The two-spelling view of {@link argvOf}, for the readers that compare spellings. */
 export declare function wordsOf(segment: LexedSegment): SegmentTokens;
-/** The substitution bodies of an UNQUOTED here-document body: `$(…)` and backticks are live there, quotes are
- *  ordinary characters, a backslash protects the next character. `undefined` when a substitution never closes. */
+/** One expansion of an unquoted here-document body; `unresolved` where the parameter text is one this lexer does not
+ *  read (`${x:-$(…)}`, a nested `${…}`) — what it may assign or run is then not in the facts. */
+export interface HeredocExpansion {
+    readonly expansion: WordExpansion;
+    readonly unresolved?: "parameter_text";
+    /** A function or value substitution ({@link opensCurrentShellSubstitution}): its list runs in the current shell. */
+    readonly currentShell?: true;
+}
+/** The expansions of an UNQUOTED here-document body, in order: `$(…)`, `$((…))`, `$[…]` and backticks, `${ …; }` /
+ *  `${| …; }`, `${…}` and `$NAME`. The body expands as double-quoted text does: quotes are ordinary characters, a backslash
+ *  protects the next character, nothing is word-split. `undefined` when an expansion never closes. */
+export declare function expansionsInHeredocBody(body: string): readonly HeredocExpansion[] | undefined;
+/** The substitution bodies of an UNQUOTED here-document body (the command and arithmetic members of
+ *  {@link expansionsInHeredocBody}, a function / value substitution marked `currentShell`). `undefined` when an
+ *  expansion never closes. */
 export declare function substitutionsInHeredocBody(body: string): {
     readonly body: string;
     readonly kind: "command" | "arithmetic";
+    readonly currentShell?: true;
 }[] | undefined;
+/** Can expanding an unquoted here-document body run a program the text does not show ({@link expansionHidesRun} over
+ *  its expansions)? A body whose expansions cannot be delimited, a parameter text this lexer does not read, and a
+ *  process-substitution opener (text to bash in a body; read here as one — the side that judges more) all count. */
+export declare function heredocBodyHidesRun(body: string): boolean;
+/** A `${…}` body read once, past its head ({@link PARAMETER_HEAD}): the texts bash evaluates as arithmetic — the subscript
+ *  (`a[i]`, `#a[i]`, `!a[i]`: up to the first `]`, or to the end where none closes) and a substring expansion's offset and
+ *  length (`x:off:len`, `*:N+=1`, after a closed subscript or none; not the `:-` `:=` `:+` `:?` operators). A line
+ *  continuation is removed first. The one reading of the body grammar: the deny lanes and auto-background ask whether
+ *  either text names a variable ({@link expansionHidesRun}), the read station re-enters what either runs. */
+export declare function parameterArithmeticTexts(body: string): {
+    readonly subscript?: string;
+    readonly offset?: string;
+};
+/**
+ * Can evaluating this expansion run a program the text does not show? A command or process substitution runs one. The
+ * arithmetic evaluator evaluates a NAME recursively (`a='x[$(…)]'; $((a))`), so arithmetic text that names a variable or
+ * carries a `$` may run one, and so may a parameter expansion's subscript or substring offset, its own or one nested in
+ * its text (`${x:-${a[i]}}`); a parameter, brace or glob text carrying a substitution opener runs what it opens.
+ */
+export declare function expansionHidesRun(e: WordExpansion): boolean;
+/** Can a compound assignment's value `(…)` run what its text does not show? The lexer keeps the value one opaque piece
+ *  (its elements unread), so any `$` or backquote in it may (`(${P@P})`, `(${!N})`, `(${x:-$(…)})`), and so may a `[…]`
+ *  subscript the evaluator reads — one naming a variable (`([x]=1)`), or carrying a `$` or backquote, an ANSI-C `$'…'`
+ *  among them (`([$'\170']=1)`: bash decodes `\170` to the name `x` and evaluates it). A `$'…'` is not counted OUTSIDE a
+ *  `[…]` — a standalone element opens an ANSI-C string and runs nothing (`($'\t' x)`) — but inside a subscript it is (the
+ *  `[…]` arm's char class holds `$`). (An integer array's ANSI-C ELEMENT, `declare -ai A=($'\170')`, decodes and
+ *  evaluates too, but needs the `-i` attribute the value text does not carry — not caught here, see KNOWN-LIMITS.) Its
+ *  command substitutions are the segment's already. The one reading the deny lanes, the read station and
+ *  auto-background share until the value is read element by element. */
+export declare function compoundValueHidesRun(w: {
+    readonly assignment?: AssignmentFact;
+}): boolean;
+/** Does the parameter body (`P@P`, `a[i]@P`) carry a transformation that EVALUATES the value — `${P@P}` expands P's value
+ *  as a prompt string, its parameter, command and arithmetic expansions run (measured on 5.3) — rather than respelling it? */
+export declare function transformEvaluates(body: string): boolean;
+/** Does evaluating a parameter expansion with this body RE-READ the parameter's own VALUE — an indirect `${!R}` (R's
+ *  value names what is then expanded, so `R='a[$(…)]'` evaluates that subscript; a name list `${!prefix*}` / a key list
+ *  `${!a[@]}` expand names only) or an evaluating transform `${P@P}` (the value is expanded as a prompt string, its own
+ *  expansions run)? The one reading every consumer uses for "the value runs what the text does not show": the read
+ *  station asks (it does not follow the value), the deny lanes and auto-background read it a hidden run through
+ *  {@link expansionHidesRun}. A subscript or substring offset re-reads the BODY's own text, not the value — that is
+ *  {@link parameterArithmeticTexts}. A line continuation in the body is removed first (`${P@\⏎P}` is `${P@P}`). */
+export declare function parameterRereadsValue(body: string): boolean;
+/** Is the arithmetic text (an arithmetic command's interior) provably free of a variable — the same reading
+ *  {@link expansionHidesRun} gives an arithmetic expansion? */
+export declare function arithmeticTextIsPlain(text: string): boolean;
+/** Does `word`, standing right before the redirection `next`, name the descriptor that redirection opens (`{fd}>file`):
+ *  a bare `{NAME}` that belongs to the operator rather than to the argv? */
+export declare function namesRedirectDescriptor(word: LexedWord, next: LexedToken | undefined): boolean;
 /** The text a word's pieces hand the program when every piece is literal; `undefined` when one is an expansion or
  *  unresolved. */
 export declare function literalTextOf(pieces: readonly WordPiece[]): string | undefined;
@@ -249,7 +327,8 @@ export declare function literalTextOf(pieces: readonly WordPiece[]): string | un
  *  backquote or a backslash is removed (a line continuation was joined when the body was read), every other character
  *  stands. `undefined` when an unescaped `$` or backquote stands in it: the program reads what the expansion makes. */
 export declare function literalHeredocBody(body: string): string | undefined;
-/** Lex a command: its segments, or the one reason bash (or this lexer) cannot delimit them. */
+/** Lex a command: its segments, or the one reason bash (or this lexer) cannot delimit them — with the segments read
+ *  before it ({@link LexParseFailure.readBefore}). */
 export declare function lexShell(source: string): ShellLex;
 /**
  * The refused-reading view of {@link lexShell}: a parse failure, and any word whose value cannot be read off the