@abot-ai/runtime 1.4.0 → 1.6.0

package/dist/src/runtime/passive-learning/store.js

@@ -0,0 +1,159 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, writeFile, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { normalizeAnalysisSchedule } from "./analysis-schedule.js";
+import { learningBatchExpiresAt } from "./batch-lifecycle.js";
+import { DEFAULT_MATURATION_POLICY, normalizeMaturationPolicy } from "../long-term-memory/maturation/retention.js";
+import { DEFAULT_CO_WORKER_RESOURCE_LIMITS, validateCoWorkerResourceLimits } from "./resources/contracts.js";
+import { normalizeIndependentLearningPreferences } from "./independent-preferences.js";
+import { normalizeLearningApplications } from "./application-policy.js";
+import { DEFAULT_ANALYSIS_TRIGGER, DEFAULT_ANALYSIS_OBSERVATION_COUNT } from "./processing-trigger.js";
+import { readObservationReviewPass } from "./processing-pass.js";
+import { readCoWorkerReviewProgress } from "./review-progress.js";
+import { normalizeLearningActivityControls } from "./activity-permissions.js";
+import { readSparkToolPermissionMode } from "./spark-chat-preferences.js";
+export const DEFAULT_LEARNING_PREFERENCES = Object.freeze({
+    enabled: false,
+    processingPaused: true,
+    excludedApplications: Object.freeze([]),
+    processingExcludedApplications: Object.freeze([]),
+    analysisIntervalMinutes: 15,
+    analysisTrigger: DEFAULT_ANALYSIS_TRIGGER,
+    analysisObservationCount: DEFAULT_ANALYSIS_OBSERVATION_COUNT,
+    analysisWindow: null,
+    collectionWindow: null,
+    proactiveEnabled: false,
+    sparkToolPermissionMode: "ask",
+    proactiveIntervalMinutes: 60,
+    proactiveWindow: null,
+    proactiveMessagesPerDay: 2,
+    maxConcurrentBatches: 1,
+    maturation: DEFAULT_MATURATION_POLICY,
+    resourceLimits: DEFAULT_CO_WORKER_RESOURCE_LIMITS,
+});
+const HISTORY_MAX_BYTES = 4 * 1024 * 1024;
+export function createLearningStateStore(directory) {
+    const file = join(directory, "state.json");
+    return {
+        async read() {
+            try {
+                const value = JSON.parse(await readFile(file, "utf8"));
+                return parseState(value);
+            }
+            catch (error) {
+                if (isMissing(error))
+                    return {
+                        schemaVersion: 1,
+                        preferences: DEFAULT_LEARNING_PREFERENCES,
+                        batches: [],
+                    };
+                throw error;
+            }
+        },
+        async write(state) {
+            await mkdir(directory, { recursive: true, mode: 0o700 });
+            const temporary = `${file}.${randomUUID()}.tmp`;
+            try {
+                await writeFile(temporary, JSON.stringify(state), {
+                    flag: "wx",
+                    mode: 0o600,
+                });
+                await rename(temporary, file);
+            }
+            finally {
+                await rm(temporary, { force: true });
+            }
+        },
+    };
+}
+export function pruneLearningBatches(batches, now) {
+    const candidates = batches
+        .filter((batch) => now < learningBatchExpiresAt(batch))
+        .slice(-50);
+    let size = candidates.reduce((total, item) => total + Buffer.byteLength(JSON.stringify(item)), 0);
+    while (size > HISTORY_MAX_BYTES && candidates.length)
+        size -= Buffer.byteLength(JSON.stringify(candidates.shift()));
+    return candidates;
+}
+export function normalizeLearningPreferences(input, previous) {
+    if (input.enabled !== undefined && typeof input.enabled !== "boolean")
+        throw new Error("invalid_learning_preferences");
+    if (input.processingPaused !== undefined &&
+        typeof input.processingPaused !== "boolean")
+        throw new Error("invalid_learning_preferences");
+    const profile = input.modelProfileId ?? previous.modelProfileId;
+    if (profile !== undefined &&
+        (typeof profile !== "string" || !profile.trim() || profile.length > 128))
+        throw new Error("invalid_learning_model_profile");
+    const excluded = normalizeLearningApplications(input.excludedApplications ?? previous.excludedApplications);
+    const processingExcluded = normalizeLearningApplications(input.processingExcludedApplications ?? previous.processingExcludedApplications ?? []);
+    const maturation = normalizeMaturationPolicy(input.maturation ?? previous.maturation ?? DEFAULT_MATURATION_POLICY);
+    const requestedConcurrency = input.maxConcurrentBatches ?? input.resourceLimits?.maxConcurrentCalls;
+    if (input.maxConcurrentBatches !== undefined && input.resourceLimits !== undefined &&
+        input.maxConcurrentBatches !== input.resourceLimits.maxConcurrentCalls)
+        throw new Error("invalid_learning_preferences");
+    const schedule = normalizeAnalysisSchedule({ ...input,
+        ...(requestedConcurrency === undefined ? {} : { maxConcurrentBatches: requestedConcurrency }) }, previous);
+    const resourceLimits = { ...(input.resourceLimits ?? previous.resourceLimits ?? DEFAULT_CO_WORKER_RESOURCE_LIMITS),
+        maxConcurrentCalls: schedule.maxConcurrentBatches ?? 1 };
+    validateCoWorkerResourceLimits(resourceLimits);
+    return Object.freeze({
+        ...(profile ? { modelProfileId: profile.trim() } : {}),
+        excludedApplications: excluded,
+        processingExcludedApplications: processingExcluded,
+        ...schedule,
+        ...normalizeIndependentLearningPreferences(input, previous),
+        sparkToolPermissionMode: readSparkToolPermissionMode(input.sparkToolPermissionMode === undefined
+            ? previous.sparkToolPermissionMode : input.sparkToolPermissionMode),
+        ...normalizeLearningActivityControls(input, previous),
+        maturation: Object.freeze({ ...maturation }),
+        resourceLimits: Object.freeze({ ...resourceLimits }),
+    });
+}
+function parseState(value) {
+    if (!value || typeof value !== "object")
+        throw new Error("invalid_learning_state");
+    const root = value;
+    if (root.schemaVersion !== 1 ||
+        !root.preferences ||
+        typeof root.preferences !== "object" ||
+        !Array.isArray(root.batches))
+        throw new Error("invalid_learning_state");
+    const preferences = normalizeLearningPreferences({
+        ...root.preferences,
+        analysisIntervalMinutes: root.preferences.analysisIntervalMinutes ?? 5,
+        processingPaused: root.preferences.processingPaused ??
+            !root.preferences.enabled,
+    }, DEFAULT_LEARNING_PREFERENCES);
+    const batches = root.batches.map((item) => {
+        if (!item || typeof item !== "object")
+            throw new Error("invalid_learning_state");
+        const batch = item;
+        if (typeof batch.id !== "string" ||
+            typeof batch.generation !== "string" ||
+            !Number.isFinite(Date.parse(batch.createdAt)) ||
+            !Array.isArray(batch.observations) ||
+            !Array.isArray(batch.recordIds))
+            throw new Error("invalid_learning_state");
+        if (![
+            "pending",
+            "processing",
+            "saved",
+            "reviewed",
+            "discarded",
+            "failed",
+            "cancelled",
+        ].includes(batch.status))
+            throw new Error("invalid_learning_state");
+        const reviewProgress = readCoWorkerReviewProgress(batch.reviewProgress);
+        return { ...batch, ...(reviewProgress ? { reviewProgress } : {}) };
+    });
+    const observationReviewPass = readObservationReviewPass(root.observationReviewPass);
+    return { schemaVersion: 1, preferences, batches, ...(observationReviewPass ? { observationReviewPass } : {}) };
+}
+function isMissing(error) {
+    return (!!error &&
+        typeof error === "object" &&
+        "code" in error &&
+        error.code === "ENOENT");
+}

