@abot-ai/runtime 1.1.0 → 1.3.0

package/dist/src/runtime/steps/reviewer-decision/verification-coverage.js

@@ -0,0 +1,52 @@
+/**
+ * Multi-target mutations need an independent post-mutation observation or a
+ * canonical satisfied fact before Reviewer may pass them as one integrated
+ * result. This is only a pass-eligibility check; it never proves semantics.
+ */
+export function projectReviewerVerificationCoverage(snapshot) {
+    const latestMutationByTarget = new Map();
+    snapshot.evidence.forEach((evidence, index) => {
+        if (evidence.outcome !== "succeeded" || evidence.effect !== "mutation") {
+            return;
+        }
+        for (const target of evidenceTargets(evidence)) {
+            latestMutationByTarget.set(target, {
+                evidenceRef: evidence.evidenceRef,
+                index,
+            });
+        }
+    });
+    const required = latestMutationByTarget.size > 1;
+    if (!required) {
+        return Object.freeze({
+            required: false,
+            complete: true,
+            mutationTargetCount: latestMutationByTarget.size,
+            verifiedTargets: Object.freeze([]),
+            missingTargets: Object.freeze([]),
+        });
+    }
+    const satisfiedEvidenceRefs = new Set(snapshot.facts.flatMap((fact) => fact.status === "satisfied" ? fact.evidenceRefs : []));
+    const verifiedTargets = [];
+    const missingTargets = [];
+    for (const [target, mutation] of latestMutationByTarget) {
+        const hasSatisfiedFact = satisfiedEvidenceRefs.has(mutation.evidenceRef);
+        const hasLaterObservation = snapshot.evidence.some((evidence, index) => index > mutation.index &&
+            evidence.outcome === "succeeded" &&
+            evidence.effect === "observation" &&
+            evidenceTargets(evidence).includes(target));
+        (hasSatisfiedFact || hasLaterObservation
+            ? verifiedTargets
+            : missingTargets).push(target);
+    }
+    return Object.freeze({
+        required: true,
+        complete: missingTargets.length === 0,
+        mutationTargetCount: latestMutationByTarget.size,
+        verifiedTargets: Object.freeze(verifiedTargets),
+        missingTargets: Object.freeze(missingTargets),
+    });
+}
+function evidenceTargets(evidence) {
+    return [...new Set((evidence.references ?? []).map(({ target }) => target))];
+}

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

@@ -0,0 +1,14 @@
+import type { ChatMessage } from "../../../model-gateway/types.js";
+import type { ToolAvailabilityEntry } from "../../../capabilities/tool-types.js";
+import type { RequestExecutionScope } from "../../request/execution-scope.js";
+import type { WorkerCapabilityCatalogGroup } from "../../orchestration/worker-capabilities/index.js";
+type BriefOptions = Readonly<{
+    allowedRoleIds?: readonly string[];
+    availableWorkerCapabilityCatalog?: readonly WorkerCapabilityCatalogGroup[];
+}>;
+/** Only routing opts in; neither the Worker nor later authoring is changed. */
+export declare function buildSupervisorCapabilityBriefOptions(request: RequestExecutionScope, options: BriefOptions): Readonly<{
+    capabilityBriefEntries?: readonly ToolAvailabilityEntry[];
+    capabilityBriefBudgetMessages?: readonly ChatMessage[];
+}>;
+export {};

package/dist/src/runtime/steps/supervisor-decision/capability-brief.js

