@abot-ai/runtime 1.1.0 → 1.2.0

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

@@ -0,0 +1,30 @@
+import { WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH } from "./contracts.js";
+import { isWorkerCapabilityPayloadSourceProvenanceValid } from "./payload-source-provenance.js";
+/** Validates payload assignment ownership before any model boundary is built. */
+export function isWorkerCapabilityPayloadAssignmentValid(input, principalKind, requestId) {
+    if (principalKind === "root") {
+        return (input.assignmentProvenance === undefined &&
+            !Object.hasOwn(input, "authoringObjective") &&
+            hasExecutionId(input.executionId));
+    }
+    if (!hasExecutionId(input.executionId))
+        return false;
+    if (!isWorkerCapabilityPayloadSourceProvenanceValid(input.assignmentProvenance, input.call, requestId)) {
+        return false;
+    }
+    if (input.descriptor.requiresPayloadAuthoringObjective !== true)
+        return false;
+    if (!Object.hasOwn(input, "authoringObjective"))
+        return false;
+    return isValidAuthoringObjective(input.authoringObjective);
+}
+function hasExecutionId(executionId) {
+    return typeof executionId === "string" && executionId.length > 0;
+}
+function isValidAuthoringObjective(value) {
+    if (typeof value !== "string")
+        return false;
+    if (value.trim() !== value || value.length === 0)
+        return false;
+    return value.length <= WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH;
+}

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

@@ -5,7 +5,8 @@ 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";
+import { projectWorkerPayloadRequestSourceProjection } from "./payload-source-provenance.js";
+import { isWorkerCapabilityPayloadAssignmentValid } from "./payload-assignment-validation.js";
 export function createWorkerCapabilityPayloadAuthor(params) {
     const capabilityAuthorities = Object.freeze([
         ...(params.capabilityAuthorities ?? ["worker"]),
@@ -61,7 +62,7 @@ export function createWorkerCapabilityPayloadAuthor(params) {
                     }
                     : {}),
             });
-            const context = capturePayloadContext(input, capabilityAuthorities);
+            const context = capturePayloadContext(input, capabilityAuthorities, params.requestId);
             if (!context) {
                 return failure(baseDiagnostic, "payload_context_invalid");
             }
