@abot-ai/runtime 1.3.1 → 1.5.0

package/dist/src/runtime/steps/execution-agent/work-plan-sources.js

@@ -0,0 +1,54 @@
+import { resolveModelWorkPlanSourceDefinition } from "../../orchestration/role-calls/work-plan-source.js";
+export function resolveExecutionWorkPlanDefinition(head, call, sourceResultRef) {
+    return resolveModelWorkPlanSourceDefinition(head.state, call, sourceResultRef, head.policy);
+}
+export function projectExecutionWorkPlanOptions(head, call) {
+    if (head.policy.authority.modelWorkPlanAuthority !== "root")
+        return undefined;
+    const sources = head.state.results.flatMap((result) => {
+        const definition = resolveExecutionWorkPlanDefinition(head, call, result.resultRef);
+        return definition
+            ? [
+                {
+                    sourceResultRef: result.resultRef,
+                    itemIds: definition.items.map((item) => item.itemId),
+                },
+            ]
+            : [];
+    });
+    const plan = call.adoptedWorkPlan;
+    if (sources.length === 0 && !plan)
+        return undefined;
+    return {
+        sources,
+        ...(plan
+            ? {
+                current: {
+                    sourceResultRef: plan.sourceResultRef,
+                    itemIds: plan.definition.items.map((item) => item.itemId),
+                },
+            }
+            : {}),
+    };
+}
+export function projectExecutionWorkPlanContext(head, call) {
+    const options = projectExecutionWorkPlanOptions(head, call);
+    if (!options)
+        return undefined;
+    const plan = call.adoptedWorkPlan;
+    return {
+        authority: "model_reported_progress_not_completion_evidence",
+        availableProposals: options.sources,
+        ...(plan
+            ? {
+                adopted: {
+                    sourceResultRef: plan.sourceResultRef,
+                    items: plan.itemStates.map((item) => ({
+                        itemId: item.itemId,
+                        status: item.status,
+                    })),
+                },
+            }
+            : {}),
+    };
+}

package/dist/src/runtime/steps/model-step-timeout.d.ts