@@ -0,0 +1,38 @@
+import { resolveModelContextAdmission } from "../../model/model-context-budget.js";
+import { resolveRequestCapabilityBriefEntries } from "../../request/capability-brief.js";
+import { appendRequestSteeringContext } from "../../request/request-steering-context.js";
+import { resolveRequestSteeringInbox } from "../../request/request-steering.js";
+import { SUPERVISOR_DECISION_MODEL_STEP, SUPERVISOR_DELEGATE_ROLE_IDS, } from "./contracts.js";
+/** Only routing opts in; neither the Worker nor later authoring is changed. */
+export function buildSupervisorCapabilityBriefOptions(request, options) {
+    if (!canProjectSupervisorCapabilityBrief(options))
+        return {};
+    const entries = resolveRequestCapabilityBriefEntries(request.capabilities, options.availableWorkerCapabilityCatalog ?? []);
+    const admission = resolveModelContextAdmission({
+        runnerConfig: request.runnerConfig,
+        agentMode: request.agentMode,
+        modelStep: SUPERVISOR_DECISION_MODEL_STEP,
+        ...(request.modelPreference
+            ? { modelPreference: request.modelPreference }
+            : {}),
+        ...(request.modelPolicy ? { modelPolicy: request.modelPolicy } : {}),
+    });
+    const instructions = (admission.invocation.instructions ?? [])
+        .map((instruction) => instruction.trim())
+        .filter((instruction) => instruction.length > 0);
+    const calibration = [];
+    if (instructions.length > 0) {
+        calibration.push({ role: "system", content: instructions.join("\n") });
+    }
+    const capabilityBriefBudgetMessages = appendRequestSteeringContext(calibration, resolveRequestSteeringInbox(request.requestSteering).snapshot());
+    return Object.freeze({
+        ...(entries === undefined ? {} : { capabilityBriefEntries: entries }),
+        capabilityBriefBudgetMessages,
+    });
+}
+function canProjectSupervisorCapabilityBrief(options) {
+    const roles = options.allowedRoleIds ?? SUPERVISOR_DELEGATE_ROLE_IDS;
+    if (!roles.includes("worker"))
+        return false;
+    return (options.availableWorkerCapabilityCatalog?.length ?? 0) > 0;
+}

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,16 +16,19 @@ export type SupervisorWorkerCapabilityAffordance = Readonly<{
 }>;
 export type SupervisorRespondDecision = Readonly<{
     action: "respond";
+    responseRecommendation?: string;
     acknowledgement?: string;
     title?: string;
 }>;
 export type SupervisorDecisionPhase = (typeof SUPERVISOR_DECISION_PHASES)[number];
