@abot-ai/runtime 1.0.0

package/dist/src/runtime/steps/worker-decision/input/prompt-context.js

@@ -0,0 +1,189 @@
+import { resolveConfiguredStepInstructionMetadata } from "../../../config/runner/step-instructions.js";
+import { assessRequestMessagesBudget, projectRequestContext, } from "../../../context/request-context.js";
+import { buildSessionArtifactPathsMessage } from "../../../context/session-artifact-paths.js";
+import { resolveModelContextBudget } from "../../../model/model-context-budget.js";
+import { buildWorkerCapabilityExecutionInstructions, buildWorkerDecisionInstructions, } from "../prompt.js";
+import { WORKER_DECISION_MODEL_STEP } from "../contracts.js";
+import { WORKER_SESSION_ARTIFACT_PATH_PROJECTION_MAX } from "../runtime-path-refinement.js";
+export function prepareWorkerPromptContext(session, references) {
+    const { request, options, capabilitySelection } = session;
+    const { dependencyResults, resume } = session.canonicalState;
+    const { selectedCapabilityExecution, selectedCapabilityBatchExecution, executionPending: capabilityExecutionPending, } = capabilitySelection;
+    const { capabilitiesAvailable, capabilitySelectionRejection, capabilityCatalogProjection, } = session.contract;
+    const { requestToolResultsMessage } = references;
+    const budget = resolveModelContextBudget({
+        runnerConfig: request.runnerConfig,
+        agentMode: request.agentMode,
+        modelStep: WORKER_DECISION_MODEL_STEP,
+        ...(request.modelPreference
+            ? { modelPreference: request.modelPreference }
+            : {}),
+        ...(request.modelPolicy ? { modelPolicy: request.modelPolicy } : {}),
+    });
+    const baseInstructions = capabilityExecutionPending
+        ? buildWorkerCapabilityExecutionInstructions({
+            workingDirectoryAvailable: options.call.workingDirectory !== undefined,
+            selectedCapabilityBatchExecution: selectedCapabilityBatchExecution !== undefined,
+            hasDependencyResults: dependencyResults.length > 0,
+            hasRequestToolResults: requestToolResultsMessage !== undefined,
+        })
+        : buildWorkerDecisionInstructions({
+            capabilitiesAvailable,
+            workingDirectoryAvailable: options.call.workingDirectory !== undefined,
+            hasCapabilityResult: resume !== undefined,
+            hasDependencyResults: dependencyResults.length > 0,
+            hasRequestToolResults: options.requestToolResults.results.length > 0,
+            hasCapabilitySelectionRejection: capabilitySelectionRejection !== undefined,
+            capabilityCatalogProjection,
+        });
+    const builtInInstructions = [
+        baseInstructions,
+        ...(capabilityExecutionPending
+            ? projectCapabilityExecutionGuidance({
+                selectedCapabilityExecution,
+                selectedCapabilityBatchExecution,
+            })
+            : []),
+    ].join("\n\n");
+    const configuredInstructionMetadata = resolveConfiguredStepInstructionMetadata({
+        runnerConfig: request.runnerConfig,
+        modelStep: WORKER_DECISION_MODEL_STEP,
+    });
+    const prompt = buildWorkerAssignmentPrompt(session);
+    return Object.freeze({
+        budget,
+        baseInstructions,
+        instructions: builtInInstructions,
+        configuredInstructionMetadata,
+        prompt,
+    });
+}
+export function projectWorkerDecisionContext(session, references, promptContext) {
+    const { request, options, diagnostic, eligibleSessionArtifactPaths, sessionArtifactPathAvailableCount, } = session;
+    const { capabilities, executionPending: capabilityExecutionPending } = session.capabilitySelection;
+    const { format } = session.contract;
+    const { requestToolResultsMessage, baseReferenceMessages, continuationMessages, } = references;
+    const { budget, instructions, prompt } = promptContext;
+    const sessionArtifactPathProjection = buildSessionArtifactPathsMessage({
+        targets: eligibleSessionArtifactPaths,
+        availableTargetCount: sessionArtifactPathAvailableCount,
+        applicable: phaseAuthorsRuntimePathControl(capabilities, capabilityExecutionPending),
+        maxTargets: WORKER_SESSION_ARTIFACT_PATH_PROJECTION_MAX,
+        fits: (message) => assessRequestMessagesBudget({
+            messages: [
+                { role: "system", content: instructions },
+                message,
+                ...baseReferenceMessages,
+                { role: "user", content: prompt },
+                ...continuationMessages,
+            ],
+            format,
+            budget,
+        }).fits,
+    });
+    const referenceMessages = Object.freeze([
+        ...(sessionArtifactPathProjection
+            ? [sessionArtifactPathProjection.message]
+            : []),
+        ...baseReferenceMessages,
+    ]);
+    const context = projectRequestContext({
+        instructions,
+        format,
+        historyMessages: [],
+        prompt,
+        referenceMessages,
+        ...(continuationMessages.length > 0 ? { continuationMessages } : {}),
+        budget,
+        diagnostic,
+        ...(request.onEvent ? { onEvent: request.onEvent } : {}),
+        deferCompactionFailure: true,
+    });
+    return Object.freeze({
+        sessionArtifactPathProjection,
+        referenceMessages,
+        context,
+    });
+}
+function buildWorkerAssignmentPrompt(session) {
+    const { callIdentity, objective, options } = session;
+    const { dependencyResults } = session.canonicalState;
+    const { pendingCapabilitySelection, pendingCapabilityBatchSelection, executionPending: capabilityExecutionPending, } = session.capabilitySelection;
+    const { availableCapabilityAffordances, capabilitiesAvailable, capabilityPromptPayload, capabilitySelectionRejection, } = session.contract;
+    const identity = {
+        callId: callIdentity.callId,
+        parentCallId: callIdentity.parentCallId,
+        depth: callIdentity.depth,
+        invocationAttempt: callIdentity.invocationAttempt,
+        objective,
+        ...(options.call.workingDirectory !== undefined
+            ? { workingDirectory: options.call.workingDirectory }
+            : {}),
+        ...(dependencyResults.length > 0 ? { dependencyResults } : {}),
+    };
+    if (capabilityExecutionPending) {
+        return JSON.stringify({
+            kind: "runtime_worker_capability_execution_assignment",
+            ...identity,
+            selectedCapabilityAffordances: availableCapabilityAffordances,
+            ...(pendingCapabilitySelection
+                ? {
+                    pendingCapabilitySelection: projectPendingCapabilityExecutionAssignment(pendingCapabilitySelection),
+                }
+                : {}),
+            ...(pendingCapabilityBatchSelection
+                ? {
+                    pendingCapabilityBatchSelection: pendingCapabilityBatchSelection.map(projectPendingCapabilityExecutionAssignment),
+                }
+                : {}),
+        });
+    }
+    return JSON.stringify({
+        kind: "runtime_worker_assignment",
+        ...identity,
+        capabilitiesAvailable,
+        ...(capabilitiesAvailable ? capabilityPromptPayload : {}),
+        ...(capabilitySelectionRejection ? { capabilitySelectionRejection } : {}),
+        availableChildRoleIds: [],
+    });
+}
+function projectPendingCapabilityExecutionAssignment(pending) {
+    return Object.freeze({
+        capabilityId: pending.capabilityId,
+        ...(pending.selectionControls
+            ? { selectionControls: pending.selectionControls }
+            : {}),
+    });
+}
+function phaseAuthorsRuntimePathControl(capabilities, capabilityExecutionPending) {
+    return capabilities.some((capability) => {
+        const selectionControlIds = new Set(capability.selectionControlIds ?? []);
+        return (capability.runtimePathControlIds ?? []).some((controlId) => capabilityExecutionPending
+            ? !selectionControlIds.has(controlId)
+            : selectionControlIds.has(controlId));
+    });
+}
+function projectCapabilityExecutionGuidance(options) {
+    if (options.selectedCapabilityExecution) {
+        return Object.freeze([
+            "### SELECTED CAPABILITY EXECUTION GUIDANCE",
+            options.selectedCapabilityExecution.guidance.length > 0
+                ? options.selectedCapabilityExecution.guidance
+                : "No additional execution guidance is supplied for this capability.",
+            "### END SELECTED CAPABILITY EXECUTION GUIDANCE",
+        ]);
+    }
+    if (options.selectedCapabilityBatchExecution) {
+        return Object.freeze([
+            "### SELECTED CAPABILITY BATCH EXECUTION GUIDANCE",
+            ...options.selectedCapabilityBatchExecution.invocations.flatMap((invocation, index) => [
+                `#### Invocation ${index + 1}: ${invocation.capabilityId}`,
+                invocation.guidance.length > 0
+                    ? invocation.guidance
+                    : "No additional execution guidance is supplied for this invocation.",
+            ]),
+            "### END SELECTED CAPABILITY BATCH EXECUTION GUIDANCE",
+        ]);
+    }
+    return Object.freeze([]);
+}

