@abot-ai/runtime 1.0.0

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

@@ -0,0 +1,240 @@
+import type WebSocket from "ws";
+import type { AgentMode, ModelReasoningLevel, ModelStep } from "../shared/types.js";
+import type { ContextBuckets, ModelContextMessage } from "../sessions/context-window.js";
+import type { SessionArtifactPathInput, SessionContextEntryKind, SessionDeleteResult, SessionListResult, SessionMessageDeleteResult, SessionMessageGrounding, SessionMessageObservationMeta, SessionMessageRole, SessionMessageSource, SessionMessageTaskType, SessionMessagesClearResult, SessionRecord, SessionRequestReplay, SessionSnapshot, SessionThinkingTraceEntry } from "../sessions/types.js";
+import type { SessionMemoryRepository } from "../sessions/memory/contracts.js";
+import type { ModelGatewayInputTokenCountParams, ModelGatewayInputTokenCountResult, ModelGatewayPolicyConfig, ModelPreference, ModelTokenUsage } from "../model-gateway/types.js";
+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 { RequestLifecycleState } from "./orchestration/lifecycle/request-lifecycle.js";
+import type { RuntimeModelExecutionPolicies } from "./config/model-execution-policy.js";
+export type RuntimePaths = {
+    rootDir: string;
+    runtimeDir: string;
+    agentWorkDir: string;
+    sessionsDir: string;
+    attachmentsDir: string;
+    workspaceDir: string;
+    sharedDir: string;
+    compiledDir: string;
+    traceFile: string;
+};
+export type RuntimeTimeouts = {
+    requestTimeoutMs?: number;
+    requestInactivityTimeoutMs?: number;
+    modelStepTimeoutMs?: number;
+    streamInactivityTimeoutMs?: number;
+};
+export type RuntimeLogRotationConfig = {
+    maxFileSizeMb: number;
+    maxFiles: number;
+    maxAgeDays: number;
+};
+export type RuntimeLoggingConfig = {
+    enabled: boolean;
+    rotation: RuntimeLogRotationConfig;
+};
+export type RuntimeModelConfig = ModelGatewayPolicyConfig;
+export type RuntimeRequestRunnerConfig = {
+    /** Absolute path resolved from requestRunner.configRef in runtime config. */
+    configPath: string;
+};
+export type RuntimePluginConfig = {
+    enabled?: boolean;
+    allow?: string[];
+    deny?: string[];
+};
+export type RuntimeConfig = {
+    runtimeId: string;
+    agentBridgeUrl: string;
+    agentBridgeToken?: string;
+    modelGatewayUrl: string;
+    paths: RuntimePaths;
+    logging?: RuntimeLoggingConfig;
+    timeouts?: RuntimeTimeouts;
+    plugins?: RuntimePluginConfig;
+    models?: RuntimeModelConfig;
+    modelExecutionPolicies?: RuntimeModelExecutionPolicies;
+    requestRunner: RuntimeRequestRunnerConfig;
+    modelPreference?: ModelPreference;
+    featureFlags?: Record<string, boolean | number | string>;
+};
+export type RuntimeHostStartOptions = {
+    runtimeConfig?: RuntimeConfig;
+    runtimeId?: string;
+    agentBridgeUrl?: string;
+    agentBridgeToken?: string;
+    eventSinkFactory?: EventSinkFactory;
+    modelGatewayClient?: ModelGatewayClient;
+    sessionStore?: SessionStore;
+    attachmentStore?: RuntimeAttachmentStore;
+    toolRegistry?: ToolRegistry;
+};
+export type RuntimeHostHandle = {
+    stop: () => Promise<void>;
+};
+export type RuntimeHost = {
+    start: (options?: RuntimeHostStartOptions) => RuntimeHostHandle;
+};
+export type AppendSessionMessageOptions = {
+    lastAgentMode?: AgentMode;
+    grounding?: SessionMessageGrounding;
+    observationMeta?: SessionMessageObservationMeta;
+    observationContent?: string;
+    thinkingTrace?: SessionThinkingTraceEntry[];
+    source?: SessionMessageSource;
+    taskType?: SessionMessageTaskType;
+    requestId?: string;
+    cronJobId?: string;
+    cronTitle?: string;
+    triggerType?: string;
+    attachments?: RuntimeAttachmentReference[];
+};
+export type AppendSessionContextEntryOptions = {
+    kind: SessionContextEntryKind;
+    content: string;
+    observationMeta: SessionMessageObservationMeta;
+    requestId?: string;
+};
+export type SessionStore = SessionMemoryRepository & {
+    getOrCreateSession: (sessionId: string) => Promise<SessionRecord>;
+    getAllSessions: () => Promise<SessionRecord[]>;
+    listSessions: (params?: {
+        limit?: number;
+        cursor?: string | null;
+    }) => Promise<SessionListResult>;
+    getSessionById: (sessionId: string) => Promise<SessionRecord | null>;
+    getSessionSnapshot: (sessionId: string, options?: {
+        afterMessageId?: string | number | null;
+        includeRequests?: boolean;
+    }) => Promise<SessionSnapshot | null>;
+    getRequestReplayById: (requestId: string, afterSeq?: number) => Promise<SessionRequestReplay | null>;
+    updateSessionTitle: (sessionId: string, title: string) => Promise<SessionRecord | null>;
+    updateSessionRuntimeMode?: (sessionId: string, runtimeModeId: string | null) => Promise<SessionRecord | null>;
+    appendMessage: (sessionId: string, role: SessionMessageRole, content: string, options?: AppendSessionMessageOptions) => Promise<SessionRecord>;
+    appendContextEntry?: (sessionId: string, options: AppendSessionContextEntryOptions) => Promise<SessionRecord>;
+    upsertArtifactPaths?: (sessionId: string, inputs: readonly SessionArtifactPathInput[]) => Promise<SessionRecord>;
+    startRequestStream: (sessionId: string, requestId: string) => Promise<SessionRecord>;
+    appendRequestEvent: (sessionId: string, requestId: string, payload: Record<string, unknown>) => Promise<SessionRecord>;
+    deleteSession: (sessionId: string) => Promise<boolean>;
+    deleteSessionWithStats: (sessionId: string) => Promise<SessionDeleteResult>;
+    resetSession: (sessionId: string) => Promise<SessionRecord | null>;
+    clearSessionMessages: (sessionId: string) => Promise<SessionMessagesClearResult | null>;
+    deleteMessage: (sessionId: string, messageId: string) => Promise<SessionRecord | null>;
+    deleteMessageWithStats: (sessionId: string, messageId: string) => Promise<SessionMessageDeleteResult | null>;
+};
+export type ConversationContextProvider = {
+    buildContextBuckets: (session: SessionRecord, options?: {
+        maxConversationMessages?: number;
+        maxToolObservationMessages?: number;
+        includeRecentConversation?: boolean;
+        includeRecentConversationAcrossTaskResults?: boolean;
+    }) => ContextBuckets;
+    buildContextWindow: (session: SessionRecord, maxMessages?: number) => ModelContextMessage[];
+};
+export type ToolExecutionOptions = {
+    abortSignal?: AbortSignal;
+    sharedState?: ToolExecutionContext["sharedState"];
+    modelInvoker?: ToolExecutionContext["modelInvoker"];
+};
+export type ToolPermissionMode = "full_access" | "ask";
+export type ToolApprovalRequest = {
+    requestId: string;
+    approvalId: string;
+    call: ToolCall;
+    meta?: Record<string, unknown>;
+};
+export type ToolApprovalDecision = {
+    approved: boolean;
+    reason?: string;
+};
+export type ToolApprovalController = {
+    requestToolApproval: (request: ToolApprovalRequest, options?: {
+        abortSignal?: AbortSignal;
+    }) => Promise<ToolApprovalDecision>;
+};
+export type ToolRegistry = {
+    listDefinitions: () => ToolDefinition[];
+    /** The sole config-filtered availability snapshot for ordinary invocation. */
+    listNormalInvocations?: () => readonly RegisteredToolNormalInvocation[];
+    getDefinition: (name: string) => ToolDefinition | undefined;
+    getAdapter?: (name: string) => ToolCallAdapter | undefined;
+    hasToolsAvailable: () => boolean;
+    getImplementations: () => Record<string, ToolImplementation>;
+    prepareSharedState?: (sharedState?: ToolExecutionSharedState) => ToolExecutionSharedState;
+    execute: (call: ToolCall, options?: ToolExecutionOptions) => Promise<ToolExecutionResult>;
+};
+export type SkillProvider = {
+    getActionContext: (action: string) => Promise<string>;
+};
+export type WorkspaceProvider = {
+    getSystemSummary: () => Promise<string>;
+};
+export type ModelGatewayInvokeParams = StreamCallbacks & {
+    text?: string;
+    messages?: unknown;
+    agentMode: AgentMode;
+    taskType?: string;
+    modelStep?: ModelStep;
+    modelOverride?: string;
+    reasoningOverride?: ModelReasoningLevel;
+    modelPreference?: ModelPreference;
+    modelPolicy?: ModelGatewayPolicyConfig;
+    abortSignal: AbortSignal;
+    debugRequestId?: string;
+    format?: "json" | Record<string, unknown>;
+};
+export type ModelGatewayRawInvokeParams = {
+    prompt: string;
+    agentMode: AgentMode;
+    taskType?: string;
+    modelStep?: ModelStep;
+    modelOverride?: string;
+    reasoningOverride?: ModelReasoningLevel;
+    modelPreference?: ModelPreference;
+    modelPolicy?: ModelGatewayPolicyConfig;
+    abortSignal: AbortSignal;
+    debugRequestId?: string;
+    format?: "json" | Record<string, unknown>;
+};
+export type ModelGatewayInvokeResult = {
+    text: string;
+    meta: Record<string, unknown>;
+};
+export type ModelGatewayRawInvokeResult = {
+    text: string;
+    meta: {
+        status: number;
+        outputLength: number;
+        thinkingLength: number;
+        providerCompletionReason?: string | null;
+        usage?: ModelTokenUsage;
+    };
+};
+export type ModelGatewayClient = {
+    invoke: (params: ModelGatewayInvokeParams) => Promise<ModelGatewayInvokeResult>;
+    invokeRaw: (params: ModelGatewayRawInvokeParams) => Promise<ModelGatewayRawInvokeResult>;
+    /** Undefined means the selected provider keeps the existing estimator path. */
+    countInputTokens?: (params: ModelGatewayInputTokenCountParams) => Promise<ModelGatewayInputTokenCountResult | undefined>;
+};
+export type EventSink = {
+    publish: (payload: Record<string, unknown>) => void | Promise<void>;
+    event: (name: string, extra?: Record<string, unknown>) => void | Promise<void>;
+    runtimeState: (state: RequestLifecycleState) => void | Promise<void>;
+    token: (token: string) => void | Promise<void>;
+    legacyToken: (text: string) => void | Promise<void>;
+    thinkingDelta: (delta: string, accumulatedText: string) => void | Promise<void>;
+    completed: (output: string) => void | Promise<void>;
+    failed: (error: string, details?: Record<string, unknown>) => void | Promise<void>;
+    drain: () => Promise<void>;
+    dispose: () => void;
+};
+export type EventSinkFactory = {
+    create: (options: {
+        requestId: string;
+        ws: WebSocket;
+        persist?: (payload: Record<string, unknown>) => Promise<unknown>;
+    }) => EventSink;
+};

