@sema-agent/core 7.52.0 → 7.54.0

package/dist/tools/fs/read-deny-home.d.ts

@@ -41,7 +41,7 @@ export declare function readDenyLinksOf(env: ExecutionEnv, entries: readonly {
 /**
  * Which rows one placement reads, and where their heads are spelled:
  *  · `home` — the home-anchored rows (`~/…`), under each home; the row's run anchors it there;
- *  · `root` — the ROOTED rows (`/app/config-lkg.json`, {@link isRootedReadDenyPattern}), under the filesystem root; the run
+ *  · `root` — the ROOTED rows (`/app/config-lkg.json`, {@link readDenyRowAnchor} `root`), under the filesystem root; the run
  *    anchors it there. A root is no home: read whether or not a home answered;
  *  · `unanchored` — the rows that open with the configuration directory's name (`~/.sema/…`, {@link agentConfigDirTail})
  *    under each spelling of the root the host declares for that directory (`RunnerDeps.agentConfigDir`): the head BELOW

package/dist/tools/fs/read-deny-home.js

@@ -4,7 +4,7 @@ import { DEFAULT_GATE_AWAIT_TIMEOUT_MS, withGateTimeout } from "../../core/gate-
 import { thrownText } from "../../core/thrown-value.js";
 import { agentConfigDirTail } from "../../core/agent-config-dir.js";
 import { validatePath } from "../../core/effective-path-target.js";
-import { isRootedReadDenyPattern, readDenyPatternRun, readDenyRunHead } from "./read-deny.js";
+import { readDenyPatternRun, readDenyRowAnchor, readDenyRunHead } from "./read-deny.js";
 export const AUXILIARY_HOME_PROBE_MS = 2_000;
 const said = new Set();
 function sayOnce(kind, line) {
@@ -126,13 +126,14 @@ function anchoredRowsOf(entries, anchor) {
     return rows;
 }
 function rowHeadOf(pattern, caseSensitive, anchor) {
+    const rowAnchor = readDenyRowAnchor(pattern);
     if (anchor.at === "root") {
-        const head = isRootedReadDenyPattern(pattern) ? literalHeadOf(pattern) : "";
+        const head = rowAnchor === "root" ? literalHeadOf(pattern) : "";
         return head.length > 0 ? head : undefined;
     }
-    const { homeAnchored, run } = readDenyPatternRun(pattern);
-    if (!homeAnchored)
+    if (rowAnchor !== "home")
         return undefined;
+    const { run } = readDenyPatternRun(pattern);
     if (anchor.at === "unanchored") {
         const tail = agentConfigDirTail(run, caseSensitive);
         return tail === undefined ? undefined : literalHeadOf(tail);

package/dist/tools/fs/read-deny.d.ts

@@ -456,9 +456,22 @@ export declare function matchSegmentPatterns(path: string, compiled: readonly Co
 /** One entry's refusal under the deny list's entry law ({@link normalizeEntry}, the compiler's own), or `undefined` when the
  *  entry is lawful — the law read without compiling, for a door that judges a list before anything folds it. */
 export declare function readDenyEntryProblem(entry: unknown, layer: string): string | undefined;
-/** Is a canonical pattern ROOTED — placed at the filesystem root ({@link ReadDenyEntry})? Only {@link canonicalReadDenyPattern}
- *  puts a leading `/` on a canonical pattern, so the text is the whole answer. */
-export declare function isRootedReadDenyPattern(canonical: string): boolean;
+/** Where a deny row is anchored ({@link readDenyRowAnchor}): the filesystem root, the execution environment's home, or nowhere. */
+export type ReadDenyRowAnchorWord = "root" | "home" | "none";
+/**
+ * WHERE a deny row is anchored, as the one word every reader of a row asks: `home` — a HOME-anchored row (its first segment is
+ * exactly {@link READ_DENY_HOME_WORD}): its run starts right below the execution environment's home; `root` — a ROOTED row (it
+ * opens with `/` and is not home-anchored): its run starts at the first segment of an absolute path; `none` — an unanchored row,
+ * which may match anywhere in a judged path. The compiler's placement, the linked-location pass, the band's "has anything to
+ * place" test, the head a mount resolves for a row and the canonical spelling itself all read the anchor here, so a row has one
+ * anchor however many faces ask.
+ *
+ * The pattern is read as given and gives the answer its canonical form gives, so a spelling and its canonical form are one row
+ * (`//etc` and `/etc` are both `root`; `/~/x` is `~/x`, so `home`: a leading `/` before the home word is no root). Whether the
+ * text is a LEGAL row (no backslash, at least one segment below its anchor) is not asked here: that is
+ * {@link persistedReadDenyEntryProblem} and the compiler's refusal.
+ */
+export declare function readDenyRowAnchor(pattern: string): ReadDenyRowAnchorWord;
 /**
  * the PURE validation/canonicality predicate over a PERSISTED deny entry (checkpoint v9
  * face section), for the resume pre-CAS ladder: it must refuse BEFORE the approval CAS everything

package/dist/tools/fs/read-deny.js

@@ -320,7 +320,7 @@ export function compileSegmentPattern(raw, fold) {
         return null;
     const flags = fold === "unicode" ? "i" : "";
     const segments = parts.map((segment) => {
-        const escaped = segment.replace(/[.+^${}()|[\]\\?]/g, "\\$&").replace(/\*/g, "[^/]*");
+        const escaped = segment.replace(/[.+^${}()|[\]\\?]/g, "\\$&").replace(/\*+/g, "[^/]*");
         return new RegExp(`^${escaped}$`, flags);
     });
     return { raw, segments, foldAscii: fold === "ascii" };