package/dist/src/runtime/steps/worker-decision/input/reference-context.d.ts

@@ -0,0 +1,2 @@
+import type { PreparedWorkerDecisionSession, PreparedWorkerReferenceContext } from "./types.js";
+export declare function prepareWorkerReferenceContext(session: PreparedWorkerDecisionSession): PreparedWorkerReferenceContext;

package/dist/src/runtime/steps/worker-decision/input/reference-context.js

@@ -0,0 +1,50 @@
+import { buildRequestTemporalContextMessage } from "../../../context/request-temporal-context.js";
+import { buildRequestSourceMessage, projectRequestSource, } from "../../../context/request-source.js";
+import { buildRequestToolResultsMessage } from "../../../context/request-tool-results.js";
+import { buildRoleCallAssignmentScopeMessage } from "../../../orchestration/role-calls/index.js";
+import { WORKER_DECISION_MODEL_STEP, } from "../contracts.js";
+export function prepareWorkerReferenceContext(session) {
+    const { request, options, callIdentity, objective, canonicalState } = session;
+    const { assignmentScope, dependencyResults, resume } = canonicalState;
+    const requestSource = projectRequestSource({
+        requestId: request.requestId,
+        prompt: request.prompt,
+        modelStep: WORKER_DECISION_MODEL_STEP,
+        callId: callIdentity.callId,
+        historyMessages: request.historyMessages,
+    });
+    const requestToolResultsMessage = options.requestToolResults.results.length > 0
+        ? (options.requestToolResultsContextMessage ??
+            buildRequestToolResultsMessage(options.requestToolResults))
+        : undefined;
+    const resultAuthorSource = Object.freeze({
+        ...callIdentity,
+        objective,
+        dependencyResults,
+        requestToolResults: options.requestToolResults,
+        ...(requestToolResultsMessage
+            ? { requestToolResultsContextMessage: requestToolResultsMessage }
+            : {}),
+    });
+    const baseReferenceMessages = Object.freeze([
+        ...(request.temporalContext
+            ? [buildRequestTemporalContextMessage(request.temporalContext)]
+            : []),
+        buildRequestSourceMessage(requestSource),
+        ...(assignmentScope
+            ? [buildRoleCallAssignmentScopeMessage(assignmentScope)]
+            : []),
+        ...(!resume && requestToolResultsMessage
+            ? [requestToolResultsMessage]
+            : []),
+    ]);
+    const continuationMessages = Object.freeze([
+        ...(resume && requestToolResultsMessage ? [requestToolResultsMessage] : []),
+    ]);
+    return Object.freeze({
+        requestToolResultsMessage,
+        resultAuthorSource,
+        baseReferenceMessages,
+        continuationMessages,
+    });
+}

