@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/runtime/request/approval-wait/super-compaction-restore.js

@@ -0,0 +1,61 @@
+import { createRoleCallLedger } from "../../orchestration/role-calls/index.js";
+import { hasSuperContextContract } from "../../context/super-context-policy.js";
+import { createOwnedSuperContextFailure } from "../../context/super-context-failure.js";
+import { restoreRequestContextCompaction } from "../../context/semantic-compaction/snapshot.js";
+import { assertSuperCompactionSourceIntegrity, assertSuperCompactionCheckpointIntegrity, assertSuperCompactionCheckpointBinding, } from "../../context/semantic-compaction/super-source-integrity.js";
+import { createRequestRoleCallPolicy } from "../role-call-policy.js";
+/** Compatibility must finish before approved effects or any model continuation. */
+export function restoreApprovalCompaction(params) {
+    const { snapshot, executionPolicy } = params;
+    if (!hasSuperContextContract(executionPolicy.authority, "supervisor"))
+        return restoreRequestContextCompaction(snapshot);
+    const ledger = createRoleCallLedger({
+        requestId: params.requestId,
+        policy: createRequestRoleCallPolicy(executionPolicy),
+        checkpoint: params.ledgerCheckpoint,
+    });
+    const head = ledger.current();
+    const call = head.state.calls.find((candidate) => candidate.callId === head.state.activeCallId);
+    if (!call)
+        throw new Error("context_compaction_snapshot_call_invalid");
+    try {
+        const store = restoreRequestContextCompaction(snapshot, {
+            restoreSuperQuarantine: true,
+        });
+        const input = {
+            requestId: params.requestId,
+            prompt: params.prompt,
+            head,
+            store,
+        };
+        assertSuperCompactionSourceIntegrity(input);
+        for (const record of snapshot.invalidatedScopes ?? [])
+            assertSuperCompactionCheckpointBinding({
+                ...input,
+                checkpoint: { ...record.binding, scopeId: record.scopeId },
+            });
+        for (const checkpoint of snapshot.checkpoints)
+            assertSuperCompactionCheckpointIntegrity({ ...input, checkpoint });
+        return store;
+    }
+    catch (cause) {
+        throw createOwnedSuperContextFailure({
+            code: "context_compaction_snapshot_source_incompatible",
+            head,
+            cause,
+            binding: {
+                requestId: params.requestId,
+                callId: call.callId,
+                parentCallId: call.parentCallId,
+                invocationAttempt: call.activationCount,
+                sourceRevision: head.revision,
+                contractId: call.roleId === "supervisor"
+                    ? "supervisor"
+                    : `delegated.${call.roleId}`,
+                modelStep: "context.compact",
+                phase: "approval_resume",
+                scopeId: `approval:${call.callId}`,
+            },
+        });
+    }
+}

package/dist/src/runtime/request/automation-output-contract.d.ts

@@ -0,0 +1,6 @@
+import type { ModelGatewayJsonSchemaFormat } from "../../model-gateway/types.js";
+import type { ToolNormalInvocationInput } from "../../capabilities/normal-invocation/contracts.js";
+import type { RawModelValidationResult } from "../model/invoke-raw-step.js";
+/** Request-local, trusted terminal output contract; absent for ordinary chat. */
+export declare function automationResponseFormat(schema: ToolNormalInvocationInput | undefined): ModelGatewayJsonSchemaFormat | undefined;
+export declare function validateAutomationResponse(schema: ToolNormalInvocationInput, text: string): RawModelValidationResult;

package/dist/src/runtime/request/automation-output-contract.js

