@abot-ai/runtime 1.9.0 → 2.0.0

package/dist/src/runtime/steps/execution-agent/evidence-reuse-instructions.js

@@ -0,0 +1,13 @@
+/** Decision-only policy; source evidence remains in its canonical context lane. */
+export const EXECUTION_EVIDENCE_REUSE_INSTRUCTIONS = [
+    "Use the latest supplied continuation checkpoint and settled evidence as your working memory. First establish what they already tell you about the next requested outcome. When that evidence is sufficient, continue the work; do not reread just to restore the original wording or the complete file after compaction.",
+    "A read has real latency and token cost and can cause another compaction. Before selecting a repeated observation, identify the concrete fact still missing from the supplied evidence, or the relevant change that makes the evidence stale. Choose the smallest lookup or range that resolves that gap rather than collecting the same file again.",
+    "For an existing-file edit, the selected editor loads the current target itself. Reuse the collected interface and dependency facts to specify the change; do not reread the target solely to supply its full body to that editor. Related files still require evidence when their relevant contract is not already supplied.",
+    "Conserve reads without weakening grounding: never invent missing values, treat omissions as absence, ignore a relevant change, or skip required verification merely to save a call. If a necessary fact is genuinely missing, obtain it with a focused observation.",
+    "",
+].join("\n");
+export function appendExecutionEvidenceReuseInstructions(params) {
+    if (!params.hasCapabilities)
+        return params.instructions;
+    return [params.instructions, EXECUTION_EVIDENCE_REUSE_INSTRUCTIONS].join("\n\n");
+}

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

@@ -2,8 +2,9 @@ import { directResponseVariants } from "./direct-response-contract.js";
 import { createMemoryRecallDecisionSchema } from "../memory-recall-decision.js";
 import { createExecutionWorkPlanDecisionSchema } from "./work-plan-schema.js";
 import { isToolCatalogGroupId } from "../../../capabilities/tool-types.js";
-import { CAPABILITY_COUNT_MAX, EXECUTION_WORKING_DIRECTORY_MAX_LENGTH, EXECUTION_WORKING_DIRECTORY_PATTERN, canOfferCapabilityBatchSelection, normalizeCapabilityDescriptor, normalizeCapabilityControlsSchema, partitionCapabilityControlsSchema, } from "../../orchestration/capability-adapters/index.js";
+import { CAPABILITY_COUNT_MAX, EXECUTION_WORKING_DIRECTORY_MAX_LENGTH, EXECUTION_WORKING_DIRECTORY_PATTERN, canOfferCapabilityBatchSelection, normalizeCapabilityDescriptor, } from "../../orchestration/capability-adapters/index.js";
 import { EXECUTION_AGENT_ACKNOWLEDGEMENT_MAX_LENGTH, EXECUTION_AGENT_AUDIT_CRITERION_COUNT_MAX, EXECUTION_AGENT_AUDIT_CRITERION_ID_MAX_LENGTH, EXECUTION_AGENT_CAPABILITY_SCOPE_GROUP_COUNT_MAX, EXECUTION_AGENT_CAPABILITY_BATCH_COUNT_MAX, EXECUTION_AGENT_OBJECTIVE_MAX_LENGTH, EXECUTION_AGENT_RESPONSE_MAX_LENGTH, EXECUTION_AGENT_TITLE_MAX_LENGTH, } from "./contracts.js";
