@sema-agent/core 7.5.1 → 7.5.2

package/dist/core/runner/prepare-suspend-saga.js

@@ -0,0 +1,308 @@
+import { defaultTaskRegistry } from "../task-registry.js";
+import { isRemoteExecutionEnv, isSuspendable, RemoteExecutionError } from "../remote-env.js";
+import { constraintChainDigest, constraintChainEntryOfLayer } from "../tool-policy.js";
+import { raceSettlementAgainstSignal } from "./abort-race.js";
+import { placementValueOrAbsent } from "./checkpoint-scope.js";
+import { serializeAnnouncedListings } from "./announce-once-ledger.js";
+import { remoteEnvFailureNote, restoreWorkspaceWithRetry } from "./remote-env-retry.js";
+const PARK_COMPENSATION_TIMEOUT_MS = 30_000;
+export async function compensateUnparkedPause(remoteEnv, snapshotId, io) {
+    const boundCtl = new AbortController();
+    const boundTimer = setTimeout(() => boundCtl.abort(), io.boundMs);
+    const bound = boundCtl.signal;
+    let phase = "resumeVM";
+    let restoreAttempts = 1;
+    let vmRunning = false;
+    const work = (async () => {
+        const { outcome: back, attempts: backAttempts } = await restoreWorkspaceWithRetry(remoteEnv, snapshotId, { abortSignal: bound }, (attempt) => (restoreAttempts = attempt));
+        if (!back.ok) {
+            io.noteFailure(remoteEnvFailureNote("resumeVM", back.error, backAttempts));
+            io.disclose(back.error);
+            return { ok: false, reason: `resumeVM failed (${back.error.code}) while compensating an unparked pause` };
+        }
+        vmRunning = true;
+        if (bound.aborted) {
+            return { ok: false, reason: "resumeVM settled only after the decision bound" };
+        }
+        phase = "postResumeInit";
+        const init = await remoteEnv.postResumeInit({ abortSignal: bound });
+        if (!init.ok) {
+            io.noteFailure(remoteEnvFailureNote("postResumeInit", init.error, 1));
+            io.disclose(init.error);
+            return { ok: false, reason: `postResumeInit failed (${init.error.code}) while compensating an unparked pause` };
+        }
+        return { ok: true };
+    })();
+    const raced = await raceSettlementAgainstSignal(work, bound);
+    clearTimeout(boundTimer);
+    if (raced.tag === "value")
+        return raced.value;
+    if (raced.tag === "threw") {
+        io.noteFailure(remoteEnvFailureNote(phase, raced.error instanceof RemoteExecutionError
+            ? raced.error
+            : new RemoteExecutionError("unknown", `the pause compensation's ${phase} call threw: ${raced.error instanceof Error ? raced.error.message : String(raced.error)}`), phase === "resumeVM" ? restoreAttempts : 1));
+        io.disclose(raced.error);
+        return {
+            ok: false,
+            reason: "the pause compensation threw (adapter contract violation; the deployment's error face carries the exception)",
+        };
+    }
+    const timedOut = new RemoteExecutionError("timeout", `the pause compensation's ${phase} call did not settle within the ${io.boundMs}ms decision bound`);
+    io.noteFailure(remoteEnvFailureNote(phase, timedOut, phase === "resumeVM" ? restoreAttempts : 1));
+    io.disclose(timedOut);
+    const destroyOwnerlessLate = () => {
+        io.disclose(new Error(`park compensation settled after its ${io.boundMs}ms decision bound: the VM is running with no run ` +
+            `left to own it — destroying the env (an ownerless running VM must not linger; the run already took ` +
+            `the fail-closed arm when the bound fired)`));
+        void Promise.resolve()
+            .then(() => remoteEnv.destroy())
+            .catch((destroyErr) => io.disclose(destroyErr));
+    };
+    void work.then((late) => {
+        if (vmRunning) {
+            destroyOwnerlessLate();
+            return;
+        }
+        void late;
+    }, (lateErr) => {
+        io.disclose(lateErr);
+        if (vmRunning)
+            destroyOwnerlessLate();
+    });
+    return {
+        ok: false,
+        reason: `the pause compensation did not settle within ${io.boundMs}ms — treated as failed (a late-restored VM is destroyed; a late restore failure is disclosed)`,
+    };
+}
+function stampPlacementRootSessionId(placementRootResolved) {
+    return placementValueOrAbsent(placementRootResolved);
+}
+function autoModeLatchHealthy(d) {
+    try {
+        return d.breakerOpen() !== true && typeof d.consecutiveFailures === "function" && d.consecutiveFailures() === 0;
+    }
+    catch {
+        return false;
+    }
+}
+export function prepareSuspendSaga(input) {
+    const { gateMachineryActive, abortController, harness, checkpointStore, deps, sessionId, hostTaskId, taskScope, liveSpendRef, resume, nestedStats, internals, activeTools, outputRef, readFileStateForCheckpoint, faceCheckpointSection, reminderMark, handsCwdRef, worktreeSessionRef, inheritedParentConstraints, seedInheritedGate, inheritedAncestorRules, inheritedShellGate, autoModeIntent, autoModeDecider, inheritedAdmittedOrgScopes, ownOrgVerdictRef, orgGovernedProvenance, announcedListingsRef, gitStatusRef, hookIdentity, placementRootResolved, externalContentTargetActive, remoteEnvFailures, memoryEngineSession, suspendLoopRef, ownedEnv, incompleteSuspendAdapter } = input;
+    if (!gateMachineryActive)
+        return { saga: undefined };
+    const inFlightSpendMicroUsd = () => {
+        const own = liveSpendRef.get?.().costMicroUsd ?? 0;
+        const seededNested = resume?.seed.nestedStats.costMicroUsd;
+        const nestedDelta = nestedStats.costMicroUsd - (typeof seededNested === "number" && Number.isFinite(seededNested) ? seededNested : 0);
+        return (Number.isFinite(own) ? own : 0) + Math.max(0, Number.isFinite(nestedDelta) ? nestedDelta : 0);
+    };
+    const repairBundleForCheckpoint = (parkedSpendMicroUsd) => {
+        const carried = internals?.repairBundle !== undefined
+            ? structuredClone(internals.repairBundle)
+            : resume?.seed.repairBundle !== undefined
+                ? structuredClone(resume.seed.repairBundle)
+                : undefined;
+        if (carried === undefined)
+            return undefined;
+        if (parkedSpendMicroUsd === undefined || !Number.isFinite(parkedSpendMicroUsd) || parkedSpendMicroUsd <= 0)
+            return carried;
+        const prior = typeof carried.spentMicroUsd === "number" && Number.isFinite(carried.spentMicroUsd) ? Math.max(0, carried.spentMicroUsd) : 0;
+        carried.spentMicroUsd = prior + parkedSpendMicroUsd;
+        return carried;
+    };
+    const screeningParkDisclosedRef = { done: false };
+    const serializeCheckpointState = (workspaceHandle, parkedSpendMicroUsd) => ({
+        activeTools: [...activeTools],
+        outputRef: { value: outputRef.value, set: outputRef.set },
+        nestedStats: { ...nestedStats },
+        consolidationNotes: undefined,
+        readFileState: readFileStateForCheckpoint ? [...readFileStateForCheckpoint.entries()] : undefined,
+        readFace: faceCheckpointSection(),
+        reminderMark,
+        repairBundle: repairBundleForCheckpoint(parkedSpendMicroUsd),
+        workspaceHandle,
+        handsCwd: handsCwdRef?.current,
+        activeWorktree: worktreeSessionRef?.current ? { ...worktreeSessionRef.current } : undefined,
+        runningBackgroundTasks: (() => {
+            const live = defaultTaskRegistry
+                .list({ owner: hostTaskId, scope: taskScope, sessionId })
+                .filter((t) => t.status === "pending" || t.status === "running")
+                .map((t) => ({ id: t.task_id, ...(t.description !== undefined ? { description: t.description } : {}) }));
+            return live.length > 0 ? live : undefined;
+        })(),
+        pendingSteer: undefined,
+        pendingSteerQueue: undefined,
+        inheritedGate: (() => {
+            const requiresParentConstraint = (inheritedParentConstraints?.length ?? 0) > 0 || seedInheritedGate?.requiresParentConstraint === true;
+            const parentConstraintCount = (inheritedParentConstraints?.length ?? 0) > 0 ? inheritedParentConstraints.length : seedInheritedGate?.parentConstraintCount;
+            const constraintChain = (inheritedParentConstraints?.length ?? 0) > 0
+                ? inheritedParentConstraints.map((pc) => constraintChainEntryOfLayer(pc))
+                : seedInheritedGate?.constraintChain;
+            const constraintDigest = (inheritedParentConstraints?.length ?? 0) > 0
+                ? constraintChainDigest(constraintChain)
+                : seedInheritedGate?.constraintDigest;
+            const autoModeIntentCarried = autoModeIntent && (autoModeDecider === undefined || autoModeLatchHealthy(autoModeDecider));
+            return inheritedAncestorRules !== undefined ||
+                inheritedShellGate !== undefined ||
+                autoModeIntentCarried ||
+                inheritedAdmittedOrgScopes !== undefined ||
+                ownOrgVerdictRef.current !== undefined ||
+                orgGovernedProvenance ||
+                requiresParentConstraint
+                ? {
+                    ...(inheritedAncestorRules !== undefined ? { ancestorRules: structuredClone(inheritedAncestorRules) } : {}),
+                    ...(inheritedShellGate !== undefined ? { shellGate: inheritedShellGate } : {}),
+                    ...(autoModeIntentCarried ? { autoModeRequested: true } : {}),
+                    ...(inheritedAdmittedOrgScopes !== undefined ? { admittedOrgScopes: [...inheritedAdmittedOrgScopes] } : {}),
+                    ...(ownOrgVerdictRef.current !== undefined
+                        ? { ownAdmittedOrgScopes: [...ownOrgVerdictRef.current.scopes], ownAdmittedOrgWriteScope: ownOrgVerdictRef.current.writeScope }
+                        : {}),
+                    ...(orgGovernedProvenance ? { orgAdmissionGoverned: true } : {}),
+                    requiresParentConstraint,
+                    ...(requiresParentConstraint && parentConstraintCount !== undefined ? { parentConstraintCount } : {}),
+                    ...(requiresParentConstraint && constraintChain !== undefined
+                        ? { constraintChain: structuredClone(constraintChain), ...(constraintDigest !== undefined ? { constraintDigest } : {}) }
+                        : {}),
+                }
+                : undefined;
+        })(),
+        announcedListings: serializeAnnouncedListings(announcedListingsRef),
+        gitAnnouncement: gitStatusRef.announced !== undefined ? { ...gitStatusRef.announced } : undefined,
+        delegationProvenance: internals?.delegationProvenance !== undefined ? { ...internals.delegationProvenance.ref.current } : undefined,
+        isDelegatedChild: hookIdentity.isDelegatedChild ? true : undefined,
+        placementRootSessionId: stampPlacementRootSessionId(placementRootResolved),
+        externalContentTarget: externalContentTargetActive ? true : undefined,
+    });
+    const compensatePausedVM = (remoteEnv, snapshotId) => compensateUnparkedPause(remoteEnv, snapshotId, {
+        boundMs: PARK_COMPENSATION_TIMEOUT_MS,
+        noteFailure: (note) => remoteEnvFailures.push(note),
+        disclose: (err) => {
+            try {
+                deps.onError?.(err, { phase: "config", sessionId });
+            }
+            catch {
+            }
+        },
+    });
+    const commitSuspendSaga = async (token, cp, remoteEnv, remoteHandle, cutSignal) => {
+        if (!checkpointStore)
+            return { tag: "absent" };
+        if (memoryEngineSession)
+            await memoryEngineSession.harvest("checkpoint");
+        if (cutSignal?.aborted) {
+            if (remoteEnv !== undefined && remoteHandle?.snapshotId !== undefined) {
+                const back = await compensatePausedVM(remoteEnv, remoteHandle.snapshotId);
+                if (!back.ok) {
+                    abortController.abort();
+                    void harness.abort();
+                    return { tag: "compensation_failed", reason: back.reason };
+                }
+            }
+            return { tag: "cut" };
+        }
+        const announceCommittedScreeningPark = () => {
+            const committedCount = cp.state.inheritedGate?.parentConstraintCount;
+            if (cp.state.inheritedGate?.requiresParentConstraint === true &&
+                !screeningParkDisclosedRef.done &&
+                (inheritedParentConstraints ?? []).some((pc) => pc.preToolUse !== undefined)) {
+                screeningParkDisclosedRef.done = true;
+                try {
+                    deps.onError?.(new Error(`durable park under an inherited PreToolUse SCREENING constraint: this checkpoint records ` +
+                        `requiresParentConstraint with parentConstraintCount=${committedCount ?? "(unrecorded)"}, and the live ` +
+                        `closures cannot be persisted. A resume on THIS Runner re-supplies them automatically; a resume on a fresh ` +
+                        `Runner (restart / another replica) must hand back the whole chain via resumeStream(..., internals), ` +
+                        `rebuilding the screening entry with createPreToolUseConstraintPolicy(hook, env) — otherwise the row stays ` +
+                        `pending. If the face only observes, declare Hooks.preToolUseObservational and it stops entering the chain.`), { phase: "degraded", sessionId, classification: "screening-constraint-in-durable-chain" });
+                }
+                catch {
+                }
+            }
+        };
+        const confirmPutOutcome = async (putErr) => {
+            if (putErr?.code === "checkpoint.already_exists")
+                return "absent";
+            try {
+                const row = await checkpointStore.get(token);
+                if (row == null)
+                    return "absent";
+                const sameCall = (a, b) => a.kind === b.kind && (a.kind !== "tool_approval" || b.kind !== "tool_approval" || a.toolCallId === b.toolCallId);
+                const isOurs = row.scope === cp.scope && row.sessionId === cp.sessionId && row.leafId === cp.leafId && sameCall(row.pendingAction, cp.pendingAction);
+                return isOurs ? "committed" : "absent";
+            }
+            catch (readErr) {
+                deps.onError?.(readErr, { phase: "config", sessionId });
+                return "unknown";
+            }
+        };
+        try {
+            await checkpointStore.put(token, cp);
+            announceCommittedScreeningPark();
+            return { tag: "committed" };
+        }
+        catch (putErr) {
+            deps.onError?.(putErr, { phase: "config", sessionId });
+            const confirmed = await confirmPutOutcome(putErr);
+            if (confirmed === "committed") {
+                try {
+                    deps.onError?.(new Error(`durable approval checkpoint: the store's write reported a failure but the row EXISTS — the commit ` +
+                        `landed and its acknowledgement was lost (a network backend can complete the INSERT and drop the ` +
+                        `connection before replying). The run suspends on that row rather than continuing, which would leave ` +
+                        `a redeemable pending checkpoint behind. This backend's acknowledgement path is lossy — the operator ` +
+                        `face carries the store's own message.`), { phase: "degraded", sessionId, classification: "checkpoint-put-confirmation-lost" });
+                }
+                catch {
+                }
+                announceCommittedScreeningPark();
+                return { tag: "committed" };
+            }
+            if (confirmed === "unknown") {
+                const unknownReason = "the approval checkpoint's state cannot be established (the store rejected the write and then could not be read back; a committed-but-unacknowledged row may exist) — the run is stopped rather than continued past an approval whose durable record is unknown";
+                try {
+                    deps.onError?.(new Error(`durable approval checkpoint: ${unknownReason}`), {
+                        phase: "degraded",
+                        sessionId,
+                        classification: "checkpoint-put-outcome-unknown",
+                    });
+                }
+                catch {
+                }
+                abortController.abort();
+                void harness.abort();
+                return { tag: "unknown", reason: unknownReason };
+            }
+            const reason = "the approval checkpoint could not be persisted (the store rejected the write; the deployment's error face carries the store's own message)";
+            if (remoteEnv !== undefined && remoteHandle?.snapshotId !== undefined) {
+                const back = await compensatePausedVM(remoteEnv, remoteHandle.snapshotId);
+                if (back.ok)
+                    return { tag: "absent", reason };
+                abortController.abort();
+                void harness.abort();
+                return { tag: "compensation_failed", reason };
+            }
+            return { tag: "absent", reason };
+        }
+    };
+    const suspendLoopCapHit = (count, cap, detail) => {
+        if (cap === undefined)
+            return false;
+        if (count + 1 <= cap)
+            return false;
+        suspendLoopRef.hit = true;
+        abortController.abort();
+        void harness.abort();
+        try {
+            deps.onError?.(new Error(`suspend loop: task already suspended ${count} time(s) (max ${cap}); refusing to suspend again${detail}`), { phase: "config", sessionId });
+        }
+        catch {
+        }
+        return true;
+    };
+    const suspendableEnv = ownedEnv !== undefined && isSuspendable(ownedEnv) ? ownedEnv : undefined;
+    const parkOnlyRemoteEnv = suspendableEnv === undefined && ownedEnv !== undefined && isRemoteExecutionEnv(ownedEnv) && incompleteSuspendAdapter === undefined
+        ? ownedEnv
+        : undefined;
+    const parkOnlyHandle = (env) => {
+        const { snapshotId: _lineage, ...identity } = env.workspaceHandle();
+        return { ...identity, restoreMode: "park_only" };
+    };
+    return { saga: { inFlightSpendMicroUsd, serializeCheckpointState, compensatePausedVM, commitSuspendSaga, suspendLoopCapHit, suspendableEnv, parkOnlyRemoteEnv, parkOnlyHandle } };
+}