package/dist/src/runtime/steps/worker-decision/input/session.d.ts

@@ -0,0 +1,3 @@
+import type { PreparedWorkerDecisionAssembly, PreparedWorkerDecisionSession, WorkerDecisionInputOptions, WorkerDecisionInputRequest } from "./types.js";
+export declare function prepareWorkerDecisionSession(request: WorkerDecisionInputRequest, options: WorkerDecisionInputOptions): PreparedWorkerDecisionSession;
+export declare function prepareWorkerDecisionAssembly(session: PreparedWorkerDecisionSession): PreparedWorkerDecisionAssembly;

package/dist/src/runtime/steps/worker-decision/input/session.js

@@ -0,0 +1,55 @@
+import { projectWorkerDecisionCallIdentity } from "../contracts.js";
+import { projectEligibleWorkerSessionArtifactPaths } from "../runtime-path-refinement.js";
+import { prepareWorkerCapabilitySelection } from "./capability-selection.js";
+import { prepareWorkerCanonicalState, projectCapabilities, validateCanonicalSources, } from "./canonical-state.js";
+import { prepareWorkerDecisionContract } from "./contract.js";
+import { resolveWorkerDecisionDiagnostic } from "./diagnostic-projection.js";
+import { prepareWorkerPromptContext, projectWorkerDecisionContext, } from "./prompt-context.js";
+import { prepareWorkerReferenceContext } from "./reference-context.js";
+export function prepareWorkerDecisionSession(request, options) {
+    const callIdentity = projectWorkerDecisionCallIdentity(options.call);
+    const diagnostic = resolveWorkerDecisionDiagnostic(request.requestId, options, callIdentity);
+    const objective = options.call.objective;
+    validateCanonicalSources({
+        requestId: request.requestId,
+        call: options.call,
+        capabilitySource: options.capabilitySource,
+        resumeSource: options.capabilityResume,
+    });
+    const eligibleSessionArtifactPaths = projectEligibleWorkerSessionArtifactPaths(request.sessionArtifactPaths, options.requestToolResults);
+    const sessionArtifactPathAvailableCount = request.sessionArtifactPaths?.length ?? 0;
+    const projectedCapabilities = projectCapabilities({
+        requestId: request.requestId,
+        call: options.call,
+        binding: options.capabilitySource?.binding,
+        authorityLedger: options.capabilitySource?.ledger,
+        deferRuntimePathControls: eligibleSessionArtifactPaths.length > 0,
+    });
+    const capabilitySelection = prepareWorkerCapabilitySelection(options, projectedCapabilities);
+    const canonicalState = prepareWorkerCanonicalState(request, options, callIdentity);
+    const contract = prepareWorkerDecisionContract({
+        options,
+        projectedCapabilities,
+        eligibleSessionArtifactPaths,
+        canonicalSource: canonicalState.canonicalSource,
+        capabilitySelection,
+    });
+    return Object.freeze({
+        request,
+        options,
+        callIdentity,
+        diagnostic,
+        objective,
+        eligibleSessionArtifactPaths,
+        sessionArtifactPathAvailableCount,
+        capabilitySelection,
+        canonicalState,
+        contract,
+    });
+}
+export function prepareWorkerDecisionAssembly(session) {
+    const references = prepareWorkerReferenceContext(session);
+    const prompt = prepareWorkerPromptContext(session, references);
+    const projection = projectWorkerDecisionContext(session, references, prompt);
+    return Object.freeze({ references, prompt, projection });
+}

