@abot-ai/runtime 1.8.0 → 1.9.0

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,13 +6,17 @@ 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[];
     diagnostic?: SupervisorDecisionDiagnosticContext;
     resume?: SupervisorResumeContext;
@@ -27,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,
@@ -62,7 +64,13 @@ export function buildSupervisorDecisionInput(request, options) {
         })
         : undefined;
     const roleContinuationParts = roleContinuationPart ? [roleContinuationPart] : [];
+    const initialMemoryMessage = options.memoryRecallMessage
+        ? undefined
+        : options.initialMemoryMessage;
+    const skillReadContext = projectSupervisorSkillReadContext(options.skillReadHead);
     const referenceMessages = [
+        ...skillReadContext.referenceMessages,
+        ...(initialMemoryMessage ? [initialMemoryMessage] : []),
         ...(request.temporalContext
             ? [buildRequestTemporalContextMessage(request.temporalContext)]
             : []),
@@ -86,7 +94,9 @@ export function buildSupervisorDecisionInput(request, options) {
     const instructions = [
         buildSupervisorDecisionInstructions({
             allowMemoryRecall: options.allowMemoryRecall === true,
+            allowSkillAuthoring: options.allowSkillAuthoring === true,
             hasMemoryRecallContext: options.memoryRecallMessage !== undefined,
+            hasInitialMemoryContext: initialMemoryMessage !== undefined,
             includeAcknowledgement,
             includeTitle,
             includeResponseRecommendation,
@@ -96,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");
@@ -109,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 } : {}),
@@ -134,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,
@@ -173,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[];
+        }>;
+    }>;
+};

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

@@ -0,0 +1,39 @@
+import { projectRequestContext } from "../../context/request-context.js";
+import { resolveModelContextAdmission, resolveModelContextBudget } from "../../model/model-context-budget.js";
+import { estimateMessagesTokens } from "../../context/token-estimator.js";
+import { appendRequestSteeringContext } from "../../request/request-steering-context.js";
+import { resolveRequestSteeringInbox } from "../../request/request-steering.js";
+import { buildAvailableSkillsText, AVAILABLE_SKILLS_MAX_TOKENS } from "../../knowledge-skills/available-skills-projection.js";
+import { SUPERVISOR_DECISION_MODEL_STEP } from "./contracts.js";
+/** Preparation sees the current request, not routing state or prior tool/document bodies. */
+export function buildSupervisorPreparationInput(request, options) {
+    const admissionOptions = {
+        runnerConfig: request.runnerConfig, agentMode: request.agentMode,
+        modelStep: SUPERVISOR_DECISION_MODEL_STEP,
+        ...(request.modelPreference ? { modelPreference: request.modelPreference } : {}),
+        ...(request.modelPolicy ? { modelPolicy: request.modelPolicy } : {}),
+    };
+    const budget = resolveModelContextBudget(admissionOptions);
+    const calibration = resolveModelContextAdmission(admissionOptions).invocation.instructions ?? [];
+    const additionalMessages = appendRequestSteeringContext(calibration.length ? [{ role: "system", content: calibration.join("\n") }] : [], resolveRequestSteeringInbox(request.requestSteering).snapshot());
+    const additionalTokens = estimateMessagesTokens(additionalMessages, budget.tokenEstimation);
+    const base = {
+        instructions: options.instructions, format: options.format,
+        prompt: request.prompt, historyMessages: [], budget,
+        ...(request.attachments ? { attachments: request.attachments } : {}),
+        diagnostic: options.diagnostic, onEvent: request.onEvent, deferCompactionFailure: true,
+    };
+    const baseContext = projectRequestContext(base);
+    const catalog = options.availableSkills === undefined ? undefined : buildAvailableSkillsText({
+        skills: options.availableSkills,
+        budgetTokens: options.expandedCatalog
+            ? Math.max(0, baseContext.budget.availableInputTokens - baseContext.budget.estimatedInputTokens - additionalTokens)
+            : AVAILABLE_SKILLS_MAX_TOKENS,
+        tokenEstimation: budget.tokenEstimation,
+        includeListHint: false,
+    });
+    const instructions = options.availableSkills === undefined ? options.instructions : [
+        catalog ?? "Available Skills: no remaining candidate metadata is available.", options.instructions,
+    ].join("\n");
+    return { format: options.format, context: projectRequestContext({ ...base, instructions }) };
+}

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

