@sema-agent/core 7.19.0 → 7.20.1

package/dist/agents/verify.js

@@ -1,6 +1,7 @@
 import { Type } from "typebox";
 import { CODE_AGENT_PROMPT } from "../prompts/default.js";
 import { releaseSession } from "./session-util.js";
+import { childClampSeats } from "../core/child-clamp-seats.js";
 import { mapNestedSuspend, isDurablePause, pauseFamily } from "./suspend-guard.js";
 import { delimitUntrusted, sanitizeUntrustedText } from "../core/untrusted-text.js";
 import { createSafeNotifier } from "../core/safe-notify.js";
@@ -136,17 +137,21 @@ export async function verifyCompleted(runner, result, specBase, objective, confi
     const runVerifier = async (impl, round) => {
         refuseUnhonorableInternals(internals, "before_leg");
         const roundEvidence = round === 1 ? config.evidence : undefined;
-        const v = await runner.runTask({
+        const verifierSpec = {
             objective: verifierObjective(objective, impl, roundEvidence),
             systemPrompt: verifierPrompt,
             ...(config.verifierModel ? { model: config.verifierModel } : { modelRole: "verifier" }),
             roles: specBase.roles,
             tools: verifierTools,
             handsReadOnly: config.verifierHandsReadOnly ?? true,
-            ...(foldedRootsFace ? { readFace: "roots" } : {}),
-            ...(foldedRootsWriteFace ? { writeFace: "roots" } : {}),
-            ...(foldedReadDeny.length > 0 ? { readDenyPatterns: [...foldedReadDeny] } : {}),
             interactiveTools: false,
+            ...childClampSeats({
+                handsReadOnly: specBase.handsReadOnly,
+                interactiveTools: specBase.interactiveTools,
+                readFace: foldedRootsFace ? "roots" : undefined,
+                writeFace: foldedRootsWriteFace ? "roots" : undefined,
+                readDenyPatterns: foldedReadDeny,
+            }),
             outputSchema: VerdictSchema,
             enableBlockedReport: false,
             limits: { ...(specBase.limits?.maxWalltimeMs !== undefined ? { maxWalltimeMs: specBase.limits.maxWalltimeMs } : {}) },
@@ -167,7 +172,8 @@ export async function verifyCompleted(runner, result, specBase, objective, confi
             ...(specBase.clientContext !== undefined ? { clientContext: { ...specBase.clientContext } } : {}),
             ...(specBase.promptProfile !== undefined ? { promptProfile: specBase.promptProfile } : {}),
             signal: specBase.signal,
-        }, legInternals());
+        };
+        const v = await runner.runTask(verifierSpec, legInternals());
         try {
             const cost = (v.stats.costMicroUsd ?? 0) + (v.stats.nested?.costMicroUsd ?? 0);
             return { verdict: v.structuredOutput, cost, ...(isDurablePause(v.terminal) ? { paused: { ...v, terminal: v.terminal } } : {}) };
@@ -241,14 +247,19 @@ export async function verifyCompleted(runner, result, specBase, objective, confi
         if (config.costCeilingMicroUsd != null && spend >= config.costCeilingMicroUsd)
             break;
         refuseUnhonorableInternals(internals, "before_leg");
-        current = await runner.runTask({
+        const fixLegSpec = {
             ...specBase,
             sessionId: current.sessionId,
             objective: fixObjective(outcome.findings),
-            ...(foldedRootsFace ? { readFace: "roots" } : {}),
-            ...(foldedRootsWriteFace ? { writeFace: "roots" } : {}),
-            ...(foldedReadDeny.length > 0 ? { readDenyPatterns: [...foldedReadDeny] } : {}),
-        }, legInternals());
+            ...childClampSeats({
+                handsReadOnly: specBase.handsReadOnly,
+                interactiveTools: specBase.interactiveTools,
+                readFace: foldedRootsFace ? "roots" : specBase.readFace,
+                writeFace: foldedRootsWriteFace ? "roots" : specBase.writeFace,
+                readDenyPatterns: foldedReadDeny,
+            }),
+        };
+        current = await runner.runTask(fixLegSpec, legInternals());
         spend += (current.stats.costMicroUsd ?? 0) + (current.stats.nested?.costMicroUsd ?? 0);
         implAccount.add(current.stats);
         if (isDurablePause(current.terminal)) {

package/dist/brain/anthropic.js

@@ -365,6 +365,7 @@ export function createAnthropicBrain(config = {}) {
                 const blocks = new Map();
                 const usageRaw = {};
                 let stopReason = null;
+                const terminalFrameSeen = () => stopReason != null;
                 let stopDetails;
                 let nextContentIndex = 0;
                 let malformedFrames = 0;
@@ -532,6 +533,7 @@ export function createAnthropicBrain(config = {}) {
                             hasSubstantiveText,
                             hasCompletedToolCall,
                             hasOnlyThinking: hasThinking && !hasSubstantiveText && !hasCompletedToolCall,
+                            terminalFrameSeen: terminalFrameSeen(),
                         };
                     },
                     sealForRetry() {
@@ -666,7 +668,7 @@ export function createAnthropicBrain(config = {}) {
                             emptyNoFinish ||
                             (toolError !== undefined && noUsableContent) ||
                             (truncatedEmpty && !dynamicCut && !staticReasoningCut);
-                        const tornWithContent = !errored && opts?.truncated !== true && stopReason == null && !noUsableContent && !degenerate;
+                        const tornWithContent = !errored && opts?.truncated !== true && !terminalFrameSeen() && !noUsableContent && !degenerate;
                         const errorMessageOut = tornWithContent ? (errorMessage ? `${errorMessage}\n${STREAM_TORN_WARNING}` : STREAM_TORN_WARNING) : errorMessage;
                         const errorKind = degenerate
                             ? "degenerate"

package/dist/brain/open-responses.js

@@ -303,6 +303,7 @@ export function createOpenResponsesBrain(config = {}) {
                 let usageRaw;
                 let responseId;
                 let terminalStatus;
+                const terminalFrameSeen = () => terminalStatus !== undefined;
                 let incompleteReason;
                 let accumRefusal = "";
                 const capabilityNotes = [];
@@ -573,6 +574,7 @@ export function createOpenResponsesBrain(config = {}) {
                             hasSubstantiveText,
                             hasCompletedToolCall,
                             hasOnlyThinking: hasReasoning && !hasSubstantiveText && !hasCompletedToolCall,
+                            terminalFrameSeen: terminalFrameSeen(),
                         };
                     },
                     sealForRetry() {
@@ -690,7 +692,7 @@ export function createOpenResponsesBrain(config = {}) {
                         const safetyCut = incompleteReason === INCOMPLETE_CONTENT_FILTER;
                         const refused = accumRefusal.trim().length > 0;
                         const incompleteUnmapped = terminalStatus === "incomplete" && incompleteReason !== INCOMPLETE_MAX_OUTPUT_TOKENS && incompleteReason !== INCOMPLETE_CONTENT_FILTER;
-                        const emptyNoFinish = noUsableContent && (terminalStatus === undefined || incompleteUnmapped) && !degenerate;
+                        const emptyNoFinish = noUsableContent && (!terminalFrameSeen() || incompleteUnmapped) && !degenerate;
                         const maxTokensNote = sentMaxTokens !== undefined
                             ? `effective max_output_tokens=${sentMaxTokens} (from ${sentMaxTokensLane === "options"
                                 ? "options.maxTokens"
@@ -718,7 +720,7 @@ export function createOpenResponsesBrain(config = {}) {
                             emptyNoFinish ||
                             (toolError !== undefined && noUsableContent) ||
                             (truncatedEmpty && !dynamicCut && !staticReasoningCut);
-                        const tornWithContent = !errored && opts?.truncated !== true && (terminalStatus === undefined || incompleteUnmapped) && !noUsableContent && !degenerate;
+                        const tornWithContent = !errored && opts?.truncated !== true && (!terminalFrameSeen() || incompleteUnmapped) && !noUsableContent && !degenerate;
                         const partialWarning = terminalStatus === undefined ? STREAM_TORN_WARNING : RESPONSE_INCOMPLETE_WARNING;
                         const errorMessageOut = tornWithContent ? (errorMessage ? `${errorMessage}\n${partialWarning}` : partialWarning) : errorMessage;
                         const errorKind = degenerate

package/dist/brain/openai.js

@@ -373,6 +373,7 @@ export function createOpenAIBrain(config = {}) {
                 let textIndex = 0;
                 const toolAccum = new Map();
                 let finishReason = null;
+                const terminalFrameSeen = () => finishReason != null;
                 let usageRaw;
                 let malformedFrames = 0;
                 let malformedSample;
@@ -438,6 +439,7 @@ export function createOpenAIBrain(config = {}) {
                             hasSubstantiveText,
                             hasCompletedToolCall,
                             hasOnlyThinking: accumReasoning.length > 0 && !hasSubstantiveText && !hasCompletedToolCall,
+                            terminalFrameSeen: terminalFrameSeen(),
                         };
                     },
                     sealForRetry() {
@@ -619,7 +621,7 @@ export function createOpenAIBrain(config = {}) {
                             emptyNoFinish ||
                             (toolError !== undefined && noUsableContent) ||
                             (truncatedEmpty && !dynamicCut);
-                        const tornWithContent = !errored && opts?.truncated !== true && finishReason == null && !noUsableContent && !degenerate;
+                        const tornWithContent = !errored && opts?.truncated !== true && !terminalFrameSeen() && !noUsableContent && !degenerate;
                         const errorMessageOut = tornWithContent ? (errorMessage ? `${errorMessage}\n${STREAM_TORN_WARNING}` : STREAM_TORN_WARNING) : errorMessage;
                         const errorKind = degenerate
                             ? "degenerate"

package/dist/brain/stream-engine.d.ts

@@ -194,11 +194,15 @@ export interface StreamParser {
      * - `hasOnlyThinking` — thinking streamed but nothing substantive (no non-blank text, no completed
      *   tool call) → tier B (seal + whole-turn retry). A dangling tool-call accumulation alongside the
      *   thinking does not veto this (nothing was admitted; the retry's snapshot replacement drops it).
+     * - `terminalFrameSeen` — the provider TERMINATED this stream (openai `finish_reason`, anthropic
+     *   `message_delta.stop_reason`, responses `response.completed`/`response.incomplete`). A FACT, not a tier:
+     *   the parser reports it off the same state its own finalize reads, and the tiering owns what it means.
      */
     snapshot(): {
         hasSubstantiveText: boolean;
         hasCompletedToolCall: boolean;
         hasOnlyThinking: boolean;
+        terminalFrameSeen: boolean;
     };
     /**
      * design/124 §0.5-2 tier B: seal the UI stream before a whole-turn retry — emit `thinking_end` for

package/dist/brain/stream-engine.js

@@ -647,6 +647,10 @@ export function runStreamingBrain(args) {
                 return;
             }
             const snap = parser.snapshot();
+            if (snap.terminalFrameSeen) {
+                parser.finalize();
+                return;
+            }
             if (snap.hasSubstantiveText || snap.hasCompletedToolCall) {
                 midstreamWarning =
                     failure.kind === "stalled"

package/dist/core/auto-mode.d.ts

@@ -13,10 +13,12 @@ export declare function isAutoModeUnavailableCause(v: unknown): v is AutoModeUna
 /**
  * HOW a reply failed to carry a verdict — the closed set behind `parse_error.form`. `missing` = the reader found
  * NO answer (empty text, prose, an answer only inside a thinking block); `conflict` = it found TWO distinct
- * `<block>` answers (raw or thinking-stripped). The split exists for the classify leg's re-ask: a missing
- * answer is asked for again (CC 2.1.259 `Vrr` re-asks an unparseable reply), a conflict is not — it carries a
- * `yes`, and a second attempt that answered `no` would erase it. Not on any wire face; the trace frame and the
- * gate record keep the one word `parse_error`.
+ * `<block>` answers (raw or thinking-stripped). The split decides who gets a SECOND ATTEMPT at the same
+ * question, on both seats that offer one: a missing answer is asked for again (CC 2.1.259 `Vrr` re-asks an
+ * unparseable reply) and handed on to the next candidate ({@link rungDidNotRule}); a conflict gets neither —
+ * it carries a `yes`, and any second attempt that answered `no` would erase it. One rule, two seats: whatever
+ * a re-ask may not overwrite, a later rung may not overwrite either. Not on any wire face; the trace frame and
+ * the gate record keep the one word `parse_error`.
  */
 export declare const AUTO_MODE_PARSE_FAILURES: readonly ["missing", "conflict"];
 export type AutoModeParseFailure = (typeof AUTO_MODE_PARSE_FAILURES)[number];
@@ -26,8 +28,9 @@ export declare function isAutoModeParseFailure(v: unknown): v is AutoModeParseFa
  * WHY a classification moved DOWN the candidate ladder — the closed set behind
  * {@link AutoModeClassifierRound}'s `fallback.cause`, i.e. the ways a candidate produces NO RULING
  * ({@link rungDidNotRule}). Two words are the unavailable causes verbatim (the leg threw / rejected; the
- * round-trip cap elapsed); `parse_error` is the candidate that ANSWERED without a verdict. A ruling is not a
- * member: the ladder stops at a verdict either way.
+ * round-trip cap elapsed); `parse_error` is the candidate that ANSWERED with no answer in it at all (the
+ * `missing` form). A ruling is not a member, and neither is a CONTRADICTORY reply (`conflict`): the ladder
+ * stops at a rung that settled the classification, whichever way it settled it.
  */
 export declare const AUTO_MODE_FALLBACK_CAUSES: readonly ["error", "timeout", "parse_error"];
 export type AutoModeFallbackCause = (typeof AUTO_MODE_FALLBACK_CAUSES)[number];
@@ -65,8 +68,9 @@ export type AutoModeVerdict = ({
 } & AutoModeRoundAttributed)
 /** The model responded but not in the `<block>…` contract shape. Handled as a BLOCK with the CC
  *  parse-failure sentence ({@link classifierParseFailureDenyMessage}), counted by the denial limit. `form`
- *  says WHICH way the reply failed ({@link AutoModeParseFailure}): the classify leg re-asks a `missing`
- *  reply once and never a `conflict`. */
+ *  says WHICH way the reply failed ({@link AutoModeParseFailure}) and decides who may try the question a
+ *  second time: the classify leg re-asks a `missing` reply once and the ladder hands it to the next rung;
+ *  a `conflict` gets neither ({@link rungDidNotRule}). */
  | ({
     kind: "parse_error";
     raw: string;
@@ -100,20 +104,18 @@ export interface AutoModeClassifierRound {
  * the QUESTION (the transcript window every rung shares), not in a rung's answer.
  *
  * WHY IT EXISTS. The ladder advances on "the rung produced no ruling", and a hook that rejects looks exactly
- * like that. But a classification whose prompt could not be built fails IDENTICALLY on every rung (the build is one
- * shared promise, by contract — "the same prompt, re-asked" is literal), so the walk recorded a fallback
- * `{from: seat, to: main, cause: "error"}` and a deny sentence naming two models, for a classification in which NO
- * MODEL WAS EVER DISPATCHED: a transcript-store outage read, on every face a person can see, as a broken
- * classifier seat. The verdict is unchanged (fail-closed `unavailable`); what changes is that the record
- * stops attributing it to models that were never asked.
+ * like that. But a classification whose prompt could not be built fails IDENTICALLY on every rung (the build is
+ * one shared promise, by contract — "the same prompt, re-asked" is literal), so without this word the walk
+ * records a fallback and a deny sentence naming two models for a classification in which NO MODEL WAS EVER
+ * DISPATCHED. The verdict is unchanged (fail-closed `unavailable`); what this changes is that the record stops
+ * attributing it to models that were never asked.
  *
  * Carried as a `code` on the thrown error rather than a class so any classify hook — including one this
  * package never constructed — can raise it without importing a constructor.
  *
  * WHAT IT DOES NOT COVER, stated: a build that OUTRUNS a rung's cap is still recorded as that rung's
  * `timeout`. The cap bounds the whole classify call, assembly included, so at that point nothing distinguishes
- * a slow transcript store from a slow model. Moving the per-classification build outside the rung cap is a
- * seam change, filed for a later version.
+ * a slow transcript store from a slow model.
  */
 export declare const AUTO_MODE_ROUND_NOT_ASKED_CODE = "auto_mode.round_not_asked";
 /** Mint the marker above around whatever failed, keeping the original as `cause` for the host's own logs.
@@ -124,8 +126,25 @@ export declare const AUTO_MODE_ROUND_NOT_ASKED_CODE = "auto_mode.round_not_asked
 export declare function autoModeRoundNotAsked(reason: unknown): Error & {
     code: string;
 };
-/** Why a rung did not settle the classification, or `undefined` when it RULED and the ladder stops — the ONE
- *  predicate behind the advance (there is no `if (fallback)` arm anywhere). */
+/**
+ * Why a rung did not settle the classification, or `undefined` when it SETTLED it and the ladder stops — the
+ * ONE predicate behind the advance (there is no `if (fallback)` arm anywhere).
+ *
+ * A rung settles the classification two ways: it RULES (`allow` / `block`), or it answers with a
+ * CONTRADICTION (`parse_error` of form `conflict` — two distinct `<block>` answers in one reply). The second
+ * is not a ruling and stays the fail-closed deny it is; what it is NOT is an unanswered question. It holds a
+ * `yes`, so asking the SAME question again — of the same model as a re-ask, or of the next rung as a fallback
+ * — can only overwrite that `yes` with a `no` and allow a call the classifier already objected to. One rule
+ * for both second attempts: {@link AUTO_MODE_PARSE_FAILURES} names the form, the leg reads it for the re-ask
+ * and this predicate reads it for the walk. Only a reply with NO answer in it (`missing`) moves the ladder.
+ *
+ * @contract auto_mode.ladder.advances_on_no_evidence — the candidate ladder advances on exactly one
+ * condition, and it is the ABSENCE of evidence: the rung's leg threw or rejected, its round-trip cap elapsed,
+ * or its reply carried no answer at all. A rung that RULED and a rung whose reply CONTRADICTED itself both
+ * settle the classification where they stand — the contradiction as the fail-closed `parse_error` deny it
+ * already is, attributed to that rung and disclosing no fallback — so no later candidate is ever asked a
+ * question an earlier one has already answered `yes` to.
+ */
 export declare function rungDidNotRule(v: AutoModeVerdict): AutoModeFallbackCause | undefined;
 /**
  * The model-facing deny text for an `unavailable` verdict — CC 2.1.250 `x1t`, with the parenthetical `EIt`

package/dist/core/auto-mode.js

@@ -56,7 +56,7 @@ export function rungDidNotRule(v) {
     if (v.kind === "unavailable")
         return v.cause;
     if (v.kind === "parse_error")
-        return "parse_error";
+        return v.form === "conflict" ? undefined : "parse_error";
     return undefined;
 }
 export function classifierUnavailableDenyMessage(toolName, cause, attribution) {

package/dist/core/child-clamp-seats.d.ts

@@ -0,0 +1,79 @@
+/**
+ * The TIGHTEN-ONLY CLAMP SEATS an engine-built child spec carries from the run that builds it — and the
+ * ONE carrier every such constructor passes them through.
+ *
+ * Why a carrier and not a convention. The engine builds child specs in several places (the delegation
+ * lane, the observer sidecar, the wake/revival fold, the teacher's internal legs, the verify gate's two
+ * legs, the workflow lane), and each re-deriving per seat WHICH value is the tightening one lands a new
+ * seat one constructor at a time — the ones it does not reach staying invisible, since a `grep readFace`
+ * census cannot see a station that carries the face through a persisted seed or a synthesized fold.
+ *
+ * Two mechanical halves replace the census:
+ *  · the COMPILER — {@link ChildClampSource} requires every seat as a PRESENT key (an `undefined` value
+ *    is fine; a missing key is not), so adding a member to {@link CHILD_CLAMP_SEATS} reds `tsc` at every
+ *    construction site until each one says what it carries there;
+ *  · the SCAN — `scripts/verify-child-clamp-seats.mjs` reads {@link ENGINE_CHILD_SPEC_CONSTRUCTORS} and
+ *    requires each registered constructor to go through this carrier, requires the carrier's own source
+ *    to cover every seat, and requires every tighten-only seat `tightenTaskSpec` governs to be either
+ *    carried here or listed in {@link CHILD_CLAMP_SEATS_NOT_CARRIED} with a reason.
+ *
+ * What "tighten-only" means for this seat list: the value that travels is the RESTRICTING one and only
+ * that one, so a parent that clamped nothing changes nothing about its children, and nothing a child can
+ * author lifts a clamp its parent ran under. That is why the carrier omits a key rather than writing a
+ * loosening value — a constructor may state its own stricter default and spread this after it.
+ */
+import type { ReadDenyEntry } from "../tools/fs/read-deny.js";
+import type { TaskSpec } from "./types.js";
+/**
+ * The clamp seats, as string literals (the closed set the scan and the wire-manifest reader both parse —
+ * a spread or an identifier here reads as an empty set).
+ */
+export declare const CHILD_CLAMP_SEATS: readonly ["handsReadOnly", "interactiveTools", "readFace", "writeFace", "readDenyPatterns"];
+/** One clamp seat's name. */
+export type ChildClampSeat = (typeof CHILD_CLAMP_SEATS)[number];
+/**
+ * The seats `tightenTaskSpec` governs that this carrier deliberately does NOT carry, each with the reason
+ * — the "forgot" / "decided" distinction, kept where a new reader will trip over it. The scan requires
+ * every seat named in `tightenTaskSpec` to be in this table or in {@link CHILD_CLAMP_SEATS}.
+ */
+export declare const CHILD_CLAMP_SEATS_NOT_CARRIED: Readonly<Record<string, string>>;
+/**
+ * The engine-built child-spec constructors, as `<repo-relative file>#<name>` — the closed registry the
+ * scan enumerates. A constructor that builds a spec for a child RUN belongs here; the scan requires each
+ * row to resolve to exactly one declaration IN ITS OWN FILE that calls {@link childClampSeats}.
+ *
+ * Why the file is half the key, and why a shape the scan cannot read is a RED rather than an absence: a
+ * registry keyed on a bare NAME asks a syntactic scan to enumerate every shape that binds a callable, and
+ * that list has no end — every shape it misses leaves the real constructor invisible while a namesake
+ * answers for it.
+ */
+export declare const ENGINE_CHILD_SPEC_CONSTRUCTORS: readonly ["src/agents/subagent.ts#buildChildSpec", "src/agents/subagent.ts#observerSpec", "src/agents/subagent.ts#resumeSpec", "src/agents/teacher.ts#inheritedDeploymentConfig", "src/agents/verify.ts#verifierSpec", "src/agents/verify.ts#fixLegSpec", "src/orchestration/workflow-primitives.ts#workflowChildClamps"];
+/**
+ * The clamp source a construction site hands the carrier: EVERY seat as a present key. A site whose lane
+ * has no value for a seat writes `undefined` explicitly — which is the point, since that is a sentence
+ * a reader (and a diff) can see, unlike an absent key.
+ */
+export interface ChildClampSource {
+    /** The write-hands clamp: only `true` travels. */
+    handsReadOnly: boolean | undefined;
+    /** The hard-headless clamp: only `false` travels. */
+    interactiveTools: boolean | undefined;
+    /** The read containment face: only `"roots"` travels. */
+    readFace: TaskSpec["readFace"] | undefined;
+    /** The write containment face: only `"roots"` travels. */
+    writeFace: TaskSpec["writeFace"] | undefined;
+    /** The deny-set additions: an add-only axis, so a non-empty list travels as a spawn-time copy. */
+    readDenyPatterns: readonly ReadDenyEntry[] | undefined;
+}
+/**
+ * Project a parent's clamps onto a child spec — the ONE place that decides, per seat, which value is the
+ * tightening one and how it is copied. Spread the result onto the child spec; a seat with nothing to
+ * clamp contributes NO KEY, so a constructor may state its own stricter value above the spread and keep
+ * it (a `false` from the parent can never lift it).
+ *
+ * @contract child_spec.clamps_travel_whole — every child spec the ENGINE builds carries the whole of its
+ * parent's tighten-only clamp seats (`CHILD_CLAMP_SEATS`) through this one carrier: only the restricting
+ * value of each seat travels, arrays are copied at spawn, and a seat the parent did not clamp adds no key
+ * — so a clamp can never end one level deep, and a new seat cannot reach some constructors and not others.
+ */
+export declare function childClampSeats(source: ChildClampSource): Partial<TaskSpec>;

package/dist/core/child-clamp-seats.js

@@ -0,0 +1,29 @@
+export const CHILD_CLAMP_SEATS = ["handsReadOnly", "interactiveTools", "readFace", "writeFace", "readDenyPatterns"];
+export const CHILD_CLAMP_SEATS_NOT_CARRIED = Object.freeze({
+    toolPolicy: "not a clamp a child spec copies: a parent's denies reach its children through the ancestor-constraint chain the child's own prepare folds, not by putting the parent's policy object on the child seat",
+    shellGate: "travels on the inherited-gate lane (`InheritedGate.shellGate`, a trusted internals seat), not on the child spec — a spec-level copy would be a second source for the same clamp",
+    onAsk: "per-lane by construction: the delegation lane wraps the parent's approver with spawn provenance before it becomes the child's seat, and a lane with no approver must hand down none",
+    hooks: "a deployment seat, not an inherited clamp — `tightenTaskSpec` refuses to merge two hook sets rather than composing them, so there is no tightening value to carry",
+    excludeTools: "roster control rather than containment: the lanes that copy a parent's roster do so beside these seats, and the workflow lane authors its child roster from the governance baseline instead of the host's",
+    deferTools: "roster control, same reading as `excludeTools` above",
+});
+export const ENGINE_CHILD_SPEC_CONSTRUCTORS = [
+    "src/agents/subagent.ts#buildChildSpec",
+    "src/agents/subagent.ts#observerSpec",
+    "src/agents/subagent.ts#resumeSpec",
+    "src/agents/teacher.ts#inheritedDeploymentConfig",
+    "src/agents/verify.ts#verifierSpec",
+    "src/agents/verify.ts#fixLegSpec",
+    "src/orchestration/workflow-primitives.ts#workflowChildClamps",
+];
+export function childClampSeats(source) {
+    return {
+        ...(source.handsReadOnly === true ? { handsReadOnly: true } : {}),
+        ...(source.interactiveTools === false ? { interactiveTools: false } : {}),
+        ...(source.readFace === "roots" ? { readFace: "roots" } : {}),
+        ...(source.writeFace === "roots" ? { writeFace: "roots" } : {}),
+        ...(source.readDenyPatterns !== undefined && source.readDenyPatterns.length > 0
+            ? { readDenyPatterns: [...source.readDenyPatterns] }
+            : {}),
+    };
+}