@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/runtime/request/root-invalid-output.js

@@ -0,0 +1,130 @@
+import { projectInvalidOutputProgress } from "./root-invalid-output-progress.js";
+import { resolveModelOutputFailure, } from "../model/invalid-output-failure.js";
+import { ModelOutputIncompleteError } from "../model/provider-completion.js";
+import { traceDebug } from "../observability/debug-logger.js";
+import { RUNTIME_ROOT_ROLE_ID } from "../orchestration/roles.js";
+import { runModelAuthoredDegradedFinalization } from "../steps/degraded-finalization/model-authored.js";
+import { resolveRequestSteeringInbox } from "./request-steering.js";
+import { commitSupervisorResponse } from "./root-response-commit.js";
+import { resolveRoleCallTransactions } from "../orchestration/role-calls/index.js";
+/** Finalizes known model-output failures at the still-current root boundary. */
+export async function finalizeInvalidRootOutput(params) {
+    if (!isRootModelOutputStage(params.failureStage))
+        return undefined;
+    const failure = resolveRootModelOutputFailure(params.request, params.error);
+    if (!failure)
+        return undefined;
+    if (!isRootModelOutputStep(params.request, failure.modelStep))
+        return undefined;
+    params.request.abortSignal.throwIfAborted();
+    const steering = resolveRequestSteeringInbox(params.request.requestSteering);
+    const steeringVersion = failure.steeringVersion ?? params.steeringVersion;
+    if (!steering.isCurrent(steeringVersion))
+        return { kind: "continue" };
+    const head = params.ledger.current();
+    const root = head.state.calls.find((call) => call.callId === head.state.rootCallId);
+    if (!canFinalizeInvalidOutputAtActiveRoot(head, params.expectedHead, root)) {
+        return undefined;
+    }
+    traceDebug("runtime.request", "root.invalid_output.finalizing", {
+        requestId: params.request.requestId,
+        callId: root.callId,
+        sourceRevision: head.revision,
+        failureStage: params.failureStage,
+        ...failure,
+        steeringVersion,
+    });
+    const input = {
+        problem: { stage: failure.validationStage, code: failure.code },
+        progress: projectInvalidOutputProgress(head),
+    };
+    let response;
+    try {
+        response = await runModelAuthoredDegradedFinalization({
+            request: params.request,
+            input,
+            maxResponseChars: head.policy.limits.maxResponseChars,
+        });
+    }
+    catch (error) {
+        params.request.abortSignal.throwIfAborted();
+        if (!steering.isCurrent(steeringVersion))
+            return { kind: "continue" };
+        throw error;
+    }
+    params.request.abortSignal.throwIfAborted();
+    if (!steering.isCurrent(steeringVersion))
+        return { kind: "continue" };
+    if (!isInvalidOutputHeadUnchanged(params.ledger.current(), head))
+        throw params.error;
+    if (!steering.seal(steeringVersion))
+        return { kind: "continue" };
+    await params.publishDeferredTitle?.();
+    params.request.abortSignal.throwIfAborted();
+    const output = await commitSupervisorResponse({
+        transactions: resolveRoleCallTransactions(params.ledger),
+        expectedHead: head,
+        callId: root.callId,
+        response,
+    });
+    traceDebug("runtime.request", "root.invalid_output.finalized", {
+        requestId: params.request.requestId,
+        callId: root.callId,
+        code: failure.code,
+        modelStep: failure.modelStep,
+    });
+    return {
+        kind: "complete",
+        result: {
+            output,
+            ...(params.request.executionPolicy.authority.terminalTextMode === "exact"
+                ? { outputTextMode: "exact" }
+                : {}),
+        },
+    };
+}
+function resolveRootModelOutputFailure(request, error) {
+    if (!(error instanceof ModelOutputIncompleteError))
+        return resolveModelOutputFailure(error);
+    if (!error.modelStep)
+        return undefined;
+    if (!isRootAuthoredOutputStep(request, error.modelStep))
+        return undefined;
+    return Object.freeze({
+        code: error.code,
+        modelStep: error.modelStep,
+        validationStage: error.stage,
+        steeringVersion: error.steeringVersion,
+        issues: [],
+    });
+}
+function isRootModelOutputStage(stage) {
+    return stage === "decide" || stage === "compose_response";
+}
+function isRootModelOutputStep(request, modelStep) {
+    if (modelStep === "context.compact")
+        return true;
+    return isRootAuthoredOutputStep(request, modelStep);
+}
+function isRootAuthoredOutputStep(request, modelStep) {
+    const contract = request.executionPolicy.rootContract;
+    if (modelStep === contract.decisionModelStep)
+        return true;
+    return modelStep === contract.responseModelStep;
+}
+function canFinalizeInvalidOutputAtActiveRoot(head, expectedHead, root) {
+    if (!isInvalidOutputHeadUnchanged(head, expectedHead))
+        return false;
+    if (!root)
+        return false;
+    if (root.roleId !== RUNTIME_ROOT_ROLE_ID)
+        return false;
+    if (root.status !== "active")
+        return false;
+    if (head.state.activeCallId !== root.callId)
+        return false;
+    return head.state.phase === "running";
+}
+function isInvalidOutputHeadUnchanged(head, expectedHead) {
+    return head === expectedHead;
+}

