@abot-ai/runtime 1.3.1 → 1.5.0

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.d.ts

@@ -6,6 +6,7 @@ import type { ExecutionPolicyAuthoritySnapshot } from "../orchestration/role-cal
 import type { RequestCapabilityCompositionView, RequestCapabilityExecutionView } from "./execution-scope.js";
 type RequestWorkerCapabilityProviderParams<TRequest> = Readonly<{
     request: TRequest;
+    requestWorkingDirectory?: string;
     executionPolicyAuthority?: ExecutionPolicyAuthoritySnapshot;
     requestAttachments?: readonly ToolRequestAttachment[];
     runtimeConfig?: RuntimeConfig;

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

@@ -14,6 +14,8 @@ export function createRequestWorkerCapabilityProvider(params) {
     function getRequestToolRegistry() {
         requestToolRegistry ??= createRequestRuntimeToolRegistry({
             request: params.request,
+            requestWorkingDirectory: params.requestWorkingDirectory,
+            toolPermissionMode: params.request.toolPermissionMode,
             ...(params.requestAttachments
                 ? { requestAttachments: params.requestAttachments }
                 : {}),
@@ -39,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

@@ -5,26 +5,29 @@ export declare function createRuntimeEnvironment(config: RuntimeConfig, override
     services: Readonly<{
         config: RuntimeConfig;
         sessions: import("./ports.js").SessionStore;
+        projects?: import("./projects/contracts.js").RuntimeProjectService;
         attachments: import("./index.js").RuntimeAttachmentStore;
         tools: import("./ports.js").ToolRegistry;
         models: import("./ports.js").ModelGatewayClient;
         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,3 +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";
@@ -13,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,
@@ -32,16 +36,36 @@ 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,
+        projects: createRuntimeProjectService(config, sessionLifecycle.store),
         attachments,
         tools,
         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,
@@ -65,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",
     ]) {

package/dist/src/runtime/scheduler/journal-index-state.d.ts

@@ -18,10 +18,10 @@ export declare function encodeJournalIndexState(state: JournalIndexState, genera
         id: string;
         requestId: string;
         sessionId: string;
+        environmentId: string;
         status: import("./contracts.js").SchedulerRunStatus;
         jobId: string;
         scheduledAt: string;
-        environmentId: string;
         jobRevision: number;
         offset: number;
         active?: SchedulerRun;

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

@@ -1,6 +1,7 @@
 import type { SchedulerRunListQuery, SchedulerSnapshot } from "./contracts.js";
 export declare class SchedulerJournalStore {
     private readonly directory;
+    private readonly onCommittedChange?;
     private index;
     private sequence;
     private generation?;
@@ -8,13 +9,14 @@ export declare class SchedulerJournalStore {
     private legacy?;
     private publicationFailure?;
     private ownedDirectoriesSynced;
-    constructor(directory: string);
+    constructor(directory: string, onCommittedChange?: (() => void) | undefined);
     load(): Promise<this>;
     prepareOwned(): Promise<void>;
     snapshot(view?: "active"): Promise<SchedulerSnapshot>;
     readRuns(jobId?: string, query?: SchedulerRunListQuery): Promise<import("./contracts.js").SchedulerRun[]>;
     update<T>(mutate: (state: SchedulerSnapshot) => T, view?: "active"): Promise<T>;
     private replaceGeneration;
+    private notifyCommittedChange;
     private ensureOwnedDirectoriesSynced;
     private publishHead;
     private requireDurablePublication;

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

@@ -10,6 +10,7 @@ import { cleanObsoleteJournalCheckpoints, loadCheckpointJournalIndex, writeJourn
 import { JournalPublicationSyncError, syncJournalDirectory, syncJournalDirectoryPath, } from "./journal-durability.js";
 export class SchedulerJournalStore {
     directory;
+    onCommittedChange;
     index = new SchedulerJournalIndex();
     sequence = 0;
     generation;
@@ -17,8 +18,9 @@ export class SchedulerJournalStore {
     legacy;
     publicationFailure;
     ownedDirectoriesSynced = false;
-    constructor(directory) {
+    constructor(directory, onCommittedChange) {
         this.directory = directory;
+        this.onCommittedChange = onCommittedChange;
     }
     async load() {
         const head = await readJournalHead(this.directory);
@@ -89,7 +91,7 @@ export class SchedulerJournalStore {
             const complete = view === "active"
                 ? applyWorkingChanges(await this.snapshot(), delta)
                 : after;
-            await this.replaceGeneration(complete);
+            await this.replaceGeneration(complete, true);
             return result;
         }
         const file = join(this.directory, this.generation, journalTransactionName(this.sequence + 1));
@@ -99,9 +101,10 @@ export class SchedulerJournalStore {
         this.index.apply(delta, file);
         this.sequence += 1;
         this.head = head;
+        this.notifyCommittedChange();
         return result;
     }
-    async replaceGeneration(snapshot) {
+    async replaceGeneration(snapshot, hasLogicalChange = false) {
         const generation = await createJournalGeneration(this.directory);
         const index = new SchedulerJournalIndex();
         let sequence = 0;
@@ -126,9 +129,19 @@ export class SchedulerJournalStore {
         this.generation = generation;
         this.head = head;
         this.legacy = undefined;
+        if (hasLogicalChange)
+            this.notifyCommittedChange();
         // Failed physical removal remains discoverable on the next explicit operation.
         await cleanObsoleteJournalGenerations(this.directory, generation);
     }
+    notifyCommittedChange() {
+        try {
+            this.onCommittedChange?.();
+        }
+        catch {
+            /* A view cannot change the outcome of a committed transaction. */
+        }
+    }
     async ensureOwnedDirectoriesSynced() {
         if (this.ownedDirectoriesSynced)
             return;

package/dist/src/runtime/scheduler/run-records.js

@@ -10,6 +10,7 @@ export function makeSchedulerRun(job, scheduledAt, trigger) {
         prompt: job.prompt,
         modelProfileId: job.modelProfileId,
         agentMode: job.agentMode,
+        toolPermissionMode: job.toolPermissionMode,
         timeZone: job.timeZone,
         jobRevision: job.revision,
         scheduledAt,

package/dist/src/runtime/scheduler/schedule-validation.js

@@ -1,3 +1,4 @@
+import { requireSchedulerToolPermissionMode } from "./tool-permission-mode.js";
 import { SchedulerValidationError } from "./validation-error.js";
 import { parseSchedulerInstant, schedulerInstantFromMilliseconds, } from "./instant-validation.js";
 export { SchedulerValidationError } from "./validation-error.js";
@@ -27,6 +28,7 @@ export function validateSchedulerJobInput(input) {
     if (!allowedModes.includes(input.agentMode)) {
         throw new SchedulerValidationError("scheduler_invalid_job", "agentMode is invalid");
     }
+    requireSchedulerToolPermissionMode(input.toolPermissionMode);
     validateTimeZone(input.timeZone);
 }
 export function validateTimeZone(timeZone) {

package/dist/src/runtime/scheduler/scheduler-engine.js

@@ -63,7 +63,7 @@ async function dispatchPendingRun(context, pending) {
     }
     if (!canBeginSchedulerRun(context, pending.jobId, pending.sessionId, epoch))
         return;
-    const release = context.executor.tryReserve(pending.sessionId);
+    const release = await context.executor.tryReserve(pending.sessionId);
     if (!release)
         return;
     let delegated = false;
@@ -148,6 +148,7 @@ function startCapturedRun(context, job, run) {
             title: run.title,
             modelProfileId: run.modelProfileId,
             agentMode: run.agentMode,
+            toolPermissionMode: run.toolPermissionMode ?? "full_access",
             timeZone: run.timeZone,
             revision: run.jobRevision,
         }, run);