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

package/apps/cli/dist/commands/lib/session-output.d.ts

@@ -29,7 +29,7 @@ export type TurnSummary = {
     checkpointId?: string;
     runtimeTurnId?: string;
     turnSeq?: number;
-    status: "running" | "completed" | "failed" | "cancelled";
+    status: "running" | "completed" | "failed" | "cancelled" | "unknown";
     prompt: string;
     output: string;
     terminalText: string;

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

@@ -243,6 +243,13 @@ export function summarizeTurns(events) {
             current.checkpointId = payload.currentHead;
             current.runtimeTurnId = payload.lastTurnId;
         }
+        else if (payload?.type === "status" && isReconcileUnknownTag(payload.tag)) {
+            if (current.status === "running") {
+                current.status = "unknown";
+                current.completedAt = event.createdAt;
+                current.terminalText = payload.text.trim();
+            }
+        }
         else if (payload?.type === "memory_used") {
             current.usedMemories = dedupeUsedMemories([...current.usedMemories, ...payload.memories]);
         }
@@ -472,6 +479,9 @@ function turnInProgressError(sessionId, turn, latestCompleted) {
         latestCompletedTurnId: latestCompleted?.turnId,
     });
 }
+function isReconcileUnknownTag(tag) {
+    return tag === "reconcile:unknown" || tag === "reconcile:not_found" || tag === "reconcile:uninspectable";
+}
 export async function rebuildTurnOutput(client, sessionId, turnId) {
     const events = await client.history(sessionId, 1000);
     const folded = foldAliasedRuntimeEvents(events);

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

@@ -34,7 +34,7 @@ function orchestrationStateFromStatus(status) {
         return "idle";
     if (status === "completed")
         return "completed";
-    if (status === "failed" || status === "offline")
+    if (status === "failed" || status === "offline" || status === "unknown")
         return "blocked";
     return "closed";
 }
@@ -70,6 +70,17 @@ export function deriveOrchestration(session, events = []) {
             completed: false,
         };
     }
