@abot-ai/runtime 1.8.0 → 1.9.0

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

@@ -1,19 +1,23 @@
 import { resolveMemoryRecallSteeringVersion } from "../../long-term-memory/recall-binding.js";
 import { canOfferMemoryRecall } from "../../long-term-memory/recall-policy.js";
-import { invokeStructuredModelStep, StructuredModelInvalidOutputError, } from "../../model/invoke-structured-step.js";
 import { createModelStepCompactionController } from "../../context/model-step-compaction.js";
 import { superCompactionFailureOwner } from "../../context/super-compaction-failure-owner.js";
 import { createSessionMemoryAwareCompactionController } from "../../context/session-memory/index.js";
 import { resolveRequestSteeringInbox, } from "../../request/request-steering.js";
 import { SUPERVISOR_DECISION_MODEL_STEP, } from "./contracts.js";
-import { traceSupervisorDecisionPhaseSuperseded, traceSupervisorModelCompleted, traceSupervisorModelFailed, traceSupervisorModelStarted, traceSupervisorWorkingDirectoryModelStarted, } from "./diagnostics.js";
 import { buildSupervisorDecisionInput } from "./input.js";
 import { buildSupervisorCapabilityBriefOptions } from "./capability-brief.js";
 import { createSupervisorCapabilityBriefReadmissionController } from "./capability-brief-readmission.js";
-import { parseSupervisorDecisionOutput } from "./parser.js";
-import { buildSupervisorWorkingDirectoryInput, mergeSupervisorWorkingDirectory, parseSupervisorWorkingDirectoryOutput, } from "./working-directory.js";
+import { createSupervisorArtifactPathsReadmissionController } from "./artifact-paths.js";
+import { buildSupervisorWorkingDirectoryInput, mergeSupervisorWorkingDirectory, } from "./working-directory.js";
 import { SUPERVISOR_RESPONSE_MODEL_STEP } from "../supervisor-response/contracts.js";
 import { resolveCanonicalReviewerCompletionTargetText } from "../reviewer-decision/contracts.js";
