@abot-ai/runtime 1.8.1 → 2.0.0

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

@@ -0,0 +1,147 @@
+import { resolveCapabilityBriefHeadroom, resolveCapabilityBriefMessageHeadroom, } from "../../context/capability-brief-budget.js";
+import { buildSessionArtifactPathsMessage } from "../../context/session-artifact-paths.js";
+import { estimateMessageTokens } from "../../context/token-estimator.js";
+import { resolveModelContextAdmission } from "../../model/model-context-budget.js";
+import { buildSupervisorCapabilityBriefOptions } from "./capability-brief.js";
+import { SUPERVISOR_DECISION_MODEL_STEP } from "./contracts.js";
+import { buildSupervisorArtifactPathInstructions } from "./prompt.js";
+/** Adds a bounded continuity reference only within the remaining full-context budget. */
+export function projectSupervisorArtifactPaths(params) {
+    if (!params.targets?.length)
+        return undefined;
+    const instructions = [
+        params.context.instructions,
+        buildSupervisorArtifactPathInstructions(),
+    ].join("\n");
+    // The existing catalog and all history retain priority over this reference.
+    const headroom = resolveCapabilityBriefHeadroom({
+        context: { ...params.context, instructions },
+        additionalBudgetMessages: params.additionalBudgetMessages,
+    });
+    const artifactPaths = buildSessionArtifactPathsMessage({
+        targets: params.targets,
+        applicable: true,
+        applicability: "supervisor_objective_and_working_directory_reference_only",
+        maxTargets: 8,
+        fits: (message) => estimateMessageTokens(message, params.context.budget.tokenEstimation) <=
+            headroom,
+    });
+    if (!artifactPaths)
+        return undefined;
+    return {
+        instructions,
+        baseInstructions: params.context.instructions,
+        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;
+    if (!projection)
+        return controller;
+    let admittedArtifactMessage;
+    return Object.freeze({
+        ...controller,
+        project(messages) {
+            admittedArtifactMessage = undefined;
+            const artifactIndex = messages.findIndex((message) => matchesBoundArtifactMessage(message, projection.message));
+            if (artifactIndex < 0)
+                return controller.project(messages);
+            const followingMessage = messages[artifactIndex + 1];
+            const withoutArtifact = messages.filter((_, index) => index !== artifactIndex);
+            const withoutAdditions = options.includeInstructions
+                ? replaceBoundInstructionPrefix(withoutArtifact, projection.instructions, projection.baseInstructions)
+                : withoutArtifact;
+            const projected = controller.project(withoutAdditions);
+            const withInstructions = options.includeInstructions
+                ? replaceBoundInstructionPrefix(projected, projection.baseInstructions, projection.instructions)
+                : projected;
+            const admission = resolveModelContextAdmission({
+                runnerConfig: request.runnerConfig,
+                agentMode: request.agentMode,
+                modelStep: SUPERVISOR_DECISION_MODEL_STEP,
+                modelPreference: request.modelPreference,
+                modelPolicy: request.modelPolicy,
+                requestFormat: options.format,
+            });
+            const { capabilityBriefBudgetMessages = [] } = buildSupervisorCapabilityBriefOptions(request, {});
+            const headroom = resolveCapabilityBriefMessageHeadroom({
+                messages: [...withInstructions, ...capabilityBriefBudgetMessages],
+                budget: admission.budget,
+                format: options.format,
+            });
+            const artifactPaths = buildSessionArtifactPathsMessage({
+                targets: request.sessionArtifactPaths ?? [],
+                applicable: true,
+                applicability: "supervisor_objective_and_working_directory_reference_only",
+                maxTargets: 8,
+                fits: (message) => estimateMessageTokens(message, admission.budget.tokenEstimation) <=
+                    headroom,
+            });
+            if (!artifactPaths)
+                return projected;
+            // The current prompt follows the reference and survives compaction verbatim.
+            const insertionIndex = followingMessage
+                ? withInstructions.indexOf(followingMessage)
+                : withInstructions.length;
+            if (insertionIndex < 0)
+                throw new Error("supervisor_artifact_path_position_binding_invalid");
+            admittedArtifactMessage = artifactPaths.message;
+            return [
+                ...withInstructions.slice(0, insertionIndex),
+                artifactPaths.message,
+                ...withInstructions.slice(insertionIndex),
+            ];
+        },
+        projectForCompaction(messages) {
+            const artifactIndex = admittedArtifactMessage
+                ? messages.indexOf(admittedArtifactMessage)
+                : -1;
+            if (artifactIndex < 0)
+                return controller.projectForCompaction?.(messages) ?? messages;
+            const withoutArtifact = messages.filter((_, index) => index !== artifactIndex);
+            const withoutAdditions = options.includeInstructions
+                ? replaceBoundInstructionPrefix(withoutArtifact, projection.instructions, projection.baseInstructions)
+                : withoutArtifact;
+            return (controller.projectForCompaction?.(withoutAdditions) ?? withoutAdditions);
+        },
+        getStages: () => controller.getStages(),
+        ...(controller.hasExhaustedVerifiedCompactionSources
+            ? {
+                hasExhaustedVerifiedCompactionSources: (messages) => controller.hasExhaustedVerifiedCompactionSources(messages),
+            }
+            : {}),
+    });
+}
+function matchesBoundArtifactMessage(left, right) {
+    return (left === right ||
+        (left.role === right.role && left.content === right.content));
+}
+function replaceBoundInstructionPrefix(messages, previous, replacement) {
+    const instructions = messages[0];
+    if (instructions?.role !== "system" ||
+        !instructions.content.startsWith(previous))
+        throw new Error("supervisor_artifact_path_instruction_binding_invalid");
+    return [
+        {
+            ...instructions,
+            content: replacement + instructions.content.slice(previous.length),
+        },
+        ...messages.slice(1),
+    ];
+}

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

@@ -4,6 +4,8 @@ import type { RequestExecutionScope } from "../../request/execution-scope.js";
 import type { WorkerCapabilityCatalogGroup } from "../../orchestration/worker-capabilities/index.js";
 type BriefOptions = Readonly<{
     allowedRoleIds?: readonly string[];
+    remainingCapabilityExecutions?: number;
+    remainingRoleCalls?: number;
     availableWorkerCapabilityCatalog?: readonly WorkerCapabilityCatalogGroup[];
 }>;
 /** Only routing opts in; neither the Worker nor later authoring is changed. */

package/dist/src/runtime/steps/supervisor-decision/capability-brief.js

@@ -1,3 +1,4 @@
+import { projectSupervisorWorkerCapabilityBriefEntries } from "../../orchestration/worker-capabilities/supervisor-skill-authority.js";
 import { resolveModelContextAdmission } from "../../model/model-context-budget.js";
 import { resolveRequestCapabilityBriefEntries } from "../../request/capability-brief.js";
 import { appendRequestSteeringContext } from "../../request/request-steering-context.js";
@@ -5,9 +6,15 @@ import { resolveRequestSteeringInbox } from "../../request/request-steering.js";
 import { SUPERVISOR_DECISION_MODEL_STEP, SUPERVISOR_DELEGATE_ROLE_IDS, } from "./contracts.js";
 /** Only routing opts in; neither the Worker nor later authoring is changed. */
 export function buildSupervisorCapabilityBriefOptions(request, options) {
-    if (!canProjectSupervisorCapabilityBrief(options))
+    const hasCapabilityBrief = canProjectSupervisorCapabilityBrief(options);
+    if (!hasCapabilityBrief && !request.sessionArtifactPaths?.length)
         return {};
-    const entries = resolveRequestCapabilityBriefEntries(request.capabilities, options.availableWorkerCapabilityCatalog ?? []);
+    const entries = hasCapabilityBrief
+        ? projectSupervisorWorkerCapabilityBriefEntries({
+            authority: request.executionPolicy.authority,
+            entries: resolveRequestCapabilityBriefEntries(request.capabilities, options.availableWorkerCapabilityCatalog ?? []),
+        })
+        : undefined;
     const admission = resolveModelContextAdmission({
         runnerConfig: request.runnerConfig,
         agentMode: request.agentMode,

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

@@ -1,4 +1,6 @@
 import type { MemoryRecallDecision } from "../memory-recall-decision.js";
+import type { SkillReadDecision } from "../skill-read-decision.js";
+import type { SupervisorSkillAuthoringSelection } from "../supervisor-skill-authoring/contract.js";
 import { type RuntimeDelegateRoleId } from "../../orchestration/roles.js";
 import type { RoleCapabilityDeclaredEffect, RoleChildReturnContext, RoleCallWorkerCapabilityScope } from "../../orchestration/role-calls/index.js";
 export declare const SUPERVISOR_DECISION_MODEL_STEP: "supervisor.decision";
@@ -8,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 ["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;
@@ -39,7 +41,10 @@ export type SupervisorInvokeRoleDecision = Readonly<SupervisorInvokeRoleDecision
 }> | Readonly<SupervisorInvokeRoleDecisionBase & {
     roleId: Exclude<SupervisorDelegateRoleId, "planner" | "worker">;
 }>;
-export type SupervisorDecision = MemoryRecallDecision | SupervisorRespondDecision | SupervisorInvokeRoleDecision;
+export type SupervisorDecision = MemoryRecallDecision | SkillReadDecision | SupervisorRespondDecision | SupervisorInvokeRoleDecision | (SupervisorSkillAuthoringSelection & Readonly<{
+    acknowledgement?: string;
+    title?: string;
+}>);
 export type SupervisorDecisionOutcome = Readonly<{
     decision: SupervisorDecision;
     steeringVersion: number;
@@ -54,7 +59,11 @@ export type SupervisorRoutingInvokeRoleDecision = Readonly<SupervisorInvokeRoleD
 }> | Readonly<SupervisorInvokeRoleDecisionMetadata & {
     roleId: "reviewer";
 }>;
-export type SupervisorRoutingDecision = MemoryRecallDecision | SupervisorRespondDecision | SupervisorRoutingInvokeRoleDecision;
+export type SupervisorRoutingDecision = MemoryRecallDecision | SupervisorRespondDecision | SupervisorRoutingInvokeRoleDecision | Readonly<{
+    action: "author_skill";
+    acknowledgement?: never;
+    title?: never;
+}>;
 export type SupervisorWorkingDirectoryRoutingDecision = Extract<SupervisorRoutingInvokeRoleDecision, Readonly<{
     roleId: "planner" | "worker";
 }>>;

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

@@ -11,6 +11,11 @@ export const SUPERVISOR_ACKNOWLEDGEMENT_MAX_LENGTH = 220;
 export const SUPERVISOR_TITLE_MAX_LENGTH = 80;
 export const SUPERVISOR_OBJECTIVE_MAX_LENGTH = 8_192;
 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

@@ -0,0 +1,40 @@
+import type { ModelStepContextCompactionController } from "../../model/model-step-port.js";
+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;
+    steeringVersion: number;
+}>;
+export declare function createDecisionOutcome(decision: SupervisorDecision, steeringVersion: number): SupervisorDecisionOutcome;
+export declare function runRoutingPhase(params: {
+    request: RequestExecutionScope;
+    requestSteering: RequestSteeringInbox;
+    boundSteeringVersion?: number;
+    input: ReturnType<typeof buildSupervisorDecisionInput>;
+    diagnostic: SupervisorDecisionDiagnosticContext;
+    contextCompaction: ModelStepContextCompactionController;
+}): Promise<AcceptedSupervisorPhase<SupervisorRoutingDecision>>;
+export declare function runWorkingDirectoryPhase(params: {
+    request: RequestExecutionScope;
+    requestSteering: RequestSteeringInbox;
+    boundSteeringVersion?: number;
+    input: ReturnType<typeof buildSupervisorWorkingDirectoryInput>;
+    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: {
+    diagnostic: SupervisorDecisionDiagnosticContext;
+    requestSteering: RequestSteeringInbox;
+    routingSteeringVersion: number;
+    workingDirectorySteeringVersion?: number;
+    checkpoint: "before_working_directory" | "after_working_directory";
+}): void;
+export {};

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

@@ -0,0 +1,143 @@
+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 });
+}
+export async function runRoutingPhase(params) {
+    const startedAt = Date.now();
+    traceSupervisorModelStarted({
+        diagnostic: params.diagnostic,
+        allowMemoryRecall: params.input.allowMemoryRecall,
+        allowSkillAuthoring: params.input.allowSkillAuthoring,
+        messageCount: params.input.context.messages.length,
+        messageCharacterCount: params.input.context.messages.reduce((total, message) => total + message.content.length, 0),
+        includeAcknowledgement: params.input.includeAcknowledgement,
+        includeTitle: params.input.includeTitle,
+        allowedRoleIds: params.input.allowedRoleIds,
+        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,
+            ...(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(parseRoutingOutput(text, {
+                includeAcknowledgement: params.input.includeAcknowledgement,
+                includeTitle: params.input.includeTitle,
+                includeResponseRecommendation: params.input.includeResponseRecommendation,
+                allowMemoryRecall: params.input.allowMemoryRecall,
+                allowSkillAuthoring: params.input.allowSkillAuthoring,
+                allowedRoleIds: params.input.allowedRoleIds,
+                availableWorkerCapabilityCatalog: params.input.availableWorkerCapabilityCatalog,
+                diagnostic: params.diagnostic,
+            }), params.requestSteering),
+        });
+        traceSupervisorModelCompleted({
+            diagnostic: params.diagnostic,
+            decision: accepted.decision,
+            durationMs: Date.now() - startedAt,
+        });
+        return accepted;
+    }
+    catch (error) {
+        tracePhaseFailure(params.diagnostic, startedAt, error);
+        throw error;
+    }
+}
+export async function runWorkingDirectoryPhase(params) {
+    const startedAt = Date.now();
+    traceSupervisorWorkingDirectoryModelStarted({
+        diagnostic: params.diagnostic,
+        messageCount: params.input.messages.length,
+        messageCharacterCount: params.input.messages.reduce((total, message) => total + message.content.length, 0),
+        frozenDecision: params.frozenDecision,
+    });
+    try {
+        const accepted = await invokeStructuredModelStep({
+            request: params.request,
+            boundSteeringVersion: params.boundSteeringVersion,
+            modelStep: params.input.modelStep,
+            format: params.input.format,
+            messages: params.input.messages,
+            ...(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, {
+                diagnostic: params.diagnostic,
+            }), params.requestSteering),
+        });
+        traceSupervisorModelCompleted({
+            diagnostic: params.diagnostic,
+            decision: mergeSupervisorWorkingDirectory(params.frozenDecision, accepted.decision),
+            durationMs: Date.now() - startedAt,
+        });
+        return accepted;
+    }
+    catch (error) {
+        tracePhaseFailure(params.diagnostic, startedAt, error);
+        throw error;
+    }
+}
+function captureAcceptedPhase(parsed, requestSteering) {
+    if (!parsed.ok) {
+        return parsed;
+    }
+    return Object.freeze({
+        ok: true,
+        decision: Object.freeze({
+            decision: parsed.decision,
+            steeringVersion: requestSteering.snapshot().version,
+        }),
+    });
+}
+export function requiresWorkingDirectory(decision) {
+    return (decision.action === "invoke_role" &&
+        (decision.roleId === "planner" || decision.roleId === "worker"));
+}
+function tracePhaseFailure(diagnostic, startedAt, error) {
+    traceSupervisorModelFailed({
+        diagnostic,
+        durationMs: Date.now() - startedAt,
+        errorType: error instanceof Error && error.name ? error.name : typeof error,
+        invalidStructuredOutput: error instanceof StructuredModelInvalidOutputError,
+    });
+}
+export function tracePhaseSuperseded(params) {
+    traceSupervisorDecisionPhaseSuperseded({
+        diagnostic: params.diagnostic,
+        routingSteeringVersion: params.routingSteeringVersion,
+        currentSteeringVersion: params.requestSteering.snapshot().version,
+        ...(params.workingDirectorySteeringVersion === undefined
+            ? {}
+            : {
+                workingDirectorySteeringVersion: params.workingDirectorySteeringVersion,
+            }),
+        checkpoint: params.checkpoint,
+    });
+}

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>;

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