package/dist/src/runtime/ports.js

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

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

@@ -0,0 +1,121 @@
+import type { ModelGatewayAttachment, ModelGatewayPolicyConfig, ModelPreference } from "../../model-gateway/types.js";
+import type { AgentMode } from "../../shared/types.js";
+import type { RuntimeAttachmentStore } from "../attachments/store.js";
+import type { RuntimeThinkingTrace } from "../model/thinking-trace.js";
+import type { EventSinkFactory, ModelGatewayClient, RuntimeConfig, ToolApprovalController, ToolPermissionMode, ToolRegistry } from "../ports.js";
+import type { RequestRunnerConfig } from "../config/runner/contracts.js";
+import type { RequestExecutionPolicySelection } from "../config/model-execution-policy.js";
+import type { RequestHistoryMessage } from "../context/request-context-contracts.js";
+import type { RequestContextCompactionStore } from "../context/semantic-compaction/index.js";
+import type { RequestTemporalContext } from "../context/request-temporal-context.js";
+import type { RequestSessionStore } from "./session-store.js";
+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";
+export type RunRequestMessage = {
+    type: string;
+    requestId: string;
+    sessionId?: unknown;
+    input?: string;
+    text?: string;
+    agentMode?: unknown;
+    modelPreference?: unknown;
+    toolPermissionMode?: unknown;
+    attachments?: unknown;
+};
+export type RequestHandlerOptions = {
+    runtimeConfig?: RuntimeConfig;
+    eventSinkFactory?: EventSinkFactory;
+    modelGatewayClient?: ModelGatewayClient;
+    sessionStore?: RequestSessionStore;
+    attachmentStore?: RuntimeAttachmentStore;
+    toolRegistry?: ToolRegistry;
+    toolApprovalController?: ToolApprovalController;
+    requestSteering?: RequestSteeringInbox;
+    sessionMemoryCompactor?: SessionMemoryCompactor;
+};
+/** Exact provider-free seed used to construct one request execution scope. */
+export type RequestExecutionSeed = Readonly<{
+    requestId: string;
+    sessionId: string;
+    prompt: string;
+    temporalContext?: RequestTemporalContext;
+    historyMessages: readonly RequestHistoryMessage[];
+    sessionArtifactPaths?: readonly string[];
+    shouldGenerateSessionTitle: boolean;
+    runnerConfig: RequestRunnerConfig;
+    /** Resolved once by the production request handler before runner entry. */
+    executionPolicySelection?: RequestExecutionPolicySelection;
+    attachments?: ModelGatewayAttachment[];
+    agentMode: AgentMode;
+    modelPreference?: ModelPreference;
+    modelPolicy?: ModelGatewayPolicyConfig;
+    modelGatewayClient: Pick<ModelGatewayClient, "invoke" | "invokeRaw" | "countInputTokens">;
+    contextCompactionStore?: RequestContextCompactionStore;
+    sessionMemory?: RequestSessionMemory;
+    requestSteering?: RequestSteeringInbox;
+    toolPermissionMode: ToolPermissionMode;
+    toolApprovalController?: ToolApprovalController;
+    abortSignal: AbortSignal;
+    onAcknowledgement: (acknowledgement: string) => void;
+    onSessionTitle: (title: string) => Promise<void>;
+    onThinkingDelta: (delta: string) => void;
+    onThinkingTrace: (entry: RuntimeThinkingTrace) => void;
+    onAnswerToken: (token: string) => void;
+    onEvent: (name: string, extra?: Record<string, unknown>) => void;
+}>;
+/** Stable request/session identity shared by every request-scoped facet. */
+export type RequestIdentity = Readonly<{
+    requestId: RequestExecutionSeed["requestId"];
+    sessionId: RequestExecutionSeed["sessionId"];
+}>;
+/** Accepted client input and request controls; no derived runtime services. */
+export type AcceptedRequestInput = Readonly<{
+    prompt: RequestExecutionSeed["prompt"];
+    temporalContext?: RequestExecutionSeed["temporalContext"];
+    attachments?: RequestExecutionSeed["attachments"];
+    agentMode: RequestExecutionSeed["agentMode"];
+}>;
+/** Immutable session snapshot captured before request execution begins. */
+export type RequestSessionSnapshot = Readonly<{
+    historyMessages: RequestExecutionSeed["historyMessages"];
+    sessionArtifactPaths?: RequestExecutionSeed["sessionArtifactPaths"];
+    shouldGenerateSessionTitle: RequestExecutionSeed["shouldGenerateSessionTitle"];
+    contextCompactionStore?: RequestExecutionSeed["contextCompactionStore"];
+    sessionMemory?: RequestExecutionSeed["sessionMemory"];
+}>;
+/** Model configuration and gateway selected once for this request. */
+export type RequestModelRuntime = Readonly<{
+    runnerConfig: RequestExecutionSeed["runnerConfig"];
+    modelPreference?: RequestExecutionSeed["modelPreference"];
+    modelPolicy?: RequestExecutionSeed["modelPolicy"];
+    modelGatewayClient: RequestExecutionSeed["modelGatewayClient"];
+}>;
+/** Request-local cancellation, steering, capability controls, and events. */
+export type RequestLifecycleRuntime = Readonly<{
+    requestSteering?: RequestExecutionSeed["requestSteering"];
+    toolPermissionMode: RequestExecutionSeed["toolPermissionMode"];
+    toolApprovalController?: RequestExecutionSeed["toolApprovalController"];
+    abortSignal: RequestExecutionSeed["abortSignal"];
+    onEvent: RequestExecutionSeed["onEvent"];
+}>;
+/** Client-facing request presentation callbacks. */
+export type RequestPresentation = Readonly<{
+    onAcknowledgement: RequestExecutionSeed["onAcknowledgement"];
+    onSessionTitle: RequestExecutionSeed["onSessionTitle"];
+    onThinkingDelta: RequestExecutionSeed["onThinkingDelta"];
+    onThinkingTrace: RequestExecutionSeed["onThinkingTrace"];
+    onAnswerToken: RequestExecutionSeed["onAnswerToken"];
+}>;
+/** The exact request-owned surface required by model invocation. */
+export type RequestModelInvocationView = Readonly<Pick<RequestExecutionSeed, "requestId" | "runnerConfig" | "agentMode" | "modelPreference" | "modelPolicy" | "modelGatewayClient" | "requestSteering" | "abortSignal" | "onThinkingDelta" | "onThinkingTrace">>;
+/**
+ * Nominal marker for a request that already owns its single model-step port.
+ * It is non-enumerable on canonical request views, so it cannot enter model or
+ * provider payloads through spread/JSON projection.
+ */
+export declare const BOUND_REQUEST_MODEL_INVOCATION: unique symbol;
+export type BoundRequestModelInvocationContext = RequestModelInvocationView & Readonly<{
+    [BOUND_REQUEST_MODEL_INVOCATION]: true;
+    modelSteps: RequestModelStepPort;
+}>;

