@abot-ai/runtime 1.0.0 → 1.1.0

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

@@ -1,15 +1,15 @@
 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 { buildImmediateOperationSupervisionEvidenceMessage } from "../../../context/operation-supervision-evidence.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 { assignmentScope, dependencyResults, operationSupervision, resume } = canonicalState;
     const requestSource = projectRequestSource({
         requestId: request.requestId,
         prompt: request.prompt,
-        modelStep: WORKER_DECISION_MODEL_STEP,
+        modelStep: session.diagnostic.modelStep,
         callId: callIdentity.callId,
         historyMessages: request.historyMessages,
     });
@@ -17,6 +17,15 @@ export function prepareWorkerReferenceContext(session) {
         ? (options.requestToolResultsContextMessage ??
             buildRequestToolResultsMessage(options.requestToolResults))
         : undefined;
+    if (operationSupervision && !canonicalState.canonicalSource) {
+        throw new Error("worker_operation_supervision_source_missing");
+    }
+    const operationSupervisionEvidenceMessage = operationSupervision && canonicalState.canonicalSource
+        ? buildImmediateOperationSupervisionEvidenceMessage(canonicalState.canonicalSource.head, options.call)
+        : undefined;
+    if (operationSupervision && !operationSupervisionEvidenceMessage) {
+        throw new Error("worker_operation_supervision_evidence_missing");
+    }
     const resultAuthorSource = Object.freeze({
         ...callIdentity,
         objective,
@@ -25,6 +34,11 @@ export function prepareWorkerReferenceContext(session) {
         ...(requestToolResultsMessage
             ? { requestToolResultsContextMessage: requestToolResultsMessage }
             : {}),
+        ...(operationSupervisionEvidenceMessage
+            ? {
+                operationSupervisionEvidenceContextMessage: operationSupervisionEvidenceMessage,
+            }
+            : {}),
     });
     const baseReferenceMessages = Object.freeze([
         ...(request.temporalContext
@@ -37,12 +51,16 @@ export function prepareWorkerReferenceContext(session) {
         ...(!resume && requestToolResultsMessage
             ? [requestToolResultsMessage]
             : []),
+        ...(operationSupervisionEvidenceMessage
+            ? [operationSupervisionEvidenceMessage]
+            : []),
     ]);
     const continuationMessages = Object.freeze([
         ...(resume && requestToolResultsMessage ? [requestToolResultsMessage] : []),
     ]);
     return Object.freeze({
         requestToolResultsMessage,
+        operationSupervisionEvidenceMessage,
         resultAuthorSource,
         baseReferenceMessages,
         continuationMessages,

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

@@ -26,12 +26,13 @@ export function prepareWorkerDecisionSession(request, options) {
         deferRuntimePathControls: eligibleSessionArtifactPaths.length > 0,
     });
     const capabilitySelection = prepareWorkerCapabilitySelection(options, projectedCapabilities);
-    const canonicalState = prepareWorkerCanonicalState(request, options, callIdentity);
+    const canonicalState = prepareWorkerCanonicalState(request, options, callIdentity, diagnostic.modelStep, capabilitySelection.executionPending);
     const contract = prepareWorkerDecisionContract({
         options,
         projectedCapabilities,
         eligibleSessionArtifactPaths,
         canonicalSource: canonicalState.canonicalSource,
+        dependencyResultCount: canonicalState.dependencyResults.length,
         capabilitySelection,
     });
     return Object.freeze({

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

@@ -5,7 +5,7 @@ import type { RequestToolResultsView } from "../../../context/request-tool-resul
 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 { projectRoleCallAssignmentScope, type RoleCallDependencyResult, type RoleCallFrame, type RoleCallLedger, type RoleCallLedgerHead, type RoleOperationSupervisionNotice } 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";
@@ -29,6 +29,7 @@ export type WorkerDecisionCapabilityResumeSource = WorkerDecisionCanonicalSource
 export type WorkerSelectedCapabilityExecution = Readonly<{
     capabilityId: string;
     intent: string;
+    authoringObjective?: string;
     selectionControls?: WorkerCapabilityControls;
     guidance: string;
 }>;
@@ -36,6 +37,7 @@ export type WorkerSelectedCapabilityBatchExecution = Readonly<{
     invocations: readonly Readonly<{
         capabilityId: string;
         intent: string;
+        authoringObjective?: string;
         selectionControls?: WorkerCapabilityControls;
         guidance: string;
     }>[];
@@ -43,6 +45,7 @@ export type WorkerSelectedCapabilityBatchExecution = Readonly<{
 export type WorkerPendingCapabilitySelection = Readonly<{
     capabilityId: string;
     intent: string;
+    authoringObjective?: string;
     selectionControls?: WorkerCapabilityControls;
 }>;
 export type WorkerPendingCapabilityBatchSelection = readonly WorkerPendingCapabilitySelection[];
@@ -70,6 +73,7 @@ export type PreparedWorkerCanonicalState = Readonly<{
     assignmentScope: ReturnType<typeof projectRoleCallAssignmentScope> | undefined;
     dependencyResults: readonly RoleCallDependencyResult[];
     resume: ReturnType<typeof projectWorkerCapabilityResumeContext> | undefined;
+    operationSupervision: readonly RoleOperationSupervisionNotice[] | undefined;
 }>;
 export type PreparedWorkerDecisionContract = Readonly<{
     availableCapabilityIds: readonly string[];
@@ -98,6 +102,7 @@ export type PreparedWorkerDecisionSession = Readonly<{
 }>;
 export type PreparedWorkerReferenceContext = Readonly<{
     requestToolResultsMessage: ChatMessage | undefined;
+    operationSupervisionEvidenceMessage: ChatMessage | undefined;
     resultAuthorSource: WorkerResultAuthorSource;
     baseReferenceMessages: readonly ChatMessage[];
     continuationMessages: readonly ChatMessage[];

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

@@ -2,13 +2,13 @@ import type { ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.
 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 { CAPABILITY_CONTROLS_MODEL_STEP, 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;
+    modelStep: typeof WORKER_DECISION_MODEL_STEP | typeof CAPABILITY_CONTROLS_MODEL_STEP;
     diagnostic: WorkerDecisionDiagnosticContext;
     allowedActions: readonly WorkerDecision["action"][];
     availableCapabilities: readonly WorkerCapabilityDescriptor[];

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

@@ -1,4 +1,3 @@
-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) {
@@ -15,7 +14,7 @@ function projectBuiltWorkerDecisionInput(session, assembly) {
     return {
         context: assembly.projection.context,
         format,
-        modelStep: WORKER_DECISION_MODEL_STEP,
+        modelStep: diagnostic.modelStep,
         diagnostic,
         allowedActions,
         availableCapabilities: capabilities,

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

@@ -0,0 +1,3 @@
+import type { WorkerControlDecision } from "../contracts.js";
+import type { ActionValidation, DecisionValidationContext, WorkerDecisionAction } from "./validation-contract.js";
+export declare function buildAcceptedWorkerDecision(action: WorkerDecisionAction, record: Record<string, unknown>, context: DecisionValidationContext, validation: ActionValidation): WorkerControlDecision;

package/dist/src/runtime/steps/worker-decision/parser/accepted-decision.js

@@ -0,0 +1,70 @@
+export function buildAcceptedWorkerDecision(action, record, context, validation) {
+    switch (action) {
+        case "return_result":
+            return { action: "return_result" };
+        case "return_failure":
+            return {
+                action: "return_failure",
+                reason: record.reason.trim(),
+            };
+        case "invoke_capability":
+            return buildAcceptedSingleCapabilityDecision(record, context, validation);
+        case "invoke_capabilities":
+            return buildAcceptedCapabilityBatchDecision(context, validation);
+    }
+}
+function buildAcceptedSingleCapabilityDecision(record, context, validation) {
+    const capabilityId = context.pendingCapabilitySelection?.capabilityId ??
+        record.capabilityId;
+    const intent = context.pendingCapabilitySelection?.intent ??
+        record.intent.trim();
+    const authoringObjective = context.pendingCapabilitySelection?.authoringObjective ??
+        validation.acceptedAuthoringObjective;
+    const acceptedInvocation = {
+        action: "invoke_capability",
+        capabilityId,
+        intent,
+        ...(authoringObjective ? { authoringObjective } : {}),
+    };
+    if (context.decisionPhase === "capability_execution") {
+        return {
+            ...acceptedInvocation,
+            controls: validation.acceptedControls,
+        };
+    }
+    if (validation.acceptedSelectionControls) {
+        return {
+            ...acceptedInvocation,
+            selectionControls: validation.acceptedSelectionControls,
+        };
+    }
+    return acceptedInvocation;
+}
+function buildAcceptedCapabilityBatchDecision(context, validation) {
+    return {
+        action: "invoke_capabilities",
+        invocations: Object.freeze(validation.acceptedBatchInvocations.map((invocation) => projectAcceptedCapabilityInvocation(context, invocation))),
+    };
+}
+function projectAcceptedCapabilityInvocation(context, invocation) {
+    const acceptedInvocation = {
+        capabilityId: invocation.capabilityId,
+        intent: invocation.intent,
+        ...(invocation.authoringObjective
+            ? { authoringObjective: invocation.authoringObjective }
+            : {}),
+    };
+    if (context.decisionPhase === "capability_execution") {
+        return Object.freeze({
+            ...acceptedInvocation,
+            controls: invocation.controls,
+        });
+    }
+    if (invocation.selectionControls) {
+        return Object.freeze({
+            ...acceptedInvocation,
+            selectionControls: invocation.selectionControls,
+        });
+    }
+    return Object.freeze(acceptedInvocation);
+}

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

@@ -0,0 +1,4 @@
+import { type WorkerDecisionValidationIssue } from "../contracts.js";
+import type { ActionValidation, DecisionValidationContext, WorkerDecisionAction } from "./validation-contract.js";
+export declare function readWorkerDecisionAction(value: unknown): WorkerDecisionAction | undefined;
+export declare function validateWorkerDecisionAction(action: WorkerDecisionAction | undefined, record: Record<string, unknown>, context: DecisionValidationContext, issues: WorkerDecisionValidationIssue[]): ActionValidation;

package/dist/src/runtime/steps/worker-decision/parser/action-validation.js

@@ -0,0 +1,55 @@
+import { WORKER_RESULT_MAX_LENGTH, } from "../contracts.js";
+import { validateCapabilityBatchDecision } from "./capability-batch-validation.js";
+import { validateSingleCapabilityDecision } from "./capability-invocation-validation.js";
+import { validateBoundedWorkerDecisionText, validateExactWorkerDecisionKeys, } from "./decision-shape-validation.js";
+import { createWorkerDecisionIssue } from "./validation-contract.js";
+export function readWorkerDecisionAction(value) {
+    if (value === "return_result")
+        return value;
+    if (value === "return_failure")
+        return value;
+    if (value === "invoke_capability")
+        return value;
+    if (value === "invoke_capabilities")
+        return value;
+    return undefined;
+}
+export function validateWorkerDecisionAction(action, record, context, issues) {
+    if (!action) {
+        issues.push(createWorkerDecisionIssue("worker_action_invalid", "decision.action"));
+        return {};
+    }
+    if (isTerminalWorkerActionUnavailable(action, context.allowedActions)) {
+        issues.push(createWorkerDecisionIssue("worker_terminal_action_unavailable", "decision.action", `${action} is unavailable in this Worker decision state; choose one of ${JSON.stringify(context.allowedActions)}.`));
+        return {};
+    }
+    return validateSelectedWorkerAction(action, record, context, issues);
+}
+function isTerminalWorkerActionUnavailable(action, allowedActions) {
+    if (allowedActions.includes(action))
+        return false;
+    if (action === "return_result")
+        return true;
+    return action === "return_failure";
+}
+function validateSelectedWorkerAction(action, record, context, issues) {
+    switch (action) {
+        case "return_result":
+            validateReturnResultDecision(record, issues);
+            return {};
+        case "return_failure":
+            validateReturnFailureDecision(record, issues);
+            return {};
+        case "invoke_capability":
+            return validateSingleCapabilityDecision(record, context, issues);
+        case "invoke_capabilities":
+            return validateCapabilityBatchDecision(record, context, issues);
+    }
+}
+function validateReturnResultDecision(record, issues) {
+    validateExactWorkerDecisionKeys(record, ["action"], issues);
+}
+function validateReturnFailureDecision(record, issues) {
+    validateExactWorkerDecisionKeys(record, ["action", "reason"], issues);
+    validateBoundedWorkerDecisionText(record.reason, WORKER_RESULT_MAX_LENGTH, "worker_result_invalid", "decision.reason", issues);
+}

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

@@ -0,0 +1,3 @@
+import { type WorkerDecisionValidationIssue } from "../contracts.js";
+import type { ActionValidation, DecisionValidationContext } from "./validation-contract.js";
+export declare function validateCapabilityBatchDecision(record: Record<string, unknown>, context: DecisionValidationContext, issues: WorkerDecisionValidationIssue[]): ActionValidation;

package/dist/src/runtime/steps/worker-decision/parser/capability-batch-validation.js

@@ -0,0 +1,135 @@
+import { WORKER_CAPABILITY_INTENT_MAX_LENGTH, } from "../contracts.js";
+import { workerCapabilityBatchExecutionSlotId } from "../format.js";
+import { parseCapabilityInvocation } from "./capability-invocation-validation.js";
+import { readWorkerDecisionRecord, validateExactWorkerDecisionKeys, } from "./decision-shape-validation.js";
+import { createWorkerDecisionIssue } from "./validation-contract.js";
+export function validateCapabilityBatchDecision(record, context, issues) {
+    validateExactWorkerDecisionKeys(record, ["action", "invocations"], issues);
+    const invocations = readCapabilityBatchInvocations(record.invocations, context);
+    if (!hasAllowedCapabilityBatchSize(invocations, context)) {
+        issues.push(createWorkerDecisionIssue("worker_capability_batch_size_invalid", "decision.invocations"));
+        return {};
+    }
+    const acceptedBatchInvocations = [];
+    invocations.forEach((input, index) => {
+        const pendingSlotId = capabilityBatchPendingSlotId(context, index);
+        const path = pendingSlotId
+            ? `decision.invocations.${pendingSlotId}`
+            : `decision.invocations[${index}]`;
+        const invocationRecord = readWorkerDecisionRecord(input);
+        if (!invocationRecord) {
+            issues.push(createWorkerDecisionIssue("worker_capability_batch_item_invalid", path));
+            return;
+        }
+        const pendingInvocation = pendingCapabilityBatchInvocation(context, index);
+        const invocation = parseCapabilityInvocation({
+            record: invocationRecord,
+            path,
+            includesActionKey: false,
+            observationOnly: true,
+            executionRequiresPendingInvocation: false,
+            decisionPhase: context.decisionPhase,
+            availableCapabilities: context.availableCapabilities,
+            pendingInvocation,
+            pendingSlotId,
+        }, issues);
+        if (!canAcceptObservationBatchInvocation(context, invocationRecord, invocation, pendingInvocation)) {
+            return;
+        }
+        acceptedBatchInvocations.push(projectAcceptedCapabilityInvocation(context, invocationRecord, invocation, pendingInvocation));
+    });
+    return { acceptedBatchInvocations };
+}
+function readCapabilityBatchInvocations(value, context) {
+    if (context.decisionPhase === "capability_execution") {
+        return readPendingCapabilityBatchExecutionSlots(value, context.pendingCapabilityBatchSelection?.length);
+    }
+    return Array.isArray(value) ? value : undefined;
+}
+function capabilityBatchPendingSlotId(context, index) {
+    if (context.decisionPhase !== "capability_execution")
+        return undefined;
+    return workerCapabilityBatchExecutionSlotId(index);
+}
+function pendingCapabilityBatchInvocation(context, index) {
+    if (context.decisionPhase !== "capability_execution")
+        return undefined;
+    return context.pendingCapabilityBatchSelection?.[index];
+}
+function hasAllowedCapabilityBatchSize(invocations, context) {
+    if (!invocations)
+        return false;
+    if (context.decisionPhase === "capability_execution") {
+        if (!context.pendingCapabilityBatchSelection)
+            return false;
+        return (invocations.length === context.pendingCapabilityBatchSelection.length);
+    }
+    if (invocations.length < 2)
+        return false;
+    if (!Number.isInteger(context.maxBatchCapabilityExecutions))
+        return false;
+    if (context.maxBatchCapabilityExecutions < 2)
+        return false;
+    return invocations.length <= context.maxBatchCapabilityExecutions;
+}
+function canAcceptObservationBatchInvocation(context, invocationRecord, invocation, pendingInvocation) {
+    if (invocation.selectedCapability?.effect !== "observation")
+        return false;
+    if (!pendingInvocation &&
+        !hasValidGeneratedCapabilityIdentity(invocationRecord)) {
+        return false;
+    }
+    if (context.decisionPhase === "capability_execution") {
+        return invocation.controls !== undefined;
+    }
+    if (!invocation.controlsPartition?.selectionControlIds.length)
+        return true;
+    return invocation.selectionControls !== undefined;
+}
+function hasValidGeneratedCapabilityIdentity(invocation) {
+    if (typeof invocation.capabilityId !== "string")
+        return false;
+    if (typeof invocation.intent !== "string")
+        return false;
+    if (invocation.intent.trim().length === 0)
+        return false;
+    return invocation.intent.length <= WORKER_CAPABILITY_INTENT_MAX_LENGTH;
+}
+function projectAcceptedCapabilityInvocation(context, invocationRecord, invocation, pendingInvocation) {
+    const capabilityId = pendingInvocation?.capabilityId ??
+        invocationRecord.capabilityId;
+    const intent = pendingInvocation?.intent ?? invocationRecord.intent.trim();
+    const authoringObjective = pendingInvocation?.authoringObjective ?? invocation.authoringObjective;
+    if (context.decisionPhase === "capability_execution") {
+        return Object.freeze({
+            capabilityId,
+            intent,
+            ...(authoringObjective ? { authoringObjective } : {}),
+            controls: invocation.controls,
+        });
+    }
+    return Object.freeze({
+        capabilityId,
+        intent,
+        ...(authoringObjective ? { authoringObjective } : {}),
+        ...(invocation.selectionControls
+            ? { selectionControls: invocation.selectionControls }
+            : {}),
+    });
+}
+function readPendingCapabilityBatchExecutionSlots(value, expectedCount) {
+    const record = readWorkerDecisionRecord(value);
+    if (!record || expectedCount === undefined)
+        return undefined;
+    const expectedSlotIds = Array.from({ length: expectedCount }, (_, index) => workerCapabilityBatchExecutionSlotId(index));
+    const actualSlotIds = Object.keys(record);
+    if (!hasExactPendingBatchExecutionSlots(actualSlotIds, expectedSlotIds)) {
+        return undefined;
+    }
+    return expectedSlotIds.map((slotId) => record[slotId]);
+}
+function hasExactPendingBatchExecutionSlots(actualSlotIds, expectedSlotIds) {
+    if (actualSlotIds.length !== expectedSlotIds.length)
+        return false;
+    return actualSlotIds.every((slotId) => expectedSlotIds.includes(slotId));
+}

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

@@ -0,0 +1,6 @@
+import type { WorkerDecisionValidationIssue } from "../contracts.js";
+import { type WorkerCapabilityControls, type WorkerCapabilityControlsPartition, type WorkerCapabilityDescriptor } from "../../../orchestration/worker-capabilities/index.js";
+import type { CapabilityInvocationValidationInput } from "./validation-contract.js";
+export declare function partitionSelectedCapabilityControls(selectedCapability: WorkerCapabilityDescriptor | undefined, capabilityPath: string, issues: WorkerDecisionValidationIssue[]): WorkerCapabilityControlsPartition | undefined;
+export declare function validateCapabilitySelectionControls(params: CapabilityInvocationValidationInput, selectedCapability: WorkerCapabilityDescriptor | undefined, controlsPartition: WorkerCapabilityControlsPartition | undefined, issues: WorkerDecisionValidationIssue[]): WorkerCapabilityControls | undefined;
+export declare function validateCapabilityExecutionControls(params: CapabilityInvocationValidationInput, selectedCapability: WorkerCapabilityDescriptor | undefined, controlsPartition: WorkerCapabilityControlsPartition | undefined, issues: WorkerDecisionValidationIssue[]): WorkerCapabilityControls | undefined;

package/dist/src/runtime/steps/worker-decision/parser/capability-controls-validation.js

@@ -0,0 +1,132 @@
+import { mergeWorkerCapabilityControls, partitionWorkerCapabilityControlsSchema, validateWorkerCapabilityRemainingControls, validateWorkerCapabilitySelectionControls, } from "../../../orchestration/worker-capabilities/index.js";
+import { readWorkerDecisionRecord } from "./decision-shape-validation.js";
+import { createWorkerDecisionIssue, hasObservationOnlyCapabilityMismatch, } from "./validation-contract.js";
+export function partitionSelectedCapabilityControls(selectedCapability, capabilityPath, issues) {
+    if (!selectedCapability)
+        return undefined;
+    const partition = partitionWorkerCapabilityControlsSchema(selectedCapability.controls, selectedCapability.selectionControlIds);
+    if (partition.ok)
+        return partition.value;
+    issues.push(createWorkerDecisionIssue("worker_capability_controls_schema_invalid", capabilityPath));
+    return undefined;
+}
+export function validateCapabilitySelectionControls(params, selectedCapability, controlsPartition, issues) {
+    if (!selectedCapability)
+        return undefined;
+    if (hasObservationOnlyCapabilityMismatch(params, selectedCapability)) {
+        return undefined;
+    }
+    if (!controlsPartition)
+        return undefined;
+    if (params.decisionPhase !== "capability_selection")
+        return undefined;
+    if (controlsPartition.selectionControlIds.length === 0)
+        return undefined;
+    const selectionControls = validateWorkerCapabilitySelectionControls(controlsPartition, normalizeGeneratedCapabilityControls(params.record.selectionControls, controlsPartition.selectionSchema));
+    if (selectionControls.ok)
+        return selectionControls.value;
+    issues.push(createWorkerCapabilityControlsIssue({
+        issueCode: selectionControls.issueCode,
+        controlId: selectionControls.controlId,
+        path: selectionControls.controlId
+            ? `${params.path}.selectionControls.${selectionControls.controlId}`
+            : `${params.path}.selectionControls`,
+        capability: selectedCapability,
+        schema: controlsPartition.selectionSchema,
+        pendingSlotId: params.pendingSlotId,
+    }));
+    return undefined;
+}
+export function validateCapabilityExecutionControls(params, selectedCapability, controlsPartition, issues) {
+    if (!selectedCapability) {
+        reportNonObjectExecutionControls(params, issues);
+        return undefined;
+    }
+    if (hasObservationOnlyCapabilityMismatch(params, selectedCapability)) {
+        reportNonObjectExecutionControls(params, issues);
+        return undefined;
+    }
+    if (!controlsPartition) {
+        reportNonObjectExecutionControls(params, issues);
+        return undefined;
+    }
+    if (params.decisionPhase !== "capability_execution") {
+        reportNonObjectExecutionControls(params, issues);
+        return undefined;
+    }
+    const remainingControls = validateWorkerCapabilityRemainingControls(controlsPartition, normalizeGeneratedCapabilityControls(params.record.controls, controlsPartition.remainingSchema));
+    if (!remainingControls.ok) {
+        issues.push(createWorkerCapabilityControlsIssue({
+            issueCode: remainingControls.issueCode,
+            controlId: remainingControls.controlId,
+            path: remainingControls.controlId
+                ? `${params.path}.controls.${remainingControls.controlId}`
+                : `${params.path}.controls`,
+            capability: selectedCapability,
+            schema: controlsPartition.remainingSchema,
+            pendingSlotId: params.pendingSlotId,
+        }));
+        return undefined;
+    }
+    const mergedControls = mergeWorkerCapabilityControls(controlsPartition, {
+        selectionControls: params.pendingInvocation?.selectionControls ?? {},
+        remainingControls: remainingControls.value,
+    });
+    if (mergedControls.ok)
+        return mergedControls.value;
+    issues.push(createWorkerCapabilityControlsIssue({
+        issueCode: mergedControls.issueCode,
+        controlId: mergedControls.controlId,
+        path: mergedControls.controlId
+            ? `${params.path}.controls.${mergedControls.controlId}`
+            : `${params.path}.controls`,
+        capability: selectedCapability,
+        schema: controlsPartition.remainingSchema,
+        pendingSlotId: params.pendingSlotId,
+    }));
+    return undefined;
+}
+function reportNonObjectExecutionControls(params, issues) {
+    if (params.decisionPhase !== "capability_execution")
+        return;
+    if (readWorkerDecisionRecord(params.record.controls))
+        return;
+    issues.push(createWorkerDecisionIssue("worker_capability_controls_not_object", `${params.path}.controls`));
+}
+function normalizeGeneratedCapabilityControls(value, schema) {
+    const record = readWorkerDecisionRecord(value);
+    if (!record)
+        return value;
+    const required = new Set(schema.required);
+    return Object.fromEntries(Object.entries(record).filter(([controlId, controlValue]) => shouldRetainGeneratedCapabilityControl(controlId, controlValue, required, schema)));
+}
+function shouldRetainGeneratedCapabilityControl(controlId, controlValue, required, schema) {
+    if (controlValue !== null)
+        return true;
+    if (required.has(controlId))
+        return true;
+    return !Object.prototype.hasOwnProperty.call(schema.properties, controlId);
+}
+function createWorkerCapabilityControlsIssue(params) {
+    const code = `worker_capability_${params.issueCode}`;
+    if (!requiresDetailedCapabilityControlsIssue(params.issueCode)) {
+        return createWorkerDecisionIssue(code, params.path);
+    }
+    return createWorkerDecisionIssue(code, params.path, `${pendingCapabilityBindingMessage(params)} ${capabilityControlProblemMessage(params)} Allowed control IDs: ${JSON.stringify(Object.keys(params.schema.properties))}. Required control IDs: ${JSON.stringify(params.schema.required)}.`);
+}
+function requiresDetailedCapabilityControlsIssue(issueCode) {
+    return (issueCode === "controls_unknown" ||
+        issueCode === "controls_required_missing");
+}
+function pendingCapabilityBindingMessage(params) {
+    if (params.pendingSlotId) {
+        return `Pending slot ${JSON.stringify(params.pendingSlotId)} is frozen to capabilityId ${JSON.stringify(params.capability.capabilityId)}.`;
+    }
+    return `Pending capabilityId is ${JSON.stringify(params.capability.capabilityId)}.`;
+}
+function capabilityControlProblemMessage(params) {
+    if (params.issueCode === "controls_unknown") {
+        return `Control ${JSON.stringify(params.controlId)} is not allowed for this capability.`;
+    }
+    return `Required control ${JSON.stringify(params.controlId)} is missing for this capability.`;
+}

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

@@ -0,0 +1,4 @@
+import { type WorkerDecisionValidationIssue } from "../contracts.js";
+import type { ActionValidation, CapabilityInvocationValidation, CapabilityInvocationValidationInput, DecisionValidationContext } from "./validation-contract.js";
+export declare function validateSingleCapabilityDecision(record: Record<string, unknown>, context: DecisionValidationContext, issues: WorkerDecisionValidationIssue[]): ActionValidation;
+export declare function parseCapabilityInvocation(params: CapabilityInvocationValidationInput, issues: WorkerDecisionValidationIssue[]): CapabilityInvocationValidation;