@@ -0,0 +1,33 @@
+import { validateJsonSchemaValue } from "../model/json-schema-value.js";
+/** Request-local, trusted terminal output contract; absent for ordinary chat. */
+export function automationResponseFormat(schema) {
+    if (!schema)
+        return undefined;
+    return {
+        type: "json_schema",
+        name: "automation_step_result",
+        strict: true,
+        schema,
+    };
+}
+export function validateAutomationResponse(schema, text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return invalid("automation_agent_output_invalid_json", "Return one JSON object only.");
+    }
+    const issue = validateJsonSchemaValue(schema, parsed);
+    if (issue)
+        return invalid("automation_agent_output_invalid_schema", issue.message);
+    return { ok: true, value: text };
+}
+function invalid(code, message) {
+    return {
+        ok: false,
+        stage: "response_contract",
+        issues: [{ code, path: "output", message }],
+        reason: code,
+    };
+}

package/dist/src/runtime/request/contracts.d.ts

@@ -17,6 +17,9 @@ import type { RequestSteeringInbox } from "./request-steering.js";
 import type { RequestModelStepPort } from "../model/model-step-port.js";
 import type { RequestSessionMemory, SessionMemoryCompactor } from "../context/session-memory/index.js";
 import type { LongTermMemoryService } from "../long-term-memory/contracts.js";
