@abot-ai/runtime 1.4.0 → 1.5.0

package/dist/src/sessions/request-lifecycle/service.js

@@ -0,0 +1,95 @@
+import { assertValidSessionId } from "../record/rules.js";
+import { saveDurableSessionFile } from "../durable-session-commit.js";
+import { collectSessionContinuationBlobs, cleanupConsumedSessionContinuations, } from "./continuation-cleanup.js";
+import { assertContinuationSchema, createSessionContinuationBlobs, } from "./continuation-blobs.js";
+import { projectSessionRequestLifecycle } from "./projection.js";
+import { startSessionActivation, commitSessionApprovalWait, } from "./activation-transitions.js";
+import { commitSessionApprovalDecision } from "./approval-decisions.js";
+import { cancelSessionApprovalWait, commitSessionTerminal, interruptSessionActivation, } from "./terminal-transitions.js";
+import { acceptedLifecycle, appendLifecycleEvent, lifecycleRequest, rejectLifecycleCommand, touchLifecycle, validateActivationExpectation, validateWaitExpectation, } from "./record-operations.js";
+/** Commands share SessionService's queue and file, never a parallel checkpoint store. */
+export function createSessionRequestLifecycle(dependencies) {
+    const blobs = createSessionContinuationBlobs(dependencies.sessionsDir);
+    async function mutate(sessionId, operation) {
+        assertValidSessionId(sessionId);
+        return dependencies.enqueue(sessionId, async () => {
+            const session = await dependencies.read(sessionId);
+            if (!session)
+                return rejectLifecycleCommand("session_missing");
+            const previousBlobs = collectSessionContinuationBlobs(session);
+            const result = await operation({
+                session,
+                timestamp: dependencies.now().toISOString(),
+                createMessageId: dependencies.createMessageId,
+            });
+            if (!result.accepted || result.duplicate)
+                return result;
+            await saveDurableSessionFile(dependencies.sessionsDir, session);
+            await cleanupConsumedSessionContinuations(dependencies.sessionsDir, session, previousBlobs);
+            return result;
+        });
+    }
+    async function readRequest(sessionId, requestId) {
+        const session = await dependencies.read(sessionId);
+        return session?.requests?.find((request) => request.requestId === requestId);
+    }
+    return {
+        ...blobs,
+        startActivation: (sessionId, command) => mutate(sessionId, (context) => startSessionActivation(context, command)),
+        commitWait: (sessionId, command) => mutate(sessionId, async (context) => {
+            // Verify immutable content before acknowledging its canonical reference.
+            // The versioned continuation remains opaque to lifecycle storage.
+            assertContinuationSchema(command.continuation);
+            await blobs.readBlob(sessionId, command.continuation.blob);
+            return commitSessionApprovalWait(context, command);
+        }),
+        commitDecision: (sessionId, command) => mutate(sessionId, (context) => commitSessionApprovalDecision(context, command)),
+        cancelWait: (sessionId, command) => mutate(sessionId, (context) => cancelSessionApprovalWait(context, command)),
+        commitTerminal: (sessionId, command) => mutate(sessionId, (context) => commitSessionTerminal(context, command)),
+        interruptActivation: (sessionId, command) => mutate(sessionId, (context) => interruptSessionActivation(context, command)),
+        appendActivationEvent: (sessionId, command) => mutate(sessionId, (context) => {
+            const request = lifecycleRequest(context.session, command.expected.requestId);
+            const mismatch = validateActivationExpectation(request, command.expected);
+            if (mismatch)
+                return rejectLifecycleCommand(mismatch, request);
+            if (command.payload.type === "completed" ||
+                command.payload.type === "failed")
+                return rejectLifecycleCommand("invalid_command", request);
+            touchLifecycle(context, request);
+            return acceptedLifecycle(request, [
+                appendLifecycleEvent(context, request, command.payload),
+            ]);
+        }),
+        async get(sessionId, requestId) {
+            const request = await readRequest(sessionId, requestId);
+            return request ? (projectSessionRequestLifecycle(request) ?? null) : null;
+        },
+        async listWaiting(sessionId) {
+            const sessions = sessionId
+                ? [await dependencies.read(sessionId)]
+                : await dependencies.list();
+            return sessions.flatMap((session) => (session?.requests ?? []).flatMap((request) => {
+                if (request.status !== "awaiting_approval")
+                    return [];
+                const projected = projectSessionRequestLifecycle(request);
+                return projected ? [projected] : [];
+            }));
+        },
+        async getDecisionReceipt(sessionId, requestId, generation, commandId) {
+            const request = await readRequest(sessionId, requestId);
+            if (request?.generation !== generation)
+                return null;
+            const receipt = request.lifecycle?.decisionReceipts.find((value) => value.commandId === commandId);
+            return receipt ? structuredClone(receipt) : null;
+        },
+        async getContinuation(sessionId, expected) {
+            const session = await dependencies.read(sessionId);
+            if (!session)
+                return null;
+            const request = lifecycleRequest(session, expected.requestId);
+            if (validateWaitExpectation(request, expected))
+                return null;
+            return structuredClone(request.lifecycle.wait.continuation);
+        },
+    };
+}

