@myagentroam/node 0.1.0

package/dist/runtime-state.js

@@ -0,0 +1,957 @@
+import { randomUUID } from 'node:crypto';
+/**
+ * Deliberately process-local runtime domain.  No method in this class writes
+ * into Node SQLite: a Node restart loses active runs, approvals, leases and
+ * managed-session aliases by design.  Durable conversation history belongs to
+ * the Runner/native transcript, never to MAR.
+ */
+export class NodeRuntimeState {
+    nodeId;
+    getWorkspace;
+    now;
+    sessions = new Map();
+    runs = new Map();
+    messageRuns = new Map();
+    events = new Map();
+    turns = new Map();
+    approvals = new Map();
+    workspaceEvents = new Map();
+    /** A Session owns at most one running turn; Workspace sessions may run concurrently. */
+    leases = new Map();
+    /** Session FIFO metadata is deliberately process-local with the rest of run state. */
+    queuedRuns = new Map();
+    queueVersions = new Map();
+    pausedQueues = new Set();
+    snapshots = new Map();
+    nextEventId = 1;
+    nextWorkspaceEventId = 1;
+    constructor(nodeId, getWorkspace, now = Date.now) {
+        this.nodeId = nodeId;
+        this.getWorkspace = getWorkspace;
+        this.now = now;
+    }
+    activeWorkspaceLeaseCount() {
+        return this.leases.size;
+    }
+    activeSessionRun(sessionId) {
+        const runId = this.leases.get(sessionId);
+        return runId === undefined ? undefined : this.runs.get(runId);
+    }
+    hasActiveSessionLease(sessionId) {
+        return this.leases.has(sessionId);
+    }
+    createAgentSession(input) {
+        if (this.getWorkspace(input.workspaceId) === undefined)
+            throw new Error('WORKSPACE_NOT_FOUND');
+        const now = this.now();
+        const id = input.externalSessionId ?? randomUUID();
+        if (this.sessions.has(id))
+            throw new Error('SESSION_ID_CONFLICT');
+        const value = {
+            id,
+            nodeId: this.nodeId(),
+            workspaceId: input.workspaceId,
+            runner: input.runner,
+            externalSessionId: input.externalSessionId ?? null,
+            nativeControl: input.externalSessionId === undefined ? 'MAR_MANAGED' : (input.nativeControl ?? 'EXTERNAL'),
+            channelToken: null,
+            cwd: input.cwd,
+            model: input.model ?? null,
+            effort: input.effort ?? null,
+            access: input.access ?? null,
+            customTitle: null,
+            runnerTitle: input.title?.trim().slice(0, 160) || null,
+            pinnedAt: null,
+            // A first user prompt is only a process-local temporary title. A
+            // Runner/native title can replace it on the next discovery refresh.
+            titleSource: 'AUTO',
+            lastActivityAt: now,
+            createdAt: now
+        };
+        this.sessions.set(value.id, value);
+        return value;
+    }
+    /** Internal envelope compatibility for a Run already accepted in this process. */
+    adoptRun(input) {
+        let session = this.sessions.get(input.sessionId);
+        if (session === undefined) {
+            const now = this.now();
+            session = {
+                id: input.sessionId,
+                nodeId: this.nodeId(),
+                workspaceId: input.workspaceId ?? `runtime:${input.cwd}`,
+                runner: input.runner,
+                externalSessionId: input.externalSessionId ?? null,
+                nativeControl: input.externalSessionId === undefined ? 'MAR_MANAGED' : 'EXTERNAL',
+                channelToken: null,
+                cwd: input.cwd,
+                model: null,
+                effort: null,
+                access: null,
+                customTitle: null,
+                runnerTitle: null,
+                pinnedAt: null,
+                titleSource: 'AUTO',
+                lastActivityAt: now,
+                createdAt: now
+            };
+            this.sessions.set(session.id, session);
+        }
+        const existing = this.runs.get(input.runId);
+        if (existing !== undefined)
+            return existing;
+        const now = this.now();
+        const run = {
+            id: input.runId,
+            sessionId: session.id,
+            nodeId: this.nodeId(),
+            workspaceId: session.workspaceId,
+            runner: session.runner,
+            status: 'QUEUED',
+            recoveryState: 'ACTIVE',
+            version: 0,
+            clientMessageId: input.clientMessageId ?? input.runId,
+            createdAt: now,
+            updatedAt: now
+        };
+        this.runs.set(run.id, run);
+        this.leases.set(run.sessionId, run.id);
+        return run;
+    }
+    getAgentSession(id) {
+        return (this.sessions.get(id) ??
+            [...this.sessions.values()].find((value) => value.externalSessionId === id));
+    }
+    listAgentSessions() {
+        return [...this.sessions.values()].sort((a, b) => b.lastActivityAt - a.lastActivityAt);
+    }
+    findAgentSessionByExternalSession(runner, externalSessionId) {
+        return [...this.sessions.values()].find((value) => value.runner === runner && value.externalSessionId === externalSessionId);
+    }
+    updateAgentSessionConfiguration(input) {
+        return this.replaceSession(input.sessionId, {
+            model: input.model,
+            effort: input.effort,
+            access: input.access
+        });
+    }
+    setNativeControl(id, nativeControl) {
+        this.replaceSession(id, { nativeControl });
+    }
+    setExternalSessionId(id, externalSessionId) {
+        if (externalSessionId.length === 0)
+            throw new Error('SESSION_EXTERNAL_ID_INVALID');
+        this.promoteSessionIdentity(id, externalSessionId);
+    }
+    /**
+     * Atomically replaces the bootstrap Session key with the Runner-native ID.
+     * No caller may migrate the individual runtime maps independently.
+     */
+    promoteSessionIdentity(id, nativeSessionId) {
+        if (nativeSessionId.length === 0)
+            throw new Error('SESSION_EXTERNAL_ID_INVALID');
+        const current = this.requireSession(id);
+        if (id === nativeSessionId)
+            return this.replaceSession(id, {
+                externalSessionId: nativeSessionId,
+                nativeControl: 'MAR_MANAGED'
+            });
+        const collision = this.sessions.get(nativeSessionId);
+        if (collision !== undefined && collision.id !== current.id)
+            throw new Error('SESSION_ID_CONFLICT');
+        const next = {
+            ...current,
+            id: nativeSessionId,
+            externalSessionId: nativeSessionId,
+            nativeControl: 'MAR_MANAGED'
+        };
+        const runs = this.listRunsForSession(id);
+        const turns = this.turns.get(id) ?? [];
+        const queue = this.queuedRuns.get(id);
+        const queueVersion = this.queueVersions.get(id);
+        const lease = this.leases.get(id);
+        const paused = this.pausedQueues.has(id);
+        this.sessions.delete(id);
+        this.sessions.set(nativeSessionId, next);
+        for (const run of runs)
+            this.runs.set(run.id, { ...run, sessionId: nativeSessionId });
+        this.turns.delete(id);
+        this.turns.set(nativeSessionId, turns.map((turn) => ({
+            ...turn,
+            sessionId: nativeSessionId,
+            items: turn.items.map((item) => ({ ...item, sessionId: nativeSessionId }))
+        })));
+        if (queue !== undefined) {
+            this.queuedRuns.delete(id);
+            this.queuedRuns.set(nativeSessionId, queue);
+        }
+        if (queueVersion !== undefined) {
+            this.queueVersions.delete(id);
+            this.queueVersions.set(nativeSessionId, queueVersion);
+        }
+        if (lease !== undefined) {
+            this.leases.delete(id);
+            this.leases.set(nativeSessionId, lease);
+        }
+        if (paused) {
+            this.pausedQueues.delete(id);
+            this.pausedQueues.add(nativeSessionId);
+        }
+        for (const [key, runId] of [...this.messageRuns]) {
+            if (!key.startsWith(`${id}\u0000`))
+                continue;
+            this.messageRuns.delete(key);
+            this.messageRuns.set(`${nativeSessionId}${key.slice(id.length)}`, runId);
+        }
+        return next;
+    }
+    setChannelToken(id, channelToken) {
+        if (channelToken.length < 16)
+            throw new Error('SESSION_CHANNEL_TOKEN_INVALID');
+        this.replaceSession(id, { channelToken });
+    }
+    updateSessionMetadata(input) {
+        const current = this.requireSession(input.sessionId);
+        const title = input.customTitle === undefined ? current.customTitle : input.customTitle?.trim() || null;
+        if (title !== null && title.length > 160)
+            throw new Error('SESSION_TITLE_INVALID');
+        return this.replaceSession(current.id, {
+            customTitle: title,
+            pinnedAt: input.pinned === undefined ? current.pinnedAt : input.pinned ? this.now() : null,
+            titleSource: title === null ? 'AUTO' : 'CUSTOM'
+        });
+    }
+    /**
+     * Give a just-created managed Session a readable local title before the
+     * Runner has written its own transcript title. This intentionally never
+     * replaces a user rename or a Runner-provided title.
+     */
+    setTemporaryTitleIfMissing(id, title) {
+        const current = this.requireSession(id);
+        const value = title.trim().replace(/\s+/g, ' ').slice(0, 160);
+        if (value.length === 0 || current.customTitle !== null || current.runnerTitle !== null)
+            return current;
+        return this.replaceSession(id, { runnerTitle: value, titleSource: 'AUTO' });
+    }
+    /**
+     * Runner/native discovery is authoritative for its own title. Keep it on
+     * the managed Session so later `session.get` polls cannot regress to an
+     * empty fallback after a discovery response has already shown the title.
+     */
+    setRunnerTitleFromNative(id, title) {
+        const current = this.requireSession(id);
+        const value = title.trim().replace(/\s+/g, ' ').slice(0, 160);
+        if (value.length === 0 || current.customTitle !== null || current.runnerTitle === value)
+            return current;
+        return this.replaceSession(id, { runnerTitle: value, titleSource: 'RUNNER' });
+    }
+    createMessageRun(input) {
+        const key = `${input.sessionId}\u0000${input.clientMessageId}`;
+        const duplicate = this.messageRuns.get(key);
+        if (duplicate !== undefined)
+            return { run: this.requireRun(duplicate), created: false };
+        const session = this.requireSession(input.sessionId);
+        const now = this.now();
+        const run = {
+            id: randomUUID(),
+            sessionId: session.id,
+            nodeId: this.nodeId(),
+            workspaceId: session.workspaceId,
+            runner: session.runner,
+            status: 'QUEUED',
+            recoveryState: 'ACTIVE',
+            version: 0,
+            clientMessageId: input.clientMessageId,
+            createdAt: now,
+            updatedAt: now
+        };
+        let imageIndex = 0;
+        const attachments = (input.attachments ?? []).map(({ name, mime, dataBase64 }) => {
+            const attachment = {
+                name,
+                mime,
+                byteSize: Buffer.byteLength(dataBase64, 'base64'),
+                runId: run.id
+            };
+            if (!mime.startsWith('image/'))
+                return attachment;
+            return { ...attachment, imageIndex: imageIndex++ };
+        });
+        const user = {
+            id: randomUUID(),
+            sessionId: session.id,
+            turnId: '',
+            runId: run.id,
+            parentItemId: null,
+            sourceSequence: null,
+            revision: 0,
+            kind: 'user_message',
+            status: 'COMPLETED',
+            payload: {
+                clientMessageId: input.clientMessageId,
+                text: input.content,
+                contexts: [],
+                attachments,
+                delivery: 'ACCEPTED'
+            },
+            startedAt: now,
+            completedAt: now
+        };
+        const turn = {
+            id: randomUUID(),
+            sessionId: session.id,
+            runId: run.id,
+            userItemId: user.id,
+            status: 'QUEUED',
+            model: session.model,
+            effort: session.effort,
+            access: session.access,
+            items: [user],
+            startedAt: null,
+            completedAt: null
+        };
+        const fixedTurn = { ...turn, items: [{ ...user, turnId: turn.id }] };
+        this.runs.set(run.id, run);
+        this.messageRuns.set(key, run.id);
+        this.queuedRuns.set(session.id, [...(this.queuedRuns.get(session.id) ?? []), run.id]);
+        this.bumpQueueVersion(session.id);
+        this.turns.set(session.id, [...(this.turns.get(session.id) ?? []), fixedTurn]);
+        this.recordWorkspaceActivity(run.workspaceId, 'run.created', {
+            runId: run.id,
+            sessionId: session.id,
+            runner: run.runner
+        });
+        this.replaceSession(session.id, { lastActivityAt: now });
+        return { run, created: true };
+    }
+    sessionQueue(sessionId) {
+        return {
+            version: this.queueVersions.get(sessionId) ?? 0,
+            paused: this.pausedQueues.has(sessionId),
+            runIds: this.queuedRuns.get(sessionId) ?? []
+        };
+    }
+    isQueuedRun(runId) {
+        const run = this.requireRun(runId);
+        return (this.queuedRuns.get(run.sessionId) ?? []).includes(runId);
+    }
+    claimNextQueuedRun(sessionId) {
+        if (this.leases.has(sessionId) || this.pausedQueues.has(sessionId))
+            return undefined;
+        const queue = this.queuedRuns.get(sessionId) ?? [];
+        const runId = queue[0];
+        if (runId === undefined)
+            return undefined;
+        this.queuedRuns.set(sessionId, queue.slice(1));
+        this.bumpQueueVersion(sessionId);
+        const run = this.requireRun(runId);
+        this.leases.set(sessionId, run.id);
+        return run;
+    }
+    pauseSessionQueue(sessionId) {
+        this.pausedQueues.add(sessionId);
+        this.bumpQueueVersion(sessionId);
+    }
+    resumeSessionQueue(sessionId) {
+        if (!this.pausedQueues.delete(sessionId))
+            return;
+        this.bumpQueueVersion(sessionId);
+    }
+    reorderSessionQueue(sessionId, expectedVersion, runIds) {
+        const current = this.queuedRuns.get(sessionId) ?? [];
+        if (this.sessionQueue(sessionId).version !== expectedVersion ||
+            current.length !== runIds.length ||
+            new Set(current).size !== current.length ||
+            current.some((runId) => !runIds.includes(runId)))
+            throw new Error('QUEUE_VERSION_CONFLICT');
+        if (runIds.some((runId) => this.requireRun(runId).status !== 'QUEUED'))
+            throw new Error('QUEUE_ITEM_INVALID');
+        this.queuedRuns.set(sessionId, [...runIds]);
+        this.bumpQueueVersion(sessionId);
+    }
+    prioritizeQueuedRun(runId) {
+        const run = this.requireRun(runId);
+        const queue = this.queuedRuns.get(run.sessionId) ?? [];
+        if (!queue.includes(runId) || run.status !== 'QUEUED')
+            throw new Error('QUEUE_ITEM_INVALID');
+        this.queuedRuns.set(run.sessionId, [
+            runId,
+            ...queue.filter((candidate) => candidate !== runId)
+        ]);
+        this.bumpQueueVersion(run.sessionId);
+        return run;
+    }
+    updateQueuedMessage(runId, content) {
+        const run = this.requireRun(runId);
+        if (!(this.queuedRuns.get(run.sessionId) ?? []).includes(runId) || run.status !== 'QUEUED')
+            throw new Error('QUEUE_ITEM_INVALID');
+        this.updateTurnForRun(runId, (turn) => ({
+            ...turn,
+            items: turn.items.map((item) => item.id === turn.userItemId && isRecord(item.payload)
+                ? { ...item, payload: { ...item.payload, text: content } }
+                : item)
+        }));
+        return run;
+    }
+    deleteQueuedRun(runId) {
+        const run = this.requireRun(runId);
+        const queue = this.queuedRuns.get(run.sessionId) ?? [];
+        if (!queue.includes(runId) || run.status !== 'QUEUED')
+            throw new Error('QUEUE_ITEM_INVALID');
+        this.queuedRuns.set(run.sessionId, queue.filter((candidate) => candidate !== runId));
+        this.bumpQueueVersion(run.sessionId);
+        this.runs.delete(runId);
+        this.events.delete(runId);
+        this.snapshots.delete(runId);
+        this.turns.set(run.sessionId, (this.turns.get(run.sessionId) ?? []).filter((turn) => turn.runId !== runId));
+        for (const [key, candidate] of this.messageRuns)
+            if (candidate === runId)
+                this.messageRuns.delete(key);
+    }
+    queuedMessageText(runId) {
+        const run = this.requireRun(runId);
+        const turn = (this.turns.get(run.sessionId) ?? []).find((candidate) => candidate.runId === runId);
+        const item = turn?.items.find((candidate) => candidate.id === turn.userItemId);
+        return isRecord(item?.payload) && typeof item.payload.text === 'string'
+            ? item.payload.text
+            : '';
+    }
+    getRun(id) {
+        return this.runs.get(id);
+    }
+    findMessageRun(sessionId, clientMessageId) {
+        const runId = this.messageRuns.get(`${sessionId}\u0000${clientMessageId}`);
+        return runId === undefined ? undefined : this.runs.get(runId);
+    }
+    listRunsForSession(sessionId) {
+        return [...this.runs.values()]
+            .filter((run) => run.sessionId === sessionId)
+            .sort((a, b) => b.createdAt - a.createdAt);
+    }
+    transitionRun(id, next) {
+        const current = this.requireRun(id);
+        if (!transitionAllowed(current.status, next))
+            throw new Error('RUN_STATE_INVALID');
+        const value = { ...current, status: next, version: current.version + 1, updatedAt: this.now() };
+        this.runs.set(id, value);
+        if (terminal(next) && this.leases.get(value.sessionId) === value.id)
+            this.leases.delete(value.sessionId);
+        this.updateTurnForRun(id, (turn) => ({
+            ...turn,
+            status: next,
+            completedAt: terminal(next) ? this.now() : turn.completedAt,
+            items: terminal(next)
+                ? turn.items.map((item) => activeConversationItem(item.status)
+                    ? { ...item, status: completedStatusForRun(next), completedAt: this.now() }
+                    : item)
+                : turn.items
+        }));
+        return value;
+    }
+    appendRunEvent(input) {
+        this.requireRun(input.runId);
+        const prior = this.events.get(input.runId) ?? [];
+        if (prior.some((event) => event.sequence === input.sequence))
+            return undefined;
+        if (input.sequence > (prior.at(-1)?.sequence ?? 0) + 1)
+            throw new Error('EVENT_SEQUENCE_GAP');
+        const value = {
+            id: this.nextEventId++,
+            runId: input.runId,
+            sequence: input.sequence,
+            eventType: input.eventType,
+            payload: input.payload,
+            ...(input.status === undefined ? {} : { status: input.status }),
+            createdAt: this.now()
+        };
+        this.events.set(input.runId, [...prior, value]);
+        if (input.status !== undefined)
+            this.transitionRun(input.runId, input.status);
+        this.projectEvent(value);
+        const run = this.requireRun(input.runId);
+        this.recordWorkspaceActivity(run.workspaceId, 'run.updated', {
+            runId: run.id,
+            eventType: input.eventType,
+            status: input.status ?? null
+        });
+        return value;
+    }
+    listRunEvents(id, after = 0) {
+        return (this.events.get(id) ?? []).filter((event) => event.sequence > after);
+    }
+    listConversationTurns(input) {
+        this.requireSession(input.sessionId);
+        // Queued turns have not received `run.started` yet. Their user item still
+        // has the acceptance timestamp, so use it rather than sorting every
+        // queued turn as time zero. The insertion index makes same-millisecond
+        // sends deterministic; callers receive newest first and render reverse.
+        const all = [...(this.turns.get(input.sessionId) ?? [])]
+            .map((turn, index) => ({ turn, index }))
+            .sort((a, b) => {
+            const timestamp = (value) => value.startedAt ??
+                value.items.find((item) => item.id === value.userItemId)?.startedAt ??
+                0;
+            return timestamp(b.turn) - timestamp(a.turn) || b.index - a.index;
+        })
+            .map(({ turn }) => turn);
+        const start = decodeCursor(input.cursor, input.sessionId);
+        const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
+        const slice = all.slice(start, start + limit);
+        return {
+            turns: slice,
+            nextCursor: start + limit < all.length ? encodeCursor(input.sessionId, start + limit) : null
+        };
+    }
+    conversationTurnForRun(runId) {
+        for (const turns of this.turns.values()) {
+            const turn = turns.find((candidate) => candidate.runId === runId);
+            if (turn !== undefined)
+                return turn;
+        }
+        return undefined;
+    }
+    listConversationItems(input) {
+        const turns = this.listConversationTurns(input).turns;
+        return { items: turns.flatMap((turn) => turn.items), nextCursor: null };
+    }
+    recordCommandExecution(input) {
+        const session = this.requireSession(input.sessionId);
+        const now = this.now();
+        const item = {
+            id: randomUUID(),
+            sessionId: input.sessionId,
+            turnId: '',
+            runId: null,
+            parentItemId: null,
+            sourceSequence: null,
+            revision: 1,
+            kind: 'command_execution',
+            status: input.failed ? 'FAILED' : 'COMPLETED',
+            payload: {
+                command: input.command,
+                cwd: input.cwd,
+                outputPreview: input.outputPreview.slice(0, 10_000),
+                outputRef: null,
+                exitCode: input.failed ? 1 : 0,
+                durationMs: 0,
+                truncated: false
+            },
+            startedAt: now,
+            completedAt: now
+        };
+        const turn = {
+            id: randomUUID(),
+            sessionId: input.sessionId,
+            runId: null,
+            userItemId: null,
+            status: input.failed ? 'FAILED' : 'SUCCEEDED',
+            model: session.model,
+            effort: session.effort,
+            access: session.access,
+            items: [],
+            startedAt: now,
+            completedAt: now
+        };
+        const completedItem = { ...item, turnId: turn.id };
+        const completedTurn = { ...turn, items: [completedItem] };
+        this.turns.set(input.sessionId, [...(this.turns.get(input.sessionId) ?? []), completedTurn]);
+        this.replaceSession(session.id, { lastActivityAt: now });
+        return completedTurn;
+    }
+    listWorkspaceActivity(input) {
+        const all = this.workspaceEvents.get(input.workspaceId) ?? [];
+        const start = decodeCursor(input.cursor, input.workspaceId);
+        const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
+        const events = all.slice(start, start + limit);
+        return {
+            events,
+            nextCursor: start + limit < all.length ? encodeCursor(input.workspaceId, start + limit) : null
+        };
+    }
+    createApproval(input) {
+        this.requireRun(input.runId);
+        if (this.approvals.has(input.approvalId))
+            throw new Error('APPROVAL_ALREADY_EXISTS');
+        if (input.expiresAt <= this.now())
+            throw new Error('APPROVAL_EXPIRED');
+        const value = {
+            id: input.approvalId,
+            runId: input.runId,
+            status: 'PENDING',
+            payload: input.payload,
+            expiresAt: input.expiresAt,
+            createdAt: this.now(),
+            decidedAt: null
+        };
+        this.approvals.set(value.id, value);
+        return value;
+    }
+    getApproval(id) {
+        const value = this.approvals.get(id);
+        if (value?.status === 'PENDING' && value.expiresAt <= this.now())
+            return this.expireApproval(id);
+        return value;
+    }
+    listApprovals(runId) {
+        return [...this.approvals.values()]
+            .filter((value) => value.runId === runId)
+            .map((value) => this.getApproval(value.id));
+    }
+    expireApproval(id) {
+        const value = this.requireApproval(id);
+        if (value.status !== 'PENDING')
+            return value;
+        if (value.expiresAt > this.now())
+            throw new Error('APPROVAL_NOT_EXPIRED');
+        const next = { ...value, status: 'EXPIRED', decidedAt: this.now() };
+        this.approvals.set(id, next);
+        return next;
+    }
+    decideApproval(id, decision) {
+        const value = this.getApproval(id);
+        if (value === undefined)
+            throw new Error('APPROVAL_NOT_FOUND');
+        if (value.status === 'EXPIRED')
+            throw new Error('APPROVAL_EXPIRED');
+        if (value.status !== 'PENDING')
+            throw new Error('APPROVAL_ALREADY_DECIDED');
+        const next = { ...value, status: decision, decidedAt: this.now() };
+        this.approvals.set(id, next);
+        return next;
+    }
+    expireDueApprovals() {
+        return [...this.approvals.values()]
+            .filter((value) => value.status === 'PENDING' && value.expiresAt <= this.now())
+            .map((value) => this.expireApproval(value.id));
+    }
+    listNonterminalRuns() {
+        return [...this.runs.values()].filter((run) => !terminal(run.status));
+    }
+    lastRunSequence(id) {
+        return this.events.get(id)?.at(-1)?.sequence ?? 0;
+    }
+    saveSnapshot(id, value) {
+        this.snapshots.set(id, value);
+    }
+    getSnapshot(id) {
+        return this.snapshots.get(id);
+    }
+    hasActiveWorkspaceLease(workspaceId) {
+        return [...this.leases.values()]
+            .map((runId) => this.runs.get(runId))
+            .some((run) => run?.workspaceId === workspaceId);
+    }
+    /** Removes a terminal Session's process-local projection after its native history is deleted. */
+    removeAgentSession(sessionId) {
+        this.requireSession(sessionId);
+        const runs = this.listRunsForSession(sessionId);
+        if (runs.some((run) => !terminal(run.status)))
+            throw new Error('SESSION_ACTIVE');
+        const runIds = new Set(runs.map((run) => run.id));
+        this.sessions.delete(sessionId);
+        this.turns.delete(sessionId);
+        this.queuedRuns.delete(sessionId);
+        this.queueVersions.delete(sessionId);
+        this.pausedQueues.delete(sessionId);
+        this.leases.delete(sessionId);
+        for (const runId of runIds) {
+            this.runs.delete(runId);
+            this.events.delete(runId);
+            this.snapshots.delete(runId);
+        }
+        for (const [key, runId] of this.messageRuns)
+            if (runIds.has(runId))
+                this.messageRuns.delete(key);
+        for (const [approvalId, approval] of this.approvals)
+            if (runIds.has(approval.runId))
+                this.approvals.delete(approvalId);
+    }
+    removeWorkspace(workspaceId) {
+        if (this.hasActiveWorkspaceLease(workspaceId))
+            throw new Error('WORKSPACE_BUSY');
+        const sessionIds = new Set([...this.sessions.values()]
+            .filter((session) => session.workspaceId === workspaceId)
+            .map((session) => session.id));
+        const runIds = new Set([...this.runs.values()].filter((run) => run.workspaceId === workspaceId).map((run) => run.id));
+        for (const sessionId of sessionIds) {
+            this.sessions.delete(sessionId);
+            this.turns.delete(sessionId);
+        }
+        for (const runId of runIds) {
+            this.runs.delete(runId);
+            this.events.delete(runId);
+            this.snapshots.delete(runId);
+        }
+        for (const [key, runId] of this.messageRuns)
+            if (runIds.has(runId))
+                this.messageRuns.delete(key);
+        for (const [approvalId, approval] of this.approvals)
+            if (runIds.has(approval.runId))
+                this.approvals.delete(approvalId);
+        this.workspaceEvents.delete(workspaceId);
+        for (const sessionId of sessionIds) {
+            this.queuedRuns.delete(sessionId);
+            this.queueVersions.delete(sessionId);
+            this.pausedQueues.delete(sessionId);
+            this.leases.delete(sessionId);
+        }
+    }
+    reconcileRun(id, active) {
+        // There is no cross-restart run recovery: this process-local state is
+        // discarded on restart and cannot be reconciled from SQLite.
+        void id;
+        void active;
+    }
+    replaceSession(id, patch) {
+        const value = this.requireSession(id);
+        const next = { ...value, ...patch };
+        this.sessions.set(id, next);
+        return next;
+    }
+    bumpQueueVersion(sessionId) {
+        this.queueVersions.set(sessionId, (this.queueVersions.get(sessionId) ?? 0) + 1);
+    }
+    requireSession(id) {
+        const value = this.sessions.get(id);
+        if (value === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        return value;
+    }
+    requireRun(id) {
+        const value = this.runs.get(id);
+        if (value === undefined)
+            throw new Error('RUN_NOT_FOUND');
+        return value;
+    }
+    requireApproval(id) {
+        const value = this.approvals.get(id);
+        if (value === undefined)
+            throw new Error('APPROVAL_NOT_FOUND');
+        return value;
+    }
+    recordWorkspaceActivity(workspaceId, eventType, payload) {
+        const event = {
+            id: this.nextWorkspaceEventId++,
+            workspaceId,
+            eventType,
+            payload,
+            createdAt: this.now()
+        };
+        this.workspaceEvents.set(workspaceId, [
+            ...(this.workspaceEvents.get(workspaceId) ?? []),
+            event
+        ]);
+    }
+    updateTurnForRun(runId, update) {
+        const run = this.requireRun(runId);
+        const current = this.turns.get(run.sessionId) ?? [];
+        this.turns.set(run.sessionId, current.map((turn) => (turn.runId === runId ? update(turn) : turn)));
+    }
+    projectEvent(event) {
+        const run = this.requireRun(event.runId);
+        this.updateTurnForRun(event.runId, (turn) => {
+            if (event.eventType === 'text.delta' &&
+                isRecord(event.payload) &&
+                typeof event.payload.text === 'string') {
+                const existing = turn.items.find((item) => item.id === `${event.runId}:assistant`);
+                const text = `${existing === undefined ? '' : readableText(existing.payload)}${event.payload.text}`;
+                const item = {
+                    id: `${event.runId}:assistant`,
+                    sessionId: run.sessionId,
+                    turnId: turn.id,
+                    runId: event.runId,
+                    parentItemId: null,
+                    sourceSequence: event.sequence,
+                    revision: event.sequence,
+                    kind: 'assistant_message',
+                    status: 'IN_PROGRESS',
+                    payload: { text, format: 'markdown', model: null },
+                    startedAt: existing?.startedAt ?? event.createdAt,
+                    completedAt: null
+                };
+                return {
+                    ...turn,
+                    status: 'RUNNING',
+                    startedAt: turn.startedAt ?? event.createdAt,
+                    items: [...turn.items.filter((value) => value.id !== item.id), item]
+                };
+            }
+            const projected = conversationItemFromEvent(event);
+            if (projected !== undefined) {
+                const existing = turn.items.find((item) => item.id === `${event.runId}:${projected.itemId}`);
+                const status = projected.status;
+                const item = {
+                    id: `${event.runId}:${projected.itemId}`,
+                    sessionId: run.sessionId,
+                    turnId: turn.id,
+                    runId: event.runId,
+                    parentItemId: null,
+                    sourceSequence: event.sequence,
+                    revision: (existing?.revision ?? -1) + 1,
+                    kind: projected.kind,
+                    status,
+                    payload: mergeConversationItemPayload(existing?.payload, projected),
+                    startedAt: existing?.startedAt ?? event.createdAt,
+                    completedAt: completedConversationItem(status) ? event.createdAt : null
+                };
+                return {
+                    ...turn,
+                    status: terminal(run.status) ? run.status : 'RUNNING',
+                    startedAt: turn.startedAt ?? event.createdAt,
+                    items: existing === undefined
+                        ? [...turn.items, item]
+                        : turn.items.map((value) => (value.id === item.id ? item : value))
+                };
+            }
+            if (event.eventType === 'run.started' || event.eventType === 'run.running')
+                return { ...turn, status: 'RUNNING', startedAt: turn.startedAt ?? event.createdAt };
+            if (event.eventType === 'run.completed' ||
+                event.eventType === 'run.failed' ||
+                event.eventType === 'run.rejected') {
+                return {
+                    ...turn,
+                    status: this.requireRun(event.runId).status,
+                    completedAt: event.createdAt,
+                    items: turn.items.map((item) => activeConversationItem(item.status)
+                        ? {
+                            ...item,
+                            status: completedStatusForRun(this.requireRun(event.runId).status),
+                            completedAt: event.createdAt
+                        }
+                        : item)
+                };
+            }
+            return turn;
+        });
+    }
+}
+function terminal(status) {
+    return ['SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED', 'LOST'].includes(status);
+}
+function transitionAllowed(from, to) {
+    return !terminal(from) || from === to;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function readableText(value) {
+    return isRecord(value) && typeof value.text === 'string' ? value.text : '';
+}
+function conversationItemFromEvent(event) {
+    if (event.eventType !== 'conversation.item' || !isRecord(event.payload))
+        return undefined;
+    const itemId = event.payload.itemId;
+    const kind = event.payload.kind;
+    const status = event.payload.status;
+    const payload = event.payload.payload;
+    if (typeof itemId !== 'string' ||
+        itemId.length === 0 ||
+        itemId.length > 88 ||
+        typeof kind !== 'string' ||
+        !projectableConversationKind(kind) ||
+        typeof status !== 'string' ||
+        !projectableConversationStatus(status) ||
+        !isRecord(payload))
+        return undefined;
+    const append = event.payload.append;
+    return {
+        itemId,
+        kind,
+        status,
+        payload,
+        merge: event.payload.merge === true,
+        ...(append === 'sections' || append === 'outputPreview' || append === 'outputSummary'
+            ? { append }
+            : {})
+    };
+}
+function projectableConversationKind(value) {
+    return (value === 'reasoning_summary' ||
+        value === 'tool_call' ||
+        value === 'command_execution' ||
+        value === 'user_input_request' ||
+        value === 'plan' ||
+        value === 'file_change' ||
+        value === 'context_compaction' ||
+        value === 'warning' ||
+        value === 'error');
+}
+function projectableConversationStatus(value) {
+    return [
+        'PENDING',
+        'IN_PROGRESS',
+        'COMPLETED',
+        'FAILED',
+        'DECLINED',
+        'CANCELLED',
+        'INTERRUPTED'
+    ].includes(value);
+}
+function mergeConversationItemPayload(existing, next) {
+    const base = next.merge && isRecord(existing) ? existing : {};
+    const value = { ...base, ...next.payload };
+    if (next.append === 'sections') {
+        const prior = Array.isArray(base.sections) ? base.sections : [];
+        const incoming = Array.isArray(next.payload.sections) ? next.payload.sections : [];
+        const sections = new Map();
+        for (const section of [...prior, ...incoming]) {
+            if (!isRecord(section) ||
+                typeof section.index !== 'number' ||
+                !Number.isInteger(section.index) ||
+                section.index < 0 ||
+                typeof section.text !== 'string')
+                continue;
+            sections.set(section.index, appendProjectionText(sections.get(section.index) ?? '', section.text));
+        }
+        value.sections = [...sections]
+            .sort(([left], [right]) => left - right)
+            .map(([index, text]) => ({ index, text }));
+    }
+    if (next.append === 'outputPreview') {
+        const prior = typeof base.outputPreview === 'string' ? base.outputPreview : '';
+        const incoming = typeof next.payload.outputPreview === 'string' ? next.payload.outputPreview : '';
+        value.outputPreview = appendProjectionText(prior, incoming);
+    }
+    if (next.append === 'outputSummary') {
+        const prior = typeof base.outputSummary === 'string' ? base.outputSummary : '';
+        const incoming = typeof next.payload.outputSummary === 'string' ? next.payload.outputSummary : '';
+        value.outputSummary = appendProjectionText(prior, incoming);
+    }
+    return value;
+}
+function appendProjectionText(previous, next) {
+    const text = `${previous}${next}`;
+    return text.length <= 10_000 ? text : `${text.slice(0, 9_999)}…`;
+}
+function activeConversationItem(status) {
+    return status === 'PENDING' || status === 'IN_PROGRESS';
+}
+function completedConversationItem(status) {
+    return !activeConversationItem(status);
+}
+function completedStatusForRun(status) {
+    if (status === 'INTERRUPTED')
+        return 'INTERRUPTED';
+    if (status === 'CANCELLED')
+        return 'CANCELLED';
+    if (status === 'FAILED')
+        return 'FAILED';
+    return 'COMPLETED';
+}
+function encodeCursor(scope, value) {
+    return Buffer.from(JSON.stringify({ scope, value })).toString('base64url');
+}
+function decodeCursor(cursor, scope) {
+    if (cursor === undefined)
+        return 0;
+    try {
+        const value = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+        return value.scope === scope && Number.isInteger(value.value) && value.value >= 0
+            ? value.value
+            : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+//# sourceMappingURL=runtime-state.js.map