@sema-agent/core 7.5.0 → 7.5.2

package/dist/core/runner/prepare-question-face.js

@@ -0,0 +1,84 @@
+import { createAskUserQuestionTool, isLiveQuestionFace } from "../ask-question.js";
+import { boundInputHashOf } from "../canonical-json.js";
+import { resolveCheckpointStore } from "../checkpoint-store.js";
+import { CONTENT_ASK_BINDING_CAP } from "./content-ask-bindings.js";
+export { CONTENT_ASK_BINDING_CAP } from "./content-ask-bindings.js";
+export function prepareQuestionFace(input) {
+    const { frozenOnQuestion, spec, deps, runtimeCaps, resolvedInteractionPosture, resume, sessionId, tools, inheritedUnavailableAsks } = input;
+    const onQuestion = frozenOnQuestion;
+    const liveQuestionFace = isLiveQuestionFace(onQuestion) ? onQuestion : undefined;
+    const contentAskBindings = new Map();
+    const checkpointStore = resolveCheckpointStore(spec, deps);
+    const questionParkStoreWired = checkpointStore !== undefined;
+    const questionDurableMandateBinding = runtimeCaps?.forceDurableGate === true && questionParkStoreWired;
+    const contentAskRoutable = (toolCallId) => liveQuestionFace !== undefined &&
+        mountedQuestionTool !== undefined &&
+        tools.includes(mountedQuestionTool) &&
+        !questionDurableMandateBinding &&
+        !inheritedUnavailableAsks().has(toolCallId);
+    const lateStrandedAnswers = [];
+    const discloseStrandedAnswers = (records, why) => {
+        if (records.length === 0)
+            return;
+        try {
+            deps.onError?.(new Error(`AskUserQuestion: ${records.length} question(s) were answered by a person but the call never ` +
+                `executed to collect the answer (${records.map((r) => `${r.toolCallId} [delivery ${r.deliveryId}]`).join(", ")}) — ${why}. The answer(s) were NOT ` +
+                `delivered to the model and are gone with this leg; re-ask if the decision is still needed.`), { phase: "degraded", sessionId, classification: "unconsumed-human-answer" });
+        }
+        catch {
+        }
+    };
+    const settleContentAskBindings = () => {
+        const stranded = [];
+        for (const [callId, bound] of contentAskBindings) {
+            if (bound.kind === "answered")
+                stranded.push({ deliveryId: bound.deliveryId, toolCallId: callId });
+        }
+        contentAskBindings.clear();
+        discloseStrandedAnswers(stranded, "the leg ended first (abort, batch teardown, or a loop failure)");
+        const byDelivery = new Map();
+        for (const r of [...stranded, ...lateStrandedAnswers])
+            byDelivery.set(r.deliveryId, r);
+        return [...byDelivery.values()];
+    };
+    const durableQuestionFace = questionParkStoreWired && (spec.durableApproval !== undefined || runtimeCaps?.forceDurableGate === true);
+    const mountedQuestionFace = liveQuestionFace !== undefined
+        ? async (req, signal) => {
+            const bound = contentAskBindings.get(req.toolCallId);
+            if (bound !== undefined) {
+                if (bound.questionsHash === boundInputHashOf(req.questions)) {
+                    contentAskBindings.delete(req.toolCallId);
+                    if (bound.kind === "answered")
+                        return bound.answer;
+                    throw bound.error;
+                }
+                contentAskBindings.delete(req.toolCallId);
+            }
+            return liveQuestionFace(req, signal);
+        }
+        : onQuestion;
+    const questionToolMounted = spec.interactiveTools === true || (spec.interactiveTools !== false && (onQuestion !== undefined || durableQuestionFace));
+    let mountedQuestionTool;
+    if (questionToolMounted)
+        tools.push((mountedQuestionTool =
+            createAskUserQuestionTool(mountedQuestionFace, { principal: spec.principal, sourceTaskId: sessionId }, {
+                ...(resume?.redeemedContentAskCallId !== undefined
+                    ? {
+                        redeemedApprovalCallId: resume.redeemedContentAskCallId,
+                        ...(resume.redeemedContentAskQuestionsHash !== undefined ? { redeemedApprovalQuestionsHash: resume.redeemedContentAskQuestionsHash } : {}),
+                    }
+                    : {}),
+                ...(resolvedInteractionPosture !== undefined ? { posture: resolvedInteractionPosture } : {}),
+                ...(spec.interactiveQuestionFallback === true ? { interactiveFallback: true } : {}),
+                onSyntheticContinuation: ({ questionId, reason }) => {
+                    deps.onError?.(new Error(`AskUserQuestion ${questionId}: no human answer was obtainable (` +
+                        (reason === "seam_absent"
+                            ? "no onQuestion seam is wired"
+                            : reason === "declined_unavailable"
+                                ? "the wired question channel reported nobody was reachable"
+                                : "the wired question channel failed") +
+                        `) — the model was instructed to self-answer and the run CONTINUES (warning, not a failure).`), { phase: "degraded", sessionId, classification: "no-human-autoanswered" });
+                },
+            })));
+    return { checkpointStore, liveQuestionFace, contentAskBindings, contentAskRoutable, lateStrandedAnswers, discloseStrandedAnswers, settleContentAskBindings, durableQuestionFace, mountedQuestionFace, questionToolMounted, mountedQuestionTool };
+}

