@abot-ai/runtime 1.4.0 → 1.5.0

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

@@ -0,0 +1,210 @@
+import { resolveSessionWorkingDirectory } from "../projects/session-paths.js";
+import { resolveModelSelection } from "../model/model-selection.js";
+import { resolveScheduledExecution } from "./scheduled-execution.js";
+import { resolveRequestExecutionPolicy } from "./role-executor-composition.js";
+import { initializeRequestSession, openRequestSession, } from "../session/request-session.js";
+import { snapshotRequestHistory } from "../session/request-history.js";
+import { createRequestSessionTitleUpdater, shouldGenerateSessionTitle, } from "../session/session-title.js";
+import { createPersistentRequestEvents, createRequestCallbacks, } from "../streaming/request-callbacks.js";
+import { createRequestContextCompactionStore } from "../context/semantic-compaction/index.js";
+import { restoreRequestContextCompaction } from "../context/semantic-compaction/snapshot.js";
+import { createRequestSessionMemory } from "../context/session-memory/index.js";
+import { restoreRequestSessionMemory } from "../context/session-memory/snapshot.js";
+import { snapshotSessionArtifactPathTargets } from "./session-artifact-path-persistence.js";
+import { createRequestExecutionScope } from "./execution-scope.js";
+import { createRequestWorkerCapabilityProvider } from "./worker-capability-composition.js";
+import { withToolApprovalWait } from "./tool-approval-wait.js";
+import { RequestActivationEvents } from "./approval-wait/activation-events.js";
+import { createRequestApprovalGate } from "./approval-wait/approval-gate.js";
+export async function prepareRequestExecution(params) {
+    const { options, input, dependencies, resources, lifecycle, steering } = params;
+    const { requestId, sessionId } = input;
+    const { sessionStore, modelGatewayClient, longTermMemory, eventSinkFactory } = dependencies;
+    const resume = options.approvalExecution?.resume;
+    const schedule = resolveScheduledExecution(options, input);
+    const loaded = dependencies.loadDecisionEnvironment();
+    const selection = resolveModelSelection({
+        agentMode: input.rawAgentMode,
+        modelPreference: input.rawModelPreference,
+        modelPolicy: loaded.modelPolicy,
+        ...(loaded.modelExecutionPolicies
+            ? { modelExecutionPolicies: loaded.modelExecutionPolicies }
+            : {}),
+    });
+    const executionPolicy = resolveRequestExecutionPolicy(resume?.snapshot.seed.executionPolicySelection?.policy ??
+        selection.execution.policy);
+    const opened = resume
+        ? undefined
+        : await openRequestSession({
+            sessionId,
+            requestId,
+            rawAttachments: input.rawAttachments,
+            sessionStore,
+            attachmentStore: dependencies.attachmentStore,
+            activation: options.approvalExecution?.activation,
+        });
+    const durable = createExecutionEvents(params, opened?.activation);
+    const events = durable?.events ??
+        createPersistentRequestEvents({
+            currentEvents: params.initialEvents,
+            eventSinkFactory,
+            requestId,
+            sessionId,
+            sessionStore,
+            ws: params.ws,
+        });
+    if (durable)
+        params.initialEvents.dispose();
+    const callbacks = createRequestCallbacks(events, resume?.snapshot.presentation);
+    params.onEventsReady(events, callbacks, durable);
+    const generateSessionTitle = resume?.snapshot.seed.shouldGenerateSessionTitle ??
+        shouldGenerateSessionTitle(opened.session);
+    const historyMessages = resume?.snapshot.seed.historyMessages ??
+        snapshotRequestHistory(opened.session);
+    let sessionMemory;
+    if (resume?.snapshot.sessionMemory) {
+        sessionMemory = restoreRequestSessionMemory(resume.snapshot.sessionMemory, {
+            sessionId,
+            repository: sessionStore,
+            compactor: dependencies.sessionMemoryCompactor,
+        });
+    }
+    else if (!resume) {
+        sessionMemory = createRequestSessionMemory({
+            sessionId,
+            session: opened.session,
+            repository: sessionStore,
+            compactor: dependencies.sessionMemoryCompactor,
+        });
+    }
+    const initialized = resume
+        ? undefined
+        : await initializeRequestSession({
+            opened: opened,
+            sessionId,
+            requestId,
+            prompt: input.prompt,
+            agentMode: selection.agentMode,
+            sessionStore,
+            attachmentStore: dependencies.attachmentStore,
+            events,
+            ...(schedule ? { schedule } : {}),
+        });
+    const requestWorkingDirectory = resume?.snapshot.requestWorkingDirectory ??
+        resolveSessionWorkingDirectory(opened.session) ??
+        options.runtimeConfig?.paths.agentWorkDir ??
+        process.cwd();
+    const toolAttachments = resume?.snapshot.toolAttachments ?? initialized.toolAttachments;
+    if (resume)
+        resources.restore(resume.snapshot.resources);
+    let controller = dependencies.toolApprovalController;
+    if (controller && !options.approvalExecution) {
+        controller = withToolApprovalWait(controller, lifecycle);
+    }
+    const modelAttachments = resume?.snapshot.seed.attachments ?? initialized?.modelAttachments;
+    const memoryRecallLimit = options.runtimeConfig?.longTermMemory?.maxRecallCallsPerRequest;
+    const baseSeed = resume?.snapshot.seed ?? {
+        requestId,
+        sessionId,
+        prompt: initialized.prompt,
+        temporalContext: params.temporalContext,
+        historyMessages,
+        shouldGenerateSessionTitle: generateSessionTitle,
+        runnerConfig: loaded.runnerConfig,
+        executionPolicySelection: selection.execution,
+        ...(modelAttachments?.length ? { attachments: modelAttachments } : {}),
+        agentMode: selection.agentMode,
+        ...(selection.modelPreference
+            ? { modelPreference: selection.modelPreference }
+            : {}),
+        ...(selection.modelPolicy ? { modelPolicy: selection.modelPolicy } : {}),
+        toolPermissionMode: input.toolPermissionMode,
+        sessionArtifactPaths: snapshotSessionArtifactPathTargets(opened.session.artifactPaths),
+        ...(memoryRecallLimit !== undefined ? { memoryRecallLimit } : {}),
+    };
+    const seed = {
+        ...baseSeed,
+        ...(schedule ? { scheduledExecution: schedule } : {}),
+        toolResources: resources,
+        modelGatewayClient,
+        longTermMemory,
+        requestSteering: steering,
+        sessionMemory,
+        contextCompactionStore: resume
+            ? restoreRequestContextCompaction(resume.snapshot.compaction)
+            : createRequestContextCompactionStore(),
+        ...(controller ? { toolApprovalController: controller } : {}),
+        ...(options.approvalExecution
+            ? {
+                modelInvocationScope: options.approvalExecution.activation.activationId,
+                approvalGate: createRequestApprovalGate({
+                    resources,
+                    controller,
+                    signal: lifecycle.signal,
+                    onEvent: (name, payload) => {
+                        events.event(name, payload);
+                    },
+                }),
+            }
+            : {}),
+        abortSignal: lifecycle.signal,
+        onAcknowledgement: callbacks.onAcknowledgement,
+        onSessionTitle: createRequestSessionTitleUpdater({
+            shouldGenerateTitle: generateSessionTitle,
+            sessionId,
+            requestId,
+            sessionStore,
+            events,
+            abortSignal: lifecycle.signal,
+        }),
+        onThinkingDelta: callbacks.onThinkingDelta,
+        onThinkingTrace: callbacks.onThinkingTrace,
+        onAnswerToken: callbacks.onAnswerToken,
+        onEvent: (name, extra) => {
+            events.event(name, extra);
+        },
+    };
+    const toolRegistry = options.toolRegistry?.prepareRequest
+        ? await options.toolRegistry.prepareRequest({
+            requestState: resources.state,
+            onRequestDispose: resources.onRequestDispose,
+        })
+        : options.toolRegistry;
+    lifecycle.signal.throwIfAborted();
+    resources.assertRestoredStateClaimed();
+    const request = createRequestExecutionScope({
+        seed,
+        executionPolicy,
+        createWorkerCapabilities: (view) => createRequestWorkerCapabilityProvider({
+            request: view,
+            requestWorkingDirectory,
+            executionPolicyAuthority: executionPolicy.authority,
+            requestAttachments: toolAttachments,
+            ...(options.runtimeConfig
+                ? { runtimeConfig: options.runtimeConfig }
+                : {}),
+            ...(toolRegistry ? { toolRegistryOverride: toolRegistry } : {}),
+        }),
+    });
+    return {
+        request,
+        seed,
+        events,
+        callbacks,
+        durable,
+        requestWorkingDirectory,
+        toolAttachments,
+    };
+}
+function createExecutionEvents(params, openedActivation) {
+    const options = params.options.approvalExecution;
+    if (!options)
+        return undefined;
+    const store = params.dependencies.sessionStore.requestLifecycle;
+    if (!store)
+        throw new Error("durable_approval_store_unavailable");
+    const current = options.resume?.current ?? openedActivation;
+    if (!current)
+        throw new Error("request_activation_missing");
+    return new RequestActivationEvents(store, current, params.dependencies.eventSinkFactory, params.ws);
+}

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

