@abot-ai/runtime 1.0.0 → 1.2.0

package/dist/src/runtime/request/contracts.d.ts

@@ -12,6 +12,7 @@ import type { RequestSessionStore } from "./session-store.js";
 import type { RequestSteeringInbox } from "./request-steering.js";
 import type { RequestModelStepPort } from "../model/model-step-port.js";
 import type { RequestSessionMemory, SessionMemoryCompactor } from "../context/session-memory/index.js";
+import type { LongTermMemoryService } from "../long-term-memory/contracts.js";
 export type RunRequestMessage = {
     type: string;
     requestId: string;
@@ -33,6 +34,7 @@ export type RequestHandlerOptions = {
     toolApprovalController?: ToolApprovalController;
     requestSteering?: RequestSteeringInbox;
     sessionMemoryCompactor?: SessionMemoryCompactor;
+    longTermMemory?: LongTermMemoryService;
 };
 /** Exact provider-free seed used to construct one request execution scope. */
 export type RequestExecutionSeed = Readonly<{
@@ -53,6 +55,7 @@ export type RequestExecutionSeed = Readonly<{
     modelGatewayClient: Pick<ModelGatewayClient, "invoke" | "invokeRaw" | "countInputTokens">;
     contextCompactionStore?: RequestContextCompactionStore;
     sessionMemory?: RequestSessionMemory;
+    longTermMemory?: LongTermMemoryService;
     requestSteering?: RequestSteeringInbox;
     toolPermissionMode: ToolPermissionMode;
     toolApprovalController?: ToolApprovalController;
@@ -91,6 +94,10 @@ export type RequestModelRuntime = Readonly<{
     modelPolicy?: RequestExecutionSeed["modelPolicy"];
     modelGatewayClient: RequestExecutionSeed["modelGatewayClient"];
 }>;
+/** Core-owned passive memory service; never part of capability execution. */
+export type RequestMemoryRuntime = Readonly<{
+    longTermMemory?: RequestExecutionSeed["longTermMemory"];
+}>;
 /** Request-local cancellation, steering, capability controls, and events. */
 export type RequestLifecycleRuntime = Readonly<{
     requestSteering?: RequestExecutionSeed["requestSteering"];

package/dist/src/runtime/request/dependencies.d.ts

@@ -12,6 +12,7 @@ export declare function resolveRequestDependencies(options: RequestHandlerOption
             turns: readonly import("../../sessions/memory/source.js").SessionMemorySettledTurn[];
         }): Promise<string>;
     }>;
+    longTermMemory: import("../index.js").LongTermMemoryService;
     toolApprovalController: import("../ports.js").ToolApprovalController | undefined;
     loadDecisionEnvironment: () => {
         runnerConfig: import("../config/runner/contracts.js").RequestRunnerConfig;

package/dist/src/runtime/request/dependencies.js

@@ -1,16 +1,24 @@
-import { invokeModelGateway, invokeRawModelGateway, } from "../../model-gateway/client.js";
+import { invokeModelGateway, invokeRawModelGateway, embedModelGateway, } from "../../model-gateway/client.js";
 import { defaultRuntimeSessionStore } from "../adapters/default-session-adapters.js";
 import { createRuntimeEventBus } from "../events/runtime-emitter.js";
 import { loadRequestRunnerConfig } from "../config/runner/loader.js";
 import { createRequestModelPolicy } from "../config/runner/model-policy.js";
 import { createModelSessionMemoryCompactor } from "../context/session-memory/index.js";
+import { createInMemoryLongTermMemoryRepository } from "../adapters/long-term-memory/in-memory-repository.js";
+import { createLongTermMemoryService } from "../long-term-memory/service.js";
 const defaultEventSinkFactory = {
     create: createRuntimeEventBus,
 };
 const defaultModelGatewayClient = {
     invoke: invokeModelGateway,
     invokeRaw: invokeRawModelGateway,
+    embed: embedModelGateway,
 };
+const defaultLongTermMemoryService = createLongTermMemoryService({
+    repository: createInMemoryLongTermMemoryRepository(),
+    enabled: false,
+    emitClientEvents: false,
+});
 export function resolveRequestDependencies(options) {
     return {
         eventSinkFactory: options.eventSinkFactory ?? defaultEventSinkFactory,
@@ -18,6 +26,7 @@ export function resolveRequestDependencies(options) {
         sessionStore: options.sessionStore ?? defaultRuntimeSessionStore,
         attachmentStore: options.attachmentStore,
         sessionMemoryCompactor: options.sessionMemoryCompactor ?? createModelSessionMemoryCompactor(),
+        longTermMemory: options.longTermMemory ?? defaultLongTermMemoryService,
         toolApprovalController: options.toolApprovalController,
         loadDecisionEnvironment: () => {
             const configPath = options.runtimeConfig?.requestRunner?.configPath;

package/dist/src/runtime/request/execution-agent-root-execution.js

@@ -1,7 +1,7 @@
 import { projectSupervisorCallIdentity, projectSupervisorResumeContext, } from "../steps/supervisor-decision/index.js";
-import { EXECUTION_AGENT_DECISION_MODEL_STEP, EXECUTION_AGENT_RESPONSE_MODEL_STEP, runExecutionAgentDecision, runExecutionAgentResponse, } from "../steps/execution-agent/index.js";
+import { EXECUTION_AGENT_DECISION_MODEL_STEP, EXECUTION_AGENT_RESPONSE_MODEL_STEP, runExecutionAgentDecision, runExecutionAgentAuthoredResponse, } from "../steps/execution-agent/index.js";
 import { encodeExecutionAgentAuditObjective } from "../steps/auditor-decision/index.js";
-import { resolveRequestSteeringInbox } from "./request-steering.js";
+import { projectRequestSteeringSnapshot, resolveRequestSteeringInbox, } from "./request-steering.js";
 export const EXECUTION_AGENT_ROOT_CONTRACT = Object.freeze({
     contractId: "execution_agent",
     decisionModelStep: EXECUTION_AGENT_DECISION_MODEL_STEP,
@@ -27,10 +27,10 @@ export const EXECUTION_AGENT_ROOT_CONTRACT = Object.freeze({
     },
     async authorResponse(request, options) {
         const requestSteering = resolveRequestSteeringInbox(request.requestSteering);
-        return runExecutionAgentResponse(request, {
+        return runExecutionAgentAuthoredResponse(request, {
             head: options.head,
             call: options.callFrame,
-            steeringSnapshot: requestSteering.snapshot(),
+            steeringSnapshot: projectRequestSteeringSnapshot(requestSteering, options.steeringVersion),
         });
     },
 });
@@ -46,6 +46,7 @@ function projectKernelDecision(decision, steeringVersion) {
             return Object.freeze({
                 action: "reconsider_capability_selection",
                 selection: decision.selection,
+                cause: decision.cause,
             });
         case "open_capability_scope":
             return Object.freeze({

package/dist/src/runtime/request/execution-facets.d.ts

@@ -1,9 +1,10 @@
-import type { AcceptedRequestInput, RequestSessionSnapshot, RequestExecutionSeed, RequestIdentity, RequestLifecycleRuntime, RequestModelInvocationView, RequestModelRuntime, RequestPresentation } from "./contracts.js";
+import type { AcceptedRequestInput, RequestSessionSnapshot, RequestExecutionSeed, RequestIdentity, RequestLifecycleRuntime, RequestModelInvocationView, RequestModelRuntime, RequestMemoryRuntime, RequestPresentation } from "./contracts.js";
 export type RequestSeedFacets = Readonly<{
     identity: RequestIdentity;
     input: AcceptedRequestInput;
     session: RequestSessionSnapshot;
     model: RequestModelRuntime;
+    memory: RequestMemoryRuntime;
     lifecycle: RequestLifecycleRuntime;
     presentation: RequestPresentation;
 }>;

package/dist/src/runtime/request/execution-facets.js

@@ -37,6 +37,11 @@ export function createRequestSeedFacets(seed) {
             : {}),
         modelGatewayClient: seed.modelGatewayClient,
     });
+    const memory = Object.freeze({
+        ...(seed.longTermMemory !== undefined
+            ? { longTermMemory: seed.longTermMemory }
+            : {}),
+    });
     const lifecycle = Object.freeze({
         ...(seed.requestSteering !== undefined
             ? { requestSteering: seed.requestSteering }
@@ -60,6 +65,7 @@ export function createRequestSeedFacets(seed) {
         input,
         session,
         model,
+        memory,
         lifecycle,
         presentation,
     });

package/dist/src/runtime/request/execution-scope-surfaces.js

@@ -58,6 +58,11 @@ export function createScopeSurface(input) {
                 sessionMemory: enumerableGetter(() => facets.session.sessionMemory),
             }
             : {}),
+        ...(facets.memory.longTermMemory !== undefined
+            ? {
+                longTermMemory: enumerableGetter(() => facets.memory.longTermMemory),
+            }
+            : {}),
         executionPolicy: enumerableGetter(() => policy.executionPolicy),
         modelSteps: enumerableGetter(() => modelSteps),
         workerCapabilities: enumerableGetter(() => capabilities),
@@ -65,6 +70,7 @@ export function createScopeSurface(input) {
         input: hiddenValue(facets.input),
         session: hiddenValue(facets.session),
         model: hiddenValue(facets.model),
+        memory: hiddenValue(facets.memory),
         lifecycle: hiddenValue(facets.lifecycle),
         presentation: hiddenValue(facets.presentation),
         policy: hiddenValue(policy),

package/dist/src/runtime/request/execution-scope.d.ts

@@ -1,5 +1,6 @@
+import type { ToolAvailabilitySource } from "../capabilities/tool-availability.js";
 import type { WorkerCapabilityAdapterProvider } from "../orchestration/worker-capabilities/index.js";
-import type { AcceptedRequestInput, BoundRequestModelInvocationContext, RequestSessionSnapshot, RequestExecutionSeed, RequestIdentity, RequestLifecycleRuntime, RequestModelInvocationView, RequestModelRuntime, RequestPresentation } from "./contracts.js";
+import type { AcceptedRequestInput, BoundRequestModelInvocationContext, RequestSessionSnapshot, RequestExecutionSeed, RequestIdentity, RequestLifecycleRuntime, RequestModelInvocationView, RequestModelRuntime, RequestMemoryRuntime, RequestPresentation } from "./contracts.js";
 import type { CompiledExecutionPolicy } from "./root-contract.js";
 /** Request fields required while the request-bound capability catalog is built. */
 export type RequestCapabilityCompositionView = BoundRequestModelInvocationContext & Readonly<Pick<RequestExecutionSeed, "sessionId" | "prompt" | "historyMessages" | "toolPermissionMode" | "toolApprovalController" | "onEvent" | "contextCompactionStore">>;
@@ -7,9 +8,9 @@ export type RequestCapabilityCompositionView = BoundRequestModelInvocationContex
  * Stable request-owned context delivered to capability adapters.
  * Passive session artifact paths and request containers are excluded.
  */
-export type RequestCapabilityExecutionView = Readonly<Omit<RequestExecutionSeed, "sessionArtifactPaths" | "sessionMemory">> & BoundRequestModelInvocationContext;
+export type RequestCapabilityExecutionView = Readonly<Omit<RequestExecutionSeed, "sessionArtifactPaths" | "sessionMemory" | "longTermMemory">> & BoundRequestModelInvocationContext;
 export type RequestWorkerCapabilities = Readonly<{
-    provider: WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView>;
+    provider: WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView> & Partial<ToolAvailabilitySource>;
     executionContext: RequestCapabilityExecutionView;
 }>;
 export type RequestExecutionPolicyFacet = Readonly<{
@@ -22,6 +23,7 @@ export type RequestExecutionScope = RequestExecutionSeed & BoundRequestModelInvo
     input: AcceptedRequestInput;
     session: RequestSessionSnapshot;
     model: RequestModelRuntime;
+    memory: RequestMemoryRuntime;
     lifecycle: RequestLifecycleRuntime;
     presentation: RequestPresentation;
     policy: RequestExecutionPolicyFacet;

package/dist/src/runtime/request/handler.js

@@ -62,7 +62,7 @@ class RequestHandlingSession {
     }
     async execute() {
         const { requestId, sessionId, prompt, rawAttachments, rawAgentMode, rawModelPreference, toolPermissionMode, } = this.input;
-        const { eventSinkFactory, modelGatewayClient, sessionStore, attachmentStore, loadDecisionEnvironment, toolApprovalController, sessionMemoryCompactor, } = this.dependencies;
+        const { eventSinkFactory, modelGatewayClient, sessionStore, attachmentStore, loadDecisionEnvironment, toolApprovalController, sessionMemoryCompactor, longTermMemory, } = this.dependencies;
         const { runnerConfig, modelPolicy, modelExecutionPolicies } = loadDecisionEnvironment();
         const modelSelection = resolveModelSelection({
             agentMode: rawAgentMode,
@@ -138,6 +138,7 @@ class RequestHandlingSession {
             modelGatewayClient,
             contextCompactionStore: createRequestContextCompactionStore(),
             sessionMemory,
+            longTermMemory,
             requestSteering: this.requestSteering,
             toolPermissionMode,
             ...(toolApprovalController ? { toolApprovalController } : {}),
@@ -191,6 +192,8 @@ class RequestHandlingSession {
             agentMode: modelSelection.agentMode,
             thinkingTrace: callbacks.getThinkingTrace(),
             finalObservation: runnerResult.finalObservation,
+            memoryCandidates: runnerResult.memoryCandidates,
+            longTermMemory,
         });
         this.finalized = true;
         if (finalization.status === "failed")

package/dist/src/runtime/request/result.d.ts

@@ -1,4 +1,5 @@
 import type { SessionMessageObservationMeta } from "../../sessions/types.js";
+import type { MemoryCandidate } from "../long-term-memory/contracts.js";
 export type RequestObservation = {
     observationMeta: SessionMessageObservationMeta;
     observationContent: string;
@@ -9,6 +10,7 @@ export type RequestRunnerResult = {
     /** Omission preserves the legacy normalized finalization contract. */
     outputTextMode?: RequestOutputTextMode;
     finalObservation?: RequestObservation;
+    memoryCandidates?: readonly MemoryCandidate[];
 };
 export type RequestRoleExecutionHandoff = Readonly<{
     finalObservation?: RequestObservation;

package/dist/src/runtime/request/role-executor-composition.js

@@ -42,7 +42,7 @@ export const EXECUTION_AGENT_ROLE_EXECUTORS = projectRequestRoleExecutorRegistry
 ]);
 const SUPERVISOR_WORKER_V1_POLICY_DEFINITION = Object.freeze({
     id: "supervisor-worker-v1",
-    version: 1,
+    version: 2,
     rootContract: SUPERVISOR_ROOT_CONTRACT,
     roleExecutors: REQUEST_ROLE_EXECUTORS,
     capabilityAuthorities: Object.freeze(["worker"]),

package/dist/src/runtime/request/root-contract.d.ts

@@ -1,10 +1,11 @@
 import type { ModelStep } from "../../shared/model-steps.js";
 import type { RequestToolResultsView } from "../context/request-tool-results.js";
-import type { ExecutionPolicyAuthoritySnapshot, RoleCallChildReturnCommit, RoleCallFrame, RoleCallLedger, RoleCallLedgerHead, RoleCallWorkerCapabilityScope, RoleCapabilitySelectionProjection, RoleChildReturnContext } from "../orchestration/role-calls/index.js";
+import type { ExecutionPolicyAuthoritySnapshot, RoleCallChildReturnCommit, RoleCallFrame, RoleCallLedger, RoleCallLedgerHead, RoleCallWorkerCapabilityScope, RoleCapabilitySelectionProjection, RoleCapabilitySelectionReconsiderationCause, RoleChildReturnContext } from "../orchestration/role-calls/index.js";
 import type { RuntimeDelegateRoleId } from "../orchestration/roles.js";
 import type { RoleExecutorRegistry } from "../orchestration/role-executors/index.js";
 import type { WorkerCapabilityCatalogGroup, WorkerCapabilityControls } from "../orchestration/worker-capabilities/index.js";
 import type { RequestRoleExecutionHandoff } from "./result.js";
+import type { RootAuthoredResponse } from "../long-term-memory/contracts.js";
 export type RootContractCallIdentity = Readonly<{
     rootCallId: string;
     callId: string;
@@ -56,6 +57,7 @@ export type RootContractDecision = Readonly<{
 }> | Readonly<{
     action: "reconsider_capability_selection";
     selection: RoleCapabilitySelectionProjection;
+    cause: RoleCapabilitySelectionReconsiderationCause;
     acknowledgement?: undefined;
     title?: undefined;
 }>;
@@ -89,7 +91,7 @@ export type RootContractAdapter<TRequest> = Readonly<{
         call: RootContractCallIdentity;
         toolResults: RequestToolResultsView;
         resume?: RoleChildReturnContext;
-    }>): Promise<string>;
+    }>): Promise<RootAuthoredResponse>;
 }>;
 export type CompiledExecutionPolicy<TRequest> = Readonly<{
     authority: ExecutionPolicyAuthoritySnapshot;

package/dist/src/runtime/request/root-execution-kernel.js

@@ -2,12 +2,17 @@ import { projectRequestToolResults } from "../context/request-tool-results.js";
 import { emitRuntimeStatus } from "../events/runtime-status.js";
 import { resolveRoleCallTransactions, } from "../orchestration/role-calls/index.js";
 import { RUNTIME_ROOT_ROLE_ID } from "../orchestration/roles.js";
-import { createRoleCapabilityBinding, projectWorkerCapabilityCatalogGroups, } from "../orchestration/worker-capabilities/index.js";
+import { createRoleCapabilityBinding, isWorkerCapabilityOperationSupervisionLimitError, projectWorkerCapabilityCatalogGroups, } from "../orchestration/worker-capabilities/index.js";
+import { runDegradedFinalization } from "../steps/degraded-finalization/run.js";
 import { projectRequestSteeringSnapshot, resolveRequestSteeringInbox, } from "./request-steering.js";
 import { traceSupervisorRootAcknowledgementPublished, traceSupervisorRootActivationFailed, traceSupervisorRootActivationStarted, traceSupervisorRootObservationHandoffBound, traceSupervisorRootInvocationSuperseded, traceSupervisorRootResponseSuperseded, } from "./supervisor-root-execution-diagnostics.js";
+import { createPlainRootAuthoredResponse } from "../orchestration/final-response/authoring-contract.js";
 const CONTINUE_ROOT_EXECUTION = Object.freeze({
     kind: "continue",
 });
+function isTerminalRootDecision(decision) {
+    return decision.action === "respond" || decision.action === "blocked";
+}
 export async function runRootExecutionKernel(params) {
     return new RootExecutionSession(params).run();
 }
@@ -113,14 +118,13 @@ class RootExecutionSession {
             ...(this.resume ? { resume: this.resume } : {}),
         });
         const requiresFreshPresentation = this.policy.rootContract.deferRespondPresentation === true;
+        const isTerminalDecision = isTerminalRootDecision(decisionOutcome.decision);
         return Object.freeze({
             ...activation,
             decision: decisionOutcome.decision,
             decisionSteeringVersion: decisionOutcome.steeringVersion,
             requiresFreshPresentation,
-            deferPresentation: requiresFreshPresentation &&
-                (decisionOutcome.decision.action === "respond" ||
-                    decisionOutcome.decision.action === "blocked"),
+            deferPresentation: requiresFreshPresentation && isTerminalDecision,
         });
     }
     async publishImmediatePresentation(activation, attempt) {
@@ -137,19 +141,22 @@ class RootExecutionSession {
             await this.request.onSessionTitle(decision.title);
             this.titlePublished = true;
         }
-        if (decision.acknowledgement !== undefined) {
+        const acknowledgement = isTerminalRootDecision(decision)
+            ? undefined
+            : decision.acknowledgement;
+        if (acknowledgement !== undefined) {
             if (activation.requiresFreshPresentation &&
                 !this.isInvocationCurrent(activation.decisionSteeringVersion)) {
                 return false;
             }
             attempt.failureStage = "publish_acknowledgement";
-            this.request.onAcknowledgement(decision.acknowledgement);
+            this.request.onAcknowledgement(acknowledgement);
             this.acknowledgementPublished = true;
             traceSupervisorRootAcknowledgementPublished({
                 diagnostic: this.diagnostic,
                 head: activation.head,
                 call: activation.call,
-                acknowledgementLength: decision.acknowledgement.length,
+                acknowledgementLength: acknowledgement.length,
             });
         }
         return true;
@@ -217,8 +224,23 @@ class RootExecutionSession {
             invocationAttempt: activation.call.activationCount,
             steeringVersion: activation.decisionSteeringVersion,
             selection: decision.selection,
+            cause: decision.cause,
         });
         if (!reconsidered.ok) {
+            if (reconsidered.issueCode ===
+                "capability_selection_supervision_limit_exceeded" ||
+                reconsidered.issueCode === "role_activation_limit_exceeded") {
+                return this.completeSupervisionLimit({
+                    head: activation.head,
+                    call: activation.call,
+                    decisionSteeringVersion: activation.decisionSteeringVersion,
+                    attempt,
+                    problem: Object.freeze({
+                        stage: "capability_selection_supervision",
+                        code: reconsidered.issueCode,
+                    }),
+                });
+            }
             throw new Error(`role_call_ledger_rejected:${reconsidered.issueCode}`);
         }
         return CONTINUE_ROOT_EXECUTION;
@@ -277,19 +299,74 @@ class RootExecutionSession {
                 }
                 : {}),
         });
-        if (decision.action === "invoke_capability") {
-            await binding.execute({
-                capabilityId: decision.capabilityId,
-                intent: decision.intent,
-                controls: decision.controls,
-            });
+        try {
+            if (decision.action === "invoke_capability") {
+                await binding.execute({
+                    capabilityId: decision.capabilityId,
+                    intent: decision.intent,
+                    controls: decision.controls,
+                });
+            }
+            else {
+                await binding.executeBatch({ invocations: decision.invocations });
+            }
         }
-        else {
-            await binding.executeBatch({ invocations: decision.invocations });
+        catch (error) {
+            if (!isWorkerCapabilityOperationSupervisionLimitError(error)) {
+                throw error;
+            }
+            return this.completeSupervisionLimit({
+                head,
+                call,
+                decisionSteeringVersion: activation.decisionSteeringVersion,
+                attempt,
+                problem: Object.freeze({
+                    stage: "operation_supervision",
+                    code: "operation_supervision_limit_exceeded",
+                }),
+            });
         }
         this.resume = undefined;
         return CONTINUE_ROOT_EXECUTION;
     }
+    async completeSupervisionLimit(params) {
+        if (!this.isResponseCurrent(params.decisionSteeringVersion, "before_response")) {
+            return CONTINUE_ROOT_EXECUTION;
+        }
+        params.attempt.failureStage = "compose_response";
+        const response = await runDegradedFinalization({
+            request: this.request,
+            input: Object.freeze({
+                problem: params.problem,
+                progress: null,
+            }),
+        });
+        if (!this.isResponseCurrent(params.decisionSteeringVersion, "after_response")) {
+            return CONTINUE_ROOT_EXECUTION;
+        }
+        params.attempt.failureStage = "seal_response";
+        this.request.abortSignal.throwIfAborted();
+        if (!this.requestSteering.seal(params.decisionSteeringVersion)) {
+            this.traceResponseSuperseded(params.decisionSteeringVersion, "seal");
+            return CONTINUE_ROOT_EXECUTION;
+        }
+        params.attempt.failureStage = "commit_response";
+        const output = await commitSupervisorResponse({
+            transactions: this.transactions,
+            expectedHead: params.head,
+            callId: params.call.callId,
+            response,
+        });
+        return Object.freeze({
+            kind: "complete",
+            result: Object.freeze({
+                output,
+                ...(this.policy.authority.terminalTextMode === "exact"
+                    ? { outputTextMode: "exact" }
+                    : {}),
+            }),
+        });
+    }
     async completeResponse(activation, decision, attempt) {
         if (!this.isResponseCurrent(activation.decisionSteeringVersion, "before_response")) {
             return CONTINUE_ROOT_EXECUTION;
@@ -299,8 +376,8 @@ class RootExecutionSession {
             ? projectSupervisorFinalObservation(this.observationHandoff, this.resume)
             : undefined;
         attempt.failureStage = "compose_response";
-        const response = decision.action === "blocked"
-            ? decision.response
+        const authoredResponse = decision.action === "blocked"
+            ? createPlainRootAuthoredResponse(decision.response)
             : await this.policy.rootContract.authorResponse(this.request, {
                 head: activation.head,
                 callFrame: activation.call,
@@ -323,13 +400,13 @@ class RootExecutionSession {
             this.traceResponseSuperseded(activation.decisionSteeringVersion, "seal");
             return CONTINUE_ROOT_EXECUTION;
         }
-        await this.publishDeferredPresentation(activation, attempt);
+        await this.publishDeferredTitle(activation, attempt);
         attempt.failureStage = "commit_response";
         const output = await commitSupervisorResponse({
             transactions: this.transactions,
             expectedHead: activation.head,
             callId: activation.call.callId,
-            response,
+            response: authoredResponse.finalResponse,
         });
         return Object.freeze({
             kind: "complete",
@@ -339,10 +416,13 @@ class RootExecutionSession {
                     ? { outputTextMode: "exact" }
                     : {}),
                 ...(finalObservation ? { finalObservation } : {}),
+                ...(authoredResponse.memoryCandidates.length > 0
+                    ? { memoryCandidates: authoredResponse.memoryCandidates }
+                    : {}),
             }),
         });
     }
-    async publishDeferredPresentation(activation, attempt) {
+    async publishDeferredTitle(activation, attempt) {
         if (!activation.deferPresentation) {
             return;
         }
@@ -351,17 +431,6 @@ class RootExecutionSession {
             await this.request.onSessionTitle(activation.decision.title);
             this.titlePublished = true;
         }
-        if (activation.decision.acknowledgement !== undefined) {
-            attempt.failureStage = "publish_acknowledgement";
-            this.request.onAcknowledgement(activation.decision.acknowledgement);
-            this.acknowledgementPublished = true;
-            traceSupervisorRootAcknowledgementPublished({
-                diagnostic: this.diagnostic,
-                head: activation.head,
-                call: activation.call,
-                acknowledgementLength: activation.decision.acknowledgement.length,
-            });
-        }
     }
     isInvocationCurrent(decisionSteeringVersion) {
         if (this.requestSteering.isCurrent(decisionSteeringVersion)) {

package/dist/src/runtime/request/supervisor-root-execution.js

@@ -1,6 +1,7 @@
 import { projectSupervisorCallIdentity, projectSupervisorResumeContext, runSupervisorDecision, SUPERVISOR_DECISION_MODEL_STEP, } from "../steps/supervisor-decision/index.js";
-import { runSupervisorResponse, SUPERVISOR_RESPONSE_MODEL_STEP, } from "../steps/supervisor-response/index.js";
+import { runSupervisorAuthoredResponse, SUPERVISOR_RESPONSE_MODEL_STEP, } from "../steps/supervisor-response/index.js";
 import { runRootExecutionKernel, } from "./root-execution-kernel.js";
+import { projectRequestSteeringSnapshot } from "./request-steering.js";
 export const SUPERVISOR_ROOT_CONTRACT = Object.freeze({
     contractId: "supervisor",
     decisionModelStep: SUPERVISOR_DECISION_MODEL_STEP,
@@ -19,9 +20,10 @@ export const SUPERVISOR_ROOT_CONTRACT = Object.freeze({
         });
     },
     async authorResponse(request, options) {
-        return runSupervisorResponse(request, {
+        return runSupervisorAuthoredResponse(request, {
             call: options.call,
             toolResults: options.toolResults,
+            steeringSnapshot: projectRequestSteeringSnapshot(request.requestSteering, options.steeringVersion),
             ...(options.resume ? { resume: options.resume } : {}),
         });
     },

package/dist/src/runtime/request/worker-capability-composition.d.ts

@@ -1,6 +1,7 @@
 import type { RuntimeConfig, ToolRegistry } from "../ports.js";
 import type { ToolRequestAttachment } from "../../capabilities/tool-types.js";
 import type { WorkerCapabilityAdapterProvider } from "../orchestration/worker-capabilities/index.js";
+import { type ToolAvailabilitySource } from "../capabilities/tool-availability.js";
 import type { ExecutionPolicyAuthoritySnapshot } from "../orchestration/role-calls/index.js";
 import type { RequestCapabilityCompositionView, RequestCapabilityExecutionView } from "./execution-scope.js";
 type RequestWorkerCapabilityProviderParams<TRequest> = Readonly<{
@@ -14,5 +15,5 @@ type RequestWorkerCapabilityProviderParams<TRequest> = Readonly<{
  * Creates one lazy, request-scoped Worker capability source from declarative
  * role config and the neutral runtime Tool Registry.
  */
-export declare function createRequestWorkerCapabilityProvider(params: RequestWorkerCapabilityProviderParams<RequestCapabilityCompositionView>): WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView>;
+export declare function createRequestWorkerCapabilityProvider(params: RequestWorkerCapabilityProviderParams<RequestCapabilityCompositionView>): WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView> & ToolAvailabilitySource;
 export {};

package/dist/src/runtime/request/worker-capability-composition.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { createBundledPluginSkillProvider, createConfiguredSkillProvider, } from "../adapters/configured-skill-provider.js";
 import { createRegisteredToolWorkerCapabilityProvider } from "../adapters/registered-tool-worker-capabilities.js";
 import { createRequestRuntimeToolRegistry } from "../capabilities/request-runtime-tool-registry.js";
+import { projectAvailableTools, } from "../capabilities/tool-availability.js";
 import { createRequestWorkerCapabilityPayloadAuthor } from "./worker-capability-payload.js";
 /**
  * Creates one lazy, request-scoped Worker capability source from declarative
@@ -35,7 +36,7 @@ export function createRequestWorkerCapabilityProvider(params) {
         }
         return requestSkillProvider;
     }
-    return createRegisteredToolWorkerCapabilityProvider({
+    const provider = createRegisteredToolWorkerCapabilityProvider({
         getRequestToolRegistry,
         requestId: params.request.requestId,
         sessionId: params.request.sessionId,
@@ -58,4 +59,8 @@ export function createRequestWorkerCapabilityProvider(params) {
         nextApprovalId: () => `approval:${randomUUID()}`,
         onEvent: params.request.onEvent,
     });
+    return Object.freeze({
+        ...provider,
+        getAvailableTools: () => projectAvailableTools(getRequestToolRegistry().listNormalInvocations?.()),
+    });
 }

package/dist/src/runtime/request/worker-capability-payload-prompts.js

@@ -2,7 +2,7 @@ export function buildWorkerCapabilityPayloadRepairHint(input) {
     const issue = input.issues[0];
     return [
         "Your previous payload was rejected before it reached a tool, file mutation, or user response.",
-        "Correct the same immutable payload assignment; do not change its capability, target, controls, or intent.",
+        "Correct the same immutable payload assignment; do not change its assignment objective, capability, target, or controls.",
         `Repair attempt: ${input.repairAttempt}.`,
         `Validation issue: ${issue?.message ?? "Return the complete required payload."} (${issue?.code ?? "payload_output_invalid"}).`,
         issue?.code === "payload_model_output_invalid"

package/dist/src/runtime/request/worker-capability-payload.js

@@ -138,13 +138,15 @@ function payloadMessages(request, input) {
             : {}),
         ...(request.modelPolicy ? { modelPolicy: request.modelPolicy } : {}),
     });
-    const requestSource = projectRequestSource({
-        requestId: request.requestId,
-        prompt: request.prompt,
-        modelStep: input.modelStep,
-        callId,
-        historyMessages: request.historyMessages,
-    });
+    const requestSource = input.requestSourceProjection === "full_request"
+        ? projectRequestSource({
+            requestId: request.requestId,
+            prompt: request.prompt,
+            modelStep: input.modelStep,
+            callId,
+            historyMessages: request.historyMessages,
+        })
+        : undefined;
     const projectedContext = projectPayloadContext(input.context);
     traceDebug("runtime.worker_capability_payload_context", "projected", {
         requestId: request.requestId,
@@ -156,6 +158,7 @@ function payloadMessages(request, input) {
         relatedArtifactContextCount: projectedContext.relatedArtifactMessages.length,
         sourceRelatedArtifactContextCount: input.context.relatedArtifactContexts?.length ?? 0,
         hasTargetContext: input.context.targetContext !== undefined,
+        requestSourceProjection: input.requestSourceProjection,
     });
     try {
         return projectRequestContext({
@@ -163,7 +166,7 @@ function payloadMessages(request, input) {
             historyMessages: [],
             prompt: `Canonical runtime context:\n${JSON.stringify(projectedContext.metadata)}`,
             referenceMessages: [
-                buildRequestSourceMessage(requestSource),
+                ...(requestSource ? [buildRequestSourceMessage(requestSource)] : []),
                 ...projectedContext.relatedArtifactMessages,
             ],
             ...(projectedContext.targetContentMessage

package/dist/src/runtime/steps/execution-agent/capability-invocation-contract.d.ts

@@ -0,0 +1,24 @@
+import type { CapabilityControlsPartition, CapabilityControlsSchema } from "../../orchestration/capability-adapters/index.js";
+import type { ExecutionAgentDecisionValidationIssue } from "./contracts.js";
+export declare const EXECUTION_AGENT_OPERATION_OBJECTIVE_MAX_LENGTH = 4096;
+type ParsedExecutionOperationObjective = Readonly<{
+    ok: true;
+    value?: string;
+}> | Readonly<{
+    ok: false;
+}>;
+export declare function requiresExecutionOperationObjective(partition: CapabilityControlsPartition): boolean;
+export declare function executionOperationObjectiveSchema(): Record<string, unknown>;
+export declare function parseExecutionOperationObjective(params: Readonly<{
+    value: unknown;
+    required: boolean;
+    path: string;
+    issues: ExecutionAgentDecisionValidationIssue[];
+}>): ParsedExecutionOperationObjective;
+export declare function normalizeGeneratedExecutionCapabilityControls(value: unknown, schema: CapabilityControlsSchema): unknown;
+export declare function executionCapabilityControlsIssue(params: Readonly<{
+    issueCode: string;
+    controlId?: string;
+    path: string;
+}>): ExecutionAgentDecisionValidationIssue;
+export {};