package/dist/src/sessions/request-lifecycle/terminal-transitions.d.ts

@@ -0,0 +1,5 @@
+import type { SessionCancelWaitCommand, SessionCommitTerminalCommand, SessionInterruptActivationCommand, SessionLifecycleMutationResult } from "./contracts.js";
+import { type LifecycleMutationContext } from "./record-operations.js";
+export declare function commitSessionTerminal(context: LifecycleMutationContext, command: SessionCommitTerminalCommand): SessionLifecycleMutationResult;
+export declare function cancelSessionApprovalWait(context: LifecycleMutationContext, command: SessionCancelWaitCommand): SessionLifecycleMutationResult;
+export declare function interruptSessionActivation(context: LifecycleMutationContext, command: SessionInterruptActivationCommand): SessionLifecycleMutationResult;

package/dist/src/sessions/request-lifecycle/terminal-transitions.js

@@ -0,0 +1,103 @@
+import { acceptedLifecycle, appendLifecycleChangedEvent, appendLifecycleEvent, appendLifecycleMessage, hasNonemptyIdentity, lifecycleRequest, rejectLifecycleCommand, touchLifecycle, validateActivationExpectation, validateWaitExpectation, } from "./record-operations.js";
+function appendTerminalResponse(context, request, message) {
+    const { lastAgentMode, ...metadata } = message;
+    appendLifecycleMessage(context, {
+        ...metadata,
+        role: "assistant",
+        kind: "terminal",
+        requestId: request.requestId,
+        source: "request",
+        grounding: message.grounding ?? "conversation",
+    });
+    if (lastAgentMode)
+        context.session.lastAgentMode = lastAgentMode;
+}
+function hasTerminalCommandReceipt(request, commandId) {
+    if (request.status !== "completed" && request.status !== "failed")
+        return false;
+    return request.lifecycle.terminalCommandId === commandId;
+}
+export function commitSessionTerminal(context, command) {
+    const request = lifecycleRequest(context.session, command.expected.requestId);
+    if (!request)
+        return rejectLifecycleCommand("lifecycle_missing");
+    if (request.generation !== command.expected.generation)
+        return rejectLifecycleCommand("generation_mismatch", request);
+    if (hasTerminalCommandReceipt(request, command.commandId))
+        return { ...acceptedLifecycle(request), duplicate: true };
+    const mismatch = validateActivationExpectation(request, command.expected);
+    if (mismatch)
+        return rejectLifecycleCommand(mismatch, request);
+    if (!hasNonemptyIdentity(command.commandId))
+        return rejectLifecycleCommand("invalid_command", request);
+    if (!hasNonemptyIdentity(command.message.content))
+        return rejectLifecycleCommand("invalid_command", request);
+    if (command.status !== "completed" && command.status !== "failed")
+        return rejectLifecycleCommand("invalid_command", request);
+    request.status = command.status;
+    request.lifecycle.terminalCommandId = command.commandId;
+    request.lifecycle.terminalCause =
+        command.status === "failed"
+            ? (command.cause ?? "request_failed")
+            : undefined;
+    delete request.lifecycle.wait;
+    touchLifecycle(context, request);
+    appendTerminalResponse(context, request, command.message);
+    const payload = command.status === "completed"
+        ? { type: "completed", output: command.message.content }
+        : {
+            type: "failed",
+            error: command.error ?? request.lifecycle.terminalCause,
+            details: {
+                stoppedResponse: command.cause === "request_cancelled"
+                    ? command.message.content
+                    : undefined,
+            },
+        };
+    const changed = appendLifecycleChangedEvent(context, request);
+    const event = appendLifecycleEvent(context, request, payload);
+    return acceptedLifecycle(request, [changed, event]);
+}
+export function cancelSessionApprovalWait(context, command) {
+    const request = lifecycleRequest(context.session, command.expected.requestId);
+    if (!request)
+        return rejectLifecycleCommand("lifecycle_missing");
+    if (request.generation !== command.expected.generation)
+        return rejectLifecycleCommand("generation_mismatch", request);
+    if (hasTerminalCommandReceipt(request, command.commandId))
+        return { ...acceptedLifecycle(request), duplicate: true };
+    const mismatch = validateWaitExpectation(request, command.expected);
+    if (mismatch)
+        return rejectLifecycleCommand(mismatch, request);
+    if (!hasNonemptyIdentity(command.commandId))
+        return rejectLifecycleCommand("invalid_command", request);
+    if (!hasNonemptyIdentity(command.message.content))
+        return rejectLifecycleCommand("invalid_command", request);
+    const presentation = context.session.messages.find((message) => message.id === request.lifecycle.wait.presentationMessageId);
+    if (presentation?.approvalRequest)
+        presentation.approvalRequest = {
+            ...presentation.approvalRequest,
+            state: "cancelled",
+        };
+    request.status = "failed";
+    request.lifecycle.terminalCause = "request_cancelled";
+    request.lifecycle.terminalCommandId = command.commandId;
+    delete request.lifecycle.wait;
+    touchLifecycle(context, request);
+    appendTerminalResponse(context, request, command.message);
+    const changed = appendLifecycleChangedEvent(context, request);
+    const event = appendLifecycleEvent(context, request, {
+        type: "failed",
+        error: "request_cancelled",
+        details: { stoppedResponse: command.message.content },
+    });
+    return acceptedLifecycle(request, [changed, event]);
+}
+export function interruptSessionActivation(context, command) {
+    return commitSessionTerminal(context, {
+        ...command,
+        status: "failed",
+        cause: "request_interrupted",
+        error: "request_interrupted",
+    });
+}