+import { createDecisionOutcome, runRoutingPhase, runWorkingDirectoryPhase, requiresWorkingDirectory, tracePhaseSuperseded } from "./decision-phases.js";
+import { prepareSupervisorDecision } from "./preparation.js";
+import { isSupervisorSkillLookup } from "./skill-selection.js";
+import { assertBoundModelStepSteeringCurrent } from "../../model/model-step-steering.js";
+import { canOfferSupervisorSkillAuthoring } from "../supervisor-skill-authoring/input.js";
+import { runSupervisorSkillAuthoring } from "../supervisor-skill-authoring/run.js";
 export async function runSupervisorDecision(request, options) {
     const boundSteeringVersion = resolveMemoryRecallSteeringVersion(options.memoryRecallMessage, request.requestId, options.call.callId);
     const baseDiagnostic = {
@@ -32,37 +36,9 @@ export async function runSupervisorDecision(request, options) {
     const memoryRecallMessage = request.longTermMemory?.enabled
         ? options.memoryRecallMessage
         : undefined;
-    const input = buildSupervisorDecisionInput(request, {
-        allowMemoryRecall: canOfferMemoryRecall({
-            enabled: request.longTermMemory?.enabled === true,
-            recallCount: options.memoryRecallCount ?? 0,
-            maxRecallCallsPerRequest: request.memoryRecallLimit,
-        }),
-        ...(memoryRecallMessage ? { memoryRecallMessage } : {}),
-        ...buildSupervisorCapabilityBriefOptions(request, options),
-        toolResults: options.toolResults,
-        ...(options.includeAcknowledgement === undefined
-            ? {}
-            : { includeAcknowledgement: options.includeAcknowledgement }),
-        ...(options.includeTitle === undefined
-            ? {}
-            : { includeTitle: options.includeTitle }),
-        ...(options.allowedRoleIds === undefined
-            ? {}
-            : { allowedRoleIds: options.allowedRoleIds }),
-        ...(options.resume === undefined ? {} : { resume: options.resume }),
-        ...(options.workerCapabilityAffordances === undefined
-            ? {}
-            : {
-                workerCapabilityAffordances: options.workerCapabilityAffordances,
-            }),
-        ...(options.availableWorkerCapabilityCatalog === undefined
-            ? {}
-            : {
-                availableWorkerCapabilityCatalog: options.availableWorkerCapabilityCatalog,
-            }),
-        diagnostic: routingDiagnostic,
-    });
+    const initialMemoryMessage = request.longTermMemory?.enabled
+        ? options.initialMemoryMessage
+        : undefined;
     const requestSteering = resolveRequestSteeringInbox(request.requestSteering);
     const contextCompaction = createSessionMemoryAwareCompactionController(request, createModelStepCompactionController(request, {
         consumer: SUPERVISOR_DECISION_MODEL_STEP,
@@ -89,23 +65,78 @@ export async function runSupervisorDecision(request, options) {
         ]),
     }));
     for (;;) {
+        const preparation = await prepareSupervisorDecision(request, {
+            diagnostic: baseDiagnostic,
+            includeAcknowledgement: options.resume === undefined && options.includeAcknowledgement === true,
+            includeTitle: options.resume === undefined && (options.includeTitle ?? request.shouldGenerateSessionTitle ?? false),
+            allowSkillReads: request.knowledgeSkillStore !== undefined && options.allowSkillReads !== false,
+            skillReadHead: options.skillReadHead,
+            boundSteeringVersion,
+        });
+        assertBoundModelStepSteeringCurrent(requestSteering, preparation.steeringVersion);
+        if (isSupervisorSkillLookup(preparation.selection)) {
+            return createDecisionOutcome({ ...preparation.selection, ...preparation.presentation }, preparation.steeringVersion);
+        }
+        const input = buildSupervisorDecisionInput(request, {
+            allowSkillAuthoring: canOfferSupervisorSkillAuthoring(request, options),
+            allowMemoryRecall: canOfferMemoryRecall({
+                enabled: request.longTermMemory?.enabled === true,
+                recallCount: options.memoryRecallCount ?? 0,
+                maxRecallCallsPerRequest: request.memoryRecallLimit,
+            }),
+            ...(memoryRecallMessage ? { memoryRecallMessage } : {}),
+            ...(initialMemoryMessage ? { initialMemoryMessage } : {}),
+            ...buildSupervisorCapabilityBriefOptions(request, options),
+            toolResults: options.toolResults,
+            ...(options.skillReadHead ? { skillReadHead: options.skillReadHead } : {}),
+            includeAcknowledgement: false,
+            includeTitle: false,
+            ...(options.allowedRoleIds === undefined
+                ? {}
+                : { allowedRoleIds: options.allowedRoleIds }),
+            ...(options.resume === undefined ? {} : { resume: options.resume }),
+            ...(options.workerCapabilityAffordances === undefined
+                ? {}
+                : {
+                    workerCapabilityAffordances: options.workerCapabilityAffordances,
+                }),
+            ...(options.availableWorkerCapabilityCatalog === undefined
+                ? {}
+                : {
+                    availableWorkerCapabilityCatalog: options.availableWorkerCapabilityCatalog,
+                }),
+            diagnostic: routingDiagnostic,
+        });
         const routing = await runRoutingPhase({
             request,
             requestSteering,
-            boundSteeringVersion,
+            boundSteeringVersion: preparation.steeringVersion,
             input,
             diagnostic: routingDiagnostic,
-            contextCompaction: createSupervisorCapabilityBriefReadmissionController(request, { input, controller: contextCompaction }),
+            contextCompaction: createSupervisorArtifactPathsReadmissionController(request, {
+                projection: input.artifactPathsProjection,
+                format: input.format,
+                includeInstructions: true,
+                controller: createSupervisorCapabilityBriefReadmissionController(request, { input, controller: contextCompaction }),
+            }),
         });
+        if (routing.decision.action === "author_skill") {
+            const authored = await runSupervisorSkillAuthoring(request, {
+                ...options, diagnostic: baseDiagnostic,
+                boundSteeringVersion: routing.steeringVersion, contextCompaction,
+            });
+            return createDecisionOutcome({ ...authored.decision, ...preparation.presentation }, authored.steeringVersion);
+        }
         if (routing.decision.action === "invoke_role" &&
             routing.decision.roleId === "reviewer") {
             return createDecisionOutcome(Object.freeze({
                 ...routing.decision,
+                ...preparation.presentation,
                 objective: resolveCanonicalReviewerCompletionTargetText(request.prompt),
             }), routing.steeringVersion);
         }
         if (!requiresWorkingDirectory(routing.decision)) {
-            return createDecisionOutcome(routing.decision, routing.steeringVersion);
+            return createDecisionOutcome({ ...routing.decision, ...preparation.presentation }, routing.steeringVersion);
         }
         if (!requestSteering.isCurrent(routing.steeringVersion)) {
             tracePhaseSuperseded({
@@ -128,7 +159,12 @@ export async function runSupervisorDecision(request, options) {
             boundSteeringVersion,
             frozenDecision: routing.decision,
             diagnostic: workingDirectoryDiagnostic,
-            contextCompaction,
+            contextCompaction: createSupervisorArtifactPathsReadmissionController(request, {
+                projection: input.artifactPathsProjection,
+                format: workingDirectoryInput.format,
+                includeInstructions: false,
+                controller: contextCompaction,
+            }),
         });
         const merged = mergeSupervisorWorkingDirectory(routing.decision, workingDirectory.decision);
         if (workingDirectory.steeringVersion !== routing.steeringVersion ||
@@ -142,124 +178,6 @@ export async function runSupervisorDecision(request, options) {
             });
             continue;
         }
-        return createDecisionOutcome(merged, workingDirectory.steeringVersion);
+        return createDecisionOutcome({ ...merged, ...preparation.presentation }, workingDirectory.steeringVersion);
     }
 }
-function createDecisionOutcome(decision, steeringVersion) {
-    return Object.freeze({ decision, steeringVersion });
-}
-async function runRoutingPhase(params) {
-    const startedAt = Date.now();
-    traceSupervisorModelStarted({
-        diagnostic: params.diagnostic,
-        allowMemoryRecall: params.input.allowMemoryRecall,
-        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,
-                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;
-    }
-}
-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,
-        }),
-    });
-}
-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,
-    });
-}
-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/skill-selection-input.d.ts