@@ -0,0 +1,17 @@
+import type { RequestExecutionScope } from "../../request/execution-scope.js";
+import type { RoleCallLedgerHead } from "../../orchestration/role-calls/index.js";
+import { type SupervisorDecisionDiagnosticContext } from "./contracts.js";
+import { type SupervisorPresentation } from "./presentation.js";
+import { type SupervisorSkillSelection } from "./skill-selection.js";
+export declare function prepareSupervisorDecision(request: RequestExecutionScope, options: {
+    diagnostic: SupervisorDecisionDiagnosticContext;
+    includeAcknowledgement: boolean;
+    includeTitle: boolean;
+    allowSkillReads: boolean;
+    skillReadHead?: RoleCallLedgerHead;
+    boundSteeringVersion?: number;
+}): Promise<{
+    presentation: SupervisorPresentation;
+    selection: SupervisorSkillSelection;
+    steeringVersion: number;
+}>;

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

@@ -0,0 +1,65 @@
+import { invokeStructuredModelStep } from "../../model/invoke-structured-step.js";
+import { assertBoundModelStepSteeringCurrent } from "../../model/model-step-steering.js";
+import { traceDebug } from "../../observability/debug-logger.js";
+import { resolveRequestSteeringInbox } from "../../request/request-steering.js";
+import { SUPERVISOR_DECISION_MODEL_STEP } from "./contracts.js";
+import { buildSupervisorPreparationInput } from "./preparation-input.js";
+import { buildSupervisorSkillSelectionInput } from "./skill-selection-input.js";
+import { buildSupervisorPresentationInstructions, createSupervisorPresentationFormat, parseSupervisorPresentationOutput } from "./presentation.js";
+import { parseSupervisorSkillSelectionOutput } from "./skill-selection.js";
+export async function prepareSupervisorDecision(request, options) {
+    const steering = resolveRequestSteeringInbox(request.requestSteering);
+    let steeringVersion = options.boundSteeringVersion;
+    let presentation = {};
+    if (needsSupervisorPresentation(options)) {
+        const diagnostic = { ...options.diagnostic, decisionPhase: "presentation" };
+        const input = buildSupervisorPreparationInput(request, {
+            instructions: buildSupervisorPresentationInstructions(options),
+            format: createSupervisorPresentationFormat(options), diagnostic,
+        });
+        const accepted = await invokePreparationPhase(request, {
+            input, diagnostic, boundSteeringVersion: steeringVersion,
+            parse: (text) => parseSupervisorPresentationOutput(text, options),
+        });
+        presentation = accepted.decision;
+        steeringVersion = accepted.steeringVersion;
+    }
+    if (!canSelectSupervisorSkills(options))
+        return { presentation, selection: { action: "continue" }, steeringVersion: steeringVersion ?? steering.snapshot().version };
+    const diagnostic = { ...options.diagnostic, decisionPhase: "skill_selection" };
+    const input = buildSupervisorSkillSelectionInput(request, { skillReadHead: options.skillReadHead, diagnostic });
+    const accepted = await invokePreparationPhase(request, {
+        input, diagnostic, boundSteeringVersion: steeringVersion,
+        parse: parseSupervisorSkillSelectionOutput,
+    });
+    return { presentation, selection: accepted.decision, steeringVersion: accepted.steeringVersion };
+}
+function needsSupervisorPresentation(options) {
+    return options.includeAcknowledgement || options.includeTitle;
+}
+function canSelectSupervisorSkills(options) {
+    if (!options.allowSkillReads)
+        return false;
+    return !options.skillReadHead?.state.skillReads?.some((read) => read.result.outcome === "failed");
+}
+async function invokePreparationPhase(request, options) {
+    const steering = resolveRequestSteeringInbox(request.requestSteering);
+    const startedAt = Date.now();
+    assertBoundModelStepSteeringCurrent(steering, options.boundSteeringVersion);
+    traceDebug("runtime.supervisor", "model.started", { ...options.diagnostic, outputContract: options.input.format.name, messageCount: options.input.context.messages.length });
+    const accepted = await invokeStructuredModelStep({
+        request, modelStep: SUPERVISOR_DECISION_MODEL_STEP,
+        format: options.input.format, messages: options.input.context.messages,
+        boundSteeringVersion: options.boundSteeringVersion,
+        contextRetention: "exact",
+        timeoutReason: "supervisor_decision_timeout", invalidOutputReason: "invalid_supervisor_decision",
+        parse(text) {
+            const parsed = options.parse(text);
+            if (!parsed.ok)
+                return parsed;
+            return { ok: true, decision: { decision: parsed.decision, steeringVersion: steering.snapshot().version } };
+        },
+    });
+    traceDebug("runtime.supervisor", "model.completed", { ...options.diagnostic, outputContract: options.input.format.name, durationMs: Date.now() - startedAt });
+    return accepted;
+}

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

