@abot-ai/runtime 1.8.1 → 1.9.0

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({

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

@@ -1,3 +1,4 @@
+import type { RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
 import type { ChatMessage, ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.js";
 import type { ToolAvailabilityEntry } from "../../../capabilities/tool-types.js";
 import type { RequestContextProjection } from "../../context/request-context-contracts.js";
@@ -5,12 +6,15 @@ import { type RequestToolResultsView } from "../../context/request-tool-results.
 import { type WorkerCapabilityCatalogGroup } from "../../orchestration/worker-capabilities/index.js";
 import type { RequestExecutionSeed } from "../../request/contracts.js";
 import { SUPERVISOR_DECISION_MODEL_STEP, type SupervisorDecisionDiagnosticContext, type SupervisorDelegateRoleId, type SupervisorResumeContext, type SupervisorWorkerCapabilityAffordance } from "./contracts.js";
-export type SupervisorDecisionInputRequest = Pick<RequestExecutionSeed, "requestId" | "prompt" | "historyMessages" | "sessionKind" | "runnerConfig" | "attachments" | "agentMode" | "modelPreference" | "modelPolicy"> & Partial<Pick<RequestExecutionSeed, "shouldGenerateSessionTitle" | "onEvent" | "temporalContext" | "scheduledExecution" | "sessionMemory" | "longTermMemory">>;
+import { type SupervisorArtifactPathsProjection } from "./artifact-paths.js";
+export type SupervisorDecisionInputRequest = Pick<RequestExecutionSeed, "requestId" | "prompt" | "historyMessages" | "sessionKind" | "runnerConfig" | "attachments" | "agentMode" | "modelPreference" | "modelPolicy"> & Partial<Pick<RequestExecutionSeed, "shouldGenerateSessionTitle" | "onEvent" | "temporalContext" | "scheduledExecution" | "sessionMemory" | "sessionArtifactPaths" | "longTermMemory">>;
 export declare function buildSupervisorDecisionInput(request: SupervisorDecisionInputRequest, options: Readonly<{
     toolResults: RequestToolResultsView;
+    skillReadHead?: RoleCallLedgerHead;
     includeAcknowledgement?: boolean;
     includeTitle?: boolean;
     allowMemoryRecall?: boolean;
+    allowSkillAuthoring?: boolean;
     memoryRecallMessage?: ChatMessage;
     initialMemoryMessage?: ChatMessage;
     allowedRoleIds?: readonly SupervisorDelegateRoleId[];
@@ -28,7 +32,9 @@ export declare function buildSupervisorDecisionInput(request: SupervisorDecision
     includeTitle: boolean;
     includeResponseRecommendation: boolean;
     allowMemoryRecall: boolean;
+    allowSkillAuthoring: boolean;
     allowedRoleIds: readonly SupervisorDelegateRoleId[];
     workerCapabilityAffordances: readonly SupervisorWorkerCapabilityAffordance[];
     availableWorkerCapabilityCatalog: readonly WorkerCapabilityCatalogGroup[];
+    artifactPathsProjection?: SupervisorArtifactPathsProjection;
 };

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

@@ -1,9 +1,9 @@
+import { projectSupervisorSkillReadContext } from "../../context/core-skill-read-context.js";
 import { buildSparkConversationInstructions } from "../../context/spark-conversation-policy.js";
 import { projectCapabilityBrief } from "../../context/capability-brief.js";
 import { resolveConfiguredStepInstructionMetadata } from "../../config/runner/step-instructions.js";
 import { projectRequestContext } from "../../context/request-context.js";
 import { projectRootSessionMemory } from "../../context/session-memory/root-projection.js";
-import { buildConversationMemoryAvailabilityInstructions } from "../../long-term-memory/conversation-authoring/prompt.js";
 import { buildRequestTemporalContextMessage } from "../../context/request-temporal-context.js";
 import { projectScheduledExecutionContext } from "../../context/scheduled-execution-context.js";
 import { buildRequestToolResultsMessage, } from "../../context/request-tool-results.js";
@@ -12,7 +12,8 @@ import { WORKER_CAPABILITY_COUNT_MAX, WORKER_CAPABILITY_SUMMARY_MAX_LENGTH, } fr
 import { SUPERVISOR_DECISION_MODEL_STEP, SUPERVISOR_DELEGATE_ROLE_IDS, } from "./contracts.js";
 import { traceSupervisorChildResultProjected, traceSupervisorContextProjected, } from "./diagnostics.js";
 import { createSupervisorDecisionFormat } from "./format.js";
-import { buildSupervisorDecisionInstructions } from "./prompt.js";
+import { projectSupervisorArtifactPaths, } from "./artifact-paths.js";
+import { buildSupervisorDecisionInstructions, buildSupervisorMemoryAvailabilityInstructions, } from "./prompt.js";
 import { buildSupervisorContinuationPart } from "./resume.js";
 import { buildSupervisorMemoryRecallContinuationParts } from "./memory-recall-continuation.js";
 import { canRecommendDirectSupervisorResponse } from "./response-recommendation.js";
@@ -43,6 +44,7 @@ export function buildSupervisorDecisionInput(request, options) {
         : EMPTY_WORKER_CAPABILITY_AFFORDANCES;
     const format = createSupervisorDecisionFormat({
         allowMemoryRecall: options.allowMemoryRecall === true,
+        allowSkillAuthoring: options.allowSkillAuthoring === true,
         includeAcknowledgement,
         includeTitle,
         includeResponseRecommendation,
@@ -65,7 +67,9 @@ export function buildSupervisorDecisionInput(request, options) {
     const initialMemoryMessage = options.memoryRecallMessage
         ? undefined
         : options.initialMemoryMessage;
+    const skillReadContext = projectSupervisorSkillReadContext(options.skillReadHead);
     const referenceMessages = [
+        ...skillReadContext.referenceMessages,
         ...(initialMemoryMessage ? [initialMemoryMessage] : []),
         ...(request.temporalContext
             ? [buildRequestTemporalContextMessage(request.temporalContext)]
@@ -90,6 +94,7 @@ export function buildSupervisorDecisionInput(request, options) {
     const instructions = [
         buildSupervisorDecisionInstructions({
             allowMemoryRecall: options.allowMemoryRecall === true,
+            allowSkillAuthoring: options.allowSkillAuthoring === true,
             hasMemoryRecallContext: options.memoryRecallMessage !== undefined,
             hasInitialMemoryContext: initialMemoryMessage !== undefined,
             includeAcknowledgement,
@@ -101,7 +106,7 @@ export function buildSupervisorDecisionInput(request, options) {
             workerCapabilityAffordances,
             availableWorkerCapabilityCatalog,
         }),
-        ...buildConversationMemoryAvailabilityInstructions(request.longTermMemory?.enabled === true),
+        ...buildSupervisorMemoryAvailabilityInstructions(request.longTermMemory?.enabled === true),
         ...buildSparkConversationInstructions(request.sessionKind),
     ].join("\n");
     const scheduledExecution = projectScheduledExecutionContext(request, instructions, "decision");
@@ -114,14 +119,17 @@ export function buildSupervisorDecisionInput(request, options) {
         prompt: request.prompt,
         ...(request.attachments ? { attachments: request.attachments } : {}),
         ...(referenceMessages.length > 0 ? { referenceMessages } : {}),
-        continuationParts: options.memoryRecallMessage
-            ? buildSupervisorMemoryRecallContinuationParts({
-                memoryRecallMessage: options.memoryRecallMessage,
-                ...(options.resume ? { resume: options.resume } : {}),
-                currentCallId: requireSupervisorCallId(diagnostic),
-                currentInvocationAttempt: requireSupervisorInvocationAttempt(diagnostic),
-            })
-            : roleContinuationParts,
+        continuationParts: [
+            ...(options.memoryRecallMessage
+                ? buildSupervisorMemoryRecallContinuationParts({
+                    memoryRecallMessage: options.memoryRecallMessage,
+                    ...(options.resume ? { resume: options.resume } : {}),
+                    currentCallId: requireSupervisorCallId(diagnostic),
+                    currentInvocationAttempt: requireSupervisorInvocationAttempt(diagnostic),
+                })
+                : roleContinuationParts),
+            ...skillReadContext.continuationParts,
+        ],
         budget,
         diagnostic,
         ...(request.onEvent ? { onEvent: request.onEvent } : {}),
@@ -139,13 +147,22 @@ export function buildSupervisorDecisionInput(request, options) {
     });
     if (capabilityBrief.message)
         referenceMessages.push(capabilityBrief.message);
+    const artifactPaths = projectSupervisorArtifactPaths({
+        targets: request.sessionArtifactPaths,
+        context: { ...contextInput, referenceMessages },
+        additionalBudgetMessages: options.capabilityBriefBudgetMessages,
+    });
+    if (artifactPaths)
+        referenceMessages.push(artifactPaths.message);
     const context = projectRequestContext({
         ...contextInput,
+        instructions: artifactPaths?.instructions ?? contextInput.instructions,
         ...(referenceMessages.length > 0 ? { referenceMessages } : {}),
     });
     traceSupervisorContextProjected({
         diagnostic,
         allowMemoryRecall: options.allowMemoryRecall === true,
+        allowSkillAuthoring: options.allowSkillAuthoring === true,
         context,
         format,
         historyMessageCount: sessionMemory.historyMessages.length,
@@ -178,9 +195,11 @@ export function buildSupervisorDecisionInput(request, options) {
         includeTitle,
         includeResponseRecommendation,
         allowMemoryRecall: options.allowMemoryRecall === true,
+        allowSkillAuthoring: options.allowSkillAuthoring === true,
         allowedRoleIds,
         workerCapabilityAffordances,
         availableWorkerCapabilityCatalog,
+        ...(artifactPaths ? { artifactPathsProjection: artifactPaths } : {}),
     };
 }
 const EMPTY_WORKER_CAPABILITY_AFFORDANCES = Object.freeze([]);

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

@@ -5,6 +5,7 @@ export declare function parseSupervisorDecisionOutput(text: string, options?: Re
     includeTitle?: boolean;
     includeResponseRecommendation?: boolean;
     allowMemoryRecall?: boolean;
+    allowSkillAuthoring?: boolean;
     allowedRoleIds?: readonly SupervisorDelegateRoleId[];
     availableWorkerCapabilityCatalog?: readonly WorkerCapabilityCatalogGroup[];
     diagnostic?: SupervisorDecisionDiagnosticContext;

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

@@ -1,4 +1,5 @@
 import { isSupervisorDelegateRoleId, SUPERVISOR_ACKNOWLEDGEMENT_MAX_LENGTH, SUPERVISOR_DECISION_ACTIONS, SUPERVISOR_DELEGATE_ROLE_IDS, SUPERVISOR_OBJECTIVE_MAX_LENGTH, SUPERVISOR_TITLE_MAX_LENGTH, } from "./contracts.js";
+import { parseSupervisorSkillAuthoringRoute } from "../supervisor-skill-authoring/contract.js";
 import { createWorkerCapabilityScopeDecisionContract, parseWorkerCapabilityScopeDecision, } from "../worker-capability-scope-decision.js";
 import { traceSupervisorAcknowledgementNormalized, traceSupervisorDecisionAccepted, traceSupervisorDecisionRejected, traceSupervisorEnvelopeAccepted, traceSupervisorEnvelopeRejected, } from "./diagnostics.js";
 import { readStructuredDecisionEnvelope } from "../../model/structured-decision-envelope.js";
@@ -41,6 +42,16 @@ export function parseSupervisorDecisionOutput(text, options = {}) {
         });
     }
     const issues = [];
+    if (record.action === "author_skill") {
+        const parsed = parseSupervisorSkillAuthoringRoute(record, options.allowSkillAuthoring === true);
+        if (diagnostic) {
+            if (parsed.ok)
+                traceSupervisorDecisionAccepted({ diagnostic, decision: parsed.decision });
+            else
+                traceSupervisorDecisionRejected({ diagnostic, selectedAction: "author_skill", issues: parsed.issues });
+        }
+        return parsed.ok ? parsed : { ...parsed, stage: "domain_parser" };
+    }
     if (isMemoryRecallDecisionRecord(record)) {
         const recalled = parseMemoryRecallDecision(record, {
             allowMemoryRecall: options.allowMemoryRecall,

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

@@ -0,0 +1,26 @@
+import type { ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.js";
+import type { RequestExecutionScope } from "../../request/execution-scope.js";
+import type { KnowledgeSkillMetadata } from "../../knowledge-skills/store.js";
+import { type SupervisorDecisionDiagnosticContext } from "./contracts.js";
+/** Preparation sees the current request, not routing state or prior tool/document bodies. */
+export declare function buildSupervisorPreparationInput(request: RequestExecutionScope, options: {
+    instructions: string;
+    format: ModelGatewayJsonSchemaFormat;
+    diagnostic: SupervisorDecisionDiagnosticContext;
+    availableSkills?: readonly KnowledgeSkillMetadata[];
+    expandedCatalog?: boolean;
+}): {
+    format: ModelGatewayJsonSchemaFormat;
+    context: Readonly<{
+        messages: import("../../../model-gateway/types.js").ChatMessage[];
+        selectedHistoryMessageIds: string[];
+        omittedHistoryMessageIds: string[];
+        budget: import("../../context/request-context-contracts.js").RequestContextBudgetEstimate & {
+            parts: import("../../context/request-context-contracts.js").RequestContextBudgetParts;
+        };
+        compaction: Readonly<{
+            applied: boolean;
+            compactedSourceRefs: readonly string[];
+        }>;
+    }>;
+};