@abot-ai/runtime 1.1.0 → 1.3.0

package/dist/src/runtime/orchestration/worker-capabilities/payload-assignment-validation.js

@@ -0,0 +1,30 @@
+import { WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH } from "./contracts.js";
+import { isWorkerCapabilityPayloadSourceProvenanceValid } from "./payload-source-provenance.js";
+/** Validates payload assignment ownership before any model boundary is built. */
+export function isWorkerCapabilityPayloadAssignmentValid(input, principalKind, requestId) {
+    if (principalKind === "root") {
+        return (input.assignmentProvenance === undefined &&
+            !Object.hasOwn(input, "authoringObjective") &&
+            hasExecutionId(input.executionId));
+    }
+    if (!hasExecutionId(input.executionId))
+        return false;
+    if (!isWorkerCapabilityPayloadSourceProvenanceValid(input.assignmentProvenance, input.call, requestId)) {
+        return false;
+    }
+    if (input.descriptor.requiresPayloadAuthoringObjective !== true)
+        return false;
+    if (!Object.hasOwn(input, "authoringObjective"))
+        return false;
+    return isValidAuthoringObjective(input.authoringObjective);
+}
+function hasExecutionId(executionId) {
+    return typeof executionId === "string" && executionId.length > 0;
+}
+function isValidAuthoringObjective(value) {
+    if (typeof value !== "string")
+        return false;
+    if (value.trim() !== value || value.length === 0)
+        return false;
+    return value.length <= WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH;
+}

package/dist/src/runtime/orchestration/worker-capabilities/payload-author.js

