@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/sessions/metadata/publication.js

@@ -0,0 +1,78 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { withFileLock } from "../../runtime/adapters/long-term-memory/file-lock.js";
+const pendingPublications = new Map();
+export function isMissingSessionFile(error) {
+    return error?.code === "ENOENT";
+}
+export function sessionSourceStamp(source) {
+    return `${source.dev}:${source.ino}:${source.size}:${source.mtimeNs}`;
+}
+export async function currentSourceStamp(path) {
+    try {
+        return sessionSourceStamp(await stat(path, { bigint: true }));
+    }
+    catch (error) {
+        if (isMissingSessionFile(error))
+            return null;
+        throw error;
+    }
+}
+export function reportMetadataFailure(sessionId, error) {
+    process.emitWarning(`Session metadata update failed for ${sessionId}: ${String(error)}`, {
+        code: "SESSION_METADATA_WRITE_FAILED",
+    });
+}
+/** Only the derived index is expendable; canonical session read failures still propagate. */
+export async function readMetadataJson(path) {
+    try {
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch (error) {
+        if (isMissingSessionFile(error))
+            return null;
+        if (error instanceof SyntaxError)
+            return null;
+        reportMetadataFailure(path, error);
+        return null;
+    }
+}
+/** Serialize index publication/deletion by session, never across unrelated sessions. */
+export async function publishSessionMetadata(path, operation) {
+    const key = resolve(path);
+    const previous = pendingPublications.get(key) ?? Promise.resolve();
+    const pending = previous.then(operation).catch((error) => reportMetadataFailure(path, error));
+    pendingPublications.set(key, pending);
+    try {
+        await pending;
+    }
+    finally {
+        if (pendingPublications.get(key) === pending)
+            pendingPublications.delete(key);
+    }
+}
+/** List backfills and the Runtime owner may run in different processes. */
+export async function publishSessionProjection(path, operation) {
+    return publishSessionMetadata(path, async () => {
+        await mkdir(dirname(path), { recursive: true });
+        await withFileLock(`${path}.lock`, operation);
+    });
+}
+export async function writeMetadataJson(target, value, sourcePath, source) {
+    if (await currentSourceStamp(sourcePath) !== source)
+        return false;
+    await mkdir(dirname(target), { recursive: true });
+    const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, JSON.stringify(value), { encoding: "utf8", mode: 0o600 });
+        // Validate at publication too: the canonical file may change while writing the temporary.
+        if (await currentSourceStamp(sourcePath) !== source)
+            return false;
+        await rename(temporary, target);
+        return true;
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}

package/dist/src/sessions/metadata/source-receipt.d.ts

@@ -0,0 +1,5 @@
+import type { SessionMetadata } from "./projection.js";
+export type SessionMetadataChange = "projection" | "request-only";
+export declare function writeSourceReceipt(path: string, sourcePath: string, source: string, updatedAt: string, previousSource?: string): Promise<void>;
+/** Bind request-only changes to the exact projection they left unchanged. */
+export declare function applySourceReceipt(path: string, record: SessionMetadata, source: string): Promise<SessionMetadata | null>;

package/dist/src/sessions/metadata/source-receipt.js

@@ -0,0 +1,42 @@
+import { toEpochMs } from "../record/projection.js";
+import { readMetadataJson, writeMetadataJson } from "./publication.js";
+function isSourceReceipt(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const receipt = value;
+    if (receipt.version !== 1)
+        return false;
+    if (typeof receipt.source !== "string")
+        return false;
+    if (typeof receipt.projectionSource !== "string")
+        return false;
+    return typeof receipt.updatedAt === "string";
+}
+async function receiptProjectionSource(path, source, previousSource) {
+    if (previousSource === undefined)
+        return source;
+    const previous = await readMetadataJson(path);
+    if (!isSourceReceipt(previous))
+        return previousSource;
+    if (previous.source !== previousSource)
+        return previousSource;
+    return previous.projectionSource;
+}
+export async function writeSourceReceipt(path, sourcePath, source, updatedAt, previousSource) {
+    const projectionSource = await receiptProjectionSource(path, source, previousSource);
+    await writeMetadataJson(path, { version: 1, source, projectionSource, updatedAt }, sourcePath, source);
+}
+/** Bind request-only changes to the exact projection they left unchanged. */
+export async function applySourceReceipt(path, record, source) {
+    const receipt = await readMetadataJson(path);
+    if (!isSourceReceipt(receipt))
+        return null;
+    if (receipt.source !== source)
+        return null;
+    if (receipt.projectionSource !== record.source)
+        return null;
+    return {
+        ...record, source, updatedAt: receipt.updatedAt,
+        summary: { ...record.summary, updatedAt: toEpochMs(receipt.updatedAt) },
+    };
+}