+    if (latestTerminalTurn?.status === "unknown") {
+        return {
+            state: "blocked",
+            rawStatus: session.status,
+            needsUser: false,
+            blocked: true,
+            completed: false,
+            reason: "execution-unknown",
+            lastEventId: latestTerminalTurn.lastEventId,
+        };
+    }
     const state = orchestrationStateFromStatus(session.status);
     return {
         state,

package/apps/cli/dist/commands/session.js

@@ -312,6 +312,26 @@ function shouldSearchRuntimeBindingCandidates(latestEvents, metadata) {
 function runtimeBindingSuspected(candidates) {
     return candidates.some((candidate) => candidate.reasons.includes("name") && !candidate.reasons.includes("already-loaded"));
 }
+async function enrichHistoricalLoadedSessionIds(client, sessions) {
+    const snapshot = await client.snapshot();
+    const runtimeIdToSession = new Map();
+    for (const session of snapshot.sessions) {
+        if (session.status === "closed")
+            continue;
+        const metadata = await client.decodeSessionMetadata(session);
+        for (const runtimeSessionId of metadataRuntimeSessionIds(metadata)) {
+            const key = `${session.machineId}:${session.agent}:${runtimeSessionId}`;
+            const existing = runtimeIdToSession.get(key);
+            if (!existing || session.createdAt < existing.createdAt || (session.createdAt === existing.createdAt && session.id < existing.id)) {
+                runtimeIdToSession.set(key, session);
+            }
+        }
+    }
+    return sessions.map((historical) => {
+        const loaded = runtimeIdToSession.get(`${historical.machineId}:${historical.agent}:${historical.runtimeSessionId}`);
+        return loaded ? { ...historical, loadedSessionId: loaded.id } : historical;
+    });
+}
 async function findRuntimeBindingCandidates(client, session, metadata, flags) {
     const limit = parsePositiveIntFlag(flags, "runtime-limit") ?? 500;
     const result = await listWorkspaceHistoricalSessions(client, {
@@ -573,6 +593,15 @@ export async function handleSession({ domain, action, positional, flags }) {
             : undefined;
         if (repair)
             session = repair.session;
+        const metadataAvailableEvents = numberMetadata(metadata, "availableHistoricalEvents");
+        const metadataTotalEvents = numberMetadata(metadata, "historicalBackfillTotalEvents");
+        const runtimeCurrentEventCount = numberMetadata(metadata, "runtimeCurrentEventCount");
+        const tailMissingEvents = runtimeCurrentEventCount !== undefined
+            ? Math.max(0, runtimeCurrentEventCount - (metadataTotalEvents ?? metadataAvailableEvents ?? 0))
+            : undefined;
+        const latestSyncLikelyStale = tailMissingEvents !== undefined
+            ? tailMissingEvents > 0
+            : metadataTotalEvents !== undefined && metadataAvailableEvents !== undefined && metadataAvailableEvents > metadataTotalEvents;
         const data = {
             generatedAt: new Date().toISOString(),
             session: {
@@ -623,7 +652,11 @@ export async function handleSession({ domain, action, positional, flags }) {
                 latestPageEmpty: latestPage.events.length === 0,
                 latestPageHasVisibleTranscript: latestPage.events.some(isVisibleTranscriptPayloadEvent),
                 metadataReportsEmptyRuntimeSession: metadata.emptyRuntimeSession === true,
-                backfillAvailableEvents: numberMetadata(metadata, "availableHistoricalEvents"),
+                runtimeCurrentEventCount,
+                metadataAvailableEvents,
+                tailMissingEvents,
+                latestSyncLikelyStale,
+                backfillAvailableEvents: metadataAvailableEvents,
                 backfillEmittedEvents: numberMetadata(metadata, "backfilledEvents"),
                 backfillStatus: stringMetadata(metadata, "historicalBackfillStatus") ?? stringMetadata(metadata, "historicalBackfill"),
                 wrongRuntimeBindingSuspected: runtimeBindingSuspected(runtimeBinding.candidates),
@@ -701,7 +734,7 @@ export async function handleSession({ domain, action, positional, flags }) {
             sourceSessionId: session.id,
             sessionId: imported.sessionId,
             runtimeSessionId: candidate.runtimeSessionId,
-            mode: "created",
+            mode: imported.mode === "existing" ? "existing" : "created",
             sourceClosed,
             candidate: {
                 runtimeSessionId: candidate.runtimeSessionId,
@@ -725,7 +758,8 @@ export async function handleSession({ domain, action, positional, flags }) {
             includeArchived: flags["include-archived"] === true,
             limit,
         });
-        const sessions = result.sessions.map((session) => ({
+        const enrichedSessions = await enrichHistoricalLoadedSessionIds(client, result.sessions);
+        const sessions = enrichedSessions.map((session) => ({
             runtimeSessionId: session.runtimeSessionId,
             agent: session.agent,
             cwd: session.cwd,
@@ -738,11 +772,11 @@ export async function handleSession({ domain, action, positional, flags }) {
         if (wantsJson(flags) || wantsVerbose(flags)) {
             ok("session.history", {
                 source: "runtime-history",
-                sessions: wantsVerbose(flags) ? result.sessions.map((session) => ({ ...session, sessionId: session.loadedSessionId })) : sessions,
+                sessions: wantsVerbose(flags) ? enrichedSessions.map((session) => ({ ...session, sessionId: session.loadedSessionId })) : sessions,
                 page: {
                     limit,
-                    returned: result.sessions.length,
-                    hasMore: result.sessions.length >= limit,
+                    returned: enrichedSessions.length,
+                    hasMore: enrichedSessions.length >= limit,
                 },
                 ...(wantsVerbose(flags) ? { errors: result.errors, machines: result.machines } : {}),
             }, { machineId });
@@ -774,7 +808,8 @@ export async function handleSession({ domain, action, positional, flags }) {
             includeArchived: true,
             limit: 200,
         });
-        const historical = result.sessions.find((session) => session.runtimeSessionId === runtimeSessionId);
+        const enrichedSessions = await enrichHistoricalLoadedSessionIds(client, result.sessions);
+        const historical = enrichedSessions.find((session) => session.runtimeSessionId === runtimeSessionId);
         if (!historical)
             throw new CliError(`Runtime session not found: ${runtimeSessionId}`, "RUNTIME_SESSION_NOT_FOUND");
         if (historical.loadedSessionId) {
@@ -802,7 +837,7 @@ export async function handleSession({ domain, action, positional, flags }) {
         ok("session.continue", {
             sessionId: continued.sessionId,
             runtimeSessionId,
-            mode: "created",
+            mode: continued.mode === "existing" ? "existing" : "created",
             ...(historical.runtimeState === "archived" ? { runtimeState: "archived" } : {}),
         }, { requestId: continued.requestId, machineId, sessionId: continued.sessionId });
         return true;

package/apps/cli/package.json

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

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

@@ -1,7 +1,8 @@
 import { type MachineCommand } from "../../../../packages/shared/dist/index.js";
-import type { DaemonConfig, HistoricalBackfillStatus, SessionFallback, SessionState } from "../types.js";
+import type { DaemonConfig, HistoricalBackfillState, HistoricalBackfillStatus, SessionFallback, SessionState } from "../types.js";
 import { type HistoricalSessionHead } from "./events.js";
-type HistoricalBackfillDirection = "latest" | "older";
+export type HistoricalBackfillDirection = "latest" | "older";
+type HistoricalBackfillMode = HistoricalBackfillDirection | "auto";
 export type HistoricalBackfillResult = {
     availableEvents: number;
     cursor: number;
@@ -17,7 +18,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, syncDirection?: HistoricalBackfillDirection): Promise<SessionState | null>;
+export declare function resumeSession(ws: WebSocket, config: DaemonConfig, sessionId: string, requestId: string, fallback?: SessionFallback, announceSuccess?: boolean, syncDirection?: HistoricalBackfillMode): 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;
@@ -27,6 +28,22 @@ export declare function replaceAuthoritativeTranscript(ws: WebSocket, config: Da
     status?: "completed" | "cancelled" | "failed";
     strict?: boolean;
 }): Promise<HistoricalBackfillResult>;
+export declare function planAppendOnlyHistoricalBackfill<T extends {
+    turnId: string;
+}>(historicalEvents: T[], previousBackfill: HistoricalBackfillState | undefined, direction?: HistoricalBackfillMode, maxEvents?: number): {
+    cursor: number;
+    olderWindow: {
+        events: T[];
+        nextCursor: number;
+        startIndex: number;
+    };
+    status: HistoricalBackfillStatus;
+    tailWindow: {
+        events: T[];
+        startIndex: number;
+    };
+    truncated: boolean;
+};
 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,7 +256,7 @@ function historicalSessionPage(value) {
         return { sessions: value };
     return value;
 }
-export async function resumeSession(ws, config, sessionId, requestId, fallback, announceSuccess = true, syncDirection = "latest") {
+export async function resumeSession(ws, config, sessionId, requestId, fallback, announceSuccess = true, syncDirection = "auto") {
     const existing = sessions.get(sessionId);
     if (existing) {
         const refreshed = await refreshRuntimeSessionName(existing);
@@ -584,33 +584,37 @@ async function backfillHistoricalEvents(ws, config, session, runtimeSessionId =
             throw error;
         historicalEvents = [];
     }
-    const tailWindow = historicalTailWindowByTurn(historicalEvents, previousBackfill?.totalEvents);
+    const direction = options.direction ?? "auto";
+    const plan = planAppendOnlyHistoricalBackfill(historicalEvents, previousBackfill, direction);
+    const tailWindow = plan.tailWindow;
     if (tailWindow.events.length > 0) {
         await emitRuntimeTailEvents(ws, config, session.sessionId, tailWindow.events, tailWindow.startIndex);
     }
-    const cursor = normalizedBackfillCursor(previousBackfill, historicalEvents.length);
-    const olderWindow = historicalEventsWindowByTurn(historicalEvents, cursor, historicalBackfillEventLimit);
+    const olderWindow = plan.olderWindow;
     if (olderWindow.events.length > 0) {
         await emitHistoricalEvents(ws, config, session.sessionId, olderWindow.events, olderWindow.startIndex);
     }
-    const status = olderWindow.nextCursor > 0 ? "partial" : "completed";
-    const computedHead = latestCompletedHistoricalHead(session.sessionId, historicalEvents, {
-        ...(previousBackfill?.totalEvents !== undefined && previousBackfill.head === undefined
-            ? { preferTailBasisForExistingEvents: true }
-            : {}),
-        ...(previousBackfill?.totalEvents !== undefined ? { previousTotalEvents: previousBackfill.totalEvents } : {}),
-        ...(tailWindow.events.length > 0 ? { tailStartIndex: tailWindow.startIndex } : {}),
-    });
-    const head = preferPersistedHistoricalHeadBasis(computedHead, previousBackfill?.head);
+    const computedHead = direction === "older" && previousBackfill
+        ? previousBackfill.head
+        : latestCompletedHistoricalHead(session.sessionId, historicalEvents, {
+            ...(previousBackfill?.totalEvents !== undefined && previousBackfill.head === undefined
+                ? { preferTailBasisForExistingEvents: true }
+                : {}),
+            ...(previousBackfill?.totalEvents !== undefined ? { previousTotalEvents: previousBackfill.totalEvents } : {}),
+            ...(tailWindow.events.length > 0 ? { tailStartIndex: tailWindow.startIndex } : {}),
+        });
+    const head = direction === "older" && previousBackfill
+        ? previousBackfill.head
+        : preferPersistedHistoricalHeadBasis(computedHead, previousBackfill?.head);
     const result = {
         emittedEvents: tailWindow.events.length + olderWindow.events.length,
         availableEvents: historicalEvents.length,
-        cursor: olderWindow.nextCursor,
+        cursor: plan.cursor,
         olderBackfilledEvents: olderWindow.events.length,
-        status,
+        status: plan.status,
         tailRepairedEvents: tailWindow.events.length,
         totalEvents: historicalEvents.length,
-        truncated: status === "partial",
+        truncated: plan.truncated,
         ...(head ? { head } : {}),
     };
     if (head) {
@@ -652,6 +656,23 @@ function normalizedBackfillCursor(previousBackfill, totalEvents) {
         return 0;
     return Math.max(0, Math.min(previousBackfill.cursor, totalEvents));
 }
+export function planAppendOnlyHistoricalBackfill(historicalEvents, previousBackfill, direction = "auto", maxEvents = historicalBackfillEventLimit) {
+    const tailWindow = direction === "latest" || direction === "auto"
+        ? historicalTailWindowByTurn(historicalEvents, previousBackfill?.totalEvents)
+        : { events: [], startIndex: historicalEvents.length };
+    const cursor = normalizedBackfillCursor(previousBackfill, historicalEvents.length);
+    const olderWindow = direction === "older" || direction === "auto" || previousBackfill === undefined
+        ? historicalEventsWindowByTurn(historicalEvents, cursor, maxEvents)
+        : { events: [], nextCursor: cursor, startIndex: cursor };
+    const status = olderWindow.nextCursor > 0 ? "partial" : "completed";
+    return {
+        cursor: olderWindow.nextCursor,
+        olderWindow,
+        status,
+        tailWindow,
+        truncated: status === "partial",
+    };
+}
 function historicalTailWindowByTurn(events, previousTotalEvents) {
     if (previousTotalEvents === undefined || events.length <= previousTotalEvents) {
         return { events: [], startIndex: events.length };
@@ -726,6 +747,7 @@ function historicalBackfillMetadata(backfill) {
         historicalOlderBackfilledEvents: backfill.olderBackfilledEvents,
         historicalTailRepairedEvents: backfill.tailRepairedEvents,
         historicalHead: backfill.head,
+        runtimeCurrentEventCount: backfill.totalEvents,
         availableHistoricalEvents: backfill.availableEvents,
         truncatedHistoricalBackfill: backfill.truncated,
     };
@@ -735,7 +757,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), true, command.syncDirection ?? "latest");
+    await resumeSession(ws, config, command.sessionId, command.requestId, await sessionFallbackFromCommand(config, command), true, command.syncDirection ?? "auto");
 }
 export async function handleClose(ws, config, command) {
     if (command.type !== "machine:close")

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

@@ -4,6 +4,7 @@ import { getRuntime } from "../runtime.js";
 import { sessions, sessionTurns } from "../state.js";
 import { sendCommandResponse } from "../relay/send.js";
 import { settleScheduleTurnTerminal } from "../schedule/runner.js";
+import { emitEvent } from "./events.js";
 import { commandSessionMetadata } from "./metadata.js";
 export async function handleReconcileTurn(ws, config, command) {
     if (command.type !== "machine:reconcileTurn")
@@ -89,11 +90,31 @@ export async function handleReconcileTurn(ws, config, command) {
             result,
         },
     });
+    if (isUnconfirmedReconcileResult(result) && result.turnId) {
+        await emitEvent(ws, config, command.sessionId, result.turnId, {
+            type: "status",
+            tag: `reconcile:${result.status}`,
+            text: reconcileStatusText(result),
+        });
+    }
     await sendReconcileResult(ws, config, command, result);
     if (result.status === "terminal" && result.terminalStatus && result.turnId) {
         await settleTerminalSideEffects(config, result);
     }
 }
+function isUnconfirmedReconcileResult(result) {
+    return result.status === "unknown" || result.status === "not_found" || result.status === "uninspectable";
+}
+function reconcileStatusText(result) {
+    const reason = result.reason ? ` Reason: ${result.reason}` : "";
+    if (result.status === "not_found") {
+        return `Unable to confirm whether the previous execution finished; provider reported authoritative not found.${reason}`;
+    }
+    if (result.status === "uninspectable") {
+        return `Unable to confirm whether the previous execution finished; this runtime cannot inspect the turn.${reason}`;
+    }
+    return `Unable to confirm whether the previous execution finished.${reason}`;
+}
 async function sendReconcileResult(ws, config, command, result) {
     await sendCommandResponse(ws, {
         type: "machine:turnReconciled",

package/apps/daemon/package.json

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

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

@@ -6,6 +6,7 @@ export declare function createConnectionState(): {
     pendingCommandRequests: Map<string, {
         accountId: string;
         command?: string;
+        createdAt: number;
         machineId: string;
         requestId: string;
         sessionId?: string;

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

@@ -32,7 +32,7 @@ export function handleMachineMessage(context, connection, message) {
            updated_at = ?
        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")
             broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(row) });
         broadcastAck(connection.accountId, {
             type: "server:ack",
@@ -52,7 +52,7 @@ export function handleMachineMessage(context, connection, message) {
            updated_at = ?
        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")
             broadcastControllers(connection.accountId, { type: "server:session", session: sessionSnapshot(row) });
         broadcastAck(connection.accountId, { type: "server:ack", requestId: message.requestId, ok: true });
         acknowledgeMachineMessage();
@@ -246,9 +246,9 @@ export function handleMachineMessage(context, connection, message) {
                 (!message.result.turnId || message.result.turnId === claim?.turn_id);
             if (claimMatches && turnId) {
                 db.prepare(`UPDATE sessions
-           SET status = 'failed',
+           SET status = 'unknown',
                current_head = COALESCE(current_head, ?),
-               last_turn_id = ?,
+               last_turn_id = COALESCE(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) {
@@ -687,6 +687,10 @@ export function handleMachineMessage(context, connection, message) {
             .get(message.sessionId, connection.accountId, connection.machineId);
         if (!sessionRow)
             return;
+        if (sessionRow.status === "closed") {
+            acknowledgeMachineMessage();
+            return;
+        }
         maybeAliasHistoricalRuntimeEventToActiveClaim({
             db,
             accountId: connection.accountId,

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

@@ -6,6 +6,7 @@ import { createRelayRepositories } from "./repositories.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:";
+const PENDING_COMMAND_TTL_MS = 120_000;
 export function createRelayContext(options) {
     const { controllersByAccount, machinesByKey, pendingCommandRequests } = createConnectionState();
     const now = options.now ?? Date.now;
@@ -201,7 +202,19 @@ export function createRelayContext(options) {
             .get(accountId, sessionId);
         if (!claim)
             return undefined;
-        if (isStaleSessionClaim(claim)) {
+        const staleResolution = staleSessionClaimResolution(claim);
+        if (staleResolution) {
+            if (staleResolution.terminalStatus) {
+                const ts = staleResolution.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, staleResolution.terminalStatus, staleResolution.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);
@@ -209,14 +222,14 @@ export function createRelayContext(options) {
         }
         return claim;
     }
-    function isStaleSessionClaim(claim) {
+    function staleSessionClaimResolution(claim) {
         const admission = options.db
             .prepare(`SELECT dispatch, finished_at, terminal_status
          FROM relay_admissions
          WHERE account_id = ? AND request_id = ?`)
             .get(claim.account_id, claim.request_id);
         if (admission && (admission.finished_at !== null || admission.terminal_status !== null))
-            return true;
+            return {};
         const session = options.db
             .prepare(`SELECT status, current_head, last_turn_id, updated_at
          FROM sessions
@@ -224,11 +237,13 @@ export function createRelayContext(options) {
             .get(claim.account_id, claim.session_id);
         if (admission?.dispatch === "delivered" &&
             session &&
-            !["new", "running", "offline"].includes(session.status) &&
+            isSettledSessionProjectionStatus(session.status) &&
             session.updated_at > claim.created_at &&
-            session.current_head !== claim.turn_id &&
-            session.last_turn_id !== claim.turn_id) {
-            return true;
+            (session.last_turn_id === claim.turn_id || (session.current_head !== claim.turn_id && session.last_turn_id !== claim.turn_id))) {
+            return {
+                terminalStatus: terminalStatusForSettledSessionStatus(session.status),
+                finishedAt: session.updated_at,
+            };
         }
         const newerTerminal = options.db
             .prepare(`SELECT 1
@@ -242,7 +257,17 @@ export function createRelayContext(options) {
            AND created_at > ?
          LIMIT 1`)
             .get(claim.account_id, claim.session_id, claim.request_id, claim.created_at);
-        return Boolean(newerTerminal);
+        return newerTerminal ? {} : undefined;
+    }
+    function terminalStatusForSettledSessionStatus(status) {
+        if (status === "failed")
+            return "failed";
+        if (status === "cancelled" || status === "closed")
+            return "cancelled";
+        return "completed";
+    }
+    function isSettledSessionProjectionStatus(status) {
+        return status === "ready" || status === "completed" || status === "cancelled" || status === "closed";
     }
     function claimSessionTurn(params) {
         const existing = activeSessionClaim(params.accountId, params.sessionId);
@@ -290,13 +315,22 @@ export function createRelayContext(options) {
     function commandKey(accountId, requestId) {
         return `${accountId}:${requestId}`;
     }
+    function prunePendingCommands(ts = now()) {
+        for (const [key, pending] of pendingCommandRequests) {
+            if (ts - pending.createdAt > PENDING_COMMAND_TTL_MS)
+                pendingCommandRequests.delete(key);
+        }
+    }
     function markCommandPending(accountId, machineId, requestId, options = {}) {
-        pendingCommandRequests.set(commandKey(accountId, requestId), { accountId, machineId, requestId, ...options });
+        prunePendingCommands();
+        pendingCommandRequests.set(commandKey(accountId, requestId), { accountId, machineId, requestId, createdAt: now(), ...options });
     }
     function isCommandPending(accountId, requestId) {
+        prunePendingCommands();
         return pendingCommandRequests.has(commandKey(accountId, requestId));
     }
     function isSessionCommandPending(accountId, sessionId) {
+        prunePendingCommands();
         for (const pending of pendingCommandRequests.values()) {
             if (pending.accountId === accountId && pending.sessionId === sessionId)
                 return true;
@@ -522,10 +556,10 @@ export function createRelayContext(options) {
              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);
+         WHERE id = ? AND status != 'closed'`).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);
+            options.db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ? AND status != 'closed'").run(createdAt, params.sessionId);
         }
         return {
             id: eventId,
@@ -548,6 +582,8 @@ export function createRelayContext(options) {
          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;
         if (typeof session?.head_basis_message_id === "string" &&

package/package.json

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

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

@@ -59,6 +59,11 @@ export declare class ControllerClient {
         revokedAt: number;
     }>;
     listSessions(filter?: SessionFilter): Promise<SessionSnapshot[]>;
+    findLoadedRuntimeSession(input: {
+        machineId: string;
+        agent: string;
+        runtimeSessionId: string;
+    }): Promise<SessionSnapshot | undefined>;
     getSession(sessionId: string): Promise<SessionSnapshot | undefined>;
     history(sessionId: string, limit?: number): Promise<DecodedSessionEvent[]>;
     createSession(input: CreateSessionInput): Promise<CommandResult>;

package/packages/client/dist/client.js

@@ -7,6 +7,29 @@ import { sendAndWaitForDirectoryListing, sendAndWaitForDaemonLifecycleResult, se
 import { DEFAULT_SESSION_CREATE_WAIT_MS, } from "./types.js";
 import { isWaitCondition, matchesWaitCondition, parseEventCursor, parseEventLimit, parsePositiveDuration, requireNonEmpty, sleep, } from "./validation.js";
 const DEFAULT_BLOCKING_RUN_WAIT_MS = 30 * 60 * 1000;
+function addRuntimeSessionId(ids, value) {
+    if (typeof value === "string" && value.trim())
+        ids.add(value.trim());
+}
+function runtimeSessionIdsForMetadata(metadata) {
+    const ids = new Set();
+    addRuntimeSessionId(ids, metadata.importedFromRuntimeSessionId);
+    const runtime = metadata.runtime;
+    if (runtime && typeof runtime === "object" && !Array.isArray(runtime)) {
+        const record = runtime;
+        addRuntimeSessionId(ids, record.backendSessionId);
+        addRuntimeSessionId(ids, record.agentSessionId);
+        addRuntimeSessionId(ids, record.acpxRecordId);
+        const externalHandle = record.externalHandle;
+        if (externalHandle && typeof externalHandle === "object" && !Array.isArray(externalHandle)) {
+            addRuntimeSessionId(ids, externalHandle.sessionId);
+        }
+    }
+    return ids;
+}
+function isCanonicalRuntimeSessionCandidate(left, right) {
+    return left.createdAt < right.createdAt || (left.createdAt === right.createdAt && left.id < right.id);
+}
 function runSettlementTimeoutMs(options) {
     if (options.waitTimeoutMs !== undefined)
         return options.waitTimeoutMs;
@@ -169,6 +192,24 @@ export class ControllerClient {
         }
         return result;
     }
+    async findLoadedRuntimeSession(input) {
+        const machineId = requireNonEmpty(input.machineId, "machineId");
+        const agent = requireNonEmpty(input.agent, "agent");
+        const runtimeSessionId = requireNonEmpty(input.runtimeSessionId, "runtimeSessionId");
+        let selected;
+        for (const session of (await this.snapshot()).sessions) {
+            if (session.status === "closed")
+                continue;
+            if (session.machineId !== machineId || session.agent !== agent)
+                continue;
+            const metadata = await this.decodeSessionMetadata(session);
+            if (!runtimeSessionIdsForMetadata(metadata).has(runtimeSessionId))
+                continue;
+            if (!selected || isCanonicalRuntimeSessionCandidate(session, selected))
+                selected = session;
+        }
+        return selected;
+    }
     async getSession(sessionId) {
         const checkedSessionId = requireNonEmpty(sessionId, "sessionId");
         return (await this.snapshot()).sessions.find((session) => session.id === checkedSessionId);
@@ -493,6 +534,9 @@ export class ControllerClient {
         const agent = requireNonEmpty(input.agent, "agent");
         const runtimeSessionId = requireNonEmpty(input.runtimeSessionId, "runtimeSessionId");
         const name = requireNonEmpty(input.name, "name");
+        const existing = await this.findLoadedRuntimeSession({ machineId, agent, runtimeSessionId });
+        if (existing)
+            return { sessionId: existing.id, mode: "existing", events: [] };
         const requestId = randomId("req");
         const result = await this.sendCommand({
             type: "controller:importHistoricalSession",

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

@@ -13,6 +13,7 @@ export type CommandResult = {
     turnId?: string;
     admission?: "accepted" | "replayed";
     dispatch?: "queued" | "delivered";
+    mode?: "existing";
     events: EncryptedSessionEvent[];
 };
 export type DecodedSessionEvent = EncryptedSessionEvent & {

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

@@ -211,6 +211,7 @@ export declare const sessionSnapshotSchema: z.ZodObject<{
         new: "new";
         ready: "ready";
         running: "running";
+        unknown: "unknown";
         completed: "completed";
         failed: "failed";
         cancelled: "cancelled";
@@ -457,9 +458,9 @@ export declare const daemonLifecycleResultSchema: z.ZodObject<{
     platform: z.ZodOptional<z.ZodString>;
     arch: z.ZodOptional<z.ZodString>;
     installMode: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
         "npm-global": "npm-global";
         "repo-dev": "repo-dev";
-        unknown: "unknown";
     }>>;
     updateSupported: z.ZodOptional<z.ZodBoolean>;
     updateUnsupportedReason: z.ZodOptional<z.ZodString>;

package/packages/shared/dist/protocol-schemas.js

@@ -79,7 +79,7 @@ export const sessionSnapshotSchema = z.object({
     agent: z.string().min(1),
     cwd: z.string(),
     name: z.string().min(1),
-    status: z.enum(["new", "ready", "running", "completed", "failed", "cancelled", "offline", "closed"]),
+    status: z.enum(["new", "ready", "running", "unknown", "completed", "failed", "cancelled", "offline", "closed"]),
     createdAt: z.number(),
     updatedAt: z.number(),
     encryptedMetadata: encryptedEnvelopeSchema.optional(),

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

@@ -57,7 +57,7 @@ export type SessionSnapshot = {
     agent: string;
     cwd: string;
     name: string;
-    status: "new" | "ready" | "running" | "completed" | "failed" | "cancelled" | "offline" | "closed";
+    status: "new" | "ready" | "running" | "unknown" | "completed" | "failed" | "cancelled" | "offline" | "closed";
     createdAt: number;
     updatedAt: number;
     encryptedMetadata?: EncryptedEnvelope;

package/packages/shared/dist/session-state.d.ts

@@ -1,4 +1,4 @@
-export declare const sessionStatuses: readonly ["new", "ready", "running", "completed", "failed", "cancelled", "offline", "closed"];
+export declare const sessionStatuses: readonly ["new", "ready", "running", "unknown", "completed", "failed", "cancelled", "offline", "closed"];
 export type SessionStatus = (typeof sessionStatuses)[number];
 export type ControllerSessionCommand = "prompt" | "cancel" | "resume" | "rewind" | "fork" | "rename" | "close";
 export type SessionCommandDecision = {

package/packages/shared/dist/session-state.js

@@ -2,6 +2,7 @@ export const sessionStatuses = [
     "new",
     "ready",
     "running",
+    "unknown",
     "completed",
     "failed",
     "cancelled",
@@ -15,7 +16,7 @@ export function isSessionClosed(status) {
     return status === "closed";
 }
 export function isSessionBusy(status) {
-    return status === "running";
+    return status === "running" || status === "unknown";
 }
 export function controllerSessionCommandDecision(status, command) {
     if (command === "close" && status === "closed")
@@ -27,11 +28,11 @@ export function controllerSessionCommandDecision(status, command) {
             message: "Session is closed",
         };
     }
-    if (command === "prompt" && status === "running") {
+    if (command === "prompt" && isSessionBusy(status)) {
         return {
             allowed: false,
             code: "SESSION_BUSY",
-            message: "Session already has a running turn",
+            message: status === "unknown" ? "Session has a turn whose execution status is unknown" : "Session already has a running turn",
         };
     }
     return { allowed: true };
@@ -43,6 +44,8 @@ export function statusAfterMachineDisconnect(status) {
         return "failed";
     if (status === "running")
         return "offline";
+    if (status === "unknown")
+        return "unknown";
     return status;
 }
 //# sourceMappingURL=session-state.js.map