-type SupervisorInvokeRoleDecisionBase = Readonly<{
+type SupervisorInvokeRoleDecisionMetadata = Readonly<{
     action: "invoke_role";
-    objective: string;
     acknowledgement?: string;
     title?: string;
 }>;
+type SupervisorInvokeRoleDecisionBase = Readonly<SupervisorInvokeRoleDecisionMetadata & {
+    objective: string;
+}>;
 export type SupervisorInvokeRoleDecision = Readonly<SupervisorInvokeRoleDecisionBase & {
     roleId: "worker";
     workingDirectory: string;
@@ -35,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;
@@ -46,9 +50,11 @@ export type SupervisorRoutingInvokeRoleDecision = Readonly<SupervisorInvokeRoleD
 }> | Readonly<SupervisorInvokeRoleDecisionBase & {
     roleId: "planner";
 }> | Readonly<SupervisorInvokeRoleDecisionBase & {
-    roleId: Exclude<SupervisorDelegateRoleId, "planner" | "worker">;
+    roleId: Exclude<SupervisorDelegateRoleId, "planner" | "reviewer" | "worker">;
+}> | 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

@@ -1,5 +1,6 @@
 import type { ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.js";
 import type { RequestContextProjection } from "../../context/request-context-contracts.js";
+import type { CapabilityBriefProjection } from "../../context/capability-brief.js";
 import type { RoleChildReturnContext } from "../../orchestration/role-calls/index.js";
 import type { WorkerCapabilityCatalogGroup } from "../../orchestration/worker-capabilities/index.js";
 import { type SupervisorDecision, type SupervisorDecisionDiagnosticContext, type SupervisorDecisionValidationIssue, type SupervisorDelegateRoleId, type SupervisorRoutingDecision, type SupervisorWorkingDirectoryRoutingDecision, type SupervisorWorkerCapabilityAffordance } from "./contracts.js";
@@ -14,8 +15,10 @@ export declare function traceSupervisorContextProjected(params: {
     completedChildResultCount: number;
     completedChildSummaryLength: number;
     allowedRoleIds: readonly SupervisorDelegateRoleId[];
+    allowMemoryRecall: boolean;
     workerCapabilityAffordances: readonly SupervisorWorkerCapabilityAffordance[];
     availableWorkerCapabilityCatalog: readonly WorkerCapabilityCatalogGroup[];
+    capabilityBrief: CapabilityBriefProjection;
     configuredInstructionBlockCount: number;
     configuredInstructionCharacterCount: number;
     configuredInstructionRefs: readonly string[];
@@ -58,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) {
@@ -22,7 +23,11 @@ export function traceSupervisorContextProjected(params) {
         plannedWorkContextIncluded: false,
         capabilityContextIncluded: false,
         delegationContextPolicy: "explicit_role_context_exact_dependency_v1",
-        workerCapabilityCatalogContextIncluded: params.availableWorkerCapabilityCatalog.length > 0,
+        workerCapabilityCatalogContextIncluded: params.capabilityBrief.level !== "none",
+        capabilityBriefLevel: params.capabilityBrief.level,
+        capabilityBriefEstimatedTokens: params.capabilityBrief.estimatedTokens,
+        capabilityBriefBudgetTokens: params.capabilityBrief.budgetTokens,
+        capabilityBriefReason: params.capabilityBrief.reason,
         availableWorkerCapabilityCatalogGroupCount: params.availableWorkerCapabilityCatalog.length,
         availableWorkerCapabilityCatalogGroupIds: params.availableWorkerCapabilityCatalog.map((group) => group.groupId),
         availableWorkerCapabilityCatalogMemberCount: params.availableWorkerCapabilityCatalog.reduce((total, group) => total + group.memberCount, 0),
@@ -37,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],
     });
 }
@@ -95,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 }
@@ -105,7 +109,9 @@ export function traceSupervisorDecisionAccepted(params) {
         ...(params.decision.action === "invoke_role"
             ? {
                 selectedRoleId: params.decision.roleId,
-                objectiveLength: params.decision.objective.length,
+                ...("objective" in params.decision
+                    ? { objectiveLength: params.decision.objective.length }
+                    : { objectiveLength: 0 }),
                 ...(params.decision.roleId === "worker" &&
                     params.decision.workerCapabilityScope
                     ? {
@@ -142,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),
@@ -275,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,31 +1,53 @@
+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");
-    const availableNonWorkerRoleIds = allowedRoleIds.filter((roleId) => roleId !== "worker");
-    const invokeVariants = workerAvailable && workerCapabilityScopeContract.required
-        ? [
-            invokeRoleSchema(includeAcknowledgement, includeTitle, ["worker"], workerCapabilityScopeContract.schema),
-            ...(availableNonWorkerRoleIds.length > 0
-                ? [
-                    invokeRoleSchema(includeAcknowledgement, includeTitle, availableNonWorkerRoleIds),
-                ]
-                : []),
-        ]
-        : allowedRoleIds.length > 0
+    const reviewerAvailable = allowedRoleIds.includes("reviewer");
+    const objectiveRoleIds = allowedRoleIds.filter((roleId) => roleId !== "reviewer");
+    const scopedWorkerRequired = workerAvailable && workerCapabilityScopeContract.required;
+    const unscopedObjectiveRoleIds = objectiveRoleIds.filter((roleId) => roleId !== "worker" || !scopedWorkerRequired);
+    const objectiveInvokeVariants = [
+        ...(scopedWorkerRequired
+            ? [
+                invokeRoleSchema(includeAcknowledgement, includeTitle, ["worker"], workerCapabilityScopeContract.schema),
+            ]
+            : []),
+        ...(unscopedObjectiveRoleIds.length > 0
             ? [
-                invokeRoleSchema(includeAcknowledgement, includeTitle, allowedRoleIds),
+                invokeRoleSchema(includeAcknowledgement, includeTitle, unscopedObjectiveRoleIds),
             ]
-            : [];
+            : []),
+    ];
+    const invokeVariants = [
+        ...objectiveInvokeVariants,
+        ...(reviewerAvailable
+            ? [
+                invokeRoleSchema(includeAcknowledgement, includeTitle, ["reviewer"], undefined, false),
+            ]
+            : []),
+    ];
     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",
@@ -34,15 +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),
@@ -53,18 +83,21 @@ function respondSchema(includeAcknowledgement, includeTitle) {
             : {}),
     }, [
         "action",
+        ...(includeResponseRecommendation ? ["responseRecommendation"] : []),
         ...(includeAcknowledgement ? ["acknowledgement"] : []),
         ...(includeTitle ? ["title"] : []),
     ]);
 }