@@ -0,0 +1,13 @@
+import type { ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.js";
+import type { StructuredModelParseResult } from "../../model/invoke-structured-step.js";
+export type SupervisorPresentation = Readonly<{
+    acknowledgement?: string;
+    title?: string;
+}>;
+export type SupervisorPresentationOptions = Readonly<{
+    includeAcknowledgement: boolean;
+    includeTitle: boolean;
+}>;
+export declare function createSupervisorPresentationFormat(options: SupervisorPresentationOptions): ModelGatewayJsonSchemaFormat;
+export declare function buildSupervisorPresentationInstructions(options: SupervisorPresentationOptions): string;
+export declare function parseSupervisorPresentationOutput(text: string, options: SupervisorPresentationOptions): StructuredModelParseResult<SupervisorPresentation>;

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

@@ -0,0 +1,47 @@
+import { createStructuredDecisionEnvelopeSchema, readStructuredDecisionEnvelope } from "../../model/structured-decision-envelope.js";
+import { SUPERVISOR_ACKNOWLEDGEMENT_MAX_LENGTH, SUPERVISOR_TITLE_MAX_LENGTH } from "./contracts.js";
+export function createSupervisorPresentationFormat(options) {
+    const fields = presentationFields(options);
+    return {
+        type: "json_schema", name: "supervisor_presentation", strict: true,
+        schema: createStructuredDecisionEnvelopeSchema([{
+                type: "object",
+                properties: Object.fromEntries(fields.map(([name, maxLength]) => [name, { type: "string", minLength: 2, maxLength }])),
+                required: fields.map(([name]) => name), additionalProperties: false,
+            }]),
+        postValidatedSchemaConstraints: fields.map(([name]) => ({
+            keyword: "maxLength", path: `/properties/decision/properties/${name}/maxLength`,
+        })),
+    };
+}
+export function buildSupervisorPresentationInstructions(options) {
+    return [
+        "Write only the requested opening acknowledgement and conversation title, in the user's language. Return exactly the supplied JSON shape.",
+        "Do not plan, choose actions, answer the request, or claim completed work.",
+        ...(options.includeAcknowledgement ? [`acknowledgement: at most ${SUPERVISOR_ACKNOWLEDGEMENT_MAX_LENGTH} characters; one short sentence acknowledging the requested outcome. No implementation details or promises about a particular method.`] : []),
+        ...(options.includeTitle ? [`title: at most ${SUPERVISOR_TITLE_MAX_LENGTH} characters; a short description of the user's request.`] : []),
+    ].join("\n");
+}
+export function parseSupervisorPresentationOutput(text, options) {
+    let record;
+    try {
+        record = readStructuredDecisionEnvelope(JSON.parse(text));
+    }
+    catch { /* Rejected below. */ }
+    const fields = presentationFields(options);
+    if (!record || Object.keys(record).length !== fields.length || fields.some(([name, max]) => !isBoundedPresentation(record[name], max))) {
+        return { ok: false, stage: "domain_parser", issues: [{ code: "supervisor_presentation_invalid", path: "decision", message: "Return only the requested bounded acknowledgement/title fields." }] };
+    }
+    return { ok: true, decision: Object.freeze(Object.fromEntries(fields.map(([name]) => [name, record[name].trim()]))) };
+}
+function presentationFields(options) {
+    return [
+        ...(options.includeAcknowledgement ? [["acknowledgement", SUPERVISOR_ACKNOWLEDGEMENT_MAX_LENGTH]] : []),
+        ...(options.includeTitle ? [["title", SUPERVISOR_TITLE_MAX_LENGTH]] : []),
+    ];
+}
+function isBoundedPresentation(value, maximum) {
+    if (typeof value !== "string")
+        return false;
+    return value.trim().length >= 2 && value.length <= maximum;
+}

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

@@ -5,11 +5,16 @@ export declare function buildSupervisorDecisionInstructions(params?: Readonly<{
     includeTitle?: boolean;
     includeResponseRecommendation?: boolean;
     allowMemoryRecall?: boolean;
+    allowSkillAuthoring?: boolean;
     hasMemoryRecallContext?: boolean;
+    hasInitialMemoryContext?: boolean;
     allowedRoleIds?: readonly SupervisorDelegateRoleId[];
     hasCompletedChildResult?: boolean;
     hasRequestToolResults?: boolean;
     workerCapabilityAffordances?: readonly SupervisorWorkerCapabilityAffordance[];
     availableWorkerCapabilityCatalog?: readonly WorkerCapabilityCatalogGroup[];
 }>): string;
+/** SUPER decision-time wording; uses the existing core-memory availability. */
+export declare function buildSupervisorMemoryAvailabilityInstructions(memoryEnabled: boolean): readonly string[];
+export declare function buildSupervisorArtifactPathInstructions(): string;
 export declare function buildSupervisorWorkingDirectoryInstructions(): string;