package/dist/src/runtime/request/contracts.js

@@ -0,0 +1,6 @@
+/**
+ * Nominal marker for a request that already owns its single model-step port.
+ * It is non-enumerable on canonical request views, so it cannot enter model or
+ * provider payloads through spread/JSON projection.
+ */
+export const BOUND_REQUEST_MODEL_INVOCATION = Symbol("bound_request_model_invocation");

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

@@ -0,0 +1,23 @@
+import type { EventSinkFactory, ModelGatewayClient } from "../ports.js";
+import type { RequestHandlerOptions } from "./contracts.js";
+export declare function resolveRequestDependencies(options: RequestHandlerOptions): {
+    eventSinkFactory: EventSinkFactory;
+    modelGatewayClient: ModelGatewayClient;
+    sessionStore: import("./session-store.js").RequestSessionStore;
+    attachmentStore: import("../index.js").RuntimeAttachmentStore | undefined;
+    sessionMemoryCompactor: Readonly<{
+        compact(params: {
+            request: import("./contracts.js").BoundRequestModelInvocationContext;
+            previousSummary?: string;
+            turns: readonly import("../../sessions/memory/source.js").SessionMemorySettledTurn[];
+        }): Promise<string>;
+    }>;
+    toolApprovalController: import("../ports.js").ToolApprovalController | undefined;
+    loadDecisionEnvironment: () => {
+        runnerConfig: import("../config/runner/contracts.js").RequestRunnerConfig;
+        modelPolicy: import("../../model-gateway/types.js").ModelGatewayPolicyConfig;
+        modelExecutionPolicies: Readonly<Record<string, Readonly<{
+            policy: import("../config/model-execution-policy.js").RequestExecutionPolicyId;
+        }>>> | undefined;
+    };
+};

