@abot-ai/runtime 1.0.0 → 1.1.0

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

@@ -1,8 +1,9 @@
 import { createStructuredDecisionEnvelopeSchema, structuredDecisionVariantSchemaPath, } from "../../model/structured-decision-envelope.js";
 import { isRoleCapabilityId } from "../../orchestration/role-calls/index.js";
-import { WORKER_CAPABILITY_COUNT_MAX, normalizeWorkerCapabilityControlsSchema, partitionWorkerCapabilityControlsSchema, validateWorkerCapabilitySelectionControls, } from "../../orchestration/worker-capabilities/index.js";
+import { WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH, WORKER_CAPABILITY_COUNT_MAX, canOfferWorkerCapabilityBatchSelection, normalizeWorkerCapabilityControlsSchema, partitionWorkerCapabilityControlsSchema, validateWorkerCapabilitySelectionControls, } from "../../orchestration/worker-capabilities/index.js";
 import { WORKER_CAPABILITY_INTENT_MAX_LENGTH, WORKER_RESULT_MAX_LENGTH, } from "./contracts.js";
 const WORKER_CAPABILITY_CLIENT_INTENT_DESCRIPTION = "Short client-facing statement of what will happen next. Presentation only; exclude sources, dependencies, controls, payload details, and execution instructions.";
+const WORKER_CAPABILITY_AUTHORING_OBJECTIVE_DESCRIPTION = "Complete bounded content-authoring assignment for this payload. It cannot change the selected capability, controls, target, or authority.";
 export function createWorkerDecisionFormat(options = {}) {
     if (options.capabilities !== undefined &&
         !Array.isArray(options.capabilities)) {
@@ -11,6 +12,8 @@ export function createWorkerDecisionFormat(options = {}) {
     const suppliedCapabilities = options.capabilities ?? [];
     const maxBatchCapabilityExecutions = options.maxBatchCapabilityExecutions ?? 0;
     const allowSingleCapabilityInvocation = options.allowSingleCapabilityInvocation !== false;
+    const allowReturnResult = options.allowReturnResult !== false;
+    const allowReturnFailure = options.allowReturnFailure !== false;
     const uniqueCapabilityIds = new Set(suppliedCapabilities.map((capability) => capability?.capabilityId));
     if (suppliedCapabilities.length > WORKER_CAPABILITY_COUNT_MAX ||
         uniqueCapabilityIds.size !== suppliedCapabilities.length ||
@@ -24,7 +27,9 @@ export function createWorkerDecisionFormat(options = {}) {
             !isRoleCapabilityId(capability.capabilityId) ||
             (capability.effect !== "observation" &&
                 capability.effect !== "mutation" &&
-                capability.effect !== "mixed")) {
+                capability.effect !== "mixed") ||
+            (capability.requiresPayloadAuthoringObjective !== undefined &&
+                capability.requiresPayloadAuthoringObjective !== true)) {
             throw new Error("worker_capabilities_invalid");
         }
         const controls = normalizeWorkerCapabilityControlsSchema(capability.controls);
@@ -40,6 +45,7 @@ export function createWorkerDecisionFormat(options = {}) {
             effect: capability.effect,
             controls: controls.value,
             controlsPartition: controlsPartition.value,
+            requiresPayloadAuthoringObjective: capability.requiresPayloadAuthoringObjective === true,
         });
     }));
     const batchCapabilities = capabilities.filter((capability) => capability.effect === "observation");