package/dist/src/sessions/request-lifecycle/wait-initial-decisions.d.ts

@@ -0,0 +1,4 @@
+import type { SessionApprovalDecisionReceipt, SessionCommitWaitCommand } from "./contracts.js";
+import { type LifecycleMutationContext, type LifecycleRequest } from "./record-operations.js";
+export declare function hasValidInitialApprovalDecisions(request: LifecycleRequest, command: SessionCommitWaitCommand): boolean;
+export declare function createInitialApprovalReceipts(context: LifecycleMutationContext, request: LifecycleRequest, command: SessionCommitWaitCommand): SessionApprovalDecisionReceipt[];

package/dist/src/sessions/request-lifecycle/wait-initial-decisions.js

@@ -0,0 +1,34 @@
+import { hasNonemptyIdentity, } from "./record-operations.js";
+export function hasValidInitialApprovalDecisions(request, command) {
+    const decisions = command.initialDecisions ?? [];
+    if (decisions.length >= command.approvals.length)
+        return false;
+    const approvals = new Set(command.approvals.map((approval) => approval.approvalId));
+    const decided = new Set();
+    const commands = new Set(request.lifecycle.decisionReceipts.map((receipt) => receipt.commandId));
+    for (const decision of decisions) {
+        if (!approvals.has(decision.approvalId))
+            return false;
+        if (decided.has(decision.approvalId))
+            return false;
+        if (!hasNonemptyIdentity(decision.commandId))
+            return false;
+        if (commands.has(decision.commandId))
+            return false;
+        if (typeof decision.approved !== "boolean")
+            return false;
+        decided.add(decision.approvalId);
+        commands.add(decision.commandId);
+    }
+    return true;
+}
+export function createInitialApprovalReceipts(context, request, command) {
+    return (command.initialDecisions ?? []).map((decision) => ({
+        ...decision,
+        requestId: request.requestId,
+        generation: request.generation,
+        waitId: command.waitId,
+        committedAt: context.timestamp,
+        revision: request.lifecycle.revision,
+    }));
+}