package/dist/core/runner/prepare-task.d.ts

@@ -1,15 +1,17 @@
 import type { SessionStore } from "../session.js";
-export { DEFAULT_IRREVERSIBLE_SCOPE, checkpointScopeOf } from "./checkpoint-scope.js";
+export { runGuardChain, type GuardChainArgs, type GuardChainOutcome } from "./prepare-context-lane.js";
+export { gatedCallIdOf, USAGE_WINDOW_REAP_MARGIN_MS } from "./park-commit.js";
+export { batchContextAt } from "./prepare-park-ask.js";
+export { compensateUnparkedPause } from "./prepare-suspend-saga.js";
+export { DEFAULT_IRREVERSIBLE_SCOPE, checkpointScopeOf, placementValueOrAbsent } from "./checkpoint-scope.js";
 export { mcpManifestEntries } from "./prepare-wiring-manifest.js";
 export { __resetMaterializeEnvAnnouncements } from "./prepare-tool-disclosure-mount.js";
 export { fileHistoryFilesystemIdentity, resolveFileHistoryScope } from "./prepare-file-history.js";
-import { type OccurrenceIndex } from "../context-edit.js";
-import type { RemoteExecutionEnv, SnapshotId } from "../remote-env.js";
 import type { Runner } from "./runtask.js";