package/dist/src/runtime/request/root-response-commit.d.ts

@@ -0,0 +1,7 @@
+import type { RoleCallLedgerHead, RoleCallTransactions } from "../orchestration/role-calls/index.js";
+export declare function commitSupervisorResponse(params: {
+    transactions: RoleCallTransactions;
+    expectedHead: RoleCallLedgerHead;
+    callId: string;
+    response: string;
+}): Promise<string>;

package/dist/src/runtime/request/root-response-commit.js

@@ -0,0 +1,15 @@
+export async function commitSupervisorResponse(params) {
+    const committed = await params.transactions.completeRootResponse({
+        expectedHead: params.expectedHead,
+        callId: params.callId,
+        response: params.response,
+    });
+    if (!committed.ok) {
+        throw new Error(`role_call_ledger_rejected:${committed.issueCode}`);
+    }
+    const output = committed.commit.head.state.rootResponse;
+    if (!output) {
+        throw new Error("supervisor_root_response_missing");
+    }
+    return output;
+}

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

@@ -1,6 +1,18 @@
+import type { BoundApprovalDecision } from "../orchestration/worker-capabilities/approval-contracts.js";
+import { type RequestApprovalContinuation, type RequestRunnerOutcome } from "./approval-continuation.js";
 import type { RequestRunnerResult } from "./result.js";
 import { type RequestArtifactPathPersistence } from "./session-artifact-path-persistence.js";
 import { type RequestExecutionScope } from "./execution-scope.js";
-export declare function runRequestRunner(request: RequestExecutionScope, options?: Readonly<{
+type RequestRunnerOptions = Readonly<{
     persistArtifactPaths?: RequestArtifactPathPersistence;
-}>): Promise<RequestRunnerResult>;
+    durableApproval?: boolean;
+    continuation?: RequestApprovalContinuation;
+    decisions?: readonly BoundApprovalDecision[];
+}>;
+export declare function runRequestRunner(request: RequestExecutionScope, options: RequestRunnerOptions & {
+    durableApproval: true;
+}): Promise<RequestRunnerOutcome>;
+export declare function runRequestRunner(request: RequestExecutionScope, options?: RequestRunnerOptions & {
+    durableApproval?: false;
+}): Promise<RequestRunnerResult>;
+export {};

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

@@ -1,18 +1,14 @@
-import { createRoleCallLedger, ROLE_CALL_OBJECTIVE_MAX_LENGTH, ROLE_CALL_RESPONSE_MAX_LENGTH, ROLE_CALL_RESULT_MAX_LENGTH, resolveRoleCallTransactions, } from "../orchestration/role-calls/index.js";
+import { createRequestRoleCallPolicy } from "./role-call-policy.js";
+import { restoreApprovalExecutionFreshness } from "./capability-execution-freshness.js";
+import { captureRoleCallLedgerCheckpoint } from "../orchestration/role-calls/checkpoint.js";
+import { isRoleApprovalWait } from "../orchestration/role-executors/approval-continuation.js";
+import { resumeCapabilityApprovalGroup } from "../orchestration/worker-capabilities/execution/approval-group.js";
+import { createRoleApprovalContinuation, validateRequestApprovalContinuation, } from "./approval-continuation.js";
+import { createRoleCallLedger, resolveRoleCallTransactions, } from "../orchestration/role-calls/index.js";
 import { traceDebug } from "../observability/debug-logger.js";
 import { attachRequestPlannerRoleCallEvents } from "./role-call-planner-events.js";
 import { runRootExecutionKernel } from "./root-execution-kernel.js";
 import { persistSettledSessionArtifactPaths, } from "./session-artifact-path-persistence.js";
