@abot-ai/runtime 1.8.0 → 1.9.0

package/dist/src/runtime/steps/reviewer-decision/run.js

@@ -2,6 +2,7 @@ import { invokeStructuredModelStep, StructuredModelInvalidOutputError, } from ".
 import { emitRuntimeStatus } from "../../events/runtime-status.js";
 import { classifyRuntimeErrorType } from "../../observability/error-type.js";
 import { createModelStepCompactionController } from "../../context/model-step-compaction.js";
+import { buildCoreSkillReadContextMessages } from "../../context/core-skill-read-context.js";
 import { superCompactionFailureOwner } from "../../context/super-compaction-failure-owner.js";
 import { createRoleCallReviewerVerdictReceipt } from "../../orchestration/role-calls/index.js";
 import { REVIEWER_DECISION_MODEL_STEP, } from "./contracts.js";
@@ -77,6 +78,7 @@ export const GENERIC_REVIEWER_EXECUTOR = Object.freeze({
             message: "Reviewing high-level completion...",
         });
         const budget = resolveReviewerDecisionContextBudget(context);
+        const skillGuidanceMessages = buildCoreSkillReadContextMessages(ledger.current(), "delegate");
         const emptyReferenceDataBudget = Object.freeze({
             maxTokens: 0,
             ...(budget.tokenEstimation
@@ -107,6 +109,7 @@ export const GENERIC_REVIEWER_EXECUTOR = Object.freeze({
             call,
             snapshot: budgetAssessmentSnapshot,
             budget,
+            skillGuidanceMessages,
         });
         const referenceDataBudget = resolveReviewerReferenceDataBudget({
             context,
@@ -114,6 +117,7 @@ export const GENERIC_REVIEWER_EXECUTOR = Object.freeze({
             budget,
             baseAssessment,
             projectSnapshot,
+            skillGuidanceMessages,
         });
         const snapshot = projectSnapshot(referenceDataBudget, true);
         const decision = await runReviewerDecision(context, {
@@ -121,6 +125,7 @@ export const GENERIC_REVIEWER_EXECUTOR = Object.freeze({
             snapshot,
             budget,
             referenceDataBudget,
+            skillGuidanceMessages,
         });
         const receipt = createRoleCallReviewerVerdictReceipt({
             reviewerCallId: call.callId,
@@ -158,6 +163,7 @@ function resolveReviewerReferenceDataBudget(params) {
             call: params.call,
             snapshot: candidateSnapshot,
             budget: params.budget,
+            skillGuidanceMessages: params.skillGuidanceMessages,
         });
         if (assessment.fits &&
             assessment.budget.estimatedInputTokens <= inputTokenCeiling) {

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

@@ -0,0 +1,34 @@
+type SkillReadPresentation = Readonly<{
+    acknowledgement?: string;
+    title?: string;
+}>;
+export type SkillReadDecision = SkillReadPresentation & (Readonly<{
+    action: "list_skills";
+}> | Readonly<{
+    action: "read_skills";
+    skillIds: readonly string[];
+}>);
+type SkillReadPresentationContract = Readonly<{
+    includeAcknowledgement?: boolean;
+    includeTitle?: boolean;
+    acknowledgementMaxLength: number;
+    titleMaxLength: number;
+}>;
+type SkillReadValidationIssue = Readonly<{
+    code: string;
+    path: string;
+    message: string;
+}>;
+export declare function createSkillReadDecisionSchemas(options: SkillReadPresentationContract): readonly Record<string, unknown>[];
+export declare function isSkillReadDecisionRecord(record: Readonly<Record<string, unknown>>): boolean;
+export declare function parseSkillReadDecision(record: Readonly<Record<string, unknown>>, options: SkillReadPresentationContract & Readonly<{
+    allowSkillReads?: boolean;
+}>): Readonly<{
+    ok: true;
+    decision: SkillReadDecision;
+}> | Readonly<{
+    ok: false;
+    stage: "domain_parser";
+    issues: readonly SkillReadValidationIssue[];
+}>;
+export {};

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

@@ -0,0 +1,91 @@
+import { isKnowledgeSkillReadReference, KNOWLEDGE_SKILL_READ_REFERENCE_MAX_LENGTH, } from "../capabilities/knowledge-skills/read-targets.js";
+import { KNOWLEDGE_SKILL_READ_MAX_ITEMS } from "../knowledge-skills/store.js";
+export function createSkillReadDecisionSchemas(options) {
+    const presentation = {
+        ...(options.includeAcknowledgement
+            ? { acknowledgement: { type: "string", minLength: 2, maxLength: options.acknowledgementMaxLength } }
+            : {}),
+        ...(options.includeTitle
+            ? { title: { type: "string", minLength: 2, maxLength: options.titleMaxLength } }
+            : {}),
+    };
+    return ["list_skills", "read_skills"].map((action) => {
+        const properties = {
+            action: { type: "string", enum: [action] },
+            ...(action === "read_skills"
+                ? { skillIds: {
+                        type: "array", minItems: 1, maxItems: KNOWLEDGE_SKILL_READ_MAX_ITEMS,
+                        items: { type: "string", minLength: 1, maxLength: KNOWLEDGE_SKILL_READ_REFERENCE_MAX_LENGTH },
+                    } }
+                : {}),
+            ...presentation,
+        };
+        return { type: "object", properties, required: Object.keys(properties), additionalProperties: false };
+    });
+}
+export function isSkillReadDecisionRecord(record) {
+    return record.action === "list_skills" || record.action === "read_skills";
+}
+export function parseSkillReadDecision(record, options) {
+    if (!options.allowSkillReads)
+        return rejectSkillRead("skill_read_unavailable", "action", "Core Skill reads are not available for this decision.");
+    if (!isSkillReadDecisionRecord(record))
+        return rejectSkillRead("skill_read_action_invalid", "action", "Expected list_skills or read_skills.");
+    const expectedKeys = [
+        "action",
+        ...(record.action === "read_skills" ? ["skillIds"] : []),
+        ...(options.includeAcknowledgement ? ["acknowledgement"] : []),
+        ...(options.includeTitle ? ["title"] : []),
+    ];
+    const actualKeys = Object.keys(record);
+    if (actualKeys.length !== expectedKeys.length || actualKeys.some((key) => !expectedKeys.includes(key)))
+        return rejectSkillRead("skill_read_shape_invalid", "", "Fields must match the offered Skill action.");
+    if (record.action === "read_skills" && !hasValidSkillReadReferences(record.skillIds))
+        return rejectSkillRead("skill_read_references_invalid", "skillIds", "Supply one to eight distinct exact Skill IDs or full names.");
+    for (const [field, maximum] of [
+        ["acknowledgement", options.acknowledgementMaxLength],
+        ["title", options.titleMaxLength],
+    ]) {
+        if (!expectedKeys.includes(field))
+            continue;
+        if (!hasBoundedSkillPresentation(record[field], maximum))
+            return rejectSkillRead("skill_read_presentation_invalid", field, "Presentation text exceeds the offered bounds.");
+    }
+    const presentation = {
+        ...(options.includeAcknowledgement ? { acknowledgement: record.acknowledgement.trim() } : {}),
+        ...(options.includeTitle ? { title: record.title.trim() } : {}),
+    };
+    if (record.action === "list_skills")
+        return { ok: true, decision: Object.freeze({ action: "list_skills", ...presentation }) };
+    return {
+        ok: true,
+        decision: Object.freeze({
+            action: "read_skills",
+            skillIds: Object.freeze([...record.skillIds]),
+            ...presentation,
+        }),
+    };
+}
+function hasValidSkillReadReferences(value) {
+    if (!Array.isArray(value))
+        return false;
+    if (value.length === 0 || value.length > KNOWLEDGE_SKILL_READ_MAX_ITEMS)
+        return false;
+    if (!value.every(isKnowledgeSkillReadReference))
+        return false;
+    return new Set(value).size === value.length;
+}
+function hasBoundedSkillPresentation(value, maximum) {
+    if (typeof value !== "string")
+        return false;
+    if (value.length > maximum)
+        return false;
+    return value.trim().length >= 2;
+}
+function rejectSkillRead(code, field, message) {
+    return {
+        ok: false,
+        stage: "domain_parser",
+        issues: Object.freeze([{ code, path: field ? `decision.${field}` : "decision", message }]),
+    };
+}

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

@@ -0,0 +1,22 @@
+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 { RequestExecutionScope } from "../../request/execution-scope.js";
+export type SupervisorArtifactPathsProjection = Readonly<{
+    instructions: string;
+    baseInstructions: string;
+    message: ChatMessage;
+}>;
+/** Adds a bounded continuity reference only within the remaining full-context budget. */
+export declare function projectSupervisorArtifactPaths(params: Readonly<{
+    targets: readonly string[] | undefined;
+    context: Parameters<typeof projectRequestContext>[0];
+    additionalBudgetMessages?: readonly ChatMessage[];
+}>): SupervisorArtifactPathsProjection | undefined;
+/** Optional paths yield to the current attempt's mandatory context and catalog. */
+export declare function createSupervisorArtifactPathsReadmissionController(request: RequestExecutionScope, options: Readonly<{
+    controller: ModelStepContextCompactionController;
+    projection?: SupervisorArtifactPathsProjection;
+    format: ModelGatewayJsonSchemaFormat;
+    includeInstructions: boolean;
+}>): ModelStepContextCompactionController;

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

@@ -0,0 +1,132 @@
+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,
+    };
+}
+/** 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", "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,9 @@ 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",
     "routing",
     "working_directory",
 ]);

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

@@ -0,0 +1,37 @@
+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 { 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;
+}): 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,124 @@
+import { invokeStructuredModelStep, StructuredModelInvalidOutputError } from "../../model/invoke-structured-step.js";
+import { traceSupervisorDecisionPhaseSuperseded, traceSupervisorModelCompleted, traceSupervisorModelFailed, traceSupervisorModelStarted, traceSupervisorWorkingDirectoryModelStarted } from "./diagnostics.js";
+import { parseSupervisorDecisionOutput } from "./parser.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 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,
+            timeoutReason: "supervisor_decision_timeout",
+            invalidOutputReason: "invalid_supervisor_decision",
+            parse: (text) => captureAcceptedPhase(parseSupervisorDecisionOutput(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,
+            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/diagnostics.d.ts

@@ -16,6 +16,8 @@ export declare function traceSupervisorContextProjected(params: {
     completedChildSummaryLength: number;
     allowedRoleIds: readonly SupervisorDelegateRoleId[];
     allowMemoryRecall: boolean;
+    allowSkillAuthoring?: boolean;
+    allowSkillReads?: boolean;
     workerCapabilityAffordances: readonly SupervisorWorkerCapabilityAffordance[];
     availableWorkerCapabilityCatalog: readonly WorkerCapabilityCatalogGroup[];
     capabilityBrief: CapabilityBriefProjection;
@@ -52,7 +54,7 @@ export declare function traceSupervisorAcknowledgementNormalized(params: {
 export declare function traceSupervisorDecisionRejected(params: {
     diagnostic: SupervisorDecisionDiagnosticContext;
     issues: readonly SupervisorDecisionValidationIssue[];
-    selectedAction?: SupervisorDecision["action"];
+    selectedAction?: SupervisorDecision["action"] | SupervisorRoutingDecision["action"];
 }): void;
 export declare function traceSupervisorModelStarted(params: {
     diagnostic: SupervisorDecisionDiagnosticContext;
@@ -62,6 +64,8 @@ export declare function traceSupervisorModelStarted(params: {
     includeTitle: boolean;
     allowedRoleIds: readonly SupervisorDelegateRoleId[];
     allowMemoryRecall: boolean;
+    allowSkillAuthoring?: boolean;
+    allowSkillReads?: boolean;
     availableWorkerCapabilityCatalog: readonly WorkerCapabilityCatalogGroup[];
 }): void;
 export declare function traceSupervisorModelCompleted(params: {

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

@@ -286,5 +286,9 @@ function projectSupervisorAllowedActions(params) {
         : ["respond"];
     if (params.allowMemoryRecall)
         actions.push("recall_memory");
+    if (params.allowSkillReads)
+        actions.push("list_skills", "read_skills");
+    if (params.allowSkillAuthoring)
+        actions.push("author_skill");
     return actions;
 }

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

@@ -6,6 +6,7 @@ export declare function createSupervisorDecisionFormat(params?: Readonly<{
     includeTitle?: boolean;
     includeResponseRecommendation?: boolean;
     allowMemoryRecall?: boolean;
+    allowSkillAuthoring?: boolean;
     allowedRoleIds?: readonly SupervisorDelegateRoleId[];
     availableWorkerCapabilityCatalog?: readonly WorkerCapabilityCatalogGroup[];
 }>): ModelGatewayJsonSchemaFormat;

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

@@ -1,4 +1,5 @@
 import { createMemoryRecallDecisionSchema } from "../memory-recall-decision.js";
+import { SUPERVISOR_SKILL_AUTHORING_ROUTE_SCHEMA } from "../supervisor-skill-authoring/contract.js";
 import { createStructuredDecisionEnvelopeSchema, structuredDecisionVariantSchemaPath, } from "../../model/structured-decision-envelope.js";
 import { SUPERVISOR_RESPONSE_RECOMMENDATION_MAX_LENGTH } from "./response-recommendation.js";
 import { createWorkerCapabilityScopeDecisionContract } from "../worker-capability-scope-decision.js";
@@ -38,6 +39,7 @@ export function createSupervisorDecisionFormat(params = {}) {
     const variants = [
         respondSchema(includeAcknowledgement, includeTitle, includeResponseRecommendation),
         ...invokeVariants,
+        ...(params.allowSkillAuthoring ? [SUPERVISOR_SKILL_AUTHORING_ROUTE_SCHEMA] : []),
         ...(params.allowMemoryRecall
             ? [
                 createMemoryRecallDecisionSchema({