@abot-ai/runtime 1.1.0 → 1.2.0

package/dist/src/runtime/orchestration/role-calls/work-result-receipt.js

@@ -0,0 +1,187 @@
+import { exactKeys, isRecord } from "../../validation/strict-record.js";
+import { ROLE_CALL_RESULT_MAX_LENGTH, SUPERVISOR_WORKER_V1_AUTHORITY_SNAPSHOT, } from "./contracts.js";
+import { createCanonicalRoleCallWorkResultLineage, projectRoleCallWorkResultLineage, } from "./work-result-lineage.js";
+export const ROLE_CALL_WORK_RESULT_RECEIPT_KIND = "work_result_v1";
+export const ROLE_CALL_WORK_RESULT_FINGERPRINT_PATTERN = /^sha256:[a-f0-9]{64}$/u;
+const ROLE_CALL_WORK_RESULT_REFERENCE_MAX_LENGTH = 256;
+export function normalizeRoleCallWorkResultReceipt(input) {
+    if (input === undefined)
+        return undefined;
+    if (!isRecord(input))
+        return null;
+    if (!hasExactWorkResultReceiptKeys(input))
+        return null;
+    if (input.kind !== ROLE_CALL_WORK_RESULT_RECEIPT_KIND)
+        return null;
+    if (!isBoundedReference(input.producerCallId))
+        return null;
+    if (!isBoundedReference(input.callerCallId))
+        return null;
+    if (!isNonNegativeSafeInteger(input.sourceRevision))
+        return null;
+    if (!isLineageFingerprint(input.lineageFingerprint))
+        return null;
+    const plannerPlanRef = normalizePlannerPlanReference(input.plannerPlanRef);
+    if (plannerPlanRef === null)
+        return null;
+    const receipt = {
+        kind: ROLE_CALL_WORK_RESULT_RECEIPT_KIND,
+        producerCallId: input.producerCallId.trim(),
+        callerCallId: input.callerCallId.trim(),
+        sourceRevision: input.sourceRevision,
+        lineageFingerprint: input.lineageFingerprint,
+        ...(plannerPlanRef ? { plannerPlanRef } : {}),
+    };
+    if (JSON.stringify(receipt).length > ROLE_CALL_RESULT_MAX_LENGTH)
+        return null;
+    return deepFreeze(receipt);
+}
+export function mustIssueSupervisorWorkResultReceipt(input) {
+    if (input.child.roleId !== "planner" && input.child.roleId !== "worker") {
+        return false;
+    }
+    const expected = SUPERVISOR_WORKER_V1_AUTHORITY_SNAPSHOT;
+    return (input.policy.authority.id === expected.id &&
+        input.policy.authority.version === expected.version &&
+        input.policy.authority.definitionHash === expected.definitionHash);
+}
+export function createCanonicalRoleCallWorkResultReceipt(input) {
+    if (!mustIssueSupervisorWorkResultReceipt(input))
+        return null;
+    if (!hasCanonicalReturnBinding(input))
+        return null;
+    const sourceRevision = input.admittedHeadRevision;
+    if (sourceRevision === undefined)
+        return null;
+    const lineage = createCanonicalRoleCallWorkResultLineage({
+        state: input.state,
+        producer: input.child,
+        resultRef: input.resultRef,
+        outcome: input.outcome,
+        sourceRevision,
+    });
+    if (!lineage)
+        return null;
+    const receipt = normalizeRoleCallWorkResultReceipt({
+        kind: ROLE_CALL_WORK_RESULT_RECEIPT_KIND,
+        producerCallId: input.child.callId,
+        callerCallId: input.caller.callId,
+        sourceRevision,
+        lineageFingerprint: lineage.lineageFingerprint,
+        ...(lineage.planner
+            ? {
+                plannerPlanRef: {
+                    planId: lineage.planner.planId,
+                    planVersion: lineage.planner.planVersion,
+                },
+            }
+            : {}),
+    });
+    return receipt ?? null;
+}
+export function isRoleCallWorkResultReceiptValidForStoredResult(input) {
+    const receipt = normalizeRoleCallWorkResultReceipt(input.receipt);
+    if (!receipt)
+        return false;
+    if (!mustIssueSupervisorWorkResultReceipt({
+        child: input.producer,
+        policy: input.policy,
+    })) {
+        return false;
+    }
+    if (!isStoredResultBoundToReceipt(input, receipt))
+        return false;
+    return projectRoleCallWorkResultLineage({
+        state: input.state,
+        receipt,
+    }) !== null;
+}
+function hasExactWorkResultReceiptKeys(input) {
+    return exactKeys(input, [
+        "kind",
+        "producerCallId",
+        "callerCallId",
+        "sourceRevision",
+        "lineageFingerprint",
+    ], ["plannerPlanRef"]);
+}
+function normalizePlannerPlanReference(input) {
+    if (input === undefined)
+        return undefined;
+    if (!isRecord(input))
+        return null;
+    if (!exactKeys(input, ["planId", "planVersion"]))
+        return null;
+    if (!isBoundedReference(input.planId))
+        return null;
+    if (!isPositiveSafeInteger(input.planVersion))
+        return null;
+    return Object.freeze({
+        planId: input.planId.trim(),
+        planVersion: input.planVersion,
+    });
+}
+function hasCanonicalReturnBinding(input) {
+    if (!isNonNegativeSafeInteger(input.admittedHeadRevision))
+        return false;
+    if (!isBoundedReference(input.resultRef))
+        return false;
+    if (input.state.phase !== "running")
+        return false;
+    if (input.state.activeCallId !== input.child.callId)
+        return false;
+    const canonicalCaller = input.state.calls.find(({ callId }) => callId === input.caller.callId);
+    const canonicalChild = input.state.calls.find(({ callId }) => callId === input.child.callId);
+    if (canonicalCaller !== input.caller || canonicalChild !== input.child) {
+        return false;
+    }
+    if (input.caller.status !== "waiting_for_child")
+        return false;
+    if (input.child.status !== "active" || input.child.resultRef !== null) {
+        return false;
+    }
+    if (input.child.parentCallId !== input.caller.callId)
+        return false;
+    if (!input.caller.childCallIds.includes(input.child.callId))
+        return false;
+    return input.outcome === "completed" || input.outcome === "failed";
+}
+function isStoredResultBoundToReceipt(input, receipt) {
+    if (input.producer.callId !== receipt.producerCallId)
+        return false;
+    if (input.producer.parentCallId !== receipt.callerCallId)
+        return false;
+    if (input.producer.status !== "completed")
+        return false;
+    if (input.producer.resultRef !== input.result.resultRef)
+        return false;
+    if (input.result.producerCallId !== input.producer.callId)
+        return false;
+    if (input.result.roleId !== input.producer.roleId)
+        return false;
+    return input.state.results.includes(input.result);
+}
+function isBoundedReference(input) {
+    return (typeof input === "string" &&
+        input.trim().length > 0 &&
+        input.length <= ROLE_CALL_WORK_RESULT_REFERENCE_MAX_LENGTH);
+}
+function isNonNegativeSafeInteger(input) {
+    return Number.isSafeInteger(input) && input >= 0;
+}
+function isPositiveSafeInteger(input) {
+    return Number.isSafeInteger(input) && input >= 1;
+}
+function isLineageFingerprint(input) {
+    return (typeof input === "string" &&
+        ROLE_CALL_WORK_RESULT_FINGERPRINT_PATTERN.test(input));
+}
+function deepFreeze(value) {
+    if (typeof value !== "object" || value === null || Object.isFrozen(value)) {
+        return value;
+    }
+    Object.freeze(value);
+    for (const child of Object.values(value))
+        deepFreeze(child);
+    return value;
+}

