@cydm/happy-elves 0.1.0-beta.274 → 0.1.0-beta.279

package/apps/cli/dist/commands/lib/session-output.js

@@ -315,7 +315,7 @@ function foldAliasedRuntimeEvents(events) {
     const profiles = new Map();
     const runtimeToRequest = new Map();
     for (const event of events) {
-        const profile = profiles.get(event.turnId) ?? { output: "" };
+        const profile = profiles.get(event.turnId) ?? { output: "", status: "running" };
         const payload = event.decoded;
         if (payload?.type === "user_prompt" && profile.prompt === undefined) {
             profile.prompt = payload.text.trim();
@@ -328,6 +328,7 @@ function foldAliasedRuntimeEvents(events) {
             if (runtimeTurnId && runtimeTurnId !== event.turnId && !runtimeTurnId.startsWith("event:")) {
                 runtimeToRequest.set(runtimeTurnId, event.turnId);
             }
+            profile.status = payload.status;
         }
         profiles.set(event.turnId, profile);
     }
@@ -345,11 +346,46 @@ function foldAliasedRuntimeEvents(events) {
             duplicateRuntimeToRequest.set(runtimeTurnId, requestTurnId);
         }
     }
+    const inferredRuntimeToRequest = inferRuntimeCompletionAliases(profiles);
+    const inferredRequestTurns = new Set(inferredRuntimeToRequest.values());
+    const foldedRuntimeToRequest = new Map([...duplicateRuntimeToRequest, ...inferredRuntimeToRequest]);
+    const foldedEvents = [];
+    for (const event of events) {
+        if (duplicateRuntimeTurns.has(event.turnId))
+            continue;
+        const inferredRequestTurnId = inferredRuntimeToRequest.get(event.turnId);
+        if (inferredRequestTurnId) {
+            if (event.decoded?.type === "user_prompt" && profiles.get(inferredRequestTurnId)?.prompt)
+                continue;
+            foldedEvents.push({ ...event, turnId: inferredRequestTurnId });
+            continue;
+        }
+        if (inferredRequestTurns.has(event.turnId) &&
+            event.decoded?.type === "text_delta" &&
+            event.decoded.stream !== "thought") {
+            continue;
+        }
+        foldedEvents.push(event);
+    }
     return {
-        events: duplicateRuntimeTurns.size === 0 ? events : events.filter((event) => !duplicateRuntimeTurns.has(event.turnId)),
-        runtimeToRequest: duplicateRuntimeToRequest,
+        events: foldedEvents,
+        runtimeToRequest: foldedRuntimeToRequest,
     };
 }
+function inferRuntimeCompletionAliases(profiles) {
+    const requestTurns = [...profiles.entries()].filter(([turnId, profile]) => turnId.startsWith("turn_") && profile.status === "running" && Boolean(profile.prompt?.trim()));
+    const runtimeTurns = [...profiles.entries()].filter(([turnId, profile]) => !turnId.startsWith("turn_") && profile.status !== "running" && Boolean(profile.prompt?.trim()));
+    const result = new Map();
+    for (const [runtimeTurnId, runtime] of runtimeTurns) {
+        const candidates = requestTurns.filter(([, request]) => promptCompatible(request.prompt ?? "", runtime.prompt ?? "") &&
+            outputCompatibleForInferredAlias(request.output, runtime.output, request.prompt ?? "", runtime.prompt ?? ""));
+        if (candidates.length !== 1)
+            continue;
+        const [requestTurnId] = candidates[0];
+        result.set(runtimeTurnId, requestTurnId);
+    }
+    return result;
+}
 function dedupeSyntheticHistoricalEvents(events) {
     const groups = new Map();
     for (const event of events) {
@@ -408,6 +444,23 @@ function isDuplicateRuntimeOutput(requestOutput, runtimeOutput) {
     const runtime = comparableOutput(runtimeOutput);
     return !runtime || request === runtime || request.includes(runtime);
 }
+function promptCompatible(requestPrompt, runtimePrompt) {
+    const request = comparableOutput(requestPrompt);
+    const runtime = comparableOutput(runtimePrompt);
+    if (!request || !runtime)
+        return false;
+    if (request === runtime)
+        return true;
+    return (request.length >= 40 && runtime.includes(request)) ||
+        (runtime.length >= 40 && request.includes(runtime));
+}
+function outputCompatibleForInferredAlias(requestOutput, runtimeOutput, requestPrompt, runtimePrompt) {
+    const request = comparableOutput(requestOutput);
+    const runtime = comparableOutput(runtimeOutput);
+    if (request && runtime)
+        return request.includes(runtime) || runtime.includes(request);
+    return comparableOutput(requestPrompt) === comparableOutput(runtimePrompt) && Boolean(request || runtime);
+}
 function comparableOutput(value) {
     return value.replace(/\s+/g, " ").trim();
 }

package/apps/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-cli",
-  "version": "0.1.0-beta.274",
+  "version": "0.1.0-beta.279",
   "private": true,
   "type": "module"
 }

package/apps/daemon/dist/relay/release.js

@@ -248,7 +248,7 @@ async function runStage(stage) {
   await log("$ " + stage.command + " " + args.map(shellQuote).join(" "));
   const result = await run(stage.command, args, {
     cwd: input.repoCwd,
-    env: controllerEnv(),
+    env: envForStage(stage),
   });
   await log(result.stdout);
   if (result.stderr) await log(result.stderr);
@@ -300,16 +300,20 @@ async function run(command, args, options) {
   });
 }
 