@@ -1,5 +1,14 @@
+import type { ModelStep } from "../../shared/model-steps.js";
+/** Identifies a deadline owned by one model step, never the request budget. */
+export declare class ModelStepTimeoutError extends Error {
+    readonly code: string;
+    readonly modelStep: ModelStep;
+    readonly stage = "model_step_timeout";
+    constructor(code: string, modelStep: ModelStep);
+}
 export declare function createModelStepAbort(params: {
     parentSignal: AbortSignal;
+    modelStep: ModelStep;
     timeoutMs: number;
     timeoutReason: string;
 }): {

package/dist/src/runtime/steps/model-step-timeout.js

@@ -1,3 +1,15 @@
+/** Identifies a deadline owned by one model step, never the request budget. */
+export class ModelStepTimeoutError extends Error {
+    code;
+    modelStep;
+    stage = "model_step_timeout";
+    constructor(code, modelStep) {
+        super(code);
+        this.code = code;
+        this.modelStep = modelStep;
+        this.name = "ModelStepTimeoutError";
+    }
+}
 export function createModelStepAbort(params) {
     const controller = new AbortController();
     const abortFromParent = () => {
@@ -12,7 +24,7 @@ export function createModelStepAbort(params) {
         });
     }
     const timeout = setTimeout(() => {
-        controller.abort(new Error(params.timeoutReason));
+        controller.abort(new ModelStepTimeoutError(params.timeoutReason, params.modelStep));
     }, params.timeoutMs);
     return {
         signal: controller.signal,

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

@@ -0,0 +1,40 @@
+import type { ChatMessage } from "../../../model-gateway/types.js";
+import { resolveModelContextAdmission } from "../../model/model-context-budget.js";
+import type { ModelStepContextCompactionController } from "../../model/model-step-port.js";
+import type { WorkerCapabilityCatalogGroup } from "../../orchestration/worker-capabilities/index.js";
+import type { RequestWorkerCapabilityProviderSource } from "../../request/execution-scope.js";
+import type { buildPlannerDecisionInput } from "./input.js";
+type BriefRequest = Omit<Parameters<typeof resolveModelContextAdmission>[0], "modelStep"> & RequestWorkerCapabilityProviderSource;
+/** Planner delegation uses the same request-registry facts as Supervisor. */
+export declare function buildPlannerCapabilityBriefOptions(request: BriefRequest, groups: readonly WorkerCapabilityCatalogGroup[]): Readonly<{
+    entries: readonly Readonly<{
+        toolName: string;
+        operationId: string;
+        summary: string;
+        catalogGroups: readonly import("../../../capabilities/tool-types.js").ToolCatalogGroup[];
+        effect: import("../../../capabilities/tool-types.js").ToolExecutionEffect;
+    }>[] | undefined;
+    groups: readonly Readonly<{
+        groupId: import("../../../capabilities/tool-types.js").ToolCatalogGroup;
+        memberCount: number;
+        effects: readonly import("../../orchestration/worker-capabilities/contracts.js").WorkerCapabilityEffect[];
+    }>[];
+    budget: Readonly<{
+        contextWindowTokens: number;
+        outputReserveTokens: number;
+        safetyReserveTokens: number;
+        attachmentReserveTokens: number;
+        configuredInstructionReserveTokens?: number;
+        formatTokenAccounting?: import("../../../model-gateway/types.js").ModelFormatTokenAccountingConfig;
+        tokenEstimation?: import("../../../model-gateway/types.js").ModelTokenEstimationConfig;
+    }>;
+    additionalBudgetMessages: readonly ChatMessage[];
+}>;
+/** Reuses optional-brief admission without inheriting root steering authority. */
+export declare function createPlannerCapabilityBriefReadmissionController(request: BriefRequest & {
+    requestId: string;
+}, options: Readonly<{
+    input: Pick<ReturnType<typeof buildPlannerDecisionInput>, "format" | "availableWorkerCapabilityCatalog">;
+    controller: ModelStepContextCompactionController;
+}>): ModelStepContextCompactionController;
+export {};

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

@@ -0,0 +1,47 @@
+import { createCapabilityBriefReadmissionController } from "../../context/capability-brief-readmission.js";
+import { resolveModelContextAdmission } from "../../model/model-context-budget.js";
+import { traceDebug } from "../../observability/debug-logger.js";
+import { resolveRequestCapabilityBriefEntries } from "../../request/capability-brief.js";
+import { PLANNER_DECISION_MODEL_STEP } from "./contracts.js";
+/** Planner delegation uses the same request-registry facts as Supervisor. */
+export function buildPlannerCapabilityBriefOptions(request, groups) {
+    const admission = resolveModelContextAdmission({
+        runnerConfig: request.runnerConfig,
+        agentMode: request.agentMode,
+        modelStep: PLANNER_DECISION_MODEL_STEP,
+        modelPreference: request.modelPreference,
+        modelPolicy: request.modelPolicy,
+    });
+    const instructions = (admission.invocation.instructions ?? [])
+        .map((instruction) => instruction.trim())
+        .filter((instruction) => instruction.length > 0);
+    const additionalBudgetMessages = instructions.length > 0
+        ? [{ role: "system", content: instructions.join("\n") }]
+        : [];
+    return Object.freeze({
+        entries: resolveRequestCapabilityBriefEntries(request.workerCapabilities, groups),
+        groups,
+        budget: admission.budget,
+        // Root steering is deliberately not inherited by this bounded child.
+        additionalBudgetMessages,
+    });
+}
+/** Reuses optional-brief admission without inheriting root steering authority. */
+export function createPlannerCapabilityBriefReadmissionController(request, options) {
+    return createCapabilityBriefReadmissionController({
+        controller: options.controller,
+        resolveOptions: () => ({
+            ...buildPlannerCapabilityBriefOptions(request, options.input.availableWorkerCapabilityCatalog),
+            format: options.input.format,
+        }),
+        onReadmitted: (brief) => {
+            traceDebug("runtime.planner", "capability_brief.readmitted", {
+                requestId: request.requestId,
+                level: brief.level,
+                estimatedTokens: brief.estimatedTokens,
+                budgetTokens: brief.budgetTokens,
+                reason: brief.reason,
+            });
+        },
+    });
+}

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

@@ -3,7 +3,6 @@ export declare const PLANNER_DECISION_MODEL_STEP: "planner.decision";
 export declare const PLANNER_ROLE_ID: "planner";
 export declare const PLANNER_CHILD_ROLE_IDS: readonly ["worker"];
 export declare const PLANNER_OBJECTIVE_MAX_LENGTH = 8192;
-export declare const PLANNER_RESULT_MAX_LENGTH = 8192;
 export declare const PLANNER_DISPATCH_ITEM_COUNT = 1;
 export declare const PLANNER_DECISION_ACTIONS: readonly ["return_result", "return_failure", "invoke_role"];
 export type PlannerDecisionAction = (typeof PLANNER_DECISION_ACTIONS)[number];

package/dist/src/runtime/steps/planner-decision/contracts.js

@@ -1,10 +1,9 @@
 import { MODEL_STEPS } from "../../../shared/model-steps.js";
-import { normalizeRoleCallWorkingDirectory, ROLE_CALL_OBJECTIVE_MAX_LENGTH, ROLE_CALL_RESULT_MAX_LENGTH, } from "../../orchestration/role-calls/index.js";
+import { normalizeRoleCallWorkingDirectory, ROLE_CALL_OBJECTIVE_MAX_LENGTH, } from "../../orchestration/role-calls/index.js";
 export const PLANNER_DECISION_MODEL_STEP = MODEL_STEPS.PLANNER_DECISION;
 export const PLANNER_ROLE_ID = "planner";
 export const PLANNER_CHILD_ROLE_IDS = Object.freeze(["worker"]);
 export const PLANNER_OBJECTIVE_MAX_LENGTH = ROLE_CALL_OBJECTIVE_MAX_LENGTH;
-export const PLANNER_RESULT_MAX_LENGTH = ROLE_CALL_RESULT_MAX_LENGTH;
 export const PLANNER_DISPATCH_ITEM_COUNT = 1;
 export const PLANNER_DECISION_ACTIONS = Object.freeze([
     "return_result",

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

@@ -2,7 +2,7 @@ import { createStructuredDecisionEnvelopeSchema, structuredDecisionVariantSchema
 import { normalizeRoleCallWorkingDirectory, ROLE_CALL_PLAN_ITEM_TITLE_MAX_LENGTH, ROLE_CALL_WORKING_DIRECTORY_MAX_LENGTH, } from "../../orchestration/role-calls/index.js";
 import { isRuntimeDelegateRoleId, } from "../../orchestration/roles.js";
 import { createWorkerCapabilityScopeDecisionContract } from "../worker-capability-scope-decision.js";
-import { isPlannerChildRoleId, PLANNER_CHILD_ROLE_IDS, PLANNER_DISPATCH_ITEM_COUNT, PLANNER_OBJECTIVE_MAX_LENGTH, PLANNER_RESULT_MAX_LENGTH, } from "./contracts.js";
+import { isPlannerChildRoleId, PLANNER_CHILD_ROLE_IDS, PLANNER_DISPATCH_ITEM_COUNT, PLANNER_OBJECTIVE_MAX_LENGTH, } from "./contracts.js";
 import { normalizePlannerDecisionPlanContext, plannerPlanAllowsInvocation, } from "./plan.js";
 export function createPlannerDecisionFormat(options = {}) {
     const availableChildRoleIds = normalizeAvailableChildRoleIds(options.availableChildRoleIds ?? PLANNER_CHILD_ROLE_IDS);
@@ -42,13 +42,13 @@ export function createPlannerDecisionFormat(options = {}) {
             ? [
                 exactObject({
                     action: literal("return_result"),
-                    result: boundedText(PLANNER_RESULT_MAX_LENGTH),
+                    result: { type: "string", minLength: 1 },
                 }),
             ]
             : []),
         exactObject({
             action: literal("return_failure"),
-            reason: boundedText(PLANNER_RESULT_MAX_LENGTH),
+            reason: { type: "string", minLength: 1 },
         }),
         ...invokeVariantDefinitions.map(({ schema }) => schema),
     ];
@@ -59,18 +59,6 @@ export function createPlannerDecisionFormat(options = {}) {
         name: "planner_decision",
         strict: true,
         postValidatedSchemaConstraints: [
-            ...(!selectingPlan
-                ? [
-                    {
-                        keyword: "maxLength",
-                        path: `${structuredDecisionVariantSchemaPath(0, variants.length)}/properties/result/maxLength`,
-                    },
-                ]
-                : []),
-            {
-                keyword: "maxLength",
-                path: `${structuredDecisionVariantSchemaPath(failureVariantIndex, variants.length)}/properties/reason/maxLength`,
-            },
             ...invokeVariantDefinitions.flatMap(({ worker }, index) => invokeRoleMaxLengthConstraints(planContext, variants.length, invokeVariantStartIndex + index, worker && workingDirectoryRequired)),
         ],
         schema: createStructuredDecisionEnvelopeSchema(variants),

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

@@ -1,12 +1,13 @@
 import type { ModelGatewayJsonSchemaFormat } from "../../../model-gateway/types.js";
+import { type CapabilityBriefProjection } from "../../context/capability-brief.js";
 import type { RequestContextProjection } from "../../context/request-context-contracts.js";
 import { type RequestToolResultsView } from "../../context/request-tool-results.js";
 import { type RoleCallFrame, type RoleCallChildReturnCommit, type RoleCallDependencyResult, type RoleCallLedger, type RoleCallLedgerHead, type RoleChildReturnContext } from "../../orchestration/role-calls/index.js";
 import type { RuntimeDelegateRoleId } from "../../orchestration/roles.js";
+import { type WorkerCapabilityCatalogGroup } from "../../orchestration/worker-capabilities/index.js";
 import { type RequestWorkerCapabilityProviderSource } from "../../request/execution-scope.js";
 import type { RequestExecutionSeed } from "../../request/contracts.js";
 import { PLANNER_DECISION_MODEL_STEP, type PlannerChildRoleId, type PlannerDecisionDiagnosticContext, type PlannerDecisionPlanContext, type PlannerDecisionSelectionKind } from "./contracts.js";
-import { type PlannerWorkerCapabilityCatalogGroup } from "./capability-catalog-context.js";
 export type PlannerDecisionInputRequest = Pick<RequestExecutionSeed, "requestId" | "prompt" | "runnerConfig" | "agentMode" | "modelPreference" | "modelPolicy"> & Partial<Pick<RequestExecutionSeed, "onEvent" | "temporalContext">> & RequestWorkerCapabilityProviderSource;
 export type PlannerDecisionProgressSource = Readonly<{
     kind: "role_child";
@@ -29,7 +30,8 @@ export declare function buildPlannerDecisionInput(request: PlannerDecisionInputR
     allowedActions: readonly PlannerDecisionSelectionKind[];
     availableChildRoleIds: readonly PlannerChildRoleId[];
     dependencyResults: readonly RoleCallDependencyResult[];
-    availableWorkerCapabilityCatalog: readonly PlannerWorkerCapabilityCatalogGroup[];
+    availableWorkerCapabilityCatalog: readonly WorkerCapabilityCatalogGroup[];
+    capabilityBrief: CapabilityBriefProjection;
     inheritedWorkingDirectory?: string;
     planContext?: PlannerDecisionPlanContext;
     childResume?: RoleChildReturnContext;

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

@@ -1,3 +1,4 @@
+import { projectCapabilityBrief, } from "../../context/capability-brief.js";
 import { resolveConfiguredStepInstructionMetadata } from "../../config/runner/step-instructions.js";
 import { projectRequestContext } from "../../context/request-context.js";
 import { buildRequestTemporalContextMessage } from "../../context/request-temporal-context.js";
@@ -5,11 +6,12 @@ import { buildRequestSourceMessage, projectRequestSource, } from "../../context/
 import { buildRequestToolResultsMessage, } from "../../context/request-tool-results.js";
 import { resolveModelContextBudget } from "../../model/model-context-budget.js";
 import { projectRoleCallDependencyResults, projectRoleChildReturnContext, } from "../../orchestration/role-calls/index.js";
+import { projectWorkerCapabilityCatalogGroups, } from "../../orchestration/worker-capabilities/index.js";
 import { resolveRequestWorkerCapabilityCatalog, } from "../../request/execution-scope.js";
 import { PLANNER_DECISION_ACTIONS, PLANNER_DECISION_MODEL_STEP, projectPlannerDecisionCallIdentity, } from "./contracts.js";
 import { tracePlannerChildResultsProjected, tracePlannerContextProjected, } from "./diagnostics.js";
 import { createPlannerDecisionFormat, normalizeAvailableChildRoleIds, } from "./format.js";
-import { buildPlannerReferenceParts, projectPlannerWorkerCapabilityCatalogGroups, } from "./capability-catalog-context.js";
+import { buildPlannerCapabilityBriefOptions } from "./capability-brief.js";
 import { normalizePlannerDecisionPlanContext, plannerPlanAllowsInvocation, } from "./plan.js";
 import { buildPlannerDecisionInstructions } from "./prompt.js";
 import { buildPlannerChildContinuationPart } from "./resume.js";
@@ -24,7 +26,7 @@ export function buildPlannerDecisionInput(request, options) {
         };
     const configuredChildRoleIds = normalizeAvailableChildRoleIds(options.availableChildRoleIds);
     const availableWorkerCapabilityCatalog = configuredChildRoleIds.includes("worker")
-        ? projectPlannerWorkerCapabilityCatalogGroups(resolveRequestWorkerCapabilityCatalog(request).getDescriptors())
+        ? projectWorkerCapabilityCatalogGroups(resolveRequestWorkerCapabilityCatalog(request).getDescriptors())
         : Object.freeze([]);
     const availableChildRoleIds = configuredChildRoleIds;
     const inheritedWorkingDirectory = options.call.workingDirectory;
@@ -75,7 +77,7 @@ export function buildPlannerDecisionInput(request, options) {
         callId: callIdentity.callId,
     });
     const toolResultsProjection = projectPlannerToolResults(options.toolResults);
-    const referenceMessages = Object.freeze([
+    const referenceMessages = [
         ...(request.temporalContext
             ? [buildRequestTemporalContextMessage(request.temporalContext)]
             : []),
@@ -83,13 +85,7 @@ export function buildPlannerDecisionInput(request, options) {
         ...(toolResultsProjection.view.results.length > 0
             ? [buildRequestToolResultsMessage(toolResultsProjection.view)]
             : []),
-    ]);
-    const referenceParts = buildPlannerReferenceParts({
-        callId: callIdentity.callId,
-        invocationAttempt: callIdentity.invocationAttempt,
-        exactMessages: referenceMessages,
-        catalogGroups: availableWorkerCapabilityCatalog,
-    });
+    ];
     const budget = resolveModelContextBudget({
         runnerConfig: request.runnerConfig,
         agentMode: request.agentMode,
@@ -112,7 +108,7 @@ export function buildPlannerDecisionInput(request, options) {
         workerCapabilityCatalogAvailable: availableWorkerCapabilityCatalog.length > 0,
         ...(planContext ? { planContext } : {}),
     });
-    const context = projectRequestContext({
+    const contextInput = {
         instructions,
         format,
         historyMessages: [],
@@ -131,7 +127,7 @@ export function buildPlannerDecisionInput(request, options) {
             ...(planContext ? { planContext } : {}),
             completedChildResultCount: childResume?.completedChildren.length ?? 0,
         }),
-        referenceParts,
+        referenceMessages,
         ...(childContinuationPart
             ? { continuationParts: [childContinuationPart] }
             : {}),
@@ -139,6 +135,19 @@ export function buildPlannerDecisionInput(request, options) {
         diagnostic,
         ...(request.onEvent ? { onEvent: request.onEvent } : {}),
         deferCompactionFailure: true,
+    };
+    const briefOptions = buildPlannerCapabilityBriefOptions(request, availableWorkerCapabilityCatalog);
+    const capabilityBrief = projectCapabilityBrief({
+        groups: availableWorkerCapabilityCatalog,
+        context: contextInput,
+        entries: briefOptions.entries,
+        additionalBudgetMessages: briefOptions.additionalBudgetMessages,
+    });
+    if (capabilityBrief.message)
+        referenceMessages.push(capabilityBrief.message);
+    const context = projectRequestContext({
+        ...contextInput,
+        referenceMessages,
     });
     tracePlannerContextProjected({
         diagnostic,
@@ -150,7 +159,7 @@ export function buildPlannerDecisionInput(request, options) {
         availableChildRoleIds,
         workerCapabilityCatalogGroupIds: availableWorkerCapabilityCatalog.map((group) => group.groupId),
         workerCapabilityCatalogMemberCount: availableWorkerCapabilityCatalog.reduce((total, group) => total + group.memberCount, 0),
-        referenceMessageCount: referenceParts.reduce((total, part) => total + part.messages.length, 0),
+        referenceMessageCount: referenceMessages.length,
         continuationMessageCount: childContinuationPart?.messages.length ?? 0,
         completedChildResultCount: childResume?.completedChildren.length ?? 0,
         completedChildSummaryLength: childResume?.completedChildren.reduce((total, child) => total + child.summary.length, 0) ?? 0,
@@ -184,6 +193,7 @@ export function buildPlannerDecisionInput(request, options) {
         availableChildRoleIds,
         dependencyResults,
         availableWorkerCapabilityCatalog,
+        capabilityBrief,
         ...(inheritedWorkingDirectory !== undefined
             ? { inheritedWorkingDirectory }
             : {}),

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

@@ -1,6 +1,6 @@
-import { normalizeRoleCallWorkingDirectory, } from "../../orchestration/role-calls/index.js";
+import { isRoleCallResultText, normalizeRoleCallWorkingDirectory, } from "../../orchestration/role-calls/index.js";
 import { createWorkerCapabilityScopeDecisionContract, parseWorkerCapabilityScopeDecision, } from "../worker-capability-scope-decision.js";
-import { PLANNER_DECISION_ACTIONS, PLANNER_OBJECTIVE_MAX_LENGTH, PLANNER_RESULT_MAX_LENGTH, } from "./contracts.js";
+import { PLANNER_DECISION_ACTIONS, PLANNER_OBJECTIVE_MAX_LENGTH, } from "./contracts.js";
 import { tracePlannerDecisionAccepted, tracePlannerDecisionRejected, tracePlannerEnvelopeAccepted, tracePlannerEnvelopeRejected, } from "./diagnostics.js";
 import { normalizeAvailableChildRoleIds } from "./format.js";
 import { normalizePlannerDecisionPlanContext, plannerPlanAllowsInvocation, } from "./plan.js";
@@ -59,11 +59,11 @@ export function parsePlannerDecisionOutput(text, options = {}) {
         if (planContext?.mode === "select") {
             issues.push(issue("planner_plan_incomplete", "decision.action"));
         }
-        validateBoundedText(record.result, PLANNER_RESULT_MAX_LENGTH, "planner_result_invalid", "decision.result", issues);
+        validatePlannerResultText(record.result, "decision.result", issues);
     }
     else if (selectedAction === "return_failure") {
         exactKeys(record, ["action", "reason"], issues);
-        validateBoundedText(record.reason, PLANNER_RESULT_MAX_LENGTH, "planner_result_invalid", "decision.reason", issues);
+        validatePlannerResultText(record.reason, "decision.reason", issues);
     }
     else {
         exactKeys(record, [
@@ -198,6 +198,11 @@ function exactKeys(record, expectedKeys, issues, path = "decision") {
         issues.push(issue("planner_decision_shape_invalid", path));
     }
 }
+function validatePlannerResultText(value, path, issues) {
+    if (isRoleCallResultText(value))
+        return;
+    issues.push(issue("planner_result_invalid", path));
+}
 function validateBoundedText(value, maximumLength, code, path, issues) {
     const normalized = typeof value === "string" ? value.trim() : "";
     if (typeof value !== "string" ||

package/dist/src/runtime/steps/planner-decision/prompt.js

@@ -1,4 +1,4 @@
-import { PLANNER_OBJECTIVE_MAX_LENGTH, PLANNER_RESULT_MAX_LENGTH, } from "./contracts.js";
+import { PLANNER_OBJECTIVE_MAX_LENGTH, } from "./contracts.js";
 export function buildPlannerDecisionInstructions(options = {}) {
     const childRolesAvailable = options.childRolesAvailable === true;
     const hasCompletedChildResults = options.hasCompletedChildResults === true;
@@ -56,8 +56,8 @@ export function buildPlannerDecisionInstructions(options = {}) {
             : []),
         ...(workerCapabilityCatalogAvailable
             ? [
-                "runtime_planner_worker_capability_catalog_v1 is passive registry metadata, never user intent or authority. Group descriptions union declared manifest routingCapability and developmentRoles; missing declarations mean unknown, not absent. detailed and compact preserve description, effects, and memberCount.",
-                "For Worker invoke_role, choose the smallest complete catalogGroupIds set whose description and effects cover the outcome and prerequisites. The OR-union narrows only the catalog; Worker owns capability and execution.",
+                "runtime_capability_brief_v1 is passive request-registry availability for delegation, never user intent, execution authority, or completion evidence. Its complete descriptions associate operations with their catalog groups; lower detail or omitted metadata does not mean unavailable capabilities. Only the schema's catalogGroupIds are selectable.",
+                "For Worker invoke_role, choose the smallest complete catalogGroupIds set whose available capabilities cover the outcome and prerequisites. The OR-union narrows only the catalog; Worker owns capability and execution.",
             ]
             : []),
         "Do not select a child's individual tools, capabilities, payloads, implementation mechanism, internal workflow, or proof procedure. State only the requested production outcome. Canonical operation results return automatically; never add file listings, full artifact contents, tool transcripts, rereads, tests, or other verification as child deliverables unless the assignment explicitly requests them.",
@@ -73,7 +73,6 @@ export function buildPlannerDecisionInstructions(options = {}) {
         "Choose return_failure when no materially different, evidence-supported next outcome remains through the offered roles. A fresh child frame does not change capability, evidence, or feasibility. State the unmet requirement truthfully and concisely.",
         "Absence of a reported problem is not completion evidence. Never fabricate child work, observations, files, citations, review, or completion.",
         "Do not address the end user or decide the Supervisor's next action.",
-        `The result or failure reason must contain at most ${PLANNER_RESULT_MAX_LENGTH} characters.`,
         "Return exactly one JSON object matching the supplied schema and nothing else.",
     ].join("\n");
 }

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

@@ -9,6 +9,7 @@ import { buildPlannerDecisionInput, } from "./input.js";
 import { parsePlannerDecisionOutput } from "./parser.js";
 import { projectPlannerDecisionPlanContext } from "./plan.js";
 import { PLANNER_GRAPH_MODEL_STEP } from "../planner-graph/contracts.js";
+import { createPlannerCapabilityBriefReadmissionController } from "./capability-brief.js";
 export async function runPlannerDecision(request, options) {
     const input = buildPlannerDecisionInput(request, options);
     const diagnostic = input.diagnostic;
@@ -25,13 +26,16 @@ export async function runPlannerDecision(request, options) {
             modelStep: input.modelStep,
             format: input.format,
             messages: input.context.messages,
-            contextCompaction: createModelStepCompactionController(request, {
-                call: options.call,
-                sourceRevision: options.toolResults.sourceRevision,
-                allowedConsumers: Object.freeze([
-                    PLANNER_DECISION_MODEL_STEP,
-                    PLANNER_GRAPH_MODEL_STEP,
-                ]),
+            contextCompaction: createPlannerCapabilityBriefReadmissionController(request, {
+                input,
+                controller: createModelStepCompactionController(request, {
+                    call: options.call,
+                    sourceRevision: options.toolResults.sourceRevision,
+                    allowedConsumers: Object.freeze([
+                        PLANNER_DECISION_MODEL_STEP,
+                        PLANNER_GRAPH_MODEL_STEP,
+                    ]),
+                }),
             }),
             timeoutReason: "planner_decision_timeout",
             invalidOutputReason: "invalid_planner_decision",

package/dist/src/runtime/steps/planner-graph/parser.js

@@ -145,28 +145,17 @@ function validateTopology(nodes, issues) {
         return;
     const remaining = new Set(ids);
     const completed = new Set();
-    let hasParallelFrontier = false;
     while (remaining.size > 0) {
         const frontier = nodes.filter(({ localId, dependsOn }) => remaining.has(localId) && dependsOn.every((id) => completed.has(id)));
         if (frontier.length === 0) {
             issues.push(issue("cyclic_plan_graph", "decision.nodes", "The proposed graph must be acyclic."));
             return;
         }
-        if (frontier.length >= 2)
-            hasParallelFrontier = true;
         for (const node of frontier) {
             remaining.delete(node.localId);
             completed.add(node.localId);
         }
     }
-    const dependedOn = new Set(nodes.flatMap(({ dependsOn }) => dependsOn));
-    const terminalCount = nodes.filter(({ localId }) => !dependedOn.has(localId)).length;
-    if (terminalCount < 2) {
-        issues.push(issue("insufficient_terminal_deliverables", "decision.nodes", "The graph must contain at least two independently accepted terminal deliverables."));
-    }
-    if (!hasParallelFrontier) {
-        issues.push(issue("no_parallel_frontier", "decision.nodes", "The graph must expose at least one frontier with two ready nodes."));
-    }
 }
 function exactKeys(value, expected, path, issues) {
     const expectedSet = new Set(expected);

package/dist/src/runtime/steps/planner-graph/prompt.js

@@ -3,7 +3,8 @@ export function buildPlannerGraphInstructions() {
         "You are a bounded advisory Planner for one already accepted execution objective.",
         "Return exactly one JSON decision matching the supplied schema and nothing else.",
         "Propose a dependency graph only. You cannot execute capabilities, invoke roles, answer the user, review work, or claim that work occurred.",
-        'If the objective cannot honestly produce both at least two independently accepted terminal deliverables and a real parallel frontier, return the strict {"action":"decline","reason":"..."} variant. Decline is an advisory outcome, not an error.',
+        "Propose a plan when the accepted objective benefits from multiple substantial implementation or verification steps, dependency ordering, or integration. A single integrated deliverable and sequential work are valid; do not invent parallelism or extra terminal deliverables.",
+        'For a direct question or simple isolated change that needs no meaningful decomposition, return the strict {"action":"decline","reason":"..."} variant. Decline is an advisory outcome, not an error.',
         "Use dependsOn only for actual data, ordering, or integration dependencies.",
         "Every node must describe an outcome the Execution Agent can establish and contain explicit acceptance criteria. Mark a criterion mechanical only when runtime evidence can decide it; otherwise mark it semantic.",
         "The proposal is passive advice. The Execution Agent decides what to do next, and no work is complete merely because a graph was proposed.",

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

@@ -0,0 +1,10 @@
+import type { ModelStepContextCompactionController } from "../../model/model-step-port.js";
+import type { RequestExecutionScope } from "../../request/execution-scope.js";
+import type { buildSupervisorDecisionInput } from "./input.js";
+type BriefRoutingInput = Pick<ReturnType<typeof buildSupervisorDecisionInput>, "format" | "allowedRoleIds" | "availableWorkerCapabilityCatalog">;
+/** Optional routing metadata yields capacity to actual repair and steering. */
+export declare function createSupervisorCapabilityBriefReadmissionController(request: RequestExecutionScope, options: Readonly<{
+    input: BriefRoutingInput;
+    controller: ModelStepContextCompactionController;
+}>): ModelStepContextCompactionController;
+export {};

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

@@ -0,0 +1,39 @@
+import { createCapabilityBriefReadmissionController } from "../../context/capability-brief-readmission.js";
+import { resolveModelContextAdmission } from "../../model/model-context-budget.js";
+import { traceDebug } from "../../observability/debug-logger.js";
+import { buildSupervisorCapabilityBriefOptions } from "./capability-brief.js";
+import { SUPERVISOR_DECISION_MODEL_STEP } from "./contracts.js";
+/** Optional routing metadata yields capacity to actual repair and steering. */
+export function createSupervisorCapabilityBriefReadmissionController(request, options) {
+    const { input, controller } = options;
+    return createCapabilityBriefReadmissionController({
+        controller,
+        resolveOptions() {
+            const admission = resolveModelContextAdmission({
+                runnerConfig: request.runnerConfig,
+                agentMode: request.agentMode,
+                modelStep: SUPERVISOR_DECISION_MODEL_STEP,
+                modelPreference: request.modelPreference,
+                modelPolicy: request.modelPolicy,
+                requestFormat: input.format,
+            });
+            const briefOptions = buildSupervisorCapabilityBriefOptions(request, input);
+            return {
+                entries: briefOptions.capabilityBriefEntries,
+                groups: input.availableWorkerCapabilityCatalog,
+                budget: admission.budget,
+                format: input.format,
+                additionalBudgetMessages: briefOptions.capabilityBriefBudgetMessages,
+            };
+        },
+        onReadmitted(replacement) {
+            traceDebug("runtime.supervisor", "capability_brief.readmitted", {
+                requestId: request.requestId,
+                level: replacement.level,
+                estimatedTokens: replacement.estimatedTokens,
+                budgetTokens: replacement.budgetTokens,
+                reason: replacement.reason,
+            });
+        },
+    });
+}

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

@@ -5,7 +5,7 @@ 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" | "scheduledExecution" | "sessionMemory">>;
+export type SupervisorDecisionInputRequest = Pick<RequestExecutionSeed, "requestId" | "prompt" | "historyMessages" | "runnerConfig" | "attachments" | "agentMode" | "modelPreference" | "modelPolicy"> & Partial<Pick<RequestExecutionSeed, "shouldGenerateSessionTitle" | "onEvent" | "temporalContext" | "scheduledExecution" | "sessionMemory" | "longTermMemory">>;
 export declare function buildSupervisorDecisionInput(request: SupervisorDecisionInputRequest, options: Readonly<{
     toolResults: RequestToolResultsView;
     includeAcknowledgement?: boolean;

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

@@ -2,6 +2,7 @@ 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";
@@ -81,18 +82,21 @@ export function buildSupervisorDecisionInput(request, options) {
         runnerConfig: request.runnerConfig,
         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 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,
+        }),
+        ...buildConversationMemoryAvailabilityInstructions(request.longTermMemory?.enabled === true),
+    ].join("\n");
     const scheduledExecution = projectScheduledExecutionContext(request, instructions, "decision");
     referenceMessages.unshift(...scheduledExecution.referenceMessages);
     const sessionMemory = projectRootSessionMemory(request);