package/dist/src/runtime/orchestration/role-executors/activation/result-normalization.js

@@ -1,12 +1,14 @@
-import { isRoleCallWorkingDirectoryRoleId, normalizeRoleCallWorkingDirectory, parseRoleCallPlanBinding, parseRoleCallWorkerCapabilityScope, } from "../../role-calls/index.js";
+import { isRoleCallWorkingDirectoryRoleId, normalizeRoleCallWorkingDirectory, normalizeRoleCallResultReceipt, parseRoleCallPlanBinding, parseRoleCallWorkerCapabilityScope, } from "../../role-calls/index.js";
 import { isRuntimeDelegateRoleId } from "../../roles.js";
 export function normalizeRoleExecutorActivationResult(input, maxSummaryLength, maxObjectiveLength) {
     if (!isPlainRecord(input)) {
         return { ok: false, issueCode: "result_not_object" };
     }
     if (input.kind === "terminal") {
-        if (!hasExactKeys(input, ["kind", "outcome", "summary"], ["value"]) ||
-            (input.outcome !== "completed" && input.outcome !== "failed")) {
+        const receipt = normalizeRoleCallResultReceipt(input.receipt);
+        if (!hasExactKeys(input, ["kind", "outcome", "summary"], ["receipt", "value"]) ||
+            (input.outcome !== "completed" && input.outcome !== "failed") ||
+            receipt === null) {
             return { ok: false, issueCode: "terminal_shape_invalid" };
         }
         if (typeof input.summary !== "string" ||
@@ -20,6 +22,7 @@ export function normalizeRoleExecutorActivationResult(input, maxSummaryLength, m
                 kind: "terminal",
                 outcome: input.outcome,
                 summary: input.summary.trim(),
+                ...(receipt ? { receipt } : {}),
                 ...(input.value !== undefined ? { value: input.value } : {}),
             }),
         };

package/dist/src/runtime/orchestration/role-executors/child-invocation/transaction.js

@@ -169,6 +169,7 @@ export class ChildInvocationTransaction {
             childCallId: openedChild.call.callId,
             outcome: execution.outcome,
             summary: execution.summary,
+            ...(execution.receipt ? { receipt: execution.receipt } : {}),
         });
         if (!returnedResult.ok) {
             this.rejectChild({

package/dist/src/runtime/orchestration/role-executors/contracts.d.ts

@@ -1,10 +1,11 @@
-import type { RoleCallChildReturnCommit, RoleCallFrame, RoleCallLedger, RoleCallLedgerHead, RoleCallOperationSupervisionInterventionCommit, RoleCallPlanBinding, RoleCallWorkerCapabilityScope } from "../role-calls/index.js";
+import type { RoleCallChildReturnCommit, RoleCallFrame, RoleCallLedger, RoleCallLedgerHead, RoleCallOperationSupervisionInterventionCommit, RoleCallPlanBinding, RoleCallResultReceipt, RoleCallWorkerCapabilityScope } from "../role-calls/index.js";
 import type { RuntimeDelegateRoleId } from "../roles.js";
 export type RoleExecutionOutcome = "completed" | "failed";
 export type RoleExecutionResult<TValue = unknown> = Readonly<{
     kind: "terminal";
     outcome: RoleExecutionOutcome;
     summary: string;
+    receipt?: RoleCallResultReceipt;
     value?: TValue;
 }>;
 export type RoleChildInvocationResult<TValue = unknown> = Readonly<{

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

@@ -0,0 +1,36 @@
+import type { RoleCallFrame, RoleCallLedgerHead } from "../role-calls/contracts.js";
+import type { WorkerCapabilityAssignmentProvenance } from "./contracts.js";
+type WorkerCapabilityAssignmentIdentity = RoleCallFrame | Readonly<{
+    callId: string;
+    parentCallId: string | null;
+    depth: number;
+    objective: string;
+    invocationAttempt: number;
+}>;
+export type WorkerCapabilityDependencyArtifactReceipt = Readonly<{
+    sourceExecutionId: string;
+    targetPath: string;
+}>;
+export type WorkerCapabilityPlannerItemBinding = Readonly<{
+    plannerCallId: string;
+    planId: string;
+    itemId: string;
+    workerCallId: string;
+}>;
+/** Resolves one direct Planner-item binding from the canonical ledger head. */
+export declare function projectWorkerCapabilityPlannerItemBinding(head: RoleCallLedgerHead, call: RoleCallFrame): WorkerCapabilityPlannerItemBinding | undefined;
+/** Projects the canonical proof that one Worker owns one bound Planner item. */
+export declare function projectWorkerCapabilityAssignmentProvenance(params: Readonly<{
+    head: RoleCallLedgerHead;
+    call: RoleCallFrame;
+}>): WorkerCapabilityAssignmentProvenance | undefined;
+/** Validates the canonical receipt against the exact consuming Worker call. */
+export declare function isWorkerCapabilityAssignmentProvenanceValid(provenance: WorkerCapabilityAssignmentProvenance | undefined, identity: WorkerCapabilityAssignmentIdentity, requestId: string): boolean;
+/** Resolves model-visible request scope only from a verified runtime receipt. */
+export declare function projectWorkerRequestSourceProjection(provenance: WorkerCapabilityAssignmentProvenance | undefined, identity: WorkerCapabilityAssignmentIdentity, requestId: string): "full_request" | "assignment_only";
+/**
+ * Resolves only successful artifact references produced by the exact direct
+ * sibling results canonically attached to one Planner-bound Worker.
+ */
+export declare function projectWorkerCapabilityDependencyArtifactReceipts(provenance: WorkerCapabilityAssignmentProvenance | undefined, call: RoleCallFrame): readonly WorkerCapabilityDependencyArtifactReceipt[];
+export {};

package/dist/src/runtime/orchestration/worker-capabilities/assignment-provenance.js

@@ -0,0 +1,171 @@
+import { projectRoleCallDependencyResults } from "../role-calls/dependency-results.js";
+const WORKER_ASSIGNMENT_AUTHORITY = Symbol("workerAssignmentAuthority");
+const EMPTY_DEPENDENCY_ARTIFACT_RECEIPTS = Object.freeze([]);
+/** Resolves one direct Planner-item binding from the canonical ledger head. */
+export function projectWorkerCapabilityPlannerItemBinding(head, call) {
+    const canonicalCall = head.state.calls.find(({ callId }) => callId === call.callId);
+    if (canonicalCall !== call) {
+        throw new Error("worker_assignment_provenance_authority_invalid");
+    }
+    if (call.roleId !== "worker" || call.parentCallId === null)
+        return undefined;
+    const parent = head.state.calls.find(({ callId }) => callId === call.parentCallId);
+    if (!parent || parent.depth !== call.depth - 1) {
+        throw new Error("worker_assignment_provenance_parent_invalid");
+    }
+    if (parent.roleId !== "planner")
+        return undefined;
+    const plan = head.state.plans.find(({ definition }) => definition.plannerCallId === parent.callId);
+    const boundItems = plan?.itemStates.filter(({ childCallId }) => childCallId === call.callId);
+    if (!plan || !boundItems) {
+        throw new Error("worker_assignment_provenance_plan_binding_invalid");
+    }
+    if (boundItems.length !== 1) {
+        throw new Error("worker_assignment_provenance_plan_binding_invalid");
+    }
+    return Object.freeze({
+        plannerCallId: parent.callId,
+        planId: plan.definition.planId,
+        itemId: boundItems[0].itemId,
+        workerCallId: call.callId,
+    });
+}
+/** Projects the canonical proof that one Worker owns one bound Planner item. */
+export function projectWorkerCapabilityAssignmentProvenance(params) {
+    const canonicalCall = params.head.state.calls.find(({ callId }) => callId === params.call.callId);
+    if (canonicalCall !== params.call || canonicalCall.roleId !== "worker") {
+        throw new Error("worker_assignment_provenance_authority_invalid");
+    }
+    const binding = projectWorkerCapabilityPlannerItemBinding(params.head, canonicalCall);
+    if (!binding)
+        return undefined;
+    assertPlannerItemIsActive(params.head, binding);
+    const provenance = {
+        kind: "planner_plan_item_v1",
+        requestId: params.head.state.requestId,
+        sourceRevision: params.head.revision,
+        ...binding,
+        invocationAttempt: canonicalCall.activationCount,
+    };
+    const authority = Object.freeze({
+        receipt: provenance,
+        requestId: params.head.state.requestId,
+        head: params.head,
+        call: canonicalCall,
+    });
+    Object.defineProperty(provenance, WORKER_ASSIGNMENT_AUTHORITY, {
+        value: authority,
+        enumerable: false,
+        configurable: false,
+        writable: false,
+    });
+    return Object.freeze(provenance);
+}
+/** Validates the canonical receipt against the exact consuming Worker call. */
+export function isWorkerCapabilityAssignmentProvenanceValid(provenance, identity, requestId) {
+    if (provenance === undefined)
+        return true;
+    const authority = readWorkerAssignmentAuthority(provenance);
+    if (!authority)
+        return false;
+    if (authority.requestId !== requestId)
+        return false;
+    if (!Object.isFrozen(provenance))
+        return false;
+    if (provenance.kind !== "planner_plan_item_v1")
+        return false;
+    if (provenance.requestId !== requestId)
+        return false;
+    if (provenance.workerCallId !== identity.callId)
+        return false;
+    if (provenance.plannerCallId !== identity.parentCallId)
+        return false;
+    const invocationAttempt = "activationCount" in identity
+        ? identity.activationCount
+        : identity.invocationAttempt;
+    if (provenance.invocationAttempt !== invocationAttempt)
+        return false;
+    if ("activationCount" in identity) {
+        return identity.roleId === "worker" && authority.call === identity;
+    }
+    return (authority.call.depth === identity.depth &&
+        authority.call.objective === identity.objective);
+}
+/** Resolves model-visible request scope only from a verified runtime receipt. */
+export function projectWorkerRequestSourceProjection(provenance, identity, requestId) {
+    if (!isWorkerCapabilityAssignmentProvenanceValid(provenance, identity, requestId)) {
+        throw new Error("worker_assignment_provenance_receipt_invalid");
+    }
+    return provenance ? "assignment_only" : "full_request";
+}
+/**
+ * Resolves only successful artifact references produced by the exact direct
+ * sibling results canonically attached to one Planner-bound Worker.
+ */
+export function projectWorkerCapabilityDependencyArtifactReceipts(provenance, call) {
+    if (!provenance)
+        return EMPTY_DEPENDENCY_ARTIFACT_RECEIPTS;
+    if (!isWorkerCapabilityAssignmentProvenanceValid(provenance, call, provenance.requestId)) {
+        throw new Error("worker_assignment_provenance_receipt_invalid");
+    }
+    const authority = readWorkerAssignmentAuthority(provenance);
+    if (!authority || authority.head.revision !== provenance.sourceRevision) {
+        throw new Error("worker_assignment_provenance_receipt_invalid");
+    }
+    const dependencies = projectRoleCallDependencyResults(authority.head, call);
+    const receipts = dependencies.flatMap((dependency) => {
+        if (dependency.roleId !== "worker" || dependency.outcome !== "completed") {
+            return [];
+        }
+        return projectDependencyProducerArtifactReceipts(authority.head, dependency.producerCallId);
+    });
+    return Object.freeze(receipts);
+}
+function projectDependencyProducerArtifactReceipts(head, producerCallId) {
+    const receipts = [];
+    for (const execution of head.state.capabilityExecutions) {
+        if (execution.callId !== producerCallId)
+            continue;
+        if (execution.status !== "settled" || execution.outcome !== "succeeded") {
+            continue;
+        }
+        for (const reference of execution.references ?? []) {
+            receipts.push(Object.freeze({
+                sourceExecutionId: execution.executionId,
+                targetPath: reference.target,
+            }));
+        }
+    }
+    return receipts;
+}
+function assertPlannerItemIsActive(head, binding) {
+    const plan = head.state.plans.find(({ definition }) => definition.planId === binding.planId);
+    if (!plan) {
+        throw new Error("worker_assignment_provenance_plan_binding_invalid");
+    }
+    const item = plan?.itemStates.find(({ itemId }) => itemId === binding.itemId);
+    if (!item || item.childCallId !== binding.workerCallId) {
+        throw new Error("worker_assignment_provenance_plan_binding_invalid");
+    }
+    if (item.status !== "in_progress") {
+        throw new Error("worker_assignment_provenance_plan_binding_invalid");
+    }
+}
+function readWorkerAssignmentAuthority(provenance) {
+    if (typeof provenance !== "object" || provenance === null)
+        return undefined;
+    const descriptor = Object.getOwnPropertyDescriptor(provenance, WORKER_ASSIGNMENT_AUTHORITY);
+    if (!descriptor ||
+        descriptor.enumerable ||
+        descriptor.configurable ||
+        descriptor.writable) {
+        return undefined;
+    }
+    const authority = descriptor.value;
+    if (typeof authority !== "object" || authority === null)
+        return undefined;
+    if (!Object.isFrozen(authority))
+        return undefined;
+    const candidate = authority;
+    return candidate.receipt === provenance ? candidate : undefined;
+}

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

@@ -1,5 +1,5 @@
 import { type RoleCallFrame, type RoleCallDependencyResult, type RoleCallLedger, type RoleCallOperationSupervisionInterventionCommit, type RoleCapabilityEffect, type RoleCapabilityDeclaredEffect, type RoleCapabilityExecutionOutcome, type RoleCapabilityObservedEffect, type RoleCapabilityResultReference } from "../role-calls/index.js";
-import type { ToolCatalogGroup } from "../../../capabilities/tool-types.js";
+import type { ToolCatalogGroup, ToolDevelopmentRole, ToolRoutingCapability } from "../../../capabilities/tool-types.js";
 import type { CapabilityAdapterResult } from "../capability-adapters/result.js";
 export declare const WORKER_CAPABILITY_ID_MAX_LENGTH = 128;
 /** Client-facing capability narration; never an execution objective or payload. */
@@ -16,6 +16,30 @@ export declare const WORKER_CAPABILITY_CONTROL_ENUM_VALUE_MAX_LENGTH = 256;
 export declare const WORKER_CAPABILITY_CONTROL_ARRAY_MAX_ITEMS = 64;
 export type WorkerCapabilityEffect = RoleCapabilityDeclaredEffect;
 export type WorkerCapabilityObservedEffect = RoleCapabilityObservedEffect;
+declare const WORKER_CAPABILITY_ASSIGNMENT_PROVENANCE_BRAND: unique symbol;
+export type WorkerCapabilityAssignmentProvenance = Readonly<{
+    kind: "planner_plan_item_v1";
+    requestId: string;
+    sourceRevision: number;
+    plannerCallId: string;
+    planId: string;
+    itemId: string;
+    workerCallId: string;
+    invocationAttempt: number;
+    readonly [WORKER_CAPABILITY_ASSIGNMENT_PROVENANCE_BRAND]: true;
+}>;
+declare const WORKER_CAPABILITY_REQUEST_PROVENANCE_BRAND: unique symbol;
+export type WorkerCapabilityRequestScopedProvenance = Readonly<{
+    kind: "request_scoped_worker_v1";
+    requestId: string;
+    sourceRevision: number;
+    callerCallId: string;
+    workerCallId: string;
+    invocationAttempt: number;
+    readonly [WORKER_CAPABILITY_REQUEST_PROVENANCE_BRAND]: true;
+}>;
+/** Runtime-issued request-source authority for one Worker payload. */
+export type WorkerCapabilityPayloadSourceProvenance = WorkerCapabilityAssignmentProvenance | WorkerCapabilityRequestScopedProvenance;
 export type WorkerCapabilityBoundedStringControl = Readonly<{
     type: "string";
     minLength: number;
@@ -65,6 +89,10 @@ export type WorkerCapabilityDescriptor = Readonly<{
     controlsRefinement?: "mechanical_when_complete";
     /** Manifest-owned routing metadata projected only in capability selection. */
     catalogGroups?: readonly ToolCatalogGroup[];
+    /** Manifest-owned semantic routing class for this capability. */
+    routingCapability?: ToolRoutingCapability;
+    /** Manifest-owned development phases served by this capability. */
+    developmentRoles?: readonly ToolDevelopmentRole[];
     /** Canonical payload contract requires a Worker authoring receipt. */
     requiresPayloadAuthoringObjective?: true;
 }>;
@@ -110,6 +138,8 @@ export type WorkerCapabilityAdapterResult = Readonly<{
 export type WorkerCapabilityAdapterExecutionInput<TContext> = Readonly<{
     context: TContext;
     call: RoleCallFrame;
+    /** Runtime-only proof of the exact request source allowed for this payload. */
+    assignmentProvenance?: WorkerCapabilityPayloadSourceProvenance;
     executionId: string;
     /** Client-facing presentation metadata for lifecycle events only. */
     intent: string;
@@ -219,3 +249,4 @@ export type WorkerCapabilityBinding<TContext> = Readonly<{
         }>[];
     }>): Promise<WorkerCapabilityBatchAttemptReference>;
 }>;
+export {};

package/dist/src/runtime/orchestration/worker-capabilities/execution/invocation-preparation.d.ts

@@ -1,5 +1,5 @@
 import { type RoleCallDependencyResult, type RoleCallFrame } from "../../role-calls/index.js";
-import type { WorkerCapabilityAdapter, WorkerCapabilityControls, WorkerCapabilityExecutionFreshness, WorkerCapabilityPreparedExecution, WorkerSettledCapabilityResult } from "../contracts.js";
+import type { WorkerCapabilityAdapter, WorkerCapabilityControls, WorkerCapabilityExecutionFreshness, WorkerCapabilityPayloadSourceProvenance, WorkerCapabilityPreparedExecution, WorkerSettledCapabilityResult } from "../contracts.js";
 export type PreparedBoundInvocation<TContext> = Readonly<{
     adapter: WorkerCapabilityAdapter<TContext>;
     intent: string;
@@ -10,6 +10,7 @@ export type PreparedBoundInvocation<TContext> = Readonly<{
 type BoundInvocationPreparationParams<TContext> = Readonly<{
     context: TContext;
     call: RoleCallFrame;
+    assignmentProvenance?: WorkerCapabilityPayloadSourceProvenance;
     adapter: WorkerCapabilityAdapter<TContext>;
     intent: string;
     authoringObjective?: string;

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

@@ -6,6 +6,9 @@ export async function prepareBoundInvocation(params) {
     const common = Object.freeze({
         context: params.context,
         call: params.call,
+        ...(params.assignmentProvenance
+            ? { assignmentProvenance: params.assignmentProvenance }
+            : {}),
         intent: params.intent,
         ...(params.authoringObjective
             ? { authoringObjective: params.authoringObjective }

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

@@ -1,6 +1,7 @@
 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";
+import { projectWorkerCapabilityPayloadSourceProvenance } from "./payload-source-provenance.js";
 export async function executeBoundWorkerCapability(params) {
     assertExecutionCapabilityScope(params.capabilityScope, params.adapter.descriptor, params.diagnostic);
     const settledCapabilityResults = projectExecutionSettledCapabilityResults({
@@ -10,9 +11,11 @@ export async function executeBoundWorkerCapability(params) {
         descriptors: [params.adapter.descriptor],
         diagnostic: params.diagnostic,
     });
+    const assignmentProvenance = projectPayloadSourceProvenance(params);
     const prepared = await prepareBoundInvocation({
         context: params.context,
         call: params.call,
+        ...(assignmentProvenance ? { assignmentProvenance } : {}),
         adapter: params.adapter,
         intent: params.intent,
         ...(params.authoringObjective
@@ -61,27 +64,36 @@ export async function executeBoundWorkerCapabilityBatch(params) {
         descriptors: params.invocations.map(({ adapter }) => adapter.descriptor),
         diagnostic: params.diagnostic,
     });
-    const preparedInvocations = await Promise.all(params.invocations.map(async (invocation, index) => Object.freeze({
-        ...invocation,
-        prepared: await prepareBoundInvocation({
-            context: params.context,
+    const preparedInvocations = await Promise.all(params.invocations.map(async (invocation, index) => {
+        const assignmentProvenance = projectPayloadSourceProvenance({
+            ledger: params.ledger,
+            currentHead: params.currentHead,
             call: params.call,
             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 }
-                : {}),
-        }),
-    })));
+        });
+        return Object.freeze({
+            ...invocation,
+            prepared: await prepareBoundInvocation({
+                context: params.context,
+                call: params.call,
+                ...(assignmentProvenance ? { assignmentProvenance } : {}),
+                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 }
+                    : {}),
+            }),
+        });
+    }));
     const uniqueInvocations = deduplicatePreparedInvocations(preparedInvocations);
     return settlePreparedInvocationBatch({
         currentHead: params.currentHead,
@@ -94,6 +106,17 @@ export async function executeBoundWorkerCapabilityBatch(params) {
             : {}),
     });
 }
+function projectPayloadSourceProvenance(params) {
+    if (params.call.roleId !== "worker" ||
+        params.adapter?.descriptor.requiresPayloadAuthoringObjective !== true) {
+        return undefined;
+    }
+    return projectWorkerCapabilityPayloadSourceProvenance({
+        ledger: params.ledger,
+        head: params.currentHead,
+        call: params.call,
+    });
+}
 async function settlePreparedInvocationBatch(params) {
     if (params.invocations.length === 1) {
         return settleCollapsedPreparedBatch(params);

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

@@ -2,10 +2,12 @@ export * from "./batch-selection.js";
 export * from "./binding.js";
 export * from "./controls.js";
 export * from "./contracts.js";
+export * from "./assignment-provenance.js";
 export * from "./errors.js";
 export * from "./outcome-fingerprint.js";
 export * from "./payload-author.js";
 export * from "./payload-contracts.js";
+export { isWorkerCapabilityPayloadSourceProvenanceValid, projectWorkerPayloadPlannerItemProvenance, projectWorkerPayloadRequestSourceProjection, } from "./payload-source-provenance.js";
 export * from "./scope.js";
 export * from "./selection-controls.js";
 export * from "./settled-results.js";

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

@@ -2,10 +2,12 @@ export * from "./batch-selection.js";
 export * from "./binding.js";
 export * from "./controls.js";
 export * from "./contracts.js";
+export * from "./assignment-provenance.js";
 export * from "./errors.js";
 export * from "./outcome-fingerprint.js";
 export * from "./payload-author.js";
 export * from "./payload-contracts.js";
+export { isWorkerCapabilityPayloadSourceProvenanceValid, projectWorkerPayloadPlannerItemProvenance, projectWorkerPayloadRequestSourceProjection, } from "./payload-source-provenance.js";
 export * from "./scope.js";
 export * from "./selection-controls.js";
 export * from "./settled-results.js";

package/dist/src/runtime/orchestration/worker-capabilities/payload-assignment-validation.d.ts

@@ -0,0 +1,3 @@
+import type { WorkerCapabilityPayloadAuthor } from "./payload-contracts.js";
+/** Validates payload assignment ownership before any model boundary is built. */
+export declare function isWorkerCapabilityPayloadAssignmentValid(input: Parameters<WorkerCapabilityPayloadAuthor["author"]>[0], principalKind: "worker" | "root", requestId: string): boolean;