package/dist/src/runtime/request/dependencies.js

@@ -0,0 +1,40 @@
+import { invokeModelGateway, invokeRawModelGateway, } from "../../model-gateway/client.js";
+import { defaultRuntimeSessionStore } from "../adapters/default-session-adapters.js";
+import { createRuntimeEventBus } from "../events/runtime-emitter.js";
+import { loadRequestRunnerConfig } from "../config/runner/loader.js";
+import { createRequestModelPolicy } from "../config/runner/model-policy.js";
+import { createModelSessionMemoryCompactor } from "../context/session-memory/index.js";
+const defaultEventSinkFactory = {
+    create: createRuntimeEventBus,
+};
+const defaultModelGatewayClient = {
+    invoke: invokeModelGateway,
+    invokeRaw: invokeRawModelGateway,
+};
+export function resolveRequestDependencies(options) {
+    return {
+        eventSinkFactory: options.eventSinkFactory ?? defaultEventSinkFactory,
+        modelGatewayClient: options.modelGatewayClient ?? defaultModelGatewayClient,
+        sessionStore: options.sessionStore ?? defaultRuntimeSessionStore,
+        attachmentStore: options.attachmentStore,
+        sessionMemoryCompactor: options.sessionMemoryCompactor ?? createModelSessionMemoryCompactor(),
+        toolApprovalController: options.toolApprovalController,
+        loadDecisionEnvironment: () => {
+            const configPath = options.runtimeConfig?.requestRunner?.configPath;
+            if (!configPath) {
+                throw new Error("runtime request runner is not configured: runtime config must declare requestRunner.configRef");
+            }
+            const runnerConfig = loadRequestRunnerConfig({
+                configPath,
+            });
+            return {
+                runnerConfig,
+                modelPolicy: createRequestModelPolicy({
+                    platformPolicy: options.runtimeConfig?.models,
+                    runnerConfig,
+                }),
+                modelExecutionPolicies: options.runtimeConfig?.modelExecutionPolicies,
+            };
+        },
+    };
+}

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