package/dist/src/runtime/steps/worker-decision/input/types.d.ts

@@ -0,0 +1,122 @@
+import type { ChatMessage, ModelGatewayJsonSchemaFormat } from "../../../../model-gateway/types.js";
+import type { RequestExecutionSeed } from "../../../request/contracts.js";
+import type { RequestContextProjection } from "../../../context/request-context-contracts.js";
+import type { RequestToolResultsView } from "../../../context/request-tool-results.js";
+import { buildSessionArtifactPathsMessage } from "../../../context/session-artifact-paths.js";
+import type { ConfiguredStepInstructionMetadata } from "../../../config/runner/step-instructions.js";
+import { resolveModelContextBudget } from "../../../model/model-context-budget.js";
+import { projectRoleCallAssignmentScope, type RoleCallDependencyResult, type RoleCallFrame, type RoleCallLedger, type RoleCallLedgerHead } from "../../../orchestration/role-calls/index.js";
+import { type WorkerCapabilityBinding, type WorkerCapabilityControls, type WorkerCapabilityDescriptor } from "../../../orchestration/worker-capabilities/index.js";
+import type { WorkerCapabilityAffordance } from "../capability-affordances.js";
+import type { WorkerCapabilityCatalogProjection } from "../capability-catalog.js";
+import type { WorkerCapabilitySelectionRejection } from "../capability-selection-rejection.js";
+import { projectWorkerDecisionCallIdentity, type WorkerDecision, type WorkerDecisionDiagnosticContext, type WorkerResultAuthorSource } from "../contracts.js";
+import { projectWorkerCapabilityResumeContext } from "../ledger-projection.js";
+export type WorkerDecisionInputRequest = Pick<RequestExecutionSeed, "requestId" | "prompt" | "historyMessages" | "runnerConfig" | "agentMode" | "modelPreference" | "modelPolicy"> & Partial<Pick<RequestExecutionSeed, "onEvent" | "sessionArtifactPaths" | "temporalContext" | "contextCompactionStore">>;
+export type WorkerDecisionCapabilityBinding = Pick<WorkerCapabilityBinding<unknown>, "requestId" | "ledger" | "callId" | "invocationAttempt" | "capabilities">;
+type WorkerDecisionCanonicalSource = Readonly<{
+    ledger: RoleCallLedger;
+    head: RoleCallLedgerHead;
+}>;
+export type WorkerDecisionCapabilitySource = WorkerDecisionCanonicalSource & Readonly<{
+    binding: WorkerDecisionCapabilityBinding;
+}>;
+export type WorkerDecisionCapabilityResumeSource = WorkerDecisionCanonicalSource & (Readonly<{
+    executionId: string;
+}> | Readonly<{
+    executionIds: readonly string[];
+}>);
+export type WorkerSelectedCapabilityExecution = Readonly<{
+    capabilityId: string;
+    intent: string;
+    selectionControls?: WorkerCapabilityControls;
+    guidance: string;
+}>;
+export type WorkerSelectedCapabilityBatchExecution = Readonly<{
+    invocations: readonly Readonly<{
+        capabilityId: string;
+        intent: string;
+        selectionControls?: WorkerCapabilityControls;
+        guidance: string;
+    }>[];
+}>;
+export type WorkerPendingCapabilitySelection = Readonly<{
+    capabilityId: string;
+    intent: string;
+    selectionControls?: WorkerCapabilityControls;
+}>;
+export type WorkerPendingCapabilityBatchSelection = readonly WorkerPendingCapabilitySelection[];
+export type WorkerDecisionInputOptions = Readonly<{
+    call: RoleCallFrame;
+    requestToolResults: RequestToolResultsView;
+    capabilitySource?: WorkerDecisionCapabilitySource;
+    capabilityResume?: WorkerDecisionCapabilityResumeSource;
+    selectedCapabilityExecution?: WorkerSelectedCapabilityExecution;
+    selectedCapabilityBatchExecution?: WorkerSelectedCapabilityBatchExecution;
+    capabilitySelectionRejection?: WorkerCapabilitySelectionRejection;
+    requestToolResultsContextMessage?: ChatMessage;
+    diagnostic?: WorkerDecisionDiagnosticContext;
+}>;
+export type PreparedWorkerCapabilitySelection = Readonly<{
+    capabilities: readonly WorkerCapabilityDescriptor[];
+    selectedCapabilityExecution?: WorkerSelectedCapabilityExecution;
+    selectedCapabilityBatchExecution?: WorkerSelectedCapabilityBatchExecution;
+    pendingCapabilitySelection?: WorkerPendingCapabilitySelection;
+    pendingCapabilityBatchSelection?: WorkerPendingCapabilityBatchSelection;
+    executionPending: boolean;
+}>;
+export type PreparedWorkerCanonicalState = Readonly<{
+    canonicalSource: WorkerDecisionCapabilitySource | WorkerDecisionCapabilityResumeSource | undefined;
+    assignmentScope: ReturnType<typeof projectRoleCallAssignmentScope> | undefined;
+    dependencyResults: readonly RoleCallDependencyResult[];
+    resume: ReturnType<typeof projectWorkerCapabilityResumeContext> | undefined;
+}>;
+export type PreparedWorkerDecisionContract = Readonly<{
+    availableCapabilityIds: readonly string[];
+    availableCapabilityAffordances: readonly WorkerCapabilityAffordance[];
+    capabilitiesAvailable: boolean;
+    sessionArtifactPathSelectionDeferred: boolean;
+    capabilitySelectionRejection: WorkerCapabilitySelectionRejection | undefined;
+    selectionCatalog: WorkerCapabilityCatalogProjection;
+    capabilityCatalogProjection: WorkerCapabilityCatalogProjection["kind"];
+    capabilityPromptPayload: WorkerCapabilityCatalogProjection["promptPayload"];
+    allowedActions: readonly WorkerDecision["action"][];
+    maxBatchCapabilityExecutions: number;
+    format: ModelGatewayJsonSchemaFormat;
+}>;
+export type PreparedWorkerDecisionSession = Readonly<{
+    request: WorkerDecisionInputRequest;
+    options: WorkerDecisionInputOptions;
+    callIdentity: ReturnType<typeof projectWorkerDecisionCallIdentity>;
+    diagnostic: WorkerDecisionDiagnosticContext;
+    objective: string;
+    eligibleSessionArtifactPaths: readonly string[];
+    sessionArtifactPathAvailableCount: number;
+    capabilitySelection: PreparedWorkerCapabilitySelection;
+    canonicalState: PreparedWorkerCanonicalState;
+    contract: PreparedWorkerDecisionContract;
+}>;
+export type PreparedWorkerReferenceContext = Readonly<{
+    requestToolResultsMessage: ChatMessage | undefined;
+    resultAuthorSource: WorkerResultAuthorSource;
+    baseReferenceMessages: readonly ChatMessage[];
+    continuationMessages: readonly ChatMessage[];
+}>;
+export type PreparedWorkerPromptContext = Readonly<{
+    budget: ReturnType<typeof resolveModelContextBudget>;
+    baseInstructions: string;
+    instructions: string;
+    configuredInstructionMetadata: ConfiguredStepInstructionMetadata;
+    prompt: string;
+}>;
+export type ProjectedWorkerDecisionContext = Readonly<{
+    sessionArtifactPathProjection: ReturnType<typeof buildSessionArtifactPathsMessage>;
+    referenceMessages: readonly ChatMessage[];
+    context: RequestContextProjection;
+}>;
+export type PreparedWorkerDecisionAssembly = Readonly<{
+    references: PreparedWorkerReferenceContext;
+    prompt: PreparedWorkerPromptContext;
+    projection: ProjectedWorkerDecisionContext;
+}>;
+export {};