package/dist/core/runner/prepare-run-refs.d.ts

@@ -0,0 +1,89 @@
+/**
+ * design/390 §1.2 M3a — prepareTask's RUN-REFS phase, verbatim from the driver: the run's own edited-files
+ * ledger, the harness ref, the per-task skill scope, the display-forwarding wrapper, the three run-local refs
+ * (review request / stop-after-turn / plan mode) with the ctx primitives that write them, the subagent-retain
+ * ledger and the worktree-isolation helper. Nothing here has behavior of its own: the phase MINTS SEATS —
+ * mutable cells and the closures bound to them — that later phases, the tool ctx and the run loop read and
+ * write. The interface is the dependency list the segment had implicitly (design/238 R-1).
+ *
+ * SYNCHRONOUS FUNCTION, SYNCHRONOUS CALL: the stretch has no await, so the phase adds no yield between the
+ * file-history phase before it and the inherited-gate fold after it (design/390 §1.5 S1: a stretch with no
+ * await is extracted as a sync function — an `async` wrapper would open a microtask window).
+ *
+ * Every cell that leaves here as `borrowed-mutable` carries its writer table on the Result member (design/238
+ * R-3): the closures minted here, the driver's harness build, the project-context phase's inherited-skill
+ * seed, the skill tool, and the run loop's two writes — nothing else writes them. Read-stability of the host
+ * handles for the call: {@link RunInternals} (`@contract prepare.deps-read-stable`).
+ */
+import type { AgentHarness, ExecutionEnv } from "../../internal/harness.js";
+import type { SubagentWorktreeIsolation } from "../../agents/subagent.js";
+import { SubagentRetainLedger } from "../../agents/retain-ledger.js";
+import type { TaskEvent, TaskSpec } from "../types.js";
+import { ActiveSkillScope } from "./active-skill-scope.js";
+import type { Prepared, RunInternals } from "./contracts.js";
+import { type EditedFilesLedger } from "./edited-files-ledger.js";
+export interface PrepareRunRefsInput {
+    /** borrowed-readonly — the REBOUND spec. Read: `forwardSubagentEvents` (widens the forwarding filter),
+     *  `retainSubagentSessions` (the ledger opt-in and its config), `handsReadOnly` (a read-only run mints no
+     *  worktree helper). Never mutated. */
+    spec: Pick<TaskSpec, "forwardSubagentEvents" | "retainSubagentSessions" | "handsReadOnly">;
+    /** borrowed-readonly — the trusted spawn-side channel; only `onForwardEvent` (the deployment's display
+     *  sink) is read, once, to decide whether a forwarding wrapper exists at all. */
+    internals: Pick<RunInternals, "onForwardEvent"> | undefined;
+    /** borrowed-readonly — the run's resolved env; the worktree helper closes over it (lazy: no I/O until a
+     *  delegation actually mints a worktree). */
+    executionEnv: ExecutionEnv;
+    /** borrowed-readonly — the SETTLED task root (`taskRootFinal`): the worktree helper's base repo root. */
+    taskRootFinal: string;
+}
+export interface PrepareRunRefsResult {
+    /** owned — the ledger's writer (`FileEditedHook`): handed to the hands/read-face phase as its post-write
+     *  seat; nothing else calls it. */
+    noteFileEdited: EditedFilesLedger["note"];
+    /** owned — the ledger's LIVE read face (`Prepared.editedFilesSnapshot`, read at result assembly). */
+    editedFilesSnapshot: EditedFilesLedger["snapshot"];
+    /** borrowed-mutable — the harness seat: holds the harness once built, so a tool's execute can read the model
+     *  the parent is CURRENTLY on (design/38 1B: the `ToolExecuteContext.model` snapshot a delegation tool uses
+     *  for `inherit`), and breaks the harness↔tool_search build cycle (design/36 rematerialize). Writers (R-3):
+     *  the driver, ONCE, when the harness is built (`harnessRef.current = harness`) — before any run. Readers:
+     *  `requestStopAfterTurn` here (mirrors the stop onto the harness's one-way flag), the tool ctx's model
+     *  snapshot, the rebuild seam and the delegation mounts. Identity is the contract: every closure minted
+     *  before the harness exists reads this exact cell. */
+    harnessRef: {
+        current?: AgentHarness;
+    };
+    /** borrowed-mutable — the per-task LIFO skill scope. Writers: the project-context phase (the inherited-
+     *  from-parent seed frame, `push`) and the `skill` tool minted over it (`push` on a manifest load; a frame
+     *  closes by `pop`). Readers: the tool ctx's `activeSkillScope()` snapshot and the skill-scope policy layer. */
+    skillScope: ActiveSkillScope;
+    /** owned — the FILTERED display-forwarding wrapper, or undefined when the deployment wired no sink (the
+     *  tool ctx then carries no `forwardEvent` key). */
+    forwardEvent: ((e: TaskEvent) => void) | undefined;
+    /** borrowed-mutable — the review-request cell (`Prepared.reviewRequestRef`). Writers: `requestReview` here
+     *  (the first request wins) and the run loop's turn-boundary consumer, which clears `pending` once the
+     *  `plan_review` checkpoint is minted. */
+    reviewRequestRef: Prepared["reviewRequestRef"];
+    /** owned — the ctx primitive that arms `reviewRequestRef` (design/80 D-B). */
+    requestReview: (opts?: {
+        reason?: string;
+    }) => void;
+    /** borrowed-mutable — the stop-after-turn latch (`Prepared.stopRequestedRef`). Writers: `requestStopAfterTurn`
+     *  here, and nothing else; the run loop reads it at a turn boundary. */
+    stopRequestedRef: Prepared["stopRequestedRef"];
+    /** owned — the ctx primitive: flips the latch and mirrors it onto the harness's one-way flag. */
+    requestStopAfterTurn: () => void;
+    /** borrowed-mutable — the plan-mode flag (`Prepared.planModeRef`). Writers: `enterPlanMode` here, and the run
+     *  loop's resume ladder, which re-arms it when a REJECTED `plan_review` resumes into a re-plan. Read by the
+     *  tool-call gate (the write-effect refusal). */
+    planModeRef: Prepared["planModeRef"];
+    /** owned — the ctx primitive (mounted on the ctx only under `enablePlanMode`). */
+    enterPlanMode: () => void;
+    /** ownership-ref — the parent-run subagent-retain ledger, or undefined when the spec did not opt in. Its
+     *  lifecycle protocol belongs to the Runner (disposed in the task's terminal finally, design/122 D4); a
+     *  prepare that throws has nothing to release here — the ledger is empty until a delegation retains. */
+    subagentRetain: SubagentRetainLedger | undefined;
+    /** owned — the Agent tool's worktree-isolation helper (lazy; write-capable runs only), or undefined. */
+    worktreeIsolation: SubagentWorktreeIsolation | undefined;
+}
+/** The M3a phase body — prepareTask's run-refs stretch, verbatim (see the module header). */
+export declare function prepareRunRefs(input: PrepareRunRefsInput): PrepareRunRefsResult;