+import type { RegisteredToolEffectPersistence } from "../adapters/registered-tool-normal-invocations/shared/contracts.js";
+import type { ToolNormalInvocationInput } from "../../capabilities/normal-invocation/contracts.js";
+import type { ToolRequestAttachment } from "../../capabilities/tool-types.js";
 export type RunRequestMessage = {
     type: string;
     requestId: string;
@@ -43,6 +46,12 @@ export type RequestHandlerOptions = {
     toolRegistry?: ToolRegistry;
     toolApprovalController?: ToolApprovalController;
     requestSteering?: RequestSteeringInbox;
+    /** Trusted automation-only receipt boundary; never accepted from client JSON. */
+    effectPersistence?: RegisteredToolEffectPersistence;
+    /** Internal Agent-node result shape; never accepted from client JSON. */
+    automationOutputContract?: ToolNormalInvocationInput;
+    /** Validated run-manifest handles for an Automation Agent; never accepted from client JSON. */
+    automationInputAttachments?: readonly ToolRequestAttachment[];
     sessionMemoryCompactor?: SessionMemoryCompactor;
     longTermMemory?: LongTermMemoryService;
 };
@@ -57,6 +66,8 @@ export type RequestExecutionSeed = Readonly<{
     prompt: string;
     temporalContext?: RequestTemporalContext;
     scheduledExecution?: ScheduleMessageReference;
+    /** Trusted persisted session identity; controls root presentation only. */
+    sessionKind?: "spark";
     historyMessages: readonly RequestHistoryMessage[];
     sessionArtifactPaths?: readonly string[];
     shouldGenerateSessionTitle: boolean;
@@ -74,6 +85,8 @@ export type RequestExecutionSeed = Readonly<{
     /** Frozen request-local availability limit for explicit memory recall. */
     memoryRecallLimit?: number;
     requestSteering?: RequestSteeringInbox;
+    effectPersistence?: RegisteredToolEffectPersistence;
+    automationOutputContract?: ToolNormalInvocationInput;
     toolPermissionMode: ToolPermissionMode;
     toolApprovalController?: ToolApprovalController;
     abortSignal: AbortSignal;
@@ -95,10 +108,12 @@ export type AcceptedRequestInput = Readonly<{
     temporalContext?: RequestExecutionSeed["temporalContext"];
     scheduledExecution?: RequestExecutionSeed["scheduledExecution"];
     attachments?: RequestExecutionSeed["attachments"];
+    automationOutputContract?: RequestExecutionSeed["automationOutputContract"];
     agentMode: RequestExecutionSeed["agentMode"];
 }>;
 /** Immutable session snapshot captured before request execution begins. */
 export type RequestSessionSnapshot = Readonly<{
+    sessionKind?: RequestExecutionSeed["sessionKind"];
     historyMessages: RequestExecutionSeed["historyMessages"];
     sessionArtifactPaths?: RequestExecutionSeed["sessionArtifactPaths"];
     shouldGenerateSessionTitle: RequestExecutionSeed["shouldGenerateSessionTitle"];
@@ -123,6 +138,7 @@ export type RequestMemoryRuntime = Readonly<{
 export type RequestLifecycleRuntime = Readonly<{
     approvalGate?: RequestExecutionSeed["approvalGate"];
     requestSteering?: RequestExecutionSeed["requestSteering"];
+    effectPersistence?: RequestExecutionSeed["effectPersistence"];
     toolPermissionMode: RequestExecutionSeed["toolPermissionMode"];
     toolApprovalController?: RequestExecutionSeed["toolApprovalController"];
     abortSignal: RequestExecutionSeed["abortSignal"];

package/dist/src/runtime/request/execution-agent-root-execution.js

@@ -90,6 +90,7 @@ function projectKernelDecision(decision, steeringVersion) {
                 action: "invoke_capability",
                 capabilityId: decision.capabilityId,
                 intent: decision.intent,
+                ...(decision.authoringObjective ? { authoringObjective: decision.authoringObjective } : {}),
                 controls: decision.controls,
                 ...(decision.workingDirectory !== undefined
                     ? { workingDirectory: decision.workingDirectory }
@@ -105,6 +106,7 @@ function projectKernelDecision(decision, steeringVersion) {
                 invocations: Object.freeze(decision.invocations.map((invocation) => Object.freeze({
                     capabilityId: invocation.capabilityId,
                     intent: invocation.intent,
+                    ...(invocation.authoringObjective ? { authoringObjective: invocation.authoringObjective } : {}),
                     controls: invocation.controls,
                 }))),
                 ...(decision.workingDirectory !== undefined

package/dist/src/runtime/request/execution-facets.js

@@ -16,8 +16,12 @@ export function createRequestSeedFacets(seed) {
             ? { attachments: seed.attachments }
             : {}),
         agentMode: seed.agentMode,
+        ...(seed.automationOutputContract !== undefined
+            ? { automationOutputContract: seed.automationOutputContract }
+            : {}),
     });
     const session = Object.freeze({
+        ...(seed.sessionKind ? { sessionKind: seed.sessionKind } : {}),
         historyMessages: seed.historyMessages,
         ...(seed.sessionArtifactPaths !== undefined
             ? { sessionArtifactPaths: seed.sessionArtifactPaths }
@@ -57,6 +61,9 @@ export function createRequestSeedFacets(seed) {
         ...(seed.requestSteering !== undefined
             ? { requestSteering: seed.requestSteering }
             : {}),
+        ...(seed.effectPersistence !== undefined
+            ? { effectPersistence: seed.effectPersistence }
+            : {}),
         toolPermissionMode: seed.toolPermissionMode,
         ...(seed.toolApprovalController !== undefined
             ? { toolApprovalController: seed.toolApprovalController }

package/dist/src/runtime/request/execution-payload-compacted-evidence.d.ts

@@ -0,0 +1,64 @@
+import type { RequestContextCompactionStore } from "../context/semantic-compaction/store.js";
+import type { WorkerCapabilityPayloadContext } from "../orchestration/worker-capabilities/payload-contracts.js";
+import type { WorkerSettledCapabilityResult } from "../orchestration/worker-capabilities/contracts.js";
+type PayloadEvidenceRequest = Readonly<{
+    requestId: string;
+    prompt: string;
+    contextCompactionStore?: RequestContextCompactionStore;
+}>;
+/** Reuses source evidence only; the payload keeps its own accepted assignment. */
+export declare function projectExecutionPayloadCompactedEvidence(request: PayloadEvidenceRequest, context: WorkerCapabilityPayloadContext, results: readonly WorkerSettledCapabilityResult[]): Readonly<{
+    results: readonly (Readonly<{
+        executionId: string;
+        callId: string;
+        invocationAttempt: number;
+        capabilityId: string;
+        declaredEffect: import("../orchestration/role-calls/contracts.js").RoleCapabilityDeclaredEffect;
+        outcome: import("../orchestration/role-calls/contracts.js").RoleCapabilityExecutionOutcome;
+        observedEffect: import("../orchestration/role-calls/contracts.js").RoleCapabilityObservedEffect;
+        summary: string;
+        referenceData?: string;
+        references?: readonly import("../orchestration/role-calls/contracts.js").RoleCapabilityResultReference[];
+        adapterResult: import("../orchestration/capability-adapters/result.js").CapabilityAdapterResult;
+    }> | Readonly<{
+        compactedSourceRef: string;
+        capabilityId: string;
+        summary: string;
+        callId: string;
+        outcome: import("../orchestration/role-calls/contracts.js").RoleCapabilityExecutionOutcome;
+        executionId: string;
+        invocationAttempt: number;
+        observedEffect: import("../orchestration/role-calls/contracts.js").RoleCapabilityObservedEffect;
+        declaredEffect: import("../orchestration/role-calls/contracts.js").RoleCapabilityDeclaredEffect;
+        references?: readonly import("../orchestration/role-calls/contracts.js").RoleCapabilityResultReference[];
+    }>)[];
+    evidence: Readonly<{
+        kind: "runtime_payload_compacted_source_evidence_v1";
+        authority: "passive_reference_only";
+        provenance: "same_call_verified_compaction_sources";
+        purpose: "evidence_for_the_accepted_payload_assignment";
+        presenceEffect: "does_not_change_assignment_permissions_or_completion";
+        omissionMeaning: "summarized_detail_not_proven_absent";
+        requestId: string;
+        callId: string;
+        sourceScopeId: string;
+        sourceRevision: number;
+        sources: readonly import("../context/execution-compacted-evidence.js").ExecutionCompactedSource[];
+    }>;
+}> | {
+    results: readonly Readonly<{
+        executionId: string;
+        callId: string;
+        invocationAttempt: number;
+        capabilityId: string;
+        declaredEffect: import("../orchestration/role-calls/contracts.js").RoleCapabilityDeclaredEffect;
+        outcome: import("../orchestration/role-calls/contracts.js").RoleCapabilityExecutionOutcome;
+        observedEffect: import("../orchestration/role-calls/contracts.js").RoleCapabilityObservedEffect;
+        summary: string;
+        referenceData?: string;
+        references?: readonly import("../orchestration/role-calls/contracts.js").RoleCapabilityResultReference[];
+        adapterResult: import("../orchestration/capability-adapters/result.js").CapabilityAdapterResult;
+    }>[];
+    evidence: undefined;
+};
+export {};

package/dist/src/runtime/request/execution-payload-compacted-evidence.js

@@ -0,0 +1,46 @@
+import { projectExecutionCompactionObjective } from "../context/execution-compaction-objective.js";
+import { resolveExecutionCompactedSources } from "../context/execution-compacted-evidence.js";
+import { projectCompactedCapabilityResultReceipt } from "../context/compacted-capability-result-receipt.js";
+/** Reuses source evidence only; the payload keeps its own accepted assignment. */
+export function projectExecutionPayloadCompactedEvidence(request, context, results) {
+    if (!("root" in context))
+        return { results, evidence: undefined };
+    if (context.contextScope === "target_only")
+        return { results, evidence: undefined };
+    const compacted = resolveExecutionCompactedSources({
+        requestId: request.requestId,
+        prompt: request.prompt,
+        objective: projectExecutionCompactionObjective(request.prompt, context.root.updates),
+        callId: context.root.callId,
+        store: request.contextCompactionStore,
+        results,
+    });
+    if (!compacted)
+        return { results, evidence: undefined };
+    const digests = new Map(compacted.sources.map((digest) => [digest.executionId, digest]));
+    const projected = results.map((result) => {
+        const digest = digests.get(result.executionId);
+        if (!digest)
+            return result;
+        return Object.freeze({
+            ...projectCompactedCapabilityResultReceipt(result),
+            compactedSourceRef: digest.sourceRef,
+        });
+    });
+    return Object.freeze({
+        results: Object.freeze(projected),
+        evidence: Object.freeze({
+            kind: "runtime_payload_compacted_source_evidence_v1",
+            authority: "passive_reference_only",
+            provenance: "same_call_verified_compaction_sources",
+            purpose: "evidence_for_the_accepted_payload_assignment",
+            presenceEffect: "does_not_change_assignment_permissions_or_completion",
+            omissionMeaning: "summarized_detail_not_proven_absent",
+            requestId: request.requestId,
+            callId: context.root.callId,
+            sourceScopeId: compacted.scopeId,
+            sourceRevision: compacted.sourceRevision,
+            sources: compacted.sources,
+        }),
+    });
+}

package/dist/src/runtime/request/execution-scope-surfaces.d.ts

@@ -1,3 +1,4 @@
+import type { SuperFailureFinalization } from "./super-failure-explanation.js";
 import type { RequestModelStepPort } from "../model/model-step-port.js";
 import { type RequestExecutionSeed, type RequestModelInvocationView } from "./contracts.js";
 import type { RequestSeedFacets } from "./execution-facets.js";
@@ -11,4 +12,5 @@ export declare function createScopeSurface(input: Readonly<{
     modelInvocation: RequestModelInvocationView;
     modelSteps: RequestModelStepPort;
     capabilities: RequestWorkerCapabilities;
+    superFailureFinalization?: SuperFailureFinalization | undefined;
 }>): RequestExecutionScope;

package/dist/src/runtime/request/execution-scope-surfaces.js

@@ -41,6 +41,11 @@ export function createCapabilityCompositionView(facets, modelSteps) {
                 toolApprovalController: enumerableGetter(() => facets.lifecycle.toolApprovalController),
             }
             : {}),
+        ...(facets.lifecycle.effectPersistence !== undefined
+            ? {
+                effectPersistence: enumerableGetter(() => facets.lifecycle.effectPersistence),
+            }
+            : {}),
         onEvent: enumerableGetter(() => facets.lifecycle.onEvent),
         ...(facets.session.contextCompactionStore !== undefined
             ? {
@@ -61,11 +66,19 @@ export function createScopeSurface(input) {
     const { facets, policy, modelInvocation, modelSteps, capabilities } = input;
     return createFrozenSurface({
         ...requestSeedDescriptors(facets, policy.selection, true),
+        ...(facets.session.sessionKind
+            ? { sessionKind: enumerableGetter(() => facets.session.sessionKind) }
+            : {}),
         ...(facets.input.scheduledExecution !== undefined
             ? {
                 scheduledExecution: enumerableGetter(() => facets.input.scheduledExecution),
             }
             : {}),
+        ...(facets.input.automationOutputContract !== undefined
+            ? {
+                automationOutputContract: enumerableGetter(() => facets.input.automationOutputContract),
+            }
+            : {}),
         ...(facets.session.sessionMemory !== undefined
             ? {
                 sessionMemory: enumerableGetter(() => facets.session.sessionMemory),
@@ -94,6 +107,11 @@ export function createScopeSurface(input) {
         policy: hiddenValue(policy),
         modelInvocation: hiddenValue(modelInvocation),
         capabilities: hiddenValue(capabilities),
+        ...(input.superFailureFinalization
+            ? {
+                superFailureFinalization: hiddenValue(input.superFailureFinalization),
+            }
+            : {}),
         [BOUND_REQUEST_MODEL_INVOCATION]: hiddenValue(true),
         [REQUEST_EXECUTION_SCOPE]: hiddenValue(true),
     });
@@ -137,6 +155,11 @@ function requestSeedDescriptors(facets, executionPolicySelection, includeSession
             ? { attachments: enumerableGetter(() => facets.input.attachments) }
             : {}),
         agentMode: enumerableGetter(() => facets.input.agentMode),
+        ...(facets.input.automationOutputContract !== undefined
+            ? {
+                automationOutputContract: enumerableGetter(() => facets.input.automationOutputContract),
+            }
+            : {}),
         ...(facets.model.modelPreference !== undefined
             ? {
                 modelPreference: enumerableGetter(() => facets.model.modelPreference),
@@ -162,6 +185,11 @@ function requestSeedDescriptors(facets, executionPolicySelection, includeSession
                 toolApprovalController: enumerableGetter(() => facets.lifecycle.toolApprovalController),
             }
             : {}),
+        ...(facets.lifecycle.effectPersistence !== undefined
+            ? {
+                effectPersistence: enumerableGetter(() => facets.lifecycle.effectPersistence),
+            }
+            : {}),
         abortSignal: enumerableGetter(() => facets.lifecycle.abortSignal),
         onAcknowledgement: enumerableGetter(() => facets.presentation.onAcknowledgement),
         onSessionTitle: enumerableGetter(() => facets.presentation.onSessionTitle),

package/dist/src/runtime/request/execution-scope.d.ts

@@ -1,15 +1,18 @@
+import { type RuntimeFilesystemScope } from "../context/runtime-filesystem-scope.js";
+import { type SuperFailureFinalization } from "./super-failure-explanation.js";
 import type { ToolAvailabilitySource } from "../capabilities/tool-availability.js";
 import type { WorkerCapabilityAdapterProvider } from "../orchestration/worker-capabilities/index.js";
 import type { AcceptedRequestInput, BoundRequestModelInvocationContext, RequestSessionSnapshot, RequestExecutionSeed, RequestIdentity, RequestLifecycleRuntime, RequestModelInvocationView, RequestModelRuntime, RequestMemoryRuntime, RequestPresentation } from "./contracts.js";
 import type { CompiledExecutionPolicy } from "./root-contract.js";
 /** Request fields required while the request-bound capability catalog is built. */
-export type RequestCapabilityCompositionView = BoundRequestModelInvocationContext & Readonly<Pick<RequestExecutionSeed, "sessionId" | "prompt" | "historyMessages" | "toolPermissionMode" | "toolApprovalController" | "onEvent" | "contextCompactionStore">>;
+export type RequestCapabilityCompositionView = BoundRequestModelInvocationContext & Readonly<Pick<RequestExecutionSeed, "sessionId" | "prompt" | "historyMessages" | "toolPermissionMode" | "toolApprovalController" | "effectPersistence" | "onEvent" | "contextCompactionStore">>;
 /**
  * Stable request-owned context delivered to capability adapters.
  * Passive session artifact paths and request containers are excluded.
  */
 export type RequestCapabilityExecutionView = Readonly<Omit<RequestExecutionSeed, "sessionArtifactPaths" | "sessionMemory" | "longTermMemory" | "memoryRecallLimit" | "scheduledExecution">> & BoundRequestModelInvocationContext;
 export type RequestWorkerCapabilities = Readonly<{
+    filesystemScope?: RuntimeFilesystemScope;
     provider: WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView> & Partial<ToolAvailabilitySource>;
     executionContext: RequestCapabilityExecutionView;
 }>;
@@ -30,6 +33,7 @@ export type RequestExecutionScope = RequestExecutionSeed & BoundRequestModelInvo
     modelInvocation: RequestModelInvocationView;
     executionPolicy: CompiledExecutionPolicy<RequestExecutionScope>;
     capabilities: RequestWorkerCapabilities;
+    superFailureFinalization?: SuperFailureFinalization;
     workerCapabilities: RequestWorkerCapabilities;
 }>;
 export type CompiledRequestExecutionPolicy = RequestExecutionScope["executionPolicy"];
@@ -37,8 +41,10 @@ export type RequestWorkerCapabilityProviderSource = Pick<RequestExecutionScope,
 export type RequestWorkerCapabilityCatalog = Pick<WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView>, "getDescriptors" | "getExecutionGuidance">;
 export declare function createRequestExecutionScope(input: Readonly<{
     seed: RequestExecutionSeed;
+    requestWorkingDirectory?: string;
     executionPolicy: CompiledRequestExecutionPolicy;
-    createWorkerCapabilities(view: RequestCapabilityCompositionView): WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView>;
+    superFailureFinalization?: SuperFailureFinalization;
+    createWorkerCapabilities(view: RequestCapabilityCompositionView, filesystemScope?: RuntimeFilesystemScope): WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView>;
 }>): RequestExecutionScope;
 export declare function resolveRequestWorkerCapabilities(input: RequestExecutionScope): RequestWorkerCapabilities;
 export declare function resolveRequestWorkerCapabilityCatalog(input: RequestWorkerCapabilityProviderSource): RequestWorkerCapabilityCatalog;

package/dist/src/runtime/request/execution-scope.js

@@ -1,3 +1,5 @@
+import { captureRuntimeFilesystemScope, } from "../context/runtime-filesystem-scope.js";
+import { createSuperFailureFinalization, } from "./super-failure-explanation.js";
 import { RequestModelStepInvoker } from "../model/invoke-step.js";
 import { createModelInvocationView, createRequestSeedFacets, } from "./execution-facets.js";
 import { createCapabilityCompositionView, createCapabilityExecutionView, createScopeSurface, REQUEST_EXECUTION_SCOPE, } from "./execution-scope-surfaces.js";
@@ -7,14 +9,24 @@ export function createRequestExecutionScope(input) {
     const modelInvocation = createModelInvocationView(facets);
     const modelSteps = Object.freeze(new RequestModelStepInvoker(modelInvocation, facets.lifecycle.onEvent));
     const executionContext = createCapabilityExecutionView(facets, policy.selection, modelSteps);
-    const provider = input.createWorkerCapabilities(createCapabilityCompositionView(facets, modelSteps));
-    const capabilities = Object.freeze({ provider, executionContext });
+    const filesystemScope = captureRuntimeFilesystemScope(input.requestWorkingDirectory);
+    const provider = input.createWorkerCapabilities(createCapabilityCompositionView(facets, modelSteps), filesystemScope);
+    const capabilities = Object.freeze({
+        provider,
+        executionContext,
+        ...(filesystemScope ? { filesystemScope } : {}),
+    });
     return createScopeSurface({
         facets,
         policy,
         modelInvocation,
         modelSteps,
         capabilities,
+        superFailureFinalization: input.superFailureFinalization ??
+            createSuperFailureFinalization({
+                request: input.seed,
+                executionPolicy: input.executionPolicy,
+            }),
     });
 }
 export function resolveRequestWorkerCapabilities(input) {

package/dist/src/runtime/request/handler.d.ts

@@ -1,8 +1,15 @@
 import type WebSocket from "ws";
 import type { RequestHandlerOptions, RunRequestMessage } from "./contracts.js";
+import type { RequestCompletionDisposition } from "./result.js";
 import type { SessionRequestLifecycleSnapshot } from "../../sessions/request-lifecycle/contracts.js";
 export type RequestHandlerOutcome = void | Readonly<{
     kind: "awaiting_approval";
     lifecycle: SessionRequestLifecycleSnapshot;
 }>;
+export type InternalRequestHandlerOutcome = RequestHandlerOutcome | Readonly<{
+    kind: "completed";
+    disposition: RequestCompletionDisposition;
+}>;
 export declare function handleRunRequest(ws: WebSocket, msg: RunRequestMessage, options?: RequestHandlerOptions): Promise<RequestHandlerOutcome>;
+/** In-process terminal metadata; the ordinary handler preserves its public return shape. */
+export declare function handleRunRequestWithOutcome(ws: WebSocket, msg: RunRequestMessage, options?: RequestHandlerOptions): Promise<InternalRequestHandlerOutcome>;