-import type { Prepared, PreparedMicroCompact, PrepareResume, RunInternals } from "./contracts.js";
+import type { Prepared, PrepareResume, RunInternals } from "./contracts.js";
 export type { FileHistoryBoundarySeat, InheritedGate, Prepared, PreparedMicroCompact, PrepareResume, ResolvedWorkspace, RunInternals, UsageGovernance } from "./contracts.js";
-import type { AgentMessage, ExecutionEnv } from "../../internal/harness.js";
-import type { RemoteEnvFailureNote, RunnerDeps, TaskSpec } from "../types.js";
+import type { ExecutionEnv } from "../../internal/harness.js";
+import type { RunnerDeps, TaskSpec } from "../types.js";
 /** Test seam (mirrors `__resetMaterializeEnvAnnouncements`): never called by production code.
  *  Re-arms BOTH arms (a WeakMap has no clear — it is re-minted). Deliberately UNLIKE the read-face
  *  seam below (console latch only): tests here legitimately reuse ONE sink across prepares to pin
@@ -36,15 +38,6 @@ export { __resetReadFaceClampAnnouncement } from "./prepare-hands-readface.js";
  * checkpoint-cost calibration in one place.
  */
 export declare const ENV_LIFETIME_SUSPEND_MARGIN_MS = 60000;