package/dist/src/runtime/plugins/manifest-projection.js

@@ -40,6 +40,7 @@ export function projectManifestRuntimeContract(discovered, selectedCapabilityIds
         declarations.push({
             definition: {
                 name: capabilityId,
+                pluginName: manifest.name,
                 ...(capability.requiredPermissionMode
                     ? { requiredPermissionMode: capability.requiredPermissionMode }
                     : {}),
@@ -80,6 +81,9 @@ export function projectManifestRuntimeContract(discovered, selectedCapabilityIds
                         ? { fixedParams: operation.fixedParams }
                         : {}),
                     ...(operation.payload ? { payload: operation.payload } : {}),
+                    ...(operation.attachmentInput
+                        ? { attachmentInput: operation.attachmentInput }
+                        : {}),
                 })),
             },
             implementation: STATIC_VALIDATION_IMPLEMENTATION,

package/dist/src/runtime/plugins/manifest-validator.js

@@ -283,6 +283,7 @@ function parseOperation(value, path) {
         "skills",
         "fixedParams",
         "payload",
+        "attachmentInput",
     ], path);
     if (!nonEmptyString(operation.summary)) {
         throw new Error(`${path}.summary must be a non-empty string`);
@@ -298,6 +299,9 @@ function parseOperation(value, path) {
     const payload = operation.payload === undefined
         ? undefined
         : expectRecord(operation.payload, `${path}.payload`);
+    const attachmentInput = operation.attachmentInput === undefined
+        ? undefined
+        : expectRecord(operation.attachmentInput, `${path}.attachmentInput`);
     const fixedParams = parseFixedParams(operation.fixedParams, `${path}.fixedParams`);
     const legacySkills = operation.skills === undefined
         ? undefined
@@ -313,6 +317,9 @@ function parseOperation(value, path) {
             ...(payload
                 ? { payload: payload }
                 : {}),
+            ...(attachmentInput
+                ? { attachmentInput: attachmentInput }
+                : {}),
         },
         ...(legacySkills ? { legacySkills } : {}),
     };

package/dist/src/runtime/ports.d.ts

@@ -8,7 +8,7 @@ import type { ModelGatewayInputTokenCountParams, ModelGatewayInputTokenCountResu
 import type { RuntimeAttachmentStore } from "./attachments/store.js";
 import type { RuntimeAttachmentReference } from "../shared/attachments.js";
 import type { StreamCallbacks } from "../model-gateway/client-stream-parser.js";
-import type { ToolCall, ToolCallAdapter, ToolDefinition, ToolExecutionContext, ToolExecutionResult, ToolExecutionSharedState, ToolImplementation, RegisteredToolNormalInvocation } from "../capabilities/tool-types.js";
+import type { ToolCall, ToolCallAdapter, ToolDefinition, ToolExecutionContext, ToolExecutionResult, ToolExecutionSharedState, ToolImplementation, ToolUnderlyingSettlement, RegisteredToolNormalInvocation } from "../capabilities/tool-types.js";
 import type { RequestLifecycleState } from "./orchestration/lifecycle/request-lifecycle.js";
 import type { RuntimeModelExecutionPolicies } from "./config/model-execution-policy.js";
 import type { LongTermMemoryService } from "./long-term-memory/contracts.js";
@@ -112,6 +112,16 @@ export type AppendSessionContextEntryOptions = {
     requestId?: string;
 };
 export type SessionStore = SessionMemoryRepository & {
+    requestLifecycle?: import("../sessions/request-lifecycle/contracts.js").SessionRequestLifecycleStore;
+    assertInteractiveSession?: (sessionId: string) => Promise<void>;
+    createAutomationSession?: (sessionId: string, origin: import("../sessions/automation-session-origin.js").AutomationSessionOrigin) => Promise<import("../sessions/automation-session-origin.js").AutomationSessionHandle>;
+    runAsAutomationSession?: <T>(handle: import("../sessions/automation-session-origin.js").AutomationSessionHandle, task: () => Promise<T>) => Promise<T>;
+    /** Trusted attempt ownership; never exposed by interactive session routes. */
+    releaseAutomationSession?: (handle: import("../sessions/automation-session-origin.js").AutomationSessionHandle) => void;
+    /** Adapter-owned cleanup of abandoned internal transcripts only. */
+    reconcileAutomationSessions?: (cleanupAttachments: (sessionId: string) => Promise<void>, onError: (sessionId: string, error: unknown) => void) => Promise<void>;
+    createAssistantConversation?: (sessionId: string, input: import("../sessions/assistant-initiative.js").CreateAssistantConversationInput) => Promise<SessionRecord>;
+    appendAssistantInitiative?: (sessionId: string, input: import("../sessions/assistant-initiative.js").CreateAssistantConversationInput) => Promise<SessionRecord>;
     getOrCreateSession: (sessionId: string, options?: SessionCreationOptions) => Promise<SessionRecord>;
     getAllSessions: () => Promise<SessionRecord[]>;
     listSessions: (params?: {
@@ -148,6 +158,15 @@ export type ConversationContextProvider = {
     buildContextWindow: (session: SessionRecord, maxMessages?: number) => ModelContextMessage[];
 };
 export type ToolExecutionOptions = {
+    /** Opaque internal admission from the normal-invocation boundary. */
+    trustedEffectAdmission?: object;
+    /** Trusted lifecycle observer; abort may settle the result before the implementation. */
+    onUnderlyingSettlement?: (settled: Promise<ToolUnderlyingSettlement>) => void;
+    requestWork?: ToolExecutionContext["requestWork"];
+    requestState?: ToolExecutionContext["requestState"];
+    media?: ToolExecutionContext["media"];
+    resultBudget?: ToolExecutionContext["resultBudget"];
+    onRequestDispose?: ToolExecutionContext["onRequestDispose"];
     /** Trusted request snapshot, never parsed from a model tool payload. */
     requestWorkingDirectory?: string;
     abortSignal?: AbortSignal;
@@ -173,7 +192,7 @@ export type ToolApprovalController = {
 };
 export type ToolRegistry = {
     /** Build an isolated availability/execution snapshot before model projection. */
-    prepareRequest?: () => Promise<ToolRegistry>;
+    prepareRequest?: (context?: import("../capabilities/tool-request-resources.js").ToolRequestPreparationContext) => Promise<ToolRegistry>;
     listDefinitions: () => ToolDefinition[];
     /** The sole config-filtered availability snapshot for ordinary invocation. */
     listNormalInvocations?: () => readonly RegisteredToolNormalInvocation[];

package/dist/src/runtime/request/approval-continuation.d.ts

@@ -0,0 +1,24 @@
+import type { RoleCallLedger } from "../orchestration/role-calls/index.js";
+import type { RoleCallLedgerCheckpoint } from "../orchestration/role-calls/checkpoint.js";
+import type { EnteredChildCursor, RoleApprovalContinuation } from "../orchestration/role-executors/approval-continuation.js";
+import type { PreparedApprovalGroup } from "../orchestration/worker-capabilities/approval-contracts.js";
+import type { WorkerCapabilityDescriptor } from "../orchestration/worker-capabilities/contracts.js";
+import type { RootContinuationPresentation } from "./root-execution-contracts.js";
+import type { RequestRunnerResult } from "./result.js";
+/** Logical continuation only, captured at an admitted, undispatched approval boundary. */
+export type RequestApprovalContinuation = Readonly<{
+    kind: "request_approval_continuation_v1";
+    ledger: RoleCallLedgerCheckpoint;
+    root: RootContinuationPresentation;
+    callers: readonly EnteredChildCursor[];
+    preparedGroup: PreparedApprovalGroup;
+}>;
+export type RequestRunnerOutcome = Readonly<{
+    kind: "completed";
+    result: RequestRunnerResult;
+}> | Readonly<{
+    kind: "awaiting_approval";
+    continuation: RequestApprovalContinuation;
+}>;
+export declare function validateRequestApprovalContinuation(continuation: RequestApprovalContinuation, ledger: RoleCallLedger, capabilities?: readonly WorkerCapabilityDescriptor[]): void;
+export declare function createRoleApprovalContinuation(continuation: RequestApprovalContinuation, executionIds: readonly string[]): RoleApprovalContinuation;

package/dist/src/runtime/request/approval-continuation.js

@@ -0,0 +1,62 @@
+import { validateRoleApprovalWait } from "../orchestration/role-executors/approval-continuation.js";
+import { restoreEnteredChild } from "../orchestration/role-executors/child-invocation/entered-child.js";
+import { projectWorkerCapabilityScope } from "../orchestration/worker-capabilities/scope.js";
+export function validateRequestApprovalContinuation(continuation, ledger, capabilities) {
+    if (continuation?.kind !== "request_approval_continuation_v1")
+        throw new Error("request_approval_continuation_invalid");
+    if (typeof continuation.root?.acknowledgementPublished !== "boolean")
+        throw new Error("request_approval_presentation_invalid");
+    if (typeof continuation.root.titlePublished !== "boolean")
+        throw new Error("request_approval_presentation_invalid");
+    const state = ledger.current().state;
+    let callerId = state.rootCallId;
+    if (!Array.isArray(continuation.callers))
+        throw new Error("request_approval_callers_invalid");
+    if (continuation.callers.length > ledger.current().policy.limits.maxDepth)
+        throw new Error("request_approval_callers_too_deep");
+    for (const cursor of continuation.callers) {
+        if (cursor.callerCall.callId !== callerId)
+            throw new Error("request_approval_caller_chain_invalid");
+        const entered = restoreEnteredChild(ledger, cursor);
+        callerId = entered.call.callId;
+    }
+    if (callerId !== continuation.preparedGroup.callId)
+        throw new Error("request_approval_leaf_mismatch");
+    const call = state.calls.find((candidate) => candidate.callId === callerId);
+    if (!call)
+        throw new Error("request_approval_leaf_missing");
+    validateRoleApprovalWait(ledger, call, {
+        kind: "awaiting_approval",
+        group: continuation.preparedGroup,
+        callers: continuation.callers,
+    });
+    // Validate every returning caller as well as the leaf before an approved
+    // effect can run. Unrelated, already settled calls are not resumed.
+    const hasCurrentCapabilityCatalog = capabilities !== undefined;
+    if (!hasCurrentCapabilityCatalog)
+        return;
+    const resumedCalls = [
+        ...continuation.callers.map((cursor) => cursor.callerCall),
+        call,
+    ];
+    for (const resumed of resumedCalls) {
+        projectWorkerCapabilityScope({
+            entries: capabilities,
+            scope: resumed.workerCapabilityScope,
+            descriptorOf: (entry) => entry,
+        });
+    }
+}
+export function createRoleApprovalContinuation(continuation, executionIds) {
+    if (executionIds.length === 0)
+        throw new Error("request_approval_execution_empty");
+    return Object.freeze({
+        callers: continuation.callers,
+        capability: executionIds.length === 1
+            ? Object.freeze({
+                kind: "capability_execution",
+                executionId: executionIds[0],
+            })
+            : Object.freeze({ kind: "capability_batch_execution", executionIds }),
+    });
+}

package/dist/src/runtime/request/approval-wait/activation-events.d.ts

@@ -0,0 +1,36 @@
+import type WebSocket from "ws";
+import type { SessionActivationExpectation, SessionLifecycleMutationResult, SessionRequestLifecycleSnapshot, SessionRequestLifecycleStore, SessionRequestTerminalCause, SessionTerminalMessage } from "../../../sessions/request-lifecycle/contracts.js";
+import type { EventSink, EventSinkFactory } from "../../ports.js";
+type AcceptedMutation = Extract<SessionLifecycleMutationResult, {
+    accepted: true;
+}>;
+/** Execution events and lifecycle transitions share the canonical session queue. */
+export declare class RequestActivationEvents {
+    private readonly store;
+    private current;
+    private readonly ws;
+    readonly events: EventSink;
+    private tail;
+    private persistenceError;
+    private sealed;
+    constructor(store: SessionRequestLifecycleStore, current: SessionRequestLifecycleSnapshot, factory: EventSinkFactory, ws: WebSocket);
+    snapshot(): SessionRequestLifecycleSnapshot;
+    commit(operation: (expected: SessionActivationExpectation) => Promise<SessionLifecycleMutationResult>): Promise<AcceptedMutation>;
+    /** A failed event write cannot turn a committed wait into an execution failure. */
+    finalizeFailure(input: Readonly<{
+        commandId: string;
+        cause: SessionRequestTerminalCause;
+        message: SessionTerminalMessage;
+        error: string;
+        prepareFailure?: () => Promise<Readonly<{
+            cause: SessionRequestTerminalCause;
+            message: SessionTerminalMessage;
+            error: string;
+        }>>;
+    }>): Promise<SessionRequestLifecycleSnapshot>;
+    private acceptTerminalMutation;
+    private expectation;
+    private enqueue;
+    private publishCommitted;
+}
+export {};

package/dist/src/runtime/request/approval-wait/activation-events.js

@@ -0,0 +1,154 @@
+import { traceDebug } from "../../observability/debug-logger.js";
+/** Execution events and lifecycle transitions share the canonical session queue. */
+export class RequestActivationEvents {
+    store;
+    current;
+    ws;
+    events;
+    tail = Promise.resolve();
+    persistenceError;
+    sealed = false;
+    constructor(store, current, factory, ws) {
+        this.store = store;
+        this.current = current;
+        this.ws = ws;
+        const transport = {
+            send: (data) => this.enqueue(JSON.parse(data)),
+        };
+        const base = factory.create({
+            requestId: current.requestId,
+            ws: transport,
+        });
+        this.events = {
+            publish: (payload) => base.publish(payload),
+            event: (name, extra) => base.event(name, extra),
+            runtimeState: (state) => base.runtimeState(state),
+            token: (token) => base.token(token),
+            legacyToken: (text) => base.legacyToken(text),
+            thinkingDelta: (delta, accumulated) => base.thinkingDelta(delta, accumulated),
+            completed: (output) => base.completed(output),
+            failed: (error, details) => base.failed(error, details),
+            drain: async () => {
+                await base.drain();
+                await this.tail;
+                if (this.persistenceError)
+                    throw this.persistenceError;
+            },
+            dispose: () => {
+                this.sealed = true;
+                base.dispose();
+            },
+        };
+    }
+    snapshot() {
+        return this.current;
+    }
+    async commit(operation) {
+        await this.events.drain();
+        const result = await operation(this.expectation());
+        if (!result.accepted)
+            throw new Error(`request_lifecycle_rejected:${result.reason}`);
+        this.current = result.current;
+        this.sealed = result.current.status !== "streaming";
+        this.publishCommitted(result.events);
+        return result;
+    }
+    /** A failed event write cannot turn a committed wait into an execution failure. */
+    async finalizeFailure(input) {
+        this.sealed = true;
+        await this.tail;
+        const current = await this.store.get(this.current.sessionId, this.current.requestId);
+        if (!current)
+            throw new Error("request_lifecycle_missing_after_failure");
+        if (!sameOwnedActivation(current, this.current))
+            return current;
+        this.current = current;
+        if (current.status === "awaiting_approval") {
+            if (input.cause !== "request_cancelled")
+                return current;
+            if (!current.wait)
+                throw new Error("request_lifecycle_wait_missing");
+            const cancelled = await this.store.cancelWait(current.sessionId, {
+                expected: {
+                    requestId: current.requestId,
+                    generation: current.generation,
+                    revision: current.revision,
+                    waitId: current.wait.waitId,
+                },
+                commandId: input.commandId,
+                message: input.message,
+            });
+            return this.acceptTerminalMutation(cancelled);
+        }
+        if (current.status !== "streaming")
+            return current;
+        const failure = input.prepareFailure ? await input.prepareFailure() : input;
+        return this.acceptTerminalMutation(await this.store.commitTerminal(current.sessionId, {
+            expected: this.expectation(),
+            commandId: input.commandId,
+            status: "failed",
+            cause: failure.cause,
+            message: failure.message,
+            error: failure.error,
+        }));
+    }
+    acceptTerminalMutation(result) {
+        if (!result.accepted)
+            throw new Error(`request_lifecycle_rejected:${result.reason}`);
+        this.current = result.current;
+        this.publishCommitted(result.events);
+        return result.current;
+    }
+    expectation() {
+        const activation = this.current.activation;
+        if (!activation)
+            throw new Error("request_activation_missing");
+        return {
+            requestId: this.current.requestId,
+            generation: this.current.generation,
+            revision: this.current.revision,
+            ...activation,
+        };
+    }
+    enqueue(payload) {
+        if (this.sealed)
+            return;
+        this.tail = this.tail
+            .then(async () => {
+            if (this.persistenceError)
+                return;
+            const result = await this.store.appendActivationEvent(this.current.sessionId, {
+                expected: this.expectation(),
+                payload,
+            });
+            if (!result.accepted)
+                throw new Error(`request_event_rejected:${result.reason}`);
+            this.current = result.current;
+            this.publishCommitted(result.events);
+        })
+            .catch((error) => {
+            this.persistenceError ??= error;
+        });
+    }
+    publishCommitted(events) {
+        for (const event of events) {
+            try {
+                this.ws.send(JSON.stringify(event));
+            }
+            catch (error) {
+                // Delivery can be restored from the session; it cannot undo a commit.
+                traceDebug("runtime.request", "committed_event_delivery_failed", {
+                    requestId: this.current.requestId,
+                    errorType: error instanceof Error ? error.name : typeof error,
+                });
+            }
+        }
+    }
+}
+function sameOwnedActivation(current, owned) {
+    if (current.generation !== owned.generation)
+        return false;
+    if (current.activation?.activationId !== owned.activation?.activationId)
+        return false;
+    return current.activation?.ownerEpoch === owned.activation?.ownerEpoch;
+}

package/dist/src/runtime/request/approval-wait/approval-gate.d.ts

@@ -0,0 +1,9 @@
+import type { CapabilityApprovalGate } from "../../orchestration/worker-capabilities/approval-contracts.js";
+import type { RequestToolResources } from "../../capabilities/request-tool-resources.js";
+import type { ToolApprovalController } from "../../ports.js";
+export declare function createRequestApprovalGate(params: {
+    resources: RequestToolResources;
+    controller?: ToolApprovalController;
+    signal: AbortSignal;
+    onEvent(name: string, payload: Record<string, unknown>): void;
+}): CapabilityApprovalGate;

package/dist/src/runtime/request/approval-wait/approval-gate.js

@@ -0,0 +1,65 @@
+const WAIT_PARKED = "approval_wait_parked";
+export function createRequestApprovalGate(params) {
+    return {
+        async resolve(group) {
+            params.signal.throwIfAborted();
+            if (!params.resources.hasActiveWork())
+                return { kind: "awaiting_approval" };
+            return resolveWhileWorkIsActive(group, params);
+        },
+    };
+}
+async function resolveWhileWorkIsActive(group, params) {
+    const controller = params.controller;
+    if (!controller)
+        throw new Error("tool_approval_unavailable");
+    const waiting = new AbortController();
+    const abort = () => waiting.abort(params.signal.reason);
+    params.signal.addEventListener("abort", abort, { once: true });
+    if (params.signal.aborted)
+        abort();
+    const decisions = [
+        ...(group.initialDecisions ?? []),
+    ];
+    const received = new Set(decisions.map((entry) => entry.approvalId));
+    const entries = group.entries.filter((entry) => entry.approvalRequest && !received.has(entry.approvalRequest.approvalId));
+    const tasks = entries.map(async (entry) => {
+        const request = entry.approvalRequest;
+        params.onEvent("tool.approval.required", {
+            approvalId: request.approvalId,
+            executionId: entry.executionId,
+            tool: request.call.tool,
+            ...(request.meta ? { meta: request.meta } : {}),
+        });
+        const decision = await controller.requestToolApproval(request, {
+            abortSignal: waiting.signal,
+        });
+        if (waiting.signal.aborted)
+            return;
+        decisions.push({
+            approvalId: request.approvalId,
+            actionFingerprint: entry.actionFingerprint,
+            decision,
+        });
+    });
+    const allDecided = Promise.all(tasks).then(() => "decided");
+    const quiescent = params.resources
+        .waitForQuiescence(waiting.signal)
+        .then(() => "quiescent");
+    try {
+        const result = await Promise.race([allDecided, quiescent]);
+        params.signal.throwIfAborted();
+        if (result === "decided")
+            return { kind: "decisions", decisions };
+        if (decisions.length ===
+            group.entries.filter((entry) => entry.approvalRequest).length) {
+            return { kind: "decisions", decisions };
+        }
+        return { kind: "awaiting_approval", decisions };
+    }
+    finally {
+        waiting.abort(new Error(WAIT_PARKED));
+        params.signal.removeEventListener("abort", abort);
+        await Promise.allSettled([...tasks, quiescent]);
+    }
+}

package/dist/src/runtime/request/approval-wait/failure.d.ts

@@ -0,0 +1,8 @@
+import type { SessionRequestTerminalCause, SessionTerminalMessage } from "../../../sessions/request-lifecycle/contracts.js";
+import type { SessionThinkingTraceEntry } from "../../../sessions/types.js";
+export declare function classifyRequestTerminalCause(signal: AbortSignal): SessionRequestTerminalCause;
+export declare function createRequestFailureMessage(params: {
+    cause: SessionRequestTerminalCause;
+    partialAnswer: string;
+    thinkingTrace?: SessionThinkingTraceEntry[];
+}): SessionTerminalMessage;

package/dist/src/runtime/request/approval-wait/failure.js

@@ -0,0 +1,27 @@
+import { isRequestCancelled } from "../cancellation.js";
+import { isRequestInterrupted } from "../interruption.js";
+export function classifyRequestTerminalCause(signal) {
+    if (isRequestCancelled(signal))
+        return "request_cancelled";
+    if (isRequestInterrupted(signal))
+        return "request_interrupted";
+    return "request_failed";
+}
+export function createRequestFailureMessage(params) {
+    const acknowledgement = failureAcknowledgement(params.cause);
+    const content = params.partialAnswer.trim()
+        ? `${params.partialAnswer}\n\n${acknowledgement}`
+        : acknowledgement;
+    return {
+        content,
+        grounding: "conversation",
+        ...(params.thinkingTrace ? { thinkingTrace: params.thinkingTrace } : {}),
+    };
+}
+function failureAcknowledgement(cause) {
+    if (cause === "request_cancelled")
+        return "I stopped the task at your request.";
+    if (cause === "request_interrupted")
+        return "The request was interrupted when the runtime stopped.";
+    return "The request could not be completed.";
+}

package/dist/src/runtime/request/approval-wait/park.d.ts

@@ -0,0 +1,15 @@
+import type { SessionRequestLifecycleSnapshot, SessionRequestLifecycleStore } from "../../../sessions/request-lifecycle/contracts.js";
+import type { RequestToolResources } from "../../capabilities/request-tool-resources.js";
+import type { RequestLifecycle } from "../../orchestration/lifecycle/request-lifecycle.js";
+import type { prepareRequestExecution } from "../prepared-execution.js";
+import type { RequestApprovalContinuation } from "../approval-continuation.js";
+import type { RequestSteeringInbox } from "../request-steering.js";
+export declare function parkRequestApproval(params: {
+    prepared: Awaited<ReturnType<typeof prepareRequestExecution>>;
+    continuation: RequestApprovalContinuation;
+    store: SessionRequestLifecycleStore;
+    resources: RequestToolResources;
+    lifecycle: RequestLifecycle;
+    steering: RequestSteeringInbox;
+    originalPrompt: string;
+}): Promise<SessionRequestLifecycleSnapshot>;