@cydm/happy-elves 0.1.0-beta.60 → 0.1.0-beta.62

package/apps/cli/dist/commands/lib/exit.js

@@ -127,6 +127,8 @@ export function handleCliError(error) {
         latestCompletedTurnId: enriched.latestCompletedTurnId,
         commandAcked: enriched.commandAcked,
         rawStatus: enriched.rawStatus,
+        sessionStatus: enriched.sessionStatus,
+        staleRunningTurnId: enriched.staleRunningTurnId,
         lastTransientError: enriched.lastTransientError,
         retryCount: enriched.retryCount,
     }, enriched.capability, enriched.retryable);

package/apps/cli/dist/commands/lib/types.d.ts

@@ -47,6 +47,7 @@ export type OrchestrationSummary = {
         evidence: "running-turn";
         turnId: string;
     };
+    staleRunningTurnId?: string;
 };
 export type LoopRecord = {
     id: string;

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

@@ -62,6 +62,7 @@ async function threadSummary(client, session, machines, options = {}) {
     const events = options.events ?? [];
     const turns = events.length > 0 ? summarizeOrchestratorTurns(events, metadata) : [];
     const latestTurn = turns[0];
+    const runningClassification = classifyRunningTurn(session, turns, options.focusTurn);
     const orchestration = options.historyFailure
         ? {
             state: "blocked",
@@ -71,8 +72,10 @@ async function threadSummary(client, session, machines, options = {}) {
             completed: false,
             reason: `history unavailable: ${options.historyFailure.code}`,
         }
-        : deriveOrchestration(session, events, options.focusTurn);
-    const status = normalizeOrchestratorStatus(session, orchestration, latestTurn);
+        : runningClassification.state === "stale"
+            ? staleRunningOrchestration(session, runningClassification.turn.turnId)
+            : deriveOrchestration(session, events, options.focusTurn);
+    const status = normalizeOrchestratorStatus(session, orchestration, runningClassification.state === "stale" ? undefined : latestTurn);
     const machine = machineForSession(machines, session);
     return {
         threadId: session.id,
@@ -90,6 +93,7 @@ async function threadSummary(client, session, machines, options = {}) {
             online: machine?.online === true,
         },
         orchestration,
+        ...(runningClassification.state === "stale" ? { staleRunningTurnId: runningClassification.turn.turnId } : {}),
         ...(options.historyFailure ? {
             historyStatus: "unavailable",
             historyError: options.historyFailure,
@@ -200,6 +204,43 @@ function threadHistoryFailure(error) {
         retryable: retryableError(error),
     };
 }
+function isActiveRunningSessionStatus(status) {
+    return status === "running" || status === "new" || status === "failed";
+}
+function stateFromNonRunningSessionStatus(status) {
+    if (status === "closed")
+        return "closed";
+    if (status === "offline" || status === "failed")
+        return "blocked";
+    if (status === "completed")
+        return "completed";
+    return "idle";
+}
+function classifyRunningTurn(session, turns, focusTurn) {
+    const latestTurn = turns[0];
+    const runningTurn = latestTurn?.status === "running"
+        ? latestTurn
+        : focusTurn?.status === "running"
+            ? focusTurn
+            : undefined;
+    if (!runningTurn)
+        return { state: "none" };
+    return isActiveRunningSessionStatus(session.status)
+        ? { state: "active", turn: runningTurn }
+        : { state: "stale", turn: runningTurn };
+}
+function staleRunningOrchestration(session, turnId) {
+    const state = stateFromNonRunningSessionStatus(session.status);
+    return {
+        state,
+        rawStatus: session.status,
+        needsUser: false,
+        blocked: state === "blocked",
+        completed: state === "completed",
+        reason: `stale running turn from a previous daemon execution: ${turnId}`,
+        staleRunningTurnId: turnId,
+    };
+}
 function summarizeOrchestratorTurns(events, metadata) {
     const turns = summarizeTurns(events);
     if (!metadata)
@@ -456,6 +497,16 @@ function threadBusy(threadId, active, latestCompleted) {
         rawStatus: "running",
     });
 }
+function turnOrphaned(threadId, turnId, turnStatus, sessionStatus) {
+    return new OrchestratorError(`Turn ${turnId} is orphaned: session is ${sessionStatus}, but the turn has no terminal event.`, "TURN_ORPHANED", {
+        retryable: false,
+        sessionId: threadId,
+        turnId,
+        rawStatus: turnStatus,
+        sessionStatus,
+        staleRunningTurnId: turnId,
+    });
+}
 async function waitForTurn(client, threadId, turnId, timeoutMs, metadata) {
     const startedAt = Date.now();
     let retryCount = 0;
@@ -474,6 +525,12 @@ async function waitForTurn(client, threadId, turnId, timeoutMs, metadata) {
         }
         if (turn && turn.status !== "running")
             return turn;
+        if (turn?.status === "running") {
+            const session = await client.getSession(threadId).catch(() => undefined);
+            if (session && classifyRunningTurn(session, [], turn).state === "stale" && session.status !== "offline") {
+                throw turnOrphaned(threadId, turnId, turn.status, session.status);
+            }
+        }
         if (Date.now() - startedAt >= timeoutMs) {
             throw new OrchestratorError(lastTransientError
                 ? `Turn ${turnId} did not become readable before timeout; last transient error: ${lastTransientError.message}`
@@ -541,6 +598,9 @@ async function sendOrchestratorMessage(client, flags, input) {
         if (!sameBaseRequestShape(existingRequest, { turnId, inputSha256, ...selection, permissionMode: activePermissionMode }))
             throw requestConflict(input.threadId, requestId, turnId);
         const existingTurn = await readExactTurn(client, input.threadId, turnId, metadata);
+        if (existingTurn?.status === "running" && classifyRunningTurn(session, [], existingTurn).state === "stale" && session.status !== "offline") {
+            throw turnOrphaned(input.threadId, turnId, existingTurn.status, session.status);
+        }
         let context;
         let resolvedEffectivePrompt = !input.contextTurn;
         if (input.contextTurn) {
@@ -552,6 +612,26 @@ async function sendOrchestratorMessage(client, flags, input) {
                 resolvedEffectivePrompt = false;
             }
         }
+        if (!resolvedEffectivePrompt && existingTurn && existingTurn.status !== "running") {
+            const output = await rebuildOutputForTurn(client, input.threadId, existingTurn);
+            ok(input.responseType, {
+                threadId: input.threadId,
+                sessionId: input.threadId,
+                turnId,
+                requestId,
+                status: terminalStatusForTurn(existingTurn),
+                rawStatus: existingTurn.status,
+                finalOutput: output.output || undefined,
+                artifactPaths: {
+                    output: output.outputPath,
+                    latest: output.latestPath,
+                    metadata: output.metadataPath,
+                },
+                ...permissionEvidence(requestedPermissionMode, existingRequest),
+                ...earlyContextData,
+            }, { requestId, sessionId: input.threadId, turnId });
+            return;
+        }
         if (!resolvedEffectivePrompt) {
             ok(input.responseType, {
                 threadId: input.threadId,
@@ -648,7 +728,8 @@ async function sendOrchestratorMessage(client, flags, input) {
     const existingTurn = await readExactTurn(client, input.threadId, turnId, metadata);
     if (existingTurn?.prompt && promptSha256(existingTurn.prompt) !== hash)
         throw requestConflict(input.threadId, requestId, turnId);
-    const active = turns[0]?.status === "running" ? turns[0] : undefined;
+    const runningClassification = classifyRunningTurn(session, turns);
+    const active = runningClassification.state === "active" && turns[0]?.status === "running" ? turns[0] : undefined;
     const latestCompleted = turns.find((turn) => turn.status === "completed");
     if (active && active.turnId !== turnId)
         throw threadBusy(input.threadId, active, latestCompleted);
@@ -682,6 +763,9 @@ async function sendOrchestratorMessage(client, flags, input) {
         return;
     }
     if (existingTurn?.status === "running") {
+        if (classifyRunningTurn(session, [], existingTurn).state === "stale" && session.status !== "offline") {
+            throw turnOrphaned(input.threadId, turnId, existingTurn.status, session.status);
+        }
         const runningTurnRecord = requestRecordForExistingTurn(existingTurn, hash, selection, undefined, inputSha256, context?.sourceOutputSha256, Date.now());
         ok(input.responseType, {
             threadId: input.threadId,

package/apps/daemon/dist/gateway/fake.js

@@ -4,6 +4,8 @@ export function createFakeGatewayAdapter(_context) {
     return {
         async start() {
             // Fake adapter is intentionally passive; tests can call the daemon gateway sender directly.
+            if (process.env.HAPPY_ELVES_GATEWAY_FAKE_START_FAIL === "1")
+                throw new Error("fake gateway start failed");
             if (process.env.HAPPY_ELVES_GATEWAY_FAKE_LIFECYCLE_LOG === "1")
                 console.log("[gateway:fake:lifecycle] start");
         },

package/apps/daemon/dist/gateway/runtime.js

@@ -376,8 +376,8 @@ async function runGatewayPrompt(ws, config, gateway, binding, input, session, ac
             turnId,
         }, ws);
         if (gatewayProjectionSupported()) {
-            await emitEventBestEffort(ws, config, binding.sessionId, turnId, { type: "user_prompt", text: input.text });
-            await emitEventBestEffort(ws, config, binding.sessionId, turnId, {
+            await emitGatewayEventBestEffort(ws, config, binding.sessionId, turnId, requestId, "prompt", { type: "user_prompt", text: input.text });
+            await emitGatewayEventBestEffort(ws, config, binding.sessionId, turnId, requestId, "submitted", {
                 type: "status",
                 text: "Gateway prompt submitted to runtime",
                 tag: "gateway",
@@ -409,7 +409,7 @@ async function runGatewayPrompt(ws, config, gateway, binding, input, session, ac
                 promptChars: input.text.length,
             },
         });
-        pumpRuntimeEvents(turn, ws, config, binding.sessionId, turnId, outputPreview);
+        pumpRuntimeEvents(turn, ws, config, binding.sessionId, turnId, requestId, outputPreview);
         result = await turn.result.catch((error) => runtimeTurnFailureResult(error));
     }
     catch (error) {
@@ -437,7 +437,7 @@ async function runGatewayPrompt(ws, config, gateway, binding, input, session, ac
             evidence: { gatewayId: gateway.id, platformEventId: input.platformEventId, error: errorMessage(error) },
         });
     }
-    await emitDoneEvent(ws, config, binding.sessionId, turnId, result);
+    await emitDoneEvent(ws, config, binding.sessionId, turnId, requestId, result);
     release();
     if (gatewayProjectionSupported()) {
         sendGatewayProjection({
@@ -485,16 +485,18 @@ async function runGatewayPrompt(ws, config, gateway, binding, input, session, ac
     });
     return true;
 }
-function pumpRuntimeEvents(turn, ws, config, sessionId, turnId, outputPreview) {
+function pumpRuntimeEvents(turn, ws, config, sessionId, turnId, requestId, outputPreview) {
     void (async () => {
+        let runtimeEventIndex = 0;
         try {
             for await (const event of turn.events) {
+                runtimeEventIndex += 1;
                 const payload = runtimeEventToPayload(event);
                 if (payload.type === "text_delta" && payload.stream !== "thought") {
                     outputPreview.text = `${outputPreview.text}${payload.text}`.slice(-4000);
                 }
                 if (gatewayProjectionSupported()) {
-                    await emitEventBestEffort(ws, config, sessionId, turnId, payload);
+                    await emitGatewayEventBestEffort(ws, config, sessionId, turnId, requestId, `runtime:${runtimeEventIndex}`, payload);
                 }
             }
         }
@@ -510,11 +512,11 @@ function pumpRuntimeEvents(turn, ws, config, sessionId, turnId, outputPreview) {
         }
     })();
 }
-async function emitDoneEvent(ws, config, sessionId, turnId, result) {
+async function emitDoneEvent(ws, config, sessionId, turnId, requestId, result) {
     if (!gatewayProjectionSupported())
         return;
     try {
-        await emitEventBestEffort(ws, config, sessionId, turnId, result.status === "failed"
+        await emitGatewayEventBestEffort(ws, config, sessionId, turnId, requestId, "done", result.status === "failed"
             ? {
                 type: "done",
                 status: "failed",
@@ -541,7 +543,13 @@ async function emitDoneEvent(ws, config, sessionId, turnId, result) {
         });
     }
 }
+async function emitGatewayEventBestEffort(ws, config, sessionId, turnId, requestId, eventKey, payload) {
+    await emitEventBestEffort(ws, config, sessionId, turnId, payload, {
+        messageIdParts: ["gateway", requestId, sessionId, turnId, eventKey],
+    });
+}
 async function deliverGatewayStopNotifications(config, sessionId, turnId, payload) {
+    await refreshGatewayStoreSnapshot();
     const state = await readGatewayState();
     const tracked = gatewayTurnDestinations.get(gatewayTurnKey(sessionId, turnId));
     for (const gateway of enabledGateways.values()) {
@@ -667,6 +675,8 @@ async function selectNextQueuedInbound() {
                 return removeQueuedInboundFromState(state, next, { kind: "dropped", input: next, reason: "missing_gateway" });
             if (!gateway)
                 continue;
+            if (!gatewayAdapters.has(next.gatewayId))
+                continue;
             const binding = state.bindings.find((item) => item.gatewayId === next.gatewayId && conversationKey(item) === conversationKey(next.destination));
             if (!binding)
                 return removeQueuedInboundFromState(state, next, { kind: "dropped", input: next, reason: "missing_binding" });

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

@@ -2,7 +2,9 @@ import { type EncryptedEnvelope, type SessionEventPayload, type SessionHeadAdvan
 import type { RuntimeEvent, RuntimeHistoricalEvent } from "../../../../packages/runtime/dist/index.js";
 import type { DaemonConfig } from "../types.js";
 export declare function emitEvent(ws: WebSocket, config: DaemonConfig, sessionId: string, turnId: string, payload: SessionEventPayload): Promise<void>;
-export declare function emitEventBestEffort(ws: WebSocket, config: DaemonConfig, sessionId: string, turnId: string, payload: SessionEventPayload): Promise<void>;
+export declare function emitEventBestEffort(ws: WebSocket, config: DaemonConfig, sessionId: string, turnId: string, payload: SessionEventPayload, options?: {
+    messageIdParts?: readonly unknown[];
+}): Promise<void>;
 export declare function emitHistoricalEvents(ws: WebSocket, config: DaemonConfig, sessionId: string, events: RuntimeHistoricalEvent[], startIndex?: number): Promise<void>;
 export declare function emitRuntimeTailEvents(ws: WebSocket, config: DaemonConfig, sessionId: string, events: RuntimeHistoricalEvent[], startIndex?: number): Promise<void>;
 export declare function emitSessionHeadAdvanced(ws: WebSocket, sessionId: string, head: HistoricalSessionHead, encryptedMetadata?: EncryptedEnvelope, status?: "completed" | "cancelled" | "failed"): Promise<void>;

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

@@ -12,13 +12,14 @@ export async function emitEvent(ws, config, sessionId, turnId, payload) {
         payload: await encryptJson(config.accountSecret, `event:${sessionId}:${turnId}:${eventSeq}`, payload),
     }, ws);
 }
-export async function emitEventBestEffort(ws, config, sessionId, turnId, payload) {
+export async function emitEventBestEffort(ws, config, sessionId, turnId, payload, options = {}) {
     eventSeq++;
     const message = {
         type: "machine:event",
         sessionId,
         turnId,
         seq: eventSeq,
+        ...(options.messageIdParts ? { messageId: bestEffortEventMessageId(options.messageIdParts) } : {}),
         payload: await encryptJson(config.accountSecret, `event:${sessionId}:${turnId}:${eventSeq}`, payload),
     };
     try {
@@ -28,6 +29,10 @@ export async function emitEventBestEffort(ws, config, sessionId, turnId, payload
         // Gateway relay projection is best-effort; local runtime progress must not depend on it.
     }
 }
+function bestEffortEventMessageId(parts) {
+    const digest = createHash("sha256").update(JSON.stringify(parts)).digest("base64url").slice(0, 32);
+    return `msg_gateway_event_${digest}`;
+}
 export async function emitHistoricalEvents(ws, config, sessionId, events, startIndex = 0) {
     const encryptedEvents = await encryptedHistoricalEvents(config, sessionId, events, startIndex);
     for (const event of encryptedEvents) {

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

@@ -293,13 +293,25 @@ export async function handleCancel(ws, config, command) {
     const activeTurnId = sessionTurns.activeTurnId(command.sessionId);
     const turn = sessionTurns.activeTurn(command.sessionId);
     if (!turn) {
+        if (command.turnId) {
+            const stopReason = command.reason
+                ? `${command.reason} (no active runtime turn after daemon restart)`
+                : "cancel requested after daemon restart; runtime turn is no longer active";
+            await emitEvent(ws, config, command.sessionId, command.turnId, {
+                type: "done",
+                status: "cancelled",
+                stopReason,
+                currentHead: command.turnId,
+                lastTurnId: command.turnId,
+            });
+        }
         await appendAudit({
             sessionId: command.sessionId,
             machineId: config.machineId,
             actor: "user",
             action: "turn.cancel.noop",
             summary: `No active turn to cancel for session ${command.sessionId}`,
-            evidence: { requestId: command.requestId, turnId: command.turnId, reason: command.reason },
+            evidence: { requestId: command.requestId, turnId: command.turnId, reason: command.reason, emittedTerminal: Boolean(command.turnId) },
         });
         return;
     }

package/apps/daemon/package.json

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

package/apps/relay/dist/http-routes.js

@@ -371,20 +371,31 @@ export function registerHttpRoutes(app, context, controllerInviteTtlMs) {
         if (!session)
             throw new HttpError(404, "SESSION_NOT_FOUND", "Session not found");
         const ts = context.now();
-        const expectedEncryptedMetadata = body.expectedEncryptedMetadata === undefined
-            ? session.encrypted_metadata
-            : body.expectedEncryptedMetadata === null
+        const hasExpectedEncryptedMetadata = body.expectedEncryptedMetadata !== undefined;
+        const expectedEncryptedMetadata = hasExpectedEncryptedMetadata
+            ? body.expectedEncryptedMetadata === null
                 ? null
-                : JSON.stringify(body.expectedEncryptedMetadata);
-        const result = body.expectedUpdatedAt === undefined
-            ? context.db.prepare(`UPDATE sessions
-         SET encrypted_metadata = ?,
-             updated_at = ?
-         WHERE account_id = ? AND id = ?`).run(JSON.stringify(body.encryptedMetadata), ts, token.account_id, params.sessionId)
-            : context.db.prepare(`UPDATE sessions
+                : JSON.stringify(body.expectedEncryptedMetadata)
+            : session.encrypted_metadata;
+        const encryptedMetadata = JSON.stringify(body.encryptedMetadata);
+        const result = (() => {
+            if (body.expectedUpdatedAt !== undefined) {
+                return context.db.prepare(`UPDATE sessions
+           SET encrypted_metadata = ?,
+               updated_at = ?
+           WHERE account_id = ? AND id = ? AND updated_at = ? AND encrypted_metadata IS ?`).run(encryptedMetadata, ts, token.account_id, params.sessionId, body.expectedUpdatedAt, expectedEncryptedMetadata);
+            }
+            if (hasExpectedEncryptedMetadata) {
+                return context.db.prepare(`UPDATE sessions
+           SET encrypted_metadata = ?,
+               updated_at = ?
+           WHERE account_id = ? AND id = ? AND encrypted_metadata IS ?`).run(encryptedMetadata, ts, token.account_id, params.sessionId, expectedEncryptedMetadata);
+            }
+            return context.db.prepare(`UPDATE sessions
          SET encrypted_metadata = ?,
              updated_at = ?
-         WHERE account_id = ? AND id = ? AND updated_at = ? AND encrypted_metadata IS ?`).run(JSON.stringify(body.encryptedMetadata), ts, token.account_id, params.sessionId, body.expectedUpdatedAt, expectedEncryptedMetadata);
+         WHERE account_id = ? AND id = ?`).run(encryptedMetadata, ts, token.account_id, params.sessionId);
+        })();
         if (result.changes === 0) {
             throw new HttpError(409, "SESSION_METADATA_CONFLICT", "Session metadata changed; retry with the latest session");
         }

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

@@ -46,6 +46,7 @@ export type MachineHandlerContext = {
         turnSeq?: number;
         occurredAt?: number;
         payload: EncryptedEnvelope;
+        advanceSessionHead?: boolean;
     }): Extract<ServerMessage, {
         type: "server:event";
     }>["event"];

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

@@ -68,6 +68,7 @@ export declare function createRelayContext(options: CreateRelayContextOptions):
         turnSeq?: number;
         occurredAt?: number;
         payload: EncryptedEnvelope;
+        advanceSessionHead?: boolean;
     }) => EncryptedSessionEvent;
     aliasedRuntimeEventHasRequestEvents: (params: {
         accountId: string;

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

@@ -587,7 +587,7 @@ export function createRelayContext(options) {
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
             .run(params.accountId, params.sessionId, params.machineId, params.messageId ?? null, params.turnId, seqRow.nextSeq, params.turnSeq ?? null, JSON.stringify(params.payload), createdAt, params.occurredAt ?? null);
         const eventId = Number(result.lastInsertRowid);
-        if (shouldAdvanceSessionHead(params, eventId, createdAt)) {
+        if (params.advanceSessionHead !== false && shouldAdvanceSessionHead(params, eventId, createdAt)) {
             const order = logicalEventOrder({
                 id: eventId,
                 createdAt,

package/apps/relay/dist/session-projection-reducer.js

@@ -340,15 +340,12 @@ function handleMachineEvent(context, connection, message, acknowledgeMachineMess
         acknowledgeMachineMessage();
         return;
     }
-    if (context.aliasedRuntimeEventHasRequestEvents({
+    const suppressAliasedRuntimeProjection = context.aliasedRuntimeEventHasRequestEvents({
         accountId: connection.accountId,
         sessionId: message.sessionId,
         machineId: connection.machineId,
         runtimeTurnId: message.turnId,
-    })) {
-        acknowledgeMachineMessage();
-        return;
-    }
+    });
     const event = context.insertEvent({
         accountId: connection.accountId,
         sessionId: message.sessionId,
@@ -359,9 +356,11 @@ function handleMachineEvent(context, connection, message, acknowledgeMachineMess
         turnSeq: message.seq,
         occurredAt: message.occurredAt,
         payload: message.payload,
+        advanceSessionHead: !suppressAliasedRuntimeProjection,
     });
     const pendingSessionRow = applyPendingSessionHeadAdvances(context.db, connection.accountId, message.sessionId, connection.machineId, context.now());
-    context.broadcastControllers(connection.accountId, { type: "server:event", event });
+    if (!suppressAliasedRuntimeProjection)
+        context.broadcastControllers(connection.accountId, { type: "server:event", event });
     if (pendingSessionRow)
         context.broadcastControllers(connection.accountId, { type: "server:session", session: context.sessionSnapshot(pendingSessionRow) });
     acknowledgeMachineMessage();
@@ -411,14 +410,21 @@ function handleTurnDone(context, connection, message, acknowledgeMachineMessage)
     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 requestTurnCompletesActiveRun = sessionRow.status === "running" &&
+        requestBasisEvent !== undefined &&
+        requestOrder !== undefined &&
+        compareHeadBasisOrder(requestOrder, currentOrder) >= 0;
     const isTerminalForCurrentTurn = isRuntimeAliasForCurrentRequest ||
         sessionRow.last_turn_id === message.turnId ||
         isInitialTerminal ||
-        (sessionRow.status === "running" && !sessionRow.last_turn_id);
+        (sessionRow.status === "running" && !sessionRow.last_turn_id) ||
+        requestTurnCompletesActiveRun;
     const aliasCompletesCurrentRequest = isRuntimeAliasForCurrentRequest &&
         requestOrder !== undefined &&
         compareHeadBasisOrder(requestOrder, currentOrder) >= 0;
-    const shouldApplyTurnDone = isTerminalForCurrentTurn && (aliasCompletesCurrentRequest || (basisComparison !== null ? basisComparison >= 0 : !currentOrder));
+    const shouldApplyTurnDone = isTerminalForCurrentTurn && (aliasCompletesCurrentRequest ||
+        requestTurnCompletesActiveRun ||
+        (basisComparison !== null ? basisComparison >= 0 : !currentOrder));
     const shouldApplyHead = shouldApplyTurnDone;
     const pendingRun = context.pendingRunCommand(connection.accountId, {
         machineId: connection.machineId,

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.60",
+  "version": "0.1.0-beta.62",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@cydm/happy-elves",
-      "version": "0.1.0-beta.60",
+      "version": "0.1.0-beta.62",
       "license": "Apache-2.0",
       "dependencies": {
         "@fastify/cors": "11.2.0",
@@ -757,9 +757,9 @@
       "license": "BSD-3-Clause"
     },
     "node_modules/@types/node": {
-      "version": "26.1.0",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-26.1.0.tgz",
-      "integrity": "sha512-O0A1G3xPGy4w7AgQdAQYUlQ+BKk2Oovw8eRpofyp5KdBZULnbe+WqaOVNrm705SHphCiG4XHsACrSmPu1f+Kgw==",
+      "version": "26.1.1",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-26.1.1.tgz",
+      "integrity": "sha512-nxAkRSVkN1Y0JC1W8ky/fTfkGsMmcrRsbx+3XoZE+rMOX71kLYTV7fLXpqud1GpbpP5TuffXFqfX7fH2GgZREw==",
       "license": "MIT",
       "dependencies": {
         "undici-types": "~8.3.0"
@@ -898,9 +898,9 @@
       }
     },
     "node_modules/bare-fs": {
-      "version": "4.7.3",
-      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.7.3.tgz",
-      "integrity": "sha512-xRgplks8SvcKkdlv2M6Z2LZmRsmqd+x0nXXGXeMEjwdibj1HSDrlnqBRLeYdMvsgCox7Bq0e+DHwfczOfsn6IA==",
+      "version": "4.7.4",
+      "resolved": "https://registry.npmjs.org/bare-fs/-/bare-fs-4.7.4.tgz",
+      "integrity": "sha512-y1kC+ffIx/tPLdTE693uNjHfzTfr+ravR5tvWlMXe25nELbkqV400S71qHDwbkAQ1FVEZobB1NFRzFbCCcyBCQ==",
       "license": "Apache-2.0",
       "dependencies": {
         "bare-events": "^2.5.4",
@@ -921,23 +921,11 @@
         }
       }
     },
-    "node_modules/bare-os": {
-      "version": "3.9.3",
-      "resolved": "https://registry.npmjs.org/bare-os/-/bare-os-3.9.3.tgz",
-      "integrity": "sha512-fF4Q7QsyKVF5Rj0qvI8BgUNjqzC2JvQlpTaPLjVJVxYVUX5Zr9un+y3w1HmA4nNKdFmRBT8z/WmrjvXzXVerKQ==",
-      "license": "Apache-2.0",
-      "engines": {
-        "bare": ">=1.14.0"
-      }
-    },
     "node_modules/bare-path": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/bare-path/-/bare-path-3.0.1.tgz",
-      "integrity": "sha512-ghj2DSK/2e99a1anTVPCV4m4YIYtrbXhfM7V3D7XZLOTsybnYyaJloymGqssQc8l/or0UoDyRtNQkmkEF/ysgQ==",
-      "license": "Apache-2.0",
-      "dependencies": {
-        "bare-os": "^3.0.1"
-      }
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/bare-path/-/bare-path-3.1.1.tgz",
+      "integrity": "sha512-JprUlveX3QjApC1cTpsUOiscADftCGVWkzitbHsRqv84hzYwYHw2mbluddsq5TvI8mH/8Ov1f4BiMAdcB0oYnQ==",
+      "license": "Apache-2.0"
     },
     "node_modules/bare-stream": {
       "version": "2.13.3",

package/package.json

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

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

@@ -467,6 +467,8 @@ export type JsonEnvelope<T = unknown> = {
         activeTurnId?: string;
         latestCompletedTurnId?: string;
         commandAcked?: boolean;
+        sessionStatus?: string;
+        staleRunningTurnId?: string;
         lastTransientError?: {
             code: string;
             message: string;
@@ -490,6 +492,8 @@ export type JsonEnvelope<T = unknown> = {
         latestCompletedTurnId?: string;
         commandAcked?: boolean;
         rawStatus?: string;
+        sessionStatus?: string;
+        staleRunningTurnId?: string;
         lastTransientError?: {
             code: string;
             message: string;