@@ -0,0 +1,105 @@
+import { resolveMemoryRecallSteeringVersion } from "../../long-term-memory/recall-binding.js";
+import { buildSupervisorMemoryRecallContinuationParts } from "./memory-recall-continuation.js";
+import { buildSparkConversationInstructions } from "../../context/spark-conversation-policy.js";
+import { projectLatestSettledConversationTurn, projectRequestContext } from "../../context/request-context.js";
+import { buildRequestTemporalContextMessage } from "../../context/request-temporal-context.js";
+import { projectScheduledExecutionContext } from "../../context/scheduled-execution-context.js";
+import { resolveModelContextBudget } from "../../model/model-context-budget.js";
+import { traceDebug } from "../../observability/debug-logger.js";
+import { SUPERVISOR_DECISION_MODEL_STEP, SUPERVISOR_DELEGATE_ROLE_IDS } from "./contracts.js";
+import { createSupervisorDelegationFormat } from "./delegation-contract.js";
+import { buildSupervisorDelegationInstructions } from "./delegation-prompt.js";
+import { projectSupervisorArtifactPaths } from "./artifact-paths.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 function buildSupervisorDelegationInput(request, options) {
+    const allowedRoleIds = [...new Set(options.allowedRoleIds ?? SUPERVISOR_DELEGATE_ROLE_IDS)]
+        .filter((role) => role === "worker" || role === "planner");
+    const allowMemoryRecall = options.allowMemoryRecall === true && options.memoryRecallMessage === undefined;
+    const continuationParts = [];
+    if (options.memoryRecallMessage) {
+        const diagnostic = options.diagnostic;
+        if (!diagnostic?.callId || !diagnostic.invocationAttempt)
+            throw new Error("supervisor_recall_call_identity_required");
+        resolveMemoryRecallSteeringVersion(options.memoryRecallMessage, request.requestId, diagnostic.callId);
+        continuationParts.push(...buildSupervisorMemoryRecallContinuationParts({
+            memoryRecallMessage: options.memoryRecallMessage,
+            currentCallId: diagnostic.callId,
+            currentInvocationAttempt: diagnostic.invocationAttempt,
+        }));
+    }
+    const format = createSupervisorDelegationFormat({ allowedRoleIds, allowMemoryRecall });
+    const budget = resolveModelContextBudget({
+        runnerConfig: request.runnerConfig,
+        agentMode: request.agentMode,
+        modelStep: SUPERVISOR_DECISION_MODEL_STEP,
+        modelPreference: request.modelPreference,
+        modelPolicy: request.modelPolicy,
+    });
+    const instructions = [
+        buildSupervisorDelegationInstructions({
+            allowedRoleIds, allowMemoryRecall, hasMemoryRecallContext: options.memoryRecallMessage !== undefined,
+        }),
+        ...buildSparkConversationInstructions(request.sessionKind),
+    ].join("\n");
+    const scheduledExecution = projectScheduledExecutionContext(request, instructions, "decision");
+    const referenceMessages = [
+        ...scheduledExecution.referenceMessages,
+        ...(!options.memoryRecallMessage && options.initialMemoryMessage ? [options.initialMemoryMessage] : []),
+        ...(request.temporalContext ? [buildRequestTemporalContextMessage(request.temporalContext)] : []),
+    ];
+    const historyMessages = projectLatestSettledConversationTurn(request.historyMessages) ?? [];
+    const contextInput = {
+        instructions: scheduledExecution.instructions,
+        format,
+        prompt: request.prompt,
+        historyMessages,
+        // Keep this single source turn whole. The exact model-step admission still
+        // accounts for it and rejects oversize input before any child is dispatched.
+        historyRetention: "compaction_managed",
+        referenceMessages,
+        continuationParts,
+        ...(request.attachments ? { attachments: request.attachments } : {}),
+        budget,
+        diagnostic: options.diagnostic,
+        onEvent: request.onEvent,
+        deferCompactionFailure: true,
+    };
+    const artifactPathsProjection = projectSupervisorArtifactPaths({
+        targets: request.sessionArtifactPaths,
+        context: contextInput,
+        additionalBudgetMessages: options.capabilityBriefBudgetMessages,
+    });
+    if (artifactPathsProjection)
+        referenceMessages.push(artifactPathsProjection.message);
+    const projected = projectRequestContext({
+        ...contextInput,
+        instructions: artifactPathsProjection?.instructions ?? contextInput.instructions,
+    });
+    const selectedIds = new Set(projected.selectedHistoryMessageIds);
+    const context = {
+        ...projected,
+        omittedHistoryMessageIds: request.historyMessages
+            .filter((message) => !selectedIds.has(message.id)).map((message) => message.id),
+    };
+    traceDebug("runtime.supervisor", "delegation.context.projected", {
+        ...options.diagnostic,
+        messageCount: context.messages.length,
+        messageCharacterCount: context.messages.reduce((sum, message) => sum + message.content.length, 0),
+        selectedHistoryMessageCount: context.selectedHistoryMessageIds.length,
+        omittedHistoryMessageCount: context.omittedHistoryMessageIds.length,
+        referenceMessageCount: referenceMessages.length,
+        allowedRoleIds,
+    });
+    return {
+        context, format, modelStep: SUPERVISOR_DECISION_MODEL_STEP,
+        delegationOnly: true,
+        includeAcknowledgement: false, includeTitle: false, includeResponseRecommendation: false,
+        allowMemoryRecall, allowSkillAuthoring: false, allowedRoleIds,
+        workerCapabilityAffordances: [], availableWorkerCapabilityCatalog: [],
+        ...(artifactPathsProjection ? { artifactPathsProjection } : {}),
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { SupervisorDelegateRoleId } from "./contracts.js";
+/** A procedure was accepted; this phase chooses root recall or a bounded child assignment. */
+export declare function buildSupervisorDelegationInstructions(options: Readonly<{
+    allowedRoleIds: readonly SupervisorDelegateRoleId[];
+    allowMemoryRecall?: boolean;
+    hasMemoryRecallContext?: boolean;
+}>): string;

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

@@ -0,0 +1,13 @@
+import { buildMemoryRecallDecisionInstructions } from "../memory-recall-prompt.js";
+import { buildSupervisorRoleGuidance, buildSupervisorDelegationGuidance } from "./role-guidance.js";
+/** A procedure was accepted; this phase chooses root recall or a bounded child assignment. */
+export function buildSupervisorDelegationInstructions(options) {
+    return [
+        options.allowMemoryRecall
+            ? "A procedure is required. Choose your own memory lookup or Worker/Planner with a bounded task using only the supplied JSON schema. Do not reconsider a direct reply here. Tool availability and tool selection belong to the execution role, not this decision."
+            : "A procedure is required. Choose Worker or Planner and its bounded task using only the supplied JSON schema. Do not reconsider a direct reply. Tool availability and tool selection belong to the execution role, not this decision.",
+        ...buildMemoryRecallDecisionInstructions(options.allowMemoryRecall === true, options.hasMemoryRecallContext),
+        ...buildSupervisorRoleGuidance(options.allowedRoleIds),
+        ...buildSupervisorDelegationGuidance(),
+    ].join("\n");
+}