@abot-ai/runtime 1.0.0 → 1.2.0

package/dist/src/runtime/steps/supervisor-response/run.js

@@ -3,17 +3,39 @@ import { createModelStepCompactionController } from "../../context/model-step-co
 import { createSessionMemoryAwareCompactionController } from "../../context/session-memory/index.js";
 import { SUPERVISOR_RESPONSE_MODEL_STEP, } from "./contracts.js";
 import { traceSupervisorResponseModelCompleted, traceSupervisorResponseModelFailed, traceSupervisorResponseModelStarted, } from "./diagnostics.js";
-import { buildSupervisorResponseInput } from "./input.js";
+import { buildSupervisorMemoryAuthoringInput, buildSupervisorResponseInput, } from "./input.js";
 import { buildSupervisorResponseRepairHint } from "./prompt.js";
 import { SUPERVISOR_DECISION_MODEL_STEP } from "../supervisor-decision/contracts.js";
+import { retrieveResponseLongTermMemory } from "../../long-term-memory/response-context.js";
+import { authorSupervisorMemoryCandidates } from "./memory-authoring.js";
 const SUPERVISOR_RESPONSE_MAX_REPAIR_ATTEMPTS = 1;
 export async function runSupervisorResponse(request, options) {
+    const authored = await runSupervisorAuthoredResponse(request, options);
+    return authored.finalResponse;
+}
+export async function runSupervisorAuthoredResponse(request, options) {
+    const memoryEnabled = request.longTermMemory?.enabled === true;
+    const memoryMessage = memoryEnabled && options.steeringSnapshot
+        ? await retrieveResponseLongTermMemory(request, options.steeringSnapshot)
+        : undefined;
+    const inputOptions = {
+        ...options,
+        ...(memoryMessage ? { longTermMemoryMessage: memoryMessage } : {}),
+    };
+    const memoryCandidates = memoryEnabled
+        ? await authorSupervisorMemoryCandidates({
+            request,
+            messages: buildSupervisorMemoryAuthoringInput(request, inputOptions)
+                .context.messages,
+            contextCompaction: createSupervisorResponseCompaction(request, options),
+        })
+        : Object.freeze([]);
+    const input = buildSupervisorResponseInput(request, inputOptions);
     const diagnostic = {
         requestId: request.requestId,
         modelStep: SUPERVISOR_RESPONSE_MODEL_STEP,
         ...options.call,
     };
-    const input = buildSupervisorResponseInput(request, options);
     const startedAt = Date.now();
     traceSupervisorResponseModelStarted({
         diagnostic,
@@ -21,33 +43,26 @@ export async function runSupervisorResponse(request, options) {
         messageCharacterCount: input.context.messages.reduce((total, message) => total + message.content.length, 0),
     });
     try {
-        const output = await invokeRepairableRawModelStep({
+        const finalResponse = await invokeRepairableRawModelStep({
             request,
             modelStep: input.modelStep,
             messages: input.context.messages,
-            contextCompaction: createSessionMemoryAwareCompactionController(request, createModelStepCompactionController(request, {
-                call: {
-                    roleId: "supervisor",
-                    callId: options.call.callId,
-                    objective: request.prompt,
-                },
-                sourceRevision: options.toolResults.sourceRevision,
-                allowedConsumers: Object.freeze([
-                    SUPERVISOR_DECISION_MODEL_STEP,
-                    SUPERVISOR_RESPONSE_MODEL_STEP,
-                ]),
-            })),
+            contextCompaction: createSupervisorResponseCompaction(request, options),
             timeoutReason: "supervisor_response_timeout",
             maxRepairAttempts: SUPERVISOR_RESPONSE_MAX_REPAIR_ATTEMPTS,
             validate: validateSupervisorResponse,
             buildRepairHint: buildSupervisorResponseRepairHint,
         });
+        const authored = Object.freeze({
+            finalResponse,
+            memoryCandidates,
+        });
         traceSupervisorResponseModelCompleted({
             diagnostic,
             durationMs: Date.now() - startedAt,
-            outputLength: output.length,
+            outputLength: authored.finalResponse.length,
         });
-        return output;
+        return authored;
     }
     catch (error) {
         traceSupervisorResponseModelFailed({
@@ -58,6 +73,20 @@ export async function runSupervisorResponse(request, options) {
         throw error;
     }
 }
+function createSupervisorResponseCompaction(request, options) {
+    return createSessionMemoryAwareCompactionController(request, createModelStepCompactionController(request, {
+        call: {
+            roleId: "supervisor",
+            callId: options.call.callId,
+            objective: request.prompt,
+        },
+        sourceRevision: options.toolResults.sourceRevision,
+        allowedConsumers: Object.freeze([
+            SUPERVISOR_DECISION_MODEL_STEP,
+            SUPERVISOR_RESPONSE_MODEL_STEP,
+        ]),
+    }));
+}
 function validateSupervisorResponse(text) {
     const response = text.trim();
     const internalEnvelope = response

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

@@ -1,10 +1,13 @@
 import type { ChatMessage } from "../../../model-gateway/types.js";
 import type { RequestToolResultsView } from "../../context/request-tool-results.js";
 import { type RoleCallFrame, type RoleCallDependencyResult } from "../../orchestration/role-calls/index.js";
-import type { WorkerCapabilityControls, WorkerCapabilityInvocation, WorkerSettledCapabilityResult } from "../../orchestration/worker-capabilities/index.js";
+import type { WorkerCapabilityControls, WorkerCapabilityAssignmentProvenance, WorkerCapabilityInvocation, WorkerSettledCapabilityResult } from "../../orchestration/worker-capabilities/index.js";
+import { CAPABILITY_CONTROLS_MODEL_STEP } from "../../orchestration/worker-capabilities/index.js";
 export { WORKER_CAPABILITY_INTENT_MAX_LENGTH } from "../../orchestration/worker-capabilities/index.js";
+export { WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH } from "../../orchestration/worker-capabilities/index.js";
 export declare const WORKER_DECISION_MODEL_STEP: "worker.decision";
 export declare const WORKER_RESULT_MODEL_STEP: "worker.result";
+export { CAPABILITY_CONTROLS_MODEL_STEP };
 export declare const WORKER_ROLE_ID: "worker";
 export declare const WORKER_RESULT_MAX_LENGTH = 8192;
 export declare const WORKER_DECISION_ACTIONS: readonly ["return_result", "return_failure", "invoke_capability", "invoke_capabilities"];
@@ -25,12 +28,14 @@ export type WorkerInvokeCapabilityDecision = Readonly<{
     action: "invoke_capability";
     capabilityId: string;
     intent: string;
+    authoringObjective?: string;
     controls: WorkerCapabilityControls;
 }>;
 export type WorkerInvokeCapabilitySelection = Readonly<{
     action: "invoke_capability";
     capabilityId: string;
     intent: string;
+    authoringObjective?: string;
     selectionControls?: WorkerCapabilityControls;
 }>;
 export type WorkerInvokeCapabilitiesDecision = Readonly<{
@@ -42,6 +47,7 @@ export type WorkerInvokeCapabilitiesSelection = Readonly<{
     invocations: readonly Readonly<{
         capabilityId: string;
         intent: string;
+        authoringObjective?: string;
         selectionControls?: WorkerCapabilityControls;
     }>[];
 }>;
@@ -80,13 +86,15 @@ export type WorkerDecisionCallIdentity = Readonly<{
 }>;
 export type WorkerResultAuthorSource = WorkerDecisionCallIdentity & Readonly<{
     objective: string;
+    assignmentProvenance?: WorkerCapabilityAssignmentProvenance;
     dependencyResults: readonly RoleCallDependencyResult[];
     requestToolResults: RequestToolResultsView;
     requestToolResultsContextMessage?: ChatMessage;
+    operationSupervisionEvidenceContextMessage?: ChatMessage;
 }>;
 export type WorkerDecisionDiagnosticContext = Readonly<{
     requestId: string;
-    modelStep: typeof WORKER_DECISION_MODEL_STEP;
+    modelStep: typeof WORKER_DECISION_MODEL_STEP | typeof CAPABILITY_CONTROLS_MODEL_STEP;
     decisionPhase: WorkerDecisionPhase;
 }> & WorkerDecisionCallIdentity;
 export declare function projectWorkerDecisionCallIdentity(call: RoleCallFrame): WorkerDecisionCallIdentity;

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

@@ -1,8 +1,11 @@
 import { MODEL_STEPS } from "../../../shared/model-steps.js";
 import { ROLE_CALL_RESULT_MAX_LENGTH, } from "../../orchestration/role-calls/index.js";
+import { CAPABILITY_CONTROLS_MODEL_STEP } from "../../orchestration/worker-capabilities/index.js";
 export { WORKER_CAPABILITY_INTENT_MAX_LENGTH } from "../../orchestration/worker-capabilities/index.js";
+export { WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH } from "../../orchestration/worker-capabilities/index.js";
 export const WORKER_DECISION_MODEL_STEP = MODEL_STEPS.WORKER_DECISION;
 export const WORKER_RESULT_MODEL_STEP = MODEL_STEPS.WORKER_RESULT;
+export { CAPABILITY_CONTROLS_MODEL_STEP };
 export const WORKER_ROLE_ID = "worker";
 export const WORKER_RESULT_MAX_LENGTH = ROLE_CALL_RESULT_MAX_LENGTH;
 export const WORKER_DECISION_ACTIONS = Object.freeze([

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

@@ -4,14 +4,18 @@ export declare function createWorkerDecisionFormat(options?: Readonly<{
     capabilities?: readonly WorkerCapabilityDescriptor[];
     maxBatchCapabilityExecutions?: number;
     allowSingleCapabilityInvocation?: boolean;
+    allowReturnResult?: boolean;
+    allowReturnFailure?: boolean;
     pendingCapabilitySelection?: Readonly<{
         capabilityId: string;
         intent: string;
+        authoringObjective?: string;
         selectionControls?: WorkerCapabilityControls;
     }>;
     pendingCapabilityBatchSelection?: readonly Readonly<{
         capabilityId: string;
         intent: string;
+        authoringObjective?: string;
         selectionControls?: WorkerCapabilityControls;
     }>[];
 }>): ModelGatewayJsonSchemaFormat;

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,22 @@
 import { isToolCatalogGroupId, } from "../../../../capabilities/tool-types.js";
-import { isRoleCapabilityId, projectRoleCallAssignmentScope, } 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 { isRoleCapabilityId, projectRoleCallAssignmentScope, projectImmediateRoleOperationSupervisionNotices, } from "../../../orchestration/role-calls/index.js";
+import { WORKER_CAPABILITY_COUNT_MAX, WORKER_CAPABILITY_SUMMARY_MAX_LENGTH, normalizeWorkerCapabilityControlsSchema, partitionWorkerCapabilityControlsSchema, projectWorkerCapabilityAssignmentProvenance, } 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 assignmentProvenance = canonicalSource
+        ? projectWorkerCapabilityAssignmentProvenance({
+            head: canonicalSource.head,
+            call: options.call,
         })
         : undefined;
     const dependencyResults = canonicalSource
@@ -20,7 +25,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 +42,21 @@ 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,
+        ...(assignmentProvenance ? { assignmentProvenance } : {}),
         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 +89,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 +97,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 +109,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 +153,9 @@ export function projectCapabilities(params) {
             ...(descriptor.controlsRefinement
                 ? { controlsRefinement: descriptor.controlsRefinement }
                 : {}),
+            ...(descriptor.requiresPayloadAuthoringObjective
+                ? { requiresPayloadAuthoringObjective: true }
+                : {}),
             catalogGroups: Object.freeze([...descriptor.catalogGroups]),
         });
     });