package/dist/src/sessions/session-service.d.ts

@@ -1,3 +1,5 @@
+import type { SessionRequestLifecycleStore } from "./request-lifecycle/contracts.js";
+import { type CreateAssistantConversationInput } from "./assistant-initiative.js";
 import { type SessionCreationOptions } from "./project-binding.js";
 import type { SessionContextEntryKind, SessionArtifactPathInput, SessionMessageGrounding, SessionMessage, SessionMessageDeleteResult, SessionMessageObservationMeta, SessionMessageRole, SessionMessageSource, SessionMessageTaskType, SessionMessagesClearResult, SessionDeleteResult, SessionListResult, SessionRequestReplay, SessionRecord, SessionSnapshot, SessionThinkingTraceEntry } from "./types.js";
 import type { SessionMemoryCheckpointCommit, SessionMemoryCheckpointCommitResult } from "./memory/contracts.js";
@@ -8,6 +10,7 @@ type SessionServiceOptions = {
     createMessageId?: (session: SessionRecord) => string;
 };
 export declare class SessionService {
+    readonly requestLifecycle: SessionRequestLifecycleStore;
     private readonly sessionsDir;
     private readonly now;
     private readonly createMessageId;
@@ -46,6 +49,7 @@ export declare class SessionService {
         triggerType?: string;
         attachments?: SessionMessage["attachments"];
     }): Promise<SessionRecord>;