-function controllerEnv() {
+function envForStage(stage) {
+  const env = { ...process.env };
+  if (stage.phase !== "update" && stage.phase !== "notify") {
+    delete env.HAPPY_ELVES_RELAY_URL;
+    delete env.HAPPY_ELVES_CONTROLLER_TOKEN;
+    delete env.HAPPY_ELVES_ACCOUNT_SECRET;
+    return env;
+  }
   const config = input.controllerConfig;
-  return {
-    ...process.env,
-    ...(config ? {
-      HAPPY_ELVES_RELAY_URL: config.relayUrl,
-      HAPPY_ELVES_CONTROLLER_TOKEN: config.controllerToken,
-      HAPPY_ELVES_ACCOUNT_SECRET: config.accountSecret,
-    } : {}),
-  };
+  if (!config) return env;
+  env.HAPPY_ELVES_RELAY_URL = config.relayUrl;
+  env.HAPPY_ELVES_CONTROLLER_TOKEN = config.controllerToken;
+  env.HAPPY_ELVES_ACCOUNT_SECRET = config.accountSecret;
+  return env;
 }
 
 async function setStage(name, patch) {

package/apps/daemon/dist/session/lifecycle.d.ts

@@ -1,6 +1,7 @@
 import { type MachineCommand } from "../../../../packages/shared/dist/index.js";
 import type { DaemonConfig, HistoricalBackfillStatus, SessionFallback, SessionState } from "../types.js";
 import { type HistoricalSessionHead } from "./events.js";
+type HistoricalBackfillDirection = "latest" | "older";
 export type HistoricalBackfillResult = {
     availableEvents: number;
     cursor: number;
@@ -16,7 +17,7 @@ export type HistoricalBackfillResult = {
 export declare function handleCreateSession(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
 export declare function handleImportHistoricalSession(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
 export declare function handleListHistoricalSessions(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
-export declare function resumeSession(ws: WebSocket, config: DaemonConfig, sessionId: string, requestId: string, fallback?: SessionFallback, announceSuccess?: boolean): Promise<SessionState | null>;
+export declare function resumeSession(ws: WebSocket, config: DaemonConfig, sessionId: string, requestId: string, fallback?: SessionFallback, announceSuccess?: boolean, syncDirection?: HistoricalBackfillDirection): Promise<SessionState | null>;
 export declare function usesAuthoritativeTranscript(session: SessionState): boolean;
 export declare function replaceAuthoritativeTranscript(ws: WebSocket, config: DaemonConfig, session: SessionState, runtimeSessionId?: string | undefined, input?: {
     currentHead?: string;
@@ -28,3 +29,4 @@ export declare function replaceAuthoritativeTranscript(ws: WebSocket, config: Da
 }): Promise<HistoricalBackfillResult>;
 export declare function handleResume(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
 export declare function handleClose(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
+export {};

package/apps/daemon/dist/session/lifecycle.js

@@ -256,12 +256,14 @@ function historicalSessionPage(value) {
         return { sessions: value };
     return value;
 }
-export async function resumeSession(ws, config, sessionId, requestId, fallback, announceSuccess = true) {
+export async function resumeSession(ws, config, sessionId, requestId, fallback, announceSuccess = true, syncDirection = "latest") {
     const existing = sessions.get(sessionId);
     if (existing) {
         const refreshed = await refreshRuntimeSessionName(existing);
         const nameChanged = refreshed.name !== existing.name;
-        const backfill = await backfillHistoricalEvents(ws, config, refreshed, undefined, refreshed.historicalBackfill ?? fallback?.historicalBackfill);
+        const backfill = await backfillHistoricalEvents(ws, config, refreshed, undefined, refreshed.historicalBackfill ?? fallback?.historicalBackfill, {
+            direction: syncDirection,
+        });
         const resumed = withHistoricalBackfill(refreshed, backfill);
         sessions.set(sessionId, resumed);
         await appendAudit({
@@ -311,7 +313,9 @@ export async function resumeSession(ws, config, sessionId, requestId, fallback,
         const state = await refreshRuntimeSessionName({ sessionId, agent, cwd, name, handle });
         sessions.set(sessionId, state);
         const nameChanged = state.name !== name;
-        const backfill = await backfillHistoricalEvents(ws, config, state, resumeSessionId, fallback?.historicalBackfill);
+        const backfill = await backfillHistoricalEvents(ws, config, state, resumeSessionId, fallback?.historicalBackfill, {
+            direction: syncDirection,
+        });
         const resumed = withHistoricalBackfill(state, backfill);
         sessions.set(sessionId, resumed);
         await appendAudit({
@@ -558,7 +562,7 @@ async function backfillHistoricalEvents(ws, config, session, runtimeSessionId =
     if (!runtimeSessionId)
         return completedBackfillResult(0);
     if (usesAuthoritativeTranscript(session)) {
-        if (previousBackfill?.status === "partial" && previousBackfill.providerCursor) {
+        if ((options.direction ?? "latest") === "older" && previousBackfill?.status === "partial" && previousBackfill.providerCursor) {
             return await prependAuthoritativeTranscript(ws, config, session, runtimeSessionId, previousBackfill, { strict: options.strict });
         }
         return await replaceAuthoritativeTranscript(ws, config, session, runtimeSessionId, { strict: options.strict });
@@ -731,7 +735,7 @@ export async function handleResume(ws, config, command) {
         return;
     if (!claimCommandRequest(ws, command.requestId))
         return;
-    await resumeSession(ws, config, command.sessionId, command.requestId, await sessionFallbackFromCommand(config, command));
+    await resumeSession(ws, config, command.sessionId, command.requestId, await sessionFallbackFromCommand(config, command), true, command.syncDirection ?? "latest");
 }
 export async function handleClose(ws, config, command) {
     if (command.type !== "machine:close")

package/apps/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-daemon",
-  "version": "0.1.0-beta.274",
+  "version": "0.1.0-beta.279",
   "private": true,
   "type": "module"
 }

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

@@ -354,6 +354,7 @@ export function handleControllerMessage(context, connection, message) {
             type: "machine:resume",
             requestId: message.requestId,
             sessionId: message.sessionId,
+            ...(message.syncDirection ? { syncDirection: message.syncDirection } : {}),
             encryptedMetadata: sessionRow.encrypted_metadata ? parseJson(sessionRow.encrypted_metadata, undefined) : undefined,
         });
         return;
@@ -784,21 +785,20 @@ export function handleControllerMessage(context, connection, message) {
             sendAck(connection, { type: "server:ack", requestId: message.requestId, ok: true });
             return;
         }
+        const closedSession = setSessionStatus(sessionRow.id, "closed");
+        finishSessionClaim({
+            accountId: connection.accountId,
+            sessionId: sessionRow.id,
+            terminalStatus: "cancelled",
+            errorCode: "SESSION_CLOSED",
+        });
+        if (closedSession)
+            broadcastControllers(connection.accountId, { type: "server:session", session: closedSession });
+        sendAck(connection, { type: "server:ack", requestId: message.requestId, ok: true });
         const machineConnection = connectedMachine(connection.accountId, sessionRow.machine_id);
         if (!machineConnection) {
-            const session = setSessionStatus(sessionRow.id, "closed");
-            finishSessionClaim({
-                accountId: connection.accountId,
-                sessionId: sessionRow.id,
-                terminalStatus: "cancelled",
-                errorCode: "SESSION_CLOSED",
-            });
-            if (session)
-                broadcastControllers(connection.accountId, { type: "server:session", session });
-            sendAck(connection, { type: "server:ack", requestId: message.requestId, ok: true });
             return;
         }
-        markCommandPending(connection.accountId, sessionRow.machine_id, message.requestId);
         send(machineConnection.socket, {
             type: "machine:close",
             requestId: message.requestId,

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

@@ -223,7 +223,7 @@ export function handleMachineMessage(context, connection, message) {
              current_head = COALESCE(?, current_head),
              last_turn_id = COALESCE(?, last_turn_id),
              updated_at = ?
-         WHERE id = ? AND account_id = ? AND machine_id = ?`).run(message.result.terminalStatus, message.result.currentHead ?? null, message.result.lastTurnId ?? message.result.turnId ?? null, ts, message.result.sessionId, connection.accountId, connection.machineId);
+         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,
@@ -237,6 +237,30 @@ export function handleMachineMessage(context, connection, message) {
             if (row)
                 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) {
+                db.prepare(`UPDATE sessions
+           SET status = 'failed',
+               current_head = COALESCE(current_head, ?),
+               last_turn_id = ?,
+               updated_at = ?
+           WHERE id = ? AND account_id = ? AND machine_id = ? AND status != 'closed'`).run(turnId, turnId, ts, message.result.sessionId, connection.accountId, connection.machineId);
+                if (requestId) {
+                    db.prepare(`UPDATE relay_admissions
+             SET last_error_code = COALESCE(last_error_code, ?), updated_at = ?
+             WHERE account_id = ? AND session_id = ? AND request_id = ?`).run(message.result.status === "not_found" ? "EXECUTION_NOT_FOUND" : "EXECUTION_UNKNOWN", ts, connection.accountId, message.result.sessionId, requestId);
+                }
+                const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.result.sessionId);
+                if (row)
+                    broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(row) });
+            }
+        }
         rememberCommandResponse(connection.accountId, message.requestId, response);
         clearCommandPending(connection.accountId, message.requestId);
         broadcastControllers(connection.accountId, response);
@@ -371,6 +395,10 @@ 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 &&
@@ -396,13 +424,30 @@ export function handleMachineMessage(context, connection, message) {
             return;
         }
         const ts = now();
+        const promptTurnForRequest = message.requestId
+            ? promptTurnForRequestId(db, connection.accountId, message.sessionId, connection.machineId, message.requestId)
+            : undefined;
+        const activeClaim = activePromptClaim(db, connection.accountId, message.sessionId, connection.machineId);
+        const replacementRequestTurn = promptTurnForRequest?.turn_id ??
+            (sessionRow.status === "running" && message.status ? activeClaim?.turn_id : undefined);
+        const replacementRequestId = promptTurnForRequest?.request_id ??
+            (replacementRequestTurn === activeClaim?.turn_id ? activeClaim?.request_id : undefined);
         const inserted = [];
         db.exec("BEGIN");
         try {
             db.prepare(`DELETE FROM session_events
          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);
+            if (replacementRequestTurn) {
+                recordAliasesForRuntimeTurnIds({
+                    accountId: connection.accountId,
+                    sessionId: message.sessionId,
+                    machineId: connection.machineId,
+                    requestTurnId: replacementRequestTurn,
+                    requestId: replacementRequestId,
+                    runtimeTurnIds: [message.lastTurnId, message.currentHead, replacementBasis?.turnId],
+                    recordTurnAlias,
+                });
+            }
             clearPendingSessionHeadAdvances(db, connection.accountId, message.sessionId, connection.machineId);
             for (const event of message.events) {
                 const result = db
@@ -449,6 +494,16 @@ export function handleMachineMessage(context, connection, message) {
              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, 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);
+            if (message.status && replacementRequestTurn) {
+                finishSessionClaim({
+                    accountId: connection.accountId,
+                    sessionId: message.sessionId,
+                    ...(replacementRequestId ? { requestId: replacementRequestId } : {}),
+                    turnId: replacementRequestTurn,
+                    terminalStatus: message.status,
+                    finishedAt: ts,
+                });
+            }
             db.exec("COMMIT");
         }
         catch (error) {
@@ -464,7 +519,7 @@ export function handleMachineMessage(context, connection, message) {
             broadcastControllers(connection.accountId, {
                 type: "server:sessionTranscriptReplaced",
                 session,
-                events: inserted,
+                events: inserted.map((event) => canonicalEventForControllers(db, connection.accountId, event)),
                 hasMoreBefore: message.hasMoreBefore,
                 nextBefore: message.nextBefore,
             });
@@ -481,6 +536,10 @@ export function handleMachineMessage(context, connection, message) {
             acknowledgeMachineMessage();
             return;
         }
+        if (sessionRow.status === "closed") {
+            acknowledgeMachineMessage();
+            return;
+        }
         const ts = now();
         const inserted = [];
         db.exec("BEGIN");
@@ -540,6 +599,27 @@ export function handleMachineMessage(context, connection, message) {
     }
     if (message.type === "machine:sessionHeadAdvanced") {
         const ts = now();
+        const sessionBefore = db
+            .prepare("SELECT * FROM sessions WHERE id = ? AND account_id = ? AND machine_id = ?")
+            .get(message.sessionId, connection.accountId, connection.machineId);
+        if (sessionBefore?.status === "closed") {
+            acknowledgeMachineMessage();
+            return;
+        }
+        const activeClaim = sessionBefore
+            ? activePromptClaim(db, connection.accountId, message.sessionId, connection.machineId)
+            : undefined;
+        if (sessionBefore?.status === "running" && activeClaim && message.status) {
+            recordAliasesForRuntimeTurnIds({
+                accountId: connection.accountId,
+                sessionId: message.sessionId,
+                machineId: connection.machineId,
+                requestTurnId: activeClaim.turn_id,
+                requestId: activeClaim.request_id,
+                runtimeTurnIds: [message.lastTurnId, message.currentHead, message.basis.turnId],
+                recordTurnAlias,
+            });
+        }
         const input = {
             accountId: connection.accountId,
             sessionId: message.sessionId,
@@ -580,7 +660,22 @@ export function handleMachineMessage(context, connection, message) {
             acknowledgeMachineMessage();
             return;
         }
-        const row = result.session ?? db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
+        if (message.status && activeClaim && sessionBefore?.status === "running") {
+            db.prepare(`UPDATE sessions
+         SET status = ?,
+             last_turn_id = COALESCE(?, last_turn_id),
+             updated_at = ?
+         WHERE id = ? AND account_id = ? AND machine_id = ? AND status = 'running'`).run(message.status, message.lastTurnId ?? message.currentHead ?? message.basis.turnId, ts, message.sessionId, connection.accountId, connection.machineId);
+            finishSessionClaim({
+                accountId: connection.accountId,
+                sessionId: message.sessionId,
+                requestId: activeClaim.request_id,
+                turnId: activeClaim.turn_id,
+                terminalStatus: message.status,
+                finishedAt: ts,
+            });
+        }
+        const row = db.prepare("SELECT * FROM sessions WHERE id = ?").get(message.sessionId);
         if (row)
             broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(row) });
         acknowledgeMachineMessage();
@@ -592,6 +687,17 @@ export function handleMachineMessage(context, connection, message) {
             .get(message.sessionId, connection.accountId, connection.machineId);
         if (!sessionRow)
             return;
+        maybeAliasHistoricalRuntimeEventToActiveClaim({
+            db,
+            accountId: connection.accountId,
+            sessionId: message.sessionId,
+            machineId: connection.machineId,
+            session: sessionRow,
+            turnId: message.turnId,
+            messageId: message.messageId,
+            occurredAt: message.occurredAt,
+            recordTurnAlias,
+        });
         const event = insertEvent({
             accountId: connection.accountId,
             sessionId: message.sessionId,
@@ -604,7 +710,7 @@ export function handleMachineMessage(context, connection, message) {
             payload: message.payload,
         });
         const pendingSessionRow = applyPendingSessionHeadAdvances(db, connection.accountId, message.sessionId, connection.machineId, now());
-        broadcastControllers(connection.accountId, { type: "server:event", event });
+        broadcastControllers(connection.accountId, { type: "server:event", event: canonicalEventForControllers(db, connection.accountId, event) });
         if (pendingSessionRow)
             broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(pendingSessionRow) });
         acknowledgeMachineMessage();
@@ -639,6 +745,18 @@ export function handleMachineMessage(context, connection, message) {
             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 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));
@@ -790,6 +908,8 @@ function applySessionHeadAdvance(db, input, ts) {
         .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 };
@@ -903,4 +1023,82 @@ function latestEventForTurn(db, accountId, sessionId, machineId, turnId) {
        LIMIT 1`)
         .get(accountId, sessionId, machineId, turnId);
 }
+function activePromptClaim(db, accountId, sessionId, machineId) {
+    return db
+        .prepare(`SELECT * FROM relay_session_claims
+       WHERE account_id = ? AND session_id = ? AND machine_id = ? AND state = 'active'
+       LIMIT 1`)
+        .get(accountId, sessionId, machineId);
+}
+function promptTurnForRequestId(db, accountId, sessionId, machineId, requestId) {
+    const claim = db
+        .prepare(`SELECT request_id, turn_id FROM relay_session_claims
+       WHERE account_id = ? AND session_id = ? AND machine_id = ? AND request_id = ? AND state = 'active'
+       LIMIT 1`)
+        .get(accountId, sessionId, machineId, requestId);
+    if (claim)
+        return claim;
+    return db
+        .prepare(`SELECT request_id, turn_id FROM relay_admissions
+       WHERE account_id = ? AND session_id = ? AND machine_id = ? AND request_id = ? AND kind = 'prompt' AND turn_id IS NOT NULL
+       LIMIT 1`)
+        .get(accountId, sessionId, machineId, requestId);
+}
+function maybeAliasHistoricalRuntimeEventToActiveClaim(input) {
+    if (input.session.status !== "running")
+        return;
+    if (!isHistoricalRuntimeBackfillMessage(input.messageId, input.occurredAt))
+        return;
+    const claim = activePromptClaim(input.db, input.accountId, input.sessionId, input.machineId);
+    if (!claim)
+        return;
+    recordAliasesForRuntimeTurnIds({
+        accountId: input.accountId,
+        sessionId: input.sessionId,
+        machineId: input.machineId,
+        requestTurnId: claim.turn_id,
+        requestId: claim.request_id,
+        runtimeTurnIds: [input.turnId],
+        recordTurnAlias: input.recordTurnAlias,
+    });
+}
+function isHistoricalRuntimeBackfillMessage(messageId, occurredAt) {
+    if (messageId?.startsWith("hist_") || messageId?.startsWith("tail_"))
+        return true;
+    return occurredAt !== undefined;
+}
+function recordAliasesForRuntimeTurnIds(input) {
+    for (const runtimeTurnId of input.runtimeTurnIds) {
+        if (!isRuntimeTurnAliasCandidate(input.requestTurnId, runtimeTurnId))
+            continue;
+        input.recordTurnAlias({
+            accountId: input.accountId,
+            sessionId: input.sessionId,
+            machineId: input.machineId,
+            requestTurnId: input.requestTurnId,
+            runtimeTurnId,
+            requestId: input.requestId,
+        });
+    }
+}
+function isRuntimeTurnAliasCandidate(requestTurnId, runtimeTurnId) {
+    if (!runtimeTurnId)
+        return false;
+    const value = runtimeTurnId.trim();
+    if (!value || value === requestTurnId)
+        return false;
+    if (value.startsWith("event:"))
+        return false;
+    return true;
+}
+function canonicalEventForControllers(db, accountId, event) {
+    const alias = db
+        .prepare(`SELECT request_turn_id FROM session_turn_aliases
+       WHERE account_id = ? AND session_id = ? AND machine_id = ? AND runtime_turn_id = ?
+       LIMIT 1`)
+        .get(accountId, event.sessionId, event.machineId, event.turnId);
+    return alias && alias.request_turn_id !== event.turnId
+        ? { ...event, turnId: alias.request_turn_id }
+        : event;
+}
 //# sourceMappingURL=machine-handlers.js.map

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

@@ -366,6 +366,29 @@ export function createRelayContext(options) {
         if (!machine)
             return "queued";
         const command = JSON.parse(row.message);
+        if (command.type === "machine:prompt") {
+            const session = options.db
+                .prepare("SELECT status FROM sessions WHERE account_id = ? AND id = ? AND machine_id = ?")
+                .get(accountId, command.sessionId, row.machine_id);
+            if (session?.status === "closed") {
+                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);
+                finishSessionClaim({
+                    accountId,
+                    sessionId: command.sessionId,
+                    requestId,
+                    turnId: command.turnId,
+                    terminalStatus: "cancelled",
+                    errorCode: "SESSION_CLOSED",
+                    finishedAt: ts,
+                });
+                return "queued";
+            }
+        }
         send(machine.socket, command);
         const ts = now();
         options.db
@@ -635,7 +658,9 @@ export function createRelayContext(options) {
     }
     function setSessionStatus(sessionId, status) {
         const ts = now();
-        options.db.prepare("UPDATE sessions SET status = ?, updated_at = ? WHERE id = ?").run(status, ts, sessionId);
+        options.db
+            .prepare("UPDATE sessions SET status = ?, updated_at = ? WHERE id = ? AND (status != 'closed' OR ? = 'closed')")
+            .run(status, ts, sessionId, status);
         const row = options.db.prepare("SELECT * FROM sessions WHERE id = ?").get(sessionId);
         return row ? sessionSnapshot(row) : undefined;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.274",
+  "version": "0.1.0-beta.279",
   "description": "Remote controller for local coding agents with hosted or self-hosted relay support.",
   "type": "module",
   "bin": {

package/packages/client/dist/client.d.ts

@@ -70,7 +70,9 @@ export declare class ControllerClient {
     collectPage(sessionId: string, input?: CollectInput): Promise<DecodedSessionEventsPage>;
     repairSessionHead(sessionId: string, input: RepairSessionHeadInput): Promise<RepairSessionHeadResult>;
     wait(sessionId: string, input?: WaitInput): Promise<SessionSnapshot>;
-    resume(sessionId: string): Promise<CommandResult>;
+    resume(sessionId: string, options?: {
+        syncDirection?: "latest" | "older";
+    }): Promise<CommandResult>;
     listHistoricalSessionsPage(input: HistoricalSessionsInput): Promise<HistoricalSessionListPage>;
     listHistoricalSessions(input: HistoricalSessionsInput): Promise<HistoricalSessionSnapshot[]>;
     listDirectory(input: DirectoryInput): Promise<DirectoryListing>;

package/packages/client/dist/client.js

@@ -302,10 +302,15 @@ export class ControllerClient {
             await sleep(intervalMs);
         }
     }
-    async resume(sessionId) {
+    async resume(sessionId, options = {}) {
         const checkedSessionId = requireNonEmpty(sessionId, "sessionId");
         const requestId = randomId("req");
-        return await this.sendCommand({ type: "controller:resume", requestId, sessionId: checkedSessionId });
+        return await this.sendCommand({
+            type: "controller:resume",
+            requestId,
+            sessionId: checkedSessionId,
+            ...(options.syncDirection ? { syncDirection: options.syncDirection } : {}),
+        });
     }
     async listHistoricalSessionsPage(input) {
         const machineId = requireNonEmpty(input.machineId, "machineId");

package/packages/shared/dist/protocol.d.ts

@@ -50,6 +50,7 @@ export type ControllerClientMessage = {
     type: "controller:resume";
     requestId: string;
     sessionId: string;
+    syncDirection?: "latest" | "older";
 } | {
     type: "controller:listHistoricalSessions";
     requestId: string;
@@ -384,6 +385,7 @@ export type MachineCommand = {
     type: "machine:resume";
     requestId: string;
     sessionId: string;
+    syncDirection?: "latest" | "older";
     encryptedMetadata?: EncryptedEnvelope;
 } | {
     type: "machine:listHistoricalSessions";

package/packages/shared/dist/protocol.js

@@ -57,6 +57,7 @@ const controllerMessageSchema = z.discriminatedUnion("type", [
         type: z.literal("controller:resume"),
         requestId: z.string().min(1),
         sessionId: z.string().min(1),
+        syncDirection: z.enum(["latest", "older"]).optional(),
     }),
     z.object({
         type: z.literal("controller:listHistoricalSessions"),
@@ -458,6 +459,7 @@ const machineCommandSchema = z.discriminatedUnion("type", [
         type: z.literal("machine:resume"),
         requestId: z.string().min(1),
         sessionId: z.string().min(1),
+        syncDirection: z.enum(["latest", "older"]).optional(),
         encryptedMetadata: encryptedEnvelopeSchema.optional(),
     }),
     z.object({