-/**
- * design/164 件五 — how long AFTER a governance window frees a `usage_window` checkpoint stays reapable-free.
- * The retention TTL answers "was this abandoned?"; a usage-window suspend is not abandoned while the window
- * it waits on is still full, so its deadline is pushed to `retryAfterMs + this`. One hour gives a host's
- * scheduler a realistic chance to pick the resume up (a cron tick, a queue drain) before the row is
- * treated as garbage — small next to the 30-day retention it is compared against, and large next to any
- * polling interval a driver would sanely use.
- */
-export declare const USAGE_WINDOW_REAP_MARGIN_MS: number;
 /**
  * design/164 件四 — resolve the moment an env's lifetime EXPIRES (epoch ms), or `undefined` when the env
  * declares none / cannot be aged. Split out as a pure function so the anchor rules are testable and
@@ -71,71 +64,7 @@ export declare function resolveEnvLifetimeExpiry(env: ExecutionEnv, observedAt:
 export { resolveCheckpointStore } from "../checkpoint-store.js";
 export { isFableFamilyModelId, resolveAttachmentsConfig, resolveModelPromptTraits, resolveTaskLimits } from "./prepare-config-doors.js";
 export { rebaseWorkspacePath, rebaseWorkspacePathAcross } from "./workspace-path.js";
-/** See {@link runGuardChain}. */
-export interface GuardChainArgs {
-    /** The post-frontier view the chain starts from. */
-    edited: AgentMessage[];
-    /** The pre-cap counterpart view (arm A's clearSource — RB-212 durable composition seat). */
-    replayed: AgentMessage[];
-    index: OccurrenceIndex;
-    microCompact: PreparedMicroCompact;
-    guardAt: number;
-    charsPerToken: number;
-    offloadStore: import("../tool-result-store.js").ToolResultStore | undefined;
-    sessionId: string;
-    taskId: string;
-    deps: RunnerDeps;
-    trimPressureRef: {
-        droppedMessages: boolean;
-    };
-    recheck: boolean | undefined;
-    signal: AbortSignal | undefined;
-    /** The r7 per-request observation buffer — the chain DROPS it on its early returns (a discarded
-     *  provisional projection must not narrate itself). */
-    pendingProjectionObservations: Array<() => void>;
-}
-export type GuardChainOutcome = {
-    earlyReturn: {
-        messages: AgentMessage[];
-        adoptSessionRebuild?: boolean;
-    };
-} | {
-    working: AgentMessage[];
-    trimmed: AgentMessage[];
-    trimDroppedMessages: boolean;
-};
-/**
- * design/374 slice 3 — the GUARD CHAIN over one request build (D-7 case-ii transfer table),
- * module-level per the design/238 body-span bank. design/123 D3: the chain reads the anchored
- * coordinate re-estimated on the EDITED array (pre-anchor clears don't lower it — deliberately;
- * trimToBudget doc). The opt-out machine = the pre-374 backstop order byte-identical
- * (trim as the ordinary second line); otherwise arm A (blocking machine run, only when the
- * frontier pass is off) → arm B (in-turn forced compaction behind the adopt seam) → arm C (trim,
- * the disaster-only last resort and this chain's sole `context.trim` emitter). Returns either the
- * post-chain view for the pipeline tail, or an EARLY hook result the context handler must return
- * verbatim (arm-B adoption / the r8 dead-turn stand-down).
- */
-export declare function runGuardChain(args: GuardChainArgs): Promise<GuardChainOutcome>;
-/**
- * WHICH tool call a committed durable park is holding this run — `undefined` when nothing parked, or
- * when the park that did commit holds no call (a resource slice, a plan review).
- *
- * SINGLE derivation on purpose. Two consumers need this answer: the abort-classification seam, which
- * stamps it into the `details` of the results the loop mints for the contaminated siblings, and the
- * `tool_end` projection, which puts it on the wire. Reading it from one function keeps the two from
- * disagreeing about WHICH HOLDER WINS or about what a holder with no call means. They are not otherwise
- * interchangeable: the frame face applies strictly narrower conditions on top of this answer (see
- * `tool_end.gatedCallId`), so a frame may omit an id this function returns — never the reverse.
- *
- * The frame side must not read the id back out of a tool RESULT even though the marker is there: a
- * result's `details` is written by the tool (and replaceable by post-tool hooks), so lifting a
- * cross-call attribution from it would let any failing tool name an arbitrary call and put a phantom
- * approval wait on someone else's frame. Same rule, same reason, as `settledBy`.
- *
- * The two holders are never both set (the commit-side discriminant writes exactly one); they are read
- * here in assemble-result's slot order so the winner is the same one the terminal status is built from.
- */
-export declare function gatedCallIdOf(p: Pick<Prepared, "suspendRef" | "reviewRef">): string | undefined;
+/** Everything the run loop needs, built once by {@link prepareTask} (task setup, isolated from the loop). */
 /**
  * RB-330 + 5.38 r2 件2 — the SINGLE effective-delegation derivation for a leg, minted once per prepare
  * and read by EVERY consumer face; two facets, one source:
@@ -165,62 +94,6 @@ export declare function effectiveDelegationFacts(internals: Pick<RunInternals, "
     isDelegatedChild: boolean;
     isNonForkChild: boolean;
 };
-/**
- * From the resumed/active transcript, the batch position of `currentId` (design/45 §4.ter): the tool-call
- * ids of the assistant message that issued it (the batch), and the subset already resolved (executed
- * before the suspend — #1..k-1). ID-based, not positional (council Question #1): immune to reordering.
- */
-export declare function batchContextAt(messages: AgentMessage[], currentId: string): {
-    batchToolCallIds: string[];
-    completedCallIds: string[];
-};
-/**
- * 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;
-}>;
-/**
- * rescan C5 — the ONE spelling of the placement fields' empty-string discipline: `""` is absence
- * wearing clothes (the resume entry's principal-rung posture), and every placement read that must
- * treat it so — the resume rung's two sides (runtask), the restore fold's seed and the suspend
- * stamp — goes through THIS helper, so three sites cannot drift into three readings. Deliberately
- * NOT applied to the live `internals.placementRoot`/`rootSessionId` reads of the RESOLUTION fold:
- * an empty supplied claim there is an assembly error the execution-env phase's `mintPlacementRootSessionId` refuses
- * loudly on the factory path, and normalizing it away would silently repair what should be loud.
- */
-export declare function placementValueOrAbsent(value: string | undefined): string | undefined;
 /**
  * Build everything a task run needs (council design/34 ②: a free function with EXPLICIT deps, not a
  * Runner method — testable and decoupled). Resolves the model/role/thinking, acquires + reconciles the