+    createAssistantConversation(sessionId: string, input: CreateAssistantConversationInput): Promise<SessionRecord>;
     compareAndSwapSessionMemoryCheckpoint(sessionId: string, command: SessionMemoryCheckpointCommit): Promise<SessionMemoryCheckpointCommitResult>;
     appendContextEntry(sessionId: string, options: {
         kind: SessionContextEntryKind;

package/dist/src/sessions/session-service.js

@@ -1,4 +1,9 @@
 import { randomUUID } from "node:crypto";
+import { saveDurableSessionFile } from "./durable-session-commit.js";
+import { cleanupSessionContinuations } from "./request-lifecycle/continuation-cleanup.js";
+import { createSessionRequestLifecycle } from "./request-lifecycle/service.js";
+import { projectSessionRequestLifecycle } from "./request-lifecycle/projection.js";
+import { createAssistantConversationRecord, } from "./assistant-initiative.js";
 import { assertSessionProjectUnchanged, copySessionProject, } from "./project-binding.js";
 import { getDefaultSessionsDir } from "../runtime/config/layout.js";
 import { assertValidSessionArtifactPathInputs, upsertSessionArtifactPaths, } from "./artifact-paths.js";
@@ -10,6 +15,7 @@ function toIso(now) {
     return now().toISOString();
 }
 export class SessionService {
+    requestLifecycle;
     sessionsDir;
     now;
     createMessageId;
@@ -19,6 +25,14 @@ export class SessionService {
             options.sessionsDir || getDefaultSessionsDir(process.cwd());
         this.now = options.now || (() => new Date());
         this.createMessageId = options.createMessageId || defaultCreateMessageId;
+        this.requestLifecycle = createSessionRequestLifecycle({
+            sessionsDir: this.sessionsDir,
+            now: this.now,
+            createMessageId: this.createMessageId,
+            enqueue: this.runSessionMutation.bind(this),
+            read: this.getSessionById.bind(this),
+            list: this.getAllSessions.bind(this),
+        });
     }
     async getOrCreateSession(sessionId, options = {}) {
         assertValidSessionId(sessionId);
@@ -92,6 +106,9 @@ export class SessionService {
             return {
                 requestId,
                 sessionId: request.sessionId,
+                ...(request.lifecycle
+                    ? { lifecycle: projectSessionRequestLifecycle(request) }
+                    : {}),
                 ...(request.generation ? { generation: request.generation } : {}),
                 events: request.events
                     .filter((event) => event.seqNo > normalizedAfterSeq)
@@ -107,15 +124,17 @@ export class SessionService {
     }
     async deleteSessionWithStats(sessionId) {
         assertValidSessionId(sessionId);
-        await ensureSessionsDir(this.sessionsDir);
-        const session = await loadSessionFile(this.sessionsDir, sessionId);
-        const deleted = await deleteSessionFile(this.sessionsDir, sessionId);
-        return {
-            sessionId,
-            deleted,
-            deletedMessages: deleted ? (session?.messages.length ?? 0) : 0,
-            deletedRequests: deleted ? (session?.requests?.length ?? 0) : 0,
-        };
+        return this.runSessionMutation(sessionId, async () => {
+            await ensureSessionsDir(this.sessionsDir);
+            const session = await loadSessionFile(this.sessionsDir, sessionId);
+            const deleted = await deleteSessionFile(this.sessionsDir, sessionId);
+            return {
+                sessionId,
+                deleted,
+                deletedMessages: deleted ? (session?.messages.length ?? 0) : 0,
+                deletedRequests: deleted ? (session?.requests?.length ?? 0) : 0,
+            };
+        });
     }
     async resetSession(sessionId) {
         const result = await this.clearSessionMessages(sessionId);
@@ -175,6 +194,7 @@ export class SessionService {
             }
             const deletedMessages = session.messages.length;
             const deletedRequests = session.requests?.length ?? 0;
+            const hadDurableRequests = session.requests?.some((request) => request.lifecycle);
             const updatedAt = toIso(this.now);
             session.messages = [];
             session.messageCount = 0;
@@ -184,7 +204,11 @@ export class SessionService {
             delete session.sessionMemoryCheckpoint;
             delete session.runtimeModeId;
             session.updatedAt = updatedAt;
-            await saveSessionFile(this.sessionsDir, session);
+            if (hadDurableRequests)
+                await saveDurableSessionFile(this.sessionsDir, session);
+            else
+                await saveSessionFile(this.sessionsDir, session);
+            await cleanupSessionContinuations(this.sessionsDir, sessionId);
             return {
                 sessionId,
                 cleared: deletedMessages > 0 || deletedRequests > 0,
@@ -226,6 +250,15 @@ export class SessionService {
             return session;
         });
     }
+    async createAssistantConversation(sessionId, input) {
+        assertValidSessionId(sessionId);
+        return this.runSessionMutation(sessionId, () => createAssistantConversationRecord({
+            directory: this.sessionsDir,
+            sessionId,
+            input,
+            now: this.now(),
+        }));
+    }
     async compareAndSwapSessionMemoryCheckpoint(sessionId, command) {
         assertValidSessionId(sessionId);
         return this.runSessionMutation(sessionId, async () => {
@@ -285,6 +318,8 @@ export class SessionService {
             const timestamp = toIso(this.now);
             const existing = getSessionRequest(session, requestId);
             if (existing) {
+                if (existing.lifecycle)
+                    throw new Error("request_lifecycle_command_required");
                 existing.status = "streaming";
                 existing.updatedAt = timestamp;
                 existing.events = compactRequestEvents(existing.events);
@@ -316,6 +351,8 @@ export class SessionService {
             const session = await this.getOrCreateSession(sessionId);
             const timestamp = toIso(this.now);
             let request = getSessionRequest(session, requestId);
+            if (request?.lifecycle)
+                throw new Error("request_lifecycle_command_required");
             if (!request) {
                 request = {
                     requestId,
@@ -397,6 +434,7 @@ export class SessionService {
                 };
             }
             const requestId = targetMessage.requestId;
+            const hadDurableRequests = session.requests?.some((request) => request.lifecycle);
             let deletedRequestId;
             let deletedRequestEvents;
             if (requestId) {
@@ -416,7 +454,10 @@ export class SessionService {
                 delete session.runtimeModeId;
             }
             session.updatedAt = updatedAt;
-            await saveSessionFile(this.sessionsDir, session);
+            if (hadDurableRequests)
+                await saveDurableSessionFile(this.sessionsDir, session);
+            else
+                await saveSessionFile(this.sessionsDir, session);
             return {
                 sessionId,
                 messageId,

package/dist/src/sessions/session-store.d.ts

@@ -1,6 +1,6 @@
 import type { SessionRecord } from "./types.js";
 export declare function ensureSessionsDir(sessionsDir: string): Promise<void>;
 export declare function loadSessionFile(sessionsDir: string, sessionId: string): Promise<SessionRecord | null>;
-export declare function saveSessionFile(sessionsDir: string, session: SessionRecord): Promise<void>;
+export declare function saveSessionFile(sessionsDir: string, session: SessionRecord, assertCurrent?: () => void): Promise<void>;
 export declare function deleteSessionFile(sessionsDir: string, sessionId: string): Promise<boolean>;
 export declare function loadAllSessionFiles(sessionsDir: string): Promise<SessionRecord[]>;

package/dist/src/sessions/session-store.js

@@ -1,6 +1,8 @@
 import { mkdir, readdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
+import { saveDurableSessionFile, syncSessionDirectory, } from "./durable-session-commit.js";
+import { cleanupSessionContinuations } from "./request-lifecycle/continuation-cleanup.js";
 function getSessionFilePath(sessionsDir, sessionId) {
     return join(sessionsDir, `${sessionId}.json`);
 }
@@ -20,11 +22,15 @@ export async function loadSessionFile(sessionsDir, sessionId) {
         throw error;
     }
 }
-export async function saveSessionFile(sessionsDir, session) {
+export async function saveSessionFile(sessionsDir, session, assertCurrent) {
+    if (session.requests?.some((request) => request.lifecycle)) {
+        return saveDurableSessionFile(sessionsDir, session, assertCurrent);
+    }
     const filePath = getSessionFilePath(sessionsDir, session.id);
     const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
     try {
         await writeFile(tempPath, JSON.stringify(session, null, 2), "utf-8");
+        assertCurrent?.();
         await rename(tempPath, filePath);
     }
     catch (error) {
@@ -36,6 +42,8 @@ export async function deleteSessionFile(sessionsDir, sessionId) {
     const filePath = getSessionFilePath(sessionsDir, sessionId);
     try {
         await rm(filePath);
+        await syncSessionDirectory(sessionsDir);
+        await cleanupSessionContinuations(sessionsDir, sessionId);
         return true;
     }
     catch (error) {

package/dist/src/sessions/types.d.ts

@@ -2,8 +2,9 @@ import type { SessionProject } from "./project-binding.js";
 import type { AgentMode } from "../shared/types.js";
 import type { RuntimeAttachmentReference } from "../shared/attachments.js";
 import type { SessionMemoryCheckpoint } from "./memory/contracts.js";
+import type { SessionApprovalPresentation, SessionRequestLifecycleRecord, SessionRequestLifecycleSnapshot } from "./request-lifecycle/contracts.js";
 export type SessionMessageRole = "user" | "assistant";
-export type SessionMessageSource = "user" | "request" | "agent_bridge" | "cron";
+export type SessionMessageSource = "user" | "request" | "agent_bridge" | "cron" | "co_worker";
 export type SessionMessageTaskType = string;
 export type SessionMessageGrounding = "conversation" | "tool_observation";
 export type ToolObservationKind = "stable_fact" | "volatile_external" | "task_result";
@@ -40,7 +41,7 @@ export type SessionThinkingTraceEntry = {
     status: SessionThinkingTraceStatus;
     text: string;
 };
-export type SessionRequestStatus = "streaming" | "completed" | "failed";
+export type SessionRequestStatus = "streaming" | "awaiting_approval" | "completed" | "failed";
 export type SessionRuntimeEvent = {
     seqNo: number;
     type: string;
@@ -49,6 +50,7 @@ export type SessionRuntimeEvent = {
     payload: Record<string, unknown>;
 };
 export type SessionRequestRecord = {
+    lifecycle?: SessionRequestLifecycleRecord;
     requestId: string;
     sessionId: string;
     /** Absent for legacy records and records recreated by late event appends. */
@@ -69,6 +71,7 @@ export type SessionRequestFinalState = {
     completedAt: number;
 };
 export type SessionRequestReplay = {
+    lifecycle?: SessionRequestLifecycleSnapshot;
     requestId: string;
     sessionId: string;
     generation?: string;
@@ -91,6 +94,9 @@ export type SessionListResult = {
     nextCursor: string | null;
 };
 export type SessionSnapshotMessage = {
+    kind?: "tool_approval_request" | "terminal";
+    approvalRequest?: SessionApprovalPresentation;
+    initiative?: import("./assistant-initiative.js").AssistantInitiative;
     schedule?: import("./schedule-metadata.js").ScheduleMessageReference;
     id: string | number;
     sessionId: string;
@@ -105,6 +111,7 @@ export type SessionSnapshotMessage = {
     attachments?: RuntimeAttachmentReference[];
 };
 export type SessionSnapshotRequest = {
+    lifecycle?: SessionRequestLifecycleSnapshot;
     requestId: string;
     sessionId: string;
     status: SessionRequestStatus;
@@ -144,6 +151,9 @@ export type SessionMessageDeleteResult = {
     deletedRequestEvents?: number;
 };
 export type SessionMessage = {
+    kind?: "tool_approval_request" | "terminal";
+    approvalRequest?: SessionApprovalPresentation;
+    initiative?: import("./assistant-initiative.js").AssistantInitiative;
     schedule?: import("./schedule-metadata.js").ScheduleMessageReference;
     id: string;
     role: SessionMessageRole;

package/dist/src/shared/model-step-registry-data.json

@@ -1,5 +1,14 @@
 {
   "steps": {
+    "LEARNING_BATCH": {
+      "id": "learning.batch",
+      "owner": "runtime-core",
+      "role": "utility",
+      "lane": "utility",
+      "defaultFormat": "json",
+      "outputContract": "passive_learning_batch",
+      "attachmentPolicy": "none"
+    },
     "SUPERVISOR_DECISION": {
       "id": "supervisor.decision",
       "owner": "runtime-core",

package/dist/src/shared/model-step-registry.d.ts

@@ -2,6 +2,15 @@ import type { ModelInvocationLane, ModelInvocationStepDefinition } from "./model
 export type { ModelInvocationFormat, ModelInvocationAttachmentPolicy, ModelInvocationLane, ModelInvocationOutputTokenPolicy, ModelInvocationRole, ModelInvocationStepDefinition, ModelInvocationStepOwner, RegisteredModelInvocationStepDefinition, } from "./model-step-registry.types.js";
 export declare const CORE_DECISION_OUTPUT_TOKEN_LIMIT = 2048;
 export declare const MODEL_INVOCATION_STEP_REGISTRY: {
+    readonly LEARNING_BATCH: {
+        readonly id: "learning.batch";
+        readonly owner: "runtime-core";
+        readonly role: "utility";
+        readonly lane: "utility";
+        readonly defaultFormat: "json";
+        readonly outputContract: "passive_learning_batch";
+        readonly attachmentPolicy: "none";
+    };
     readonly SUPERVISOR_DECISION: {
         readonly id: "supervisor.decision";
         readonly owner: "runtime-core";

package/dist/src/shared/model-step-registry.generated.d.ts

@@ -1,4 +1,13 @@
 export declare const GENERATED_MODEL_INVOCATION_STEP_REGISTRY: {
+    readonly LEARNING_BATCH: {
+        readonly id: "learning.batch";
+        readonly owner: "runtime-core";
+        readonly role: "utility";
+        readonly lane: "utility";
+        readonly defaultFormat: "json";
+        readonly outputContract: "passive_learning_batch";
+        readonly attachmentPolicy: "none";
+    };
     readonly SUPERVISOR_DECISION: {
         readonly id: "supervisor.decision";
         readonly owner: "runtime-core";

package/dist/src/shared/model-step-registry.generated.js

@@ -1,4 +1,13 @@
 export const GENERATED_MODEL_INVOCATION_STEP_REGISTRY = {
+    LEARNING_BATCH: {
+        id: "learning.batch",
+        owner: "runtime-core",
+        role: "utility",
+        lane: "utility",
+        defaultFormat: "json",
+        outputContract: "passive_learning_batch",
+        attachmentPolicy: "none",
+    },
     SUPERVISOR_DECISION: {
         id: "supervisor.decision",
         owner: "runtime-core",

package/dist/src/shared/passive-observation.d.ts

@@ -0,0 +1,46 @@
+/** Maximum replay lifetime of collected evidence, including paused batches. */
+export declare const PASSIVE_OBSERVATION_RETENTION_MS: number;
+/** Passive desktop evidence. An edit describes a changed editable control, not authorship. */
+export type PassiveObservationSource = Readonly<{
+    app: string;
+    processId?: number;
+    windowId: string;
+    documentId?: string;
+    title?: string;
+    url?: string;
+}>;
+export type PassiveObservation = Readonly<{
+    id: string;
+    timestamp: string;
+    sequence: number;
+    source: PassiveObservationSource;
+    content: string;
+    kind: "view" | "edit" | "activity";
+    extraction: "uia" | "ax" | "atspi";
+    coverage: "complete" | "partial" | "metadata_only";
+    coverageReason?: string;
+    revisitsObservationId?: string;
+}>;
+export type PassiveCollectionState = "starting" | "collecting" | "partial" | "unavailable" | "permission_required" | "paused" | "stopped" | "disconnected" | "failed";
+export type PassiveCollectorEvent = Readonly<{
+    type: "observation";
+    observation: PassiveObservation;
+}> | Readonly<{
+    type: "status";
+    state: PassiveCollectionState;
+    reason?: string;
+}>;
+/** Device identity is attached by the authenticated broker, never trusted from screen content. */
+export type HostObservationEvent = PassiveCollectorEvent & Readonly<{
+    deviceId: string;
+    ownerId: string;
+    leaseId: string;
+}>;
+export type HostObservationSubscription = Readonly<{
+    rootDir: string;
+    ownerId: string;
+    leaseId: string;
+    abortSignal: AbortSignal;
+    excludedApplications?: readonly string[];
+    onEvent(event: HostObservationEvent): void;
+}>;

package/dist/src/shared/passive-observation.js

@@ -0,0 +1,2 @@
+/** Maximum replay lifetime of collected evidence, including paused batches. */
+export const PASSIVE_OBSERVATION_RETENTION_MS = 24 * 60 * 60 * 1000;