@@ -1,5 +1,6 @@
 import type { SessionMessageObservationMeta } from "../../sessions/types.js";
 import type { MemoryCandidate } from "../long-term-memory/contracts.js";
+export type { RequestApprovalContinuation, RequestRunnerOutcome, } from "./approval-continuation.js";
 export type RequestObservation = {
     observationMeta: SessionMessageObservationMeta;
     observationContent: string;

package/dist/src/runtime/request/role-call-policy.d.ts

@@ -0,0 +1,4 @@
+import { type RoleCallPolicyInput } from "../orchestration/role-calls/index.js";
+import type { CompiledRequestExecutionPolicy } from "./execution-scope.js";
+/** The same canonical policy binds fresh execution and approval hydration. */
+export declare function createRequestRoleCallPolicy(policy: CompiledRequestExecutionPolicy): RoleCallPolicyInput;

package/dist/src/runtime/request/role-call-policy.js

@@ -0,0 +1,16 @@
+import { ROLE_CALL_OBJECTIVE_MAX_LENGTH, ROLE_CALL_RESPONSE_MAX_LENGTH, ROLE_CALL_RESULT_MAX_LENGTH, } from "../orchestration/role-calls/index.js";
+const REQUEST_ROLE_CALL_LIMITS = Object.freeze({
+    maxDepth: 12,
+    maxCalls: 48,
+    maxCapabilityExecutions: 96,
+    maxObjectiveChars: ROLE_CALL_OBJECTIVE_MAX_LENGTH,
+    maxResultChars: ROLE_CALL_RESULT_MAX_LENGTH,
+    maxResponseChars: ROLE_CALL_RESPONSE_MAX_LENGTH,
+});
+/** The same canonical policy binds fresh execution and approval hydration. */
+export function createRequestRoleCallPolicy(policy) {
+    return Object.freeze({
+        authority: policy.authority,
+        limits: REQUEST_ROLE_CALL_LIMITS,
+    });
+}

package/dist/src/runtime/request/root-child-completion.d.ts

@@ -0,0 +1,17 @@
+import type { RoleCallLedger, RoleChildReturnContext } from "../orchestration/role-calls/index.js";
+import type { RoleChildInvocationResult } from "../orchestration/role-executors/contracts.js";
+import type { RequestRoleExecutionHandoff } from "./result.js";
+import type { CompiledRequestExecutionPolicy } from "./execution-scope.js";
+import { type RootObservationHandoff } from "./root-observation-handoff.js";
+import type { SupervisorRootDiagnosticContext } from "./supervisor-root-execution-diagnostics.js";
+/** Used by both a just-invoked child and an entered child from a saved wait. */
+export declare function projectRootChildCompletion(params: {
+    ledger: RoleCallLedger;
+    policy: CompiledRequestExecutionPolicy;
+    child: RoleChildInvocationResult<RequestRoleExecutionHandoff>;
+    diagnostic: SupervisorRootDiagnosticContext;
+    observationHandoff?: RootObservationHandoff;
+}): Readonly<{
+    resume: RoleChildReturnContext;
+    observationHandoff?: RootObservationHandoff;
+}>;

package/dist/src/runtime/request/root-child-completion.js

@@ -0,0 +1,23 @@
+import { bindSupervisorObservationHandoff, } from "./root-observation-handoff.js";
+/** Used by both a just-invoked child and an entered child from a saved wait. */
+export function projectRootChildCompletion(params) {
+    const resume = params.policy.rootContract.projectResume(params.ledger, params.child.returnCommit);
+    const finalObservation = params.child.execution.value?.finalObservation;
+    if (!finalObservation)
+        return {
+            resume,
+            ...(params.observationHandoff
+                ? { observationHandoff: params.observationHandoff }
+                : {}),
+        };
+    return {
+        resume,
+        observationHandoff: bindSupervisorObservationHandoff({
+            diagnostic: params.diagnostic,
+            returnCommit: params.child.returnCommit,
+            resume,
+            finalObservation,
+            replaced: params.observationHandoff !== undefined,
+        }),
+    };
+}

package/dist/src/runtime/request/root-execution-contracts.d.ts

@@ -0,0 +1,45 @@
+import type { RoleCallFrame, RoleCallLedger, RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+import type { RoleApprovalContinuation, RoleApprovalWait } from "../orchestration/role-executors/approval-continuation.js";
+import type { RequestExecutionScope } from "./execution-scope.js";
+import type { RequestRunnerResult } from "./result.js";
+import type { RootContractCallIdentity, RootContractDecision } from "./root-contract.js";
+import type { RootObservationHandoff } from "./root-observation-handoff.js";
+import type { SupervisorRootFailureStage } from "./supervisor-root-execution-diagnostics.js";
+export type RootActivation = Readonly<{
+    head: RoleCallLedgerHead;
+    call: RoleCallFrame;
+    callIdentity: RootContractCallIdentity;
+}>;
+export type RootDecisionActivation = RootActivation & Readonly<{
+    decision: RootContractDecision;
+    decisionSteeringVersion: number;
+    requiresFreshPresentation: boolean;
+    deferPresentation: boolean;
+}>;
+export type RootActivationAttempt = {
+    failureStage: SupervisorRootFailureStage;
+    head?: RoleCallLedgerHead;
+    call?: RoleCallFrame;
+    publishDeferredTitle?: () => Promise<void>;
+};
+export type RootLoopControl = Readonly<{
+    kind: "continue";
+}> | Readonly<{
+    kind: "complete";
+    result: RequestRunnerResult;
+}> | RoleApprovalWait;
+export type RootContinuationPresentation = Readonly<{
+    acknowledgementPublished: boolean;
+    titlePublished: boolean;
+    observationHandoff?: RootObservationHandoff;
+}>;
+export type RootApprovalWait = RoleApprovalWait & Readonly<{
+    root: RootContinuationPresentation;
+}>;
+export type RootExecutionInput = Readonly<{
+    request: RequestExecutionScope;
+    ledger: RoleCallLedger;
+    durableApproval?: boolean;
+    continuation?: RoleApprovalContinuation;
+    presentation?: RootContinuationPresentation;
+}>;

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

@@ -0,0 +1 @@
+export {};

package/dist/src/runtime/request/root-execution-kernel.d.ts

@@ -1,11 +1,13 @@
-import { type RoleCallLedger } from "../orchestration/role-calls/index.js";
+import type { RootExecutionInput, RootApprovalWait } from "./root-execution-contracts.js";
 import { type RequestExecutionScope } from "./execution-scope.js";
 import type { RequestRunnerResult } from "./result.js";
 import type { RootContractAdapter } from "./root-contract.js";
 export type { RootContractCallIdentity, RootContractDecision, RootContractDecisionOutcome, } from "./root-contract.js";
 export type { CompiledRequestExecutionPolicy } from "./execution-scope.js";
 export type RequestRootContractAdapter = RootContractAdapter<RequestExecutionScope>;
-export declare function runRootExecutionKernel(params: {
-    request: RequestExecutionScope;
-    ledger: RoleCallLedger;
+export declare function runRootExecutionKernel(params: RootExecutionInput & {
+    durableApproval: true;
+}): Promise<RequestRunnerResult | RootApprovalWait>;
+export declare function runRootExecutionKernel(params: RootExecutionInput & {
+    durableApproval?: false;
 }): Promise<RequestRunnerResult>;

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

@@ -1,3 +1,10 @@
+import { createRootExecutionFreshness } from "./capability-execution-freshness.js";
+import { bindRoleApprovalWait, isRoleApprovalWait, } from "../orchestration/role-executors/approval-continuation.js";
+import { isWorkerCapabilityApprovalWait } from "../orchestration/worker-capabilities/approval-contracts.js";
+import { createEnteredChildInvocation } from "../orchestration/role-executors/child-invocation/entered-child.js";
+import { projectRootChildCompletion } from "./root-child-completion.js";
+import { finalizeInvalidRootOutput } from "./root-invalid-output.js";
+import { commitSupervisorResponse } from "./root-response-commit.js";
 import { projectRequestToolResults } from "../context/request-tool-results.js";
 import { emitRuntimeStatus } from "../events/runtime-status.js";
 import { isModelStepSteeringSuperseded } from "../model/model-step-steering.js";
@@ -5,9 +12,9 @@ import { resolveRoleCallTransactions, } from "../orchestration/role-calls/index.
 import { RUNTIME_ROOT_ROLE_ID } from "../orchestration/roles.js";
 import { createRoleCapabilityBinding, isWorkerCapabilityOperationSupervisionLimitError, projectWorkerCapabilityCatalogGroups, } from "../orchestration/worker-capabilities/index.js";
 import { runDegradedFinalization } from "../steps/degraded-finalization/run.js";
-import { projectRequestSteeringSnapshot, resolveRequestSteeringInbox, } from "./request-steering.js";
+import { resolveRequestSteeringInbox, } from "./request-steering.js";
 import { traceSupervisorRootAcknowledgementPublished, traceSupervisorRootActivationFailed, traceSupervisorRootActivationStarted, traceSupervisorRootInvocationSuperseded, traceSupervisorRootResponseSuperseded, } from "./supervisor-root-execution-diagnostics.js";
-import { bindSupervisorObservationHandoff, projectSupervisorFinalObservation, } from "./root-observation-handoff.js";
+import { projectSupervisorFinalObservation, } from "./root-observation-handoff.js";
 import { performRootMemoryRecall } from "./root-memory-recall.js";
 import { applyRootModelWorkPlan } from "./root-plan-update.js";
 import { projectRootMemoryRecallMessage } from "../long-term-memory/recall-context.js";
@@ -22,6 +29,7 @@ export async function runRootExecutionKernel(params) {
     return new RootExecutionSession(params).run();
 }
 class RootExecutionSession {
+    params;
     request;
     ledger;
     transactions;
@@ -34,10 +42,15 @@ class RootExecutionSession {
     acknowledgementPublished = false;
     titlePublished = false;
     constructor(params) {
+        this.params = params;
         this.request = params.request;
         this.ledger = params.ledger;
         this.transactions = resolveRoleCallTransactions(params.ledger);
         this.policy = params.request.executionPolicy;
+        this.acknowledgementPublished =
+            params.presentation?.acknowledgementPublished ?? false;
+        this.titlePublished = params.presentation?.titlePublished ?? false;
+        this.observationHandoff = params.presentation?.observationHandoff;
         this.diagnostic = Object.freeze({
             requestId: params.request.requestId,
             allowedRoleIds: this.policy.roleExecutors.roleIds,
@@ -45,15 +58,53 @@ class RootExecutionSession {
         this.requestSteering = resolveRequestSteeringInbox(params.request.requestSteering);
     }
     async run() {
+        if (this.params.continuation?.callers.length) {
+            const child = await this.policy.roleExecutors.invokeChild(createEnteredChildInvocation({
+                requestId: this.request.requestId,
+                context: this.request,
+                ledger: this.ledger,
+                continuation: this.params.continuation,
+            }));
+            if (isRoleApprovalWait(child))
+                return this.captureApprovalWait(child);
+            const completed = projectRootChildCompletion({
+                ledger: this.ledger,
+                policy: this.policy,
+                child,
+                diagnostic: this.diagnostic,
+                ...(this.observationHandoff
+                    ? { observationHandoff: this.observationHandoff }
+                    : {}),
+            });
+            this.resume = completed.resume;
+            this.observationHandoff = completed.observationHandoff;
+        }
         // Every accepted continuation reserves its next activation in the ledger.
         for (;;) {
             const control = await this.runActivation();
+            if (isRoleApprovalWait(control))
+                return this.captureApprovalWait(control);
             if (control.kind === "complete") {
                 return control.result;
             }
         }
     }
+    captureApprovalWait(wait) {
+        if (!this.params.durableApproval)
+            throw new Error("request_durable_approval_not_enabled");
+        return Object.freeze({
+            ...wait,
+            root: Object.freeze({
+                acknowledgementPublished: this.acknowledgementPublished,
+                titlePublished: this.titlePublished,
+                ...(this.observationHandoff
+                    ? { observationHandoff: this.observationHandoff }
+                    : {}),
+            }),
+        });
+    }
     async runActivation() {
+        const steeringVersion = this.requestSteering.snapshot().version;
         const attempt = {
             failureStage: "project_activation",
         };
@@ -70,6 +121,17 @@ class RootExecutionSession {
                 this.traceResponseSuperseded(error.boundSteeringVersion, "after_response");
                 return CONTINUE_ROOT_EXECUTION;
             }
+            const invalidOutput = await finalizeInvalidRootOutput({
+                request: this.request,
+                ledger: this.ledger,
+                expectedHead: attempt.head,
+                failureStage: attempt.failureStage,
+                steeringVersion,
+                publishDeferredTitle: attempt.publishDeferredTitle,
+                error,
+            });
+            if (invalidOutput)
+                return invalidOutput;
             traceSupervisorRootActivationFailed({
                 diagnostic: this.diagnostic,
                 failureStage: attempt.failureStage,
@@ -226,6 +288,7 @@ class RootExecutionSession {
         }
         attempt.failureStage = "invoke_child";
         const child = await this.policy.roleExecutors.invokeChild({
+            allowApprovalWait: true,
             requestId: this.request.requestId,
             context: this.request,
             callerCall: activation.call,
@@ -241,18 +304,20 @@ class RootExecutionSession {
                 : {}),
             turnCount: activation.call.activationCount,
         });
+        if (isRoleApprovalWait(child))
+            return child;
         attempt.failureStage = "project_resume";
-        this.resume = this.policy.rootContract.projectResume(this.ledger, child.returnCommit);
-        if (child.execution.value?.finalObservation) {
-            attempt.failureStage = "bind_observation";
-            this.observationHandoff = bindSupervisorObservationHandoff({
-                diagnostic: this.diagnostic,
-                returnCommit: child.returnCommit,
-                resume: this.resume,
-                finalObservation: child.execution.value.finalObservation,
-                replaced: this.observationHandoff !== undefined,
-            });
-        }
+        const completed = projectRootChildCompletion({
+            ledger: this.ledger,
+            policy: this.policy,
+            child,
+            diagnostic: this.diagnostic,
+            ...(this.observationHandoff
+                ? { observationHandoff: this.observationHandoff }
+                : {}),
+        });
+        this.resume = completed.resume;
+        this.observationHandoff = completed.observationHandoff;
         return CONTINUE_ROOT_EXECUTION;
     }
     async reconsiderCapabilitySelection(activation, decision, attempt) {
@@ -332,6 +397,9 @@ class RootExecutionSession {
             call,
             ledger: this.ledger,
             adapters: this.request.workerCapabilities.provider.getAdapters(),
+            ...(this.request.approvalGate
+                ? { approvalGate: this.request.approvalGate }
+                : {}),
             ...(this.policy.authority.capabilityAuthorities.includes("root")
                 ? {
                     executionFreshness: createRootExecutionFreshness({
@@ -342,15 +410,16 @@ class RootExecutionSession {
                 : {}),
         });
         try {
-            if (decision.action === "invoke_capability") {
-                await binding.execute({
+            const execution = decision.action === "invoke_capability"
+                ? await binding.execute({
                     capabilityId: decision.capabilityId,
                     intent: decision.intent,
                     controls: decision.controls,
-                });
-            }
-            else {
-                await binding.executeBatch({ invocations: decision.invocations });
+                })
+                : await binding.executeBatch({ invocations: decision.invocations });
+            if (isWorkerCapabilityApprovalWait(execution)) {
+                this.resume = undefined;
+                return bindRoleApprovalWait(execution);
             }
         }
         catch (error) {
@@ -417,6 +486,7 @@ class RootExecutionSession {
         const finalObservation = this.observationHandoff
             ? projectSupervisorFinalObservation(this.observationHandoff, this.resume)
             : undefined;
+        attempt.publishDeferredTitle = () => this.publishDeferredTitle(activation, attempt);
         attempt.failureStage = "compose_response";
         const authoredResponse = decision.action === "blocked"
             ? createPlainRootAuthoredResponse(decision.response)
@@ -507,17 +577,6 @@ class RootExecutionSession {
         });
     }
 }
-function createRootExecutionFreshness(params) {
-    const snapshot = projectRequestSteeringSnapshot(params.requestSteering, params.steeringVersion);
-    return Object.freeze({
-        token: Object.freeze({
-            kind: "request_steering_v1",
-            version: snapshot.version,
-            updates: Object.freeze(snapshot.updates.map(({ sequence, text }) => Object.freeze({ sequence, text }))),
-        }),
-        isCurrent: () => params.requestSteering.isCurrent(snapshot.version),
-    });
-}
 function emitSupervisorResumeStatus(request) {
     emitRuntimeStatus(request, {
         stage: "supervisor",
@@ -537,18 +596,3 @@ function requireRootCallFrame(params) {
     }
     return call;
 }
-async function commitSupervisorResponse(params) {
-    const committed = await params.transactions.completeRootResponse({
-        expectedHead: params.expectedHead,
-        callId: params.callId,
-        response: params.response,
-    });
-    if (!committed.ok) {
-        throw new Error(`role_call_ledger_rejected:${committed.issueCode}`);
-    }
-    const output = committed.commit.head.state.rootResponse;
-    if (!output) {
-        throw new Error("supervisor_root_response_missing");
-    }
-    return output;
-}

package/dist/src/runtime/request/root-invalid-output-progress.d.ts

@@ -0,0 +1,4 @@
+import type { RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+import type { DegradedFinalizationProgress } from "../steps/degraded-finalization/contract.js";
+/** Presents recorded plan status only; it neither changes work nor verifies success. */
+export declare function projectInvalidOutputProgress(head: RoleCallLedgerHead): DegradedFinalizationProgress | null;

package/dist/src/runtime/request/root-invalid-output-progress.js

@@ -0,0 +1,16 @@
+import { buildRequestPlanSnapshot } from "./plan-event-projection.js";
+/** Presents recorded plan status only; it neither changes work nor verifies success. */
+export function projectInvalidOutputProgress(head) {
+    const root = head.state.calls.find((call) => call.callId === head.state.rootCallId);
+    const plans = root?.adoptedWorkPlan
+        ? [root.adoptedWorkPlan, ...head.state.plans]
+        : head.state.plans;
+    if (plans.length === 0)
+        return null;
+    const items = plans.flatMap((plan) => buildRequestPlanSnapshot(plan).items);
+    return {
+        planSummary: "",
+        completed: items.filter((item) => item.status === "done"),
+        unresolved: items.filter((item) => item.status !== "done"),
+    };
+}

package/dist/src/runtime/request/root-invalid-output.d.ts

@@ -0,0 +1,21 @@
+import type { RoleCallLedger, RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+import type { RequestExecutionScope } from "./execution-scope.js";
+import type { RequestRunnerResult } from "./result.js";
+import type { SupervisorRootFailureStage } from "./supervisor-root-execution-diagnostics.js";
+type InvalidRootOutputResult = Readonly<{
+    kind: "continue";
+}> | Readonly<{
+    kind: "complete";
+    result: RequestRunnerResult;
+}>;
+/** Finalizes known model-output failures at the still-current root boundary. */
+export declare function finalizeInvalidRootOutput(params: {
+    request: RequestExecutionScope;
+    ledger: RoleCallLedger;
+    expectedHead: RoleCallLedgerHead | undefined;
+    failureStage: SupervisorRootFailureStage;
+    steeringVersion: number;
+    publishDeferredTitle?: (() => Promise<void>) | undefined;
+    error: unknown;
+}): Promise<InvalidRootOutputResult | undefined>;
+export {};