-function invokeRoleSchema(includeAcknowledgement, includeTitle, allowedRoleIds, workerCapabilityScopeSchema) {
+function invokeRoleSchema(includeAcknowledgement, includeTitle, allowedRoleIds, workerCapabilityScopeSchema, includeObjective = true) {
     return exactObject({
         action: literal("invoke_role"),
         roleId: {
             type: "string",
             enum: [...allowedRoleIds],
         },
-        objective: boundedText(SUPERVISOR_OBJECTIVE_MAX_LENGTH),
+        ...(includeObjective
+            ? { objective: boundedText(SUPERVISOR_OBJECTIVE_MAX_LENGTH) }
+            : {}),
         ...(workerCapabilityScopeSchema
             ? { workerCapabilityScope: workerCapabilityScopeSchema }
             : {}),
@@ -79,7 +112,7 @@ function invokeRoleSchema(includeAcknowledgement, includeTitle, allowedRoleIds,
     }, [
         "action",
         "roleId",
-        "objective",
+        ...(includeObjective ? ["objective"] : []),
         ...(workerCapabilityScopeSchema ? ["workerCapabilityScope"] : []),
         ...(includeAcknowledgement ? ["acknowledgement"] : []),
         ...(includeTitle ? ["title"] : []),
@@ -88,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
             ? [
                 {
@@ -104,11 +155,11 @@ function createPostValidatedConstraints(params) {
                 },
             ]
             : []),
+        ...Array.from({ length: params.objectiveInvokeVariantCount }, (_, index) => index + 1).map((index) => ({
+            keyword: "maxLength",
+            path: `${base(index)}/properties/objective/maxLength`,
+        })),
         ...Array.from({ length: params.invokeVariantCount }, (_, index) => index + 1).flatMap((index) => [
-            {
-                keyword: "maxLength",
-                path: `${base(index)}/properties/objective/maxLength`,
-            },
             ...(params.includeAcknowledgement
                 ? [
                     {

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

@@ -1,25 +1,32 @@
-import type { ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.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";
 import { type RequestToolResultsView } from "../../context/request-tool-results.js";
 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;
     workerCapabilityAffordances?: readonly SupervisorWorkerCapabilityAffordance[];
     availableWorkerCapabilityCatalog?: readonly WorkerCapabilityCatalogGroup[];
+    capabilityBriefEntries?: readonly ToolAvailabilityEntry[];
+    capabilityBriefBudgetMessages?: readonly ChatMessage[];
 }>): {
     context: RequestContextProjection;
     format: ModelGatewayJsonSchemaFormat;
     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

@@ -1,7 +1,9 @@
+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 { 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";
@@ -10,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");
@@ -23,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),
     ];
@@ -35,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,
     });
@@ -52,6 +59,7 @@ export function buildSupervisorDecisionInput(request, options) {
             currentInvocationAttempt: requireSupervisorInvocationAttempt(diagnostic),
         })
         : undefined;
+    const roleContinuationParts = roleContinuationPart ? [roleContinuationPart] : [];
     const referenceMessages = [
         ...(request.temporalContext
             ? [buildRequestTemporalContextMessage(request.temporalContext)]
@@ -74,43 +82,71 @@ 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 context = projectRequestContext({
-        instructions,
+    const contextInput = {
+        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 } : {}),
         deferCompactionFailure: true,
+    };
+    const capabilityBrief = projectCapabilityBrief({
+        groups: availableWorkerCapabilityCatalog,
+        context: contextInput,
+        ...(options.capabilityBriefEntries === undefined
+            ? {}
+            : { entries: options.capabilityBriefEntries }),
+        ...(options.capabilityBriefBudgetMessages === undefined
+            ? {}
+            : { additionalBudgetMessages: options.capabilityBriefBudgetMessages }),
+    });
+    if (capabilityBrief.message)
+        referenceMessages.push(capabilityBrief.message);
+    const context = projectRequestContext({
+        ...contextInput,
+        ...(referenceMessages.length > 0 ? { referenceMessages } : {}),
     });
     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,
         workerCapabilityAffordances,
         availableWorkerCapabilityCatalog,
+        capabilityBrief,
         configuredInstructionBlockCount: configuredInstructionMetadata.blockCount,
         configuredInstructionCharacterCount: configuredInstructionMetadata.characterCount,
         configuredInstructionRefs: configuredInstructionMetadata.refs,
@@ -129,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;