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

package/apps/relay/dist/machine-handlers.js

@@ -1,5 +1,8 @@
+import { normalizeRuntimeSessionIds, upsertSessionRuntimeBindings } from "./runtime-bindings.js";
+const REWRITE_HEAD_BASIS_SEQ = 0;
+const REWRITE_HEAD_BASIS_PREFIX = "rewrite:";
 export function handleMachineMessage(context, connection, message) {
-    const { broadcastAck, broadcastControllers, broadcastError, clearCommandPending, db, insertEvent, aliasedRuntimeEventHasRequestEvents, machineMessageProcessed, markMachineMessageProcessed, now, recordTurnAlias, rememberCommandResponse, sendMachineMessageAck, sessionSnapshot, setSessionStatus, updateMachineLastSeen, } = context;
+    const { broadcastAck, broadcastControllers, broadcastError, clearCommandPending, db, finishSessionClaim, insertEvent, machineMessageProcessed, markMachineMessageProcessed, now, recordTurnAlias, rememberCommandResponse, sendMachineMessageAck, sessionSnapshot, setSessionStatus, updateMachineLastSeen, } = context;
     const messageId = machineMessageId(message);
     if (messageId && machineMessageProcessed(connection.accountId, connection.machineId, messageId)) {
         sendMachineMessageAck(connection, messageId);
@@ -28,10 +31,12 @@ export function handleMachineMessage(context, connection, message) {
            name = COALESCE(?, name),
            encrypted_metadata = COALESCE(?, encrypted_metadata),
            updated_at = ?
-       WHERE id = ? AND account_id = ? AND machine_id = ?`).run(message.name ?? null, message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : null, ts, message.sessionId, connection.accountId, connection.machineId);
+       WHERE id = ? AND account_id = ? AND machine_id = ? AND status != 'closed'`).run(message.name ?? null, message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : null, ts, message.sessionId, connection.accountId, connection.machineId);
         const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
-        if (row)
+        if (row && row.status !== "closed") {
+            recordRuntimeBindingsFromMachineMessage(db, connection, row, message, ts);
             broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(row) });
+        }
         broadcastAck(connection.accountId, {
             type: "server:ack",
             requestId: message.requestId,
@@ -48,10 +53,12 @@ export function handleMachineMessage(context, connection, message) {
            name = COALESCE(?, name),
            encrypted_metadata = COALESCE(?, encrypted_metadata),
            updated_at = ?
-       WHERE id = ? AND account_id = ? AND machine_id = ?`).run(message.name ?? null, message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : null, ts, message.sessionId, connection.accountId, connection.machineId);
+       WHERE id = ? AND account_id = ? AND machine_id = ? AND status != 'closed'`).run(message.name ?? null, message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : null, ts, message.sessionId, connection.accountId, connection.machineId);
         const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
-        if (row)
+        if (row && row.status !== "closed") {
+            recordRuntimeBindingsFromMachineMessage(db, connection, row, message, ts);
             broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(row) });
+        }
         broadcastAck(connection.accountId, { type: "server:ack", requestId: message.requestId, ok: true });
         acknowledgeMachineMessage();
         return;
@@ -117,15 +124,150 @@ export function handleMachineMessage(context, connection, message) {
         broadcastControllers(connection.accountId, response);
         return;
     }