+import { partitionExecutionCapabilityControls } from "./capability-controls-partition.js";
 import { projectCapabilitySelectionProperties } from "./capability-selection-schema.js";
 import { freezeControlsEvidenceEligibility } from "./controls-evidence-contract.js";
 export function createExecutionAgentDecisionFormat(options = {}) {
@@ -183,11 +184,7 @@ export function prepareExecutionAgentDecisionContract(options) {
         if (!normalized.ok) {
             throw new Error("execution_agent_capabilities_invalid");
         }
-        const controls = normalizeCapabilityControlsSchema(normalized.value.controls);
-        if (!controls.ok) {
-            throw new Error("execution_agent_capabilities_invalid");
-        }
-        const partition = partitionCapabilityControlsSchema(controls.value, normalized.value.selectionControlIds);
+        const partition = partitionExecutionCapabilityControls(normalized.value);
         if (!partition.ok) {
             throw new Error("execution_agent_capabilities_invalid");
         }

package/dist/src/runtime/steps/execution-agent/input.d.ts

@@ -2,11 +2,13 @@ import type { ChatMessage, ModelGatewayJsonSchemaFormat } from "../../../model-g
 import type { RequestContextProjection } from "../../context/request-context-contracts.js";
 import type { ExecutionMemoryProjection } from "../../long-term-memory/initial-context.js";
 import type { RoleCallFrame, RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
-import { type CapabilityCatalogGroup, type CapabilityDescriptor } from "../../orchestration/capability-adapters/index.js";
+import type { CapabilityCatalogGroup, CapabilityDescriptor } from "../../orchestration/capability-adapters/index.js";
 import { type RequestExecutionScope } from "../../request/execution-scope.js";
 import { appendRequestSteeringContext } from "../../request/request-steering-context.js";
 import type { RequestSteeringSnapshot } from "../../request/request-steering.js";
 import { EXECUTION_AGENT_DECISION_MODEL_STEP, type ExecutionAgentDecisionContractOptions } from "./contracts.js";
+import { type ExecutionCapabilityScope } from "./capability-scope.js";
+import { type ExecutionObservationGuidance } from "./observation-guidance.js";
 export type ExecutionAgentInput = Readonly<{
     context: RequestContextProjection;
     messages: ReturnType<typeof appendRequestSteeringContext>;
@@ -27,6 +29,8 @@ type BuildExecutionAgentInputOptions = Readonly<{
     allowAuditor: boolean;
     memoryRecallMessage?: ChatMessage;
     memoryContext?: ExecutionMemoryProjection;
+    capabilityScope?: ExecutionCapabilityScope;
+    observationGuidance?: readonly ExecutionObservationGuidance[];
 }>;
 export declare function buildExecutionAgentInput(request: RequestExecutionScope, options: BuildExecutionAgentInputOptions): ExecutionAgentInput;
 export {};

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

@@ -14,7 +14,6 @@ import { buildRequestTemporalContextMessage } from "../../context/request-tempor
 import { projectScheduledExecutionContext } from "../../context/scheduled-execution-context.js";
 import { buildImmediateOperationSupervisionEvidenceMessage } from "../../context/operation-supervision-evidence.js";
 import { resolveModelContextBudget } from "../../model/model-context-budget.js";
-import { projectCapabilityCatalogGroups, projectCapabilityScope, } from "../../orchestration/capability-adapters/index.js";
 import { resolveRequestWorkerCapabilities, } from "../../request/execution-scope.js";
 import { resolveRequestCapabilityBriefEntries } from "../../request/capability-brief.js";
 import { appendRequestSteeringContext } from "../../request/request-steering-context.js";
@@ -24,34 +23,15 @@ import { projectEligibleControlsEvidenceExecutionIds, requiresControlsEvidenceSe
 import { createExecutionAgentDecisionFormat, prepareExecutionAgentDecisionContract, } from "./format.js";
 import { projectExecutionWorkPlanOptions } from "./work-plan-sources.js";
 import { buildExecutionAgentInstructions } from "./prompt.js";
+import { appendExecutionEvidenceReuseInstructions } from "./evidence-reuse-instructions.js";
+import { assertExecutionAgentCanonicalSource, resolveExecutionCapabilityScope, } from "./capability-scope.js";
+import { buildExecutionObservationGuidanceInstructions, } from "./observation-guidance.js";
 import { buildExecutionCapabilityCatalogMessage, buildExecutionCapabilityGroupCatalogMessage, buildExecutionContinuationMessages, buildExecutionDecisionStateMessage, } from "./state-context.js";
 export function buildExecutionAgentInput(request, options) {
-    assertCanonicalSource(request, options.head, options.call);
+    assertExecutionAgentCanonicalSource(request, options.head, options.call);
     const directResponse = resolveDirectResponseOffer(request, options.head, options.call);
-    const allCapabilities = resolveRequestWorkerCapabilities(request).provider.getDescriptors();
-    const capabilityCatalogGroups = projectCapabilityCatalogGroups(allCapabilities);
-    const activeCapabilityCatalogGroupIds = options.call.workerCapabilityScope?.catalogGroupIds ?? null;
+    const { capabilities, capabilityCatalogGroups, activeCapabilityCatalogGroupIds, knownGroupIds, remainingExecutions, capabilityScopeAction, } = options.capabilityScope ?? resolveExecutionCapabilityScope(request, options);
     const eligibleSessionArtifactPaths = projectEligibleSessionArtifactPaths(request.sessionArtifactPaths, options.head, options.call);
-    const remainingExecutions = options.head.policy.limits.maxCapabilityExecutions -
-        options.head.state.capabilityExecutions.length;
-    const scopedCapabilities = activeCapabilityCatalogGroupIds !== null && remainingExecutions > 0
-        ? projectCapabilityScope({
-            entries: allCapabilities,
-            scope: options.call.workerCapabilityScope,
-            descriptorOf: (entry) => entry,
-        }).entries
-        : Object.freeze([]);
-    const capabilities = scopedCapabilities;
-    const knownGroupIds = Object.freeze(capabilityCatalogGroups.map(({ groupId }) => groupId));
-    const hasInactiveGroup = activeCapabilityCatalogGroupIds !== null &&
-        knownGroupIds.some((groupId) => !activeCapabilityCatalogGroupIds.includes(groupId));
-    const capabilityScopeAction = remainingExecutions <= 0 || knownGroupIds.length === 0
-        ? null
-        : activeCapabilityCatalogGroupIds === null
-            ? "open"
-            : hasInactiveGroup
-                ? "extend"
-                : null;
     const auditInput = projectAuditorInputState(options.head, options.call.callId, options.steeringSnapshot.version);
     const availableAuditCriterionIds = options.allowAuditor && auditInput.available
         ? Object.freeze([EXECUTION_AGENT_ROOT_AUDIT_CRITERION_ID])
@@ -114,6 +94,7 @@ export function buildExecutionAgentInput(request, options) {
             includeTitle: options.includeTitle,
             includeWorkingDirectory: options.call.workingDirectory === undefined,
         }),
+        ...buildExecutionObservationGuidanceInstructions(capabilities, options.observationGuidance ?? []),
         ...buildDirectResponseInstructions(directResponse.maxLength, request.runnerConfig, directMemoryAuthoring !== undefined),
         ...buildConversationMemoryAvailabilityInstructions(request.longTermMemory?.enabled === true),
         ...buildSparkConversationInstructions(request.sessionKind),
@@ -156,7 +137,10 @@ export function buildExecutionAgentInput(request, options) {
         maxLength: directResponse.maxLength ?? null,
     });
     const contextInput = {
-        instructions: scheduledExecution.instructions,
+        instructions: appendExecutionEvidenceReuseInstructions({
+            instructions: scheduledExecution.instructions,
+            hasCapabilities: capabilities.length > 0,
+        }),
         format,
         ...sessionMemory,
         prompt: request.prompt,
@@ -205,13 +189,3 @@ function projectEligibleSessionArtifactPaths(sessionArtifactPaths, head, call) {
         .slice(0, 8)
         .filter((target) => !currentRequestTargets.has(target)));
 }
-function assertCanonicalSource(request, head, call) {
-    if (head.state.requestId !== request.requestId ||
-        head.state.phase !== "running" ||
-        head.state.rootCallId !== call.callId ||
-        head.state.activeCallId !== call.callId ||
-        call.parentCallId !== null ||
-        call.status !== "active") {
-        throw new Error("execution_agent_head_invalid");
-    }
-}

package/dist/src/runtime/steps/execution-agent/observation-guidance.d.ts

@@ -0,0 +1,11 @@
+import type { CapabilityDescriptor } from "../../orchestration/capability-adapters/index.js";
+import { type RequestExecutionScope } from "../../request/execution-scope.js";
+import type { ExecutionCapabilityScope } from "./capability-scope.js";
+export type ExecutionObservationGuidance = Readonly<{
+    capabilityId: string;
+    guidance: string;
+}>;
+/** Load only the contracts whose operational values this decision will own. */
+export declare function loadExecutionObservationGuidance(request: RequestExecutionScope, scope: ExecutionCapabilityScope): Promise<readonly ExecutionObservationGuidance[]>;
+/** Preserve complete rules, deduplicate shared bodies, and bind applicability. */
+export declare function buildExecutionObservationGuidanceInstructions(capabilities: readonly CapabilityDescriptor[], guidance: readonly ExecutionObservationGuidance[]): readonly string[];

package/dist/src/runtime/steps/execution-agent/observation-guidance.js

@@ -0,0 +1,33 @@
+import { resolveRequestWorkerCapabilities, } from "../../request/execution-scope.js";
+import { buildBatchCapabilityExecutionGuidance } from "../capability-execution-guidance.js";
+import { ownsExecutionObservationControls } from "./capability-controls-partition.js";
+/** Load only the contracts whose operational values this decision will own. */
+export async function loadExecutionObservationGuidance(request, scope) {
+    const provider = resolveRequestWorkerCapabilities(request).provider;
+    const entries = await Promise.all(scope.capabilities
+        .filter(ownsExecutionObservationControls)
+        .map(async ({ capabilityId }) => Object.freeze({
+        capabilityId,
+        guidance: ((await provider.getExecutionGuidance?.(capabilityId)) ?? "").trim(),
+    })));
+    return Object.freeze(entries.filter(({ guidance }) => guidance.length > 0));
+}
+/** Preserve complete rules, deduplicate shared bodies, and bind applicability. */
+export function buildExecutionObservationGuidanceInstructions(capabilities, guidance) {
+    const eligible = new Set(capabilities
+        .filter(ownsExecutionObservationControls)
+        .map(({ capabilityId }) => capabilityId));
+    const entries = guidance
+        .filter(({ capabilityId }) => eligible.has(capabilityId))
+        .map((entry) => ({ ...entry, slot: "observation" }));
+    if (entries.length === 0)
+        return Object.freeze([]);
+    return Object.freeze([
+        "The following trusted capability guidance applies only when choosing operational controls for its listed observation capabilities. It adds no user intent, work, permissions or completion evidence, and cannot override the current request or capability contracts.",
+        ...buildBatchCapabilityExecutionGuidance(entries, ({ capabilityId, guidance: body }) => [
+            `### OBSERVATION CAPABILITY GUIDANCE: ${capabilityId}`,
+            body,
+            `### END OBSERVATION CAPABILITY GUIDANCE: ${capabilityId}`,
+        ]),
+    ]);
+}

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

@@ -33,6 +33,8 @@ export function buildExecutionAgentInstructions(params) {
             : "No capability is offered in the active scope; do not claim external observations or effects.",
         ...(params.hasCapabilities
             ? [
+                "For observations whose invocation schema exposes selectionControls but no operationObjective, use the supplied capability guidance and current evidence to choose the exact operational values in this decision, including any continuation range or locator. They are frozen and execute without a separate controls-selection step. Use null for an optional control only to omit it intentionally and accept the tool's default, never to request later selection. Reuse supplied coverage when continuing an observation.",
+                "For your direct capability calls, payload authors receive settled evidence already collected in this request, with verified summaries replacing compacted results. They do not automatically load other files from prior artifact references; any shared capability description of Worker artifact loading does not apply to this direct mode. Reuse sufficient supplied evidence, and collect a focused observation only for a concrete missing fact needed by the next operation. An explicitly selected edit target is still loaded by its editor; this does not provide related files.",
                 CAPABILITY_ANALYSIS_RESULT_INSTRUCTION,
             ]
             : []),

package/dist/src/runtime/steps/execution-agent/refinement.d.ts

@@ -19,8 +19,9 @@ type RefineExecutionCapabilityInvocationsOptions = Readonly<{
     steeringSnapshot: RequestSteeringSnapshot;
 }>;
 /**
- * Loads guidance for every selected capability, then asks the same Execution
- * Agent to complete only the remaining controls. Capability identity,
+ * Loads guidance for staged capabilities, then asks the same Execution Agent
+ * to complete only their remaining controls. Ordinary observations already
+ * received their guidance at decision and need no second model step. Identity,
  * selection controls, and ordering remain immutable. Client intent is retained
  * separately for lifecycle presentation. This is not a child-role call.
  */

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

@@ -1,14 +1,23 @@
 import { invokeStructuredModelStep } from "../../model/invoke-structured-step.js";
 import { createStructuredDecisionEnvelopeSchema, readStructuredDecisionEnvelope, } from "../../model/structured-decision-envelope.js";
-import { CAPABILITY_CONTROLS_MODEL_STEP, materializeCapabilityControlsIfComplete, mergeCapabilityControls, partitionCapabilityControlsSchema, } from "../../orchestration/capability-adapters/index.js";
+import { CAPABILITY_CONTROLS_MODEL_STEP, materializeCapabilityControlsIfComplete, mergeCapabilityControls, } from "../../orchestration/capability-adapters/index.js";
 import { resolveRequestWorkerCapabilities, } from "../../request/execution-scope.js";
+import { ownsExecutionObservationControls, partitionExecutionCapabilityControls, } from "./capability-controls-partition.js";
 import { requiresExecutionOperationObjective } from "./capability-invocation-contract.js";
 import { buildExecutionControlsRefinementInstructions } from "./refinement-prompt.js";
 import { buildExecutionControlsRefinementInput, executionRefinementSlotId as slotId, } from "./refinement-input.js";
 import { requiresControlsEvidenceSelection } from "./controls-evidence-contract.js";
+function canExecuteWithSelectedControls(descriptor, controls, guidance) {
+    if (controls === undefined)
+        return false;
+    if (ownsExecutionObservationControls(descriptor))
+        return true;
+    return guidance.length === 0;
+}
 /**
- * Loads guidance for every selected capability, then asks the same Execution
- * Agent to complete only the remaining controls. Capability identity,
+ * Loads guidance for staged capabilities, then asks the same Execution Agent
+ * to complete only their remaining controls. Ordinary observations already
+ * received their guidance at decision and need no second model step. Identity,
  * selection controls, and ordering remain immutable. Client intent is retained
  * separately for lifecycle presentation. This is not a child-role call.
  */
@@ -21,7 +30,7 @@ export async function refineExecutionCapabilityInvocations(request, options) {
         if (!descriptor) {
             throw new Error("execution_capability_refinement_descriptor_missing");
         }
-        const partition = partitionCapabilityControlsSchema(descriptor.controls, descriptor.selectionControlIds);
+        const partition = partitionExecutionCapabilityControls(descriptor);
         if (!partition.ok) {
             throw new Error("execution_capability_refinement_schema_invalid");
         }
@@ -47,14 +56,16 @@ export async function refineExecutionCapabilityInvocations(request, options) {
         });
     });
     const guidanceByCapabilityId = new Map(await Promise.all([
-        ...new Set(prepared.map(({ descriptor }) => descriptor.capabilityId)),
+        ...new Set(prepared
+            .filter(({ descriptor }) => !ownsExecutionObservationControls(descriptor))
+            .map(({ descriptor }) => descriptor.capabilityId)),
     ].map(async (capabilityId) => [
         capabilityId,
         ((await resolveRequestWorkerCapabilities(request).provider.getExecutionGuidance?.(capabilityId)) ?? "").trim(),
     ])));
     const pending = Object.freeze(prepared.flatMap((entry) => {
         const guidance = guidanceByCapabilityId.get(entry.descriptor.capabilityId) ?? "";
-        if (entry.controls !== undefined && guidance.length === 0)
+        if (canExecuteWithSelectedControls(entry.descriptor, entry.controls, guidance))
             return [];
         return [
             Object.freeze({

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

@@ -8,6 +8,8 @@ import { EXECUTION_AGENT_DECISION_MODEL_STEP, EXECUTION_AGENT_RESPONSE_MODEL_STE
 import { createExecutionAgentCompactionController } from "./compaction.js";
 import { createSessionMemoryAwareCompactionController } from "../../context/session-memory/index.js";
 import { buildExecutionAgentInput } from "./input.js";
+import { resolveExecutionCapabilityScope } from "./capability-scope.js";
+import { loadExecutionObservationGuidance } from "./observation-guidance.js";
 import { parseExecutionAgentDecisionOutput } from "./parser.js";
 import { refineExecutionCapabilityInvocations } from "./refinement.js";
 import { createRefinementInvalidOutputCause } from "./refinement-reconsideration.js";
@@ -15,7 +17,11 @@ export async function runExecutionAgentDecision(request, options) {
     assertBoundModelStepSteeringCurrent(resolveRequestSteeringInbox(request.requestSteering), resolveMemoryRecallSteeringVersion(options.memoryRecallMessage, request.requestId, options.call.callId));
     assertBoundModelStepSteeringCurrent(resolveRequestSteeringInbox(request.requestSteering), options.steeringSnapshot.version);
     const memoryContext = projectExecutionAgentMemory(request, options.head.state.initialMemory, options.steeringSnapshot);
-    const input = buildExecutionAgentInput(request, { ...options, memoryContext });
+    const capabilityScope = resolveExecutionCapabilityScope(request, options);
+    const observationGuidance = await loadExecutionObservationGuidance(request, capabilityScope);
+    const input = buildExecutionAgentInput(request, {
+        ...options, memoryContext, capabilityScope, observationGuidance,
+    });
     const accepted = await invokeStructuredModelStep({
         request,
         boundSteeringVersion: options.steeringSnapshot.version,

package/dist/src/runtime/steps/skill-read-decision.d.ts

@@ -31,4 +31,5 @@ export declare function parseSkillReadDecision(record: Readonly<Record<string, u
     stage: "domain_parser";
     issues: readonly SkillReadValidationIssue[];
 }>;
+export declare function classifySkillReadReferences(value: unknown): "valid" | "invalid" | "duplicate";
 export {};

package/dist/src/runtime/steps/skill-read-decision.js

@@ -67,13 +67,18 @@ export function parseSkillReadDecision(record, options) {
     };
 }
 function hasValidSkillReadReferences(value) {
+    return classifySkillReadReferences(value) === "valid";
+}
+export function classifySkillReadReferences(value) {
     if (!Array.isArray(value))
-        return false;
+        return "invalid";
     if (value.length === 0 || value.length > KNOWLEDGE_SKILL_READ_MAX_ITEMS)
-        return false;
+        return "invalid";
     if (!value.every(isKnowledgeSkillReadReference))
-        return false;
-    return new Set(value).size === value.length;
+        return "invalid";
+    if (new Set(value).size !== value.length)
+        return "duplicate";
+    return "valid";
 }
 function hasBoundedSkillPresentation(value, maximum) {
     if (typeof value !== "string")

package/dist/src/runtime/steps/supervisor-decision/artifact-paths.d.ts

@@ -1,6 +1,6 @@
 import type { ChatMessage, ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.js";
 import type { projectRequestContext } from "../../context/request-context.js";
-import type { ModelStepContextCompactionController } from "../../model/model-step-port.js";
+import type { ModelStepContextCompactionController, ModelStepOptionalContextProjection } from "../../model/model-step-port.js";
 import type { RequestExecutionScope } from "../../request/execution-scope.js";
 export type SupervisorArtifactPathsProjection = Readonly<{
     instructions: string;
@@ -13,6 +13,11 @@ export declare function projectSupervisorArtifactPaths(params: Readonly<{
     context: Parameters<typeof projectRequestContext>[0];
     additionalBudgetMessages?: readonly ChatMessage[];
 }>): SupervisorArtifactPathsProjection | undefined;
+/** Exact phases may omit this bound optional reference without invoking compaction. */
+export declare function createSupervisorArtifactPathsOptionalProjection(options: Readonly<{
+    projection?: SupervisorArtifactPathsProjection;
+    includeInstructions: boolean;
+}>): ModelStepOptionalContextProjection | undefined;
 /** Optional paths yield to the current attempt's mandatory context and catalog. */
 export declare function createSupervisorArtifactPathsReadmissionController(request: RequestExecutionScope, options: Readonly<{
     controller: ModelStepContextCompactionController;

package/dist/src/runtime/steps/supervisor-decision/artifact-paths.js

@@ -34,6 +34,21 @@ export function projectSupervisorArtifactPaths(params) {
         message: artifactPaths.message,
     };
 }
+/** Exact phases may omit this bound optional reference without invoking compaction. */
+export function createSupervisorArtifactPathsOptionalProjection(options) {
+    const { projection } = options;
+    if (!projection)
+        return undefined;
+    return (messages) => {
+        const index = messages.findIndex((message) => matchesBoundArtifactMessage(message, projection.message));
+        if (index < 0)
+            return messages;
+        const withoutArtifact = messages.filter((_, candidate) => candidate !== index);
+        return options.includeInstructions
+            ? replaceBoundInstructionPrefix(withoutArtifact, projection.instructions, projection.baseInstructions)
+            : withoutArtifact;
+    };
+}
 /** Optional paths yield to the current attempt's mandatory context and catalog. */
 export function createSupervisorArtifactPathsReadmissionController(request, options) {
     const { controller, projection } = options;

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

@@ -10,7 +10,7 @@ export declare const SUPERVISOR_DECISION_ACTIONS: readonly ["respond", "invoke_r
 export declare const SUPERVISOR_ACKNOWLEDGEMENT_MAX_LENGTH = 220;
 export declare const SUPERVISOR_TITLE_MAX_LENGTH = 80;
 export declare const SUPERVISOR_OBJECTIVE_MAX_LENGTH = 8192;
-export declare const SUPERVISOR_DECISION_PHASES: readonly ["presentation", "skill_selection", "skill_authoring", "routing", "working_directory"];
+export declare const SUPERVISOR_DECISION_PHASES: readonly ["presentation", "skill_selection", "skill_authoring", "procedure_gate", "delegation", "routing", "working_directory"];
 export type SupervisorDelegateRoleId = RuntimeDelegateRoleId;
 export type SupervisorWorkerCapabilityAffordance = Readonly<{
     purpose: string;

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

@@ -14,6 +14,8 @@ export const SUPERVISOR_DECISION_PHASES = Object.freeze([
     "presentation",
     "skill_selection",
     "skill_authoring",
+    "procedure_gate",
+    "delegation",
     "routing",
     "working_directory",
 ]);

package/dist/src/runtime/steps/supervisor-decision/decision-phases.d.ts

@@ -3,6 +3,7 @@ import type { RequestExecutionScope } from "../../request/execution-scope.js";
 import type { RequestSteeringInbox } from "../../request/request-steering.js";
 import type { SupervisorDecision, SupervisorDecisionOutcome, SupervisorDecisionDiagnosticContext, SupervisorRoutingDecision, SupervisorWorkingDirectoryDecision, SupervisorWorkingDirectoryRoutingDecision } from "./contracts.js";
 import { buildSupervisorDecisionInput } from "./input.js";
+import { type SupervisorArtifactPathsProjection } from "./artifact-paths.js";
 import { buildSupervisorWorkingDirectoryInput } from "./working-directory.js";
 type AcceptedSupervisorPhase<T> = Readonly<{
     decision: T;
@@ -25,6 +26,8 @@ export declare function runWorkingDirectoryPhase(params: {
     frozenDecision: SupervisorWorkingDirectoryRoutingDecision;
     diagnostic: SupervisorDecisionDiagnosticContext;
     contextCompaction: ModelStepContextCompactionController;
+    exactContext?: boolean;
+    artifactPathsProjection?: SupervisorArtifactPathsProjection;
 }): Promise<AcceptedSupervisorPhase<SupervisorWorkingDirectoryDecision>>;
 export declare function requiresWorkingDirectory(decision: SupervisorRoutingDecision): decision is SupervisorWorkingDirectoryRoutingDecision;
 export declare function tracePhaseSuperseded(params: {

package/dist/src/runtime/steps/supervisor-decision/decision-phases.js

@@ -1,6 +1,8 @@
 import { invokeStructuredModelStep, StructuredModelInvalidOutputError } from "../../model/invoke-structured-step.js";
 import { traceSupervisorDecisionPhaseSuperseded, traceSupervisorModelCompleted, traceSupervisorModelFailed, traceSupervisorModelStarted, traceSupervisorWorkingDirectoryModelStarted } from "./diagnostics.js";
 import { parseSupervisorDecisionOutput } from "./parser.js";
+import { parseSupervisorDelegationOutput } from "./delegation-contract.js";
+import { createSupervisorArtifactPathsOptionalProjection } from "./artifact-paths.js";
 import { mergeSupervisorWorkingDirectory, parseSupervisorWorkingDirectoryOutput } from "./working-directory.js";
 export function createDecisionOutcome(decision, steeringVersion) {
     return Object.freeze({ decision: Object.freeze(decision), steeringVersion });
@@ -19,16 +21,26 @@ export async function runRoutingPhase(params) {
         availableWorkerCapabilityCatalog: params.input.availableWorkerCapabilityCatalog,
     });
     try {
+        const parseRoutingOutput = params.input.delegationOnly
+            ? parseSupervisorDelegationOutput
+            : parseSupervisorDecisionOutput;
         const accepted = await invokeStructuredModelStep({
             request: params.request,
             boundSteeringVersion: params.boundSteeringVersion,
             modelStep: params.input.modelStep,
             format: params.input.format,
             messages: params.input.context.messages,
-            contextCompaction: params.contextCompaction,
+            ...(params.input.delegationOnly
+                ? {
+                    contextRetention: "exact",
+                    optionalContextProjection: createSupervisorArtifactPathsOptionalProjection({
+                        projection: params.input.artifactPathsProjection, includeInstructions: true,
+                    }),
+                }
+                : { contextCompaction: params.contextCompaction }),
             timeoutReason: "supervisor_decision_timeout",
             invalidOutputReason: "invalid_supervisor_decision",
-            parse: (text) => captureAcceptedPhase(parseSupervisorDecisionOutput(text, {
+            parse: (text) => captureAcceptedPhase(parseRoutingOutput(text, {
                 includeAcknowledgement: params.input.includeAcknowledgement,
                 includeTitle: params.input.includeTitle,
                 includeResponseRecommendation: params.input.includeResponseRecommendation,
@@ -66,7 +78,14 @@ export async function runWorkingDirectoryPhase(params) {
             modelStep: params.input.modelStep,
             format: params.input.format,
             messages: params.input.messages,
-            contextCompaction: params.contextCompaction,
+            ...(params.exactContext
+                ? {
+                    contextRetention: "exact",
+                    optionalContextProjection: createSupervisorArtifactPathsOptionalProjection({
+                        projection: params.artifactPathsProjection, includeInstructions: false,
+                    }),
+                }
+                : { contextCompaction: params.contextCompaction }),
             timeoutReason: "supervisor_decision_timeout",
             invalidOutputReason: "invalid_supervisor_decision",
             parse: (text) => captureAcceptedPhase(parseSupervisorWorkingDirectoryOutput(text, {

package/dist/src/runtime/steps/supervisor-decision/delegation-contract.d.ts

@@ -0,0 +1,9 @@
+import type { ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.js";
+import { type SupervisorRoutingDecisionParseResult } from "./contracts.js";
+import { parseSupervisorDecisionOutput } from "./parser.js";
+type CanonicalParserOptions = NonNullable<Parameters<typeof parseSupervisorDecisionOutput>[1]>;
+export type SupervisorDelegationOptions = Pick<CanonicalParserOptions, "allowedRoleIds" | "allowMemoryRecall">;
+/** Initial delegation offers Worker/Planner and eligible root recall, never tools or response. */
+export declare function createSupervisorDelegationFormat(options?: SupervisorDelegationOptions): ModelGatewayJsonSchemaFormat;
+export declare function parseSupervisorDelegationOutput(text: string, options?: CanonicalParserOptions): SupervisorRoutingDecisionParseResult;
+export {};

package/dist/src/runtime/steps/supervisor-decision/delegation-contract.js

@@ -0,0 +1,82 @@
+import { createStructuredDecisionEnvelopeSchema, readStructuredDecisionEnvelope, structuredDecisionVariantSchemaPath, } from "../../model/structured-decision-envelope.js";
+import { SUPERVISOR_DELEGATE_ROLE_IDS, } from "./contracts.js";
+import { traceSupervisorDecisionRejected, traceSupervisorEnvelopeAccepted } from "./diagnostics.js";
+import { createSupervisorDecisionFormat } from "./format.js";
+import { parseSupervisorDecisionOutput } from "./parser.js";
+/** Initial delegation offers Worker/Planner and eligible root recall, never tools or response. */
+export function createSupervisorDelegationFormat(options = {}) {
+    const canonical = createSupervisorDecisionFormat(canonicalDelegationOptions(options));
+    const decision = canonical.schema.properties.decision;
+    const canonicalVariants = decision.anyOf ?? [decision];
+    const variants = canonicalVariants.slice(1);
+    if (!hasDelegationActions(variants))
+        throw new Error("supervisor_delegation_actions_unavailable");
+    return {
+        ...canonical,
+        name: "supervisor_delegation",
+        schema: createStructuredDecisionEnvelopeSchema(variants),
+        postValidatedSchemaConstraints: rebaseDelegationConstraints(canonical, canonicalVariants.length),
+    };
+}
+export function parseSupervisorDelegationOutput(text, options = {}) {
+    const response = readForbiddenDelegationResponse(text);
+    if (response) {
+        const issues = [{
+                code: "supervisor_delegation_action_invalid", path: "decision.action",
+                message: "Choose an offered delegation action; respond belongs to the preceding gate.",
+            }];
+        if (options.diagnostic) {
+            traceSupervisorEnvelopeAccepted({
+                diagnostic: options.diagnostic, outputLength: text.length, keyCount: Object.keys(response).length,
+            });
+            traceSupervisorDecisionRejected({ diagnostic: options.diagnostic, selectedAction: "respond", issues });
+        }
+        return { ok: false, stage: "domain_parser", issues };
+    }
+    return parseSupervisorDecisionOutput(text, {
+        ...canonicalDelegationOptions(options),
+        ...(options.diagnostic ? { diagnostic: options.diagnostic } : {}),
+    });
+}
+function canonicalDelegationOptions(options) {
+    const allowedRoleIds = (options.allowedRoleIds ?? SUPERVISOR_DELEGATE_ROLE_IDS).filter(isDelegationRole);
+    const canRecallBeforeDelegation = options.allowMemoryRecall === true && allowedRoleIds.length > 0;
+    return {
+        allowMemoryRecall: canRecallBeforeDelegation,
+        allowSkillAuthoring: false,
+        allowedRoleIds,
+        availableWorkerCapabilityCatalog: [],
+        includeAcknowledgement: false,
+        includeTitle: false,
+        includeResponseRecommendation: false,
+    };
+}
+function isDelegationRole(roleId) {
+    return roleId === "worker" || roleId === "planner";
+}
+function hasDelegationActions(variants) {
+    return variants.length > 0;
+}
+function readForbiddenDelegationResponse(text) {
+    try {
+        const record = readStructuredDecisionEnvelope(JSON.parse(text));
+        return record?.action === "respond" ? record : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function rebaseDelegationConstraints(canonical, canonicalVariantCount) {
+    return (canonical.postValidatedSchemaConstraints ?? []).map((constraint) => {
+        const originalIndex = Array.from({ length: canonicalVariantCount }, (_, index) => index)
+            .find((index) => constraint.path.startsWith(`${structuredDecisionVariantSchemaPath(index, canonicalVariantCount)}/`));
+        if (!isDelegationConstraintIndex(originalIndex))
+            throw new Error("supervisor_delegation_constraint_invalid");
+        const originalPrefix = structuredDecisionVariantSchemaPath(originalIndex, canonicalVariantCount);
+        const delegationPrefix = structuredDecisionVariantSchemaPath(originalIndex - 1, canonicalVariantCount - 1);
+        return { ...constraint, path: delegationPrefix + constraint.path.slice(originalPrefix.length) };
+    });
+}
+function isDelegationConstraintIndex(index) {
+    return index !== undefined && index > 0;
+}

package/dist/src/runtime/steps/supervisor-decision/delegation-input.d.ts

@@ -0,0 +1,7 @@
+import type { buildSupervisorDecisionInput, SupervisorDecisionInputRequest } from "./input.js";
+/**
+ * Initial delegation uses one exact settled conversation turn, not the full routing
+ * history or captured Skill bodies. Those remain available to their execution
+ * owners. This projection is phase-local and never changes session checkpoints.
+ */
+export declare function buildSupervisorDelegationInput(request: SupervisorDecisionInputRequest, options: Parameters<typeof buildSupervisorDecisionInput>[1]): ReturnType<typeof buildSupervisorDecisionInput>;