package/dist/src/runtime/steps/worker-decision/input/types.js

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

package/dist/src/runtime/steps/worker-decision/input.d.ts

@@ -0,0 +1,21 @@
+import type { ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.js";
+import type { RequestContextProjection } from "../../context/request-context-contracts.js";
+import type { RoleCallDependencyResult } from "../../orchestration/role-calls/index.js";
+import type { WorkerCapabilityDescriptor } from "../../orchestration/worker-capabilities/index.js";
+import { WORKER_DECISION_MODEL_STEP, type WorkerDecision, type WorkerDecisionDiagnosticContext, type WorkerResultAuthorSource } from "./contracts.js";
+import type { WorkerDecisionInputOptions, WorkerDecisionInputRequest, WorkerPendingCapabilityBatchSelection, WorkerPendingCapabilitySelection } from "./input/types.js";
+export type { WorkerDecisionCapabilityResumeSource, WorkerDecisionCapabilitySource, WorkerDecisionInputRequest, WorkerPendingCapabilityBatchSelection, WorkerPendingCapabilitySelection, WorkerSelectedCapabilityBatchExecution, WorkerSelectedCapabilityExecution, } from "./input/types.js";
+export declare function buildWorkerDecisionInput(request: WorkerDecisionInputRequest, options: WorkerDecisionInputOptions): {
+    context: RequestContextProjection;
+    format: ModelGatewayJsonSchemaFormat;
+    modelStep: typeof WORKER_DECISION_MODEL_STEP;
+    diagnostic: WorkerDecisionDiagnosticContext;
+    allowedActions: readonly WorkerDecision["action"][];
+    availableCapabilities: readonly WorkerCapabilityDescriptor[];
+    availableCapabilityIds: readonly string[];
+    maxBatchCapabilityExecutions: number;
+    pendingCapabilitySelection?: WorkerPendingCapabilitySelection;
+    pendingCapabilityBatchSelection?: WorkerPendingCapabilityBatchSelection;
+    dependencyResults: readonly RoleCallDependencyResult[];
+    resultAuthorSource: WorkerResultAuthorSource;
+};

package/dist/src/runtime/steps/worker-decision/input.js

@@ -0,0 +1,31 @@
+import { WORKER_DECISION_MODEL_STEP, } from "./contracts.js";
+import { traceWorkerDecisionInputProjection } from "./input/diagnostic-projection.js";
+import { prepareWorkerDecisionAssembly, prepareWorkerDecisionSession, } from "./input/session.js";
+export function buildWorkerDecisionInput(request, options) {
+    const session = prepareWorkerDecisionSession(request, options);
+    const assembly = prepareWorkerDecisionAssembly(session);
+    traceWorkerDecisionInputProjection(session, assembly);
+    return projectBuiltWorkerDecisionInput(session, assembly);
+}
+function projectBuiltWorkerDecisionInput(session, assembly) {
+    const { diagnostic } = session;
+    const { dependencyResults } = session.canonicalState;
+    const { capabilities, pendingCapabilitySelection, pendingCapabilityBatchSelection, } = session.capabilitySelection;
+    const { format, allowedActions, availableCapabilityIds, maxBatchCapabilityExecutions, } = session.contract;
+    return {
+        context: assembly.projection.context,
+        format,
+        modelStep: WORKER_DECISION_MODEL_STEP,
+        diagnostic,
+        allowedActions,
+        availableCapabilities: capabilities,
+        availableCapabilityIds,
+        maxBatchCapabilityExecutions,
+        ...(pendingCapabilitySelection ? { pendingCapabilitySelection } : {}),
+        ...(pendingCapabilityBatchSelection
+            ? { pendingCapabilityBatchSelection }
+            : {}),
+        dependencyResults,
+        resultAuthorSource: assembly.references.resultAuthorSource,
+    };
+}

package/dist/src/runtime/steps/worker-decision/ledger-projection.d.ts

@@ -0,0 +1,9 @@
+import type { RoleCallLedger, RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
+import { type WorkerCapabilityResumeContext } from "./contracts.js";
+export declare function projectWorkerCapabilityResumeContext(ledger: RoleCallLedger, head: RoleCallLedgerHead, refs: Readonly<{
+    callId: string;
+}> & (Readonly<{
+    executionId: string;
+}> | Readonly<{
+    executionIds: readonly string[];
+}>)): WorkerCapabilityResumeContext;

package/dist/src/runtime/steps/worker-decision/ledger-projection.js

@@ -0,0 +1,40 @@
+import { projectWorkerSettledCapabilityResults, } from "../../orchestration/worker-capabilities/index.js";
+export function projectWorkerCapabilityResumeContext(ledger, head, refs) {
+    if (ledger.current() !== head) {
+        throw new Error("worker_capability_resume_head_stale");
+    }
+    const call = head.state.calls.find((candidate) => candidate.callId === refs.callId);
+    if (head.state.phase !== "running" ||
+        head.state.activeCallId !== refs.callId ||
+        call?.roleId !== "worker" ||
+        call.status !== "active" ||
+        call.parentCallId === null ||
+        call.callId !== refs.callId) {
+        throw new Error("worker_capability_resume_projection_invalid");
+    }
+    const settledResults = projectWorkerSettledCapabilityResults({
+        ledger,
+        head,
+        call,
+    });
+    const executionIds = "executionIds" in refs ? refs.executionIds : [refs.executionId];
+    const returnedExecutions = settledResults.slice(-executionIds.length);
+    if (executionIds.length === 0 ||
+        new Set(executionIds).size !== executionIds.length ||
+        returnedExecutions.length !== executionIds.length ||
+        !returnedExecutions.every((execution, index) => execution.executionId === executionIds[index] &&
+            execution.invocationAttempt + 1 === call.activationCount)) {
+        throw new Error("worker_capability_resume_projection_invalid");
+    }
+    return "executionIds" in refs
+        ? Object.freeze({
+            requestId: head.state.requestId,
+            returnedExecutionIds: Object.freeze([...executionIds]),
+            settledResults,
+        })
+        : Object.freeze({
+            requestId: head.state.requestId,
+            returnedExecutionId: executionIds[0],
+            settledResults,
+        });
+}

package/dist/src/runtime/steps/worker-decision/parser.d.ts

@@ -0,0 +1,17 @@
+import { type WorkerDecisionPhase, type WorkerDecisionDiagnosticContext, type WorkerDecisionParseResult } from "./contracts.js";
+import { type WorkerCapabilityControls, type WorkerCapabilityDescriptor } from "../../orchestration/worker-capabilities/index.js";
+export declare function parseWorkerDecisionOutput(text: string, diagnostic?: WorkerDecisionDiagnosticContext, options?: Readonly<{
+    availableCapabilities?: readonly WorkerCapabilityDescriptor[];
+    maxBatchCapabilityExecutions?: number;
+    decisionPhase?: WorkerDecisionPhase;
+    pendingCapabilitySelection?: Readonly<{
+        capabilityId: string;
+        intent: string;
+        selectionControls?: WorkerCapabilityControls;
+    }>;
+    pendingCapabilityBatchSelection?: readonly Readonly<{
+        capabilityId: string;
+        intent: string;
+        selectionControls?: WorkerCapabilityControls;
+    }>[];
+}>): WorkerDecisionParseResult;