+    if (message.type === "machine:gatewayResult") {
+        const response = {
+            type: "server:gatewayResult",
+            requestId: message.requestId,
+            machineId: connection.machineId,
+            result: message.result,
+        };
+        rememberCommandResponse(connection.accountId, message.requestId, response);
+        clearCommandPending(connection.accountId, message.requestId);
+        broadcastControllers(connection.accountId, response);
+        return;
+    }
+    if (message.type === "machine:scheduleResult") {
+        const response = {
+            type: "server:scheduleResult",
+            requestId: message.requestId,
+            machineId: connection.machineId,
+            result: message.result,
+        };
+        rememberCommandResponse(connection.accountId, message.requestId, response);
+        clearCommandPending(connection.accountId, message.requestId);
+        broadcastControllers(connection.accountId, response);
+        return;
+    }
+    if (message.type === "machine:memoryResult") {
+        const response = {
+            type: "server:memoryResult",
+            requestId: message.requestId,
+            machineId: connection.machineId,
+            result: message.result,
+        };
+        rememberCommandResponse(connection.accountId, message.requestId, response);
+        clearCommandPending(connection.accountId, message.requestId);
+        broadcastControllers(connection.accountId, response);
+        return;
+    }
+    if (message.type === "machine:optionResponded") {
+        clearCommandPending(connection.accountId, message.requestId);
+        broadcastAck(connection.accountId, {
+            type: "server:ack",
+            requestId: message.requestId,
+            ok: true,
+            sessionId: message.sessionId,
+            turnId: message.turnId,
+        });
+        acknowledgeMachineMessage();
+        return;
+    }
+    if (message.type === "machine:turnReconciled") {
+        const response = {
+            type: "server:turnReconciled",
+            requestId: message.requestId,
+            machineId: connection.machineId,
+            result: message.result,
+        };
+        const ts = now();
+        if (message.result.status === "active") {
+            db.prepare(`UPDATE sessions
+         SET status = 'running', updated_at = ?
+         WHERE id = ? AND account_id = ? AND machine_id = ? AND status NOT IN ('closed', 'cancelled', 'failed', 'completed')`).run(ts, message.result.sessionId, connection.accountId, connection.machineId);
+            const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.result.sessionId);
+            if (row)
+                broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(row) });
+        }
+        if (message.result.status === "terminal" && message.result.terminalStatus) {
+            const activeClaim = activePromptClaim(db, connection.accountId, message.result.sessionId, connection.machineId);
+            const terminalMatchesActiveClaim = Boolean(activeClaim) &&
+                (!message.result.requestId || message.result.requestId === activeClaim?.request_id) &&
+                (!message.result.turnId || message.result.turnId === activeClaim?.turn_id);
+            const shouldProjectTerminal = !activeClaim || terminalMatchesActiveClaim;
+            if (message.result.turnId || message.result.lastTurnId || message.result.currentHead || message.result.providerTurnId) {
+                recordTurnAlias({
+                    accountId: connection.accountId,
+                    sessionId: message.result.sessionId,
+                    machineId: connection.machineId,
+                    requestTurnId: message.result.turnId ?? message.result.lastTurnId ?? message.result.currentHead ?? message.result.providerTurnId ?? "",
+                    runtimeTurnId: message.result.lastTurnId ?? message.result.currentHead ?? message.result.providerTurnId,
+                    requestId: message.result.requestId,
+                });
+            }
+            if (shouldProjectTerminal) {
+                db.prepare(`UPDATE sessions
+           SET status = ?,
+               current_head = COALESCE(?, current_head),
+               last_turn_id = COALESCE(?, last_turn_id),
+               updated_at = ?
+           WHERE id = ? AND account_id = ? AND machine_id = ? AND status != 'closed'`).run(message.result.terminalStatus, message.result.currentHead ?? null, message.result.lastTurnId ?? message.result.turnId ?? null, ts, message.result.sessionId, connection.accountId, connection.machineId);
+            }
+            finishSessionClaim({
+                accountId: connection.accountId,
+                sessionId: message.result.sessionId,
+                requestId: message.result.requestId,
+                turnId: message.result.turnId,
+                terminalStatus: message.result.terminalStatus,
+                ...(message.result.error ? { errorCode: "TURN_ERROR" } : {}),
+                finishedAt: ts,
+            });
+            if (shouldProjectTerminal) {
+                const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.result.sessionId);
+                if (row && row.status !== "closed")
+                    broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(row) });
+            }
+        }
+        if (message.result.status === "unknown" || message.result.status === "not_found" || message.result.status === "uninspectable") {
+            const claim = activePromptClaim(db, connection.accountId, message.result.sessionId, connection.machineId);
+            const turnId = message.result.turnId ?? claim?.turn_id;
+            const requestId = message.result.requestId ?? claim?.request_id;
+            const claimMatches = Boolean(claim) &&
+                (!message.result.requestId || message.result.requestId === claim?.request_id) &&
+                (!message.result.turnId || message.result.turnId === claim?.turn_id);
+            if (claimMatches && turnId) {
+                finishSessionClaim({
+                    accountId: connection.accountId,
+                    sessionId: message.result.sessionId,
+                    requestId,
+                    turnId,
+                    terminalStatus: "unknown",
+                    errorCode: message.result.status === "not_found" ? "EXECUTION_NOT_FOUND" : "EXECUTION_UNKNOWN",
+                    finishedAt: ts,
+                });
+                const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.result.sessionId);
+                if (row && row.status !== "closed")
+                    broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(row) });
+            }
+        }
+        rememberCommandResponse(connection.accountId, message.requestId, response);
+        clearCommandPending(connection.accountId, message.requestId);
+        broadcastControllers(connection.accountId, response);
+        acknowledgeMachineMessage();
+        return;
+    }
     if (message.type === "machine:sessionRewound") {
         const ts = now();
         const update = db.prepare(`UPDATE sessions
        SET status = 'ready',
            current_head = ?,
            last_turn_id = COALESCE(?, last_turn_id),
+           head_basis_event_id = NULL,
+           head_basis_message_id = ?,
+           head_basis_logical_time = ?,
+           head_basis_turn_seq = ?,
            encrypted_metadata = COALESCE(?, encrypted_metadata),
            updated_at = ?
-       WHERE id = ? AND account_id = ? AND machine_id = ?`).run(message.currentHead, message.lastTurnId ?? null, message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : null, ts, message.sessionId, connection.accountId, connection.machineId);
+       WHERE id = ? AND account_id = ? AND machine_id = ?`).run(message.currentHead, message.lastTurnId ?? null, `rewrite:${message.requestId}`, ts, REWRITE_HEAD_BASIS_SEQ, message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : null, ts, message.sessionId, connection.accountId, connection.machineId);
         if (update.changes === 0) {
             broadcastError(connection.accountId, {
                 type: "server:error",
@@ -136,6 +278,7 @@ export function handleMachineMessage(context, connection, message) {
             acknowledgeMachineMessage();
             return;
         }
+        clearPendingSessionHeadAdvances(db, connection.accountId, message.sessionId, connection.machineId);
         const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
         if (row)
             broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(row) });
@@ -180,7 +323,7 @@ export function handleMachineMessage(context, connection, message) {
             db.prepare(`INSERT INTO sessions
          (id, account_id, machine_id, agent, cwd, name, status, encrypted_metadata,
           current_head, last_turn_id, source_session_id, source_checkpoint_id, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(message.sessionId, connection.accountId, connection.machineId, source.agent, source.cwd, message.name ?? source.name, "ready", message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : source.encrypted_metadata, message.sourceCheckpointId, source.last_turn_id, message.sourceSessionId, message.sourceCheckpointId, ts, ts);
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(message.sessionId, connection.accountId, connection.machineId, source.agent, source.cwd, message.name ?? source.name, message.transcriptPending === true ? "running" : "ready", message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : source.encrypted_metadata, message.sourceCheckpointId, source.last_turn_id, message.sourceSessionId, message.sourceCheckpointId, ts, ts);
         }
         const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
         if (row)
@@ -220,6 +363,12 @@ export function handleMachineMessage(context, connection, message) {
     }
     if (message.type === "machine:sessionClosed") {
         const session = setSessionStatus(message.sessionId, "closed");
+        finishSessionClaim({
+            accountId: connection.accountId,
+            sessionId: message.sessionId,
+            terminalStatus: "cancelled",
+            errorCode: "SESSION_CLOSED",
+        });
         if (session)
             broadcastControllers(connection.accountId, { type: "server:session", session });
         broadcastAck(connection.accountId, { type: "server:ack", requestId: message.requestId, ok: true });
@@ -234,6 +383,34 @@ export function handleMachineMessage(context, connection, message) {
             acknowledgeMachineMessage();
             return;
         }
+        if (sessionRow.status === "closed") {
+            acknowledgeMachineMessage();
+            return;
+        }
+        const replacementBasis = message.basis;
+        const replacementBasisEvent = replacementBasis
+            ? message.events.find((event) => event.messageId === replacementBasis.eventMessageId &&
+                event.turnId === replacementBasis.turnId &&
+                event.seq === replacementBasis.turnSeq)
+            : undefined;
+        if (replacementBasis && !replacementBasisEvent) {
+            broadcastError(connection.accountId, {
+                type: "server:error",
+                code: "SESSION_REPLACEMENT_BASIS_MISSING",
+                message: "Transcript replacement basis event is not present in the replacement window",
+            });
+            acknowledgeMachineMessage();
+            return;
+        }
+        const currentOrder = sessionHeadBasisOrder(db, sessionRow);
+        const replacementOrder = replacementBasis ? headAdvanceBasisOrder(replacementBasis) : undefined;
+        const shouldApplyReplacement = message.replacementKind === "command" ||
+            !currentOrder ||
+            (replacementOrder !== undefined && compareHeadBasisOrder(replacementOrder, currentOrder) >= 0);
+        if (!shouldApplyReplacement) {
+            acknowledgeMachineMessage();
+            return;
+        }
         const ts = now();
         const inserted = [];
         db.exec("BEGIN");
@@ -242,6 +419,7 @@ export function handleMachineMessage(context, connection, message) {
          WHERE account_id = ? AND session_id = ? AND machine_id = ?`).run(connection.accountId, message.sessionId, connection.machineId);
             db.prepare(`DELETE FROM session_turn_aliases
          WHERE account_id = ? AND session_id = ? AND machine_id = ?`).run(connection.accountId, message.sessionId, connection.machineId);
+            clearPendingSessionHeadAdvances(db, connection.accountId, message.sessionId, connection.machineId);
             for (const event of message.events) {
                 const result = db
                     .prepare(`INSERT INTO session_events
@@ -261,21 +439,42 @@ export function handleMachineMessage(context, connection, message) {
                     payload: event.payload,
                 });
             }
+            const insertedBasisEvent = replacementBasis
+                ? inserted.find((event) => event.messageId === replacementBasis.eventMessageId &&
+                    event.turnId === replacementBasis.turnId &&
+                    event.turnSeq === replacementBasis.turnSeq)
+                : undefined;
             const lastEvent = inserted.at(-1);
+            const headBasisEvent = insertedBasisEvent ?? lastEvent;
+            const headBasisOrder = headBasisEvent ? logicalEventOrderFromParts({
+                id: headBasisEvent.id,
+                createdAt: headBasisEvent.createdAt,
+                messageId: headBasisEvent.messageId,
+                occurredAt: headBasisEvent.occurredAt,
+                seq: headBasisEvent.seq,
+                turnSeq: headBasisEvent.turnSeq,
+            }) : undefined;
             db.prepare(`UPDATE sessions
          SET status = COALESCE(?, status),
              current_head = COALESCE(?, ?),
              last_turn_id = COALESCE(?, ?),
+             head_basis_event_id = ?,
+             head_basis_message_id = ?,
+             head_basis_logical_time = ?,
+             head_basis_turn_seq = ?,
              encrypted_metadata = COALESCE(?, encrypted_metadata),
              updated_at = ?
-         WHERE id = ? AND account_id = ? AND machine_id = ?`).run(message.status ?? null, message.currentHead ?? null, lastEvent ? `event:${lastEvent.id}` : sessionRow.current_head, message.lastTurnId ?? null, lastEvent?.turnId ?? sessionRow.last_turn_id, message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : null, ts, message.sessionId, connection.accountId, connection.machineId);
+         WHERE id = ? AND account_id = ? AND machine_id = ?`).run(message.status ?? null, message.currentHead ?? null, lastEvent ? `event:${lastEvent.id}` : sessionRow.current_head, message.lastTurnId ?? null, lastEvent?.turnId ?? sessionRow.last_turn_id, headBasisEvent?.id ?? null, headBasisEvent?.messageId ?? null, headBasisOrder?.time ?? null, headBasisOrder?.seq ?? null, message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : null, ts, message.sessionId, connection.accountId, connection.machineId);
             db.exec("COMMIT");
         }
         catch (error) {
             db.exec("ROLLBACK");
             throw error;
         }
-        const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
+        const pendingSessionRow = inserted.length > 0
+            ? applyPendingSessionHeadAdvances(db, connection.accountId, message.sessionId, connection.machineId, now())
+            : undefined;
+        const row = pendingSessionRow ?? db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
         if (row) {
             const session = sessionSnapshot(row);
             broadcastControllers(connection.accountId, {
@@ -298,6 +497,10 @@ export function handleMachineMessage(context, connection, message) {
             acknowledgeMachineMessage();
             return;
         }
+        if (sessionRow.status === "closed") {
+            acknowledgeMachineMessage();
+            return;
+        }
         const ts = now();
         const inserted = [];
         db.exec("BEGIN");
@@ -339,7 +542,8 @@ export function handleMachineMessage(context, connection, message) {
             db.exec("ROLLBACK");
             throw error;
         }
-        const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
+        const pendingSessionRow = applyPendingSessionHeadAdvances(db, connection.accountId, message.sessionId, connection.machineId, now());
+        const row = pendingSessionRow ?? db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
         if (row) {
             const session = sessionSnapshot(row);
             broadcastControllers(connection.accountId, {
@@ -354,32 +558,79 @@ export function handleMachineMessage(context, connection, message) {
         acknowledgeMachineMessage();
         return;
     }
-    if (message.type === "machine:event") {
-        const sessionRow = db
-            .prepare("SELECT * FROM sessions WHERE id = ? AND account_id = ? AND machine_id = ?")
-            .get(message.sessionId, connection.accountId, connection.machineId);
-        if (!sessionRow)
-            return;
-        if (aliasedRuntimeEventHasRequestEvents({
+    if (message.type === "machine:sessionHeadAdvanced") {
+        const ts = now();
+        const input = {
             accountId: connection.accountId,
             sessionId: message.sessionId,
             machineId: connection.machineId,
-            runtimeTurnId: message.turnId,
-        })) {
+            messageId,
+            currentHead: message.currentHead,
+            lastTurnId: message.lastTurnId,
+            basis: message.basis,
+            status: message.status,
+            ...(message.encryptedMetadata ? { encryptedMetadata: message.encryptedMetadata } : {}),
+        };
+        const result = applySessionHeadAdvance(db, input, ts);
+        if (result.status === "session-not-found") {
+            broadcastError(connection.accountId, {
+                type: "server:error",
+                code: "SESSION_NOT_FOUND",
+                message: "Session not found for head advance",
+            });
+            acknowledgeMachineMessage();
+            return;
+        }
+        if (result.status === "missing") {
+            storePendingSessionHeadAdvance(db, input, ts);
+            broadcastError(connection.accountId, {
+                type: "server:error",
+                code: "SESSION_HEAD_BASIS_MISSING",
+                message: "Head advance basis event is not available yet; update will be applied when the event arrives",
+            });
+            acknowledgeMachineMessage();
+            return;
+        }
+        if (result.status === "mismatch") {
+            broadcastError(connection.accountId, {
+                type: "server:error",
+                code: "SESSION_HEAD_BASIS_MISMATCH",
+                message: "Head advance basis does not match the stored event",
+            });
             acknowledgeMachineMessage();
             return;
         }
+        const row = result.session ?? db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
+        if (row && row.status !== "closed")
+            broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(row) });
+        acknowledgeMachineMessage();
+        return;
+    }
+    if (message.type === "machine:event") {
+        const sessionRow = db
+            .prepare("SELECT * FROM sessions WHERE id = ? AND account_id = ? AND machine_id = ?")
+            .get(message.sessionId, connection.accountId, connection.machineId);
+        if (!sessionRow)
+            return;
+        const closed = sessionRow.status === "closed";
         const event = insertEvent({
             accountId: connection.accountId,
             sessionId: message.sessionId,
             machineId: connection.machineId,
+            source: "machine",
             messageId: message.messageId,
             turnId: message.turnId,
             turnSeq: message.seq,
             occurredAt: message.occurredAt,
             payload: message.payload,
+            updateSession: !closed,
         });
-        broadcastControllers(connection.accountId, { type: "server:event", event });
+        const pendingSessionRow = applyPendingSessionHeadAdvances(db, connection.accountId, message.sessionId, connection.machineId, now());
+        if (!closed) {
+            broadcastControllers(connection.accountId, { type: "server:event", event });
+            if (pendingSessionRow && pendingSessionRow.status !== "closed")
+                broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(pendingSessionRow) });
+        }
         acknowledgeMachineMessage();
         return;
     }
@@ -395,29 +646,115 @@ export function handleMachineMessage(context, connection, message) {
                 runtimeTurnId: message.lastTurnId ?? message.currentHead,
             });
         }
+        const runtimeTurnId = message.lastTurnId ?? message.currentHead ?? message.turnId;
+        const runtimeBasisEvent = runtimeTurnId
+            ? latestEventForTurn(db, connection.accountId, message.sessionId, connection.machineId, runtimeTurnId)
+            : undefined;
+        const requestBasisEvent = runtimeTurnId !== message.turnId
+            ? latestEventForTurn(db, connection.accountId, message.sessionId, connection.machineId, message.turnId)
+            : undefined;
+        const basisEvent = runtimeBasisEvent ?? requestBasisEvent;
+        const basisOrder = basisEvent ? logicalEventOrder(basisEvent) : undefined;
+        const requestOrder = requestBasisEvent ? logicalEventOrder(requestBasisEvent) : undefined;
+        const sessionRow = db
+            .prepare("SELECT * FROM sessions WHERE id = ? AND account_id = ? AND machine_id = ?")
+            .get(message.sessionId, connection.accountId, connection.machineId);
+        if (!sessionRow) {
+            acknowledgeMachineMessage();
+            return;
+        }
+        if (sessionRow.status === "closed") {
+            finishSessionClaim({
+                accountId: connection.accountId,
+                sessionId: message.sessionId,
+                turnId: message.turnId,
+                terminalStatus: status,
+                ...(message.error ? { errorCode: "TURN_ERROR" } : {}),
+                finishedAt: ts,
+            });
+            acknowledgeMachineMessage();
+            return;
+        }
+        const activeClaim = activePromptClaim(db, connection.accountId, message.sessionId, connection.machineId);
+        const turnDoneMatchesActiveClaim = !activeClaim || activeClaim.turn_id === message.turnId;
+        const currentOrder = sessionHeadBasisOrder(db, sessionRow);
+        const basisComparison = basisOrder ? compareHeadBasisOrder(basisOrder, currentOrder) : null;
+        const isRuntimeAliasForCurrentRequest = Boolean(runtimeBasisEvent && runtimeTurnId !== message.turnId && (sessionRow.last_turn_id === message.turnId || requestBasisEvent));
+        const isInitialTerminal = !sessionRow.last_turn_id && !currentOrder;
+        const isTerminalForCurrentTurn = isRuntimeAliasForCurrentRequest ||
+            sessionRow.last_turn_id === message.turnId ||
+            isInitialTerminal ||
+            (sessionRow.status === "running" && !sessionRow.last_turn_id);
+        const aliasCompletesCurrentRequest = isRuntimeAliasForCurrentRequest &&
+            requestOrder !== undefined &&
+            compareHeadBasisOrder(requestOrder, currentOrder) >= 0;
+        const shouldApplyTurnDone = turnDoneMatchesActiveClaim &&
+            isTerminalForCurrentTurn &&
+            (aliasCompletesCurrentRequest || (basisComparison !== null ? basisComparison >= 0 : !currentOrder));
+        const shouldApplyHead = shouldApplyTurnDone;
         db.prepare(`UPDATE sessions
        SET status = ?,
            current_head = COALESCE(?, current_head),
            last_turn_id = COALESCE(?, last_turn_id),
+           head_basis_event_id = COALESCE(?, head_basis_event_id),
+           head_basis_message_id = COALESCE(?, head_basis_message_id),
+           head_basis_logical_time = COALESCE(?, head_basis_logical_time),
+           head_basis_turn_seq = COALESCE(?, head_basis_turn_seq),
            encrypted_metadata = COALESCE(?, encrypted_metadata),
            updated_at = ?
-       WHERE id = ? AND account_id = ? AND machine_id = ?`).run(status, message.currentHead ?? null, message.lastTurnId ?? message.turnId, message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : null, ts, message.sessionId, connection.accountId, connection.machineId);
+       WHERE id = ? AND account_id = ? AND machine_id = ?`).run(shouldApplyTurnDone ? status : sessionRow.status, shouldApplyHead ? message.currentHead ?? null : null, shouldApplyHead ? message.lastTurnId ?? message.turnId : null, shouldApplyHead ? basisEvent?.id ?? null : null, shouldApplyHead ? basisEvent?.message_id ?? null : null, shouldApplyHead ? basisOrder?.time ?? null : null, shouldApplyHead ? basisOrder?.seq ?? null : null, shouldApplyTurnDone && message.encryptedMetadata ? JSON.stringify(message.encryptedMetadata) : null, ts, message.sessionId, connection.accountId, connection.machineId);
         const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
         const session = row ? sessionSnapshot(row) : undefined;