@@ -71,7 +77,13 @@ export function createWorkerDecisionFormat(options = {}) {
     const pendingSingleCapability = pendingCapabilitySelection
         ? capabilities.find(({ capabilityId }) => capabilityId === pendingCapabilitySelection.capabilityId)
         : undefined;
-    const batchEnabled = maxBatchCapabilityExecutions >= 2 && batchCapabilities.length > 0;
+    const batchEnabled = pendingCapabilityBatchSelection !== undefined ||
+        (decisionPhase === "capability_selection" &&
+            maxBatchCapabilityExecutions >= 2 &&
+            canOfferWorkerCapabilityBatchSelection(batchCapabilities.map((capability) => ({
+                capabilityId: capability.capabilityId,
+                selectionSchema: capability.controlsPartition.selectionSchema,
+            }))));
     const singleSelectionGroups = groupCapabilitiesBySelectionSchema(capabilities);
     const batchSelectionGroups = groupCapabilitiesBySelectionSchema(batchCapabilities);
     const singleCapabilityVariants = !allowSingleCapabilityInvocation
@@ -81,6 +93,11 @@ export function createWorkerDecisionFormat(options = {}) {
                 action: literal("invoke_capability"),
                 capabilityId: enumeration(group.capabilities.map(({ capabilityId }) => capabilityId)),
                 intent: capabilityIntentSelectionSchema(),
+                ...(group.requiresPayloadAuthoringObjective
+                    ? {
+                        authoringObjective: capabilityAuthoringObjectiveSelectionSchema(),
+                    }
+                    : {}),
                 ...(group.partition.selectionControlIds.length > 0
                     ? {
                         selectionControls: projectControlsSchema(group.partition.selectionSchema),
@@ -112,14 +129,30 @@ export function createWorkerDecisionFormat(options = {}) {
             maxItems: maxBatchCapabilityExecutions,
             items: projectCapabilitySelectionItemSchema(batchSelectionGroups),
         };
+    const returnResultVariants = allowReturnResult
+        ? [
+            exactObject({
+                action: literal("return_result"),
+            }),
+        ]
+        : [];
+    const returnFailureVariants = allowReturnFailure
+        ? [
+            exactObject({
+                action: literal("return_failure"),
+                reason: boundedText(WORKER_RESULT_MAX_LENGTH),
+            }),
+        ]
+        : [];
+    const singleCapabilityVariantCount = allowSingleCapabilityInvocation
+        ? singleCapabilityVariants.length
+        : 0;
+    const returnFailureVariantIndex = returnResultVariants.length;
+    const capabilityVariantStartIndex = returnResultVariants.length + returnFailureVariants.length;
+    const batchVariantIndex = capabilityVariantStartIndex + singleCapabilityVariantCount;
     const variants = [
-        exactObject({
-            action: literal("return_result"),
-        }),
-        exactObject({
-            action: literal("return_failure"),
-            reason: boundedText(WORKER_RESULT_MAX_LENGTH),
-        }),
+        ...returnResultVariants,
+        ...returnFailureVariants,
         ...singleCapabilityVariants,
         ...(batchEnabled
             ? [
@@ -130,32 +163,40 @@ export function createWorkerDecisionFormat(options = {}) {
             ]
             : []),
     ];
-    const singleCapabilityVariantCount = allowSingleCapabilityInvocation
-        ? singleCapabilityVariants.length
-        : 0;
-    const batchVariantIndex = singleCapabilityVariantCount + 2;
     return {
         type: "json_schema",
         name: "worker_decision",
         strict: true,
         postValidatedSchemaConstraints: [
-            {
-                keyword: "maxLength",
-                path: `${structuredDecisionVariantSchemaPath(1, variants.length)}/properties/reason/maxLength`,
-            },
+            ...(allowReturnFailure
+                ? [
+                    {
+                        keyword: "maxLength",
+                        path: `${structuredDecisionVariantSchemaPath(returnFailureVariantIndex, variants.length)}/properties/reason/maxLength`,
+                    },
+                ]
+                : []),
             ...(allowSingleCapabilityInvocation && singleCapabilityVariants.length > 0
                 ? decisionPhase === "capability_selection"
                     ? singleSelectionGroups.flatMap((group, index) => {
-                        const variantPath = structuredDecisionVariantSchemaPath(2 + index, variants.length);
+                        const variantPath = structuredDecisionVariantSchemaPath(capabilityVariantStartIndex + index, variants.length);
                         return [
                             {
                                 keyword: "maxLength",
                                 path: `${variantPath}/properties/intent/maxLength`,
                             },
+                            ...(group.requiresPayloadAuthoringObjective
+                                ? [
+                                    {
+                                        keyword: "maxLength",
+                                        path: `${variantPath}/properties/authoringObjective/maxLength`,
+                                    },
+                                ]
+                                : []),
                             ...collectControlMaxLengthConstraints(group.partition.selectionSchema, `${variantPath}/properties/selectionControls`),
                         ];
                     })
-                    : collectControlMaxLengthConstraints(pendingSingleCapability.controlsPartition.remainingSchema, `${structuredDecisionVariantSchemaPath(2, variants.length)}/properties/controls`)
+                    : collectControlMaxLengthConstraints(pendingSingleCapability.controlsPartition.remainingSchema, `${structuredDecisionVariantSchemaPath(capabilityVariantStartIndex, variants.length)}/properties/controls`)
                 : []),
             ...(batchEnabled
                 ? decisionPhase === "capability_selection"
@@ -183,7 +224,11 @@ function validPendingSelection(pending, capabilities) {
     if (!capability)
         return false;
     const expectsSelectionControls = capability.controlsPartition.selectionControlIds.length > 0;
-    if (Object.hasOwn(pending, "selectionControls") !== expectsSelectionControls) {
+    if (Object.hasOwn(pending, "selectionControls") !== expectsSelectionControls ||
+        Object.hasOwn(pending, "authoringObjective") !==
+            capability.requiresPayloadAuthoringObjective ||
+        (capability.requiresPayloadAuthoringObjective &&
+            !validAuthoringObjective(pending.authoringObjective))) {
         return false;
     }
     return validateWorkerCapabilitySelectionControls(capability.controlsPartition, pending.selectionControls ?? {}).ok;
@@ -191,10 +236,14 @@ function validPendingSelection(pending, capabilities) {
 function groupCapabilitiesBySelectionSchema(capabilities) {
     const groups = new Map();
     for (const capability of capabilities) {
-        const signature = JSON.stringify(capability.controlsPartition.selectionSchema);
+        const signature = JSON.stringify({
+            selectionSchema: capability.controlsPartition.selectionSchema,
+            requiresPayloadAuthoringObjective: capability.requiresPayloadAuthoringObjective,
+        });
         const group = groups.get(signature) ?? {
             capabilities: [],
             partition: capability.controlsPartition,
+            requiresPayloadAuthoringObjective: capability.requiresPayloadAuthoringObjective,
         };
         group.capabilities.push(capability);
         groups.set(signature, group);
@@ -202,12 +251,18 @@ function groupCapabilitiesBySelectionSchema(capabilities) {
     return Object.freeze([...groups.values()].map((group) => Object.freeze({
         capabilities: Object.freeze([...group.capabilities]),
         partition: group.partition,
+        requiresPayloadAuthoringObjective: group.requiresPayloadAuthoringObjective,
     })));
 }
 function projectCapabilitySelectionItemSchema(groups) {
     const variants = groups.map((group) => exactObject({
         capabilityId: enumeration(group.capabilities.map(({ capabilityId }) => capabilityId)),
         intent: capabilityIntentSelectionSchema(),
+        ...(group.requiresPayloadAuthoringObjective
+            ? {
+                authoringObjective: capabilityAuthoringObjectiveSelectionSchema(),
+            }
+            : {}),
         ...(group.partition.selectionControlIds.length > 0
             ? {
                 selectionControls: projectControlsSchema(group.partition.selectionSchema),
@@ -226,6 +281,14 @@ function collectBatchSelectionMaxLengthConstraints(params) {
                 keyword: "maxLength",
                 path: `${itemPath}/properties/intent/maxLength`,
             },
+            ...(group.requiresPayloadAuthoringObjective
+                ? [
+                    {
+                        keyword: "maxLength",
+                        path: `${itemPath}/properties/authoringObjective/maxLength`,
+                    },
+                ]
+                : []),
             ...collectControlMaxLengthConstraints(group.partition.selectionSchema, `${itemPath}/properties/selectionControls`),
         ];
     });
@@ -252,6 +315,18 @@ function capabilityIntentSelectionSchema() {
         description: WORKER_CAPABILITY_CLIENT_INTENT_DESCRIPTION,
     };
 }
+function capabilityAuthoringObjectiveSelectionSchema() {
+    return {
+        ...boundedText(WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH),
+        description: WORKER_CAPABILITY_AUTHORING_OBJECTIVE_DESCRIPTION,
+    };
+}
+function validAuthoringObjective(value) {
+    return (typeof value === "string" &&
+        value.trim() === value &&
+        value.length > 0 &&
+        value.length <= WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH);
+}
 function projectControlSchema(control) {
     if (control.type === "array") {
         return {

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

@@ -0,0 +1,9 @@
+import { type WorkerDecision } from "../contracts.js";
+export declare function resolveWorkerDecisionAllowedActions(params: Readonly<{
+    capabilityExecutionPending: boolean;
+    capabilitySelectionRejectionPresent: boolean;
+    dependencyResultCount: number;
+    requestToolResultCount: number;
+    canInvokeSingleCapability: boolean;
+    canInvokeCapabilityBatch: boolean;
+}>): readonly WorkerDecision["action"][];

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

@@ -0,0 +1,15 @@
+import { WORKER_DECISION_ACTIONS } from "../contracts.js";
+export function resolveWorkerDecisionAllowedActions(params) {
+    const capabilitySelectionIsReconsidering = params.capabilitySelectionRejectionPresent &&
+        !params.capabilityExecutionPending;
+    const capabilityExecutionWasReaffirmed = params.capabilitySelectionRejectionPresent &&
+        params.capabilityExecutionPending;
+    const canReturnResult = !params.capabilityExecutionPending && !capabilitySelectionIsReconsidering;
+    const canReturnFailure = !capabilityExecutionWasReaffirmed;
+    return Object.freeze([
+        ...(canReturnResult ? [WORKER_DECISION_ACTIONS[0]] : []),
+        ...(canReturnFailure ? [WORKER_DECISION_ACTIONS[1]] : []),
+        ...(params.canInvokeSingleCapability ? [WORKER_DECISION_ACTIONS[2]] : []),
+        ...(params.canInvokeCapabilityBatch ? [WORKER_DECISION_ACTIONS[3]] : []),
+    ]);
+}

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

@@ -1,9 +1,9 @@
 import { type RoleCallFrame, type RoleCallLedger } from "../../../orchestration/role-calls/index.js";
 import { type WorkerCapabilityDescriptor } from "../../../orchestration/worker-capabilities/index.js";
 import type { RequestExecutionSeed } from "../../../request/contracts.js";
-import { projectWorkerDecisionCallIdentity } from "../contracts.js";
+import { projectWorkerDecisionCallIdentity, type WorkerDecisionDiagnosticContext } from "../contracts.js";
 import type { PreparedWorkerCanonicalState, WorkerDecisionCapabilityBinding, WorkerDecisionCapabilityResumeSource, WorkerDecisionCapabilitySource, WorkerDecisionInputOptions } from "./types.js";
-export declare function prepareWorkerCanonicalState(request: Pick<RequestExecutionSeed, "requestId" | "prompt"> & Partial<Pick<RequestExecutionSeed, "contextCompactionStore">>, options: WorkerDecisionInputOptions, callIdentity: ReturnType<typeof projectWorkerDecisionCallIdentity>): PreparedWorkerCanonicalState;
+export declare function prepareWorkerCanonicalState(request: Pick<RequestExecutionSeed, "requestId" | "prompt"> & Partial<Pick<RequestExecutionSeed, "contextCompactionStore">>, options: WorkerDecisionInputOptions, callIdentity: ReturnType<typeof projectWorkerDecisionCallIdentity>, modelStep: WorkerDecisionDiagnosticContext["modelStep"], capabilityExecutionPending: boolean): PreparedWorkerCanonicalState;
 export declare function projectCapabilities(params: Readonly<{
     requestId: string;
     call: RoleCallFrame;

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

@@ -1,17 +1,16 @@
 import { isToolCatalogGroupId, } from "../../../../capabilities/tool-types.js";
-import { isRoleCapabilityId, projectRoleCallAssignmentScope, } from "../../../orchestration/role-calls/index.js";
+import { isRoleCapabilityId, projectRoleCallAssignmentScope, projectImmediateRoleOperationSupervisionNotices, } from "../../../orchestration/role-calls/index.js";
 import { WORKER_CAPABILITY_COUNT_MAX, WORKER_CAPABILITY_SUMMARY_MAX_LENGTH, normalizeWorkerCapabilityControlsSchema, partitionWorkerCapabilityControlsSchema, } from "../../../orchestration/worker-capabilities/index.js";
 import { projectSemanticCompactionDependencyResults } from "../../../context/semantic-compaction/index.js";
 import { projectWorkerCapabilityResumeContext } from "../ledger-projection.js";
-import { WORKER_DECISION_MODEL_STEP, } from "../contracts.js";
 import { projectEffectiveWorkerSelectionControlIds } from "../runtime-path-refinement.js";
-export function prepareWorkerCanonicalState(request, options, callIdentity) {
+export function prepareWorkerCanonicalState(request, options, callIdentity, modelStep, capabilityExecutionPending) {
     const canonicalSource = options.capabilitySource ?? options.capabilityResume;
     const assignmentScope = canonicalSource
         ? projectRoleCallAssignmentScope({
             head: canonicalSource.head,
             call: options.call,
-            modelStep: WORKER_DECISION_MODEL_STEP,
+            modelStep,
         })
         : undefined;
     const dependencyResults = canonicalSource
@@ -20,7 +19,7 @@ export function prepareWorkerCanonicalState(request, options, callIdentity) {
             prompt: request.prompt,
             head: canonicalSource.head,
             call: options.call,
-            consumer: WORKER_DECISION_MODEL_STEP,
+            consumer: modelStep,
             ...(request.contextCompactionStore
                 ? { store: request.contextCompactionStore }
                 : {}),
@@ -37,13 +36,20 @@ export function prepareWorkerCanonicalState(request, options, callIdentity) {
     if (resume !== undefined && resume.requestId !== request.requestId) {
         throw new Error("worker_capability_resume_request_mismatch");
     }
+    const operationSupervision = shouldProjectWorkerOperationSupervision(canonicalSource, capabilityExecutionPending)
+        ? projectImmediateRoleOperationSupervisionNotices(canonicalSource.head, options.call)
+        : Object.freeze([]);
     return Object.freeze({
         canonicalSource,
         assignmentScope,
         dependencyResults,
         resume,
+        operationSupervision: operationSupervision.length > 0 ? operationSupervision : undefined,
     });
 }
+function shouldProjectWorkerOperationSupervision(canonicalSource, capabilityExecutionPending) {
+    return canonicalSource !== undefined && !capabilityExecutionPending;
+}
 function hasBatchCapabilityResume(source) {
     return "executionIds" in source;
 }
@@ -76,7 +82,7 @@ export function projectCapabilities(params) {
             descriptor === null ||
             !Object.isFrozen(descriptor) ||
             descriptorKeys.length < 5 ||
-            descriptorKeys.length > 8 ||
+            descriptorKeys.length > 9 ||
             descriptorKeys.some((key) => key !== "capabilityId" &&
                 key !== "summary" &&
                 key !== "effect" &&
@@ -84,7 +90,8 @@ export function projectCapabilities(params) {
                 key !== "selectionControlIds" &&
                 key !== "runtimePathControlIds" &&
                 key !== "controlsRefinement" &&
-                key !== "catalogGroups") ||
+                key !== "catalogGroups" &&
+                key !== "requiresPayloadAuthoringObjective") ||
             !isRoleCapabilityId(descriptor.capabilityId) ||
             seen.has(descriptor.capabilityId) ||
             typeof descriptor.summary !== "string" ||
@@ -95,6 +102,8 @@ export function projectCapabilities(params) {
                 descriptor.effect !== "mixed") ||
             (descriptor.controlsRefinement !== undefined &&
                 descriptor.controlsRefinement !== "mechanical_when_complete") ||
+            (descriptor.requiresPayloadAuthoringObjective !== undefined &&
+                descriptor.requiresPayloadAuthoringObjective !== true) ||
             !Array.isArray(descriptor.catalogGroups) ||
             descriptor.catalogGroups.length === 0 ||
             descriptor.catalogGroups.some((groupId) => !isToolCatalogGroupId(groupId)) ||
@@ -137,6 +146,9 @@ export function projectCapabilities(params) {
             ...(descriptor.controlsRefinement
                 ? { controlsRefinement: descriptor.controlsRefinement }
                 : {}),
+            ...(descriptor.requiresPayloadAuthoringObjective
+                ? { requiresPayloadAuthoringObjective: true }
+                : {}),
             catalogGroups: Object.freeze([...descriptor.catalogGroups]),
         });
     });

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,4 +1,4 @@
-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) {
@@ -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.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({
@@ -107,7 +109,7 @@ export function projectWorkerDecisionContext(session, references, promptContext)
 }
 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({