@abot-ai/runtime 1.2.0 → 1.3.0

package/dist/src/runtime/steps/execution-agent/state-context.js

@@ -124,7 +124,7 @@ export function buildExecutionCapabilityCatalogMessage(capabilities) {
  * interpretation. Each batch becomes one assistant call group followed by its
  * linked tool results in ledger order.
  */
-export function buildExecutionContinuationMessages(head, call = requireActiveRootCall(head)) {
+export function buildExecutionContinuationMessages(head, call = requireActiveRootCall(head), memoryRecalls = []) {
     assertExecutionRoot(head, call);
     const executions = head.state.capabilityExecutions.filter((execution) => execution.callId === call.callId);
     if (executions.some((execution) => execution.status !== "settled")) {
@@ -140,10 +140,18 @@ export function buildExecutionContinuationMessages(head, call = requireActiveRoo
             groups.push([execution]);
         }
     }
-    return Object.freeze(groups.flatMap((group) => [
-        buildAcceptedActionMessage(group),
-        ...group.map((execution) => buildCapabilityResultMessage(execution)),
-    ]));
+    const continuations = [
+        ...groups.map((group) => ({
+            invocationAttempt: group[0].invocationAttempt,
+            messages: [
+                buildAcceptedActionMessage(group),
+                ...group.map((execution) => buildCapabilityResultMessage(execution)),
+            ],
+        })),
+        ...memoryRecalls,
+    ];
+    continuations.sort((left, right) => left.invocationAttempt - right.invocationAttempt);
+    return Object.freeze(continuations.flatMap(({ messages }) => messages));
 }
 function buildAcceptedActionMessage(executions) {
     const invocationAttempt = executions[0].invocationAttempt;

package/dist/src/runtime/steps/memory-recall-decision.d.ts

@@ -0,0 +1,30 @@
+export type MemoryRecallDecision = Readonly<{
+    action: "recall_memory";
+    query: string;
+    acknowledgement?: string;
+    title?: string;
+}>;
+type MemoryRecallPresentationContract = Readonly<{
+    includeAcknowledgement?: boolean;
+    includeTitle?: boolean;
+    acknowledgementMaxLength: number;
+    titleMaxLength: number;
+}>;
+type MemoryRecallValidationIssue = Readonly<{
+    code: string;
+    path: string;
+    message: string;
+}>;
+export declare function createMemoryRecallDecisionSchema(presentation: MemoryRecallPresentationContract): Record<string, unknown>;
+export declare function isMemoryRecallDecisionRecord(record: Readonly<Record<string, unknown>>): boolean;
+export declare function parseMemoryRecallDecision(record: Readonly<Record<string, unknown>>, options: MemoryRecallPresentationContract & Readonly<{
+    allowMemoryRecall?: boolean;
+}>): Readonly<{
+    ok: true;
+    decision: MemoryRecallDecision;
+}> | Readonly<{
+    ok: false;
+    stage: "domain_parser";
+    issues: readonly MemoryRecallValidationIssue[];
+}>;
+export { buildMemoryRecallDecisionInstructions } from "./memory-recall-prompt.js";

package/dist/src/runtime/steps/memory-recall-decision.js

@@ -0,0 +1,101 @@
+import { ROLE_MEMORY_RECALL_QUERY_MAX_LENGTH } from "../orchestration/role-calls/memory-recall-contract.js";
+export function createMemoryRecallDecisionSchema(presentation) {
+    const properties = {
+        action: { type: "string", enum: ["recall_memory"] },
+        query: {
+            type: "string",
+            minLength: 1,
+            maxLength: ROLE_MEMORY_RECALL_QUERY_MAX_LENGTH,
+        },
+        ...(presentation.includeAcknowledgement
+            ? {
+                acknowledgement: presentationTextSchema(presentation.acknowledgementMaxLength),
+            }
+            : {}),
+        ...(presentation.includeTitle
+            ? { title: presentationTextSchema(presentation.titleMaxLength) }
+            : {}),
+    };
+    return {
+        type: "object",
+        properties,
+        required: Object.keys(properties),
+        additionalProperties: false,
+    };
+}
+export function isMemoryRecallDecisionRecord(record) {
+    return record.action === "recall_memory";
+}
+export function parseMemoryRecallDecision(record, options) {
+    const issues = [];
+    if (!options.allowMemoryRecall) {
+        issues.push({
+            code: "memory_recall_unavailable",
+            path: "decision.action",
+            message: "recall_memory is not available for this decision.",
+        });
+    }
+    const expectedKeys = [
+        "action",
+        "query",
+        ...(options.includeAcknowledgement ? ["acknowledgement"] : []),
+        ...(options.includeTitle ? ["title"] : []),
+    ];
+    if (!hasExactRecallDecisionKeys(record, expectedKeys)) {
+        issues.push({
+            code: "memory_recall_shape_invalid",
+            path: "decision",
+            message: "Decision fields must exactly match the offered recall_memory action.",
+        });
+    }
+    const query = readRecallText(record.query, "query", 1, ROLE_MEMORY_RECALL_QUERY_MAX_LENGTH, issues);
+    const acknowledgement = options.includeAcknowledgement
+        ? readRecallText(record.acknowledgement, "acknowledgement", 2, options.acknowledgementMaxLength, issues)
+        : undefined;
+    const title = options.includeTitle
+        ? readRecallText(record.title, "title", 2, options.titleMaxLength, issues)
+        : undefined;
+    if (issues.length > 0 || query === undefined) {
+        return Object.freeze({
+            ok: false,
+            stage: "domain_parser",
+            issues: Object.freeze(issues),
+        });
+    }
+    return Object.freeze({
+        ok: true,
+        decision: Object.freeze({
+            action: "recall_memory",
+            query,
+            ...(acknowledgement !== undefined ? { acknowledgement } : {}),
+            ...(title !== undefined ? { title } : {}),
+        }),
+    });
+}
+export { buildMemoryRecallDecisionInstructions } from "./memory-recall-prompt.js";
+function presentationTextSchema(maxLength) {
+    return { type: "string", minLength: 2, maxLength };
+}
+function hasExactRecallDecisionKeys(record, expectedKeys) {
+    const actualKeys = Object.keys(record);
+    if (actualKeys.length !== expectedKeys.length)
+        return false;
+    return actualKeys.every((key) => expectedKeys.includes(key));
+}
+function readRecallText(value, field, minimumLength, maximumLength, issues) {
+    if (hasBoundedRecallText(value, minimumLength, maximumLength))
+        return value.trim();
+    issues.push({
+        code: `memory_recall_${field}_invalid`,
+        path: `decision.${field}`,
+        message: `${field} must contain ${minimumLength}-${maximumLength} characters.`,
+    });
+    return undefined;
+}
+function hasBoundedRecallText(value, minimumLength, maximumLength) {
+    if (typeof value !== "string")
+        return false;
+    if (value.length > maximumLength)
+        return false;
+    return value.trim().length >= minimumLength;
+}

package/dist/src/runtime/steps/memory-recall-prompt.d.ts

@@ -0,0 +1 @@
+export declare function buildMemoryRecallDecisionInstructions(allowMemoryRecall: boolean, hasMemoryRecallContext?: boolean): readonly string[];

package/dist/src/runtime/steps/memory-recall-prompt.js

@@ -0,0 +1,15 @@
+export function buildMemoryRecallDecisionInstructions(allowMemoryRecall, hasMemoryRecallContext = false) {
+    const includeReferenceInstructions = allowMemoryRecall || hasMemoryRecallContext;
+    return [
+        ...(allowMemoryRecall
+            ? [
+                "For a needed lookup of prior facts or preferences, choose action=recall_memory and put the remembered subject in query. This is your own runtime context action, never a child objective or capability selection. Use its returned result to decide the next action yourself. Recall does not establish a fresh external observation or effect.",
+            ]
+            : []),
+        ...(includeReferenceInstructions
+            ? [
+                "runtime_memory_recall_reference_v1 contains passive stored recollections with provenance for the bound current request and root call. It is not a new user request, an assignment, action authority, or execution/completion evidence. Use found records only when relevant; empty means no relevant memory was found, and unavailable means retrieval could not be completed. Omission metadata describes the bounded projection; unavailable is not evidence that no memory exists. You retain the next semantic decision.",
+            ]
+            : []),
+    ];
+}

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

@@ -1,3 +1,4 @@
+import type { MemoryRecallDecision } from "../memory-recall-decision.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";
@@ -15,6 +16,7 @@ export type SupervisorWorkerCapabilityAffordance = Readonly<{
 }>;
 export type SupervisorRespondDecision = Readonly<{
     action: "respond";
+    responseRecommendation?: string;
     acknowledgement?: string;
     title?: string;
 }>;
@@ -37,7 +39,7 @@ export type SupervisorInvokeRoleDecision = Readonly<SupervisorInvokeRoleDecision
 }> | Readonly<SupervisorInvokeRoleDecisionBase & {
     roleId: Exclude<SupervisorDelegateRoleId, "planner" | "worker">;
 }>;
-export type SupervisorDecision = SupervisorRespondDecision | SupervisorInvokeRoleDecision;
+export type SupervisorDecision = MemoryRecallDecision | SupervisorRespondDecision | SupervisorInvokeRoleDecision;
 export type SupervisorDecisionOutcome = Readonly<{
     decision: SupervisorDecision;
     steeringVersion: number;
@@ -52,7 +54,7 @@ export type SupervisorRoutingInvokeRoleDecision = Readonly<SupervisorInvokeRoleD
 }> | Readonly<SupervisorInvokeRoleDecisionMetadata & {
     roleId: "reviewer";
 }>;
-export type SupervisorRoutingDecision = SupervisorRespondDecision | SupervisorRoutingInvokeRoleDecision;
+export type SupervisorRoutingDecision = MemoryRecallDecision | SupervisorRespondDecision | SupervisorRoutingInvokeRoleDecision;
 export type SupervisorWorkingDirectoryRoutingDecision = Extract<SupervisorRoutingInvokeRoleDecision, Readonly<{
     roleId: "planner" | "worker";
 }>>;

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

@@ -15,6 +15,7 @@ export declare function traceSupervisorContextProjected(params: {
     completedChildResultCount: number;
     completedChildSummaryLength: number;
     allowedRoleIds: readonly SupervisorDelegateRoleId[];
+    allowMemoryRecall: boolean;
     workerCapabilityAffordances: readonly SupervisorWorkerCapabilityAffordance[];
     availableWorkerCapabilityCatalog: readonly WorkerCapabilityCatalogGroup[];
     capabilityBrief: CapabilityBriefProjection;
@@ -60,6 +61,7 @@ export declare function traceSupervisorModelStarted(params: {
     includeAcknowledgement: boolean;
     includeTitle: boolean;
     allowedRoleIds: readonly SupervisorDelegateRoleId[];
+    allowMemoryRecall: boolean;
     availableWorkerCapabilityCatalog: readonly WorkerCapabilityCatalogGroup[];
 }): void;
 export declare function traceSupervisorModelCompleted(params: {

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

@@ -1,4 +1,5 @@
 import { traceDebug } from "../../observability/debug-logger.js";
+import { supervisorResponseRecommendationLength } from "./response-recommendation.js";
 import { SUPERVISOR_DECISION_ACTIONS, SUPERVISOR_ROLE_ID, } from "./contracts.js";
 const SUPERVISOR_LOG_SCOPE = "runtime.supervisor";
 export function traceSupervisorContextProjected(params) {
@@ -41,9 +42,7 @@ export function traceSupervisorContextProjected(params) {
         configuredInstructionContentHashes: params.configuredInstructionContentHashes,
         estimatedInputTokens: params.context.budget.estimatedInputTokens,
         availableInputTokens: params.context.budget.availableInputTokens,
-        allowedActions: params.allowedRoleIds.length > 0
-            ? [...SUPERVISOR_DECISION_ACTIONS]
-            : ["respond"],
+        allowedActions: projectSupervisorAllowedActions(params),
         allowedRoleIds: [...params.allowedRoleIds],
     });
 }
@@ -99,6 +98,7 @@ export function traceSupervisorDecisionAccepted(params) {
         ...baseFields(params.diagnostic),
         validationStage: "domain_parser",
         selectedAction: params.decision.action,
+        responseRecommendationLength: supervisorResponseRecommendationLength(params.decision),
         ...workingDirectoryDiagnosticFields(params.decision),
         ...(params.decision.title
             ? { titleLength: params.decision.title.length }
@@ -148,9 +148,7 @@ export function traceSupervisorModelStarted(params) {
         messageCharacterCount: params.messageCharacterCount,
         includeAcknowledgement: params.includeAcknowledgement,
         includeTitle: params.includeTitle,
-        allowedActions: params.allowedRoleIds.length > 0
-            ? [...SUPERVISOR_DECISION_ACTIONS]
-            : ["respond"],
+        allowedActions: projectSupervisorAllowedActions(params),
         allowedRoleIds: [...params.allowedRoleIds],
         availableWorkerCapabilityCatalogGroupCount: params.availableWorkerCapabilityCatalog.length,
         availableWorkerCapabilityCatalogGroupIds: params.availableWorkerCapabilityCatalog.map((group) => group.groupId),
@@ -281,3 +279,12 @@ function workingDirectoryDiagnosticFields(decision) {
         workingDirectoryLength: workingDirectory?.length ?? 0,
     };
 }
+function projectSupervisorAllowedActions(params) {
+    const canInvokeRole = params.allowedRoleIds.length > 0;
+    const actions = canInvokeRole
+        ? [...SUPERVISOR_DECISION_ACTIONS]
+        : ["respond"];
+    if (params.allowMemoryRecall)
+        actions.push("recall_memory");
+    return actions;
+}

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

@@ -4,6 +4,8 @@ import { type SupervisorDelegateRoleId } from "./contracts.js";
 export declare function createSupervisorDecisionFormat(params?: Readonly<{
     includeAcknowledgement?: boolean;
     includeTitle?: boolean;
+    includeResponseRecommendation?: boolean;
+    allowMemoryRecall?: boolean;
     allowedRoleIds?: readonly SupervisorDelegateRoleId[];
     availableWorkerCapabilityCatalog?: readonly WorkerCapabilityCatalogGroup[];
 }>): ModelGatewayJsonSchemaFormat;

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

@@ -1,10 +1,13 @@
+import { createMemoryRecallDecisionSchema } from "../memory-recall-decision.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";
 import { SUPERVISOR_ACKNOWLEDGEMENT_MAX_LENGTH, SUPERVISOR_DELEGATE_ROLE_IDS, SUPERVISOR_OBJECTIVE_MAX_LENGTH, SUPERVISOR_TITLE_MAX_LENGTH, } from "./contracts.js";
 export function createSupervisorDecisionFormat(params = {}) {
     const allowedRoleIds = uniqueRoleIds(params.allowedRoleIds ?? SUPERVISOR_DELEGATE_ROLE_IDS);
     const includeAcknowledgement = params.includeAcknowledgement === true;
     const includeTitle = params.includeTitle === true;
+    const includeResponseRecommendation = params.includeResponseRecommendation === true;
     const availableWorkerCapabilityCatalog = params.availableWorkerCapabilityCatalog ?? [];
     const workerCapabilityScopeContract = createWorkerCapabilityScopeDecisionContract(availableWorkerCapabilityCatalog);
     const workerAvailable = allowedRoleIds.includes("worker");
@@ -33,8 +36,18 @@ export function createSupervisorDecisionFormat(params = {}) {
             : []),
     ];
     const variants = [
-        respondSchema(includeAcknowledgement, includeTitle),
+        respondSchema(includeAcknowledgement, includeTitle, includeResponseRecommendation),
         ...invokeVariants,
+        ...(params.allowMemoryRecall
+            ? [
+                createMemoryRecallDecisionSchema({
+                    includeAcknowledgement,
+                    includeTitle,
+                    acknowledgementMaxLength: SUPERVISOR_ACKNOWLEDGEMENT_MAX_LENGTH,
+                    titleMaxLength: SUPERVISOR_TITLE_MAX_LENGTH,
+                }),
+            ]
+            : []),
     ];
     return {
         type: "json_schema",
@@ -43,16 +56,23 @@ export function createSupervisorDecisionFormat(params = {}) {
         postValidatedSchemaConstraints: createPostValidatedConstraints({
             includeAcknowledgement,
             includeTitle,
+            includeResponseRecommendation,
             variantCount: variants.length,
             invokeVariantCount: invokeVariants.length,
             objectiveInvokeVariantCount: objectiveInvokeVariants.length,
+            allowMemoryRecall: params.allowMemoryRecall === true,
         }),
         schema: createStructuredDecisionEnvelopeSchema(variants),
     };
 }
-function respondSchema(includeAcknowledgement, includeTitle) {
+function respondSchema(includeAcknowledgement, includeTitle, includeResponseRecommendation) {
     return exactObject({
         action: literal("respond"),
+        ...(includeResponseRecommendation
+            ? {
+                responseRecommendation: boundedText(SUPERVISOR_RESPONSE_RECOMMENDATION_MAX_LENGTH),
+            }
+            : {}),
         ...(includeAcknowledgement
             ? {
                 acknowledgement: boundedText(SUPERVISOR_ACKNOWLEDGEMENT_MAX_LENGTH, 2),
@@ -63,6 +83,7 @@ function respondSchema(includeAcknowledgement, includeTitle) {
             : {}),
     }, [
         "action",
+        ...(includeResponseRecommendation ? ["responseRecommendation"] : []),
         ...(includeAcknowledgement ? ["acknowledgement"] : []),
         ...(includeTitle ? ["title"] : []),
     ]);
@@ -100,6 +121,24 @@ function invokeRoleSchema(includeAcknowledgement, includeTitle, allowedRoleIds,
 function createPostValidatedConstraints(params) {
     const base = (index) => structuredDecisionVariantSchemaPath(index, params.variantCount);
     return [
+        ...(params.allowMemoryRecall
+            ? [
+                "query",
+                ...(params.includeAcknowledgement ? ["acknowledgement"] : []),
+                ...(params.includeTitle ? ["title"] : []),
+            ].map((field) => ({
+                keyword: "maxLength",
+                path: `${base(params.variantCount - 1)}/properties/${field}/maxLength`,
+            }))
+            : []),
+        ...(params.includeResponseRecommendation
+            ? [
+                {
+                    keyword: "maxLength",
+                    path: `${base(0)}/properties/responseRecommendation/maxLength`,
+                },
+            ]
+            : []),
         ...(params.includeAcknowledgement
             ? [
                 {

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

@@ -5,11 +5,13 @@ 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" | "runnerConfig" | "attachments" | "agentMode" | "modelPreference" | "modelPolicy"> & Partial<Pick<RequestExecutionSeed, "shouldGenerateSessionTitle" | "onEvent" | "temporalContext" | "sessionMemory">>;
+export type SupervisorDecisionInputRequest = Pick<RequestExecutionSeed, "requestId" | "prompt" | "historyMessages" | "runnerConfig" | "attachments" | "agentMode" | "modelPreference" | "modelPolicy"> & Partial<Pick<RequestExecutionSeed, "shouldGenerateSessionTitle" | "onEvent" | "temporalContext" | "scheduledExecution" | "sessionMemory">>;
 export declare function buildSupervisorDecisionInput(request: SupervisorDecisionInputRequest, options: Readonly<{
     toolResults: RequestToolResultsView;
     includeAcknowledgement?: boolean;
     includeTitle?: boolean;
+    allowMemoryRecall?: boolean;
+    memoryRecallMessage?: ChatMessage;
     allowedRoleIds?: readonly SupervisorDelegateRoleId[];
     diagnostic?: SupervisorDecisionDiagnosticContext;
     resume?: SupervisorResumeContext;
@@ -23,6 +25,8 @@ export declare function buildSupervisorDecisionInput(request: SupervisorDecision
     modelStep: typeof SUPERVISOR_DECISION_MODEL_STEP;
     includeAcknowledgement: boolean;
     includeTitle: boolean;
+    includeResponseRecommendation: boolean;
+    allowMemoryRecall: boolean;
     allowedRoleIds: readonly SupervisorDelegateRoleId[];
     workerCapabilityAffordances: readonly SupervisorWorkerCapabilityAffordance[];
     availableWorkerCapabilityCatalog: readonly WorkerCapabilityCatalogGroup[];

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

@@ -3,6 +3,7 @@ import { resolveConfiguredStepInstructionMetadata } from "../../config/runner/st
 import { projectRequestContext } from "../../context/request-context.js";
 import { projectRootSessionMemory } from "../../context/session-memory/root-projection.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";
 import { resolveModelContextBudget } from "../../model/model-context-budget.js";
 import { WORKER_CAPABILITY_COUNT_MAX, WORKER_CAPABILITY_SUMMARY_MAX_LENGTH, } from "../../orchestration/worker-capabilities/index.js";
@@ -11,6 +12,8 @@ import { traceSupervisorChildResultProjected, traceSupervisorContextProjected, }
 import { createSupervisorDecisionFormat } from "./format.js";
 import { buildSupervisorDecisionInstructions } from "./prompt.js";
 import { buildSupervisorContinuationPart } from "./resume.js";
+import { buildSupervisorMemoryRecallContinuationParts } from "./memory-recall-continuation.js";
+import { canRecommendDirectSupervisorResponse } from "./response-recommendation.js";
 export function buildSupervisorDecisionInput(request, options) {
     if (options.resume && options.includeTitle === true) {
         throw new Error("supervisor_resume_title_not_allowed");
@@ -24,6 +27,7 @@ export function buildSupervisorDecisionInput(request, options) {
     const includeTitle = options.resume
         ? false
         : (options.includeTitle ?? request.shouldGenerateSessionTitle ?? false);
+    const includeResponseRecommendation = canRecommendDirectSupervisorResponse(options);
     const allowedRoleIds = [
         ...new Set(options.allowedRoleIds ?? SUPERVISOR_DELEGATE_ROLE_IDS),
     ];
@@ -36,8 +40,10 @@ export function buildSupervisorDecisionInput(request, options) {
         ? normalizeWorkerCapabilityAffordances(options.workerCapabilityAffordances)
         : EMPTY_WORKER_CAPABILITY_AFFORDANCES;
     const format = createSupervisorDecisionFormat({
+        allowMemoryRecall: options.allowMemoryRecall === true,
         includeAcknowledgement,
         includeTitle,
+        includeResponseRecommendation,
         allowedRoleIds,
         availableWorkerCapabilityCatalog,
     });
@@ -53,6 +59,7 @@ export function buildSupervisorDecisionInput(request, options) {
             currentInvocationAttempt: requireSupervisorInvocationAttempt(diagnostic),
         })
         : undefined;
+    const roleContinuationParts = roleContinuationPart ? [roleContinuationPart] : [];
     const referenceMessages = [
         ...(request.temporalContext
             ? [buildRequestTemporalContextMessage(request.temporalContext)]
@@ -75,25 +82,35 @@ export function buildSupervisorDecisionInput(request, options) {
         modelStep: SUPERVISOR_DECISION_MODEL_STEP,
     });
     const instructions = buildSupervisorDecisionInstructions({
+        allowMemoryRecall: options.allowMemoryRecall === true,
+        hasMemoryRecallContext: options.memoryRecallMessage !== undefined,
         includeAcknowledgement,
         includeTitle,
+        includeResponseRecommendation,
         allowedRoleIds,
         hasCompletedChildResult: options.resume !== undefined,
         hasRequestToolResults: options.toolResults.results.length > 0,
         workerCapabilityAffordances,
         availableWorkerCapabilityCatalog,
     });
+    const scheduledExecution = projectScheduledExecutionContext(request, instructions, "decision");
+    referenceMessages.unshift(...scheduledExecution.referenceMessages);
     const sessionMemory = projectRootSessionMemory(request);
     const contextInput = {
-        instructions,
+        instructions: scheduledExecution.instructions,
         format,
         ...sessionMemory,
         prompt: request.prompt,
         ...(request.attachments ? { attachments: request.attachments } : {}),
         ...(referenceMessages.length > 0 ? { referenceMessages } : {}),
-        ...(roleContinuationPart
-            ? { continuationParts: [roleContinuationPart] }
-            : {}),
+        continuationParts: options.memoryRecallMessage
+            ? buildSupervisorMemoryRecallContinuationParts({
+                memoryRecallMessage: options.memoryRecallMessage,
+                ...(options.resume ? { resume: options.resume } : {}),
+                currentCallId: requireSupervisorCallId(diagnostic),
+                currentInvocationAttempt: requireSupervisorInvocationAttempt(diagnostic),
+            })
+            : roleContinuationParts,
         budget,
         diagnostic,
         ...(request.onEvent ? { onEvent: request.onEvent } : {}),
@@ -117,12 +134,13 @@ export function buildSupervisorDecisionInput(request, options) {
     });
     traceSupervisorContextProjected({
         diagnostic,
+        allowMemoryRecall: options.allowMemoryRecall === true,
         context,
         format,
         historyMessageCount: sessionMemory.historyMessages.length,
         attachmentCount: request.attachments?.length ?? 0,
         referenceMessageCount: referenceMessages.length,
-        continuationMessageCount: roleContinuationPart?.messages.length ?? 0,
+        continuationMessageCount: contextInput.continuationParts?.reduce((count, part) => count + part.messages.length, 0) ?? 0,
         completedChildResultCount: options.resume?.completedChildren.length ?? 0,
         completedChildSummaryLength: options.resume?.completedChildren.reduce((total, child) => total + child.summary.length, 0) ?? 0,
         allowedRoleIds,
@@ -147,6 +165,8 @@ export function buildSupervisorDecisionInput(request, options) {
         modelStep: SUPERVISOR_DECISION_MODEL_STEP,
         includeAcknowledgement,
         includeTitle,
+        includeResponseRecommendation,
+        allowMemoryRecall: options.allowMemoryRecall === true,
         allowedRoleIds,
         workerCapabilityAffordances,
         availableWorkerCapabilityCatalog,

package/dist/src/runtime/steps/supervisor-decision/memory-recall-continuation.d.ts

@@ -0,0 +1,10 @@
+import type { ChatMessage } from "../../../model-gateway/types.js";
+import type { RequestContextPinnedPart } from "../../context/request-context-contracts.js";
+import type { SupervisorResumeContext } from "./contracts.js";
+/** Place recalls using the child-return position captured when each was accepted. */
+export declare function buildSupervisorMemoryRecallContinuationParts(params: {
+    memoryRecallMessage: ChatMessage;
+    resume?: SupervisorResumeContext;
+    currentCallId: string;
+    currentInvocationAttempt: number;
+}): readonly RequestContextPinnedPart[];

package/dist/src/runtime/steps/supervisor-decision/memory-recall-continuation.js

@@ -0,0 +1,32 @@
+import { projectMemoryRecallContinuations, } from "../../long-term-memory/recall-continuation.js";
+import { buildSupervisorChildContinuationParts } from "./resume.js";
+/** Place recalls using the child-return position captured when each was accepted. */
+export function buildSupervisorMemoryRecallContinuationParts(params) {
+    const recalls = projectMemoryRecallContinuations(params.memoryRecallMessage);
+    const children = params.resume
+        ? buildSupervisorChildContinuationParts({ ...params, resume: params.resume })
+        : [];
+    if (!hasBoundRecallChildPositions(recalls, children.length)) {
+        throw new Error("memory_recall_child_position_invalid");
+    }
+    const parts = [];
+    for (let childIndex = 0; childIndex <= children.length; childIndex++) {
+        for (const recall of recalls) {
+            if (recall.completedChildCount !== childIndex)
+                continue;
+            parts.push(Object.freeze({
+                sourceRef: `memory-recall:${params.currentCallId}:${recall.invocationAttempt}`,
+                category: "role_continuation",
+                retention: "exact",
+                messages: recall.messages,
+            }));
+        }
+        const child = children[childIndex];
+        if (child)
+            parts.push(child);
+    }
+    return Object.freeze(parts);
+}
+function hasBoundRecallChildPositions(recalls, completedChildCount) {
+    return recalls.every((recall) => recall.completedChildCount <= completedChildCount);
+}

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

@@ -3,6 +3,8 @@ import type { WorkerCapabilityCatalogGroup } from "../../orchestration/worker-ca
 export declare function parseSupervisorDecisionOutput(text: string, options?: Readonly<{
     includeAcknowledgement?: boolean;
     includeTitle?: boolean;
+    includeResponseRecommendation?: boolean;
+    allowMemoryRecall?: boolean;
     allowedRoleIds?: readonly SupervisorDelegateRoleId[];
     availableWorkerCapabilityCatalog?: readonly WorkerCapabilityCatalogGroup[];
     diagnostic?: SupervisorDecisionDiagnosticContext;

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

@@ -2,9 +2,12 @@ import { isSupervisorDelegateRoleId, SUPERVISOR_ACKNOWLEDGEMENT_MAX_LENGTH, SUPE
 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";
+import { isMemoryRecallDecisionRecord, parseMemoryRecallDecision, } from "../memory-recall-decision.js";
+import { projectSupervisorResponseRecommendation, supervisorResponseRecommendationKeys, } from "./response-recommendation.js";
 export function parseSupervisorDecisionOutput(text, options = {}) {
     const includeAcknowledgement = options.includeAcknowledgement === true;
     const includeTitle = options.includeTitle === true;
+    const includeResponseRecommendation = options.includeResponseRecommendation === true;
     const allowedRoleIds = [
         ...new Set(options.allowedRoleIds ?? SUPERVISOR_DELEGATE_ROLE_IDS),
     ];
@@ -38,6 +41,30 @@ export function parseSupervisorDecisionOutput(text, options = {}) {
         });
     }
     const issues = [];
+    if (isMemoryRecallDecisionRecord(record)) {
+        const recalled = parseMemoryRecallDecision(record, {
+            allowMemoryRecall: options.allowMemoryRecall,
+            includeAcknowledgement,
+            includeTitle,
+            acknowledgementMaxLength: SUPERVISOR_ACKNOWLEDGEMENT_MAX_LENGTH,
+            titleMaxLength: SUPERVISOR_TITLE_MAX_LENGTH,
+        });
+        if (!diagnostic)
+            return recalled;
+        if (!recalled.ok) {
+            traceSupervisorDecisionRejected({
+                diagnostic,
+                selectedAction: "recall_memory",
+                issues: recalled.issues,
+            });
+            return recalled;
+        }
+        traceSupervisorDecisionAccepted({
+            diagnostic,
+            decision: recalled.decision,
+        });
+        return recalled;
+    }
     let normalizedAcknowledgement;
     let acknowledgementOriginalLength;
     let workerCapabilityScope;
@@ -50,6 +77,7 @@ export function parseSupervisorDecisionOutput(text, options = {}) {
     else if (selectedAction === "respond") {
         exactKeys(record, [
             "action",
+            ...supervisorResponseRecommendationKeys(record, includeResponseRecommendation),
             ...(includeAcknowledgement ? ["acknowledgement"] : []),
             ...(includeTitle ? ["title"] : []),
         ], issues);
@@ -119,6 +147,7 @@ export function parseSupervisorDecisionOutput(text, options = {}) {
         selectedAction,
         includeAcknowledgement,
         includeTitle,
+        includeResponseRecommendation,
         normalizedAcknowledgement,
         workerCapabilityScope,
     });
@@ -146,7 +175,13 @@ function buildAcceptedSupervisorRoutingDecision(params) {
             : {}),
     };
     if (params.selectedAction === "respond") {
-        return { action: "respond", ...presentation };
+        return {
+            action: "respond",
+            ...presentation,
+            ...(params.includeResponseRecommendation
+                ? projectSupervisorResponseRecommendation(params.record.responseRecommendation)
+                : {}),
+        };
     }
     const objective = params.record.objective?.trim();
     if (params.record.roleId === "worker") {

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

@@ -3,6 +3,9 @@ import type { WorkerCapabilityCatalogGroup } from "../../orchestration/worker-ca
 export declare function buildSupervisorDecisionInstructions(params?: Readonly<{
     includeAcknowledgement?: boolean;
     includeTitle?: boolean;
+    includeResponseRecommendation?: boolean;
+    allowMemoryRecall?: boolean;
+    hasMemoryRecallContext?: boolean;
     allowedRoleIds?: readonly SupervisorDelegateRoleId[];
     hasCompletedChildResult?: boolean;
     hasRequestToolResults?: boolean;