@@ -0,0 +1,21 @@
+import type { RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
+import type { RequestExecutionScope } from "../../request/execution-scope.js";
+import { type SupervisorDecisionDiagnosticContext } from "./contracts.js";
+export declare function buildSupervisorSkillSelectionInput(request: RequestExecutionScope, options?: {
+    skillReadHead?: RoleCallLedgerHead;
+    diagnostic?: SupervisorDecisionDiagnosticContext;
+}): {
+    format: import("../../../model-gateway/types.js").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[];
+        }>;
+    }>;
+};

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

@@ -0,0 +1,29 @@
+import { isKnowledgeSkillStorageFailure } from "../../knowledge-skills/personal-contracts.js";
+import { SUPERVISOR_DECISION_MODEL_STEP } from "./contracts.js";
+import { buildSupervisorPreparationInput } from "./preparation-input.js";
+import { createSupervisorSkillSelectionFormat, SUPERVISOR_SKILL_SELECTION_INSTRUCTIONS } from "./skill-selection.js";
+export function buildSupervisorSkillSelectionInput(request, options = {}) {
+    const reads = options.skillReadHead?.state.skillReads ?? [];
+    const loadedIds = new Set(reads.flatMap((read) => read.operation === "read_skills" && read.result.outcome === "completed"
+        ? read.result.skills.map((skill) => skill.skillId) : []));
+    const lastList = [...reads].reverse().find((read) => read.operation === "list_skills" && read.result.outcome === "completed");
+    const metadata = lastList?.result.outcome === "completed"
+        ? lastList.result.skills : readCandidateMetadata(request);
+    return buildSupervisorPreparationInput(request, {
+        instructions: SUPERVISOR_SKILL_SELECTION_INSTRUCTIONS,
+        format: createSupervisorSkillSelectionFormat(),
+        diagnostic: options.diagnostic ?? { requestId: request.requestId, modelStep: SUPERVISOR_DECISION_MODEL_STEP, decisionPhase: "skill_selection" },
+        availableSkills: metadata.filter((skill) => !loadedIds.has(skill.skillId)),
+        expandedCatalog: lastList !== undefined,
+    });
+}
+function readCandidateMetadata(request) {
+    try {
+        return request.knowledgeSkillStore?.list() ?? [];
+    }
+    catch (error) {
+        if (isKnowledgeSkillStorageFailure(error))
+            return [];
+        throw error;
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.js";
+import type { StructuredModelParseResult } from "../../model/invoke-structured-step.js";
+import { type SkillReadDecision } from "../skill-read-decision.js";
+type SupervisorSkillRead = Extract<SkillReadDecision, {
+    action: "read_skills";
+}>;
+export type SupervisorSkillSelection = SupervisorSkillRead | Readonly<{
+    action: "continue";
+}>;
+export declare function isSupervisorSkillLookup(selection: SkillReadDecision | Readonly<{
+    action: "continue";
+}>): selection is SupervisorSkillRead;
+export declare function createSupervisorSkillSelectionFormat(): ModelGatewayJsonSchemaFormat;
+export declare const SUPERVISOR_SKILL_SELECTION_INSTRUCTIONS: string;
+export declare function parseSupervisorSkillSelectionOutput(text: string): StructuredModelParseResult<SupervisorSkillSelection>;
+export {};

package/dist/src/runtime/steps/supervisor-decision/skill-selection.js

@@ -0,0 +1,44 @@
+import { createStructuredDecisionEnvelopeSchema, readStructuredDecisionEnvelope } from "../../model/structured-decision-envelope.js";
+import { createSkillReadDecisionSchemas, parseSkillReadDecision } from "../skill-read-decision.js";
+const READ_OPTIONS = Object.freeze({ acknowledgementMaxLength: 0, titleMaxLength: 0, allowSkillReads: true });
+export function isSupervisorSkillLookup(selection) {
+    return selection.action === "read_skills";
+}
+export function createSupervisorSkillSelectionFormat() {
+    const [, readSchema] = createSkillReadDecisionSchemas(READ_OPTIONS);
+    return {
+        type: "json_schema", name: "supervisor_skill_selection", strict: true,
+        schema: createStructuredDecisionEnvelopeSchema([
+            { type: "object", properties: { action: { type: "string", enum: ["continue"] } }, required: ["action"], additionalProperties: false },
+            readSchema,
+        ]),
+        postValidatedSchemaConstraints: [{ keyword: "maxLength", path: "/properties/decision/anyOf/1/properties/skillIds/items/maxLength" }],
+    };
+}
+export const SUPERVISOR_SKILL_SELECTION_INSTRUCTIONS = [
+    "Match the user's request to Available Skills. Your only task is selecting relevant guidance; return only the supplied JSON shape.",
+    "Select a Skill only when its description is relevant to the requested task, resources, workflow or answer style. Do not select Skills merely because they exist. No relevant match: choose continue. Greetings and standalone factual questions normally need no Skill.",
+    "For a relevant match, choose read_skills with up to eight exact IDs or full names in skillIds. Percent-decode displayed IDs. A user request to create or edit a Skill matches Skill Creator.",
+    "Skills already read successfully for this request are omitted; do not request them again. Metadata is not document content and grants no authority or completion evidence.",
+    "The available catalog is already supplied. Choose read_skills from the displayed metadata or continue. Reading is optional; do not invent a match.",
+].join("\n");
+export function parseSupervisorSkillSelectionOutput(text) {
+    let record;
+    try {
+        record = readStructuredDecisionEnvelope(JSON.parse(text));
+    }
+    catch { /* Rejected below. */ }
+    if (!record)
+        return { ok: false, stage: "json_envelope", issues: [{ code: "skill_selection_envelope_invalid", path: "decision", message: "Return one decision object." }] };
+    if (isContinueSelection(record))
+        return { ok: true, decision: Object.freeze({ action: "continue" }) };
+    const parsed = parseSkillReadDecision(record, READ_OPTIONS);
+    if (!parsed.ok)
+        return parsed;
+    if (!isSupervisorSkillLookup(parsed.decision))
+        return { ok: false, stage: "domain_parser", issues: [{ code: "skill_selection_action_invalid", path: "decision.action", message: "Choose read_skills or continue." }] };
+    return { ok: true, decision: parsed.decision };
+}
+function isContinueSelection(record) {
+    return record.action === "continue" && Object.keys(record).length === 1;
+}

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

@@ -3,6 +3,7 @@ import type { ChatMessage } from "../../../model-gateway/types.js";
 import { type RequestToolResultsView } from "../../context/request-tool-results.js";
 import type { RequestExecutionSeed } from "../../request/contracts.js";
 import { SUPERVISOR_RESPONSE_MODEL_STEP, type SupervisorResponseCallIdentity, type SupervisorResponseResumeContext } from "./contracts.js";
+import type { RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
 export type SupervisorResponseInputRequest = Pick<RequestExecutionSeed, "requestId" | "prompt" | "historyMessages" | "sessionKind" | "runnerConfig" | "attachments" | "agentMode" | "modelPreference" | "modelPolicy" | "scheduledExecution" | "automationOutputContract"> & Partial<Pick<RequestExecutionSeed, "onEvent" | "sessionMemory">>;
 export declare function buildSupervisorResponseInput(request: SupervisorResponseInputRequest, options: SupervisorResponseInputOptions): {
     context: RequestContextProjection;
@@ -14,8 +15,10 @@ export declare function buildSupervisorMemoryAuthoringInput(request: SupervisorR
 };
 type SupervisorResponseInputOptions = Readonly<{
     responseRecommendation?: string;
+    responseRecommendationOrigin?: "skill_authoring_no_save";
     call: SupervisorResponseCallIdentity;
     toolResults: RequestToolResultsView;
+    skillReadHead?: RoleCallLedgerHead;
     resume?: SupervisorResponseResumeContext;
     longTermMemoryMessage?: ChatMessage;
     memoryAuthoringMessage?: ChatMessage;

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

@@ -11,6 +11,7 @@ import { createSupervisorMemoryCandidatesFormat } from "./memory-authoring.js";
 import { buildSupervisorResponseRecommendationMessage } from "./response-recommendation.js";
 import { buildSupervisorMemoryAuthoringInstructions, buildSupervisorResponseInstructions, } from "./prompt.js";
 import { automationResponseFormat } from "../../request/automation-output-contract.js";
+import { buildCoreSkillReadContextMessages } from "../../context/core-skill-read-context.js";
 export function buildSupervisorResponseInput(request, options) {
     const responseRecommendationMessage = buildSupervisorResponseRecommendationMessage(options);
     const scheduledExecution = projectScheduledExecutionContext(request, [buildSupervisorResponseInstructions({
@@ -24,6 +25,10 @@ export function buildSupervisorResponseInput(request, options) {
             : [])].join("\n"), "response");
     return buildSupervisorInput(request, options, {
         ...scheduledExecution,
+        referenceMessages: [
+            ...(scheduledExecution.referenceMessages ?? []),
+            ...buildCoreSkillReadContextMessages(options.skillReadHead),
+        ],
         ...(request.automationOutputContract
             ? { format: automationResponseFormat(request.automationOutputContract) }
             : {}),

package/dist/src/runtime/steps/supervisor-response/prompt.js

@@ -1,3 +1,4 @@
+import { SUPER_SKILL_GUIDANCE_INSTRUCTION } from "../supervisor-skill-instructions.js";
 import { CONVERSATION_MEMORY_AUTHORING_INSTRUCTIONS } from "../../long-term-memory/conversation-authoring/prompt.js";
 export function buildSupervisorResponseInstructions(params) {
     return [
@@ -31,6 +32,7 @@ export function buildSupervisorResponseInstructions(params) {
                 "Use each capsule result only for its exact reported outcome, observed effect, and summary. It does not by itself prove completion of the delegated work or of the user request.",
             ]
             : []),
+        SUPER_SKILL_GUIDANCE_INSTRUCTION,
         "Do not mention internal role names, call identifiers, runtime contracts, or orchestration unless the user explicitly asks about them.",
     ].join("\n");
 }

package/dist/src/runtime/steps/supervisor-response/response-recommendation.d.ts

@@ -1,3 +1,4 @@
+import type { RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
 import type { ChatMessage } from "../../../model-gateway/types.js";
 import type { RequestToolResultsView } from "../../context/request-tool-results.js";
 import type { SupervisorResponseCallIdentity, SupervisorResponseResumeContext } from "./contracts.js";
@@ -5,6 +6,8 @@ export declare const SUPERVISOR_RESPONSE_RECOMMENDATION_KIND = "runtime_supervis
 export declare function buildSupervisorResponseRecommendationMessage(options: Readonly<{
     call: SupervisorResponseCallIdentity;
     responseRecommendation?: string;
+    responseRecommendationOrigin?: "skill_authoring_no_save";
     resume?: SupervisorResponseResumeContext;
     toolResults: RequestToolResultsView;
+    skillReadHead?: RoleCallLedgerHead;
 }>): ChatMessage | undefined;

package/dist/src/runtime/steps/supervisor-response/response-recommendation.js

@@ -6,20 +6,40 @@ export function buildSupervisorResponseRecommendationMessage(options) {
     if (!isSupervisorResponseRecommendation(options.responseRecommendation)) {
         throw new Error("supervisor_response_recommendation_invalid");
     }
-    if (!canRecommendDirectSupervisorResponse(options)) {
+    if (!canProjectSupervisorResponseRecommendation(options)) {
         throw new Error("supervisor_response_recommendation_scope_invalid");
     }
+    const { limitations, ...semantics } = supervisorResponseRecommendationSemantics(options.responseRecommendationOrigin);
     return Object.freeze({
         role: "system",
         content: JSON.stringify({
             kind: SUPERVISOR_RESPONSE_RECOMMENDATION_KIND,
             authority: "accepted_supervisor_decision",
-            purpose: "guide_direct_response_content",
-            applicability: "current_direct_response_only",
+            ...semantics,
             callId: options.call.callId,
             invocationAttempt: options.call.invocationAttempt,
             responseRecommendation: options.responseRecommendation,
-            limitations: "Internal answer-content recommendation from the accepted Supervisor decision, not new user intent, execution authority, or completion evidence. Use its relevant substance to compose the answer, subject to the current request and supplied facts. Do not expose the recommendation's internal framing.",
+            limitations,
         }),
     });
 }
+function canProjectSupervisorResponseRecommendation(options) {
+    if (options.responseRecommendationOrigin === "skill_authoring_no_save")
+        return true;
+    return canRecommendDirectSupervisorResponse(options);
+}
+function supervisorResponseRecommendationSemantics(origin) {
+    if (origin === "skill_authoring_no_save") {
+        return {
+            purpose: "explain_skill_authoring_no_save",
+            applicability: "current_response_after_skill_authoring_no_save",
+            outcome: "no_save",
+            limitations: "The accepted Skill authoring flow did not produce a save. Use the supplied reason to explain why, subject to the current request and supplied facts. It adds no user intent, execution authority, or completion evidence. This decision does not establish a save; report any earlier save only from its confirmed write result. Do not expose internal routing details.",
+        };
+    }
+    return {
+        purpose: "guide_direct_response_content",
+        applicability: "current_direct_response_only",
+        limitations: "Internal answer-content recommendation from the accepted Supervisor decision, not new user intent, execution authority, or completion evidence. Use its relevant substance to compose the answer, subject to the current request and supplied facts. Do not expose the recommendation's internal framing.",
+    };
+}

package/dist/src/runtime/steps/supervisor-response/run.d.ts

@@ -1,4 +1,5 @@
 import type { ChatMessage } from "../../../model-gateway/types.js";
+import type { RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
 import type { RequestToolResultsView } from "../../context/request-tool-results.js";
 import type { RequestExecutionScope } from "../../request/execution-scope.js";
 import { type SupervisorResponseCallIdentity, type SupervisorResponseResumeContext } from "./contracts.js";
@@ -6,16 +7,22 @@ import { type RequestSteeringSnapshot } from "../../request/request-steering.js"
 import type { RootAuthoredResponse } from "../../long-term-memory/contracts.js";
 export declare function runSupervisorResponse(request: RequestExecutionScope, options: Readonly<{
     responseRecommendation?: string;
+    responseRecommendationOrigin?: "skill_authoring_no_save";
     memoryRecallMessage?: ChatMessage;
+    initialMemoryMessage?: ChatMessage;
     call: SupervisorResponseCallIdentity;
     toolResults: RequestToolResultsView;
+    skillReadHead?: RoleCallLedgerHead;
     resume?: SupervisorResponseResumeContext;
 }>): Promise<string>;
 export declare function runSupervisorAuthoredResponse(request: RequestExecutionScope, options: Readonly<{
     responseRecommendation?: string;
+    responseRecommendationOrigin?: "skill_authoring_no_save";
     memoryRecallMessage?: ChatMessage;
+    initialMemoryMessage?: ChatMessage;
     call: SupervisorResponseCallIdentity;
     toolResults: RequestToolResultsView;
+    skillReadHead?: RoleCallLedgerHead;
     resume?: SupervisorResponseResumeContext;
     steeringSnapshot?: RequestSteeringSnapshot;
 }>): Promise<RootAuthoredResponse>;

package/dist/src/runtime/steps/supervisor-response/run.js

@@ -9,7 +9,6 @@ import { buildSupervisorMemoryAuthoringInput, buildSupervisorResponseInput, } fr
 import { buildSupervisorResponseRepairHint } from "./prompt.js";
 import { SUPERVISOR_DECISION_MODEL_STEP } from "../supervisor-decision/contracts.js";
 import { resolveRequestSteeringInbox, } from "../../request/request-steering.js";
-import { retrieveResponseLongTermMemory } from "../../long-term-memory/response-context.js";
 import { authorSupervisorMemoryCandidates } from "./memory-authoring.js";
 import { canAuthorConversationMemory, prepareConversationMemoryAuthoring, } from "../../long-term-memory/conversation-authoring/context.js";
 import { assertBoundModelStepSteeringCurrent, isModelStepSteeringSuperseded, } from "../../model/model-step-steering.js";
@@ -32,11 +31,9 @@ export async function runSupervisorAuthoredResponse(request, options) {
             ? options.steeringSnapshot?.version
             : undefined);
     assertBoundModelStepSteeringCurrent(requestSteering, boundSteeringVersion);
-    const memoryMessage = options.memoryRecallMessage ??
-        (memoryEnabled && options.steeringSnapshot
-            ? await retrieveResponseLongTermMemory(request, options.steeringSnapshot)
-            : undefined);
-    assertBoundModelStepSteeringCurrent(requestSteering, boundSteeringVersion);
+    const memoryMessage = memoryEnabled
+        ? options.memoryRecallMessage ?? options.initialMemoryMessage
+        : undefined;
     const inputOptions = {
         ...options,
         ...(memoryMessage ? { longTermMemoryMessage: memoryMessage } : {}),

package/dist/src/runtime/steps/supervisor-skill-authoring/contract.d.ts

@@ -0,0 +1,43 @@
+import type { ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.js";
+import type { KnowledgeSkillMetadata } from "../../knowledge-skills/store.js";
+import type { StructuredModelParseResult } from "../../model/invoke-structured-step.js";
+export type SupervisorSkillAuthoringSelection = Readonly<{
+    action: "create_skill";
+    name: string;
+    description: string;
+}> | Readonly<{
+    action: "update_skill";
+    skillId: string;
+    name?: string;
+    description?: string;
+}> | Readonly<{
+    action: "no_save";
+    reason: string;
+}>;
+export type SupervisorSkillWriteSelection = Exclude<SupervisorSkillAuthoringSelection, {
+    action: "no_save";
+}>;
+export type SupervisorSkillAuthoringOptions = Readonly<{
+    writeOperationIds: readonly string[];
+    personalSkills: readonly KnowledgeSkillMetadata[];
+}>;
+export declare const SUPERVISOR_SKILL_NO_SAVE_REASON_MAX_LENGTH = 300;
+export declare const SUPERVISOR_SKILL_AUTHORING_ROUTE_SCHEMA: {
+    type: string;
+    properties: {
+        action: {
+            type: string;
+            enum: string[];
+        };
+    };
+    required: string[];
+    additionalProperties: boolean;
+};
+export declare function isSupervisorSkillWriteSelection(decision: Readonly<{
+    action: string;
+}>): decision is SupervisorSkillWriteSelection;
+export declare function parseSupervisorSkillAuthoringRoute(record: Readonly<Record<string, unknown>>, allowed: boolean): StructuredModelParseResult<Readonly<{
+    action: "author_skill";
+}>>;
+export declare function createSupervisorSkillAuthoringFormat(options: SupervisorSkillAuthoringOptions): ModelGatewayJsonSchemaFormat;
+export declare function parseSupervisorSkillAuthoringOutput(text: string, options: SupervisorSkillAuthoringOptions): StructuredModelParseResult<SupervisorSkillAuthoringSelection>;