@cydm/happy-elves 0.1.0-beta.31 → 0.1.0-beta.310

package/apps/relay/dist/projections.d.ts

@@ -1,4 +1,4 @@
-import type { EncryptedSessionEvent, MachineSnapshot, SessionSnapshot } from "@happy-elves/shared";
+import type { EncryptedSessionEvent, MachineSnapshot, SessionSnapshot } from "../../../packages/shared/dist/index.js";
 import type { EventRow, MachineRow, SessionRow } from "./types.js";
 export declare function parseJson<T>(value: string | null | undefined, fallback: T): T;
 export declare function normalizeMachineCapabilities(value: unknown): MachineSnapshot["capabilities"];

package/apps/relay/dist/projections.js

@@ -89,12 +89,25 @@ export function sessionSnapshot(row, capabilitiesForMachine, historyModelForMach
         encryptedMetadata: parseJson(row.encrypted_metadata, undefined),
         currentHead: row.current_head ?? undefined,
         lastTurnId: row.last_turn_id ?? undefined,
+        headBasis: sessionHeadBasis(row),
         sourceSessionId: row.source_session_id ?? undefined,
         sourceCheckpointId: row.source_checkpoint_id ?? undefined,
         historyModel: historyModelForMachine?.(row.account_id, row.machine_id, row.agent),
         capabilities: capabilitiesForMachine(row.account_id, row.machine_id, row.agent),
     };
 }