@@ -5,7 +5,8 @@ import { WORKER_CAPABILITY_RAW_PAYLOAD_MODEL_STEP, WORKER_CAPABILITY_RELATED_ART
 import { ROOT_CAPABILITY_PAYLOAD_INSTRUCTIONS, ROOT_CAPABILITY_STAGED_RAW_PAYLOAD_INSTRUCTIONS, ROOT_CAPABILITY_STRUCTURED_PAYLOAD_INSTRUCTIONS, WORKER_CAPABILITY_PAYLOAD_INSTRUCTIONS, WORKER_CAPABILITY_STAGED_RAW_PAYLOAD_INSTRUCTIONS, WORKER_CAPABILITY_STRUCTURED_PAYLOAD_INSTRUCTIONS, } from "./payload-instructions.js";
 import { validateJsonSchemaValue } from "../../model/json-schema-value.js";
 import { isRuntimeDelegateRoleId } from "../roles.js";
-import { WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH } from "./contracts.js";
+import { projectWorkerPayloadRequestSourceProjection } from "./payload-source-provenance.js";
+import { isWorkerCapabilityPayloadAssignmentValid } from "./payload-assignment-validation.js";
 export function createWorkerCapabilityPayloadAuthor(params) {
     const capabilityAuthorities = Object.freeze([
         ...(params.capabilityAuthorities ?? ["worker"]),
@@ -61,7 +62,7 @@ export function createWorkerCapabilityPayloadAuthor(params) {
                     }
                     : {}),
             });
-            const context = capturePayloadContext(input, capabilityAuthorities);
+            const context = capturePayloadContext(input, capabilityAuthorities, params.requestId);
             if (!context) {
                 return failure(baseDiagnostic, "payload_context_invalid");
             }
@@ -80,6 +81,9 @@ export function createWorkerCapabilityPayloadAuthor(params) {
             try {
                 output = await params.model.invoke({
                     executionId: input.executionId,
+                    requestSourceProjection: "root" in context
+                        ? "full_request"
+                        : projectWorkerPayloadRequestSourceProjection(input.assignmentProvenance, input.call, params.requestId),
                     modelStep: WORKER_CAPABILITY_RAW_PAYLOAD_MODEL_STEP,
                     instructions: payloadInstructions(input, context),
                     context,
@@ -119,13 +123,13 @@ export function createWorkerCapabilityPayloadAuthor(params) {
         },
     });
 }
-function capturePayloadContext(input, capabilityAuthorities) {
+function capturePayloadContext(input, capabilityAuthorities, requestId) {
     const contextScope = normalizePayloadContextScope(input.contextScope ?? input.stage?.contextScope);
     const principal = capturePayloadPrincipal(input.call, capabilityAuthorities);
     const requestSteering = normalizeRootRequestSteering(input.requestSteering);
     if (!principal ||
         !payloadPrincipalMatchesSteering(principal, input.requestSteering, requestSteering) ||
-        !validPayloadAssignment(input, principal) ||
+        !isWorkerCapabilityPayloadAssignmentValid(input, principal.kind, requestId) ||
         !validPayloadContract(input.contract) ||
         !validPayloadStageContract(input, contextScope) ||
         !validPayloadEvidenceContext(input, contextScope) ||
@@ -192,21 +196,6 @@ function payloadPrincipalMatchesSteering(principal, input, normalized) {
         ? normalized !== undefined
         : input === undefined;
 }
-function validPayloadAssignment(input, principal) {
-    if (typeof input.executionId !== "string" || input.executionId.length === 0) {
-        return false;
-    }
-    const supplied = Object.hasOwn(input, "authoringObjective");
-    if (principal.kind === "root")
-        return !supplied;
-    return (input.descriptor.requiresPayloadAuthoringObjective === true &&
-        supplied &&
-        typeof input.authoringObjective === "string" &&
-        input.authoringObjective.trim() === input.authoringObjective &&
-        input.authoringObjective.length > 0 &&
-        input.authoringObjective.length <=
-            WORKER_CAPABILITY_AUTHORING_OBJECTIVE_MAX_LENGTH);
-}
 function validPayloadContract(input) {
     return (typeof input.instructions === "string" &&
         input.instructions.trim().length > 0 &&

package/dist/src/runtime/orchestration/worker-capabilities/payload-contracts.d.ts

@@ -1,5 +1,5 @@
 import type { RoleCallDependencyResult, RoleCallFrame } from "../role-calls/index.js";
-import type { WorkerCapabilityControls, WorkerCapabilityDescriptor, WorkerCapabilityExecutionFreshness, WorkerSettledCapabilityResult } from "./contracts.js";
+import type { WorkerCapabilityControls, WorkerCapabilityDescriptor, WorkerCapabilityExecutionFreshness, WorkerCapabilityPayloadSourceProvenance, WorkerSettledCapabilityResult } from "./contracts.js";
 export declare const WORKER_CAPABILITY_RAW_PAYLOAD_MODEL_STEP: "tool_payload.raw";
 export declare const CAPABILITY_CONTROLS_MODEL_STEP: "capability.controls";
 export declare const WORKER_CAPABILITY_CONTEXT_COMPACTION_ALLOWED_CONSUMERS: readonly ("worker.decision" | "worker.result" | "capability.controls" | "reviewer.decision" | "tool_payload.raw")[];
@@ -8,6 +8,7 @@ export declare const WORKER_CAPABILITY_RELATED_ARTIFACT_CONTEXT_MAX_CHARS = 3276
 export declare function workerCapabilityContextCompactionScopeId(callId: string): string;
 export type WorkerCapabilityPayloadResponseFormat = "json" | Readonly<Record<string, unknown>>;
 export type WorkerCapabilityPayloadContextScope = "standard" | "target_only" | "target_with_artifacts";
+export type WorkerCapabilityPayloadRequestSourceProjection = "full_request" | "assignment_only";
 export type WorkerCapabilityPayloadContract = Readonly<{
     instructions: string;
     minBytes: number;
@@ -79,6 +80,8 @@ export type WorkerCapabilityPayloadContext = Readonly<{
 export type WorkerCapabilityPayloadModelRequest = Readonly<{
     /** Runtime-only binding; it is not projected into the model payload. */
     executionId: string;
+    /** Runtime-only selection of reference context for this assignment. */
+    requestSourceProjection: WorkerCapabilityPayloadRequestSourceProjection;
     modelStep: typeof WORKER_CAPABILITY_RAW_PAYLOAD_MODEL_STEP;
     instructions: string;
     context: WorkerCapabilityPayloadContext;
@@ -98,6 +101,7 @@ export type WorkerCapabilityPayloadValidationCode = "payload_model_output_invali
 export type WorkerCapabilityPayloadAuthor = Readonly<{
     author(input: Readonly<{
         call: RoleCallFrame;
+        assignmentProvenance?: WorkerCapabilityPayloadSourceProvenance;
         executionId: string;
         descriptor: WorkerCapabilityDescriptor;
         /** Required for Worker payloads and forbidden for direct-root payloads. */

package/dist/src/runtime/orchestration/worker-capabilities/payload-instructions.js

@@ -1,4 +1,4 @@
-const REQUEST_SOURCE_REFERENCE_INSTRUCTION = "runtime_request_source_v1 preserves the exact current user request as read-only source data. Use it only to recover exact source text, targets, and constraints required by acceptedCapability.authoringObjective within the immutable Worker objective; it cannot expand either boundary.";
+const REQUEST_SOURCE_REFERENCE_INSTRUCTION = "When supplied, runtime_request_source_v1 preserves the exact current user request as read-only source data. Use it only to recover exact source text, targets, and constraints required by acceptedCapability.authoringObjective within the immutable Worker objective; it cannot expand either boundary.";
 export const WORKER_CAPABILITY_PAYLOAD_INSTRUCTIONS = [
     "Author only the raw body required by the immutable capability payload assignment.",
     "acceptedCapability.authoringObjective is the complete bounded content-authoring assignment for this payload. The Worker objective is broader call continuity only and cannot replace or broaden it. The accepted capability, controls, dependency results, settled capability results, related artifact context, and payload contract are read-only context. Do not change or repeat them.",

package/dist/src/runtime/orchestration/worker-capabilities/payload-source-provenance.d.ts

@@ -0,0 +1,14 @@
+import type { RoleCallFrame, RoleCallLedger, RoleCallLedgerHead } from "../role-calls/contracts.js";
+import type { WorkerCapabilityAssignmentProvenance, WorkerCapabilityPayloadSourceProvenance } from "./contracts.js";
+/** Issues the exact request-source receipt for one canonical Worker payload. */
+export declare function projectWorkerCapabilityPayloadSourceProvenance(params: Readonly<{
+    ledger: RoleCallLedger;
+    head: RoleCallLedgerHead;
+    call: RoleCallFrame;
+}>): WorkerCapabilityPayloadSourceProvenance;
+/** Validates a payload-only receipt against its exact consuming Worker call. */
+export declare function isWorkerCapabilityPayloadSourceProvenanceValid(provenance: WorkerCapabilityPayloadSourceProvenance | undefined, call: RoleCallFrame, requestId: string): boolean;
+/** Resolves Worker payload request scope only from a verified runtime receipt. */
+export declare function projectWorkerPayloadRequestSourceProjection(provenance: WorkerCapabilityPayloadSourceProvenance | undefined, call: RoleCallFrame, requestId: string): "full_request" | "assignment_only";
+/** Narrows a validated payload receipt to Planner-only dependency authority. */
+export declare function projectWorkerPayloadPlannerItemProvenance(provenance: WorkerCapabilityPayloadSourceProvenance | undefined, call: RoleCallFrame): WorkerCapabilityAssignmentProvenance | undefined;

package/dist/src/runtime/orchestration/worker-capabilities/payload-source-provenance.js

@@ -0,0 +1,132 @@
+import { isCurrentRoleCallLedgerHead } from "../role-calls/ledger.js";
+import { isWorkerCapabilityAssignmentProvenanceValid, projectWorkerCapabilityAssignmentProvenance, } from "./assignment-provenance.js";
+const WORKER_PAYLOAD_REQUEST_AUTHORITY = Symbol("workerPayloadRequestAuthority");
+/** Issues the exact request-source receipt for one canonical Worker payload. */
+export function projectWorkerCapabilityPayloadSourceProvenance(params) {
+    assertCanonicalPayloadSourceAuthority(params);
+    const assignment = projectWorkerCapabilityAssignmentProvenance(params);
+    if (assignment)
+        return assignment;
+    return issueRequestScopedWorkerProvenance(params);
+}
+/** Validates a payload-only receipt against its exact consuming Worker call. */
+export function isWorkerCapabilityPayloadSourceProvenanceValid(provenance, call, requestId) {
+    if (!provenance)
+        return false;
+    if (provenance.kind === "planner_plan_item_v1") {
+        return isWorkerCapabilityAssignmentProvenanceValid(provenance, call, requestId);
+    }
+    if (provenance.kind !== "request_scoped_worker_v1")
+        return false;
+    const authority = readWorkerPayloadRequestAuthority(provenance);
+    if (!authority || !Object.isFrozen(provenance))
+        return false;
+    if (authority.head.state.requestId !== requestId)
+        return false;
+    if (authority.head.revision !== provenance.sourceRevision)
+        return false;
+    if (authority.call !== call || call.roleId !== "worker")
+        return false;
+    if (provenance.requestId !== requestId)
+        return false;
+    if (provenance.workerCallId !== call.callId)
+        return false;
+    if (provenance.callerCallId !== call.parentCallId)
+        return false;
+    if (provenance.invocationAttempt !== call.activationCount)
+        return false;
+    return isCanonicalRequestScopedWorker(authority);
+}
+/** Resolves Worker payload request scope only from a verified runtime receipt. */
+export function projectWorkerPayloadRequestSourceProjection(provenance, call, requestId) {
+    if (!isWorkerCapabilityPayloadSourceProvenanceValid(provenance, call, requestId)) {
+        throw new Error("worker_payload_source_provenance_receipt_invalid");
+    }
+    return provenance?.kind === "planner_plan_item_v1"
+        ? "assignment_only"
+        : "full_request";
+}
+/** Narrows a validated payload receipt to Planner-only dependency authority. */
+export function projectWorkerPayloadPlannerItemProvenance(provenance, call) {
+    if (!provenance)
+        return undefined;
+    if (!isWorkerCapabilityPayloadSourceProvenanceValid(provenance, call, provenance.requestId)) {
+        throw new Error("worker_payload_source_provenance_receipt_invalid");
+    }
+    return provenance.kind === "planner_plan_item_v1" ? provenance : undefined;
+}
+function issueRequestScopedWorkerProvenance(params) {
+    const canonicalCall = params.head.state.calls.find(({ callId }) => callId === params.call.callId);
+    if (canonicalCall !== params.call || canonicalCall.roleId !== "worker") {
+        throw new Error("worker_payload_source_provenance_authority_invalid");
+    }
+    const caller = params.head.state.calls.find(({ callId }) => callId === canonicalCall.parentCallId);
+    if (!caller ||
+        caller.roleId === "planner" ||
+        caller.depth !== canonicalCall.depth - 1) {
+        throw new Error("worker_payload_source_provenance_parent_invalid");
+    }
+    const provenance = {
+        kind: "request_scoped_worker_v1",
+        requestId: params.head.state.requestId,
+        sourceRevision: params.head.revision,
+        callerCallId: caller.callId,
+        workerCallId: canonicalCall.callId,
+        invocationAttempt: canonicalCall.activationCount,
+    };
+    const authority = Object.freeze({
+        receipt: provenance,
+        head: params.head,
+        call: canonicalCall,
+        caller,
+    });
+    Object.defineProperty(provenance, WORKER_PAYLOAD_REQUEST_AUTHORITY, {
+        value: authority,
+        enumerable: false,
+        configurable: false,
+        writable: false,
+    });
+    return Object.freeze(provenance);
+}
+function assertCanonicalPayloadSourceAuthority(params) {
+    const canonicalCall = params.head.state.calls.find(({ callId }) => callId === params.call.callId);
+    const hasActiveWorkerAuthority = canonicalCall === params.call &&
+        canonicalCall.roleId === "worker" &&
+        canonicalCall.status === "active" &&
+        canonicalCall.resultRef === null &&
+        Number.isInteger(canonicalCall.activationCount) &&
+        canonicalCall.activationCount >= 1 &&
+        params.head.state.activeCallId === canonicalCall.callId &&
+        params.head.policy.authority.capabilityAuthorities.includes("worker");
+    if (!isCurrentRoleCallLedgerHead(params.ledger, params.head) ||
+        !hasActiveWorkerAuthority) {
+        throw new Error("worker_payload_source_provenance_authority_invalid");
+    }
+}
+function isCanonicalRequestScopedWorker(authority) {
+    const canonicalCall = authority.head.state.calls.find(({ callId }) => callId === authority.call.callId);
+    const canonicalCaller = authority.head.state.calls.find(({ callId }) => callId === authority.caller.callId);
+    return (canonicalCall === authority.call &&
+        canonicalCaller === authority.caller &&
+        authority.call.parentCallId === authority.caller.callId &&
+        authority.caller.roleId !== "planner" &&
+        authority.caller.depth === authority.call.depth - 1);
+}
+function readWorkerPayloadRequestAuthority(provenance) {
+    if (typeof provenance !== "object" || provenance === null)
+        return undefined;
+    const descriptor = Object.getOwnPropertyDescriptor(provenance, WORKER_PAYLOAD_REQUEST_AUTHORITY);
+    if (!descriptor ||
+        descriptor.enumerable ||
+        descriptor.configurable ||
+        descriptor.writable) {
+        return undefined;
+    }
+    const authority = descriptor.value;
+    if (typeof authority !== "object" || authority === null)
+        return undefined;
+    if (!Object.isFrozen(authority))
+        return undefined;
+    const candidate = authority;
+    return candidate.receipt === provenance ? candidate : undefined;
+}

package/dist/src/runtime/plugins/manifest-validator.js

@@ -1,4 +1,5 @@
 import { isToolCatalogGroupId } from "../../capabilities/tool-types.js";
+import { parseEventResultMetadata } from "../../capabilities/tool-definition-validator/event-result-metadata.js";
 import { ABOT_RUNTIME_EXTENSION, ABOT_RUNTIME_EXTENSION_VERSION, AGENT_PLUGIN_MANIFEST_SCHEMA, } from "../../plugin-contract/manifest.js";
 const PLUGIN_NAME_PATTERN = /^(?!.*(?:--|\.\.))[a-z0-9][a-z0-9.-]{0,62}[a-z0-9]$|^[a-z0-9]$/u;
 const SECRET_ENV_PATTERN = /^[A-Z][A-Z0-9_]*$/u;
@@ -179,7 +180,8 @@ function parseEventPresentation(value, path) {
     if (value === undefined)
         return undefined;
     const presentation = expectRecord(value, path);
-    rejectUnknownKeys(presentation, ["metadata", "lifecycle"], path);
+    rejectUnknownKeys(presentation, ["metadata", "lifecycle", "resultMetadata"], path);
+    const resultMetadata = parseEventResultMetadata(presentation.resultMetadata, `${path}.resultMetadata`);
     const metadata = expectRecord(presentation.metadata, `${path}.metadata`);
     const lifecycle = presentation.lifecycle;
     if (lifecycle !== undefined && !isRecord(lifecycle)) {
@@ -232,6 +234,7 @@ function parseEventPresentation(value, path) {
                 },
             ];
         })),
+        ...(resultMetadata ? { resultMetadata } : {}),
         ...(parsedLifecycle && Object.keys(parsedLifecycle).length > 0
             ? { lifecycle: parsedLifecycle }
             : {}),

package/dist/src/runtime/ports.d.ts

@@ -51,6 +51,7 @@ export type RuntimeLongTermMemoryConfig = {
     enabled: boolean;
     emitClientEvents: boolean;
     embeddingProfileId?: string;
+    maxRecallCallsPerRequest?: number;
 };
 export type RuntimeConfig = {
     runtimeId: string;
@@ -81,12 +82,15 @@ export type RuntimeHostStartOptions = {
     toolRegistry?: ToolRegistry;
 };
 export type RuntimeHostHandle = {
+    /** Optional for custom hosts; default hosts expose scheduler startup readiness. */
+    ready?: Promise<void>;
     stop: () => Promise<void>;
 };
 export type RuntimeHost = {
     start: (options?: RuntimeHostStartOptions) => RuntimeHostHandle;
 };
 export type AppendSessionMessageOptions = {
+    schedule?: import("../sessions/schedule-metadata.js").ScheduleMessageReference;
     lastAgentMode?: AgentMode;
     grounding?: SessionMessageGrounding;
     observationMeta?: SessionMessageObservationMeta;

package/dist/src/runtime/request/bound-runtime-handler.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeEnvironmentServices, RuntimeRequestHandler } from "../composition.js";
+export declare function createBoundRuntimeRequestHandler(services: RuntimeEnvironmentServices): RuntimeRequestHandler;

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

@@ -0,0 +1,25 @@
+import { handleRunRequest } from "./handler.js";
+export function createBoundRuntimeRequestHandler(services) {
+    const environmentOptions = {
+        runtimeConfig: services.config,
+        eventSinkFactory: services.events,
+        modelGatewayClient: services.models,
+        sessionStore: services.sessions,
+        attachmentStore: services.attachments,
+        toolRegistry: services.tools,
+        sessionMemoryCompactor: services.sessionMemoryCompactor,
+        longTermMemory: services.longTermMemory,
+    };
+    return Object.freeze({
+        handle(ws, message, requestOptions = {}) {
+            const invoke = () => handleRunRequest(ws, message, {
+                ...environmentOptions,
+                ...requestOptions,
+            });
+            if (services.requestAdmission) {
+                return services.requestAdmission.run(typeof message.sessionId === "string" ? message.sessionId : "", invoke);
+            }
+            return invoke();
+        },
+    });
+}

package/dist/src/runtime/request/capability-brief.d.ts

@@ -0,0 +1,5 @@
+import type { ToolAvailabilityEntry } from "../../capabilities/tool-types.js";
+import type { WorkerCapabilityCatalogGroup } from "../orchestration/worker-capabilities/index.js";
+import type { RequestWorkerCapabilities } from "./execution-scope.js";
+/** Reuses the request registry's facts, bounded by its offered capability set. */
+export declare function resolveRequestCapabilityBriefEntries(capabilities: RequestWorkerCapabilities, groups: readonly WorkerCapabilityCatalogGroup[]): readonly ToolAvailabilityEntry[] | undefined;

package/dist/src/runtime/request/capability-brief.js

@@ -0,0 +1,24 @@
+/** Reuses the request registry's facts, bounded by its offered capability set. */
+export function resolveRequestCapabilityBriefEntries(capabilities, groups) {
+    if (groups.length === 0)
+        return undefined;
+    const availableTools = capabilities.provider.getAvailableTools?.();
+    if (availableTools === undefined)
+        return undefined;
+    const groupIds = new Set(groups.map((group) => group.groupId));
+    const offered = capabilities.provider
+        .getDescriptors()
+        .filter((descriptor) => (descriptor.catalogGroups ?? ["other"]).some((id) => groupIds.has(id)));
+    const byOperation = new Map(availableTools.map((entry) => [entry.operationId, entry]));
+    const entries = [];
+    for (const descriptor of offered) {
+        const entry = byOperation.get(descriptor.capabilityId);
+        if (entry === undefined)
+            return undefined;
+        entries.push(Object.freeze({
+            ...entry,
+            catalogGroups: Object.freeze((descriptor.catalogGroups ?? ["other"]).filter((id) => groupIds.has(id))),
+        }));
+    }
+    return Object.freeze(entries);
+}

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

@@ -1,5 +1,6 @@
 import type { ModelGatewayAttachment, ModelGatewayPolicyConfig, ModelPreference } from "../../model-gateway/types.js";
 import type { AgentMode } from "../../shared/types.js";
+import type { ScheduleMessageReference } from "../../sessions/schedule-metadata.js";
 import type { RuntimeAttachmentStore } from "../attachments/store.js";
 import type { RuntimeThinkingTrace } from "../model/thinking-trace.js";
 import type { EventSinkFactory, ModelGatewayClient, RuntimeConfig, ToolApprovalController, ToolPermissionMode, ToolRegistry } from "../ports.js";
@@ -42,6 +43,7 @@ export type RequestExecutionSeed = Readonly<{
     sessionId: string;
     prompt: string;
     temporalContext?: RequestTemporalContext;
+    scheduledExecution?: ScheduleMessageReference;
     historyMessages: readonly RequestHistoryMessage[];
     sessionArtifactPaths?: readonly string[];
     shouldGenerateSessionTitle: boolean;
@@ -56,6 +58,8 @@ export type RequestExecutionSeed = Readonly<{
     contextCompactionStore?: RequestContextCompactionStore;
     sessionMemory?: RequestSessionMemory;
     longTermMemory?: LongTermMemoryService;
+    /** Frozen request-local availability limit for explicit memory recall. */
+    memoryRecallLimit?: number;
     requestSteering?: RequestSteeringInbox;
     toolPermissionMode: ToolPermissionMode;
     toolApprovalController?: ToolApprovalController;
@@ -76,6 +80,7 @@ export type RequestIdentity = Readonly<{
 export type AcceptedRequestInput = Readonly<{
     prompt: RequestExecutionSeed["prompt"];
     temporalContext?: RequestExecutionSeed["temporalContext"];
+    scheduledExecution?: RequestExecutionSeed["scheduledExecution"];
     attachments?: RequestExecutionSeed["attachments"];
     agentMode: RequestExecutionSeed["agentMode"];
 }>;
@@ -97,6 +102,7 @@ export type RequestModelRuntime = Readonly<{
 /** Core-owned passive memory service; never part of capability execution. */
 export type RequestMemoryRuntime = Readonly<{
     longTermMemory?: RequestExecutionSeed["longTermMemory"];
+    memoryRecallLimit?: RequestExecutionSeed["memoryRecallLimit"];
 }>;
 /** Request-local cancellation, steering, capability controls, and events. */
 export type RequestLifecycleRuntime = Readonly<{

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

@@ -19,6 +19,9 @@ export const EXECUTION_AGENT_ROOT_CONTRACT = Object.freeze({
             includeTitle: options.includeTitle,
             allowPlanner: options.allowedRoleIds.includes("planner"),
             allowAuditor: options.allowedRoleIds.includes("reviewer"),
+            ...(options.memoryRecallMessage
+                ? { memoryRecallMessage: options.memoryRecallMessage }
+                : {}),
         });
         return Object.freeze({
             decision: projectKernelDecision(outcome.decision, outcome.steeringVersion),
@@ -31,6 +34,9 @@ export const EXECUTION_AGENT_ROOT_CONTRACT = Object.freeze({
             head: options.head,
             call: options.callFrame,
             steeringSnapshot: projectRequestSteeringSnapshot(requestSteering, options.steeringVersion),
+            ...(options.memoryRecallMessage
+                ? { memoryRecallMessage: options.memoryRecallMessage }
+                : {}),
         });
     },
 });
@@ -42,6 +48,12 @@ function projectKernelDecision(decision, steeringVersion) {
         ...(decision.title !== undefined ? { title: decision.title } : {}),
     };
     switch (decision.action) {
+        case "recall_memory":
+            return Object.freeze({
+                action: "recall_memory",
+                query: decision.query,
+                ...presentation,
+            });
         case "reconsider_capability_selection":
             return Object.freeze({
                 action: "reconsider_capability_selection",

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

@@ -9,6 +9,9 @@ export function createRequestSeedFacets(seed) {
         ...(seed.temporalContext !== undefined
             ? { temporalContext: seed.temporalContext }
             : {}),
+        ...(seed.scheduledExecution !== undefined
+            ? { scheduledExecution: seed.scheduledExecution }
+            : {}),
         ...(seed.attachments !== undefined
             ? { attachments: seed.attachments }
             : {}),
@@ -38,6 +41,9 @@ export function createRequestSeedFacets(seed) {
         modelGatewayClient: seed.modelGatewayClient,
     });
     const memory = Object.freeze({
+        ...(seed.memoryRecallLimit !== undefined
+            ? { memoryRecallLimit: seed.memoryRecallLimit }
+            : {}),
         ...(seed.longTermMemory !== undefined
             ? { longTermMemory: seed.longTermMemory }
             : {}),

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

@@ -53,6 +53,11 @@ export function createScopeSurface(input) {
     const { facets, policy, modelInvocation, modelSteps, capabilities } = input;
     return createFrozenSurface({
         ...requestSeedDescriptors(facets, policy.selection, true),
+        ...(facets.input.scheduledExecution !== undefined
+            ? {
+                scheduledExecution: enumerableGetter(() => facets.input.scheduledExecution),
+            }
+            : {}),
         ...(facets.session.sessionMemory !== undefined
             ? {
                 sessionMemory: enumerableGetter(() => facets.session.sessionMemory),
@@ -63,6 +68,11 @@ export function createScopeSurface(input) {
                 longTermMemory: enumerableGetter(() => facets.memory.longTermMemory),
             }
             : {}),
+        ...(facets.memory.memoryRecallLimit !== undefined
+            ? {
+                memoryRecallLimit: enumerableGetter(() => facets.memory.memoryRecallLimit),
+            }
+            : {}),
         executionPolicy: enumerableGetter(() => policy.executionPolicy),
         modelSteps: enumerableGetter(() => modelSteps),
         workerCapabilities: enumerableGetter(() => capabilities),

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

@@ -1,3 +1,4 @@
+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, RequestMemoryRuntime, RequestPresentation } from "./contracts.js";
 import type { CompiledExecutionPolicy } from "./root-contract.js";
@@ -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" | "longTermMemory">> & BoundRequestModelInvocationContext;
+export type RequestCapabilityExecutionView = Readonly<Omit<RequestExecutionSeed, "sessionArtifactPaths" | "sessionMemory" | "longTermMemory" | "memoryRecallLimit" | "scheduledExecution">> & BoundRequestModelInvocationContext;
 export type RequestWorkerCapabilities = Readonly<{
-    provider: WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView>;
+    provider: WorkerCapabilityAdapterProvider<RequestCapabilityExecutionView> & Partial<ToolAvailabilitySource>;
     executionContext: RequestCapabilityExecutionView;
 }>;
 export type RequestExecutionPolicyFacet = Readonly<{

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

@@ -6,6 +6,7 @@ import { failRequest, finalizeRequest, } from "../lifecycle/request-finalizer.js
 import { resolveModelSelection } from "../model/model-selection.js";
 import { resolveRequestDependencies } from "./dependencies.js";
 import { parseRequestInput } from "./input.js";
+import { resolveScheduledExecution } from "./scheduled-execution.js";
 import { runRequestRunner } from "./runner.js";
 import { createRequestWorkerCapabilityProvider } from "./worker-capability-composition.js";
 import { resolveRequestExecutionPolicy } from "./role-executor-composition.js";
@@ -61,6 +62,7 @@ class RequestHandlingSession {
         }
     }
     async execute() {
+        const schedule = resolveScheduledExecution(this.options, this.input);
         const { requestId, sessionId, prompt, rawAttachments, rawAgentMode, rawModelPreference, toolPermissionMode, } = this.input;
         const { eventSinkFactory, modelGatewayClient, sessionStore, attachmentStore, loadDecisionEnvironment, toolApprovalController, sessionMemoryCompactor, longTermMemory, } = this.dependencies;
         const { runnerConfig, modelPolicy, modelExecutionPolicies } = loadDecisionEnvironment();
@@ -112,15 +114,18 @@ class RequestHandlingSession {
             sessionStore,
             attachmentStore,
             events: this.events,
+            ...(schedule ? { schedule } : {}),
         });
         this.bindSteeringPersistence();
         this.enterModelStage();
         const sessionArtifactPaths = snapshotSessionArtifactPathTargets(openedSession.session.artifactPaths);
+        const memoryRecallLimit = this.options.runtimeConfig?.longTermMemory?.maxRecallCallsPerRequest;
         const runnerRequestSeed = {
             requestId,
             sessionId,
             prompt: initializedRequest.prompt,
             temporalContext: this.temporalContext,
+            ...(schedule ? { scheduledExecution: schedule } : {}),
             historyMessages,
             shouldGenerateSessionTitle: generateSessionTitle,
             runnerConfig,
@@ -139,6 +144,7 @@ class RequestHandlingSession {
             contextCompactionStore: createRequestContextCompactionStore(),
             sessionMemory,
             longTermMemory,
+            ...(memoryRecallLimit !== undefined ? { memoryRecallLimit } : {}),
             requestSteering: this.requestSteering,
             toolPermissionMode,
             ...(toolApprovalController ? { toolApprovalController } : {}),

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,4 +1,6 @@
 import type { ModelStep } from "../../shared/model-steps.js";
+import type { ChatMessage } from "../../model-gateway/types.js";
+import type { MemoryRecallDecision } from "../steps/memory-recall-decision.js";
 import type { RequestToolResultsView } from "../context/request-tool-results.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";
@@ -13,8 +15,9 @@ export type RootContractCallIdentity = Readonly<{
     depth: number;
     invocationAttempt: number;
 }>;
-export type RootContractDecision = Readonly<{
+export type RootContractDecision = MemoryRecallDecision | Readonly<{
     action: "respond";
+    responseRecommendation?: string;
     acknowledgement?: string;
     title?: string;
 }> | Readonly<{
@@ -82,15 +85,18 @@ export type RootContractAdapter<TRequest> = Readonly<{
         includeTitle: boolean;
         allowedRoleIds: readonly RuntimeDelegateRoleId[];
         availableWorkerCapabilityCatalog: readonly WorkerCapabilityCatalogGroup[];
+        memoryRecallMessage?: ChatMessage;
         resume?: RoleChildReturnContext;
     }>): Promise<RootContractDecisionOutcome>;
     authorResponse(request: TRequest, options: Readonly<{
         head: RoleCallLedgerHead;
         callFrame: RoleCallFrame;
         steeringVersion: number;
+        responseRecommendation?: string;
         call: RootContractCallIdentity;
         toolResults: RequestToolResultsView;
         resume?: RoleChildReturnContext;
+        memoryRecallMessage?: ChatMessage;
     }>): Promise<RootAuthoredResponse>;
 }>;
 export type CompiledExecutionPolicy<TRequest> = Readonly<{