package/dist/src/sessions/metadata/store.d.ts

@@ -0,0 +1,7 @@
+import type { SessionRecord } from "../types.js";
+import { type SessionMetadata } from "./projection.js";
+export { currentSourceStamp, sessionSourceStamp } from "./publication.js";
+/** The canonical session has already committed. A derived-index failure cannot undo it. */
+export declare function updateSessionMetadata(sessionsDir: string, session: SessionRecord, source: string, previousSource?: string | null): Promise<void>;
+export declare function deleteSessionMetadata(sessionsDir: string, sessionId: string): Promise<void>;
+export declare function listSessionMetadata(sessionsDir: string): Promise<SessionMetadata[]>;

package/dist/src/sessions/metadata/store.js

@@ -0,0 +1,119 @@
+import { mkdir, open, readdir, rm } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { compareSessionMetadata, isCurrentSessionMetadata, projectSessionMetadata, } from "./projection.js";
+import { currentSourceStamp, isMissingSessionFile, publishSessionMetadata, publishSessionProjection, readMetadataJson, reportMetadataFailure, sessionSourceStamp, writeMetadataJson, } from "./publication.js";
+import { applySourceReceipt, writeSourceReceipt } from "./source-receipt.js";
+export { currentSourceStamp, sessionSourceStamp } from "./publication.js";
+const pendingLists = new Map();
+const concurrentMetadataReads = 4;
+function metadataPath(sessionsDir, sessionId) {
+    return join(sessionsDir, ".metadata", `${sessionId}.json`);
+}
+async function writeMetadata(sessionsDir, record) {
+    const target = metadataPath(sessionsDir, record.summary.id);
+    const sourcePath = join(sessionsDir, `${record.summary.id}.json`);
+    await publishSessionProjection(target, async () => {
+        if (!await writeMetadataJson(target, record, sourcePath, record.source))
+            return;
+        // The full projection already carries its source; only request-only changes need a receipt.
+        await rm(`${target}.source`, { force: true });
+    });
+}
+/** The canonical session has already committed. A derived-index failure cannot undo it. */
+export async function updateSessionMetadata(sessionsDir, session, source, previousSource) {
+    if (previousSource) {
+        const target = metadataPath(sessionsDir, session.id);
+        return publishSessionMetadata(target, () => writeSourceReceipt(`${target}.source`, join(sessionsDir, `${session.id}.json`), source, session.updatedAt, previousSource));
+    }
+    try {
+        await writeMetadata(sessionsDir, projectSessionMetadata(session, source));
+    }
+    catch (error) {
+        reportMetadataFailure(session.id, error);
+    }
+}
+export async function deleteSessionMetadata(sessionsDir, sessionId) {
+    const target = metadataPath(sessionsDir, sessionId);
+    await publishSessionProjection(target, async () => {
+        await rm(target, { force: true });
+        await rm(`${target}.source`, { force: true });
+    });
+}
+async function readSourceMetadata(path) {
+    const handle = await open(path, "r").catch((error) => {
+        if (isMissingSessionFile(error))
+            return null;
+        throw error;
+    });
+    if (!handle)
+        return null;
+    try {
+        const source = sessionSourceStamp(await handle.stat({ bigint: true }));
+        const session = JSON.parse(await handle.readFile("utf8"));
+        return projectSessionMetadata(session, source);
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function readCurrentMetadata(target, sessionId, source) {
+    const stored = await readMetadataJson(target);
+    if (isCurrentSessionMetadata(stored, sessionId, source))
+        return stored;
+    const projectionSource = stored?.source;
+    if (typeof projectionSource !== "string")
+        return null;
+    if (!isCurrentSessionMetadata(stored, sessionId, projectionSource))
+        return null;
+    return applySourceReceipt(`${target}.source`, stored, source);
+}
+async function loadMetadata(sessionsDir, sessionId) {
+    const path = join(sessionsDir, `${sessionId}.json`);
+    const source = await currentSourceStamp(path);
+    if (source === null)
+        return null;
+    const current = await readCurrentMetadata(metadataPath(sessionsDir, sessionId), sessionId, source);
+    if (current)
+        return current;
+    const rebuilt = await readSourceMetadata(path);
+    if (!rebuilt)
+        return null;
+    await writeMetadata(sessionsDir, rebuilt);
+    return rebuilt;
+}
+function settledMetadata(result) {
+    if (result.status === "rejected")
+        throw result.reason;
+    return result.value;
+}
+/**
+ * Each atomically published record completes its own backfill. Restarts reuse
+ * those records; interrupted backfills only rebuild missing/stale entries.
+ * Source stamps also detect older writers and a crash between the two commits.
+ */
+async function readMetadataList(sessionsDir) {
+    await mkdir(sessionsDir, { recursive: true });
+    const names = (await readdir(sessionsDir)).filter((name) => name.endsWith(".json"));
+    const records = [];
+    for (let offset = 0; offset < names.length; offset += concurrentMetadataReads) {
+        // Bound disk fan-out and drain the batch before propagating a canonical read failure.
+        const batch = await Promise.allSettled(names.slice(offset, offset + concurrentMetadataReads)
+            .map((name) => loadMetadata(sessionsDir, name.slice(0, -5))));
+        records.push(...batch.map(settledMetadata).filter((record) => record !== null));
+    }
+    return records.sort(compareSessionMetadata);
+}
+export async function listSessionMetadata(sessionsDir) {
+    const directory = resolve(sessionsDir);
+    const existing = pendingLists.get(directory);
+    if (existing)
+        return existing;
+    const pending = readMetadataList(directory);
+    pendingLists.set(directory, pending);
+    try {
+        return await pending;
+    }
+    finally {
+        pendingLists.delete(directory);
+    }
+}

package/dist/src/sessions/project-binding.d.ts

@@ -7,6 +7,7 @@ export type SessionProject = Readonly<{
 }>;
 export type SessionCreationOptions = Readonly<{
     project?: SessionProject;
+    kind?: import("./spark-session.js").SessionKind;
 }>;
 export declare function copySessionProject(project: SessionProject): SessionProject;
 export declare function assertSessionProjectUnchanged(session: SessionRecord, requested?: SessionProject): void;

package/dist/src/sessions/record/projection.d.ts

@@ -7,10 +7,12 @@ export declare function normalizeAfterSeq(afterSeq: number): number;
 export declare function toEpochMs(timestamp: string): number;
 export declare function toClientReplayEvent(event: SessionRuntimeEvent): Record<string, unknown>;
 export declare function getRequestFinalState(request: SessionRequestRecord): SessionRequestReplay["finalState"];
+export declare function toMessageIdForUi(id: string): string | number;
 export declare function isSameMessageId(messageId: string, requestedId: string): boolean;
 export declare function filterMessagesAfter(messages: SessionRecord["messages"], afterMessageId: string | number | null | undefined): SessionRecord["messages"];
 export declare function clientVisibleMessages(messages: SessionRecord["messages"]): SessionRecord["messages"];
-export declare function toSnapshotMessage(sessionId: string, message: SessionRecord["messages"][number], requests: SessionRequestRecord[]): SessionSnapshotMessage;
+export declare function toSnapshotMessage(sessionId: string, message: SessionRecord["messages"][number], requests: SessionRequestRecord[], resolveRequestId?: (message: SessionRecord["messages"][number]) => string | null): SessionSnapshotMessage;
+export declare function createMessageRequestIdResolver(requests: SessionRequestRecord[]): (message: SessionRecord["messages"][number]) => string | null;
 export declare function toSnapshotRequest(request: SessionRequestRecord): SessionSnapshotRequest;
 export declare function normalizeSessionTitle(title: string): string;
 export declare function toSessionListItem(session: SessionRecord): {
@@ -26,5 +28,6 @@ export declare function toSessionListItem(session: SessionRecord): {
         name: string;
         directory: string;
     }> | undefined;
+    kind?: "spark" | undefined;
     id: string;
 };

package/dist/src/sessions/record/projection.js

@@ -1,3 +1,4 @@
+import { isAssistantInitiativeMessage } from "../assistant-initiative-message.js";
 import { projectSessionRequestLifecycle } from "../request-lifecycle/projection.js";
 function getRequestEventCompactionKey(payload) {
     const type = typeof payload.type === "string" ? payload.type : "";
@@ -86,7 +87,7 @@ export function getRequestFinalState(request) {
     }
     return null;
 }
-function toMessageIdForUi(id) {
+export function toMessageIdForUi(id) {
     const match = /^msg-(\d+)$/.exec(id);
     if (match) {
         return Number(match[1]);
@@ -142,7 +143,7 @@ function messageSource(message) {
     }
     return message.role === "user" ? "user" : "request";
 }
-export function toSnapshotMessage(sessionId, message, requests) {
+export function toSnapshotMessage(sessionId, message, requests, resolveRequestId = createMessageRequestIdResolver(requests)) {
     return {
         ...(message.kind ? { kind: message.kind } : {}),
         ...(message.approvalRequest
@@ -154,7 +155,7 @@ export function toSnapshotMessage(sessionId, message, requests) {
         text: message.content,
         source: messageSource(message),
         createdAt: toEpochMs(message.createdAt),
-        requestId: message.requestId ?? inferMessageRequestId(message, requests),
+        requestId: resolveRequestId(message),
         cronJobId: message.cronJobId ?? null,
         ...(message.initiative ? { initiative: message.initiative } : {}),
         ...(message.schedule ? { schedule: message.schedule } : {}),
@@ -165,20 +166,30 @@ export function toSnapshotMessage(sessionId, message, requests) {
             : {}),
     };
 }
-function inferMessageRequestId(message, requests) {
-    if (message.role !== "assistant") {
-        return null;
-    }
-    for (let index = requests.length - 1; index >= 0; index -= 1) {
-        const request = requests[index];
+export function createMessageRequestIdResolver(requests) {
+    let completedOutputs;
+    return (message) => {
+        if (message.requestId != null)
+            return message.requestId;
+        if (isAssistantInitiativeMessage(message))
+            return null;
+        if (message.role !== "assistant")
+            return null;
+        completedOutputs ??= indexCompletedRequestOutputs(requests);
+        return completedOutputs.get(message.content) ?? null;
+    };
+}
+function indexCompletedRequestOutputs(requests) {
+    const outputs = new Map();
+    for (const request of requests) {
         const finalState = getRequestFinalState(request);
-        if (finalState?.status === "completed" &&
-            typeof finalState.output === "string" &&
-            finalState.output === message.content) {
-            return request.requestId;
-        }
+        if (finalState?.status !== "completed")
+            continue;
+        if (typeof finalState.output !== "string")
+            continue;
+        outputs.set(finalState.output, request.requestId);
     }
-    return null;
+    return outputs;
 }
 export function toSnapshotRequest(request) {
     return {
@@ -209,6 +220,7 @@ export function toSessionListItem(session) {
         .find((message) => message.role === "assistant");
     return {
         id: session.id,
+        ...(session.kind ? { kind: session.kind } : {}),
         ...(session.project ? { project: session.project } : {}),
         title: session.title,
         createdAt: toEpochMs(session.createdAt),

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

@@ -10,7 +10,7 @@ import { acceptedLifecycle, appendLifecycleEvent, lifecycleRequest, rejectLifecy
 /** 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) {
+    async function mutate(sessionId, operation, metadataChange = "projection") {
         assertValidSessionId(sessionId);
         return dependencies.enqueue(sessionId, async () => {
             const session = await dependencies.read(sessionId);
@@ -24,7 +24,7 @@ export function createSessionRequestLifecycle(dependencies) {
             });
             if (!result.accepted || result.duplicate)
                 return result;
-            await saveDurableSessionFile(dependencies.sessionsDir, session);
+            await saveDurableSessionFile(dependencies.sessionsDir, session, undefined, metadataChange);
             await cleanupConsumedSessionContinuations(dependencies.sessionsDir, session, previousBlobs);
             return result;
         });
@@ -59,7 +59,7 @@ export function createSessionRequestLifecycle(dependencies) {
             return acceptedLifecycle(request, [
                 appendLifecycleEvent(context, request, command.payload),
             ]);
-        }),
+        }, "request-only"),
         async get(sessionId, requestId) {
             const request = await readRequest(sessionId, requestId);
             return request ? (projectSessionRequestLifecycle(request) ?? null) : null;

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

@@ -1,3 +1,5 @@
+import { type SessionSnapshotOptions } from "./snapshot.js";
+import { type AutomationSessionHandle, type AutomationSessionOrigin } from "./automation-session-origin.js";
 import type { SessionRequestLifecycleStore } from "./request-lifecycle/contracts.js";
 import { type CreateAssistantConversationInput } from "./assistant-initiative.js";
 import { type SessionCreationOptions } from "./project-binding.js";
@@ -12,10 +14,17 @@ type SessionServiceOptions = {
 export declare class SessionService {
     readonly requestLifecycle: SessionRequestLifecycleStore;
     private readonly sessionsDir;
+    private readonly automationAccess;
+    private readonly automationSessions;
     private readonly now;
     private readonly createMessageId;
     private readonly sessionMutationQueues;
     constructor(options?: SessionServiceOptions);
+    assertInteractiveSession(sessionId: string): Promise<void>;
+    createAutomationSession(sessionId: string, origin: AutomationSessionOrigin): Promise<AutomationSessionHandle>;
+    releaseAutomationSession(handle: AutomationSessionHandle): void;
+    reconcileAutomationSessions(cleanupAttachments: (sessionId: string) => Promise<void>, onError: (sessionId: string, error: unknown) => void): Promise<void>;
+    runAsAutomationSession<T>(handle: AutomationSessionHandle, task: () => Promise<T>): Promise<T>;
     getOrCreateSession(sessionId: string, options?: SessionCreationOptions): Promise<SessionRecord>;
     getAllSessions(): Promise<SessionRecord[]>;
     listSessions(params?: {
@@ -23,10 +32,7 @@ export declare class SessionService {
         cursor?: string | null;
     }): Promise<SessionListResult>;
     getSessionById(sessionId: string): Promise<SessionRecord | null>;
-    getSessionSnapshot(sessionId: string, options?: {
-        afterMessageId?: string | number | null;
-        includeRequests?: boolean;
-    }): Promise<SessionSnapshot | null>;
+    getSessionSnapshot(sessionId: string, options?: SessionSnapshotOptions): Promise<SessionSnapshot | null>;
     getRequestReplayById(requestId: string, afterSeq?: number): Promise<SessionRequestReplay | null>;
     deleteSession(sessionId: string): Promise<boolean>;
     deleteSessionWithStats(sessionId: string): Promise<SessionDeleteResult>;
@@ -50,6 +56,7 @@ export declare class SessionService {
         attachments?: SessionMessage["attachments"];
     }): Promise<SessionRecord>;
     createAssistantConversation(sessionId: string, input: CreateAssistantConversationInput): Promise<SessionRecord>;
+    appendAssistantInitiative(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,7 @@
+import { projectSessionSnapshot } from "./snapshot.js";
 import { randomUUID } from "node:crypto";
+import { AutomationSessionLockedError, createAutomationSessionAccess, hasAutomationSessionOrigin, } from "./automation-session-origin.js";
+import { createAutomationSessionStore } from "./automation-session-store.js";
 import { saveDurableSessionFile } from "./durable-session-commit.js";
 import { cleanupSessionContinuations } from "./request-lifecycle/continuation-cleanup.js";
 import { createSessionRequestLifecycle } from "./request-lifecycle/service.js";
@@ -7,16 +10,20 @@ 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";
-import { clientVisibleMessages, compactRequestEvents, filterMessagesAfter, getRequestFinalState, getSessionRequest, isSameMessageId, normalizeAfterSeq, normalizeCursor, normalizeLimit, normalizeSessionTitle, toClientReplayEvent, toEpochMs, toSessionListItem, toSnapshotMessage, toSnapshotRequest, } from "./record/projection.js";
+import { compactRequestEvents, getRequestFinalState, getSessionRequest, isSameMessageId, normalizeAfterSeq, normalizeCursor, normalizeLimit, normalizeSessionTitle, toClientReplayEvent, toEpochMs, toSessionListItem, } from "./record/projection.js";
 import { assertValidRequestId, assertValidSessionId, createContextEntryId, defaultCreateMessageId, pruneSupersededContextEntries, } from "./record/rules.js";
 import { deleteSessionFile, ensureSessionsDir, loadAllSessionFiles, loadSessionFile, saveSessionFile, } from "./session-store.js";
 import { resolveSessionMemoryCheckpointCommit } from "./memory/rules.js";
+import { assertSessionKindUnchanged, sessionKindCreationFields } from "./spark-session.js";
+import { appendAssistantInitiativeRecord } from "./assistant-initiative-append.js";
 function toIso(now) {
     return now().toISOString();
 }
 export class SessionService {
     requestLifecycle;
     sessionsDir;
+    automationAccess = createAutomationSessionAccess();
+    automationSessions;
     now;
     createMessageId;
     sessionMutationQueues = new Map();
@@ -24,6 +31,10 @@ export class SessionService {
         this.sessionsDir =
             options.sessionsDir || getDefaultSessionsDir(process.cwd());
         this.now = options.now || (() => new Date());
+        this.automationSessions = createAutomationSessionStore({
+            sessionsDir: this.sessionsDir, now: this.now, access: this.automationAccess,
+            enqueue: this.runSessionMutation.bind(this),
+        });
         this.createMessageId = options.createMessageId || defaultCreateMessageId;
         this.requestLifecycle = createSessionRequestLifecycle({
             sessionsDir: this.sessionsDir,
@@ -34,12 +45,32 @@ export class SessionService {
             list: this.getAllSessions.bind(this),
         });
     }
+    async assertInteractiveSession(sessionId) {
+        assertValidSessionId(sessionId);
+        const session = await loadSessionFile(this.sessionsDir, sessionId);
+        if (session && hasAutomationSessionOrigin(session))
+            throw new AutomationSessionLockedError();
+    }
+    async createAutomationSession(sessionId, origin) {
+        return this.automationSessions.create(sessionId, origin);
+    }
+    releaseAutomationSession(handle) {
+        this.automationSessions.release(handle);
+    }
+    reconcileAutomationSessions(cleanupAttachments, onError) {
+        return this.automationSessions.reconcile(cleanupAttachments, onError);
+    }
+    runAsAutomationSession(handle, task) {
+        return this.automationAccess.run(handle, task);
+    }
     async getOrCreateSession(sessionId, options = {}) {
         assertValidSessionId(sessionId);
         await ensureSessionsDir(this.sessionsDir);
         const existing = await loadSessionFile(this.sessionsDir, sessionId);
         if (existing) {
+            this.automationAccess.assertAccess(sessionId, existing);
             assertSessionProjectUnchanged(existing, options.project);
+            assertSessionKindUnchanged(existing, options.kind);
             return existing;
         }
         const timestamp = toIso(this.now);
@@ -48,7 +79,7 @@ export class SessionService {
             ...(options.project
                 ? { project: copySessionProject(options.project) }
                 : {}),
-            title: sessionId,
+            ...sessionKindCreationFields(sessionId, options),
             createdAt: timestamp,
             updatedAt: timestamp,
             lastAgentMode: "reasoning",
@@ -60,7 +91,9 @@ export class SessionService {
     }
     async getAllSessions() {
         const sessions = await loadAllSessionFiles(this.sessionsDir);
-        return sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+        return sessions
+            .filter((session) => this.automationAccess.canAccess(session.id, session))
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     }
     async listSessions(params = {}) {
         const limit = normalizeLimit(params.limit);
@@ -76,29 +109,22 @@ export class SessionService {
     async getSessionById(sessionId) {
         assertValidSessionId(sessionId);
         await ensureSessionsDir(this.sessionsDir);
-        return loadSessionFile(this.sessionsDir, sessionId);
+        const session = await loadSessionFile(this.sessionsDir, sessionId);
+        return session && this.automationAccess.canAccess(sessionId, session)
+            ? session
+            : null;
     }
     async getSessionSnapshot(sessionId, options = {}) {
         const session = await this.getSessionById(sessionId);
-        if (!session) {
-            return null;
-        }
-        return {
-            sessionId,
-            ...(session.project ? { project: session.project } : {}),
-            title: session.title,
-            messages: filterMessagesAfter(clientVisibleMessages(session.messages), options.afterMessageId).map((message) => toSnapshotMessage(sessionId, message, session.requests ?? [])),
-            requests: options.includeRequests === false
-                ? []
-                : (session.requests ?? []).map(toSnapshotRequest),
-            nextCursor: null,
-        };
+        return session ? projectSessionSnapshot(session, options) : null;
     }
     async getRequestReplayById(requestId, afterSeq = 0) {
         assertValidRequestId(requestId);
         const normalizedAfterSeq = normalizeAfterSeq(afterSeq);
         const sessions = await loadAllSessionFiles(this.sessionsDir);
         for (const session of sessions) {
+            if (!this.automationAccess.canAccess(session.id, session))
+                continue;
             const request = getSessionRequest(session, requestId);
             if (!request) {
                 continue;
@@ -259,6 +285,12 @@ export class SessionService {
             now: this.now(),
         }));
     }
+    async appendAssistantInitiative(sessionId, input) {
+        assertValidSessionId(sessionId);
+        return this.runSessionMutation(sessionId, () => appendAssistantInitiativeRecord({
+            directory: this.sessionsDir, sessionId, input, now: this.now(),
+        }));
+    }
     async compareAndSwapSessionMemoryCheckpoint(sessionId, command) {
         assertValidSessionId(sessionId);
         return this.runSessionMutation(sessionId, async () => {
@@ -396,7 +428,7 @@ export class SessionService {
                 request.status = "streaming";
             }
             session.updatedAt = timestamp;
-            await saveSessionFile(this.sessionsDir, session);
+            await saveSessionFile(this.sessionsDir, session, undefined, "request-only");
             return session;
         });
     }
@@ -472,7 +504,12 @@ export class SessionService {
     }
     async runSessionMutation(sessionId, mutation) {
         const previous = this.sessionMutationQueues.get(sessionId) ?? Promise.resolve();
-        const current = previous.catch(() => undefined).then(mutation);
+        const current = previous.catch(() => undefined).then(async () => {
+            const existing = await loadSessionFile(this.sessionsDir, sessionId);
+            if (existing)
+                this.automationAccess.assertAccess(sessionId, existing);
+            return mutation();
+        });
         const queued = current.then(() => undefined, () => undefined);
         this.sessionMutationQueues.set(sessionId, queued);
         try {

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

@@ -1,6 +1,7 @@
 import type { SessionRecord } from "./types.js";
+import type { SessionMetadataChange } from "./metadata/source-receipt.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, assertCurrent?: () => void): Promise<void>;
+export declare function saveSessionFile(sessionsDir: string, session: SessionRecord, assertCurrent?: () => void, metadataChange?: SessionMetadataChange): 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,8 +1,9 @@
-import { mkdir, readdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
+import { mkdir, readdir, readFile, rename, rm, stat, 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";
+import { currentSourceStamp, deleteSessionMetadata, sessionSourceStamp, updateSessionMetadata } from "./metadata/store.js";
 function getSessionFilePath(sessionsDir, sessionId) {
     return join(sessionsDir, `${sessionId}.json`);
 }
@@ -22,14 +23,17 @@ export async function loadSessionFile(sessionsDir, sessionId) {
         throw error;
     }
 }
-export async function saveSessionFile(sessionsDir, session, assertCurrent) {
+export async function saveSessionFile(sessionsDir, session, assertCurrent, metadataChange = "projection") {
     if (session.requests?.some((request) => request.lifecycle)) {
-        return saveDurableSessionFile(sessionsDir, session, assertCurrent);
+        return saveDurableSessionFile(sessionsDir, session, assertCurrent, metadataChange);
     }
     const filePath = getSessionFilePath(sessionsDir, session.id);
+    const previousSource = metadataChange === "request-only" ? await currentSourceStamp(filePath) : undefined;
     const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+    let source;
     try {
         await writeFile(tempPath, JSON.stringify(session, null, 2), "utf-8");
+        source = sessionSourceStamp(await stat(tempPath, { bigint: true }));
         assertCurrent?.();
         await rename(tempPath, filePath);
     }
@@ -37,12 +41,14 @@ export async function saveSessionFile(sessionsDir, session, assertCurrent) {
         await rm(tempPath, { force: true }).catch(() => undefined);
         throw error;
     }
+    await updateSessionMetadata(sessionsDir, session, source, previousSource);
 }
 export async function deleteSessionFile(sessionsDir, sessionId) {
     const filePath = getSessionFilePath(sessionsDir, sessionId);
     try {
         await rm(filePath);
         await syncSessionDirectory(sessionsDir);
+        await deleteSessionMetadata(sessionsDir, sessionId);
         await cleanupSessionContinuations(sessionsDir, sessionId);
         return true;
     }