@abot-ai/runtime 1.4.0 → 1.6.0

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

@@ -1,10 +1,15 @@
+import { changeAutomationSchedulerJobState, createAutomationSchedulerJob, requestAutomationSchedulerRunNow, updateAutomationSchedulerJob, } from "./automation-job-management.js";
+import { stopAutomationSchedulerRun } from "./automation-run-control.js";
+import { requestAutomationSchedulerRerun } from "./automation-rerun.js";
 import { changeSchedulerJobState, createSchedulerJob, deleteSchedulerSession, matchesSchedulerFilter, requestSchedulerRunNow, updateSchedulerJob, } from "./job-management.js";
 import { tickScheduler } from "./scheduler-engine.js";
 import { requireRunningScheduler, } from "./service-context.js";
 import { recoverSchedulerSnapshot } from "./startup-recovery.js";
 import { querySchedulerRuns } from "./run-list-query.js";
 import { createSchedulerWorkingStore } from "./working-store.js";
+import { observeAutomationRunChanges } from "./automation-run-change-events.js";
 import { SchedulerSessionDeletionState } from "./session-deletion-state.js";
+import { isAutomationSchedulerJob, isAutomationSchedulerRun, isRequestSchedulerJob, isRequestSchedulerRun, } from "./scheduler-target.js";
 export function createSchedulerService(options) {
     let tail = Promise.resolve();
     let releaseOwner;
@@ -12,8 +17,11 @@ export function createSchedulerService(options) {
     let ticking;
     const context = {
         environmentId: options.environmentId,
-        store: createSchedulerWorkingStore(options.store),
+        store: options.onAutomationRunChange
+            ? observeAutomationRunChanges(createSchedulerWorkingStore(options.store), options.onAutomationRunChange)
+            : createSchedulerWorkingStore(options.store),
         executor: options.executor,
+        automationExecutor: options.automationExecutor,
         now: options.now ?? Date.now,
         running: false,
         generation: 0,
@@ -21,6 +29,7 @@ export function createSchedulerService(options) {
         pendingJobMutations: new Set(),
         deletedSessions: new SchedulerSessionDeletionState(),
         pendingCompletions: new Map(),
+        pendingAutomationCompletions: new Map(),
         enqueue: (operation) => {
             const result = tail.then(operation);
             tail = result.catch(() => undefined);
@@ -39,9 +48,25 @@ export function createSchedulerService(options) {
                 const release = await options.store.acquire();
                 releaseOwner = release;
                 try {
-                    await context.store.update((state) => {
-                        recoverSchedulerSnapshot(state, options.environmentId, context.now());
-                    });
+                    const automationExecutor = options.automationExecutor;
+                    if (automationExecutor) {
+                        const update = context.store.updateWithAutomations;
+                        if (!update)
+                            throw new Error("automation_store_unavailable");
+                        await update((state, automations) => {
+                            const recovered = recoverSchedulerSnapshot(state, options.environmentId, context.now());
+                            automationExecutor.recover(state, automations, recovered);
+                            requireRecoveredAutomationReports(state, automations, recovered);
+                        });
+                        await automationExecutor.reconcileSessions?.().catch(context.onError);
+                    }
+                    else {
+                        await context.store.update((state) => {
+                            if (state.jobs.some(isAutomationSchedulerJob))
+                                throw new Error("automation_executor_unavailable");
+                            recoverSchedulerSnapshot(state, options.environmentId, context.now());
+                        });
+                    }
                     if (requestedGeneration !== context.generation) {
                         await release();
                         releaseOwner = undefined;
@@ -65,6 +90,7 @@ export function createSchedulerService(options) {
             context.generation += 1;
             context.running = false;
             context.pendingCompletions.clear();
+            context.pendingAutomationCompletions.clear();
             if (timer)
                 clearInterval(timer);
             timer = undefined;
@@ -90,11 +116,13 @@ export function createSchedulerService(options) {
         create: (input) => createSchedulerJob(context, input),
         list: (filter = {}) => context.enqueue(async () => {
             requireRunningScheduler(context);
-            return (await context.store.read()).jobs.filter((job) => matchesSchedulerFilter(job, filter));
+            return (await context.store.read()).jobs
+                .filter(isRequestSchedulerJob)
+                .filter((job) => matchesSchedulerFilter(job, filter));
         }),
         get: (jobId) => context.enqueue(async () => {
             requireRunningScheduler(context);
-            return ((await context.store.read()).jobs.find((job) => job.id === jobId) ??
+            return ((await context.store.read()).jobs.find((job) => isRequestSchedulerJob(job) && job.id === jobId) ??
                 null);
         }),
         update: (jobId, patch) => updateSchedulerJob(context, jobId, patch),
@@ -105,11 +133,56 @@ export function createSchedulerService(options) {
         deleteSession: (sessionId) => deleteSchedulerSession(context, sessionId),
         listRuns: (jobId, query) => context.enqueue(async () => {
             requireRunningScheduler(context);
-            if (options.store.readRuns)
-                return options.store.readRuns(jobId, query);
-            const runs = (await options.store.read()).runs;
-            return querySchedulerRuns(runs, jobId, query);
+            const runs = options.store.readRuns
+                ? await options.store.readRuns(jobId, query, "request")
+                : (await options.store.read()).runs;
+            return querySchedulerRuns(runs.filter(isRequestSchedulerRun), jobId, options.store.readRuns ? undefined : query);
+        }),
+        createAutomationJob: (input, commitPublication) => createAutomationSchedulerJob(context, input, commitPublication),
+        getAutomationJob: (automationId) => context.enqueue(async () => {
+            requireRunningScheduler(context);
+            return ((await context.store.read()).jobs.find((job) => isAutomationSchedulerJob(job) &&
+                job.target.automationId === automationId) ?? null);
+        }),
+        listAutomationJobs: () => context.enqueue(async () => {
+            requireRunningScheduler(context);
+            return (await context.store.read()).jobs.filter(isAutomationSchedulerJob);
+        }),
+        updateAutomationJob: (jobId, patch, commitPublication) => updateAutomationSchedulerJob(context, jobId, patch, commitPublication),
+        pauseAutomationJob: (jobId) => changeAutomationSchedulerJobState(context, jobId, "paused"),
+        resumeAutomationJob: (jobId) => changeAutomationSchedulerJobState(context, jobId, "active"),
+        runNowAutomation: (jobId, runOptions) => requestAutomationSchedulerRunNow(context, jobId, runOptions),
+        rerunAutomationRun: (previousRunId, runOptions) => requestAutomationSchedulerRerun(context, previousRunId, runOptions),
+        stopAutomationRun: (runId) => stopAutomationSchedulerRun(context, runId),
+        listAutomationRuns: (automationId, query) => context.enqueue(async () => {
+            requireRunningScheduler(context);
+            const job = (await context.store.read()).jobs.find((item) => isAutomationSchedulerJob(item) &&
+                item.target.automationId === automationId);
+            if (!job)
+                return [];
+            const boundedQuery = query ?? { limit: 100 };
+            const runs = options.store.readRuns
+                ? await options.store.readRuns(job.id, boundedQuery, "automation")
+                : (await options.store.read()).runs;
+            return querySchedulerRuns(runs.filter(isAutomationSchedulerRun), job.id, options.store.readRuns ? undefined : boundedQuery);
+        }),
+        getAutomationRun: (runId) => context.enqueue(async () => {
+            requireRunningScheduler(context);
+            const run = options.store.readRun
+                ? await options.store.readRun(runId)
+                : (await options.store.read()).runs.find((item) => item.id === runId);
+            return run && isAutomationSchedulerRun(run) ? run : null;
         }),
     };
     return service;
 }
+function requireRecoveredAutomationReports(scheduler, automations, runIds) {
+    for (const runId of runIds) {
+        const run = scheduler.runs.find((item) => item.id === runId);
+        if (!run || !isAutomationSchedulerRun(run) || !run.reportRef)
+            throw new Error("automation_report_missing");
+        const execution = automations.executions.find((item) => item.id === runId);
+        if (execution?.reportRef !== run.reportRef)
+            throw new Error("automation_report_missing");
+    }
+}

package/dist/src/runtime/scheduler/scheduler-target.d.ts

@@ -0,0 +1,9 @@
+import type { SchedulerAutomationJob, SchedulerAutomationRun, SchedulerJob, SchedulerRun, SchedulerStoredJob, SchedulerStoredRun } from "./contracts.js";
+export declare function isAutomationSchedulerJob(job: SchedulerStoredJob): job is SchedulerAutomationJob;
+export declare function isRequestSchedulerJob(job: SchedulerStoredJob): job is SchedulerJob;
+export declare function isAutomationSchedulerRun(run: SchedulerStoredRun): run is SchedulerAutomationRun;
+export declare function isRequestSchedulerRun(run: SchedulerStoredRun): run is SchedulerRun;
+export declare function requireRequestSchedulerJob(job: SchedulerStoredJob): SchedulerJob;
+export declare function requireRequestSchedulerRun(run: SchedulerStoredRun): SchedulerRun;
+export declare function sameSchedulerTarget(job: SchedulerStoredJob, run: SchedulerStoredRun): boolean;
+export declare function schedulerTargetKey(value: SchedulerStoredJob | SchedulerStoredRun): string;

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

@@ -0,0 +1,41 @@
+export function isAutomationSchedulerJob(job) {
+    return job.target?.kind === "automation";
+}
+export function isRequestSchedulerJob(job) {
+    return !isAutomationSchedulerJob(job);
+}
+export function isAutomationSchedulerRun(run) {
+    return run.target?.kind === "automation";
+}
+export function isRequestSchedulerRun(run) {
+    return !isAutomationSchedulerRun(run);
+}
+export function requireRequestSchedulerJob(job) {
+    if (!isRequestSchedulerJob(job))
+        throw new Error("scheduler_request_job_required");
+    return job;
+}
+export function requireRequestSchedulerRun(run) {
+    if (!isRequestSchedulerRun(run))
+        throw new Error("scheduler_request_run_required");
+    return run;
+}
+export function sameSchedulerTarget(job, run) {
+    if (isAutomationSchedulerJob(job)) {
+        if (!isAutomationSchedulerRun(run))
+            return false;
+        if (job.target.automationId !== run.target.automationId)
+            return false;
+        return run.target.definitionRevision <= job.target.definitionRevision;
+    }
+    if (!isRequestSchedulerRun(run))
+        return false;
+    return job.sessionId === run.sessionId;
+}
+export function schedulerTargetKey(value) {
+    if (value.target?.kind === "automation")
+        return `automation:${value.target.automationId}`;
+    if (!("sessionId" in value))
+        throw new Error("scheduler_store_corrupt");
+    return `session:${value.sessionId}`;
+}

package/dist/src/runtime/scheduler/service-context.d.ts

@@ -1,10 +1,12 @@
-import type { SchedulerExecutor, SchedulerStore } from "./contracts.js";
+import type { SchedulerAutomationExecutor, SchedulerExecutor, SchedulerStore } from "./contracts.js";
 import type { SchedulerRunCompletion } from "./run-completion.js";
+import type { AutomationSchedulerRunCompletion } from "./automation-run-completion.js";
 import type { SchedulerSessionDeletionState } from "./session-deletion-state.js";
 export interface SchedulerContext {
     environmentId: string;
     store: SchedulerStore;
     executor: SchedulerExecutor;
+    automationExecutor?: SchedulerAutomationExecutor;
     now(): number;
     running: boolean;
     generation: number;
@@ -12,10 +14,12 @@ export interface SchedulerContext {
     pendingJobMutations: Set<string>;
     deletedSessions: SchedulerSessionDeletionState;
     pendingCompletions: Map<string, SchedulerRunCompletion>;
+    pendingAutomationCompletions: Map<string, AutomationSchedulerRunCompletion>;
     enqueue<T>(operation: () => Promise<T>): Promise<T>;
     onError(error: unknown): void;
 }
 export declare function requireRunningScheduler(context: SchedulerContext): void;
 export declare function jobEpoch(context: SchedulerContext, jobId: string): number;
 export declare function invalidateJob(context: SchedulerContext, jobId: string): () => void;
-export declare function canBeginSchedulerRun(context: SchedulerContext, jobId: string, sessionId: string, epoch: number): boolean;
+export declare function canBeginSchedulerRun(context: SchedulerContext, jobId: string, epoch: number): boolean;
+export declare function canBeginRequestSchedulerRun(context: SchedulerContext, jobId: string, sessionId: string, epoch: number): boolean;

package/dist/src/runtime/scheduler/service-context.js

@@ -15,12 +15,15 @@ export function invalidateJob(context, jobId) {
         context.pendingJobMutations.delete(jobId);
     };
 }
-export function canBeginSchedulerRun(context, jobId, sessionId, epoch) {
+export function canBeginSchedulerRun(context, jobId, epoch) {
     if (!context.running)
         return false;
-    if (context.deletedSessions.has(sessionId))
-        return false;
     if (context.pendingJobMutations.has(jobId))
         return false;
     return jobEpoch(context, jobId) === epoch;
 }
+export function canBeginRequestSchedulerRun(context, jobId, sessionId, epoch) {
+    if (context.deletedSessions.has(sessionId))
+        return false;
+    return canBeginSchedulerRun(context, jobId, epoch);
+}

package/dist/src/runtime/scheduler/snapshot-validation.d.ts

@@ -1,4 +1,4 @@
-import type { SchedulerJob, SchedulerRun, SchedulerSnapshot } from "./contracts.js";
-export declare function parseStoredJob(value: unknown): SchedulerJob;
-export declare function parseStoredRun(value: unknown): SchedulerRun;
+import type { SchedulerSnapshot, SchedulerStoredJob, SchedulerStoredRun } from "./contracts.js";
+export declare function parseStoredJob(value: unknown): SchedulerStoredJob;
+export declare function parseStoredRun(value: unknown): SchedulerStoredRun;
 export declare function parseSchedulerSnapshot(value: unknown): SchedulerSnapshot;

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

@@ -1,4 +1,7 @@
+import { parseStoredAutomationJob, parseStoredAutomationRun, } from "./automation-snapshot-validation.js";
+import { sameSchedulerTarget } from "./scheduler-target.js";
 import { normalizeStoredSchedulerSchedule, validateSchedulerJobInput, validateTimeZone, } from "./schedule-validation.js";
+import { isSchedulerToolPermissionMode, requireSchedulerToolPermissionMode, } from "./tool-permission-mode.js";
 function isRecord(value) {
     if (!value || typeof value !== "object")
         return false;
@@ -16,11 +19,15 @@ function requireSnapshotInstant(value) {
 export function parseStoredJob(value) {
     if (!isRecord(value))
         failSnapshot();
+    if (isAutomationTarget(value.target))
+        return parseStoredAutomationJob(value);
+    if (!isRequestTarget(value.target))
+        failSnapshot();
     const job = value;
     validateSchedulerJobInput(job);
     if (!job.id || !job.environmentId)
         failSnapshot();
-    if (job.toolPermissionMode !== "full_access")
+    if (!isSchedulerToolPermissionMode(job.toolPermissionMode))
         failSnapshot();
     if (!["active", "paused", "cancelled", "completed"].includes(job.state))
         failSnapshot();
@@ -36,11 +43,17 @@ export function parseStoredJob(value) {
     if (job.schedule?.kind === "interval" && !job.schedule.anchorAt)
         failSnapshot();
     const normalized = normalizeStoredSchedulerSchedule(job.schedule);
+    if (normalized.kind === "manual")
+        failSnapshot();
     return { ...job, schedule: normalized };
 }
 export function parseStoredRun(value) {
     if (!isRecord(value))
         failSnapshot();
+    if (isAutomationTarget(value.target))
+        return parseStoredAutomationRun(value);
+    if (!isRequestTarget(value.target))
+        failSnapshot();
     for (const field of [
         "id",
         "jobId",
@@ -61,6 +74,7 @@ export function parseStoredRun(value) {
         failSnapshot();
     if (Number(value.jobRevision) < 1)
         failSnapshot();
+    requireSchedulerToolPermissionMode(value.toolPermissionMode);
     validateTimeZone(String(value.timeZone));
     const states = [
         "pending",
@@ -101,7 +115,7 @@ export function parseSchedulerSnapshot(value) {
         const owner = jobs.find((job) => job.id === run.jobId);
         if (!owner)
             failSnapshot();
-        if (owner.sessionId !== run.sessionId)
+        if (!sameSchedulerTarget(owner, run))
             failSnapshot();
         if (owner.environmentId !== run.environmentId)
             failSnapshot();
@@ -110,3 +124,11 @@ export function parseSchedulerSnapshot(value) {
     }
     return { schemaVersion: 1, jobs, runs };
 }
+function isAutomationTarget(value) {
+    return isRecord(value) && value.kind === "automation";
+}
+function isRequestTarget(value) {
+    if (value === undefined)
+        return true;
+    return isRecord(value) && value.kind === "request";
+}

package/dist/src/runtime/scheduler/startup-recovery.d.ts

@@ -1,2 +1,2 @@
 import type { SchedulerSnapshot } from "./contracts.js";
-export declare function recoverSchedulerSnapshot(state: SchedulerSnapshot, environmentId: string, now: number): void;
+export declare function recoverSchedulerSnapshot(state: SchedulerSnapshot, environmentId: string, now: number): string[];

package/dist/src/runtime/scheduler/startup-recovery.js

@@ -1,16 +1,22 @@
+import { randomUUID } from "node:crypto";
+import { makeAutomationSchedulerRun } from "./automation-run-records.js";
 import { nextSchedulerOccurrence } from "./next-occurrence.js";
 import { makeSchedulerRun } from "./run-records.js";
+import { isAutomationSchedulerJob, isAutomationSchedulerRun, } from "./scheduler-target.js";
 export function recoverSchedulerSnapshot(state, environmentId, now) {
     const at = new Date(now).toISOString();
+    const recoveredAutomationRuns = [];
     for (const job of state.jobs) {
         if (job.environmentId !== environmentId)
             throw new Error("scheduler_environment_mismatch");
     }
     for (const run of state.runs) {
-        if (run.status === "running") {
+        if (run.status === "running" || run.status === "stopping") {
             run.status = "interrupted";
             run.finishedAt = at;
             run.error = "scheduler_process_stopped";
+            if (isAutomationSchedulerRun(run))
+                recoveredAutomationRuns.push(run.id);
             continue;
         }
         if (run.status !== "pending")
@@ -18,6 +24,8 @@ export function recoverSchedulerSnapshot(state, environmentId, now) {
         run.status = "missed";
         run.finishedAt = at;
         run.error = "scheduler_offline_no_catchup";
+        if (isAutomationSchedulerRun(run))
+            recoveredAutomationRuns.push(run.id);
     }
     for (const job of state.jobs) {
         if (job.state !== "active")
@@ -26,13 +34,18 @@ export function recoverSchedulerSnapshot(state, environmentId, now) {
             continue;
         if (Date.parse(job.nextRunAt) > now)
             continue;
-        const missed = makeSchedulerRun(job, job.nextRunAt, "schedule");
+        const missed = isAutomationSchedulerJob(job)
+            ? makeAutomationSchedulerRun(job, randomUUID(), job.nextRunAt, "schedule")
+            : makeSchedulerRun(job, job.nextRunAt, "schedule");
         missed.status = "missed";
         missed.finishedAt = at;
         missed.error = "scheduler_offline_no_catchup";
         state.runs.push(missed);
+        if (isAutomationSchedulerRun(missed))
+            recoveredAutomationRuns.push(missed.id);
         job.nextRunAt = nextSchedulerOccurrence(job.schedule, job.timeZone, now);
         if (!job.nextRunAt)
             job.state = "completed";
     }
+    return recoveredAutomationRuns;
 }

package/dist/src/runtime/scheduler/tool-permission-mode.d.ts

@@ -0,0 +1,5 @@
+import type { ToolPermissionMode } from "../../capabilities/tool-permission-mode.js";
+export type SchedulerToolPermissionMode = Extract<ToolPermissionMode, "full_access" | "full_plus">;
+export declare function isSchedulerToolPermissionMode(value: unknown): value is SchedulerToolPermissionMode;
+/** Missing authority belongs to legacy Full jobs and runs; never upgrade it. */
+export declare function requireSchedulerToolPermissionMode(value: unknown): SchedulerToolPermissionMode;

package/dist/src/runtime/scheduler/tool-permission-mode.js

@@ -0,0 +1,14 @@
+import { SchedulerValidationError } from "./validation-error.js";
+export function isSchedulerToolPermissionMode(value) {
+    if (value === "full_access")
+        return true;
+    return value === "full_plus";
+}
+/** Missing authority belongs to legacy Full jobs and runs; never upgrade it. */
+export function requireSchedulerToolPermissionMode(value) {
+    if (value === undefined)
+        return "full_access";
+    if (isSchedulerToolPermissionMode(value))
+        return value;
+    throw new SchedulerValidationError("scheduler_invalid_job", "toolPermissionMode must be full_access or full_plus");
+}

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

@@ -3,6 +3,14 @@ export function createSchedulerWorkingStore(store) {
     return {
         acquire: () => store.acquire(),
         read: () => store.read("active"),
+        readRun: store.readRun?.bind(store),
+        readAutomationRunByKey: store.readAutomationRunByKey?.bind(store),
+        countAutomationRunsOnDay: store.countAutomationRunsOnDay?.bind(store),
         update: (mutate) => store.update(mutate, "active"),
+        readAutomations: store.readAutomations?.bind(store),
+        updateAutomations: store.updateAutomations?.bind(store),
+        updateWithAutomations: store.updateWithAutomations
+            ? (mutate) => store.updateWithAutomations(mutate, "active")
+            : undefined,
     };
 }

package/dist/src/runtime/session/cancelled-response.d.ts

@@ -0,0 +1,12 @@
+import type { SessionThinkingTraceEntry } from "../../sessions/types.js";
+import type { RequestSessionStore } from "../request/session-store.js";
+type CancelledResponseParams = {
+    sessionStore: Pick<RequestSessionStore, "getOrCreateSession" | "appendMessage">;
+    sessionId: string;
+    requestId: string;
+    partialAnswer: string;
+    thinkingTrace?: SessionThinkingTraceEntry[];
+};
+/** Called only after opening the request session; the terminal remains cancelled. */
+export declare function persistCancelledResponse(params: CancelledResponseParams): Promise<Record<string, unknown>>;
+export {};

package/dist/src/runtime/session/cancelled-response.js

@@ -0,0 +1,39 @@
+import { traceDebug } from "../observability/debug-logger.js";
+/** Called only after opening the request session; the terminal remains cancelled. */
+export async function persistCancelledResponse(params) {
+    try {
+        const stoppedResponse = await appendCancelledResponse(params);
+        if (stoppedResponse === undefined)
+            return {};
+        return { stoppedResponse };
+    }
+    catch (error) {
+        traceDebug("runtime.request", "cancelled_response.persist_failed", {
+            requestId: params.requestId,
+            sessionId: params.sessionId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return { stoppedResponsePersistenceFailed: true };
+    }
+}
+async function appendCancelledResponse(params) {
+    const session = await params.sessionStore.getOrCreateSession(params.sessionId);
+    const requestMessages = session.messages.filter((message) => message.requestId === params.requestId);
+    const hasPersistedUserMessage = requestMessages.some((message) => message.role === "user");
+    if (!hasPersistedUserMessage)
+        return undefined;
+    const existingResponse = requestMessages.find((message) => message.role === "assistant");
+    if (existingResponse)
+        return existingResponse.content;
+    const acknowledgement = "I stopped the task at your request.";
+    const output = params.partialAnswer.trim()
+        ? `${params.partialAnswer}\n\n${acknowledgement}`
+        : acknowledgement;
+    await params.sessionStore.appendMessage(params.sessionId, "assistant", output, {
+        requestId: params.requestId,
+        source: "request",
+        grounding: "conversation",
+        thinkingTrace: params.thinkingTrace,
+    });
+    return output;
+}

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

@@ -0,0 +1,3 @@
+import type { SessionRequestLifecycleSnapshot, SessionRequestLifecycleStore, SessionStartActivationCommand } from "../../sessions/request-lifecycle/contracts.js";
+/** A failed acknowledgement cannot leave this owner's initial activation live. */
+export declare function startRequestActivation(store: SessionRequestLifecycleStore, sessionId: string, command: SessionStartActivationCommand): Promise<SessionRequestLifecycleSnapshot>;

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

@@ -0,0 +1,43 @@
+import { randomUUID } from "node:crypto";
+import { SessionCommitOutcomeUnknownError } from "../../sessions/durable-session-commit.js";
+/** A failed acknowledgement cannot leave this owner's initial activation live. */
+export async function startRequestActivation(store, sessionId, command) {
+    try {
+        const started = await store.startActivation(sessionId, command);
+        if (!started.accepted)
+            throw new Error(`request_activation_rejected:${started.reason}`);
+        return started.current;
+    }
+    catch (error) {
+        if (!(error instanceof SessionCommitOutcomeUnknownError))
+            throw error;
+        const current = await store.get(sessionId, command.requestId);
+        if (!isUnconfirmedInitialActivation(current, command))
+            throw error;
+        // No runner has started. Close the exact visible activation before its
+        // owner releases the control; an uncertain commit never permits dispatch.
+        const interrupted = await store.interruptActivation(sessionId, {
+            expected: {
+                requestId: current.requestId,
+                generation: current.generation,
+                revision: current.revision,
+                activationId: command.activationId,
+                ownerEpoch: command.ownerEpoch,
+            },
+            commandId: randomUUID(),
+            message: {
+                content: "The task was interrupted because its startup could not be saved reliably.",
+            },
+        });
+        if (!interrupted.accepted)
+            throw new Error(`request_activation_interruption_rejected:${interrupted.reason}`, { cause: error });
+        throw error;
+    }
+}
+function isUnconfirmedInitialActivation(current, command) {
+    if (current?.status !== "streaming")
+        return false;
+    if (current.activation?.activationId !== command.activationId)
+        return false;
+    return current.activation.ownerEpoch === command.ownerEpoch;
+}

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

@@ -1,10 +1,17 @@
+import { isAssistantInitiativeMessage } from "../../sessions/assistant-initiative.js";
 export function snapshotRequestHistory(session) {
-    return session.messages.map((message) => ({
+    return session.messages.filter(isRequestHistoryMessage).map((message) => ({
         id: message.id,
         role: message.role,
         content: message.content,
         createdAt: message.createdAt,
         ...(message.requestId ? { requestId: message.requestId } : {}),
         ...(message.grounding ? { grounding: message.grounding } : {}),
+        ...(isAssistantInitiativeMessage(message)
+            ? { assistantInitiativeId: message.initiative.proposalId }
+            : {}),
     }));
 }
+function isRequestHistoryMessage(message) {
+    return message.kind !== "tool_approval_request";
+}

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

@@ -1,5 +1,6 @@
 import type { ModelGatewayAttachment } from "../../model-gateway/types.js";
 import type { SessionRecord } from "../../sessions/types.js";
+import type { SessionActivation, SessionRequestLifecycleSnapshot } from "../../sessions/request-lifecycle/contracts.js";
 import type { AgentMode } from "../../shared/types.js";
 import type { RuntimeAttachmentReference, RuntimeAttachmentStore } from "../attachments/store.js";
 import type { EventSink } from "../ports.js";
@@ -8,6 +9,7 @@ import type { RequestSessionStore } from "../request/session-store.js";
 type OpenedRequestSession = {
     session: SessionRecord;
     attachments: RuntimeAttachmentReference[];
+    activation?: SessionRequestLifecycleSnapshot;
 };
 export declare function openRequestSession(params: {
     sessionId: string;
@@ -15,6 +17,7 @@ export declare function openRequestSession(params: {
     rawAttachments: unknown;
     sessionStore: RequestSessionStore;
     attachmentStore?: RuntimeAttachmentStore;
+    activation?: SessionActivation;
 }): Promise<OpenedRequestSession>;
 export declare function initializeRequestSession(params: {
     opened: OpenedRequestSession;
@@ -25,6 +28,7 @@ export declare function initializeRequestSession(params: {
     sessionStore: RequestSessionStore;
     attachmentStore?: RuntimeAttachmentStore;
     events: EventSink;
+    onUserMessagePersisted?(): void;
     schedule?: import("../../sessions/schedule-metadata.js").ScheduleMessageReference;
 }): Promise<Readonly<{
     prompt: string;

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

@@ -1,5 +1,6 @@
 import { appendRequestAttachmentManifest } from "../orchestration/request/request-attachment-prompt.js";
 import { resolveModelGatewayAttachments, resolveRequestAttachments, resolveToolRequestAttachments, } from "../orchestration/request/request-attachments.js";
+import { startRequestActivation } from "./request-activation.js";
 export async function openRequestSession(params) {
     if (!params.sessionId) {
         throw new Error("sessionId required");
@@ -10,6 +11,17 @@ export async function openRequestSession(params) {
         sessionId: params.sessionId,
         attachmentStore: params.attachmentStore,
     });
+    if (params.activation) {
+        const store = params.sessionStore.requestLifecycle;
+        if (!store)
+            throw new Error("durable_approval_store_unavailable");
+        // The first persisted running record already has its recoverable activation.
+        const activation = await startRequestActivation(store, params.sessionId, {
+            requestId: params.requestId,
+            ...params.activation,
+        });
+        return { session, attachments, activation };
+    }
     await params.sessionStore.startRequestStream(params.sessionId, params.requestId);
     return { session, attachments };
 }
@@ -25,6 +37,10 @@ export async function initializeRequestSession(params) {
             ? { attachments: params.opened.attachments }
             : {}),
     });
+    params.onUserMessagePersisted?.();
+    params.events.event("session.messages.updated", {
+        sessionId: params.sessionId,
+    });
     if (params.schedule) {
         const message = persisted.messages.find((entry) => entry.requestId === params.requestId && entry.role === "user");
         params.events.event("schedule.triggered", {

package/dist/src/runtime/session/session-deletion-boundary.d.ts

@@ -3,7 +3,7 @@ import type { SessionStore } from "../ports.js";
 import { type SessionDeletionFinalizer } from "./session-deletion-finalization.js";
 import type { SessionMutationQueue } from "./session-mutation-queue.js";
 /** Shared transaction for managed stores and compatibility deletion adapters. */
-export declare function createSessionDeletionBoundary(base: Pick<SessionStore, "deleteSessionWithStats">, enqueue: SessionMutationQueue, finalize?: SessionDeletionFinalizer): {
+export declare function createSessionDeletionBoundary(base: Pick<SessionStore, "deleteSessionWithStats">, enqueue: SessionMutationQueue, finalize?: SessionDeletionFinalizer, beforeDelete?: (sessionId: string) => Promise<void>): {
     deleteSessionWithStats: (sessionId: string) => Promise<SessionDeleteResult>;
     isDeleted: (sessionId: string) => boolean;
     onDeleted: (listener: import("./session-deletion-cleanup.js").SessionDeletionListener) => () => void;