@@ -486,10 +486,12 @@ function normalizeEntry(entry, layer) {
 }
 function canonicalReadDenyPattern(pattern) {
     const joined = pattern.split("/").filter(Boolean).join("/");
-    return pattern.startsWith("/") && !readDenyPatternRun(joined).homeAnchored ? `/${joined}` : joined;
+    return readDenyRowAnchor(pattern) === "root" ? `/${joined}` : joined;
 }
-export function isRootedReadDenyPattern(canonical) {
-    return canonical.startsWith("/");
+export function readDenyRowAnchor(pattern) {
+    if (readDenyPatternRun(pattern).homeAnchored)
+        return "home";
+    return pattern.startsWith("/") ? "root" : "none";
 }
 export function persistedReadDenyEntryProblem(e) {
     if (typeof e !== "object" || e === null)
@@ -548,14 +550,15 @@ export function compileReadDeny(additions = [], layer = "additions", builtin, ru
     }
     const homeSegments = [...new Set(checkedReadDenyHomes(homes))].map(homeAnchorSegments);
     const compiled = normalized.map((e) => {
-        const { homeAnchored, run } = readDenyPatternRun(e.pattern);
+        const { run } = readDenyPatternRun(e.pattern);
+        const rowAnchor = readDenyRowAnchor(e.pattern);
         const fold = e.caseSensitive ? "none" : "ascii";
         const c = compileSegmentPattern(run, fold);
         if (c === null)
             throw new Error(`readDenyPatterns: pattern ${JSON.stringify(e.pattern)} compiled to zero segments.`);
-        if (isRootedReadDenyPattern(e.pattern))
+        if (rowAnchor === "root")
             return { ...c, raw: e.pattern, anchors: [[]], rootedOnly: true };
-        if (!homeAnchored)
+        if (rowAnchor === "none")
             return { ...c, raw: e.pattern };
         if (homeSegments.length === 0)
             return { ...c, raw: e.pattern, unplacedHome: true };
@@ -566,8 +569,8 @@ export function compileReadDeny(additions = [], layer = "additions", builtin, ru
     const linkedPlacements = [];
     normalized.forEach((e, i) => {
         const locations = linked.get(e.pattern);
-        const { homeAnchored, run } = readDenyPatternRun(e.pattern);
-        if (locations === undefined || !(homeAnchored || isRootedReadDenyPattern(e.pattern)))
+        const { run } = readDenyPatternRun(e.pattern);
+        if (locations === undefined || readDenyRowAnchor(e.pattern) === "none")
             return;
         const c = compiled[i];
         const rest = c.segments.slice(readDenyRunHead(run));

package/dist/tools/fs/safety.d.ts

@@ -66,12 +66,13 @@ export interface ReadEntry {
      *  disk (hash mismatch) always serves real content and the dedup disarms permanently.
      *  Optional/additive: absent = normal entry. */
     seededFromContext?: boolean;
-    /** The id of the tool call whose RESULT carried the body this entry dedups against: when the
-     *  request-layer stale-result pass clears THAT transmission, the entry retires with it
-     *  (`applyContextShrinkToReadFileState`, `tool-results-cleared` arm). Recorded only by the Read
-     *  lanes that TRANSMIT a body — a write-back's content is the model's own arguments and a
-     *  seeded/re-attached entry never rode a tool result, so neither carries this and neither is
-     *  retired by a clear. Optional/additive: absent (an older checkpoint) never matches a cleared id. */
+    /** The transmission that carried the body this entry dedups against — the tool call whose RESULT carried it, or the
+     *  attachment frame that did (`attachmentTransmissionId`): when THAT transmission leaves the request (a stale-result
+     *  clear, a trim), the entry retires with it (`applyContextShrinkToReadFileState`, `transmissions-gone` arm). Recorded
+     *  only by the deliveries that TRANSMIT a body (a Read result or a frame replayed from the transcript included) — a
+     *  write-back's content is the model's own arguments and a context-seeded entry never rode a message, so neither
+     *  carries this and neither is retired by it. Optional/additive: absent (an
+     *  older checkpoint) never matches. */
     transmittedByToolCallId?: string;
 }
 /** Per-task record of which files have been read, keyed by canonical path: owned by prepare-task,

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

@@ -437,9 +437,11 @@ export declare function isArithmeticCommand(segment: LexedSegment): boolean;
 /** The `[[` operators whose operands the arithmetic evaluator reads (`[[ x -eq y ]]`; `[` / `test` compare integers
  *  without evaluating them). */
 export declare const ARITHMETIC_TEST_OPERATORS: ReadonlySet<string>;
-/** The substitutions a parameter expansion's body hands the arithmetic evaluator: its subscript (`${a[…]}`) and the
- *  offset and length of a substring expansion (`${x:off:len}` — the shell expands them, then evaluates them). */
-export declare function parameterBodySubstitutions(name: string, body: string, table: BindingTable | undefined): string[];
+/** The substitutions a parameter expansion's body hands the arithmetic evaluator: its subscript (`${a[…]}`, `${#a[…]}`,
+ *  `${!a[…]}`) and the offset and length of a substring expansion (`${x:off:len}` — the shell expands them, then
+ *  evaluates them), as the lexer's one reading of the body finds them ({@link parameterArithmeticTexts}). The body's own
+ *  text only: what a VALUE runs when the expansion re-reads it is not followed (the station asks, see its caller). */
+export declare function parameterBodySubstitutions(body: string, table: BindingTable | undefined): string[];
 /**
  * The substitutions the shell's ARITHMETIC evaluator runs while it evaluates `text`: every `$(…)`, backquote or process
  * substitution inside an array SUBSCRIPT of it (`a[$(…)]` — quoted or not: the evaluator re-reads the text it is

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

@@ -1,4 +1,4 @@
-import { argvOf, lexShell, literalTildeSpelling, substitutionsInHeredocBody } from "../../shell/lex.js";
+import { argvOf, arithmeticTextIsPlain, expansionHidesRun, expansionsInHeredocBody, lexShell, literalTildeSpelling, namesRedirectDescriptor, parameterArithmeticTexts } from "../../shell/lex.js";
 import { shellWordsOf } from "../../shell/shell-words.js";
 import { isShellSyntaxWord, LOOP_LIST_HEADS, readProgramPosition } from "./bash-program-position.js";
 import { declaredAttributes, programRow, readArgRoles } from "./program-read-model.js";
@@ -456,18 +456,16 @@ export function bindingEffectOf(segment, argv, shape, readValue, shadow, availab
     for (const t of segment.tokens) {
         if (t.kind !== "heredoc" || t.quoted)
             continue;
-        if (t.body.includes("${"))
+        const expansions = expansionsInHeredocBody(t.body);
+        const evaluatesUnseen = (x) => (x.expansion.kind === "parameter" && expansionHidesRun(x.expansion)) || (x.expansion.kind === "arithmetic" && !arithmeticTextIsPlain(x.expansion.body ?? ""));
+        if (expansions === undefined || expansions.some((x) => x.unresolved !== undefined || evaluatesUnseen(x)))
             unknownAll();
-        for (const s of substitutionsInHeredocBody(t.body) ?? [])
-            if (s.kind === "arithmetic")
-                for (const name of arithmeticAssignedNames(s.body))
-                    kill(name);
+        for (const name of assignedByPieces((expansions ?? []).map((x) => ({ span: [0, 0], quotedBy: undefined, expansion: x.expansion }))))
+            kill(name);
     }
     segment.tokens.forEach((t, i) => {
-        const next = segment.tokens[i + 1];
-        const m = t.kind === "word" && next?.kind === "redirect" ? /^\{([A-Za-z_][A-Za-z0-9_]*)\}$/.exec(t.raw) : null;
-        if (m !== null)
-            kill(m[1]);
+        if (t.kind === "word" && namesRedirectDescriptor(t, segment.tokens[i + 1]))
+            kill(t.raw.slice(1, -1));
     });
     const tokens = segment.tokens;
     if (isArithmeticCommand(segment)) {
@@ -665,8 +663,10 @@ function assignedByPieces(pieces) {
     const out = [];
     for (const p of pieces) {
         const e = p.expansion;
-        if (e?.kind === "parameter" && e.name !== undefined && e.body !== undefined && new RegExp(`^${e.name}:?=`).test(e.body))
+        if (e?.kind === "parameter" && e.name !== undefined && e.body !== undefined && (e.body.startsWith(`${e.name}=`) || e.body.startsWith(`${e.name}:=`)))
             out.push(e.name);
+        if (e?.kind === "parameter" && e.body !== undefined)
+            out.push(...arithmeticAssignedNames(e.body));
         if (e?.kind === "arithmetic" && e.body !== undefined)
             out.push(...arithmeticAssignedNames(e.body));
     }
@@ -1042,12 +1042,11 @@ export function isArithmeticCommand(segment) {
     return a?.kind === "group" && a.op === "(" && b?.kind === "group" && b.op === "(";
 }
 export const ARITHMETIC_TEST_OPERATORS = new Set(["-eq", "-ne", "-lt", "-le", "-gt", "-ge"]);
-export function parameterBodySubstitutions(name, body, table) {
-    const rest = body.slice(name.length);
-    const out = arithmeticSubstitutions(rest.startsWith("[") ? rest.slice(0, rest.indexOf("]") + 1 || undefined) : "", table);
-    const offset = /^(?:\[[^\]]*\])?:(?![-=+?])(.*)$/s.exec(rest)?.[1];
+export function parameterBodySubstitutions(body, table) {
+    const { subscript, offset } = parameterArithmeticTexts(body);
+    const out = arithmeticSubstitutions(subscript === undefined ? "" : `[${subscript}]`, table);
     if (offset !== undefined)
-        out.push(...substitutionBodies(`${offset}`, true), ...arithmeticSubstitutions(offset, table));
+        out.push(...substitutionBodies(offset, true), ...arithmeticSubstitutions(offset, table));
     return [...new Set(out)];
 }
 export function arithmeticSubstitutions(text, table, chain = new Set(), budget = { left: ARITHMETIC_VALUES_MAX }) {

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

@@ -22,7 +22,7 @@ export function descriptorsBoundBy(r) {
         return [r.fd];
     if (r.op === "&>" || r.op === "&>>")
         return [1, 2];
-    return [r.op === "<" || r.op === "<<<" || r.op === "<&" ? 0 : 1];
+    return [r.op === "<" || r.op === "<<<" || r.op === "<&" || r.op === "<>" ? 0 : 1];
 }
 export function bindDescriptors(into, r) {
     for (const fd of descriptorsBoundBy(r))

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

@@ -1,5 +1,5 @@
-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 { expansionsInHeredocBody, lexShell, PARSE_FAILURE_SENTENCE, substitutionsInHeredocBody, literalTextOf, literalTildeSpelling, parameterRereadsValue, UNRESOLVED_SENTENCE, } from "../../shell/lex.js";
+import { programTextOf, readOfText, readsOf, rewritten, segmentReadingsOf, settledFieldsOf, spelledWithHome, 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, joinRebound, loopListHeadAt, namesBoundIn, parameterBodySubstitutions, projectSegment, valueOf, } from "./shell-read-bindings.js";
 import { commandEnvironmentNames, isShellSyntaxWord, programBasename, programPositionRunsShell, readProgramPosition, shellScanDeclineOf, } from "./bash-program-position.js";
@@ -310,51 +310,40 @@ 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 enclosedToo = (e) => [e, ...(e.inner ?? []).flatMap(enclosedToo)];
+    const expansionsOf = (sg) => sg.tokens.flatMap((t) => (t.kind === "word" ? t : t.kind === "redirect" ? t.target : undefined)?.pieces ?? []).flatMap((q) => (q.expansion !== undefined ? enclosedToo(q.expansion) : []));
     const count = (list, body) => list.filter((b) => b === body).length;
-    const arithmeticBody = (body) => {
-        const l = lexShell(body);
-        if ("parseFailure" in l)
-            nested.push(nestedPlan(body, "substitution"));
-        else
-            for (const s of l.segments.flatMap((sg) => sg.substitutions))
-                nested.push(nestedPlan(s, "substitution"));
-        ctx.reentered.push(...arithmeticSubstitutions(body, table));
-    };
-    for (const body of segment.substitutions) {
-        if (count(arithmetic, body) > 0 && count(arithmetic, body) === count(segment.substitutions, body))
-            arithmeticBody(body);
-        else
-            nested.push(nestedPlan(body, "substitution"));
-    }
-    let unreadableHeredoc = false;
-    for (const t of segment.tokens) {
-        if (t.kind !== "heredoc" || t.quoted)
-            continue;
-        const inner = substitutionsInHeredocBody(t.body);
-        if (inner === undefined) {
-            unreadableHeredoc = true;
-            continue;
-        }
-        for (const s of inner) {
-            if (s.kind === "arithmetic" && isArithmeticBody(s.body))
-                arithmeticBody(s.body);
+    const substitute = (body, here) => void (here ? ctx.reentered.push(body) : nested.push(nestedPlan(body, "substitution")));
+    const unread = (sentence) => void nested.push({ segments: [], unreadable: sentence, shape: { grouped: false, backgrounded: false, strayRedirection: false } });
+    const parameter = (e) => void (e.kind === "parameter" && e.body !== undefined && (parameterRereadsValue(e.body) && unread("a parameter expansion re-reads a value (an indirect `${!name}`, an evaluating `${name@P}`), which this station does not follow"), ctx.reentered.push(...parameterBodySubstitutions(e.body, table))));
+    const expandedText = (all, undelimited) => {
+        if (all === undefined)
+            return void unread(undelimited), false;
+        for (const x of all) {
+            if (x.expansion.kind === "arithmetic")
+                arithmeticBody(x.expansion.body ?? "");
+            else if (x.expansion.kind === "command")
+                substitute(x.expansion.body ?? "", x.currentShell === true);
             else
-                nested.push(nestedPlan(s.body, "substitution"));
+                parameter(x.expansion);
+            if (x.unresolved !== undefined)
+                void (unread(UNRESOLVED_SENTENCE[x.unresolved]), x.unresolved === "parameter_text" && expandedText(expansionsInHeredocBody(x.expansion.body ?? ""), UNRESOLVED_SENTENCE.parameter_text));
         }
-    }
-    if (unreadableHeredoc)
-        nested.push({ segments: [], unreadable: "a here-document body carries a substitution this lexer cannot delimit", shape: { grouped: false, backgrounded: false, strayRedirection: false } });
+        return all.some((x) => x.expansion.kind === "command");
+    };
+    const arithmeticBody = (body) => void (expandedText(expansionsInHeredocBody(body), "an arithmetic expansion carries a substitution this lexer cannot delimit") && unread("an arithmetic expansion evaluates what a command substitution in it prints, which this station does not read"), ctx.reentered.push(...arithmeticSubstitutions(body, table)));
+    const arithmetic = expansionsOf(segment).flatMap((e) => (e.kind === "arithmetic" && e.body !== undefined ? [e.body] : []));
+    for (const body of segment.substitutions)
+        (count(arithmetic, body) > 0 && count(arithmetic, body) === count(segment.substitutions, body) ? arithmeticBody(body) : substitute(body, segment.currentShell?.includes(body) === true));
+    for (const t of segment.tokens)
+        if (t.kind === "heredoc" && !t.quoted)
+            expandedText(expansionsInHeredocBody(t.body), "a here-document body carries a substitution this lexer cannot delimit");
+    for (const e of expansionsOf(segment))
+        parameter(e);
     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) {
-        const w = t.kind === "word" ? t : t.kind === "redirect" ? t.target : undefined;
-        for (const q of w?.pieces ?? [])
-            if (q.expansion?.kind === "parameter" && q.expansion.name !== undefined && q.expansion.body !== undefined)
-                ctx.reentered.push(...parameterBodySubstitutions(q.expansion.name, q.expansion.body, table));
-    }
-    const redirects = p.redirects.map((r) => redirectFact(r, table, decl.homeDir));
+    const redirects = p.redirects.flatMap((r) => redirectFacts(r, table, decl.homeDir));
     const reads = [];
     for (const r of redirects)
         if (r.direction === "in" && r.target !== undefined)
@@ -670,15 +659,15 @@ function dedupe(reads) {
 function relativeSpelling(spelled) {
     return !(isAbsoluteForFamily("own", spelled) || spelled.startsWith("~"));
 }
-function redirectFact(r, table, homeDir) {
+function redirectFacts(r, table, homeDir) {
     const fd = r.fd !== undefined ? { fd: r.fd } : {};
     if (r.target === undefined)
-        return { op: r.op, direction: "dup", ...fd };
-    if (r.op === "<")
-        return { op: r.op, direction: "in", ...fd, target: bare(readsOf([r.target], table, homeDir)[0], "stdin_redirect") };
+        return [{ op: r.op, direction: "dup", ...fd }];
     if (r.op === "<<<")
-        return { op: r.op, direction: "in", ...fd };
-    return { op: r.op, direction: "out", ...fd, target: bare(readsOf([r.target], table, homeDir)[0], "write_redirect_target") };
+        return [{ op: r.op, direction: "in", ...fd }];
+    const read = readsOf([r.target], table, homeDir)[0];
+    const inward = r.op === "<" || r.op === "<>" ? [{ op: r.op, direction: "in", ...fd, target: bare(read, "stdin_redirect") }] : [];
+    return r.op === "<" ? inward : [...inward, { op: r.op, direction: "out", ...fd, target: bare(read, "write_redirect_target") }];
 }
 function commandStringValue(row, toks, option) {
     const at = toks.findIndex((r) => r.folded === option);

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

@@ -111,13 +111,8 @@ export declare function spelledWithHome(spelled: string, raw: string, home: stri
  *  bash expands the pattern (or reads another delimiter) where the lexer reads a split word, so what the text opens is
  *  not what the plan names: the whole text asks, and a deny hit anywhere still refuses. `globs: false` = the text is an
  *  arithmetic expression (`$((2*(3+4)))`), which bash evaluates and never globs. A compound assignment's value is no
- *  such word: the assignment reads nothing. */
+ *  such word — the assignment reads nothing — unless the unread value may run something ({@link compoundValueHidesRun}). */
 export declare function unreadableSentenceOf(lexed: LexedCommand, text: string, globs?: boolean): string | undefined;
-/** An `$((…))` body the shell reads as ARITHMETIC: one parenthesised group spanning the whole body (`(2*(3+4))`),
- *  its bounds read off the lexer's structure — a quoted, escaped or commented parenthesis is text, not a bound — across
- *  the segments the lexer cuts at `&&` `||` `&` `|` and line breaks (operators arithmetic shares with the shell).
- *  `$((cat x); :)` opens the same way but its first group closes early: a command substitution holding a subshell. */
-export declare function isArithmeticBody(body: string): boolean;
 /** What the shell does to a word (or an assignment's value) before the program sees it, read off its pieces: the
  *  lexer's expansion facts alone. A quoted text that an evaluator or an interpreter later RUNS (an arithmetic
  *  subscript, an inline program) is no rewrite of the word: the slot it stands in says what it is (the program read

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

@@ -1,4 +1,4 @@
-import { argvOf, lexShell, literalTildeSpelling, UNRESOLVED_SENTENCE } from "../../shell/lex.js";
+import { argvOf, compoundValueHidesRun, lexShell, literalTildeSpelling, UNRESOLVED_SENTENCE } from "../../shell/lex.js";
 import { expansionInWord, extglobOpenerIn, globInWord, homeExpansionOf } from "./bash-readonly-classifier.js";
 import { floorOf, judgedSpellingOf, namesIn, wordFloorValues, wordValues } from "./shell-read-bindings.js";
 export function readsOf(words, table, homeDir, split = false) {
@@ -150,7 +150,7 @@ export function unreadableSentenceOf(lexed, text, globs = true) {
     for (const segment of lexed.segments) {
         for (const token of segment.tokens) {
             const word = token.kind === "word" ? token : token.kind === "redirect" ? token.target : undefined;
-            if (word?.unresolved === "compound_array_value" && word.assignment?.form === "compound")
+            if (word?.unresolved === "compound_array_value" && word.assignment?.form === "compound" && !compoundValueHidesRun(word))
                 continue;
             if (word?.unresolved !== undefined)
                 return UNRESOLVED_SENTENCE[word.unresolved];
@@ -158,24 +158,6 @@ export function unreadableSentenceOf(lexed, text, globs = true) {
     }
     return globs && extglobOpenerIn(lexed, text) ? "an extended pattern (`?(…)` `*(…)` `+(…)` `@(…)` `!(…)`) is one this reader does not expand" : undefined;
 }
-export function isArithmeticBody(body) {
-    const l = body.startsWith("(") && body.endsWith(")") ? lexShell(body) : undefined;
-    if (l === undefined || "parseFailure" in l)
-        return false;
-    const tokens = l.segments.flatMap((sg) => sg.tokens);
-    if (tokens[0]?.kind !== "group" || tokens[0].op !== "(")
-        return false;
-    let depth = 0;
-    for (const [i, t] of tokens.entries()) {
-        if (t.kind !== "group")
-            continue;
-        if (t.op === "(")
-            depth++;
-        else if (--depth === 0)
-            return i === tokens.length - 1;
-    }
-    return false;
-}
 export function expandsOf(w) {
     if (expansionInWord(w))
         return "unresolvable";

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

@@ -210,7 +210,7 @@ export function stdinTextsOf(segment, fed) {
             const literal = t.quoted ? t.body : literalHeredocBody(t.body);
             out.push(literal === undefined ? { from: t.body } : { from: t.body, literal });
         }
-        else if (t.kind === "redirect" && (t.fd ?? 0) === 0 && (t.op === "<<<" || t.op === "<" || (t.op === "<&" && t.dup !== "-"))) {
+        else if (t.kind === "redirect" && (t.fd ?? 0) === 0 && (t.op === "<<<" || t.op === "<" || t.op === "<>" || (t.op === "<&" && t.dup !== "-"))) {
             const literal = t.op === "<<<" && t.target !== undefined ? literalTextOf(t.target.pieces) : undefined;
             out.push({ from: `${t.op}${t.target?.raw ?? t.dup ?? ""}`, ...(literal !== undefined ? { literal } : {}) });
             replacesPipe = true;

package/dist/tools/web.d.ts

@@ -77,7 +77,7 @@ export interface WebFetchGrounding {
 }
 export declare function htmlToText(html: string): string;
 export declare function webFetchToolSpec(config?: WebFetchConfig): ToolSpec;
-/** Defined (harness) form of web_fetch — back-compat for direct execution / tests. For `spec.tools`, use the raw
+/** Defined (harness) form of web_fetch — back-compat (RL-1336-webfetch-factory) for direct execution / tests. For `spec.tools`, use the raw
  *  {@link webFetchToolSpec} (prepare-task defineTool-wraps spec.tools entries).
  *
  *  ⚠️ CTX-DEPENDENT BEHAVIOR: this factory takes no `enrichCtx`, so the product it returns is sealed
@@ -215,7 +215,7 @@ export interface WebSearchConfig {
      * `allowed_domains`/`blocked_domains` HINTS so a backend that supports native domain filtering (e.g. a
      * `site:` query) can apply them up front. A backend MAY ignore `opts` — core re-enforces the domain
      * constraint on the returned results as a floor (see `createWebSearchTool`), so honoring it is an
-     * optimization, not a correctness requirement. Back-compat: existing 2-arg backends keep working.
+     * optimization, not a correctness requirement. A backend declaring fewer parameters is accepted as is.
      */
     search: (query: string, signal?: AbortSignal, opts?: {
         allowedDomains?: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "7.52.0",
+  "version": "7.54.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",
@@ -77,6 +77,8 @@
     "gate:debts:rc": "node scripts/verify-debts.mjs --rc-gate",
     "gate:anchor-claims": "node scripts/verify-anchor-claims.mjs",
     "gate:anchor-claims:rc": "node scripts/verify-anchor-claims.mjs --require-corpus",
+    "gate:retirement-lines": "node scripts/verify-retirement-lines.mjs",
+    "gate:retirement-lines:rc": "node scripts/verify-retirement-lines.mjs --rc",
     "gate:rulings": "node scripts/rulings-gate.mjs --require-comms",
     "gate:error-surface": "node scripts/verify-error-surface.mjs",
     "gate:criteria": "node scripts/criteria-lint.mjs",
@@ -111,6 +113,7 @@
     "gate:negative-controls": "vitest run test/gate-negative-controls.test.ts",
     "gate:memory-ga": "node scripts/gate-memory-distillation-ga.mjs",
     "gate:all": "node scripts/gate-all.mjs",
+    "release:preflight": "node scripts/release-preflight.mjs",
     "car:gate": "node scripts/car-gate.mjs"
   },
   "dependencies": {