package/dist/core/runner/prepare-run-refs.js

@@ -0,0 +1,39 @@
+import { createSubagentWorktreeHelper } from "../../agents/subagent.js";
+import { SubagentRetainLedger } from "../../agents/retain-ledger.js";
+import { ActiveSkillScope } from "./active-skill-scope.js";
+import { createEditedFilesLedger } from "./edited-files-ledger.js";
+export function prepareRunRefs(input) {
+    const { spec, internals, executionEnv, taskRootFinal } = input;
+    const { note: noteFileEdited, snapshot: editedFilesSnapshot } = createEditedFilesLedger();
+    const harnessRef = {};
+    const skillScope = new ActiveSkillScope();
+    const forwardSink = internals?.onForwardEvent;
+    const forwardEvent = forwardSink
+        ? (e) => {
+            if (e.type === "task_progress")
+                forwardSink(e);
+            else if (spec.forwardSubagentEvents === true &&
+                (e.type === "text_delta" || e.type === "text_end" || e.type === "reasoning_delta" || e.type === "tool_start" || e.type === "tool_end")) {
+                forwardSink(e);
+            }
+        }
+        : undefined;
+    const reviewRequestRef = {};
+    const requestReview = (opts) => {
+        if (reviewRequestRef.pending === undefined) {
+            reviewRequestRef.pending = opts?.reason !== undefined ? { reason: opts.reason } : {};
+        }
+    };
+    const stopRequestedRef = { current: false };
+    const requestStopAfterTurn = () => {
+        stopRequestedRef.current = true;
+        harnessRef.current?.requestStopAfterTurn();
+    };
+    const planModeRef = { active: false };
+    const enterPlanMode = () => {
+        planModeRef.active = true;
+    };
+    const subagentRetain = spec.retainSubagentSessions ? new SubagentRetainLedger(spec.retainSubagentSessions) : undefined;
+    const worktreeIsolation = spec.handsReadOnly !== true ? createSubagentWorktreeHelper(executionEnv, taskRootFinal) : undefined;
+    return { noteFileEdited, editedFilesSnapshot, harnessRef, skillScope, forwardEvent, reviewRequestRef, requestReview, stopRequestedRef, requestStopAfterTurn, planModeRef, enterPlanMode, subagentRetain, worktreeIsolation };
+}