-const INITIAL_ROLE_CALL_LIMITS = Object.freeze({
-    limits: Object.freeze({
-        maxDepth: 12,
-        maxCalls: 48,
-        maxCapabilityExecutions: 96,
-        maxObjectiveChars: ROLE_CALL_OBJECTIVE_MAX_LENGTH,
-        maxResultChars: ROLE_CALL_RESULT_MAX_LENGTH,
-        maxResponseChars: ROLE_CALL_RESPONSE_MAX_LENGTH,
-    }),
-});
 export async function runRequestRunner(request, options = {}) {
     const executionPolicy = request.executionPolicy;
     if (request.executionPolicySelection?.policy !== undefined &&
@@ -32,10 +28,10 @@ export async function runRequestRunner(request, options = {}) {
     });
     const ledger = createRoleCallLedger({
         requestId: request.requestId,
-        policy: Object.freeze({
-            authority: executionPolicy.authority,
-            limits: INITIAL_ROLE_CALL_LIMITS.limits,
-        }),
+        ...(options.continuation
+            ? { checkpoint: options.continuation.ledger }
+            : {}),
+        policy: createRequestRoleCallPolicy(executionPolicy),
     });
     attachRequestPlannerRoleCallEvents({
         ledger,
@@ -43,15 +39,35 @@ export async function runRequestRunner(request, options = {}) {
     });
     let result;
     try {
-        const created = await resolveRoleCallTransactions(ledger).createRoot({
-            expectedHead: ledger.current(),
-        });
-        if (!created.ok) {
-            throw new Error(`role_call_ledger_rejected:${created.issueCode}`);
+        let continuation;
+        if (options.continuation) {
+            validateRequestApprovalContinuation(options.continuation, ledger, request.workerCapabilities.provider.getDescriptors());
+            const executionFreshness = restoreApprovalExecutionFreshness(options.continuation.preparedGroup.executionFreshnessToken, request.requestSteering);
+            const settled = await resumeCapabilityApprovalGroup({
+                ...(executionFreshness ? { executionFreshness } : {}),
+                ledger,
+                context: request.workerCapabilities.executionContext,
+                adapters: request.workerCapabilities.provider.getAdapters(),
+                group: options.continuation.preparedGroup,
+                decisions: options.decisions ?? [],
+            });
+            continuation = createRoleApprovalContinuation(options.continuation, settled.executionIds);
+        }
+        else {
+            const created = await resolveRoleCallTransactions(ledger).createRoot({
+                expectedHead: ledger.current(),
+            });
+            if (!created.ok)
+                throw new Error(`role_call_ledger_rejected:${created.issueCode}`);
         }
         result = await runRootExecutionKernel({
             request,
             ledger,
+            durableApproval: true,
+            ...(continuation ? { continuation } : {}),
+            ...(options.continuation
+                ? { presentation: options.continuation.root }
+                : {}),
         });
     }
     catch (error) {
@@ -65,6 +81,27 @@ export async function runRequestRunner(request, options = {}) {
         });
         throw error;
     }
+    if (isRoleApprovalWait(result)) {
+        if (!options.durableApproval)
+            throw new Error("request_durable_approval_not_enabled");
+        const continuation = Object.freeze({
+            kind: "request_approval_continuation_v1",
+            ledger: captureRoleCallLedgerCheckpoint(ledger),
+            root: result.root,
+            callers: result.callers,
+            preparedGroup: result.group,
+        });
+        validateRequestApprovalContinuation(continuation, ledger, request.workerCapabilities.provider.getDescriptors());
+        await persistSettledSessionArtifactPaths({
+            head: ledger.current(),
+            sessionId: request.sessionId,
+            trigger: "approval_wait",
+            ...(options.persistArtifactPaths
+                ? { persistArtifactPaths: options.persistArtifactPaths }
+                : {}),
+        });
+        return Object.freeze({ kind: "awaiting_approval", continuation });
+    }
     await persistSettledSessionArtifactPaths({
         head: ledger.current(),
         sessionId: request.sessionId,
@@ -73,7 +110,10 @@ export async function runRequestRunner(request, options = {}) {
             ? { persistArtifactPaths: options.persistArtifactPaths }
             : {}),
     });
-    return deliverAnswer(request, result);
+    const delivered = deliverAnswer(request, result);
+    if (options.durableApproval)
+        return Object.freeze({ kind: "completed", result: delivered });
+    return delivered;
 }
 function deliverAnswer(request, result) {
     request.onAnswerToken(result.output);

package/dist/src/runtime/request/session-admission.d.ts

@@ -1,14 +1,16 @@
 /** Coordinates background admission with requests from every environment caller. */
 export declare class SessionRequestAdmission {
     private readonly isDeleted;
+    private readonly hasSavedWait?;
     private readonly active;
     private readonly reserved;
     private readonly waiters;
     private readonly idleWaiters;
     private closed;
-    constructor(isDeleted: (sessionId: string) => boolean);
+    constructor(isDeleted: (sessionId: string) => boolean, hasSavedWait?: ((sessionId: string) => Promise<boolean>) | undefined);
+    tryReserveAvailable(sessionId: string): Promise<(() => void) | null>;
     tryReserve(sessionId: string): (() => void) | null;
-    run<T>(sessionId: string, execute: () => Promise<T>): Promise<T>;
+    run<T>(sessionId: string, execute: () => Promise<T>, resume?: boolean): Promise<T>;
     close(): void;
     whenIdle(): Promise<void>;
     private requireOpenAdmission;

package/dist/src/runtime/request/session-admission.js

@@ -1,13 +1,20 @@
 /** Coordinates background admission with requests from every environment caller. */
 export class SessionRequestAdmission {
     isDeleted;
+    hasSavedWait;
     active = new Map();
     reserved = new Set();
     waiters = new Map();
     idleWaiters = new Set();
     closed = false;
-    constructor(isDeleted) {
+    constructor(isDeleted, hasSavedWait) {
         this.isDeleted = isDeleted;
+        this.hasSavedWait = hasSavedWait;
+    }
+    async tryReserveAvailable(sessionId) {
+        if (await this.hasSavedWait?.(sessionId))
+            return null;
+        return this.tryReserve(sessionId);
     }
     tryReserve(sessionId) {
         if (this.closed)
@@ -31,9 +38,10 @@ export class SessionRequestAdmission {
             this.notifyIdle();
         };
     }
-    async run(sessionId, execute) {
+    async run(sessionId, execute, resume = false) {
         this.requireOpenAdmission();
         while (this.reserved.has(sessionId)) {
+            // Even a cancelled request must wait before changing session history.
             await new Promise((resolve) => {
                 const waiting = this.waiters.get(sessionId) ?? new Set();
                 waiting.add(resolve);
@@ -41,6 +49,9 @@ export class SessionRequestAdmission {
             });
             this.requireOpenAdmission();
         }
+        if (!resume && this.hasSavedWait && (await this.hasSavedWait(sessionId)))
+            throw new Error("session_awaiting_approval");
+        this.requireOpenAdmission();
         if (this.isDeleted(sessionId))
             throw new Error("session_deleted");
         this.active.set(sessionId, (this.active.get(sessionId) ?? 0) + 1);

package/dist/src/runtime/request/session-artifact-path-persistence.d.ts

@@ -6,6 +6,6 @@ export declare function snapshotSessionArtifactPathTargets(artifactPaths: readon
 export declare function persistSettledSessionArtifactPaths(params: {
     head: RoleCallLedgerHead;
     sessionId: string;
-    trigger: "root_succeeded" | "root_failed";
+    trigger: "root_succeeded" | "root_failed" | "approval_wait";
     persistArtifactPaths?: RequestArtifactPathPersistence;
 }): Promise<void>;

package/dist/src/runtime/request/session-store.d.ts

@@ -1,2 +1,2 @@
 import type { SessionStore } from "../ports.js";
-export type RequestSessionStore = Pick<SessionStore, "appendMessage" | "appendContextEntry" | "appendRequestEvent" | "compareAndSwapSessionMemoryCheckpoint" | "getOrCreateSession" | "startRequestStream" | "upsertArtifactPaths" | "updateSessionTitle">;
+export type RequestSessionStore = Pick<SessionStore, "appendMessage" | "appendContextEntry" | "appendRequestEvent" | "compareAndSwapSessionMemoryCheckpoint" | "getOrCreateSession" | "startRequestStream" | "upsertArtifactPaths" | "updateSessionTitle" | "requestLifecycle">;

package/dist/src/runtime/request/tool-approval-wait.d.ts

@@ -0,0 +1,4 @@
+import type { ToolApprovalController } from "../ports.js";
+import type { RequestLifecycle } from "../orchestration/lifecycle/request-lifecycle.js";
+/** Decorate the approval boundary without changing approval authority. */
+export declare function withToolApprovalWait(controller: ToolApprovalController, lifecycle: RequestLifecycle): ToolApprovalController;

package/dist/src/runtime/request/tool-approval-wait.js

@@ -0,0 +1,14 @@
+/** Decorate the approval boundary without changing approval authority. */
+export function withToolApprovalWait(controller, lifecycle) {
+    return {
+        async requestToolApproval(request, options) {
+            const releaseWait = lifecycle.beginToolApprovalWait();
+            try {
+                return await controller.requestToolApproval(request, options);
+            }
+            finally {
+                releaseWait();
+            }
+        },
+    };
+}

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

@@ -41,6 +41,7 @@ export function createRequestWorkerCapabilityProvider(params) {
     const provider = createRegisteredToolWorkerCapabilityProvider({
         getRequestToolRegistry,
         requestId: params.request.requestId,
+        ...(params.request.toolResources ? { toolResources: params.request.toolResources } : {}),
         sessionId: params.request.sessionId,
         requestContext: Object.freeze({
             agentMode: params.request.agentMode,

package/dist/src/runtime/runtime-environment.d.ts

@@ -12,20 +12,22 @@ export declare function createRuntimeEnvironment(config: RuntimeConfig, override
         events: EventSinkFactory;
         sessionMemoryCompactor: import("./context/session-memory/contracts.js").SessionMemoryCompactor;
         longTermMemory: import("./index.js").LongTermMemoryService;
+        passiveLearning?: import("./passive-learning/contracts.js").PassiveLearningService;
         scheduler?: import("./index.js").SchedulerService;
         startScheduler?: () => Promise<void>;
         stopScheduler?: () => Promise<void>;
         requestAdmission?: SessionRequestAdmission;
     }>;
     requests: Readonly<{
+        cancel?: (requestId: string, sessionId: string, wait?: import("./request/cancellation.js").SavedWaitCancellation) => Promise<import("./request/cancellation.js").RequestCancellationResult>;
         steer?: (requestId: string, input: Readonly<{
             steerId: string;
             text: string;
         }>) => Promise<import("./request/request-steering.js").RequestSteeringAppendResult>;
-        handle: (ws: import("ws").default, message: import("./request/contracts.js").RunRequestMessage, options?: import("./composition.js").RuntimeRequestOptions) => Promise<void>;
+        handle: (ws: import("ws").default, message: import("./request/contracts.js").RunRequestMessage, options?: import("./composition.js").RuntimeRequestOptions) => Promise<import("./request/handler.js").RequestHandlerOutcome>;
     }>;
-    start: () => Promise<void>;
-    stop: () => Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
     subscribeScheduledEvents: (listener: (event: import("./adapters/scheduled-request-outcome.js").ScheduledRequestEvent) => void) => () => void;
 };
 export declare function recomposeRuntimeEnvironment(config: RuntimeConfig, bound: RuntimeEnvironmentServices | undefined, resolved: RuntimeApplicationOverrides): RuntimeEnvironmentServices;

package/dist/src/runtime/runtime-environment.js

@@ -1,4 +1,6 @@
 import { createRuntimeProjectService } from "./projects/service.js";
+import { traceDebug } from "./observability/debug-logger.js";
+import { createRuntimePassiveLearning } from "./adapters/passive-learning-runtime.js";
 import { createDefaultAttachmentStore, createDefaultEventSinkFactory, createDefaultModelGatewayClient, createDefaultLongTermMemoryService, createDefaultSessionStore, createDefaultToolRegistry, } from "./default-environment-adapters.js";
 import { createBoundRuntimeRequestHandler } from "./request/bound-runtime-handler.js";
 import { createModelSessionMemoryCompactor } from "./context/session-memory/index.js";
@@ -14,7 +16,8 @@ export function createRuntimeEnvironment(config, overrides = {}) {
     const attachments = overrides.attachments ?? createDefaultAttachmentStore(config);
     const sessionLifecycle = createSessionLifecycleStore(backingSessions, (result) => deleteSessionAttachmentsIfSupported(attachments, result.sessionId));
     bindManagedSessionAttachmentDeletion(sessionLifecycle.store, attachments);
-    const admission = new SessionRequestAdmission(sessionLifecycle.isDeleted);
+    const admission = new SessionRequestAdmission(sessionLifecycle.isDeleted, async (sessionId) => Boolean((await sessionLifecycle.store.requestLifecycle?.listWaiting(sessionId))
+        ?.length));
     const scheduling = createRuntimeScheduler({
         config,
         sessions: sessionLifecycle.store,
@@ -33,6 +36,25 @@ export function createRuntimeEnvironment(config, overrides = {}) {
             ready: scheduling.ensureStarted,
         });
     const models = overrides.models ?? createDefaultModelGatewayClient(config);
+    const longTermMemory = overrides.longTermMemory ??
+        createDefaultLongTermMemoryService(config, models);
+    const passiveLearning = overrides.passiveLearning ??
+        createRuntimePassiveLearning({
+            config,
+            models,
+            memory: longTermMemory,
+            sessions: sessionLifecycle.store,
+        });
+    sessionLifecycle.onDeleted(async (sessionId) => {
+        try {
+            await passiveLearning.sessionDeleted?.(sessionId);
+        }
+        catch {
+            traceDebug("runtime.passive_learning", "proposal.session_cleanup_failed", {
+                reason: "proactive_session_cleanup_failed",
+            });
+        }
+    });
     const services = Object.freeze({
         config,
         sessions: sessionLifecycle.store,
@@ -42,8 +64,8 @@ export function createRuntimeEnvironment(config, overrides = {}) {
         models,
         events: overrides.events ?? createDefaultEventSinkFactory(config),
         sessionMemoryCompactor: overrides.sessionMemoryCompactor ?? createModelSessionMemoryCompactor(),
-        longTermMemory: overrides.longTermMemory ??
-            createDefaultLongTermMemoryService(config, models),
+        longTermMemory,
+        passiveLearning,
         scheduler: scheduling.scheduler,
         startScheduler: scheduling.start,
         stopScheduler: scheduling.stop,
@@ -67,11 +89,37 @@ export function createRuntimeEnvironment(config, overrides = {}) {
             });
         },
     });
+    let unsubscribeInjectedLearning;
     return {
         services,
         requests,
-        start: scheduling.start,
-        stop: scheduling.stop,
+        async start() {
+            await scheduling.start();
+            await longTermMemory.retention?.start();
+            const notifyInjectedLearning = overrides.passiveLearning?.notifyKnowledgeChanged;
+            if (notifyInjectedLearning) {
+                unsubscribeInjectedLearning ??= longTermMemory.subscribeChanges?.(() => {
+                    overrides.passiveLearning.notifyKnowledgeChanged();
+                });
+            }
+            try {
+                await passiveLearning.start();
+            }
+            catch (error) {
+                unsubscribeInjectedLearning?.();
+                unsubscribeInjectedLearning = undefined;
+                throw error;
+            }
+        },
+        async stop() {
+            unsubscribeInjectedLearning?.();
+            unsubscribeInjectedLearning = undefined;
+            await Promise.all([
+                passiveLearning.stop(),
+                scheduling.stop(),
+                longTermMemory.retention?.stop(),
+            ]);
+        },
         subscribeScheduledEvents: scheduling.subscribe,
     };
 }

package/dist/src/runtime/runtime-host-scheduler-ownership.js

@@ -17,7 +17,11 @@ export function acquireHostScheduler(services) {
         }
         if (owner.started) {
             owner.stopping = (async () => {
-                await services?.stopScheduler?.();
+                await Promise.all([
+                    services?.stopScheduler?.(),
+                    services?.passiveLearning?.stop(),
+                    services?.longTermMemory?.retention?.stop(),
+                ]);
             })();
         }
         owner.stopping ??= Promise.resolve();
@@ -61,6 +65,13 @@ function retainSchedulerOwner(key, services) {
             return;
         owner.started = true;
         await services.startScheduler?.();
+        if (!hasSchedulerHostReferences(owner))
+            return;
+        await services.longTermMemory?.retention?.start();
+        if (!hasSchedulerHostReferences(owner))
+            return;
+        // The compatibility host owns the environment's background learning too.
+        await services.passiveLearning?.start();
     };
     owner.ready = previous?.stopping ? previous.stopping.then(start) : start();
     return owner;

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

@@ -1,4 +1,5 @@
 import type { AgentMode } from "../../shared/types.js";
+import type { SchedulerToolPermissionMode } from "./tool-permission-mode.js";
 export type SchedulerScheduleInput = {
     kind: "timer";
     delayMs: number;
@@ -53,7 +54,7 @@ export interface SchedulerJob {
     prompt: string;
     modelProfileId: string;
     agentMode: AgentMode;
-    toolPermissionMode: "full_access";
+    toolPermissionMode: SchedulerToolPermissionMode;
     timeZone: string;
     schedule: SchedulerSchedule;
     state: SchedulerJobState;
@@ -63,6 +64,7 @@ export interface SchedulerJob {
     revision: number;
 }
 export interface CreateSchedulerJobInput {
+    toolPermissionMode?: SchedulerToolPermissionMode;
     sessionId: string;
     title: string;
     prompt: string;
@@ -74,6 +76,8 @@ export interface CreateSchedulerJobInput {
 export type UpdateSchedulerJobInput = Partial<Omit<CreateSchedulerJobInput, "sessionId">>;
 export type SchedulerRunStatus = "pending" | "running" | "succeeded" | "failed" | "cancelled" | "interrupted" | "missed";
 export interface SchedulerRun {
+    /** Omitted by historical runs, which always used Full. */
+    toolPermissionMode?: SchedulerToolPermissionMode;
     id: string;
     jobId: string;
     environmentId: string;
@@ -102,7 +106,7 @@ export interface SchedulerRunOutcome {
 }
 export interface SchedulerExecutor {
     sessionExists(sessionId: string): Promise<boolean>;
-    tryReserve(sessionId: string): (() => void) | null;
+    tryReserve(sessionId: string): (() => void) | null | Promise<(() => void) | null>;
     start(job: SchedulerJob, run: SchedulerRun): Promise<SchedulerRunOutcome>;
 }
 export interface SchedulerSnapshot {

package/dist/src/runtime/scheduler/file-store.d.ts

@@ -1,2 +1,2 @@
 import type { SchedulerStore } from "./contracts.js";
-export declare function createFileSchedulerStore(directory: string): SchedulerStore;
+export declare function createFileSchedulerStore(directory: string, onCommittedChange?: () => void): SchedulerStore;

package/dist/src/runtime/scheduler/file-store.js

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { acquireFileLock } from "../adapters/long-term-memory/file-lock/acquisition.js";
 import { SchedulerJournalStore } from "./journal-store.js";
 import { journalReadIdentity, readJournalHead } from "./journal-head.js";
-export function createFileSchedulerStore(directory) {
+export function createFileSchedulerStore(directory, onCommittedChange) {
     let releaseOwner;
     let journal;
     let transactionTail = Promise.resolve();
@@ -43,7 +43,7 @@ export function createFileSchedulerStore(directory) {
                 throw error;
             }
             try {
-                journal = await new SchedulerJournalStore(directory).load();
+                journal = await new SchedulerJournalStore(directory, onCommittedChange).load();
                 await journal.prepareOwned();
             }
             catch (error) {

package/dist/src/runtime/scheduler/job-management.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { requireSchedulerToolPermissionMode } from "./tool-permission-mode.js";
 import { nextSchedulerOccurrence } from "./next-occurrence.js";
 import { normalizeSchedulerScheduleUpdate } from "./schedule-update.js";
 import { requireRepresentableIntervalRecurrence } from "./interval-range.js";
@@ -24,7 +25,7 @@ export function createSchedulerJob(context, input) {
             prompt: input.prompt,
             modelProfileId: input.modelProfileId,
             agentMode: input.agentMode,
-            toolPermissionMode: "full_access",
+            toolPermissionMode: requireSchedulerToolPermissionMode(input.toolPermissionMode),
             timeZone: input.timeZone,
             schedule,
             state: "active",
@@ -71,7 +72,6 @@ export function updateSchedulerJob(context, jobId, patch) {
             Object.assign(job, editable, {
                 schedule,
                 nextRunAt,
-                toolPermissionMode: "full_access",
                 updatedAt: new Date(now).toISOString(),
                 revision: job.revision + 1,
             });
@@ -107,6 +107,7 @@ function hasSchedulerJobChanges(job, candidate) {
         "prompt",
         "modelProfileId",
         "agentMode",
+        "toolPermissionMode",
         "timeZone",
     ].some((field) => job[field] !== candidate[field]);
 }
@@ -117,6 +118,7 @@ function pickEditableFields(patch) {
         "prompt",
         "modelProfileId",
         "agentMode",
+        "toolPermissionMode",
         "timeZone",
         "schedule",
     ]) {