-        if (session)
+        if (session && session.status !== "closed")
             broadcastControllers(connection.accountId, { type: "server:session", session });
-        if (message.error) {
+        if (shouldApplyTurnDone && message.error) {
             broadcastControllers(connection.accountId, { type: "server:error", message: message.error });
         }
+        if (shouldApplyTurnDone) {
+            finishSessionClaim({
+                accountId: connection.accountId,
+                sessionId: message.sessionId,
+                turnId: message.turnId,
+                terminalStatus: status,
+                ...(message.error ? { errorCode: "TURN_ERROR" } : {}),
+                finishedAt: ts,
+            });
+        }
         acknowledgeMachineMessage();
         return;
     }
     if (message.type === "machine:error") {
         const nonFatalSessionErrors = new Set(["CAPABILITY_UNAVAILABLE", "SESSION_BUSY", "SESSION_NAME_INVALID", "SESSION_RENAME_UNSUPPORTED", "SESSION_RENAME_FAILED"]);
-        if (message.sessionId && !nonFatalSessionErrors.has(message.code ?? "")) {
-            const session = setSessionStatus(message.sessionId, "failed");
-            if (session)
-                broadcastControllers(connection.accountId, { type: "server:session", session });
+        if (message.sessionId) {
+            if (!nonFatalSessionErrors.has(message.code ?? "")) {
+                const row = db
+                    .prepare("SELECT status FROM sessions WHERE id = ? AND account_id = ? AND machine_id = ?")
+                    .get(message.sessionId, connection.accountId, connection.machineId);
+                if (row?.status === "new" || row?.status === "running") {
+                    const session = setSessionStatus(message.sessionId, "failed");
+                    if (session)
+                        broadcastControllers(connection.accountId, { type: "server:session", session });
+                }
+            }
+            else {
+                const row = db
+                    .prepare("SELECT status FROM sessions WHERE id = ? AND account_id = ? AND machine_id = ?")
+                    .get(message.sessionId, connection.accountId, connection.machineId);
+                if (row?.status === "running" && message.code !== "SESSION_BUSY") {
+                    const session = setSessionStatus(message.sessionId, "ready");
+                    if (session)
+                        broadcastControllers(connection.accountId, { type: "server:session", session });
+                }
+            }
+        }
+        if (message.sessionId && message.requestId && message.code !== "SESSION_BUSY") {
+            finishSessionClaim({
+                accountId: connection.accountId,
+                sessionId: message.sessionId,
+                requestId: message.requestId,
+                terminalStatus: "error",
+                errorCode: message.code,
+            });
         }
         broadcastError(connection.accountId, {
             type: "server:error",
@@ -432,4 +769,207 @@ export function handleMachineMessage(context, connection, message) {
 function machineMessageId(message) {
     return "messageId" in message && typeof message.messageId === "string" ? message.messageId : undefined;
 }
+function storePendingSessionHeadAdvance(db, input, ts) {
+    db.prepare(`INSERT INTO pending_session_head_advances
+     (account_id, session_id, machine_id, message_id, current_head, last_turn_id,
+      basis_turn_id, basis_event_message_id, basis_turn_seq, basis_occurred_at,
+      encrypted_metadata, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(account_id, machine_id, message_id) WHERE message_id IS NOT NULL
+     DO UPDATE SET
+       current_head = excluded.current_head,
+       last_turn_id = excluded.last_turn_id,
+       basis_turn_id = excluded.basis_turn_id,
+       basis_event_message_id = excluded.basis_event_message_id,
+       basis_turn_seq = excluded.basis_turn_seq,
+       basis_occurred_at = excluded.basis_occurred_at,
+       encrypted_metadata = excluded.encrypted_metadata,
+       updated_at = excluded.updated_at`).run(input.accountId, input.sessionId, input.machineId, input.messageId ?? null, input.currentHead, input.lastTurnId, input.basis.turnId, input.basis.eventMessageId, input.basis.turnSeq, input.basis.occurredAt ?? null, input.encryptedMetadata ? JSON.stringify(input.encryptedMetadata) : null, ts, ts);
+}
+function clearPendingSessionHeadAdvances(db, accountId, sessionId, machineId) {
+    db.prepare(`DELETE FROM pending_session_head_advances
+     WHERE account_id = ? AND session_id = ? AND machine_id = ?`).run(accountId, sessionId, machineId);
+}
+function applyPendingSessionHeadAdvances(db, accountId, sessionId, machineId, ts) {
+    const pending = db
+        .prepare(`SELECT * FROM pending_session_head_advances
+       WHERE account_id = ? AND session_id = ? AND machine_id = ?
+       ORDER BY created_at, id`)
+        .all(accountId, sessionId, machineId);
+    let latestSession;
+    for (const row of pending) {
+        const result = applySessionHeadAdvance(db, pendingRowToHeadAdvanceInput(row), ts);
+        if (result.status === "missing")
+            continue;
+        db.prepare("DELETE FROM pending_session_head_advances WHERE id = ?").run(row.id);
+        latestSession = result.session ?? latestSession;
+    }
+    return latestSession;
+}
+function pendingRowToHeadAdvanceInput(row) {
+    return {
+        accountId: row.account_id,
+        sessionId: row.session_id,
+        machineId: row.machine_id,
+        messageId: row.message_id ?? undefined,
+        currentHead: row.current_head,
+        lastTurnId: row.last_turn_id,
+        basis: {
+            turnId: row.basis_turn_id,
+            eventMessageId: row.basis_event_message_id,
+            turnSeq: row.basis_turn_seq,
+            ...(row.basis_occurred_at !== null ? { occurredAt: row.basis_occurred_at } : {}),
+        },
+        status: "completed",
+        ...(row.encrypted_metadata ? { encryptedMetadata: JSON.parse(row.encrypted_metadata) } : {}),
+    };
+}
+function applySessionHeadAdvance(db, input, ts) {
+    const sessionRow = db
+        .prepare("SELECT * FROM sessions WHERE id = ? AND account_id = ? AND machine_id = ?")
+        .get(input.sessionId, input.accountId, input.machineId);
+    if (!sessionRow)
+        return { status: "session-not-found" };
+    if (sessionRow.status === "closed")
+        return { status: "noop", session: sessionRow };
+    const basisEvent = resolveHeadAdvanceBasisEvent(db, input.accountId, input.sessionId, input.machineId, input.basis);
+    if (!basisEvent)
+        return { status: "missing", session: sessionRow };
+    if (basisEvent.turn_id !== input.basis.turnId || basisEvent.turn_seq !== input.basis.turnSeq) {
+        return { status: "mismatch", session: sessionRow };
+    }
+    const nextOrder = logicalEventOrder(basisEvent);
+    const currentOrder = sessionHeadBasisOrder(db, sessionRow);
+    const rewriteFenced = typeof sessionRow.head_basis_message_id === "string" &&
+        sessionRow.head_basis_message_id.startsWith(REWRITE_HEAD_BASIS_PREFIX);
+    const comparison = compareHeadBasisOrder(nextOrder, currentOrder);
+    const currentHeadIsBasisEvent = sessionRow.current_head === `event:${basisEvent.id}`;
+    const currentHeadAlreadySettled = currentHeadIsBasisEvent ||
+        sessionRow.current_head === input.currentHead ||
+        sessionRow.last_turn_id === input.lastTurnId;
+    const shouldAdvance = !rewriteFenced && (comparison > 0 || (comparison === 0 && currentHeadIsBasisEvent));
+    const shouldSettleStatus = !rewriteFenced &&
+        input.status !== undefined &&
+        sessionRow.status === "running" &&
+        comparison === 0 &&
+        currentHeadAlreadySettled;
+    const shouldRefreshMetadata = !rewriteFenced &&
+        input.encryptedMetadata !== undefined &&
+        currentHeadAlreadySettled;
+    if (!shouldAdvance && !shouldSettleStatus && !shouldRefreshMetadata)
+        return { status: "noop", session: sessionRow };
+    db.prepare(`UPDATE sessions
+     SET status = COALESCE(?, status),
+         current_head = COALESCE(?, current_head),
+         last_turn_id = COALESCE(?, last_turn_id),
+         head_basis_event_id = COALESCE(?, head_basis_event_id),
+         head_basis_message_id = COALESCE(?, head_basis_message_id),
+         head_basis_logical_time = COALESCE(?, head_basis_logical_time),
+         head_basis_turn_seq = COALESCE(?, head_basis_turn_seq),
+         encrypted_metadata = COALESCE(?, encrypted_metadata),
+         updated_at = ?
+     WHERE id = ? AND account_id = ? AND machine_id = ?`).run(input.status && sessionRow.status === "running" ? input.status : null, shouldAdvance ? input.currentHead : null, shouldAdvance ? input.lastTurnId : null, shouldAdvance ? basisEvent.id : null, shouldAdvance ? basisEvent.message_id : null, shouldAdvance ? nextOrder.time : null, shouldAdvance ? nextOrder.seq : null, input.encryptedMetadata ? JSON.stringify(input.encryptedMetadata) : null, ts, input.sessionId, input.accountId, input.machineId);
+    const session = db.prepare("SELECT * FROM sessions WHERE id = ?").get(input.sessionId);
+    return { status: "applied", session };
+}
+function compareHeadBasisOrder(nextOrder, currentOrder) {
+    if (!currentOrder)
+        return 1;
+    if (nextOrder.time !== currentOrder.time)
+        return nextOrder.time > currentOrder.time ? 1 : -1;
+    if (nextOrder.seq !== currentOrder.seq)
+        return nextOrder.seq > currentOrder.seq ? 1 : -1;
+    if (nextOrder.id !== currentOrder.id)
+        return nextOrder.id > currentOrder.id ? 1 : -1;
+    return 0;
+}
+function sessionHeadBasisOrder(db, session) {
+    if (session.head_basis_logical_time !== null &&
+        session.head_basis_turn_seq !== null) {
+        return {
+            time: session.head_basis_logical_time,
+            seq: session.head_basis_turn_seq,
+            id: session.head_basis_event_id ?? 0,
+        };
+    }
+    const eventId = session.current_head ? /^event:(\d+)$/.exec(session.current_head)?.[1] : undefined;
+    if (!eventId)
+        return undefined;
+    const event = db
+        .prepare("SELECT * FROM session_events WHERE account_id = ? AND session_id = ? AND machine_id = ? AND id = ?")
+        .get(session.account_id, session.id, session.machine_id, Number(eventId));
+    return event ? logicalEventOrder(event) : undefined;
+}
+function headAdvanceBasisOrder(basis) {
+    return {
+        time: basis.occurredAt ?? 0,
+        seq: basis.turnSeq,
+        id: Number.MAX_SAFE_INTEGER,
+    };
+}
+function resolveHeadAdvanceBasisEvent(db, accountId, sessionId, machineId, basis) {
+    const exact = db
+        .prepare(`SELECT * FROM session_events
+       WHERE account_id = ? AND session_id = ? AND machine_id = ? AND message_id = ?`)
+        .get(accountId, sessionId, machineId, basis.eventMessageId);
+    if (exact)
+        return exact;
+    return db
+        .prepare(`SELECT * FROM session_events
+       WHERE account_id = ? AND session_id = ? AND machine_id = ? AND turn_id = ? AND turn_seq = ?
+       ORDER BY id DESC
+       LIMIT 1`)
+        .get(accountId, sessionId, machineId, basis.turnId, basis.turnSeq);
+}
+function logicalEventOrder(event) {
+    return logicalEventOrderFromParts({
+        id: event.id,
+        createdAt: event.created_at,
+        messageId: event.message_id ?? undefined,
+        occurredAt: event.occurred_at ?? undefined,
+        seq: event.seq,
+        turnSeq: event.turn_seq ?? undefined,
+    });
+}
+function logicalEventOrderFromParts(input) {
+    if (input.occurredAt !== undefined) {
+        return { time: input.occurredAt, seq: input.turnSeq ?? input.seq ?? input.id, id: input.id };
+    }
+    if (typeof input.messageId === "string" && input.messageId.startsWith("hist_") && input.turnSeq !== undefined) {
+        return { time: 0, seq: input.turnSeq, id: input.id };
+    }
+    return { time: input.createdAt, seq: input.turnSeq ?? input.seq ?? input.id, id: input.id };
+}
+function latestEventForTurn(db, accountId, sessionId, machineId, turnId) {
+    return db
+        .prepare(`SELECT * FROM session_events
+       WHERE account_id = ? AND session_id = ? AND machine_id = ? AND turn_id = ?
+       ORDER BY id DESC
+       LIMIT 1`)
+        .get(accountId, sessionId, machineId, turnId);
+}
+function activePromptClaim(db, accountId, sessionId, machineId) {
+    return db
+        .prepare(`SELECT request_id, turn_id
+       FROM relay_session_claims
+       WHERE account_id = ? AND session_id = ? AND machine_id = ? AND command_type = 'prompt' AND state = 'active'`)
+        .get(accountId, sessionId, machineId);
+}
+function recordRuntimeBindingsFromMachineMessage(db, connection, row, message, ts) {
+    const runtimeSessionIds = normalizeRuntimeSessionIds([
+        message.runtimeSessionId,
+        ...(message.runtimeSessionIds ?? []),
+    ]);
+    if (runtimeSessionIds.length === 0)
+        return;
+    upsertSessionRuntimeBindings(db, {
+        accountId: connection.accountId,
+        machineId: connection.machineId,
+        agent: row.agent,
+        sessionId: row.id,
+        runtimeSessionIds,
+        status: "active",
+        ts,
+    });
+}
 //# sourceMappingURL=machine-handlers.js.map