+function sessionHeadBasis(row) {
+    const basis = {};
+    if (row.head_basis_event_id !== null)
+        basis.eventId = row.head_basis_event_id;
+    if (row.head_basis_message_id !== null)
+        basis.messageId = row.head_basis_message_id;
+    if (row.head_basis_logical_time !== null)
+        basis.logicalTime = row.head_basis_logical_time;
+    if (row.head_basis_turn_seq !== null)
+        basis.turnSeq = row.head_basis_turn_seq;
+    return Object.keys(basis).length > 0 ? basis : undefined;
+}
 export function eventSnapshot(row) {
     return {
         id: row.id,

package/apps/relay/dist/relay-context.d.ts

@@ -1,8 +1,8 @@
 import type { DatabaseSync } from "node:sqlite";
-import { type EncryptedEnvelope, type EncryptedSessionEvent, type MachineSnapshot, type ServerMessage, type SessionSnapshot } from "@happy-elves/shared";
+import { type EncryptedEnvelope, type EncryptedSessionEvent, type MachineSnapshot, type ServerMessage, type SessionSnapshot } from "../../../packages/shared/dist/index.js";
 import { parseJson } from "./projections.js";
 import { filterSnapshotForScope, isFullControllerToken, scopedTokenPublic, tokenScope } from "./scope.js";
-import type { ControllerConnection, ControllerInviteRow, EventRow, MachineConnection, SessionRow, TokenKind, TokenRecord, WebSocketLike } from "./types.js";
+import type { ControllerConnection, ControllerInviteRow, EventRow, MachineConnection, RelaySessionClaimRow, SessionRow, TokenKind, TokenRecord, WebSocketLike } from "./types.js";
 type CreateRelayContextOptions = {
     db: DatabaseSync;
     eventReplayLimit: number;
@@ -29,6 +29,7 @@ export declare function createRelayContext(options: CreateRelayContextOptions):
     closeRevokedControllerConnections: (accountId: string, deviceId: string) => void;
     closeRevokedMachineConnection: (accountId: string, machineId: string) => void;
     connectedMachine: (accountId: string, machineId: string) => MachineConnection | undefined;
+    controllerDeviceOnline: (accountId: string, deviceId: string) => boolean;
     controllersByAccount: Map<string, Set<ControllerConnection>>;
     createPairingForAccount: (accountId: string) => {
         pairingCode: string;
@@ -43,11 +44,13 @@ export declare function createRelayContext(options: CreateRelayContextOptions):
         accountId: string;
         sessionId: string;
         machineId: string;
+        source: "controller" | "machine";
         messageId?: string;
         turnId: string;
         turnSeq?: number;
         occurredAt?: number;
         payload: EncryptedEnvelope;
+        updateSession?: boolean;
     }) => EncryptedSessionEvent;
     aliasedRuntimeEventHasRequestEvents: (params: {
         accountId: string;
@@ -55,16 +58,39 @@ export declare function createRelayContext(options: CreateRelayContextOptions):
         machineId: string;
         runtimeTurnId: string;
     }) => boolean;
+    activeSessionClaim: (accountId: string, sessionId: string) => RelaySessionClaimRow | undefined;
+    claimSessionTurn: (params: {
+        accountId: string;
+        sessionId: string;
+        machineId: string;
+        requestId: string;
+        turnId: string;
+        commandType: "prompt";
+        createdAt?: number;
+    }) => {
+        ok: true;
+    } | {
+        ok: false;
+        claim: RelaySessionClaimRow;
+    };
     isCommandPending: (accountId: string, requestId: string) => boolean;
+    isSessionCommandPending: (accountId: string, sessionId: string) => boolean;
     isFullControllerToken: typeof isFullControllerToken;
     machineCapabilities: (accountId: string, machineId: string) => MachineSnapshot["capabilities"] | undefined;
     machineMessageProcessed: (accountId: string, machineId: string, messageId: string) => boolean;
     machinesByKey: Map<string, MachineConnection>;
-    markCommandPending: (accountId: string, machineId: string, requestId: string) => void;
+    markCommandPending: (accountId: string, machineId: string, requestId: string, options?: {
+        command?: string;
+        sessionId?: string;
+    }) => void;
     markMachineMessageProcessed: (accountId: string, machineId: string, messageId: string) => void;
+    markTokenSeen: (token: string) => void;
     now: () => number;
     parseJson: typeof parseJson;
     previousCommandResponse: (accountId: string, requestId: string) => ServerMessage | undefined;
+    previousAdmissionAck: (accountId: string, requestId: string) => Extract<ServerMessage, {
+        type: "server:ack";
+    }> | undefined;
     recordTurnAlias: (params: {
         accountId: string;
         sessionId: string;
@@ -77,6 +103,18 @@ export declare function createRelayContext(options: CreateRelayContextOptions):
     requireFullControllerToken: (authHeader: string | undefined) => TokenRecord;
     requireHttpToken: (authHeader: string | undefined, kind: TokenKind) => TokenRecord;
     resumeOfflineSessionsForMachine: (connection: MachineConnection) => void;
+    deliverOutboxCommand: (accountId: string, requestId: string) => "queued" | "delivered";
+    deliverQueuedCommandsForMachine: (connection: MachineConnection) => void;
+    finishSessionClaim: (params: {
+        accountId: string;
+        sessionId: string;
+        requestId?: string;
+        turnId?: string;
+        terminalStatus: "completed" | "cancelled" | "failed" | "error" | "unknown";
+        errorCode?: string;
+        finishedAt?: number;
+    }) => RelaySessionClaimRow | undefined;
+    markAdmissionStarted: (accountId: string, requestId: string, startedAt?: number) => void;
     scopedTokenPublic: typeof scopedTokenPublic;
     send: (socket: WebSocketLike, message: ServerMessage) => void;
     sendAck: (connection: ControllerConnection, message: Extract<ServerMessage, {

package/apps/relay/dist/relay-context.js

@@ -3,8 +3,10 @@ import { createConnectionState, machineKey } from "./connections.js";
 import { HttpError } from "./errors.js";
 import { parseJson } from "./projections.js";
 import { createRelayRepositories } from "./repositories.js";
+import { markSessionRuntimeBindingsClosed } from "./runtime-bindings.js";
 import { filterSnapshotForScope, isFullControllerToken, messageForScopedController, scopedListAllows, scopedTokenPublic, tokenScope, } from "./scope.js";
 import { bearerToken, encodePairingCode, isPairingCodeMatch, tokenDigest } from "./security.js";
+const REWRITE_HEAD_BASIS_PREFIX = "rewrite:";
 export function createRelayContext(options) {
     const { controllersByAccount, machinesByKey, pendingCommandRequests } = createConnectionState();
     const now = options.now ?? Date.now;
@@ -34,6 +36,7 @@ export function createRelayContext(options) {
             throw new HttpError(403, "AUTH_TOKEN_REVOKED", "Token has been revoked");
         if (record.expires_at && record.expires_at <= now())
             throw new HttpError(403, "AUTH_TOKEN_EXPIRED", "Token has expired");
+        markTokenSeen(record.token);
         return record;
     }
     function requireFullControllerToken(authHeader) {
@@ -86,6 +89,19 @@ export function createRelayContext(options) {
             }
         }
     }
+    function markTokenSeen(token) {
+        options.db.prepare("UPDATE tokens SET last_seen = ? WHERE token = ?").run(now(), token);
+    }
+    function controllerDeviceOnline(accountId, deviceId) {
+        const controllers = controllersByAccount.get(accountId);
+        if (!controllers)
+            return false;
+        for (const connection of controllers) {
+            if (connection.deviceId === deviceId)
+                return true;
+        }
+        return false;
+    }
     function closeRevokedMachineConnection(accountId, machineId) {
         const ts = now();
         const rows = options.db
@@ -163,15 +179,117 @@ export function createRelayContext(options) {
             .get(accountId, requestId);
         return row ? JSON.parse(row.response) : undefined;
     }
+    function previousAdmissionAck(accountId, requestId) {
+        const row = options.db
+            .prepare("SELECT * FROM relay_admissions WHERE account_id = ? AND request_id = ?")
+            .get(accountId, requestId);
+        if (!row)
+            return undefined;
+        return {
+            type: "server:ack",
+            requestId,
+            ok: true,
+            sessionId: row.session_id,
+            ...(row.turn_id ? { turnId: row.turn_id } : {}),
+            admission: "replayed",
+            dispatch: row.dispatch,
+        };
+    }
+    function activeSessionClaim(accountId, sessionId) {
+        const claim = rawActiveSessionClaim(accountId, sessionId);
+        if (!claim)
+            return undefined;
+        const unknownErrorCode = claimUnknownExecutionErrorCode(claim);
+        if (unknownErrorCode) {
+            finishClaimRecord(claim, { terminalStatus: "unknown", errorCode: unknownErrorCode });
+            return undefined;
+        }
+        return claim;
+    }
+    function rawActiveSessionClaim(accountId, sessionId) {
+        return options.db
+            .prepare(`SELECT * FROM relay_session_claims
+         WHERE account_id = ? AND session_id = ? AND state = 'active'`)
+            .get(accountId, sessionId);
+    }
+    function claimUnknownExecutionErrorCode(claim) {
+        const admission = options.db
+            .prepare(`SELECT last_error_code
+         FROM relay_admissions
+         WHERE account_id = ? AND request_id = ?`)
+            .get(claim.account_id, claim.request_id);
+        const code = admission?.last_error_code;
+        return code === "EXECUTION_UNKNOWN" || code === "EXECUTION_NOT_FOUND" ? code : undefined;
+    }
+    function finishClaimRecord(claim, params) {
+        const ts = params.finishedAt ?? now();
+        options.db
+            .prepare(`UPDATE relay_admissions
+         SET finished_at = COALESCE(finished_at, ?),
+             terminal_status = COALESCE(terminal_status, ?),
+             last_error_code = COALESCE(?, last_error_code),
+             updated_at = ?
+         WHERE account_id = ? AND request_id = ?`)
+            .run(ts, params.terminalStatus, params.errorCode ?? null, ts, claim.account_id, claim.request_id);
+        options.db
+            .prepare("DELETE FROM relay_session_claims WHERE account_id = ? AND session_id = ? AND request_id = ?")
+            .run(claim.account_id, claim.session_id, claim.request_id);
+        if (params.terminalStatus === "unknown") {
+            options.db
+                .prepare(`UPDATE sessions
+           SET status = 'ready', updated_at = ?
+           WHERE account_id = ? AND id = ? AND machine_id = ? AND status = 'running'`)
+                .run(ts, claim.account_id, claim.session_id, claim.machine_id);
+        }
+        return claim;
+    }
+    function claimSessionTurn(params) {
+        const existing = activeSessionClaim(params.accountId, params.sessionId);
+        if (existing && existing.request_id !== params.requestId)
+            return { ok: false, claim: existing };
+        if (existing)
+            return { ok: true };
+        const ts = params.createdAt ?? now();
+        options.db
+            .prepare(`INSERT INTO relay_session_claims
+         (account_id, session_id, request_id, machine_id, turn_id, command_type, state, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, 'active', ?, ?)`)
+            .run(params.accountId, params.sessionId, params.requestId, params.machineId, params.turnId, params.commandType, ts, ts);
+        return { ok: true };
+    }
+    function markAdmissionStarted(accountId, requestId, startedAt = now()) {
+        options.db
+            .prepare(`UPDATE relay_admissions
+         SET started_at = COALESCE(started_at, ?), updated_at = ?
+         WHERE account_id = ? AND request_id = ?`)
+            .run(startedAt, startedAt, accountId, requestId);
+    }
+    function finishSessionClaim(params) {
+        const claim = rawActiveSessionClaim(params.accountId, params.sessionId);
+        if (!claim)
+            return undefined;
+        if (params.requestId && claim.request_id !== params.requestId)
+            return claim;
+        if (params.turnId && claim.turn_id !== params.turnId)
+            return claim;
+        return finishClaimRecord(claim, params);
+    }
     function commandKey(accountId, requestId) {
         return `${accountId}:${requestId}`;
     }
-    function markCommandPending(accountId, machineId, requestId) {
-        pendingCommandRequests.set(commandKey(accountId, requestId), { accountId, machineId, requestId });
+    function markCommandPending(accountId, machineId, requestId, options = {}) {
+        pendingCommandRequests.set(commandKey(accountId, requestId), { accountId, machineId, requestId, ...options });
     }
     function isCommandPending(accountId, requestId) {
         return pendingCommandRequests.has(commandKey(accountId, requestId));
     }
+    function isSessionCommandPending(accountId, sessionId) {
+        for (const pending of pendingCommandRequests.values()) {
+            if (pending.accountId === accountId && pending.sessionId === sessionId)
+                return true;
+        }
+        return false;
+    }
     function clearCommandPending(accountId, requestId) {
         pendingCommandRequests.delete(commandKey(accountId, requestId));
     }
@@ -223,6 +341,48 @@ export function createRelayContext(options) {
             message: "Machine is offline",
         });
     }
+    function deliverOutboxCommand(accountId, requestId) {
+        const row = options.db
+            .prepare("SELECT * FROM relay_dispatch_outbox WHERE account_id = ? AND request_id = ?")
+            .get(accountId, requestId);
+        if (!row)
+            return "queued";
+        if (row.state === "delivered")
+            return "delivered";
+        const machine = connectedMachine(accountId, row.machine_id);
+        if (!machine)
+            return "queued";
+        const command = JSON.parse(row.message);
+        send(machine.socket, command);
+        const ts = now();
+        options.db
+            .prepare(`UPDATE relay_dispatch_outbox
+         SET state = 'delivered', delivered_at = ?, updated_at = ?
+         WHERE account_id = ? AND request_id = ? AND state = 'queued'`)
+            .run(ts, ts, accountId, requestId);
+        options.db
+            .prepare(`UPDATE relay_admissions
+         SET dispatch = 'delivered', updated_at = ?
+         WHERE account_id = ? AND request_id = ?`)
+            .run(ts, accountId, requestId);
+        if (command.type === "machine:prompt") {
+            markAdmissionStarted(accountId, requestId, ts);
+            const session = setSessionStatus(command.sessionId, "running");
+            if (session)
+                broadcastControllers(accountId, { type: "server:session", session });
+        }
+        return "delivered";
+    }
+    function deliverQueuedCommandsForMachine(connection) {
+        const rows = options.db
+            .prepare(`SELECT * FROM relay_dispatch_outbox
+         WHERE account_id = ? AND machine_id = ? AND state = 'queued'
+         ORDER BY created_at ASC`)
+            .all(connection.accountId, connection.machineId);
+        for (const row of rows) {
+            deliverOutboxCommand(connection.accountId, row.request_id);
+        }
+    }
     function broadcastControllers(accountId, message) {
         const controllers = controllersByAccount.get(accountId);
         if (!controllers)
@@ -309,8 +469,28 @@ export function createRelayContext(options) {
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
             .run(params.accountId, params.sessionId, params.machineId, params.messageId ?? null, params.turnId, seqRow.nextSeq, params.turnSeq ?? null, JSON.stringify(params.payload), createdAt, params.occurredAt ?? null);
         const eventId = Number(result.lastInsertRowid);
-        if (shouldAdvanceSessionHead(params, eventId, createdAt)) {
-            options.db.prepare("UPDATE sessions SET current_head = ?, last_turn_id = ?, updated_at = ? WHERE id = ?").run(`event:${eventId}`, params.turnId, createdAt, params.sessionId);
+        if (params.updateSession === false) {
+            // Keep late closed-session events addressable without changing the
+            // session projection or workspace ordering.
+        }
+        else if (shouldAdvanceSessionHead(params, eventId, createdAt)) {
+            const order = logicalEventOrder({
+                id: eventId,
+                createdAt,
+                messageId: params.messageId,
+                occurredAt: params.occurredAt,
+                seq: params.turnSeq,
+                turnSeq: params.turnSeq,
+            });
+            options.db.prepare(`UPDATE sessions
+         SET current_head = ?,
+             last_turn_id = ?,
+             head_basis_event_id = ?,
+             head_basis_message_id = ?,
+             head_basis_logical_time = ?,
+             head_basis_turn_seq = ?,
+             updated_at = ?
+         WHERE id = ?`).run(`event:${eventId}`, params.turnId, eventId, params.messageId ?? null, order.time, order.seq, createdAt, params.sessionId);
         }
         else {
             options.db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(createdAt, params.sessionId);
@@ -330,19 +510,24 @@ export function createRelayContext(options) {
     }
     function shouldAdvanceSessionHead(params, eventId, createdAt) {
         const session = options.db
-            .prepare("SELECT current_head FROM sessions WHERE account_id = ? AND id = ? AND machine_id = ?")
+            .prepare(`SELECT current_head, last_turn_id, status, head_basis_event_id, head_basis_message_id,
+                head_basis_logical_time, head_basis_turn_seq
+         FROM sessions
+         WHERE account_id = ? AND id = ? AND machine_id = ?`)
             .get(params.accountId, params.sessionId, params.machineId);
         const currentHead = session?.current_head;
+        if (session?.status === "closed")
+            return false;
         if (!currentHead)
             return true;
-        const currentEventId = /^event:(\d+)$/.exec(currentHead)?.[1];
-        if (!currentEventId)
-            return !isHistoricalBackfillEvent(params);
-        const current = options.db
-            .prepare("SELECT * FROM session_events WHERE account_id = ? AND session_id = ? AND machine_id = ? AND id = ?")
-            .get(params.accountId, params.sessionId, params.machineId, Number(currentEventId));
-        if (!current)
-            return !isHistoricalBackfillEvent(params);
+        if (typeof session?.head_basis_message_id === "string" &&
+            session.head_basis_message_id.startsWith(REWRITE_HEAD_BASIS_PREFIX) &&
+            params.source === "machine") {
+            return false;
+        }
+        if (session?.status === "running" && params.source === "machine" && session.last_turn_id && params.turnId !== session.last_turn_id) {
+            return false;
+        }
         const nextOrder = logicalEventOrder({
             id: eventId,
             createdAt,
@@ -351,7 +536,34 @@ export function createRelayContext(options) {
             seq: params.turnSeq,
             turnSeq: params.turnSeq,
         });
-        const currentOrder = logicalEventOrder({
+        const currentOrder = sessionHeadBasisOrder(session) ?? currentHeadEventOrder(params, currentHead);
+        if (!currentOrder)
+            return !isHistoricalBackfillEvent(params);
+        if (nextOrder.time !== currentOrder.time)
+            return nextOrder.time > currentOrder.time;
+        if (nextOrder.seq !== currentOrder.seq)
+            return nextOrder.seq > currentOrder.seq;
+        return nextOrder.id > currentOrder.id;
+    }
+    function sessionHeadBasisOrder(session) {
+        if (session.head_basis_logical_time === null || session.head_basis_turn_seq === null)
+            return undefined;
+        return {
+            time: session.head_basis_logical_time,
+            seq: session.head_basis_turn_seq,
+            id: session.head_basis_event_id ?? 0,
+        };
+    }
+    function currentHeadEventOrder(params, currentHead) {
+        const currentEventId = /^event:(\d+)$/.exec(currentHead)?.[1];
+        if (!currentEventId)
+            return undefined;
+        const current = options.db
+            .prepare("SELECT * FROM session_events WHERE account_id = ? AND session_id = ? AND machine_id = ? AND id = ?")
+            .get(params.accountId, params.sessionId, params.machineId, Number(currentEventId));
+        if (!current)
+            return undefined;
+        return logicalEventOrder({
             id: current.id,
             createdAt: current.created_at,
             messageId: current.message_id ?? undefined,
@@ -359,11 +571,6 @@ export function createRelayContext(options) {
             seq: current.seq,
             turnSeq: current.turn_seq ?? undefined,
         });
-        if (nextOrder.time !== currentOrder.time)
-            return nextOrder.time > currentOrder.time;
-        if (nextOrder.seq !== currentOrder.seq)
-            return nextOrder.seq > currentOrder.seq;
-        return nextOrder.id > currentOrder.id;
     }
     function logicalEventOrder(input) {
         if (input.occurredAt !== undefined) {
@@ -421,7 +628,15 @@ export function createRelayContext(options) {
     }
     function setSessionStatus(sessionId, status) {
         const ts = now();
+        const previous = options.db.prepare("SELECT * FROM sessions WHERE id = ?").get(sessionId);
         options.db.prepare("UPDATE sessions SET status = ?, updated_at = ? WHERE id = ?").run(status, ts, sessionId);
+        if (status === "closed" && previous) {
+            markSessionRuntimeBindingsClosed(options.db, {
+                accountId: previous.account_id,
+                sessionId,
+                ts,
+            });
+        }
         const row = options.db.prepare("SELECT * FROM sessions WHERE id = ?").get(sessionId);
         return row ? sessionSnapshot(row) : undefined;
     }
@@ -453,6 +668,7 @@ export function createRelayContext(options) {
         closeRevokedControllerConnections,
         closeRevokedMachineConnection,
         connectedMachine,
+        controllerDeviceOnline,
         controllersByAccount,
         createPairingForAccount,
         db: options.db,
@@ -462,21 +678,30 @@ export function createRelayContext(options) {
         findUsableControllerInvite,
         insertEvent,
         aliasedRuntimeEventHasRequestEvents,
+        activeSessionClaim,
+        claimSessionTurn,
         isCommandPending,
+        isSessionCommandPending,
         isFullControllerToken,
         machineCapabilities,
         machineMessageProcessed,
         machinesByKey,
         markCommandPending,
         markMachineMessageProcessed,
+        markTokenSeen,
         now,
         parseJson,
         previousCommandResponse,
+        previousAdmissionAck,
         recordTurnAlias,
         rememberCommandResponse,
         requireFullControllerToken,
         requireHttpToken,
         resumeOfflineSessionsForMachine,
+        deliverOutboxCommand,
+        deliverQueuedCommandsForMachine,
+        finishSessionClaim,
+        markAdmissionStarted,
         scopedTokenPublic,
         send,
         sendAck,

package/apps/relay/dist/repositories.d.ts

@@ -1,8 +1,8 @@
 import type { DatabaseSync } from "node:sqlite";
-import type { MachineSnapshot, ServerMessage, SessionSnapshot } from "@happy-elves/shared";
+import type { MachineSnapshot, ServerMessage, SessionSnapshot } from "../../../packages/shared/dist/index.js";
 import type { EventRow, MachineConnection, MachineRow, SessionRow } from "./types.js";
 export declare function createRelayRepositories(db: DatabaseSync, connectedMachine: (accountId: string, machineId: string) => MachineConnection | undefined, eventReplayLimit: number): {
-    eventSnapshot: (row: EventRow) => import("@happy-elves/shared").EncryptedSessionEvent;
+    eventSnapshot: (row: EventRow) => import("../../../packages/shared/dist/index.js").EncryptedSessionEvent;
     machineCapabilities: (accountId: string, machineId: string) => MachineSnapshot["capabilities"] | undefined;
     machineSnapshot: (row: MachineRow) => MachineSnapshot;
     scopedSessionRow: (accountId: string, sessionId: string) => SessionRow | undefined;

package/apps/relay/dist/repositories.js

@@ -28,8 +28,35 @@ export function createRelayRepositories(db, connectedMachine, eventReplayLimit)
         const capabilities = machineCapabilities(accountId, machineId);
         return capabilities?.agents.find((agent) => agent.id === agentId)?.historyModel;
     }
+    function sessionStatusForProjection(row) {
+        if (row.status !== "failed")
+            return row.status;
+        const latestPromptAdmission = db
+            .prepare(`SELECT turn_id, terminal_status
+         FROM relay_admissions
+         WHERE account_id = ? AND session_id = ? AND kind = 'prompt' AND finished_at IS NOT NULL
+         ORDER BY finished_at DESC, updated_at DESC
+         LIMIT 1`)
+            .get(row.account_id, row.id);
+        if (latestPromptAdmission?.terminal_status !== "completed")
+            return row.status;
+        const terminalTurnId = latestPromptAdmission.turn_id;
+        if (!terminalTurnId)
+            return "completed";
+        if (terminalTurnId === row.last_turn_id || terminalTurnId === row.current_head)
+            return "completed";
+        const alias = db
+            .prepare(`SELECT 1 FROM session_turn_aliases
+         WHERE account_id = ? AND session_id = ? AND machine_id = ?
+           AND request_turn_id = ?
+           AND runtime_turn_id IN (?, ?)
+         LIMIT 1`)
+            .get(row.account_id, row.id, row.machine_id, terminalTurnId, row.last_turn_id ?? "", row.current_head ?? "");
+        return alias ? "completed" : row.status;
+    }
     function sessionSnapshot(row) {
-        return projectSessionSnapshot(row, sessionCapabilitiesForMachine, sessionHistoryModelForMachine);
+        const status = sessionStatusForProjection(row);
+        return projectSessionSnapshot(status === row.status ? row : { ...row, status }, sessionCapabilitiesForMachine, sessionHistoryModelForMachine);
     }
     function machineSnapshot(row) {
         return projectMachineSnapshot(row, (accountId, machineId) => connectedMachine(accountId, machineId) !== undefined);

package/apps/relay/dist/runtime-bindings.d.ts

@@ -0,0 +1,25 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { SessionRuntimeBindingRow, SessionRow } from "./types.js";
+export declare function normalizeRuntimeSessionIds(values: readonly unknown[]): string[];
+export declare function upsertSessionRuntimeBindings(db: DatabaseSync, input: {
+    accountId: string;
+    machineId: string;
+    agent: string;
+    sessionId: string;
+    runtimeSessionIds: readonly unknown[];
+    status: "active" | "closed";
+    ts: number;
+}): void;
+export declare function findSessionRuntimeBinding(db: DatabaseSync, input: {
+    accountId: string;
+    machineId: string;
+    agent: string;
+    runtimeSessionId: string;
+}): (SessionRuntimeBindingRow & {
+    session_status: SessionRow["status"] | null;
+}) | undefined;
+export declare function markSessionRuntimeBindingsClosed(db: DatabaseSync, input: {
+    accountId: string;
+    sessionId: string;
+    ts: number;
+}): void;

package/apps/relay/dist/runtime-bindings.js

@@ -0,0 +1,49 @@
+export function normalizeRuntimeSessionIds(values) {
+    const ids = [];
+    const seen = new Set();
+    for (const value of values) {
+        if (typeof value !== "string")
+            continue;
+        const id = value.trim();
+        if (!id || id.startsWith("event:") || seen.has(id))
+            continue;
+        seen.add(id);
+        ids.push(id);
+    }
+    return ids;
+}
+export function upsertSessionRuntimeBindings(db, input) {
+    const ids = normalizeRuntimeSessionIds(input.runtimeSessionIds);
+    for (const runtimeSessionId of ids) {
+        db.prepare(`INSERT INTO session_runtime_bindings
+         (account_id, machine_id, agent, runtime_session_id, session_id, status, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(account_id, machine_id, agent, runtime_session_id)
+       DO UPDATE SET
+         session_id = excluded.session_id,
+         status = excluded.status,
+         updated_at = excluded.updated_at`).run(input.accountId, input.machineId, input.agent, runtimeSessionId, input.sessionId, input.status, input.ts, input.ts);
+    }
+}
+export function findSessionRuntimeBinding(db, input) {
+    const runtimeSessionId = input.runtimeSessionId.trim();
+    if (!runtimeSessionId)
+        return undefined;
+    return db.prepare(`SELECT bindings.*, sessions.status AS session_status
+     FROM session_runtime_bindings bindings
+     LEFT JOIN sessions
+       ON sessions.id = bindings.session_id
+      AND sessions.account_id = bindings.account_id
+      AND sessions.machine_id = bindings.machine_id
+     WHERE bindings.account_id = ?
+       AND bindings.machine_id = ?
+       AND bindings.agent = ?
+       AND bindings.runtime_session_id = ?
+     LIMIT 1`).get(input.accountId, input.machineId, input.agent, runtimeSessionId);
+}
+export function markSessionRuntimeBindingsClosed(db, input) {
+    db.prepare(`UPDATE session_runtime_bindings
+     SET status = 'closed', updated_at = ?
+     WHERE account_id = ? AND session_id = ?`).run(input.ts, input.accountId, input.sessionId);
+}
+//# sourceMappingURL=runtime-bindings.js.map

package/apps/relay/dist/scope.d.ts

@@ -1,4 +1,4 @@
-import type { ServerMessage } from "@happy-elves/shared";
+import type { ServerMessage } from "../../../packages/shared/dist/index.js";
 import type { ControllerConnection, ScopedTokenScope, TokenRecord } from "./types.js";
 export declare function tokenScope(record: TokenRecord): ScopedTokenScope | null;
 export declare function isFullControllerToken(record: TokenRecord): boolean;