@@ -0,0 +1,2 @@
+import type { RequestRootContractAdapter } from "./root-execution-kernel.js";
+export declare const EXECUTION_AGENT_ROOT_CONTRACT: RequestRootContractAdapter;

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

@@ -0,0 +1,117 @@
+import { projectSupervisorCallIdentity, projectSupervisorResumeContext, } from "../steps/supervisor-decision/index.js";
+import { EXECUTION_AGENT_DECISION_MODEL_STEP, EXECUTION_AGENT_RESPONSE_MODEL_STEP, runExecutionAgentDecision, runExecutionAgentResponse, } from "../steps/execution-agent/index.js";
+import { encodeExecutionAgentAuditObjective } from "../steps/auditor-decision/index.js";
+import { resolveRequestSteeringInbox } from "./request-steering.js";
+export const EXECUTION_AGENT_ROOT_CONTRACT = Object.freeze({
+    contractId: "execution_agent",
+    decisionModelStep: EXECUTION_AGENT_DECISION_MODEL_STEP,
+    responseModelStep: EXECUTION_AGENT_RESPONSE_MODEL_STEP,
+    deferRespondPresentation: true,
+    projectCallIdentity: projectSupervisorCallIdentity,
+    projectResume: projectSupervisorResumeContext,
+    async decide(request, options) {
+        const requestSteering = resolveRequestSteeringInbox(request.requestSteering);
+        const outcome = await runExecutionAgentDecision(request, {
+            head: options.head,
+            call: options.callFrame,
+            steeringSnapshot: requestSteering.snapshot(),
+            includeAcknowledgement: options.includeAcknowledgement,
+            includeTitle: options.includeTitle,
+            allowPlanner: options.allowedRoleIds.includes("planner"),
+            allowAuditor: options.allowedRoleIds.includes("reviewer"),
+        });
+        return Object.freeze({
+            decision: projectKernelDecision(outcome.decision, outcome.steeringVersion),
+            steeringVersion: outcome.steeringVersion,
+        });
+    },
+    async authorResponse(request, options) {
+        const requestSteering = resolveRequestSteeringInbox(request.requestSteering);
+        return runExecutionAgentResponse(request, {
+            head: options.head,
+            call: options.callFrame,
+            steeringSnapshot: requestSteering.snapshot(),
+        });
+    },
+});
+function projectKernelDecision(decision, steeringVersion) {
+    const presentation = {
+        ...(decision.acknowledgement !== undefined
+            ? { acknowledgement: decision.acknowledgement }
+            : {}),
+        ...(decision.title !== undefined ? { title: decision.title } : {}),
+    };
+    switch (decision.action) {
+        case "reconsider_capability_selection":
+            return Object.freeze({
+                action: "reconsider_capability_selection",
+                selection: decision.selection,
+            });
+        case "open_capability_scope":
+            return Object.freeze({
+                action: "update_capability_scope",
+                mode: "open",
+                catalogGroupIds: decision.catalogGroupIds,
+                ...presentation,
+            });
+        case "extend_capability_scope":
+            return Object.freeze({
+                action: "update_capability_scope",
+                mode: "extend",
+                catalogGroupIds: decision.catalogGroupIds,
+                ...presentation,
+            });
+        case "invoke_capability":
+            if (!decision.controls) {
+                throw new Error("execution_agent_capability_controls_missing");
+            }
+            return Object.freeze({
+                action: "invoke_capability",
+                capabilityId: decision.capabilityId,
+                intent: decision.intent,
+                controls: decision.controls,
+                ...(decision.workingDirectory !== undefined
+                    ? { workingDirectory: decision.workingDirectory }
+                    : {}),
+                ...presentation,
+            });
+        case "invoke_capabilities":
+            if (decision.invocations.some((invocation) => !invocation.controls)) {
+                throw new Error("execution_agent_capability_controls_missing");
+            }
+            return Object.freeze({
+                action: "invoke_capabilities",
+                invocations: Object.freeze(decision.invocations.map((invocation) => Object.freeze({
+                    capabilityId: invocation.capabilityId,
+                    intent: invocation.intent,
+                    controls: invocation.controls,
+                }))),
+                ...(decision.workingDirectory !== undefined
+                    ? { workingDirectory: decision.workingDirectory }
+                    : {}),
+                ...presentation,
+            });
+        case "respond":
+            return Object.freeze({ action: "respond", ...presentation });
+        case "blocked":
+            return Object.freeze({
+                action: "blocked",
+                response: decision.response,
+                ...presentation,
+            });
+        case "invoke_planner":
+            return Object.freeze({
+                action: "invoke_role",
+                roleId: "planner",
+                objective: decision.objective,
+                ...presentation,
+            });
+        case "invoke_auditor":
+            return Object.freeze({
+                action: "invoke_role",
+                roleId: "reviewer",
+                objective: encodeExecutionAgentAuditObjective(decision.criterionIds, steeringVersion),
+                ...presentation,
+            });
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { AcceptedRequestInput, RequestSessionSnapshot, RequestExecutionSeed, RequestIdentity, RequestLifecycleRuntime, RequestModelInvocationView, RequestModelRuntime, RequestPresentation } from "./contracts.js";
+export type RequestSeedFacets = Readonly<{
+    identity: RequestIdentity;
+    input: AcceptedRequestInput;
+    session: RequestSessionSnapshot;
+    model: RequestModelRuntime;
+    lifecycle: RequestLifecycleRuntime;
+    presentation: RequestPresentation;
+}>;
+export declare function createRequestSeedFacets(seed: RequestExecutionSeed): RequestSeedFacets;
+export declare function createModelInvocationView(facets: RequestSeedFacets): RequestModelInvocationView;

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

@@ -0,0 +1,90 @@
+import { createFrozenSurface, enumerableGetter } from "./immutable-view.js";
+export function createRequestSeedFacets(seed) {
+    const identity = Object.freeze({
+        requestId: seed.requestId,
+        sessionId: seed.sessionId,
+    });
+    const input = Object.freeze({
+        prompt: seed.prompt,
+        ...(seed.temporalContext !== undefined
+            ? { temporalContext: seed.temporalContext }
+            : {}),
+        ...(seed.attachments !== undefined
+            ? { attachments: seed.attachments }
+            : {}),
+        agentMode: seed.agentMode,
+    });
+    const session = Object.freeze({
+        historyMessages: seed.historyMessages,
+        ...(seed.sessionArtifactPaths !== undefined
+            ? { sessionArtifactPaths: seed.sessionArtifactPaths }
+            : {}),
+        shouldGenerateSessionTitle: seed.shouldGenerateSessionTitle,
+        ...(seed.contextCompactionStore !== undefined
+            ? { contextCompactionStore: seed.contextCompactionStore }
+            : {}),
+        ...(seed.sessionMemory !== undefined
+            ? { sessionMemory: seed.sessionMemory }
+            : {}),
+    });
+    const model = Object.freeze({
+        runnerConfig: seed.runnerConfig,
+        ...(seed.modelPreference !== undefined
+            ? { modelPreference: seed.modelPreference }
+            : {}),
+        ...(seed.modelPolicy !== undefined
+            ? { modelPolicy: seed.modelPolicy }
+            : {}),
+        modelGatewayClient: seed.modelGatewayClient,
+    });
+    const lifecycle = Object.freeze({
+        ...(seed.requestSteering !== undefined
+            ? { requestSteering: seed.requestSteering }
+            : {}),
+        toolPermissionMode: seed.toolPermissionMode,
+        ...(seed.toolApprovalController !== undefined
+            ? { toolApprovalController: seed.toolApprovalController }
+            : {}),
+        abortSignal: seed.abortSignal,
+        onEvent: seed.onEvent,
+    });
+    const presentation = Object.freeze({
+        onAcknowledgement: seed.onAcknowledgement,
+        onSessionTitle: seed.onSessionTitle,
+        onThinkingDelta: seed.onThinkingDelta,
+        onThinkingTrace: seed.onThinkingTrace,
+        onAnswerToken: seed.onAnswerToken,
+    });
+    return Object.freeze({
+        identity,
+        input,
+        session,
+        model,
+        lifecycle,
+        presentation,
+    });
+}
+export function createModelInvocationView(facets) {
+    return createFrozenSurface({
+        requestId: enumerableGetter(() => facets.identity.requestId),
+        runnerConfig: enumerableGetter(() => facets.model.runnerConfig),
+        agentMode: enumerableGetter(() => facets.input.agentMode),
+        ...(facets.model.modelPreference !== undefined
+            ? {
+                modelPreference: enumerableGetter(() => facets.model.modelPreference),
+            }
+            : {}),
+        ...(facets.model.modelPolicy !== undefined
+            ? { modelPolicy: enumerableGetter(() => facets.model.modelPolicy) }
+            : {}),
+        modelGatewayClient: enumerableGetter(() => facets.model.modelGatewayClient),
+        ...(facets.lifecycle.requestSteering !== undefined
+            ? {
+                requestSteering: enumerableGetter(() => facets.lifecycle.requestSteering),
+            }
+            : {}),
+        abortSignal: enumerableGetter(() => facets.lifecycle.abortSignal),
+        onThinkingDelta: enumerableGetter(() => facets.presentation.onThinkingDelta),
+        onThinkingTrace: enumerableGetter(() => facets.presentation.onThinkingTrace),
+    });
+}