package/dist/core/runner/prepare-safety-scan.d.ts

@@ -1,9 +1,5 @@
 import type { RunnerDeps, TaskSpec, ToolEffect } from "../types.js";
-/** The namespaced-name shapes the protocol table currently owns, rendered for the two messages that have
- *  to name them (the caller-name reservation and the policy audit's unprefixed-name arm). Read from the
- *  table rather than written out: a message that hard-codes ONE protocol becomes wrong — while staying
- *  green — the moment a second one is appended, and both messages tell a deployment what to write. */
-export declare const NAMESPACED_NAME_SHAPES: string;
+import type { IrreversibilityTier, ReversibilityProbes } from "./contracts.js";
 export interface PrepareSafetyScanInput {
     /** borrowed-readonly — the REBOUND spec (`spec′`, the config-doors result). The scan reads
      *  `tools`, `handsReadOnly` and `enablePlanMode`; it never mutates. */
@@ -38,14 +34,14 @@ export interface PrepareSafetyScanResult {
     /** borrowed-mutable — tools whose effect is irreversible (`always`, or `maybe` incl. by probe). */
     irreversibleTools: Set<string>;
     /** borrowed-mutable — static per-tool irreversibility tier (prepare-time resolution). */
-    irreversibilityTier: Map<string, "never" | "maybe" | "always">;
+    irreversibilityTier: IrreversibilityTier;
     /** borrowed-mutable — explicit NEGATIVE axis judgments (report-face only; `riskAxesOf` reads). */
     axisExplicitNegatives: Map<string, {
         irreversible?: false;
         egress?: false;
     }>;
     /** borrowed-mutable — declared reversibility probes by tool name. */
-    reversibilityProbes: Map<string, NonNullable<TaskSpec["tools"]>[number]["reversibilityProbe"]>;
+    reversibilityProbes: ReversibilityProbes;
     /** borrowed-readonly — the caller roster's own names, snapshotted before the first await. */
     ownToolNames: ReadonlySet<string>;
 }

package/dist/core/runner/prepare-safety-scan.js

@@ -1,8 +1,7 @@
-import { PROTOCOL_TABLE } from "../protocol-table.js";
+import { NAMESPACED_NAME_SHAPES } from "../protocol-table.js";
 import { HAND_TOOL_EFFECTS } from "../../tools/fs/index.js";
 import { OFFLOAD_TOOL_NAME } from "../tool-result-store.js";
 import { PRESENT_PLAN_TOOL_NAME, ENTER_PLAN_MODE_TOOL_NAME } from "../present-plan-tool.js";
-export const NAMESPACED_NAME_SHAPES = PROTOCOL_TABLE.map((ns) => `${ns.prefix}<peer>__<tool>`).join(", ");
 export function prepareSafetyScan(input) {
     const { spec, deps } = input;
     const toolEffects = new Map();

package/dist/core/runner/prepare-suspend-saga.d.ts

@@ -0,0 +1,170 @@
+/**
+ * design/390 §1.2 M19 (suspend saga) — prepareTask's DURABLE SETTLEMENT machinery, verbatim from the driver's
+ * gate-machinery block: the in-flight spend and repair-bundle folds, the §4.bis correctness-state serializer, the shared
+ * paused-VM compensation bound to this task's failure ledger, the put-commit + put-failure saga (the pre-put cut
+ * checkpoint, the screening-park disclosure, the rejection read-back with its three answers), the suspend-loop cap, the
+ * env capability split (suspendable / park-only / neither) and the park-only handle. The module-scope helpers only this
+ * segment called moved with it (the compensation's bound and body, the auto-mode latch reading, the placement stamp).
+ * The interface is the dependency list the segment had implicitly (design/238 R-1) — every seat below used to be
+ * captured off the driver's scope.
+ *
+ * SYNCHRONOUS FUNCTION, SYNCHRONOUS CALL: the stretch has no await of its own (every await lives inside the closures it
+ * builds, which run at park time), so the phase adds no yield between the ask lane before it and the boundary parks
+ * after it (design/390 §1.5). Read-stability of the host handles for the call: {@link RunInternals}
+ * (`@contract prepare.deps-read-stable`).
+ *
+ * The saga exists exactly when the wiring-manifest phase's `gateMachineryActive` holds (the ask lane's presence law) —
+ * the boundary parks and the park closure key off `saga`'s presence, so the orchestrator grows no branch.
+ */
+import type { AgentHarness, ExecutionEnv } from "../../internal/harness.js";
+import type { AutoModeDecider } from "../auto-mode.js";
+import type { OwnOrgAdmissionVerdict } from "../memory-admission.js";
+import type { RemoteExecutionEnv, SnapshotId } from "../remote-env.js";
+import type { CheckpointStore, SerializedCheckpointState } from "../checkpoint-store.js";
+import type { RemoteEnvFailureNote, RunnerDeps } from "../types.js";
+import type { CwdRef } from "../../tools/fs/fs-shared.js";
+import type { ReadFileState } from "../../tools/fs/safety.js";
+import type { OutputRef } from "./synthetic-tools.js";
+import type { HookInvocationIdentity } from "../hooks.js";
+import type { InheritedGate, Prepared, PrepareResume, RunInternals, SuspendSaga } from "./contracts.js";
+/**
+ * design/384 slice 2 — the ONE compensation for a paused-but-unparked VM, shared by the fence's
+ * post-pause checkpoints (③ in the park closure, ④ in the saga) and the saga's put-failure absent
+ * arm (previously inline there: same two hops, one implementation now, so the three sites cannot
+ * drift). Restores the workspace (bounded transient retry) then re-establishes consistency
+ * (`postResumeInit`), both hops under one INDEPENDENT `AbortSignal.timeout(io.boundMs)` —
+ * deliberately NOT the run/cut signal: the remote contract answers an already-aborted signal
+ * `{ok:false,"aborted"}`, so gating the restore on the very signal whose firing caused the
+ * compensation made it die instantly and strand the paused VM on exactly the run-abort arm that
+ * needs it most. The adapter signal is best-effort (a deaf adapter ignores it), so the caller's
+ * await is ALSO raced against the same bound — bounded decision, three outcomes:
+ *  · settled ok  ⇒ the VM is running again ({ok:true});
+ *  · settled not-ok / threw ⇒ recorded + disclosed, {ok:false} — the caller takes its fatal
+ *    fail-closed arm (abort the run; never continue on a paused VM);
+ *  · bound fires with the adapter still in flight ⇒ {ok:false} NOW, and the in-flight call
+ *    continues DETACHED + swallow-guarded with the late-settlement split:
+ *     – late SUCCESS: a running VM now exists with no run and no committed row to own it — the
+ *       detached continuation compensates the compensation with `destroy()` (the adapter's own
+ *       best-effort contract, swallow-guarded, disclosed);
+ *     – late FAILURE: disclosed; the VM is most likely still paused — provider-side TTL/GC
+ *       territory, and the disclosure is the end of this engine's obligation (a deaf adapter's
+ *       stranded VM is that adapter's own defect surface).
+ * Decide-then-disclose throughout: `io.disclose`/`io.noteFailure` must be swallow-guarded by the
+ * caller's binding, and nothing they do can change the returned verdict. Never throws. Exported for
+ * direct unit pinning (the bounded/deaf/late arms need a small bound; production binds the
+ * `PARK_COMPENSATION_TIMEOUT_MS` constant at the one call-site closure).
+ */
+export declare function compensateUnparkedPause(remoteEnv: RemoteExecutionEnv, snapshotId: SnapshotId, io: {
+    boundMs: number;
+    noteFailure: (note: RemoteEnvFailureNote) => void;
+    disclose: (err: unknown) => void;
+}): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+}>;
+export interface PrepareSuspendSagaInput {
+    /** borrowed-readonly — the wiring-manifest phase's ONE activation predicate; false ⇒ this phase builds nothing and
+     *  returns an absent saga. */
+    gateMachineryActive: boolean;
+    /** borrowed-mutable — prepare's abort seat. Writer here: the fail-closed arms (`abort()` when a paused VM cannot be
+     *  restored, when the put outcome is unknowable, when the loop cap trips); `.signal` is read by the mint sites. */
+    abortController: {
+        readonly signal: AbortSignal;
+        abort(): void;
+    };
+    /** borrowed-mutable — the built harness. Writer here: `abort()` on the same fail-closed arms (release the gate,
+     *  then stop the loop — the two-step every stop in this file takes). */
+    harness: Pick<AgentHarness, "abort">;
+    /** borrowed-readonly — the leg's checkpoint store, or undefined (then the saga answers `absent` and no park commits). */
+    checkpointStore: CheckpointStore | undefined;
+    /** borrowed-readonly — the deployment's error face, as a Pick over the SAME `deps` object (receiver preserved for
+     *  `deps.onError?.()`): the put-failure disclosures, the compensation's disclose binding, the cap line. */
+    deps: Pick<RunnerDeps, "onError">;
+    /** borrowed-readonly — the acquired session id (every disclosure's tag, the running-tasks owner triple, the row's
+     *  session). */
+    sessionId: string;
+    /** borrowed-readonly — the per-task identity (the running-tasks owner triple). */
+    hostTaskId: string;
+    /** borrowed-readonly — the registry scope (the running-tasks owner triple). */
+    taskScope: string;
+    /** borrowed-readonly — the loop's live spend seat (`Prepared.liveSpendRef`); `.get` is read at mint time. Not written
+     *  here (runtask sets `.get`). */
+    liveSpendRef: Prepared["liveSpendRef"];
+    /** borrowed-readonly — the resume leg, or undefined: `seed.nestedStats` (the spend delta's base), `seed.repairBundle`
+     *  (the pass-through bundle). */
+    resume: Pick<PrepareResume, "seed"> | undefined;
+    /** borrowed-readonly — the cumulative nested-usage accumulator (`Prepared.nestedStats`); read at mint time, copied
+     *  onto the row. */
+    nestedStats: Prepared["nestedStats"];
+    /** borrowed-readonly — the trusted spawn-side channel: `repairBundle` (the live bundle) and `delegationProvenance`
+     *  (the aggregate copied onto the row). */
+    internals: Pick<RunInternals, "repairBundle" | "delegationProvenance"> | undefined;
+    /** borrowed-readonly — the ToolSearch activation set (`Prepared.activeTools`); copied onto the row at mint time. */
+    activeTools: Prepared["activeTools"];
+    /** borrowed-readonly — the structured-output seat; `value`/`set` are copied onto the row at mint time. */
+    outputRef: OutputRef;
+    /** borrowed-readonly — the hand's read-file state for the checkpoint, or undefined (hands-less); its entries are
+     *  copied onto the row at mint time. */
+    readFileStateForCheckpoint: ReadFileState | undefined;
+    /** borrowed-readonly — the inherited-gate phase's read-face section builder (the row's `readFace`). */
+    faceCheckpointSection: () => SerializedCheckpointState["readFace"];
+    /** borrowed-readonly — the leg's reminder provenance mark (travels with the row). */
+    reminderMark: string;
+    /** borrowed-readonly — the hand's live tracked cwd, or undefined; `current` is read at mint time. Not written here. */
+    handsCwdRef: CwdRef | undefined;
+    /** borrowed-readonly — the active EnterWorktree session seat, or undefined; `current` is read at mint time. */
+    worktreeSessionRef: Prepared["worktreeSessionRef"];
+    /** borrowed-readonly — the LIVE inherited parent constraints, or undefined (the row's `requiresParentConstraint`,
+     *  count, frozen chain and the screening-park disclosure's predicate). */
+    inheritedParentConstraints: NonNullable<InheritedGate["parentConstraints"]>[number][] | undefined;
+    /** borrowed-readonly — the resume seed's inherited gate, or undefined (the carried-forward half of the same fields). */
+    seedInheritedGate: PrepareResume["seed"]["inheritedGate"];
+    /** borrowed-readonly — the inherited ancestor rules (data half), cloned onto the row. */
+    inheritedAncestorRules: InheritedGate["ancestorRules"];
+    /** borrowed-readonly — the inherited shell-gate doctrine, persisted verbatim. */
+    inheritedShellGate: InheritedGate["shellGate"];
+    /** borrowed-readonly — the auto-mode intent (seat ∨ live ∨ seed), carried while the latch is healthy. */
+    autoModeIntent: boolean;
+    /** borrowed-readonly — the auto-mode decider, or undefined (the latch-health reading only). */
+    autoModeDecider: AutoModeDecider | undefined;
+    /** borrowed-readonly — the inherited admitted org scopes, or undefined (copied onto the row). */
+    inheritedAdmittedOrgScopes: readonly string[] | undefined;
+    /** borrowed-readonly — this leg's OWN org verdict seat; `current` is read at mint time. Not written here. */
+    ownOrgVerdictRef: {
+        current: OwnOrgAdmissionVerdict | undefined;
+    };
+    /** borrowed-readonly — the monotonic org-governed provenance bit. */
+    orgGovernedProvenance: boolean;
+    /** borrowed-readonly — the listing frames' announced name-sets mirror (`Prepared.announcedListingsRef`); serialized
+     *  onto the row at mint time. */
+    announcedListingsRef: Prepared["announcedListingsRef"];
+    /** borrowed-readonly — the git frame's lane ref (`Prepared.gitStatusRef`); `announced` is copied at mint time. */
+    gitStatusRef: Prepared["gitStatusRef"];
+    /** borrowed-readonly — the leg's identity envelope; only `isDelegatedChild` is read (the row's presence-coded bit). */
+    hookIdentity: Pick<HookInvocationIdentity, "isDelegatedChild">;
+    /** borrowed-readonly — the frozen prepare-time placement resolution (the row's placement stamp). */
+    placementRootResolved: string;
+    /** borrowed-readonly — the external-content-target fold (the row's monotonic bit). */
+    externalContentTargetActive: boolean;
+    /** borrowed-mutable — the run-scoped remote-lifecycle failure log (`Prepared.remoteEnvFailures`). Writer here: the
+     *  compensation's note binding (`push`). */
+    remoteEnvFailures: Prepared["remoteEnvFailures"];
+    /** borrowed-readonly — the memory-engine session, or undefined; `harvest("checkpoint")` is called at the commit door. */
+    memoryEngineSession: Prepared["memoryEngineSession"];
+    /** borrowed-mutable — the loop-cap latch (`Prepared.suspendLoopRef`). Writer here: `hit = true` when the cap trips. */
+    suspendLoopRef: Prepared["suspendLoopRef"];
+    /** borrowed-readonly — the per-task owned env when a factory minted one, or undefined (the capability split). Never
+     *  destroyed here. */
+    ownedEnv: ExecutionEnv | undefined;
+    /** borrowed-readonly — the restore-incomplete adapter's missing members, or undefined (excluded from both targets). */
+    incompleteSuspendAdapter: readonly ("resumeVM" | "postResumeInit")[] | undefined;
+}
+export interface PrepareSuspendSagaResult {
+    /** owned — the saga, or undefined exactly when `gateMachineryActive` is false (the boundary parks and the park closure
+     *  key off this seat). */
+    saga: SuspendSaga | undefined;
+}
+/** The M19 suspend-saga phase body — prepareTask's durable settlement stretch, verbatim (see the module header). */
+export declare function prepareSuspendSaga(input: PrepareSuspendSagaInput): PrepareSuspendSagaResult;