@abot-ai/runtime 1.0.0 → 1.1.0

package/dist/src/runtime/orchestration/worker-capabilities/execution.js

@@ -1,56 +1,25 @@
-import { ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH, ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX, ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH, ROLE_CALL_RESULT_MAX_LENGTH, resolveRoleCallTransactions, } from "../role-calls/index.js";
-import { traceWorkerCapabilityContextProjected, traceWorkerCapabilityContextRejected, traceWorkerCapabilityExecutionCompleted, traceWorkerCapabilityExecutionFailed, traceWorkerCapabilityExecutionStarted, traceWorkerCapabilityResultRejected, traceWorkerCapabilityStateRejected, } from "./diagnostics.js";
-import { projectWorkerSettledCapabilityResults } from "./settled-results.js";
-import { assertWorkerCapabilityWithinScope, WorkerCapabilityScopeError, } from "./scope.js";
-import { captureLegacyCapabilityAdapterResult, normalizeCapabilityAdapterResult, } from "../capability-adapters/result.js";
-const TECHNICAL_EXECUTION_FAILURE_SUMMARY = "The capability failed before returning a valid result.";
-const INVALID_EXECUTION_RESULT_SUMMARY = "The capability returned an invalid result.";
-const OVERSIZED_EXECUTION_RESULT_SUMMARY = "The capability result exceeded the Runtime evidence size limit.";
+import { assertExecutionCapabilityScope, projectExecutionSettledCapabilityResults, } from "./execution/context-projection.js";
+import { createPreparationId, deduplicatePreparedInvocations, prepareBoundInvocation, } from "./execution/invocation-preparation.js";
+import { beginAndSettlePreparedBatch, beginAndSettlePreparedSingle, } from "./execution/ledger-transaction.js";
 export async function executeBoundWorkerCapability(params) {
     assertExecutionCapabilityScope(params.capabilityScope, params.adapter.descriptor, params.diagnostic);
-    let settledCapabilityResults;
-    try {
-        settledCapabilityResults = projectWorkerSettledCapabilityResults({
-            ledger: params.ledger,
-            head: params.currentHead,
-            call: params.call,
-        });
-    }
-    catch (error) {
-        const issueCode = settledResultProjectionIssueCode(error);
-        traceWorkerCapabilityContextRejected(params.diagnostic, params.adapter.descriptor, issueCode);
-        throw new Error(`worker_capability_context_rejected:${issueCode}`);
-    }
-    traceWorkerCapabilityContextProjected(params.diagnostic, params.adapter.descriptor, settledCapabilityResults);
-    const transactions = resolveRoleCallTransactions(params.ledger);
-    const begunResult = await transactions.beginCapabilityExecution({
-        expectedHead: params.currentHead,
-        callId: params.call.callId,
-        invocationAttempt: params.call.activationCount,
-        capabilityId: params.adapter.descriptor.capabilityId,
-        declaredEffect: params.adapter.descriptor.effect,
-        intent: params.intent,
-        controlsJson: JSON.stringify(params.controls),
+    const settledCapabilityResults = projectExecutionSettledCapabilityResults({
+        ledger: params.ledger,
+        head: params.currentHead,
+        call: params.call,
+        descriptors: [params.adapter.descriptor],
+        diagnostic: params.diagnostic,
     });
-    if (!begunResult.ok) {
-        traceWorkerCapabilityStateRejected(params.diagnostic, params.adapter.descriptor, {
-            phase: "begin",
-            issueCode: begunResult.issueCode,
-        });
-        throw stateRejection("begin", begunResult.issueCode);
-    }
-    const begun = begunResult.commit;
-    const executionId = begun.effect.executionId;
-    traceWorkerCapabilityExecutionStarted(params.diagnostic, params.adapter.descriptor, executionId, params.intent.length, Object.keys(params.controls).length);
-    const result = await executeAndNormalizeAdapter({
+    const prepared = await prepareBoundInvocation({
         context: params.context,
         call: params.call,
-        execute: params.adapter.execute,
+        adapter: params.adapter,
         intent: params.intent,
+        ...(params.authoringObjective
+            ? { authoringObjective: params.authoringObjective }
+            : {}),
         controls: params.controls,
-        descriptor: params.adapter.descriptor,
-        diagnostic: params.diagnostic,
-        executionId,
+        preparationId: createPreparationId(params.call, 0),
         settledCapabilityResults,
         ...(params.dependencyResults
             ? { dependencyResults: params.dependencyResults }
@@ -59,342 +28,100 @@ export async function executeBoundWorkerCapability(params) {
             ? { executionFreshness: params.executionFreshness }
             : {}),
     });
-    const settledResult = await transactions.settleCapabilityExecution({
-        expectedHead: begun.head,
-        callId: params.call.callId,
-        executionId,
-        outcome: result.outcome,
-        observedEffect: result.observedEffect,
-        summary: result.summary,
-        ...(result.referenceData ? { referenceData: result.referenceData } : {}),
-        ...(result.references ? { references: result.references } : {}),
-        exactResult: result.exactResult,
+    return beginAndSettlePreparedSingle({
+        currentHead: params.currentHead,
+        ledger: params.ledger,
+        call: params.call,
+        invocation: Object.freeze({
+            adapter: params.adapter,
+            intent: params.intent,
+            ...(params.authoringObjective
+                ? { authoringObjective: params.authoringObjective }
+                : {}),
+            controls: params.controls,
+            prepared,
+        }),
+        diagnostic: params.diagnostic,
+        ...(params.executionFreshness
+            ? { executionFreshness: params.executionFreshness }
+            : {}),
     });
-    if (!settledResult.ok) {
-        traceWorkerCapabilityStateRejected(params.diagnostic, params.adapter.descriptor, {
-            phase: "settle",
-            issueCode: settledResult.issueCode,
-            executionId,
-        });
-        throw stateRejection("settle", settledResult.issueCode);
-    }
-    traceWorkerCapabilityExecutionCompleted(params.diagnostic, params.adapter.descriptor, result, executionId);
-    return Object.freeze({ executionId });
 }
 export async function executeBoundWorkerCapabilityBatch(params) {
-    if (params.invocations.length < 2 ||
-        params.invocations.some(({ adapter }) => adapter.descriptor.effect !== "observation")) {
+    if (!isExecutableObservationBatch(params.invocations)) {
         throw new Error("worker_capability_batch_invalid");
     }
     for (const { adapter } of params.invocations) {
         assertExecutionCapabilityScope(params.capabilityScope, adapter.descriptor, params.diagnostic);
     }
-    let settledCapabilityResults;
-    try {
-        settledCapabilityResults = projectWorkerSettledCapabilityResults({
-            ledger: params.ledger,
-            head: params.currentHead,
-            call: params.call,
-        });
-    }
-    catch (error) {
-        const issueCode = settledResultProjectionIssueCode(error);
-        for (const { adapter } of params.invocations) {
-            traceWorkerCapabilityContextRejected(params.diagnostic, adapter.descriptor, issueCode);
-        }
-        throw new Error(`worker_capability_context_rejected:${issueCode}`);
-    }
-    for (const { adapter } of params.invocations) {
-        traceWorkerCapabilityContextProjected(params.diagnostic, adapter.descriptor, settledCapabilityResults);
-    }
-    const transactions = resolveRoleCallTransactions(params.ledger);
-    const begunResult = await transactions.beginCapabilityBatch({
-        expectedHead: params.currentHead,
-        callId: params.call.callId,
-        invocationAttempt: params.call.activationCount,
-        entries: params.invocations.map(({ adapter, intent, controls }) => ({
-            capabilityId: adapter.descriptor.capabilityId,
-            declaredEffect: "observation",
-            intent,
-            controlsJson: JSON.stringify(controls),
-        })),
-    });
-    if (!begunResult.ok) {
-        for (const { adapter } of params.invocations) {
-            traceWorkerCapabilityStateRejected(params.diagnostic, adapter.descriptor, { phase: "begin", issueCode: begunResult.issueCode });
-        }
-        throw stateRejection("begin", begunResult.issueCode);
-    }
-    const begun = begunResult.commit;
-    const executionIds = begun.effect.executionIds;
-    params.invocations.forEach((invocation, index) => {
-        traceWorkerCapabilityExecutionStarted(params.diagnostic, invocation.adapter.descriptor, executionIds[index], invocation.intent.length, Object.keys(invocation.controls).length);
-    });
-    const results = await Promise.all(params.invocations.map((invocation, index) => executeAndNormalizeAdapter({
-        context: params.context,
+    const settledCapabilityResults = projectExecutionSettledCapabilityResults({
+        ledger: params.ledger,
+        head: params.currentHead,
         call: params.call,
-        execute: invocation.adapter.execute,
-        intent: invocation.intent,
-        controls: invocation.controls,
-        descriptor: invocation.adapter.descriptor,
+        descriptors: params.invocations.map(({ adapter }) => adapter.descriptor),
         diagnostic: params.diagnostic,
-        executionId: executionIds[index],
-        settledCapabilityResults,
-        ...(params.dependencyResults
-            ? { dependencyResults: params.dependencyResults }
-            : {}),
-        ...(params.executionFreshness
-            ? { executionFreshness: params.executionFreshness }
-            : {}),
-    })));
-    const settledResult = await transactions.settleCapabilityBatch({
-        expectedHead: begun.head,
-        callId: params.call.callId,
-        settlements: results.map((result, index) => ({
-            executionId: executionIds[index],
-            outcome: result.outcome,
-            observedEffect: result.observedEffect,
-            summary: result.summary,
-            ...(result.referenceData ? { referenceData: result.referenceData } : {}),
-            ...(result.references ? { references: result.references } : {}),
-            exactResult: result.exactResult,
-        })),
     });
-    if (!settledResult.ok) {
-        params.invocations.forEach((invocation, index) => {
-            traceWorkerCapabilityStateRejected(params.diagnostic, invocation.adapter.descriptor, {
-                phase: "settle",
-                issueCode: settledResult.issueCode,
-                executionId: executionIds[index],
-            });
-        });
-        throw stateRejection("settle", settledResult.issueCode);
-    }
-    params.invocations.forEach((invocation, index) => {
-        traceWorkerCapabilityExecutionCompleted(params.diagnostic, invocation.adapter.descriptor, results[index], executionIds[index]);
-    });
-    return Object.freeze({ executionIds: Object.freeze([...executionIds]) });
-}
-function assertExecutionCapabilityScope(projection, descriptor, diagnostic) {
-    try {
-        assertWorkerCapabilityWithinScope(projection, descriptor);
-    }
-    catch (error) {
-        const issueCode = error instanceof WorkerCapabilityScopeError
-            ? error.issueCode
-            : "capability_scope_validation_failed";
-        traceWorkerCapabilityContextRejected(diagnostic, descriptor, issueCode);
-        throw new Error(`worker_capability_rejected:${issueCode}`);
-    }
-}
-function settledResultProjectionIssueCode(error) {
-    if (error instanceof Error &&
-        (error.message === "worker_settled_results_head_stale" ||
-            error.message === "worker_settled_results_call_invalid" ||
-            error.message === "worker_settled_results_execution_invalid")) {
-        return error.message;
-    }
-    return "worker_settled_results_projection_failed";
-}
-async function executeAndNormalizeAdapter(params) {
-    let rawResult;
-    try {
-        rawResult = await params.execute(Object.freeze({
+    const preparedInvocations = await Promise.all(params.invocations.map(async (invocation, index) => Object.freeze({
+        ...invocation,
+        prepared: await prepareBoundInvocation({
             context: params.context,
             call: params.call,
-            executionId: params.executionId,
-            intent: params.intent,
-            controls: params.controls,
-            settledCapabilityResults: params.settledCapabilityResults,
+            adapter: invocation.adapter,
+            intent: invocation.intent,
+            ...(invocation.authoringObjective
+                ? { authoringObjective: invocation.authoringObjective }
+                : {}),
+            controls: invocation.controls,
+            preparationId: createPreparationId(params.call, index),
+            settledCapabilityResults,
             ...(params.dependencyResults
                 ? { dependencyResults: params.dependencyResults }
                 : {}),
             ...(params.executionFreshness
                 ? { executionFreshness: params.executionFreshness }
                 : {}),
-        }));
-    }
-    catch (error) {
-        if (error instanceof Error && error.name === "AbortError") {
-            throw error;
-        }
-        traceWorkerCapabilityExecutionFailed(params.diagnostic, params.descriptor, error, params.executionId);
-        return attachCanonicalExactResult(technicalFailure(adapterExecutionFailureSummary(error)));
-    }
-    let normalized;
-    try {
-        normalized = normalizeAdapterResult(rawResult, params.descriptor.effect);
-    }
-    catch (error) {
-        normalized = {
-            ok: false,
-            issueCode: exactResultNormalizationIssueCode(error),
-        };
-    }
-    if (!normalized.ok) {
-        traceWorkerCapabilityResultRejected(params.diagnostic, params.descriptor, normalized.issueCode, params.executionId);
-        return attachCanonicalExactResult(technicalFailure(normalized.issueCode === "adapter_result_too_large"
-            ? OVERSIZED_EXECUTION_RESULT_SUMMARY
-            : INVALID_EXECUTION_RESULT_SUMMARY));
-    }
-    return normalized.value;
-}
-function adapterExecutionFailureSummary(error) {
-    if (error instanceof Error) {
-        if (error.message.endsWith("canonical_result_result_too_large")) {
-            return OVERSIZED_EXECUTION_RESULT_SUMMARY;
-        }
-        if (error.message.endsWith("canonical_result_result_invalid") ||
-            error.message.endsWith("canonical_result_result_not_json_safe")) {
-            return INVALID_EXECUTION_RESULT_SUMMARY;
-        }
-    }
-    return TECHNICAL_EXECUTION_FAILURE_SUMMARY;
-}
-function exactResultNormalizationIssueCode(error) {
-    if (error instanceof Error &&
-        error.message.startsWith("capability_exact_result_invalid:")) {
-        const code = error.message.slice("capability_exact_result_invalid:".length);
-        if (code === "result_invalid" ||
-            code === "result_not_json_safe" ||
-            code === "result_too_large") {
-            return `adapter_${code}`;
-        }
-    }
-    return "adapter_result_unreadable";
-}
-function normalizeAdapterResult(input, declaredEffect) {
-    if (typeof input !== "object" || input === null || Array.isArray(input)) {
-        return { ok: false, issueCode: "adapter_result_not_object" };
-    }
-    const keys = Object.keys(input);
-    if (keys.length < 3 ||
-        keys.length > 6 ||
-        !keys.includes("outcome") ||
-        !keys.includes("observedEffect") ||
-        !keys.includes("summary") ||
-        keys.some((key) => key !== "outcome" &&
-            key !== "observedEffect" &&
-            key !== "summary" &&
-            key !== "referenceData" &&
-            key !== "references" &&
-            key !== "exactResult")) {
-        return { ok: false, issueCode: "adapter_result_shape_invalid" };
-    }
-    if (typeof input.summary !== "string" ||
-        input.summary.trim().length === 0 ||
-        input.summary.length > ROLE_CALL_RESULT_MAX_LENGTH) {
-        return { ok: false, issueCode: "adapter_result_summary_invalid" };
-    }
-    if (input.referenceData !== undefined &&
-        (typeof input.referenceData !== "string" ||
-            input.referenceData.trim().length === 0 ||
-            input.referenceData.length > ROLE_CAPABILITY_REFERENCE_DATA_MAX_LENGTH)) {
-        return { ok: false, issueCode: "adapter_result_reference_data_invalid" };
-    }
-    const references = normalizeResultReferences(input.references);
-    if (references === null) {
-        return { ok: false, issueCode: "adapter_result_references_invalid" };
-    }
-    if (input.outcome === "succeeded") {
-        if (!isSuccessfulObservedEffectCompatible(input.observedEffect, declaredEffect)) {
-            return { ok: false, issueCode: "observed_effect_mismatch" };
-        }
-        return {
-            ok: true,
-            value: attachCanonicalExactResult(Object.freeze({
-                outcome: "succeeded",
-                observedEffect: input.observedEffect,
-                summary: input.summary.trim(),
-                ...(input.referenceData
-                    ? { referenceData: input.referenceData.trim() }
-                    : {}),
-                ...(references ? { references } : {}),
-            }), input),
-        };
-    }
-    if (input.outcome === "failed") {
-        if (!isFailedObservedEffectCompatible(input.observedEffect, declaredEffect)) {
-            return { ok: false, issueCode: "failed_effect_invalid" };
-        }
-        return {
-            ok: true,
-            value: attachCanonicalExactResult(Object.freeze({
-                outcome: "failed",
-                observedEffect: input.observedEffect,
-                summary: input.summary.trim(),
-                ...(input.referenceData
-                    ? { referenceData: input.referenceData.trim() }
-                    : {}),
-                ...(references ? { references } : {}),
-            }), input),
-        };
-    }
-    return { ok: false, issueCode: "adapter_result_outcome_invalid" };
-}
-function attachCanonicalExactResult(normalized, raw = normalized) {
-    const exact = raw.exactResult === undefined
-        ? captureLegacyCapabilityAdapterResult(raw)
-        : normalizeCapabilityAdapterResult(raw.exactResult);
-    if (!exact.ok) {
-        throw new Error(`capability_exact_result_invalid:${exact.code}`);
-    }
-    return Object.freeze({
-        ...normalized,
-        exactResult: exact.value,
+        }),
+    })));
+    const uniqueInvocations = deduplicatePreparedInvocations(preparedInvocations);
+    return settlePreparedInvocationBatch({
+        currentHead: params.currentHead,
+        ledger: params.ledger,
+        call: params.call,
+        invocations: uniqueInvocations,
+        diagnostic: params.diagnostic,
+        ...(params.executionFreshness
+            ? { executionFreshness: params.executionFreshness }
+            : {}),
     });
 }
-function normalizeResultReferences(input) {
-    if (input === undefined)
-        return undefined;
-    if (!Array.isArray(input) ||
-        input.length > ROLE_CAPABILITY_RESULT_REFERENCE_LIMIT_MAX) {
-        return null;
-    }
-    const targets = new Set();
-    const references = [];
-    for (const candidate of input) {
-        if (typeof candidate !== "object" ||
-            candidate === null ||
-            Array.isArray(candidate)) {
-            return null;
-        }
-        const reference = candidate;
-        if (Object.keys(reference).length !== 2 ||
-            reference.kind !== "tool_target" ||
-            typeof reference.target !== "string" ||
-            reference.target.trim().length === 0 ||
-            reference.target.length >
-                ROLE_CAPABILITY_RESULT_REFERENCE_TARGET_MAX_LENGTH) {
-            return null;
-        }
-        const target = reference.target.trim();
-        if (targets.has(target))
-            return null;
-        targets.add(target);
-        references.push(Object.freeze({ kind: "tool_target", target }));
+async function settlePreparedInvocationBatch(params) {
+    if (params.invocations.length === 1) {
+        return settleCollapsedPreparedBatch(params);
     }
-    return Object.freeze(references);
+    return beginAndSettlePreparedBatch(params);
 }
-function isSuccessfulObservedEffectCompatible(observedEffect, declaredEffect) {
-    return declaredEffect === "mixed"
-        ? observedEffect === "observation" || observedEffect === "mutation"
-        : observedEffect === declaredEffect;
-}
-function isFailedObservedEffectCompatible(observedEffect, declaredEffect) {
-    return (observedEffect === "none" ||
-        observedEffect === "indeterminate" ||
-        observedEffect === "observation" ||
-        (observedEffect === "mutation" &&
-            (declaredEffect === "mutation" || declaredEffect === "mixed")));
+async function settleCollapsedPreparedBatch(params) {
+    const result = await beginAndSettlePreparedSingle({
+        currentHead: params.currentHead,
+        ledger: params.ledger,
+        call: params.call,
+        invocation: params.invocations[0],
+        diagnostic: params.diagnostic,
+        ...(params.executionFreshness
+            ? { executionFreshness: params.executionFreshness }
+            : {}),
+    });
+    return projectSingleAttemptAsBatch(result);
 }
-function technicalFailure(summary) {
+function projectSingleAttemptAsBatch(result) {
+    if ("commit" in result)
+        return result;
     return Object.freeze({
-        outcome: "failed",
-        observedEffect: "indeterminate",
-        summary,
+        executionIds: Object.freeze([result.executionId]),
     });
 }
-function stateRejection(phase, code) {
-    return new Error(`worker_capability_${phase}_rejected:${code}`);
+function isExecutableObservationBatch(invocations) {
+    if (invocations.length < 2)
+        return false;
+    return invocations.every(({ adapter }) => adapter.descriptor.effect === "observation");
 }

package/dist/src/runtime/orchestration/worker-capabilities/index.d.ts

@@ -1,6 +1,9 @@
+export * from "./batch-selection.js";
 export * from "./binding.js";
 export * from "./controls.js";
 export * from "./contracts.js";
+export * from "./errors.js";
+export * from "./outcome-fingerprint.js";
 export * from "./payload-author.js";
 export * from "./payload-contracts.js";
 export * from "./scope.js";

package/dist/src/runtime/orchestration/worker-capabilities/index.js

@@ -1,6 +1,9 @@
+export * from "./batch-selection.js";
 export * from "./binding.js";
 export * from "./controls.js";
 export * from "./contracts.js";
+export * from "./errors.js";
+export * from "./outcome-fingerprint.js";
 export * from "./payload-author.js";
 export * from "./payload-contracts.js";
 export * from "./scope.js";

package/dist/src/runtime/orchestration/worker-capabilities/outcome-fingerprint.d.ts

@@ -0,0 +1,8 @@
+import type { RoleOperationOutcomeFingerprint } from "../role-calls/index.js";
+/**
+ * Keeps thrown adapter failures distinct without persisting their raw values.
+ * Unsafe or unstable thrown values deliberately produce no tracking identity.
+ */
+export declare function createWorkerCapabilityExecutionErrorOutcomeFingerprint(error: unknown): RoleOperationOutcomeFingerprint | undefined;
+/** Keeps distinct adapter contract violations separate without exposing them. */
+export declare function createWorkerCapabilityResultRejectionOutcomeFingerprint(issueCode: string): RoleOperationOutcomeFingerprint;

package/dist/src/runtime/orchestration/worker-capabilities/outcome-fingerprint.js

@@ -0,0 +1,21 @@
+import { createHash } from "node:crypto";
+import { createStableWorkerCapabilityErrorFingerprint } from "./error-fingerprint.js";
+/**
+ * Keeps thrown adapter failures distinct without persisting their raw values.
+ * Unsafe or unstable thrown values deliberately produce no tracking identity.
+ */
+export function createWorkerCapabilityExecutionErrorOutcomeFingerprint(error) {
+    return createStableWorkerCapabilityErrorFingerprint({
+        domain: "execute",
+        error,
+    });
+}
+/** Keeps distinct adapter contract violations separate without exposing them. */
+export function createWorkerCapabilityResultRejectionOutcomeFingerprint(issueCode) {
+    return digest(["adapter_result_rejection_v1", issueCode]);
+}
+function digest(value) {
+    return `sha256:${createHash("sha256")
+        .update(JSON.stringify(value))
+        .digest("hex")}`;
+}

package/dist/src/runtime/orchestration/worker-capabilities/payload-author.js

@@ -5,6 +5,7 @@ import { WORKER_CAPABILITY_RAW_PAYLOAD_MODEL_STEP, WORKER_CAPABILITY_RELATED_ART
 import { ROOT_CAPABILITY_PAYLOAD_INSTRUCTIONS, ROOT_CAPABILITY_STAGED_RAW_PAYLOAD_INSTRUCTIONS, ROOT_CAPABILITY_STRUCTURED_PAYLOAD_INSTRUCTIONS, WORKER_CAPABILITY_PAYLOAD_INSTRUCTIONS, WORKER_CAPABILITY_STAGED_RAW_PAYLOAD_INSTRUCTIONS, WORKER_CAPABILITY_STRUCTURED_PAYLOAD_INSTRUCTIONS, } from "./payload-instructions.js";
 import { validateJsonSchemaValue } from "../../model/json-schema-value.js";
 import { isRuntimeDelegateRoleId } from "../roles.js";
+import { WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH } from "./contracts.js";
 export function createWorkerCapabilityPayloadAuthor(params) {
     const capabilityAuthorities = Object.freeze([
         ...(params.capabilityAuthorities ?? ["worker"]),
@@ -124,7 +125,7 @@ function capturePayloadContext(input, capabilityAuthorities) {
     const requestSteering = normalizeRootRequestSteering(input.requestSteering);
     if (!principal ||
         !payloadPrincipalMatchesSteering(principal, input.requestSteering, requestSteering) ||
-        !validPayloadAssignment(input) ||
+        !validPayloadAssignment(input, principal) ||
         !validPayloadContract(input.contract) ||
         !validPayloadStageContract(input, contextScope) ||
         !validPayloadEvidenceContext(input, contextScope) ||
@@ -139,11 +140,6 @@ function capturePayloadContext(input, capabilityAuthorities) {
         return null;
     }
     const sharedContext = {
-        acceptedCapability: {
-            capabilityId: input.descriptor.capabilityId,
-            summary: input.descriptor.summary,
-            controls: input.controls,
-        },
         contextScope,
         ...(input.dependencyResults
             ? { dependencyResults: input.dependencyResults }
@@ -167,13 +163,27 @@ function capturePayloadContext(input, capabilityAuthorities) {
             : {}),
     };
     return principal.kind === "worker"
-        ? immutableSnapshot({ worker: principal.context, ...sharedContext })
+        ? immutableSnapshot({
+            worker: principal.context,
+            acceptedCapability: {
+                capabilityId: input.descriptor.capabilityId,
+                summary: input.descriptor.summary,
+                authoringObjective: input.authoringObjective,
+                controls: input.controls,
+            },
+            ...sharedContext,
+        })
         : immutableSnapshot({
             root: {
                 ...principal.context,
                 steeringVersion: requestSteering.version,
                 updates: requestSteering.updates,
             },
+            acceptedCapability: {
+                capabilityId: input.descriptor.capabilityId,
+                summary: input.descriptor.summary,
+                controls: input.controls,
+            },
             ...sharedContext,
         });
 }
@@ -182,8 +192,20 @@ function payloadPrincipalMatchesSteering(principal, input, normalized) {
         ? normalized !== undefined
         : input === undefined;
 }
-function validPayloadAssignment(input) {
-    return typeof input.executionId === "string" && input.executionId.length > 0;
+function validPayloadAssignment(input, principal) {
+    if (typeof input.executionId !== "string" || input.executionId.length === 0) {
+        return false;
+    }
+    const supplied = Object.hasOwn(input, "authoringObjective");
+    if (principal.kind === "root")
+        return !supplied;
+    return (input.descriptor.requiresPayloadAuthoringObjective === true &&
+        supplied &&
+        typeof input.authoringObjective === "string" &&
+        input.authoringObjective.trim() === input.authoringObjective &&
+        input.authoringObjective.length > 0 &&
+        input.authoringObjective.length <=
+            WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH);
 }
 function validPayloadContract(input) {
     return (typeof input.instructions === "string" &&