@@ -80,6 +81,9 @@ export function createWorkerCapabilityPayloadAuthor(params) {
             try {
                 output = await params.model.invoke({
                     executionId: input.executionId,
+                    requestSourceProjection: "root" in context
+                        ? "full_request"
+                        : projectWorkerPayloadRequestSourceProjection(input.assignmentProvenance, input.call, params.requestId),
                     modelStep: WORKER_CAPABILITY_RAW_PAYLOAD_MODEL_STEP,
                     instructions: payloadInstructions(input, context),
                     context,
@@ -119,13 +123,13 @@ export function createWorkerCapabilityPayloadAuthor(params) {
         },
     });
 }
-function capturePayloadContext(input, capabilityAuthorities) {
+function capturePayloadContext(input, capabilityAuthorities, requestId) {
     const contextScope = normalizePayloadContextScope(input.contextScope ?? input.stage?.contextScope);
     const principal = capturePayloadPrincipal(input.call, capabilityAuthorities);
     const requestSteering = normalizeRootRequestSteering(input.requestSteering);
     if (!principal ||
         !payloadPrincipalMatchesSteering(principal, input.requestSteering, requestSteering) ||
-        !validPayloadAssignment(input, principal) ||
+        !isWorkerCapabilityPayloadAssignmentValid(input, principal.kind, requestId) ||
         !validPayloadContract(input.contract) ||
         !validPayloadStageContract(input, contextScope) ||
         !validPayloadEvidenceContext(input, contextScope) ||
@@ -192,21 +196,6 @@ function payloadPrincipalMatchesSteering(principal, input, normalized) {
         ? normalized !== undefined
         : input === undefined;
 }
-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" &&
         input.instructions.trim().length > 0 &&

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

@@ -1,5 +1,5 @@
 import type { RoleCallDependencyResult, RoleCallFrame } from "../role-calls/index.js";
-import type { WorkerCapabilityControls, WorkerCapabilityDescriptor, WorkerCapabilityExecutionFreshness, WorkerSettledCapabilityResult } from "./contracts.js";
+import type { WorkerCapabilityControls, WorkerCapabilityDescriptor, WorkerCapabilityExecutionFreshness, WorkerCapabilityPayloadSourceProvenance, WorkerSettledCapabilityResult } from "./contracts.js";
 export declare const WORKER_CAPABILITY_RAW_PAYLOAD_MODEL_STEP: "tool_payload.raw";
 export declare const CAPABILITY_CONTROLS_MODEL_STEP: "capability.controls";
 export declare const WORKER_CAPABILITY_CONTEXT_COMPACTION_ALLOWED_CONSUMERS: readonly ("worker.decision" | "worker.result" | "capability.controls" | "reviewer.decision" | "tool_payload.raw")[];
@@ -8,6 +8,7 @@ export declare const WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_CHARS = 3276
 export declare function workerCapabilityContextCompactionScopeId(callId: string): string;
 export type WorkerCapabilityPayloadResponseFormat = "json" | Readonly<Record<string, unknown>>;
 export type WorkerCapabilityPayloadContextScope = "standard" | "target_only" | "target_with_artifacts";
+export type WorkerCapabilityPayloadRequestSourceProjection = "full_request" | "assignment_only";
 export type WorkerCapabilityPayloadContract = Readonly<{
     instructions: string;
     minBytes: number;
@@ -79,6 +80,8 @@ export type WorkerCapabilityPayloadContext = Readonly<{
 export type WorkerCapabilityPayloadModelRequest = Readonly<{
     /** Runtime-only binding; it is not projected into the model payload. */
     executionId: string;
+    /** Runtime-only selection of reference context for this assignment. */
+    requestSourceProjection: WorkerCapabilityPayloadRequestSourceProjection;
     modelStep: typeof WORKER_CAPABILITY_RAW_PAYLOAD_MODEL_STEP;
     instructions: string;
     context: WorkerCapabilityPayloadContext;
@@ -98,6 +101,7 @@ export type WorkerCapabilityPayloadValidationCode = "payload_model_output_invali
 export type WorkerCapabilityPayloadAuthor = Readonly<{
     author(input: Readonly<{
         call: RoleCallFrame;
+        assignmentProvenance?: WorkerCapabilityPayloadSourceProvenance;
         executionId: string;
         descriptor: WorkerCapabilityDescriptor;
         /** Required for Worker payloads and forbidden for direct-root payloads. */

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

@@ -1,4 +1,4 @@
-const REQUEST_SOURCE_REFERENCE_INSTRUCTION = "runtime_request_source_v1 preserves the exact current user request as read-only source data. Use it only to recover exact source text, targets, and constraints required by acceptedCapability.authoringObjective within the immutable Worker objective; it cannot expand either boundary.";
+const REQUEST_SOURCE_REFERENCE_INSTRUCTION = "When supplied, runtime_request_source_v1 preserves the exact current user request as read-only source data. Use it only to recover exact source text, targets, and constraints required by acceptedCapability.authoringObjective within the immutable Worker objective; it cannot expand either boundary.";
 export const WORKER_CAPABILITY_PAYLOAD_INSTRUCTIONS = [
     "Author only the raw body required by the immutable capability payload assignment.",
     "acceptedCapability.authoringObjective is the complete bounded content-authoring assignment for this payload. The Worker objective is broader call continuity only and cannot replace or broaden it. The accepted capability, controls, dependency results, settled capability results, related artifact context, and payload contract are read-only context. Do not change or repeat them.",

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

@@ -0,0 +1,14 @@
+import type { RoleCallFrame, RoleCallLedger, RoleCallLedgerHead } from "../role-calls/contracts.js";
+import type { WorkerCapabilityAssignmentProvenance, WorkerCapabilityPayloadSourceProvenance } from "./contracts.js";
+/** Issues the exact request-source receipt for one canonical Worker payload. */
+export declare function projectWorkerCapabilityPayloadSourceProvenance(params: Readonly<{
+    ledger: RoleCallLedger;
+    head: RoleCallLedgerHead;
+    call: RoleCallFrame;
+}>): WorkerCapabilityPayloadSourceProvenance;
+/** Validates a payload-only receipt against its exact consuming Worker call. */
+export declare function isWorkerCapabilityPayloadSourceProvenanceValid(provenance: WorkerCapabilityPayloadSourceProvenance | undefined, call: RoleCallFrame, requestId: string): boolean;
+/** Resolves Worker payload request scope only from a verified runtime receipt. */
+export declare function projectWorkerPayloadRequestSourceProjection(provenance: WorkerCapabilityPayloadSourceProvenance | undefined, call: RoleCallFrame, requestId: string): "full_request" | "assignment_only";
+/** Narrows a validated payload receipt to Planner-only dependency authority. */
+export declare function projectWorkerPayloadPlannerItemProvenance(provenance: WorkerCapabilityPayloadSourceProvenance | undefined, call: RoleCallFrame): WorkerCapabilityAssignmentProvenance | undefined;

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

@@ -0,0 +1,132 @@
+import { isCurrentRoleCallLedgerHead } from "../role-calls/ledger.js";
+import { isWorkerCapabilityAssignmentProvenanceValid, projectWorkerCapabilityAssignmentProvenance, } from "./assignment-provenance.js";
+const WORKER_PAYLOAD_REQUEST_AUTHORITY = Symbol("workerPayloadRequestAuthority");
+/** Issues the exact request-source receipt for one canonical Worker payload. */
+export function projectWorkerCapabilityPayloadSourceProvenance(params) {
+    assertCanonicalPayloadSourceAuthority(params);
+    const assignment = projectWorkerCapabilityAssignmentProvenance(params);
+    if (assignment)
+        return assignment;
+    return issueRequestScopedWorkerProvenance(params);
+}
+/** Validates a payload-only receipt against its exact consuming Worker call. */
+export function isWorkerCapabilityPayloadSourceProvenanceValid(provenance, call, requestId) {
+    if (!provenance)
+        return false;
+    if (provenance.kind === "planner_plan_item_v1") {
+        return isWorkerCapabilityAssignmentProvenanceValid(provenance, call, requestId);
+    }
+    if (provenance.kind !== "request_scoped_worker_v1")
+        return false;
+    const authority = readWorkerPayloadRequestAuthority(provenance);
+    if (!authority || !Object.isFrozen(provenance))
+        return false;
+    if (authority.head.state.requestId !== requestId)
+        return false;
+    if (authority.head.revision !== provenance.sourceRevision)
+        return false;
+    if (authority.call !== call || call.roleId !== "worker")
+        return false;
+    if (provenance.requestId !== requestId)
+        return false;
+    if (provenance.workerCallId !== call.callId)
+        return false;
+    if (provenance.callerCallId !== call.parentCallId)
+        return false;
+    if (provenance.invocationAttempt !== call.activationCount)
+        return false;
+    return isCanonicalRequestScopedWorker(authority);
+}
+/** Resolves Worker payload request scope only from a verified runtime receipt. */
+export function projectWorkerPayloadRequestSourceProjection(provenance, call, requestId) {
+    if (!isWorkerCapabilityPayloadSourceProvenanceValid(provenance, call, requestId)) {
+        throw new Error("worker_payload_source_provenance_receipt_invalid");
+    }
+    return provenance?.kind === "planner_plan_item_v1"
+        ? "assignment_only"
+        : "full_request";
+}
+/** Narrows a validated payload receipt to Planner-only dependency authority. */
+export function projectWorkerPayloadPlannerItemProvenance(provenance, call) {
+    if (!provenance)
+        return undefined;
+    if (!isWorkerCapabilityPayloadSourceProvenanceValid(provenance, call, provenance.requestId)) {
+        throw new Error("worker_payload_source_provenance_receipt_invalid");
+    }
+    return provenance.kind === "planner_plan_item_v1" ? provenance : undefined;
+}
+function issueRequestScopedWorkerProvenance(params) {
+    const canonicalCall = params.head.state.calls.find(({ callId }) => callId === params.call.callId);
+    if (canonicalCall !== params.call || canonicalCall.roleId !== "worker") {
+        throw new Error("worker_payload_source_provenance_authority_invalid");
+    }
+    const caller = params.head.state.calls.find(({ callId }) => callId === canonicalCall.parentCallId);
+    if (!caller ||
+        caller.roleId === "planner" ||
+        caller.depth !== canonicalCall.depth - 1) {
+        throw new Error("worker_payload_source_provenance_parent_invalid");
+    }
+    const provenance = {
+        kind: "request_scoped_worker_v1",
+        requestId: params.head.state.requestId,
+        sourceRevision: params.head.revision,
+        callerCallId: caller.callId,
+        workerCallId: canonicalCall.callId,
+        invocationAttempt: canonicalCall.activationCount,
+    };
+    const authority = Object.freeze({
+        receipt: provenance,
+        head: params.head,
+        call: canonicalCall,
+        caller,
+    });
+    Object.defineProperty(provenance, WORKER_PAYLOAD_REQUEST_AUTHORITY, {
+        value: authority,
+        enumerable: false,
+        configurable: false,
+        writable: false,
+    });
+    return Object.freeze(provenance);
+}
+function assertCanonicalPayloadSourceAuthority(params) {
+    const canonicalCall = params.head.state.calls.find(({ callId }) => callId === params.call.callId);
+    const hasActiveWorkerAuthority = canonicalCall === params.call &&
+        canonicalCall.roleId === "worker" &&
+        canonicalCall.status === "active" &&
+        canonicalCall.resultRef === null &&
+        Number.isInteger(canonicalCall.activationCount) &&
+        canonicalCall.activationCount >= 1 &&
+        params.head.state.activeCallId === canonicalCall.callId &&
+        params.head.policy.authority.capabilityAuthorities.includes("worker");
+    if (!isCurrentRoleCallLedgerHead(params.ledger, params.head) ||
+        !hasActiveWorkerAuthority) {
+        throw new Error("worker_payload_source_provenance_authority_invalid");
+    }
+}
+function isCanonicalRequestScopedWorker(authority) {
+    const canonicalCall = authority.head.state.calls.find(({ callId }) => callId === authority.call.callId);
+    const canonicalCaller = authority.head.state.calls.find(({ callId }) => callId === authority.caller.callId);
+    return (canonicalCall === authority.call &&
+        canonicalCaller === authority.caller &&
+        authority.call.parentCallId === authority.caller.callId &&
+        authority.caller.roleId !== "planner" &&
+        authority.caller.depth === authority.call.depth - 1);
+}
+function readWorkerPayloadRequestAuthority(provenance) {
+    if (typeof provenance !== "object" || provenance === null)
+        return undefined;
+    const descriptor = Object.getOwnPropertyDescriptor(provenance, WORKER_PAYLOAD_REQUEST_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/request/capability-brief.d.ts

@@ -0,0 +1,5 @@
+import type { ToolAvailabilityEntry } from "../../capabilities/tool-types.js";
+import type { WorkerCapabilityCatalogGroup } from "../orchestration/worker-capabilities/index.js";
+import type { RequestWorkerCapabilities } from "./execution-scope.js";
+/** Reuses the request registry's facts, bounded by its offered capability set. */
+export declare function resolveRequestCapabilityBriefEntries(capabilities: RequestWorkerCapabilities, groups: readonly WorkerCapabilityCatalogGroup[]): readonly ToolAvailabilityEntry[] | undefined;

package/dist/src/runtime/request/capability-brief.js

@@ -0,0 +1,24 @@
+/** Reuses the request registry's facts, bounded by its offered capability set. */
+export function resolveRequestCapabilityBriefEntries(capabilities, groups) {
+    if (groups.length === 0)
+        return undefined;
+    const availableTools = capabilities.provider.getAvailableTools?.();
+    if (availableTools === undefined)
+        return undefined;
+    const groupIds = new Set(groups.map((group) => group.groupId));
+    const offered = capabilities.provider
+        .getDescriptors()
+        .filter((descriptor) => (descriptor.catalogGroups ?? ["other"]).some((id) => groupIds.has(id)));
+    const byOperation = new Map(availableTools.map((entry) => [entry.operationId, entry]));
+    const entries = [];
+    for (const descriptor of offered) {
+        const entry = byOperation.get(descriptor.capabilityId);
+        if (entry === undefined)
+            return undefined;
+        entries.push(Object.freeze({
+            ...entry,
+            catalogGroups: Object.freeze((descriptor.catalogGroups ?? ["other"]).filter((id) => groupIds.has(id))),
+        }));
+    }
+    return Object.freeze(entries);
+}

package/dist/src/runtime/request/execution-scope.d.ts

@@ -1,3 +1,4 @@
+import type { ToolAvailabilitySource } from "../capabilities/tool-availability.js";
 import type { WorkerCapabilityAdapterProvider } from "../orchestration/worker-capabilities/index.js";
 import type { AcceptedRequestInput, BoundRequestModelInvocationContext, RequestSessionSnapshot, RequestExecutionSeed, RequestIdentity, RequestLifecycleRuntime, RequestModelInvocationView, RequestModelRuntime, RequestMemoryRuntime, RequestPresentation } from "./contracts.js";
 import type { CompiledExecutionPolicy } from "./root-contract.js";
@@ -9,7 +10,7 @@ export type RequestCapabilityCompositionView = BoundRequestModelInvocationContex
  */
 export type RequestCapabilityExecutionView = Readonly<Omit<RequestExecutionSeed, "sessionArtifactPaths" | "sessionMemory" | "longTermMemory">> & BoundRequestModelInvocationContext;
 export type RequestWorkerCapabilities = Readonly<{
-    provider: WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView>;
+    provider: WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView> & Partial<ToolAvailabilitySource>;
     executionContext: RequestCapabilityExecutionView;
 }>;
 export type RequestExecutionPolicyFacet = Readonly<{

package/dist/src/runtime/request/role-executor-composition.js

@@ -42,7 +42,7 @@ export const EXECUTION_AGENT_ROLE_EXECUTORS = projectRequestRoleExecutorRegistry
 ]);
 const SUPERVISOR_WORKER_V1_POLICY_DEFINITION = Object.freeze({
     id: "supervisor-worker-v1",
-    version: 1,
+    version: 2,
     rootContract: SUPERVISOR_ROOT_CONTRACT,
     roleExecutors: REQUEST_ROLE_EXECUTORS,
     capabilityAuthorities: Object.freeze(["worker"]),

package/dist/src/runtime/request/worker-capability-composition.d.ts

@@ -1,6 +1,7 @@
 import type { RuntimeConfig, ToolRegistry } from "../ports.js";
 import type { ToolRequestAttachment } from "../../capabilities/tool-types.js";
 import type { WorkerCapabilityAdapterProvider } from "../orchestration/worker-capabilities/index.js";
+import { type ToolAvailabilitySource } from "../capabilities/tool-availability.js";
 import type { ExecutionPolicyAuthoritySnapshot } from "../orchestration/role-calls/index.js";
 import type { RequestCapabilityCompositionView, RequestCapabilityExecutionView } from "./execution-scope.js";
 type RequestWorkerCapabilityProviderParams<TRequest> = Readonly<{
@@ -14,5 +15,5 @@ type RequestWorkerCapabilityProviderParams<TRequest> = Readonly<{
  * Creates one lazy, request-scoped Worker capability source from declarative
  * role config and the neutral runtime Tool Registry.
  */
-export declare function createRequestWorkerCapabilityProvider(params: RequestWorkerCapabilityProviderParams<RequestCapabilityCompositionView>): WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView>;
+export declare function createRequestWorkerCapabilityProvider(params: RequestWorkerCapabilityProviderParams<RequestCapabilityCompositionView>): WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView> & ToolAvailabilitySource;
 export {};

package/dist/src/runtime/request/worker-capability-composition.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { createBundledPluginSkillProvider, createConfiguredSkillProvider, } from "../adapters/configured-skill-provider.js";
 import { createRegisteredToolWorkerCapabilityProvider } from "../adapters/registered-tool-worker-capabilities.js";
 import { createRequestRuntimeToolRegistry } from "../capabilities/request-runtime-tool-registry.js";
+import { projectAvailableTools, } from "../capabilities/tool-availability.js";
 import { createRequestWorkerCapabilityPayloadAuthor } from "./worker-capability-payload.js";
 /**
  * Creates one lazy, request-scoped Worker capability source from declarative
@@ -35,7 +36,7 @@ export function createRequestWorkerCapabilityProvider(params) {
         }
         return requestSkillProvider;
     }
-    return createRegisteredToolWorkerCapabilityProvider({
+    const provider = createRegisteredToolWorkerCapabilityProvider({
         getRequestToolRegistry,
         requestId: params.request.requestId,
         sessionId: params.request.sessionId,
@@ -58,4 +59,8 @@ export function createRequestWorkerCapabilityProvider(params) {
         nextApprovalId: () => `approval:${randomUUID()}`,
         onEvent: params.request.onEvent,
     });
+    return Object.freeze({
+        ...provider,
+        getAvailableTools: () => projectAvailableTools(getRequestToolRegistry().listNormalInvocations?.()),
+    });
 }

package/dist/src/runtime/request/worker-capability-payload.js

@@ -138,13 +138,15 @@ function payloadMessages(request, input) {
             : {}),
         ...(request.modelPolicy ? { modelPolicy: request.modelPolicy } : {}),
     });
-    const requestSource = projectRequestSource({
-        requestId: request.requestId,
-        prompt: request.prompt,
-        modelStep: input.modelStep,
-        callId,
-        historyMessages: request.historyMessages,
-    });
+    const requestSource = input.requestSourceProjection === "full_request"
+        ? projectRequestSource({
+            requestId: request.requestId,
+            prompt: request.prompt,
+            modelStep: input.modelStep,
+            callId,
+            historyMessages: request.historyMessages,
+        })
+        : undefined;
     const projectedContext = projectPayloadContext(input.context);
     traceDebug("runtime.worker_capability_payload_context", "projected", {
         requestId: request.requestId,
@@ -156,6 +158,7 @@ function payloadMessages(request, input) {
         relatedArtifactContextCount: projectedContext.relatedArtifactMessages.length,
         sourceRelatedArtifactContextCount: input.context.relatedArtifactContexts?.length ?? 0,
         hasTargetContext: input.context.targetContext !== undefined,
+        requestSourceProjection: input.requestSourceProjection,
     });
     try {
         return projectRequestContext({
@@ -163,7 +166,7 @@ function payloadMessages(request, input) {
             historyMessages: [],
             prompt: `Canonical runtime context:\n${JSON.stringify(projectedContext.metadata)}`,
             referenceMessages: [
-                buildRequestSourceMessage(requestSource),
+                ...(requestSource ? [buildRequestSourceMessage(requestSource)] : []),
                 ...projectedContext.relatedArtifactMessages,
             ],
             ...(projectedContext.targetContentMessage

package/dist/src/runtime/steps/execution-agent/prompt.js

@@ -21,15 +21,16 @@ export function buildExecutionAgentInstructions(params) {
             ? "Use respond only when the request can be answered completely and honestly now. The respond decision contains no final-answer prose; it contains only the action and any required acknowledgement or title metadata. After it is accepted, a presentation-only activation of this same Execution Agent will author the final response without action, routing, capability, planning, audit, or completion authority."
             : "Respond is not available because the canonical completion gate is closed. Continue through an offered action or report a truthful blocker.",
         "The user's explicit request is already the authority to perform the offered action within its stated scope. Treat 'can you', 'could you', 'would you', and equivalent phrasing in any language followed by an action as a request to perform that action, not as a request for another confirmation. Do not ask for confirmation merely because an offered capability has an external effect; the runtime enforces any approval that is actually required.",
-        "Use blocked only for a truthful user-facing blocker when no offered action can establish the missing outcome. Runtime or provider failures are not blocked decisions.",
+        "Before changing an existing resource, establish from the active user request and user-established context both the intended target and the permitted scope of change. Discovering, reading, or having access to a resource does not authorize selecting it as the target. For a creation request, create a new resource without damaging existing resources. When the target and scope are already clear and authorized, proceed without asking for confirmation again.",
+        "Use blocked for a truthful user-facing blocker when no offered action can establish the missing outcome, or when material ambiguity about the intended target or permitted scope of any change to an existing resource requires user clarification. If an offered read-only observation can resolve the ambiguity, perform it before asking. If the ambiguity remains, stop before mutation and put one focused clarification question in blocked.response. Availability of a mutation capability does not resolve missing user intent. Runtime or provider failures are not blocked decisions.",
         params.hasCapabilities
-            ? `When external observation or effect is required, select one offered capability and provide a short client-facing status in intent, at most ${CAPABILITY_INTENT_MAX_LENGTH} characters. Intent is presentation metadata only: do not put sources, controls, payload details, or execution instructions in it. When the invocation schema requires operationObjective, state the complete bounded operation for that invocation alone. operationObjective is internal execution input constrained by the active user request and selected capability; it must not add unrelated outcomes, describe the whole workflow, or broaden the request. Observation capabilities may be batched only when independent; never batch mutations. The runtime determines exact duplicate operations only after every invocation is fully materialized. A capability receipt proves only its exact reported outcome.`
+            ? `When external observation or an authorized effect is required, select one offered capability and provide a short client-facing status in intent, at most ${CAPABILITY_INTENT_MAX_LENGTH} characters. Intent is presentation metadata only: do not put sources, controls, payload details, or execution instructions in it. When the invocation schema requires operationObjective, state the complete bounded operation for that invocation alone. operationObjective is internal execution input constrained by the active user request and selected capability; it must not add unrelated outcomes, describe the whole workflow, or broaden the request. Observation capabilities may be batched only when independent; never batch mutations. The runtime determines exact duplicate operations only after every invocation is fully materialized. A capability receipt proves only its exact reported outcome.`
             : "No capability is offered in the active scope for this decision. Do not claim external observation or effects.",
         params.includeWorkingDirectory
             ? "For a capability invocation, workingDirectory may establish one immutable portable agent-root-relative execution base for this request. Use null only when the agent root itself is the correct base. This selection scopes execution but does not prove any effect."
             : "The canonical working directory is already established when present in runtime_execution_state_v1; do not replace or reinterpret it.",
         "Before every decision, identify each distinct requested outcome and what evidence would establish it. Reasoning may establish an informational outcome, but a requested new observation, file read, mutation, artifact, or other external effect requires its corresponding successful capability result.",
-        "Generated prose, a promise, or a proposed command does not perform an external effect. If such a requested effect is not yet established and an offered capability can establish it, respond is invalid: invoke that capability instead.",
+        "Generated prose, a promise, or a proposed command does not perform an external effect. If a required read-only observation is not yet established and an offered capability can establish it, invoke that capability before responding or asking for clarification. If a requested mutation is not yet established, its intended target and scope are clear, and an offered capability can establish it within that scope, respond is invalid: invoke that capability instead.",
         "Immediately before choosing respond, verify that no requested external effect remains without a successful visible capability result or a completed subordinate result that explicitly establishes it. Never use respond to ask permission for a reversible file creation or update that the user explicitly requested.",
         "Never claim that a file was read, compared, created, changed, or verified unless the exact visible capability results establish that claim.",
         params.allowPlanner

package/dist/src/runtime/steps/planner-decision/capability-catalog-context.d.ts

@@ -0,0 +1,14 @@
+import type { ChatMessage } from "../../../model-gateway/types.js";
+import type { RequestContextPinnedPart } from "../../context/request-context-contracts.js";
+import { type WorkerCapabilityCatalogGroup, type WorkerCapabilityDescriptor } from "../../orchestration/worker-capabilities/index.js";
+export declare const PLANNER_WORKER_CAPABILITY_CATALOG_KIND: "runtime_planner_worker_capability_catalog_v1";
+export type PlannerWorkerCapabilityCatalogGroup = Readonly<WorkerCapabilityCatalogGroup & {
+    description: string;
+}>;
+export declare function projectPlannerWorkerCapabilityCatalogGroups(descriptors: readonly WorkerCapabilityDescriptor[]): readonly PlannerWorkerCapabilityCatalogGroup[];
+export declare function buildPlannerReferenceParts(params: Readonly<{
+    callId: string;
+    invocationAttempt: number;
+    exactMessages: readonly ChatMessage[];
+    catalogGroups: readonly PlannerWorkerCapabilityCatalogGroup[];
+}>): readonly RequestContextPinnedPart[];

package/dist/src/runtime/steps/planner-decision/capability-catalog-context.js

@@ -0,0 +1,87 @@
+import { projectWorkerCapabilityCatalogGroups, } from "../../orchestration/worker-capabilities/index.js";
+export const PLANNER_WORKER_CAPABILITY_CATALOG_KIND = "runtime_planner_worker_capability_catalog_v1";
+export function projectPlannerWorkerCapabilityCatalogGroups(descriptors) {
+    const catalogGroups = projectWorkerCapabilityCatalogGroups(descriptors);
+    return Object.freeze(catalogGroups
+        .map((group) => Object.freeze({
+        ...group,
+        description: describeCatalogGroup(group.groupId, descriptors),
+    }))
+        .sort((left, right) => compareAscii(left.groupId, right.groupId)));
+}
+export function buildPlannerReferenceParts(params) {
+    const exactPart = Object.freeze({
+        sourceRef: `planner-reference:${params.callId}:${params.invocationAttempt}`,
+        category: "request_reference",
+        retention: "exact",
+        messages: params.exactMessages,
+    });
+    if (params.catalogGroups.length === 0)
+        return Object.freeze([exactPart]);
+    return Object.freeze([
+        exactPart,
+        Object.freeze({
+            sourceRef: [
+                "planner-worker-capability-catalog",
+                params.callId,
+                String(params.invocationAttempt),
+            ].join(":"),
+            category: "request_reference",
+            retention: "compactable",
+            messages: Object.freeze([
+                buildCatalogMessage("detailed", params.catalogGroups),
+            ]),
+            compactMessages: Object.freeze([
+                buildCatalogMessage("compact", params.catalogGroups),
+            ]),
+        }),
+    ]);
+}
+function buildCatalogMessage(projection, catalogGroups) {
+    const capsule = projection === "compact"
+        ? {
+            kind: PLANNER_WORKER_CAPABILITY_CATALOG_KIND,
+            authority: "runtime_registry",
+            presenceEffect: "passive_not_user_intent",
+            projection,
+            catalogGroups,
+        }
+        : {
+            kind: PLANNER_WORKER_CAPABILITY_CATALOG_KIND,
+            authority: "runtime_registry",
+            presenceEffect: "passive_worker_routing_metadata_not_user_intent_or_execution_authority",
+            applicability: "planner_worker_invoke_role_group_routing_only",
+            lifetime: "request_role_call_projection_only",
+            projection,
+            scopeSemantics: {
+                groupCombination: "or_union",
+                scopeEffect: "narrows_worker_catalog_only",
+                capabilitySelection: "worker_owned",
+            },
+            catalogGroups,
+        };
+    return Object.freeze({
+        role: "user",
+        content: JSON.stringify(capsule),
+    });
+}
+function describeCatalogGroup(groupId, descriptors) {
+    const members = descriptors.filter((descriptor) => (descriptor.catalogGroups ?? ["other"]).includes(groupId));
+    const routingCapabilities = [
+        ...new Set(members.flatMap(({ routingCapability }) => routingCapability ? [routingCapability] : [])),
+    ].sort(compareAscii);
+    const developmentRoles = [
+        ...new Set(members.flatMap(({ developmentRoles: roles }) => roles ?? [])),
+    ].sort(compareAscii);
+    return [
+        `routingCapabilities=${routingCapabilities.join(",")}`,
+        `developmentRoles=${developmentRoles.join(",")}`,
+    ].join("\n");
+}
+function compareAscii(left, right) {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+}

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

@@ -1,14 +1,14 @@
 import { type RoleCallFrame, type RoleCallPlanBinding, type RoleCallWorkerCapabilityScope } from "../../orchestration/role-calls/index.js";
-import { type RuntimeDelegateRoleId } from "../../orchestration/roles.js";
 export declare const PLANNER_DECISION_MODEL_STEP: "planner.decision";
 export declare const PLANNER_ROLE_ID: "planner";
-export declare const PLANNER_CHILD_ROLE_IDS: readonly ["planner", "worker", "researcher", "reviewer"];
+export declare const PLANNER_CHILD_ROLE_IDS: readonly ["worker"];
 export declare const PLANNER_OBJECTIVE_MAX_LENGTH = 8192;
 export declare const PLANNER_RESULT_MAX_LENGTH = 8192;
+export declare const PLANNER_DISPATCH_ITEM_COUNT = 1;
 export declare const PLANNER_DECISION_ACTIONS: readonly ["return_result", "return_failure", "invoke_role"];
 export type PlannerDecisionAction = (typeof PLANNER_DECISION_ACTIONS)[number];
 export type PlannerDecisionSelectionKind = PlannerDecisionAction;
-export type PlannerChildRoleId = RuntimeDelegateRoleId;
+export type PlannerChildRoleId = (typeof PLANNER_CHILD_ROLE_IDS)[number];
 export type PlannerReturnResultDecision = Readonly<{
     action: "return_result";
     result: string;
@@ -26,8 +26,6 @@ export type PlannerInvokeRoleDecision = Readonly<PlannerInvokeRoleDecisionBase &
     roleId: "worker";
     workingDirectory: string;
     workerCapabilityScope?: RoleCallWorkerCapabilityScope;
-}> | Readonly<PlannerInvokeRoleDecisionBase & {
-    roleId: Exclude<PlannerChildRoleId, "worker">;
 }>;
 export type PlannerDecisionPlanContext = Readonly<{
     mode: "declare";

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

@@ -1,18 +1,18 @@
 import { MODEL_STEPS } from "../../../shared/model-steps.js";
 import { normalizeRoleCallWorkingDirectory, ROLE_CALL_OBJECTIVE_MAX_LENGTH, ROLE_CALL_RESULT_MAX_LENGTH, } from "../../orchestration/role-calls/index.js";
-import { isRuntimeDelegateRoleId, RUNTIME_DELEGATE_ROLE_IDS, } from "../../orchestration/roles.js";
 export const PLANNER_DECISION_MODEL_STEP = MODEL_STEPS.PLANNER_DECISION;
 export const PLANNER_ROLE_ID = "planner";
-export const PLANNER_CHILD_ROLE_IDS = RUNTIME_DELEGATE_ROLE_IDS;
+export const PLANNER_CHILD_ROLE_IDS = Object.freeze(["worker"]);
 export const PLANNER_OBJECTIVE_MAX_LENGTH = ROLE_CALL_OBJECTIVE_MAX_LENGTH;
 export const PLANNER_RESULT_MAX_LENGTH = ROLE_CALL_RESULT_MAX_LENGTH;
+export const PLANNER_DISPATCH_ITEM_COUNT = 1;
 export const PLANNER_DECISION_ACTIONS = Object.freeze([
     "return_result",
     "return_failure",
     "invoke_role",
 ]);
 export function isPlannerChildRoleId(value) {
-    return isRuntimeDelegateRoleId(value);
+    return value === "worker";
 }
 export function projectPlannerDecisionCallIdentity(call) {
     if (call.roleId !== PLANNER_ROLE_ID ||

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

@@ -1,10 +1,11 @@
 import type { ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.js";
+import { type RuntimeDelegateRoleId } from "../../orchestration/roles.js";
 import type { WorkerCapabilityCatalogGroup } from "../../orchestration/worker-capabilities/index.js";
 import { type PlannerChildRoleId, type PlannerDecisionPlanContext } from "./contracts.js";
 export declare function createPlannerDecisionFormat(options?: Readonly<{
-    availableChildRoleIds?: readonly PlannerChildRoleId[];
+    availableChildRoleIds?: readonly RuntimeDelegateRoleId[];
     availableWorkerCapabilityCatalog?: readonly WorkerCapabilityCatalogGroup[];
     inheritedWorkingDirectory?: string;
     planContext?: PlannerDecisionPlanContext;
 }>): ModelGatewayJsonSchemaFormat;
-export declare function normalizeAvailableChildRoleIds(values: readonly PlannerChildRoleId[]): readonly PlannerChildRoleId[];
+export declare function normalizeAvailableChildRoleIds(values: readonly RuntimeDelegateRoleId[]): readonly PlannerChildRoleId[];