@abot-ai/runtime 1.0.0 → 1.2.0

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

@@ -1,5 +1,5 @@
 import { isRoleCapabilityId } from "../../../orchestration/role-calls/index.js";
-import { WORKER_CAPABILITY_INTENT_MAX_LENGTH, partitionWorkerCapabilityControlsSchema, validateWorkerCapabilitySelectionControls, } from "../../../orchestration/worker-capabilities/index.js";
+import { WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH, WORKER_CAPABILITY_INTENT_MAX_LENGTH, canOfferWorkerCapabilityBatchSelection, partitionWorkerCapabilityControlsSchema, validateWorkerCapabilitySelectionControls, } from "../../../orchestration/worker-capabilities/index.js";
 export function prepareWorkerCapabilitySelection(options, projectedCapabilities) {
     const selectedCapabilityExecution = options.selectedCapabilityExecution
         ? normalizeSelectedCapabilityExecution(options.selectedCapabilityExecution, projectedCapabilities)
@@ -34,6 +34,9 @@ function projectPendingCapabilitySelection(selection) {
     return Object.freeze({
         capabilityId: selection.capabilityId,
         intent: selection.intent,
+        ...(selection.authoringObjective
+            ? { authoringObjective: selection.authoringObjective }
+            : {}),
         ...(selection.selectionControls
             ? { selectionControls: selection.selectionControls }
             : {}),
@@ -62,10 +65,12 @@ function normalizeSelectedCapabilityExecution(input, capabilities) {
     }
     const controlsPartition = partitionWorkerCapabilityControlsSchema(descriptor.controls, descriptor.selectionControlIds);
     const hasSelectionControls = Object.hasOwn(input, "selectionControls");
+    const authoringObjective = normalizeSelectedAuthoringObjective(input, descriptor);
     const selectionControls = controlsPartition.ok
         ? validateWorkerCapabilitySelectionControls(controlsPartition.value, input.selectionControls ?? {})
         : controlsPartition;
     if (!controlsPartition.ok ||
+        !authoringObjective.ok ||
         !selectionControls.ok ||
         hasSelectionControls !==
             controlsPartition.value.selectionControlIds.length > 0) {
@@ -74,6 +79,9 @@ function normalizeSelectedCapabilityExecution(input, capabilities) {
     return Object.freeze({
         capabilityId: input.capabilityId,
         intent: input.intent.trim(),
+        ...(authoringObjective.value
+            ? { authoringObjective: authoringObjective.value }
+            : {}),
         ...(controlsPartition.value.selectionControlIds.length > 0
             ? { selectionControls: selectionControls.value }
             : {}),
@@ -101,10 +109,12 @@ function normalizeSelectedCapabilityBatchExecution(input, capabilities) {
         }
         const controlsPartition = partitionWorkerCapabilityControlsSchema(descriptor.controls, descriptor.selectionControlIds);
         const hasSelectionControls = Object.hasOwn(invocation, "selectionControls");
+        const authoringObjective = normalizeSelectedAuthoringObjective(invocation, descriptor);
         const selectionControls = controlsPartition.ok
             ? validateWorkerCapabilitySelectionControls(controlsPartition.value, invocation.selectionControls ?? {})
             : controlsPartition;
         if (!controlsPartition.ok ||
+            !authoringObjective.ok ||
             !selectionControls.ok ||
             hasSelectionControls !==
                 controlsPartition.value.selectionControlIds.length > 0) {
@@ -113,6 +123,9 @@ function normalizeSelectedCapabilityBatchExecution(input, capabilities) {
         return Object.freeze({
             capabilityId: descriptor.capabilityId,
             intent: invocation.intent.trim(),
+            ...(authoringObjective.value
+                ? { authoringObjective: authoringObjective.value }
+                : {}),
             ...(controlsPartition.value.selectionControlIds.length > 0
                 ? { selectionControls: selectionControls.value }
                 : {}),
@@ -121,6 +134,22 @@ function normalizeSelectedCapabilityBatchExecution(input, capabilities) {
     });
     return Object.freeze({ invocations: Object.freeze(invocations) });
 }
+function normalizeSelectedAuthoringObjective(input, descriptor) {
+    const required = descriptor.requiresPayloadAuthoringObjective === true;
+    if (Object.hasOwn(input, "authoringObjective") !== required) {
+        return { ok: false };
+    }
+    if (!required)
+        return { ok: true };
+    const value = input.authoringObjective;
+    if (typeof value !== "string" ||
+        value.trim() !== value ||
+        value.length === 0 ||
+        value.length > WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH) {
+        return { ok: false };
+    }
+    return { ok: true, value };
+}
 export function canOfferCapabilityBatch(params) {
     if (params.selectedCapabilityBatchExecution)
         return true;
@@ -130,6 +159,18 @@ export function canOfferCapabilityBatch(params) {
         return false;
     const remaining = params.canonicalSource.head.policy.limits.maxCapabilityExecutions -
         params.canonicalSource.head.state.capabilityExecutions.length;
-    return (remaining >= 2 &&
-        params.capabilities.some(({ effect }) => effect === "observation"));
+    if (remaining < 2)
+        return false;
+    return canOfferWorkerCapabilityBatchSelection(params.capabilities
+        .filter(({ effect }) => effect === "observation")
+        .map(projectCapabilityBatchSelectionCandidate));
+}
+function projectCapabilityBatchSelectionCandidate(capability) {
+    const partition = partitionWorkerCapabilityControlsSchema(capability.controls, capability.selectionControlIds);
+    return Object.freeze({
+        capabilityId: capability.capabilityId,
+        ...(partition.ok
+            ? { selectionSchema: partition.value.selectionSchema }
+            : {}),
+    });
 }

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

@@ -5,5 +5,6 @@ export declare function prepareWorkerDecisionContract(params: Readonly<{
     projectedCapabilities: readonly WorkerCapabilityDescriptor[];
     eligibleSessionArtifactPaths: readonly string[];
     canonicalSource: WorkerDecisionCapabilitySource | WorkerDecisionCapabilityResumeSource | undefined;
+    dependencyResultCount: number;
     capabilitySelection: PreparedWorkerCapabilitySelection;
 }>): PreparedWorkerDecisionContract;

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

@@ -3,6 +3,7 @@ import { projectWorkerCapabilitySelectionCatalog } from "../capability-catalog.j
 import { normalizeWorkerCapabilitySelectionRejection } from "../capability-selection-rejection.js";
 import { WORKER_DECISION_ACTIONS } from "../contracts.js";
 import { createWorkerDecisionFormat } from "../format.js";
+import { resolveWorkerDecisionAllowedActions } from "./action-policy.js";
 import { canOfferCapabilityBatch } from "./capability-selection.js";
 export function prepareWorkerDecisionContract(params) {
     const { capabilities, selectedCapabilityExecution, selectedCapabilityBatchExecution, pendingCapabilitySelection, pendingCapabilityBatchSelection, executionPending: capabilityExecutionPending, } = params.capabilitySelection;
@@ -12,6 +13,7 @@ export function prepareWorkerDecisionContract(params) {
     const sessionArtifactPathSelectionDeferred = !capabilityExecutionPending &&
         params.eligibleSessionArtifactPaths.length > 0 &&
         runtimePathSelectionWasDeferred(params.options.capabilitySource?.binding.capabilities, params.projectedCapabilities);
+    const capabilitySelectionRejectionPresent = params.options.capabilitySelectionRejection !== undefined;
     const capabilitySelectionRejection = !capabilityExecutionPending && params.options.capabilitySelectionRejection
         ? normalizeWorkerCapabilitySelectionRejection(params.options.capabilitySelectionRejection, params.projectedCapabilities.map(({ capabilityId }) => capabilityId))
         : undefined;
@@ -29,12 +31,14 @@ export function prepareWorkerDecisionContract(params) {
         selectedCapabilityExecution,
         selectedCapabilityBatchExecution,
     });
-    const allowedActions = Object.freeze([
-        WORKER_DECISION_ACTIONS[0],
-        WORKER_DECISION_ACTIONS[1],
-        ...(canInvokeSingleCapability ? [WORKER_DECISION_ACTIONS[2]] : []),
-        ...(canInvokeCapabilityBatch ? [WORKER_DECISION_ACTIONS[3]] : []),
-    ]);
+    const allowedActions = resolveWorkerDecisionAllowedActions({
+        capabilityExecutionPending,
+        capabilitySelectionRejectionPresent,
+        dependencyResultCount: params.dependencyResultCount,
+        requestToolResultCount: params.options.requestToolResults.results.length,
+        canInvokeSingleCapability,
+        canInvokeCapabilityBatch,
+    });
     const remainingCapabilityExecutions = params.canonicalSource
         ? params.canonicalSource.head.policy.limits.maxCapabilityExecutions -
             params.canonicalSource.head.state.capabilityExecutions.length
@@ -48,6 +52,8 @@ export function prepareWorkerDecisionContract(params) {
         capabilities,
         maxBatchCapabilityExecutions,
         allowSingleCapabilityInvocation: !selectedCapabilityBatchExecution,
+        allowReturnResult: allowedActions.includes(WORKER_DECISION_ACTIONS[0]),
+        allowReturnFailure: allowedActions.includes(WORKER_DECISION_ACTIONS[1]),
         ...(pendingCapabilitySelection ? { pendingCapabilitySelection } : {}),
         ...(pendingCapabilityBatchSelection
             ? {

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

@@ -1,9 +1,9 @@
-import { WORKER_DECISION_MODEL_STEP, } from "../contracts.js";
+import { CAPABILITY_CONTROLS_MODEL_STEP, WORKER_DECISION_MODEL_STEP, } from "../contracts.js";
 import { traceWorkerCapabilityResultProjected, traceWorkerContextProjected, } from "../diagnostics.js";
 import { WORKER_SESSION_ARTIFACT_PATH_PROJECTION_MAX } from "../runtime-path-refinement.js";
 export function traceWorkerDecisionInputProjection(session, assembly) {
     const { options, diagnostic, objective, sessionArtifactPathAvailableCount } = session;
-    const { assignmentScope, dependencyResults, resume } = session.canonicalState;
+    const { assignmentScope, assignmentProvenance, dependencyResults, resume } = session.canonicalState;
     const { capabilities, selectedCapabilityExecution, selectedCapabilityBatchExecution, executionPending: capabilityExecutionPending, } = session.capabilitySelection;
     const { availableCapabilityIds, availableCapabilityAffordances, capabilitiesAvailable, sessionArtifactPathSelectionDeferred, capabilitySelectionRejection, selectionCatalog, capabilityCatalogProjection, allowedActions, format, } = session.contract;
     const { requestToolResultsMessage, continuationMessages } = assembly.references;
@@ -45,7 +45,7 @@ export function traceWorkerDecisionInputProjection(session, assembly) {
         requestToolResultsProjectedCharacterCount: requestToolResultsMessage?.content.length ?? 0,
         dependencyResultRefs: dependencyResults.map((result) => result.resultRef),
         dependencyResultSummaryLength: dependencyResults.reduce((total, result) => total + result.summary.length, 0),
-        assignmentScope,
+        assignmentScope: assignmentProvenance ? undefined : assignmentScope,
         allowedActions,
         selectedCapabilityId: selectedCapabilityExecution?.capabilityId,
         selectedCapabilityIds: selectedCapabilityBatchExecution?.invocations.map(({ capabilityId }) => capabilityId),
@@ -78,13 +78,22 @@ export function resolveWorkerDecisionDiagnostic(requestId, options, callIdentity
         return options.diagnostic;
     return {
         requestId,
-        modelStep: WORKER_DECISION_MODEL_STEP,
-        decisionPhase: hasPendingCapabilityExecution(options)
-            ? "capability_execution"
-            : "capability_selection",
+        ...resolveWorkerDecisionPhase(options),
         ...callIdentity,
     };
 }
+function resolveWorkerDecisionPhase(options) {
+    if (hasPendingCapabilityExecution(options)) {
+        return {
+            modelStep: CAPABILITY_CONTROLS_MODEL_STEP,
+            decisionPhase: "capability_execution",
+        };
+    }
+    return {
+        modelStep: WORKER_DECISION_MODEL_STEP,
+        decisionPhase: "capability_selection",
+    };
+}
 function hasPendingCapabilityExecution(options) {
     return Boolean(options.selectedCapabilityExecution ||
         options.selectedCapabilityBatchExecution);

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

@@ -1,3 +1,4 @@
 import type { PreparedWorkerDecisionSession, PreparedWorkerPromptContext, PreparedWorkerReferenceContext, ProjectedWorkerDecisionContext } from "./types.js";
 export declare function prepareWorkerPromptContext(session: PreparedWorkerDecisionSession, references: PreparedWorkerReferenceContext): PreparedWorkerPromptContext;
 export declare function projectWorkerDecisionContext(session: PreparedWorkerDecisionSession, references: PreparedWorkerReferenceContext, promptContext: PreparedWorkerPromptContext): ProjectedWorkerDecisionContext;
+export declare function buildWorkerAssignmentPrompt(session: PreparedWorkerDecisionSession): string;

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

@@ -3,18 +3,17 @@ import { assessRequestMessagesBudget, projectRequestContext, } from "../../../co
 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 { dependencyResults, operationSupervision, resume } = session.canonicalState;
     const { selectedCapabilityExecution, selectedCapabilityBatchExecution, executionPending: capabilityExecutionPending, } = capabilitySelection;
-    const { capabilitiesAvailable, capabilitySelectionRejection, capabilityCatalogProjection, } = session.contract;
+    const { allowedActions, capabilitiesAvailable, capabilitySelectionRejection, capabilityCatalogProjection, } = session.contract;
     const { requestToolResultsMessage } = references;
     const budget = resolveModelContextBudget({
         runnerConfig: request.runnerConfig,
         agentMode: request.agentMode,
-        modelStep: WORKER_DECISION_MODEL_STEP,
+        modelStep: session.diagnostic.modelStep,
         ...(request.modelPreference
             ? { modelPreference: request.modelPreference }
             : {}),
@@ -26,6 +25,8 @@ export function prepareWorkerPromptContext(session, references) {
             selectedCapabilityBatchExecution: selectedCapabilityBatchExecution !== undefined,
             hasDependencyResults: dependencyResults.length > 0,
             hasRequestToolResults: requestToolResultsMessage !== undefined,
+            returnResultAvailable: allowedActions.includes("return_result"),
+            returnFailureAvailable: allowedActions.includes("return_failure"),
         })
         : buildWorkerDecisionInstructions({
             capabilitiesAvailable,
@@ -33,6 +34,7 @@ export function prepareWorkerPromptContext(session, references) {
             hasCapabilityResult: resume !== undefined,
             hasDependencyResults: dependencyResults.length > 0,
             hasRequestToolResults: options.requestToolResults.results.length > 0,
+            hasOperationSupervision: operationSupervision !== undefined,
             hasCapabilitySelectionRejection: capabilitySelectionRejection !== undefined,
             capabilityCatalogProjection,
         });
@@ -47,7 +49,7 @@ export function prepareWorkerPromptContext(session, references) {
     ].join("\n\n");
     const configuredInstructionMetadata = resolveConfiguredStepInstructionMetadata({
         runnerConfig: request.runnerConfig,
-        modelStep: WORKER_DECISION_MODEL_STEP,
+        modelStep: session.diagnostic.modelStep,
     });
     const prompt = buildWorkerAssignmentPrompt(session);
     return Object.freeze({
@@ -105,9 +107,9 @@ export function projectWorkerDecisionContext(session, references, promptContext)
         context,
     });
 }
-function buildWorkerAssignmentPrompt(session) {
+export function buildWorkerAssignmentPrompt(session) {
     const { callIdentity, objective, options } = session;
-    const { dependencyResults } = session.canonicalState;
+    const { dependencyResults, operationSupervision } = session.canonicalState;
     const { pendingCapabilitySelection, pendingCapabilityBatchSelection, executionPending: capabilityExecutionPending, } = session.capabilitySelection;
     const { availableCapabilityAffordances, capabilitiesAvailable, capabilityPromptPayload, capabilitySelectionRejection, } = session.contract;
     const identity = {
@@ -120,6 +122,7 @@ function buildWorkerAssignmentPrompt(session) {
             ? { workingDirectory: options.call.workingDirectory }
             : {}),
         ...(dependencyResults.length > 0 ? { dependencyResults } : {}),
+        ...(operationSupervision ? { operationSupervision } : {}),
     };
     if (capabilityExecutionPending) {
         return JSON.stringify({
@@ -150,6 +153,9 @@ function buildWorkerAssignmentPrompt(session) {
 function projectPendingCapabilityExecutionAssignment(pending) {
     return Object.freeze({
         capabilityId: pending.capabilityId,
+        ...(pending.authoringObjective
+            ? { authoringObjective: pending.authoringObjective }
+            : {}),
         ...(pending.selectionControls
             ? { selectionControls: pending.selectionControls }
             : {}),

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

@@ -1,48 +1,86 @@
 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 { isRequestToolResultsMessageBoundToView } from "../../../context/request-tool-results-message-binding.js";
+import { isRequestToolResultsViewValidForCallScope } from "../../../context/request-tool-results-scope.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";
+import { isWorkerCapabilityAssignmentProvenanceValid } from "../../../orchestration/worker-capabilities/index.js";
+import { projectWorkerPayloadDependencyResults } from "../payload-dependency-results.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
+    const { assignmentScope, assignmentProvenance, dependencyResults, operationSupervision, resume, } = canonicalState;
+    if (!isWorkerCapabilityAssignmentProvenanceValid(assignmentProvenance, options.call, request.requestId)) {
+        throw new Error("worker_assignment_provenance_receipt_invalid");
+    }
+    const planItemScoped = assignmentProvenance !== undefined;
+    if (!isRequestToolResultsViewValidForCallScope(options.requestToolResults, callIdentity.callId, planItemScoped)) {
+        throw new Error("worker_plan_item_tool_results_scope_invalid");
+    }
+    const requestSource = planItemScoped
+        ? undefined
+        : projectRequestSource({
+            requestId: request.requestId,
+            prompt: request.prompt,
+            modelStep: session.diagnostic.modelStep,
+            callId: callIdentity.callId,
+            historyMessages: request.historyMessages,
+        });
+    const requestToolResults = options.requestToolResults;
+    if (options.requestToolResultsContextMessage &&
+        !isRequestToolResultsMessageBoundToView(options.requestToolResultsContextMessage, requestToolResults)) {
+        throw new Error("worker_tool_results_message_binding_invalid");
+    }
+    const requestToolResultsMessage = requestToolResults.results.length > 0
         ? (options.requestToolResultsContextMessage ??
-            buildRequestToolResultsMessage(options.requestToolResults))
+            buildRequestToolResultsMessage(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 resultAuthorDependencyResults = projectWorkerPayloadDependencyResults(dependencyResults);
     const resultAuthorSource = Object.freeze({
         ...callIdentity,
         objective,
-        dependencyResults,
-        requestToolResults: options.requestToolResults,
+        ...(assignmentProvenance ? { assignmentProvenance } : {}),
+        dependencyResults: resultAuthorDependencyResults,
+        requestToolResults,
         ...(requestToolResultsMessage
             ? { requestToolResultsContextMessage: requestToolResultsMessage }
             : {}),
+        ...(operationSupervisionEvidenceMessage
+            ? {
+                operationSupervisionEvidenceContextMessage: operationSupervisionEvidenceMessage,
+            }
+            : {}),
     });
     const baseReferenceMessages = Object.freeze([
         ...(request.temporalContext
             ? [buildRequestTemporalContextMessage(request.temporalContext)]
             : []),
-        buildRequestSourceMessage(requestSource),
-        ...(assignmentScope
+        ...(requestSource ? [buildRequestSourceMessage(requestSource)] : []),
+        ...(assignmentScope && !planItemScoped
             ? [buildRoleCallAssignmentScopeMessage(assignmentScope)]
             : []),
         ...(!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,8 +5,8 @@ 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 { type WorkerCapabilityBinding, type WorkerCapabilityControls, type WorkerCapabilityDescriptor } from "../../../orchestration/worker-capabilities/index.js";
+import { projectRoleCallAssignmentScope, type RoleCallDependencyResult, type RoleCallFrame, type RoleCallLedger, type RoleCallLedgerHead, type RoleOperationSupervisionNotice } from "../../../orchestration/role-calls/index.js";
+import { type WorkerCapabilityBinding, type WorkerCapabilityAssignmentProvenance, 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";
@@ -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[];
@@ -68,8 +71,10 @@ export type PreparedWorkerCapabilitySelection = Readonly<{
 export type PreparedWorkerCanonicalState = Readonly<{
     canonicalSource: WorkerDecisionCapabilitySource | WorkerDecisionCapabilityResumeSource | undefined;
     assignmentScope: ReturnType<typeof projectRoleCallAssignmentScope> | undefined;
+    assignmentProvenance?: WorkerCapabilityAssignmentProvenance;
     dependencyResults: readonly RoleCallDependencyResult[];
     resume: ReturnType<typeof projectWorkerCapabilityResumeContext> | undefined;
+    operationSupervision: readonly RoleOperationSupervisionNotice[] | undefined;
 }>;
 export type PreparedWorkerDecisionContract = Readonly<{
     availableCapabilityIds: readonly string[];
@@ -98,6 +103,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,14 @@ 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 { projectWorkerPayloadDependencyInput } from "./payload-dependency-results.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,6 +1,6 @@
-import { WORKER_DECISION_MODEL_STEP, } from "./contracts.js";
 import { traceWorkerDecisionInputProjection } from "./input/diagnostic-projection.js";
 import { prepareWorkerDecisionAssembly, prepareWorkerDecisionSession, } from "./input/session.js";
+export { projectWorkerPayloadDependencyInput } from "./payload-dependency-results.js";
 export function buildWorkerDecisionInput(request, options) {
     const session = prepareWorkerDecisionSession(request, options);
     const assembly = prepareWorkerDecisionAssembly(session);
@@ -15,7 +15,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;