@cydm/happy-elves 0.1.0-beta.500 → 0.1.0-beta.502

package/README.md

@@ -6,8 +6,8 @@ Public beta CLI for Happy Elves.
 
 Run once in the existing user account; it detects %USERPROFILE%\.happy-elves\hosted, keeps the current daemon and sessions running, installs the independent updater, and registers per-user startup.
 
-    npm.cmd install --prefix $HOME\.happy-elves\management-entry --ignore-scripts --no-audit --no-fund --package-lock=false @cydm/happy-elves@0.1.0-beta.500
-    npm.cmd exec --yes --package @cydm/happy-elves@0.1.0-beta.500 -- happy-elves-updater install --state-root $HOME\.happy-elves\hosted --autostart
+    npm.cmd install --prefix $HOME\.happy-elves\management-entry --ignore-scripts --no-audit --no-fund --package-lock=false @cydm/happy-elves@0.1.0-beta.502
+    npm.cmd exec --yes --package @cydm/happy-elves@0.1.0-beta.502 -- happy-elves-updater install --state-root $HOME\.happy-elves\hosted --autostart
 
 The same updater entrypoint works on macOS after selecting a permanent user prefix.
 

package/apps/cli/package.json

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

package/apps/daemon/dist/orchestration/runner.js

@@ -10,7 +10,7 @@ import { rehydrateRuntimeSession } from "../session/lifecycle.js";
 import { runtimeRead } from "../session/runtime-truth.js";
 import { encryptedSessionMetadata } from "../session/metadata.js";
 import { loadSessionProjections } from "../session/store.js";
-import { appendAttention, expireInflightLeases, leaseNextAttention, latestAttentionForTask, markAttentionDelivered, markAttentionDeliveryFailed, markSubscriptionLiveness, recordTurnRuntimeBinding, reopenUnresolvedArtifactFeedbackAttentions, readOrchestrationStore, } from "./store.js";
+import { appendAttention, closeSubscriptionForTurn, expireInflightLeases, leaseNextAttention, latestAttentionForTask, markAttentionDelivered, markAttentionDeliveryFailed, markSubscriptionLiveness, recordTurnRuntimeBinding, reopenUnresolvedArtifactFeedbackAttentions, readOrchestrationStore, } from "./store.js";
 import { attentionFromReconcile, catchUpSubscriptionEvents } from "./watcher.js";
 import { scheduleRemoteOrchestrationWork } from "./remote-work-budget.js";
 import { resolveWakeIdentity } from "./wake-identity.js";
@@ -146,9 +146,6 @@ async function reconcileSubscriptionsOnce(config) {
         if (reconciledSubscriptions.has(key))
             continue;
         reconciledSubscriptions.add(key);
-        const latest = await latestAttentionForTask(subscription.taskId);
-        if (latest?.eventTypes.some((type) => type === "terminal" || type === "failure"))
-            continue;
         if (crewMachineId !== config.machineId) {
             // Remote reconcile shares the same bounded/fair scheduler as transcript
             // catch-up. Startup recovery must not create an unbounded second fleet
@@ -252,8 +249,20 @@ async function reconcileRemoteSubscription(config, subscription) {
             return;
         }
         const attention = attentionFromReconcile(result);
-        if (!attention || !subscription.eventTypes.includes(attention.eventType))
+        if (!attention)
             return;
+        const closesTurn = attention.eventType === "terminal" || attention.eventType === "failure";
+        if (!subscription.eventTypes.includes(attention.eventType)) {
+            if (closesTurn) {
+                await closeSubscriptionForTurn({
+                    taskId: subscription.taskId,
+                    consumerSessionId: subscription.consumerSessionId,
+                    crewSessionId: subscription.crewSessionId,
+                    turnId: subscription.turnId,
+                });
+            }
+            return;
+        }
         await appendAttention({
             taskId: subscription.taskId,
             consumerMachineId: subscription.consumerMachineId ?? config.machineId,
@@ -270,6 +279,7 @@ async function reconcileRemoteSubscription(config, subscription) {
                 turnId: subscription.turnId,
                 ref: result.status,
             },
+            closeSubscription: closesTurn,
         });
     }
     catch (error) {
@@ -307,14 +317,16 @@ async function markStaleSubscriptions(config) {
         if (Number.isFinite(lastSeenAt) && now - lastSeenAt < staleMs)
             continue;
         const latest = await latestAttentionForTask(subscription.taskId);
-        if (latest?.eventTypes.some((type) => type === "terminal" || type === "failure"))
-            continue;
-        if (latest?.eventTypes.includes("stale") && latest.status !== "acked")
+        if (latest?.turnId === subscription.turnId && latest.eventTypes.includes("stale") && latest.status !== "acked")
             continue;
         if ((subscription.crewMachineId ?? config.machineId) === config.machineId) {
             await reconcileLocalSubscription(config, subscription, "stale-check");
-            const reconciledLatest = await latestAttentionForTask(subscription.taskId);
-            if (reconciledLatest?.eventTypes.some((type) => type === "terminal" || type === "failure" || type === "unknown"))
+            const reconciledStore = await readOrchestrationStore();
+            const currentSubscription = reconciledStore.subscriptions.find((record) => record.taskId === subscription.taskId &&
+                record.consumerSessionId === subscription.consumerSessionId &&
+                record.crewSessionId === subscription.crewSessionId &&
+                record.turnId === subscription.turnId);
+            if (!currentSubscription || currentSubscription.status !== "active")
                 continue;
             if (await localSubscriptionTurnIsActive(subscription))
                 continue;

package/apps/daemon/dist/orchestration/store.d.ts

@@ -123,6 +123,8 @@ export type AttentionInput = {
     eventType: TaskAttentionEventType;
     reason: string;
     payloadRef?: TaskAttentionPayloadRef;
+    /** Terminal/failure attention closes the exact turn subscription atomically. */
+    closeSubscription?: boolean;
     now?: string;
 };
 export declare function readOrchestrationStore(): Promise<OrchestrationStore>;
@@ -249,6 +251,9 @@ export declare function markSubscriptionRemoteScan(taskId: string, input: {
     at?: string;
 }): Promise<void>;
 export declare function appendAttention(input: AttentionInput): Promise<TaskAttentionRecord[]>;
+export declare function closeSubscriptionForTurn(input: Pick<AttentionInput, "taskId" | "consumerSessionId" | "crewSessionId" | "turnId"> & {
+    at?: string;
+}): Promise<void>;
 export declare function listAttentions(input?: {
     consumerSessionId?: string;
     status?: TaskAttentionStatus[];

package/apps/daemon/dist/orchestration/store.js

@@ -794,6 +794,9 @@ export async function appendAttention(input) {
     let updated;
     const store = await updateOrchestrationStore((current) => {
         updated = appendAttentionRecord(current, { ...input, now: input.now ?? new Date().toISOString() });
+        if (input.closeSubscription && (input.eventType === "terminal" || input.eventType === "failure")) {
+            closeSubscriptionForTurnRecord(current, input);
+        }
         return current;
     });
     if (!updated)
@@ -802,6 +805,30 @@ export async function appendAttention(input) {
         record.consumerSessionId === updated?.consumerSessionId &&
         record.eventCursor === updated?.eventCursor);
 }
+export async function closeSubscriptionForTurn(input) {
+    if (!input.turnId)
+        return;
+    const at = input.at ?? new Date().toISOString();
+    await updateOrchestrationStore((current) => {
+        closeSubscriptionForTurnRecord(current, { ...input, now: at });
+        return current;
+    });
+}
+function closeSubscriptionForTurnRecord(store, input) {
+    if (!input.turnId)
+        return;
+    const now = input.now ?? new Date().toISOString();
+    for (const subscription of store.subscriptions) {
+        if (subscription.status !== "active")
+            continue;
+        if (subscription.taskId !== input.taskId || subscription.consumerSessionId !== input.consumerSessionId)
+            continue;
+        if (subscription.crewSessionId !== input.crewSessionId || subscription.turnId !== input.turnId)
+            continue;
+        subscription.status = "deleted";
+        subscription.updatedAt = now;
+    }
+}
 function appendAttentionRecord(store, input) {
     const index = store.attentions.findIndex((record) => record.taskId === input.taskId && record.consumerSessionId === input.consumerSessionId);
     const payloadRefs = input.payloadRef ? [input.payloadRef] : [];

package/apps/daemon/dist/orchestration/watcher.d.ts

@@ -22,7 +22,6 @@ export declare function catchUpSubscriptionEvents(input: {
     config: DaemonConfig;
     subscription: OrchestrationSubscriptionRecord;
 }): Promise<SubscriptionCatchUpResult>;
-export declare function remoteEventCursorForSubscription(crewMachineId: string, subscription: Pick<OrchestrationSubscriptionRecord, "remoteEventCursor" | "remoteEventSeq">): string | undefined;
 export declare function attentionFromReconcile(result: TurnReconcileResult): {
     eventType: TaskAttentionEventType;
     reason: string;

package/apps/daemon/dist/orchestration/watcher.js

@@ -2,15 +2,11 @@ import { randomId, } from "../../../../packages/shared/dist/index.js";
 import { appendAudit } from "../audit.js";
 import { RemoteCommandError, requestRemoteMachineResult } from "../relay/remote-command.js";
 import { runtimeRead } from "../session/runtime-truth.js";
-import { activeSubscriptionsForTurn, appendAttention, markSubscriptionLiveness, markSubscriptionRemoteScan, recordTurnRuntimeBinding, } from "./store.js";
+import { activeSubscriptionsForTurn, appendAttention, closeSubscriptionForTurn, markSubscriptionLiveness, markSubscriptionRemoteScan, recordTurnRuntimeBinding, } from "./store.js";
 import { scheduleRemoteOrchestrationWork } from "./remote-work-budget.js";
 import { relayMachineRegistry } from "../state.js";
 const remoteCatchupsInFlight = new Map();
-const legacyRemoteCursorFallbackUntil = new Map();
-const remoteForwardCursorConfirmed = new Set();
-const legacyRemoteCursorFallbackMs = 5 * 60 * 1000;
 const initialRemoteEventCursor = "event_000000000000";
-const forwardEventCursorSinceBeta = 495;
 export async function observeSessionEvent(input) {
     const attention = attentionFromEvent(input.payload);
     if (!attention) {
@@ -21,8 +17,18 @@ export async function observeSessionEvent(input) {
     }
     const subscriptions = await activeSubscriptionsForTurn(input.sessionId, input.turnId);
     for (const subscription of subscriptions) {
-        if (!subscription.eventTypes.includes(attention.eventType))
+        const closesTurn = attention.eventType === "terminal" || attention.eventType === "failure";
+        if (!subscription.eventTypes.includes(attention.eventType)) {
+            if (closesTurn) {
+                await closeSubscriptionForTurn({
+                    taskId: subscription.taskId,
+                    consumerSessionId: subscription.consumerSessionId,
+                    crewSessionId: subscription.crewSessionId,
+                    turnId: subscription.turnId,
+                });
+            }
             continue;
+        }
         await appendAttention({
             taskId: subscription.taskId,
             consumerMachineId: subscription.consumerMachineId ?? input.config.machineId,
@@ -39,6 +45,7 @@ export async function observeSessionEvent(input) {
                 turnId: input.turnId,
                 eventSeq: input.seq,
             },
+            closeSubscription: closesTurn,
         });
         await appendOrchestrationAudit(input.config, "orchestration.attention.append", `Recorded ${attention.eventType} attention for ${subscription.taskId}`, {
             taskId: subscription.taskId,
@@ -89,6 +96,7 @@ export async function observeTurnReconcile(input) {
                 turnId: input.result.turnId,
                 ref: input.result.status,
             },
+            closeSubscription: attention.eventType === "terminal" || attention.eventType === "failure",
         });
         await appendOrchestrationAudit(input.config, "orchestration.attention.reconcile", `Recorded ${attention.eventType} reconcile attention for ${subscription.taskId}`, {
             taskId: subscription.taskId,
@@ -122,8 +130,10 @@ async function catchUpSubscriptionEventsInternal(input) {
     const remoteCursor = crewMachineId !== input.config.machineId
         ? remoteEventCursorForSubscription(crewMachineId, input.subscription)
         : undefined;
-    const remoteCursorEnabled = remoteCursor !== undefined;
     try {
+        if (crewMachineId !== input.config.machineId && remotePeerForwardCursorSupport(crewMachineId) !== true) {
+            throw new RemoteCommandError(`Remote Crew ${crewMachineId} does not advertise the required forward event cursor protocol`, "REMOTE_FORWARD_CURSOR_UNSUPPORTED", false);
+        }
         const result = crewMachineId === input.config.machineId
             ? await runtimeRead(input.config, {
                 requestId: randomId("orch_catchup_events"),
@@ -146,8 +156,7 @@ async function catchUpSubscriptionEventsInternal(input) {
                     action: "turn.eventsPage",
                     sessionId: input.subscription.crewSessionId,
                     turnId: input.subscription.turnId,
-                    ...(remoteCursor ? { after: remoteCursor } : {}),
-                    ...(input.subscription.remoteEventItemId && !remoteCursor ? { afterItemId: input.subscription.remoteEventItemId } : {}),
+                    after: remoteCursor,
                     ...(input.subscription.runtimeTurnId ?? input.subscription.providerTurnId
                         ? { runtimeTurnId: input.subscription.runtimeTurnId ?? input.subscription.providerTurnId }
                         : {}),
@@ -169,19 +178,8 @@ async function catchUpSubscriptionEventsInternal(input) {
             });
             return { status: "unreachable" };
         }
-        // A rolling-upgrade peer may accept the old runtimeRead command but omit
-        // the forward cursor in its response. Treat that as the legacy path for
-        // this machine; in particular, never advance a durable cursor from a
-        // page whose peer cannot prove append-only progress.
-        if (crewMachineId !== input.config.machineId && result.cursorSupported === true) {
-            remoteForwardCursorConfirmed.add(crewMachineId);
-        }
-        else if (crewMachineId !== input.config.machineId && remoteCursorEnabled && !result.nextAfter) {
-            // A peer that accepted the forward request but cannot prove the cursor
-            // contract is no longer trusted. Remove the positive handshake so the
-            // next safe, legacy-compatible request can renegotiate it.
-            remoteForwardCursorConfirmed.delete(crewMachineId);
-            legacyRemoteCursorFallbackUntil.set(crewMachineId, Date.now() + legacyRemoteCursorFallbackMs);
+        if (crewMachineId !== input.config.machineId && result.cursorSupported !== true) {
+            throw new RemoteCommandError(`Remote Crew ${crewMachineId} returned a response without forward cursor support`, "REMOTE_FORWARD_CURSOR_UNSUPPORTED", false);
         }
         const observed = await observeSubscriptionRuntimeEvents({
             config: input.config,
@@ -191,7 +189,7 @@ async function catchUpSubscriptionEventsInternal(input) {
             skipThroughSeq: crewMachineId === input.config.machineId ? 0 : input.subscription.remoteEventSeq ?? 0,
         });
         if (crewMachineId !== input.config.machineId) {
-            const canAdvance = Boolean(result.nextAfter);
+            const canAdvance = result.cursorSupported === true;
             await markSubscriptionRemoteScan(input.subscription.taskId, {
                 crewMachineId,
                 crewSessionId: input.subscription.crewSessionId,
@@ -209,86 +207,32 @@ async function catchUpSubscriptionEventsInternal(input) {
         };
     }
     catch (error) {
-        if (crewMachineId !== input.config.machineId && remoteCursorEnabled && isRemoteEventCursorCompatibilityFailure(error)) {
-            remoteForwardCursorConfirmed.delete(crewMachineId);
-            legacyRemoteCursorFallbackUntil.set(crewMachineId, Date.now() + legacyRemoteCursorFallbackMs);
-        }
         await appendOrchestrationAudit(input.config, "orchestration.subscription.catchup_failed", `Subscription catch-up failed for ${input.subscription.taskId}`, {
             taskId: input.subscription.taskId,
             crewMachineId,
             crewSessionId: input.subscription.crewSessionId,
             turnId: input.subscription.turnId,
+            errorCode: error instanceof RemoteCommandError ? error.code : undefined,
             error: error instanceof Error ? error.message : String(error),
         });
         return { status: "failed" };
     }
 }
-function canUseRemoteEventCursor(crewMachineId) {
-    const until = legacyRemoteCursorFallbackUntil.get(crewMachineId);
-    if (until === undefined)
-        return remotePeerAdvertisesForwardCursor(crewMachineId);
-    if (until <= Date.now()) {
-        legacyRemoteCursorFallbackUntil.delete(crewMachineId);
-        return remotePeerAdvertisesForwardCursor(crewMachineId);
-    }
-    return false;
-}
-export function remoteEventCursorForSubscription(crewMachineId, subscription) {
-    const fallbackUntil = legacyRemoteCursorFallbackUntil.get(crewMachineId);
-    if (fallbackUntil !== undefined && fallbackUntil > Date.now())
-        return undefined;
-    if (fallbackUntil !== undefined)
-        legacyRemoteCursorFallbackUntil.delete(crewMachineId);
-    const advertised = remotePeerForwardCursorSupport(crewMachineId);
-    // An explicit old version wins over a stale persisted cursor (for example,
-    // after a peer downgrade). Unknown manifests are different: a persisted
-    // cursor is still positive evidence until the peer identity is refreshed.
-    if (advertised === false)
-        return undefined;
-    // A persisted cursor is positive evidence from a previous successful
-    // forward-page response. It remains usable even when the peer's manifest is
-    // temporarily unavailable during reconnect.
+function remoteEventCursorForSubscription(crewMachineId, subscription) {
+    // Every current daemon speaks the append-only forward cursor protocol. The
+    // capability gate lives in catchUpSubscriptionEventsInternal so an
+    // unavailable/old peer fails with a structured protocol error rather than
+    // silently switching to an unsafe legacy page.
+    void crewMachineId;
     if (subscription.remoteEventCursor)
         return subscription.remoteEventCursor;
-    if (advertised !== true || !canUseRemoteEventCursor(crewMachineId))
-        return undefined;
     return subscription.remoteEventSeq
         ? `event_${String(subscription.remoteEventSeq).padStart(12, "0")}`
         : initialRemoteEventCursor;
 }
-function remotePeerAdvertisesForwardCursor(crewMachineId) {
-    return remotePeerForwardCursorSupport(crewMachineId) === true;
-}
 function remotePeerForwardCursorSupport(crewMachineId) {
     const machine = relayMachineRegistry.get(crewMachineId);
-    const daemonVersion = machine?.capabilities.daemonVersion?.trim();
-    const advertisedFeature = machine?.capabilities.runtimeEvents?.forwardCursor;
-    if (advertisedFeature === false)
-        return false;
-    if (!daemonVersion) {
-        if (advertisedFeature === true || remoteForwardCursorConfirmed.has(crewMachineId))
-            return true;
-        return undefined;
-    }
-    // Published beta495 introduced the append-only eventsPage `after` field.
-    // Workspace daemons also publish an explicit feature bit. The historical
-    // package version 0.1.0 alone is not evidence: older development daemons
-    // used that same version while rejecting `after`.
-    const match = /^0\.1\.0-beta\.(\d+)$/.exec(daemonVersion);
-    if (match && Number(match[1]) < forwardEventCursorSinceBeta)
-        return false;
-    if (advertisedFeature === true || remoteForwardCursorConfirmed.has(crewMachineId))
-        return true;
-    if (match)
-        return Number(match[1]) >= forwardEventCursorSinceBeta;
-    return undefined;
-}
-function isRemoteEventCursorCompatibilityFailure(error) {
-    if (!(error instanceof RemoteCommandError))
-        return false;
-    return error.code === "REMOTE_COMMAND_TIMEOUT" ||
-        error.code === "REMOTE_MACHINE_ERROR" ||
-        /INVALID|UNKNOWN|UNRECOGNIZED|SCHEMA|PROTOCOL|CURSOR|AFTER/u.test(error.code);
+    return machine?.capabilities.runtimeEvents?.forwardCursor;
 }
 async function observeSubscriptionRuntimeEvents(input) {
     const crewMachineId = input.crewMachineId ?? input.subscription.crewMachineId ?? input.config.machineId;
@@ -360,8 +304,18 @@ async function observeSubscriptionPayload(input) {
         }
         return;
     }
-    if (!input.subscription.eventTypes.includes(attention.eventType))
+    const closesTurn = attention.eventType === "terminal" || attention.eventType === "failure";
+    if (!input.subscription.eventTypes.includes(attention.eventType)) {
+        if (closesTurn) {
+            await closeSubscriptionForTurn({
+                taskId: input.subscription.taskId,
+                consumerSessionId: input.subscription.consumerSessionId,
+                crewSessionId: input.subscription.crewSessionId,
+                turnId: input.subscription.turnId,
+            });
+        }
         return;
+    }
     await appendAttention({
         taskId: input.subscription.taskId,
         consumerMachineId: input.subscription.consumerMachineId ?? input.config.machineId,
@@ -378,6 +332,7 @@ async function observeSubscriptionPayload(input) {
             turnId: input.subscription.turnId,
             eventSeq: input.seq,
         },
+        closeSubscription: closesTurn,
     });
     await appendOrchestrationAudit(input.config, "orchestration.attention.append", `Recorded ${input.crewMachineId === input.config.machineId ? "" : "remote "}${attention.eventType} attention for ${input.subscription.taskId}`, {
         taskId: input.subscription.taskId,

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

@@ -703,10 +703,37 @@ export async function connectOnce(config) {
     let loopTimer;
     let scheduleTimer;
     let orchestrationTimer;
+    let authenticated = false;
+    const startAuthenticatedWork = () => {
+        if (!authenticated || ws.readyState !== WebSocket.OPEN)
+            return;
+        if (loopTimer || scheduleTimer || orchestrationTimer)
+            return;
+        const onlineSinceMs = Date.now();
+        loopTimer = setInterval(() => {
+            void tickLoops(ws, config).catch((error) => {
+                console.error(`Loop tick failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }, 1000);
+        scheduleTimer = setInterval(() => {
+            void tickSchedules(config, onlineSinceMs).catch((error) => {
+                console.error(`Schedule tick failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }, 1000);
+        orchestrationTimer = setInterval(() => {
+            void tickOrchestration(config).catch((error) => {
+                console.error(`Orchestration tick failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }, 1000);
+        void recoverCrewQueues(config).catch((error) => {
+            console.error(`Crew queue relay-open recovery failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        void drainPendingArtifactFeedbackAttentions(config).catch((error) => {
+            console.error(`Artifact feedback attention relay-open recovery failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    };
     await new Promise((resolve) => {
         ws.addEventListener("open", () => {
-            const onlineSinceMs = Date.now();
-            setActiveRelaySocket(ws);
             const hello = {
                 type: "hello",
                 token: config.machineToken,
@@ -714,27 +741,6 @@ export async function connectOnce(config) {
                 nodeId: config.machineId,
             };
             ws.send(JSON.stringify(hello));
-            loopTimer = setInterval(() => {
-                void tickLoops(ws, config).catch((error) => {
-                    console.error(`Loop tick failed: ${error instanceof Error ? error.message : String(error)}`);
-                });
-            }, 1000);
-            scheduleTimer = setInterval(() => {
-                void tickSchedules(config, onlineSinceMs).catch((error) => {
-                    console.error(`Schedule tick failed: ${error instanceof Error ? error.message : String(error)}`);
-                });
-            }, 1000);
-            orchestrationTimer = setInterval(() => {
-                void tickOrchestration(config).catch((error) => {
-                    console.error(`Orchestration tick failed: ${error instanceof Error ? error.message : String(error)}`);
-                });
-            }, 1000);
-            void recoverCrewQueues(config).catch((error) => {
-                console.error(`Crew queue relay-open recovery failed: ${error instanceof Error ? error.message : String(error)}`);
-            });
-            void drainPendingArtifactFeedbackAttentions(config).catch((error) => {
-                console.error(`Artifact feedback attention relay-open recovery failed: ${error instanceof Error ? error.message : String(error)}`);
-            });
         });
         ws.addEventListener("message", (event) => {
             let message;
@@ -745,11 +751,24 @@ export async function connectOnce(config) {
                 console.error(`Invalid relay message: ${error instanceof Error ? error.message : String(error)}`);
                 return;
             }
-            void handleRelayWireMessage(ws, config, message).catch(async (error) => {
+            void (async () => {
+                if (message.type === "server:hello" && !authenticated) {
+                    // Relay authentication is complete only after the server hello.
+                    // Do not activate the socket earlier: a reconnect with a durable
+                    // outbox would otherwise flush publishPacket before the relay has
+                    // installed the machine's authenticated routing context.
+                    authenticated = true;
+                    setActiveRelaySocket(ws);
+                }
+                await handleRelayWireMessage(ws, config, message);
+                if (message.type === "server:hello")
+                    startAuthenticatedWork();
+            })().catch(async (error) => {
                 await appendUnscopedRelayError(config, "DAEMON_COMMAND_FAILED", error);
             });
         });
         ws.addEventListener("close", () => {
+            authenticated = false;
             clearActiveRelaySocket(ws);
             if (loopTimer)
                 clearInterval(loopTimer);
@@ -761,6 +780,7 @@ export async function connectOnce(config) {
             resolve();
         });
         ws.addEventListener("error", () => {
+            authenticated = false;
             clearActiveRelaySocket(ws);
             if (loopTimer)
                 clearInterval(loopTimer);

package/apps/daemon/package.json

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

package/apps/updater/dist/daemon.js

@@ -6,6 +6,7 @@ import { promisify } from "node:util";
 import { updaterPaths } from "./paths.js";
 import { daemonControlRequest } from "./control.js";
 import { readUpdaterMarker, readUpdaterOwner } from "./ownership.js";
+import { managedProcessEnvironment } from "./managed-environment.js";
 const execFileAsync = promisify(execFile);
 export async function localDaemonStatus(stateRoot) {
     const file = updaterPaths(stateRoot).daemonPidPath;
@@ -91,7 +92,7 @@ export async function startDaemon(input) {
     const stderr = fsSync.openSync(paths.daemonStderrPath, "a", 0o600);
     const child = spawn(input.nodeExecutable, [input.daemonEntrypoint, "start"], {
         cwd: input.stateRoot,
-        env: { ...process.env, HAPPY_ELVES_HOME: input.stateRoot, HAPPY_ELVES_UPDATER_GENERATION: input.generation },
+        env: { ...managedProcessEnvironment(), HAPPY_ELVES_HOME: input.stateRoot, HAPPY_ELVES_UPDATER_GENERATION: input.generation },
         detached: true,
         stdio: ["ignore", stdout, stderr],
         windowsHide: true,
@@ -119,7 +120,7 @@ export function spawnUpdaterFromStableLauncher(input) {
     const child = spawn(input.nodeExecutable, [runtimeScript, "updater", "run", "--state-root", input.stateRoot], {
         cwd: input.stateRoot,
         env: {
-            ...process.env,
+            ...managedProcessEnvironment(),
             HAPPY_ELVES_HOME: input.stateRoot,
             ...(input.handoffFromPid ? { HAPPY_ELVES_UPDATER_HANDOFF_FROM: String(input.handoffFromPid) } : {}),
             ...(input.handoffToken ? { HAPPY_ELVES_UPDATER_HANDOFF_TOKEN: input.handoffToken } : {}),

package/apps/updater/dist/launcher.d.ts

@@ -1,9 +1,17 @@
 /**
- * Install a stable, state-root-local launcher. The launcher deliberately resolves
- * the active slot at invocation time so an update never leaves a shell shim
- * pointing at a removed staging directory.
+ * Select the Node runtime used by stable launchers. An explicit executable is
+ * always authoritative (the `--node` escape hatch); otherwise retain the
+ * previously verified launcher runtime across upgrades, rollback and recovery.
+ * A stale/broken launcher record is not trusted and falls back to the runtime
+ * currently executing the updater.
  */
-export declare function writeStableLaunchers(stateRoot: string, nodeExecutable: string): Promise<{
+export declare function resolveStableNodeExecutable(stateRoot: string, explicitNodeExecutable?: string): Promise<string>;
+/**
+ * Install a stable, state-root-local launcher. The launcher deliberately
+ * resolves the active slot at invocation time so an update never leaves a
+ * shell shim pointing at a removed staging directory.
+ */
+export declare function writeStableLaunchers(stateRoot: string, nodeExecutable?: string): Promise<{
     cliPath: string;
     updaterPath: string;
 }>;

package/apps/updater/dist/launcher.js

@@ -3,36 +3,61 @@ import path from "node:path";
 import { updaterPaths } from "./paths.js";
 import { readCurrentSlot } from "./slots.js";
 import { atomicWriteJson } from "./state.js";
+import { inspectNodeRuntime } from "./node-runtime.js";
 /**
- * Install a stable, state-root-local launcher. The launcher deliberately resolves
- * the active slot at invocation time so an update never leaves a shell shim
- * pointing at a removed staging directory.
+ * Select the Node runtime used by stable launchers. An explicit executable is
+ * always authoritative (the `--node` escape hatch); otherwise retain the
+ * previously verified launcher runtime across upgrades, rollback and recovery.
+ * A stale/broken launcher record is not trusted and falls back to the runtime
+ * currently executing the updater.
+ */
+export async function resolveStableNodeExecutable(stateRoot, explicitNodeExecutable) {
+    if (explicitNodeExecutable !== undefined)
+        return (await inspectNodeRuntime(explicitNodeExecutable)).executable;
+    const manifestPath = path.join(updaterPaths(stateRoot).launcherDir, "launcher.json");
+    try {
+        const parsed = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+        if (typeof parsed.nodeExecutable === "string" && parsed.nodeExecutable.trim()) {
+            return (await inspectNodeRuntime(parsed.nodeExecutable)).executable;
+        }
+    }
+    catch {
+        // The launcher may not exist during the first install, or its old runtime
+        // may have been removed. In either case use the updater's current Node.
+    }
+    return (await inspectNodeRuntime(process.execPath)).executable;
+}
+/**
+ * Install a stable, state-root-local launcher. The launcher deliberately
+ * resolves the active slot at invocation time so an update never leaves a
+ * shell shim pointing at a removed staging directory.
  */
 export async function writeStableLaunchers(stateRoot, nodeExecutable) {
     const current = await readCurrentSlot(stateRoot);
     if (!current)
         throw Object.assign(new Error("Cannot create launcher before a current slot exists"), { code: "UPDATE_SLOT_MISSING" });
+    const selectedNodeExecutable = await resolveStableNodeExecutable(stateRoot, nodeExecutable);
     const paths = updaterPaths(stateRoot);
     await fs.mkdir(paths.launcherDir, { recursive: true, mode: 0o700 });
     const runtimeScript = path.join(paths.launcherDir, "launcher-runtime.cjs");
-    await fs.writeFile(runtimeScript, runtimeScriptSource(stateRoot, nodeExecutable), { mode: 0o700 });
+    await fs.writeFile(runtimeScript, runtimeScriptSource(stateRoot, selectedNodeExecutable), { mode: 0o700 });
     const cliEntry = path.join(current.slotPath, "node_modules", "@cydm", "happy-elves", "apps", "cli", "dist", "index.js");
     const updaterEntry = path.join(current.slotPath, "node_modules", "@cydm", "happy-elves", "apps", "updater", "dist", "cli.js");
     await fs.access(cliEntry);
     await fs.access(updaterEntry);
     if (process.platform === "win32") {
-        await atomicWriteText(paths.launcherPath, windowsLauncher(nodeExecutable, runtimeScript, "cli"));
-        await atomicWriteText(paths.updaterLauncherPath, windowsLauncher(nodeExecutable, runtimeScript, "updater"));
+        await atomicWriteText(paths.launcherPath, windowsLauncher(selectedNodeExecutable, runtimeScript, "cli"));
+        await atomicWriteText(paths.updaterLauncherPath, windowsLauncher(selectedNodeExecutable, runtimeScript, "updater"));
     }
     else {
-        await atomicWriteText(paths.launcherPath, posixLauncher(nodeExecutable, runtimeScript, "cli"));
-        await atomicWriteText(paths.updaterLauncherPath, posixLauncher(nodeExecutable, runtimeScript, "updater"));
+        await atomicWriteText(paths.launcherPath, posixLauncher(selectedNodeExecutable, runtimeScript, "cli"));
+        await atomicWriteText(paths.updaterLauncherPath, posixLauncher(selectedNodeExecutable, runtimeScript, "updater"));
         await fs.chmod(paths.launcherPath, 0o700);
         await fs.chmod(paths.updaterLauncherPath, 0o700);
     }
     await atomicWriteJson(path.join(paths.launcherDir, "launcher.json"), {
         schema: 1,
-        nodeExecutable,
+        nodeExecutable: selectedNodeExecutable,
         runtimeScript,
         version: current.version,
         cliPath: cliEntry,

package/apps/updater/dist/managed-environment.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Read the current user's Windows environment without making it part of any
+ * host-job request. A manager can itself be launched by a deliberately
+ * sanitized host job; in that case process.env no longer contains provider
+ * credentials that the normal user-launched daemon would inherit.
+ *
+ * The result is used only for manager-owned updater/daemon children. It is
+ * never logged, persisted, sent over Relay, or passed to arbitrary host jobs.
+ */
+export declare function managedProcessEnvironment(base?: NodeJS.ProcessEnv, platform?: NodeJS.Platform, userEnvironment?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function parseWindowsUserEnvironment(output: string, expansionEnvironment?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;

package/apps/updater/dist/managed-environment.js

@@ -0,0 +1,125 @@
+import { execFileSync } from "node:child_process";
+const environmentLookupTimeoutMs = 2_000;
+/**
+ * Read the current user's Windows environment without making it part of any
+ * host-job request. A manager can itself be launched by a deliberately
+ * sanitized host job; in that case process.env no longer contains provider
+ * credentials that the normal user-launched daemon would inherit.
+ *
+ * The result is used only for manager-owned updater/daemon children. It is
+ * never logged, persisted, sent over Relay, or passed to arbitrary host jobs.
+ */
+export function managedProcessEnvironment(base = process.env, platform = process.platform, userEnvironment = platform === "win32" ? readWindowsUserEnvironment(base) : {}) {
+    if (platform !== "win32")
+        return { ...base };
+    const result = { ...base };
+    for (const [key, value] of Object.entries(userEnvironment)) {
+        if (!key || value === undefined || hasEnvironmentKey(result, key))
+            continue;
+        result[key] = value;
+    }
+    return result;
+}
+export function parseWindowsUserEnvironment(output, expansionEnvironment = {}) {
+    const entries = new Map();
+    const trimmed = output.trim();
+    if (trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            for (const [key, value] of Object.entries(parsed)) {
+                if (!key)
+                    continue;
+                if (typeof value === "string")
+                    entries.set(key, { value, expand: false });
+                else if (value && typeof value === "object" && "value" in value && typeof value.value === "string") {
+                    const typedValue = value;
+                    entries.set(key, { value: typedValue.value, expand: isExpandableRegistryType(typedValue.type) });
+                }
+            }
+            return materializeEnvironment(entries, expansionEnvironment);
+        }
+        catch {
+            // Fall through to the line-oriented reg.exe parser.
+        }
+    }
+    for (const line of output.split(/\r?\n/u)) {
+        // `reg query HKCU\\Environment` prints:
+        //     NAME    REG_SZ    value
+        const match = /^\s{4,}([^\s]+)\s+(REG_[A-Z0-9_]+)\s*(.*)$/u.exec(line);
+        if (!match)
+            continue;
+        const [, key, type, rawValue] = match;
+        if (!key || !rawValue)
+            continue;
+        entries.set(key, { value: rawValue, expand: isExpandableRegistryType(type) });
+    }
+    return materializeEnvironment(entries, expansionEnvironment);
+}
+function isExpandableRegistryType(type) {
+    if (typeof type !== "string")
+        return false;
+    const normalized = type.trim().toUpperCase().replace(/[-_\s]/gu, "");
+    // PowerShell's RegistryValueKind.ToString() returns ExpandString, while
+    // reg.exe uses REG_EXPAND_SZ. Both describe the same registry semantics.
+    return normalized === "EXPANDSTRING" || normalized === "REGEXPANDSZ";
+}
+function readWindowsUserEnvironment(base) {
+    try {
+        const output = execFileSync("powershell.exe", [
+            "-NoLogo",
+            "-NoProfile",
+            "-NonInteractive",
+            "-Command",
+            "$ErrorActionPreference='Stop'; $OutputEncoding=New-Object System.Text.UTF8Encoding($false); [Console]::OutputEncoding=New-Object System.Text.UTF8Encoding($false); $k=[Microsoft.Win32.Registry]::CurrentUser.OpenSubKey('Environment'); if ($null -eq $k) { '{}' } else { $o=[ordered]@{}; foreach ($n in $k.GetValueNames()) { $o[$n]=[ordered]@{ value=[string]$k.GetValue($n,$null,[Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames); type=$k.GetValueKind($n).ToString() } }; $o | ConvertTo-Json -Compress; $k.Dispose() }",
+        ], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            windowsHide: true,
+            timeout: environmentLookupTimeoutMs,
+        });
+        return parseWindowsUserEnvironment(output, base);
+    }
+    catch {
+        try {
+            const output = execFileSync("reg.exe", ["query", "HKCU\\Environment"], {
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+                windowsHide: true,
+                timeout: environmentLookupTimeoutMs,
+            });
+            return parseWindowsUserEnvironment(output, base);
+        }
+        catch {
+            // A missing registry helper or a locked-down profile must not prevent
+            // the updater from starting. The daemon will surface a provider error
+            // if it genuinely needs a credential that is unavailable in its env.
+            return {};
+        }
+    }
+}
+function materializeEnvironment(entries, expansionEnvironment) {
+    const result = {};
+    const combined = { ...expansionEnvironment };
+    for (const [key, entry] of entries)
+        combined[key] = entry.value;
+    for (const [key, entry] of entries) {
+        result[key] = entry.expand ? expandWindowsVariables(entry.value, combined) : entry.value;
+    }
+    return result;
+}
+function hasEnvironmentKey(environment, key) {
+    if (Object.hasOwn(environment, key))
+        return true;
+    const normalized = key.toUpperCase();
+    return Object.keys(environment).some((candidate) => candidate.toUpperCase() === normalized);
+}
+function expandWindowsVariables(value, environment) {
+    return value.replace(/%([^%]+)%/gu, (match, name) => {
+        const direct = environment[name];
+        if (direct !== undefined)
+            return direct;
+        const existing = Object.entries(environment).find(([key]) => key.toUpperCase() === name.toUpperCase());
+        return existing?.[1] ?? match;
+    });
+}
+//# sourceMappingURL=managed-environment.js.map

package/apps/updater/dist/run.js

@@ -7,7 +7,7 @@ import { startUpdaterRelay } from "./relay.js";
 import fs from "node:fs/promises";
 import { cancelHostJob, readHostJob, readHostJobByOperation, recoverHostJobs, startHostJob } from "./host-jobs.js";
 import { daemonEntrypoint, localDaemonStatus, spawnUpdaterFromStableLauncher, startDaemon, stopLocalDaemon, waitForUpdaterReady } from "./daemon.js";
-import { writeStableLaunchers } from "./launcher.js";
+import { resolveStableNodeExecutable, writeStableLaunchers } from "./launcher.js";
 import { clearStaleUpdaterMarkers, claimUpdaterOwner, markUpdaterHandoff, readUpdaterOwner, removeUpdaterPidIfOwned, restoreUpdaterOwner, writeUpdaterPid, writeUpdaterReady } from "./ownership.js";
 import { randomUUID } from "node:crypto";
 let daemonLifecycleTail = Promise.resolve();
@@ -132,13 +132,14 @@ async function recoverStaleUpdate(stateRoot) {
     const targetWasActivated = Boolean(current?.version && current.version === operation.targetVersion && operation.fromVersion);
     if (targetWasActivated && operation.fromVersion) {
         try {
+            const nodeExecutable = await resolveStableNodeExecutable(stateRoot);
             if (operation.daemonWasRunning !== false)
                 await stopLocalDaemon(stateRoot, 15_000);
             const packageJson = await readSlotPackage(stateRoot, operation.fromVersion);
             const restored = await activateSlot(stateRoot, { version: operation.fromVersion, digest: operation.fromDigest, buildId: operation.fromBuildId ?? (typeof packageJson?.buildId === "string" ? packageJson.buildId : undefined) });
-            await writeStableLaunchers(stateRoot, process.execPath);
+            await writeStableLaunchers(stateRoot, nodeExecutable);
             if (operation.daemonWasRunning !== false) {
-                const pid = await startDaemon({ stateRoot, nodeExecutable: process.execPath, daemonEntrypoint: daemonEntrypoint(restored.slotPath), generation: `recovery-${Date.now()}` });
+                const pid = await startDaemon({ stateRoot, nodeExecutable, daemonEntrypoint: daemonEntrypoint(restored.slotPath), generation: `recovery-${Date.now()}` });
                 if (!(await waitForDaemonPid(stateRoot, pid, 20_000)))
                     throw new Error("Recovered daemon did not become ready");
             }
@@ -170,7 +171,8 @@ async function handoffToCurrentSlot(stateRoot, owner) {
         // replacement can therefore restore the old marker without a duplicate
         // entrypoint deleting it.
         await fs.rm(readyPath, { force: true }).catch(() => undefined);
-        const nextPid = spawnUpdaterFromStableLauncher({ stateRoot, nodeExecutable: process.execPath, handoffFromPid: process.pid, handoffToken: token });
+        const nodeExecutable = await resolveStableNodeExecutable(stateRoot);
+        const nextPid = spawnUpdaterFromStableLauncher({ stateRoot, nodeExecutable, handoffFromPid: process.pid, handoffToken: token });
         if (await waitForUpdaterReady(stateRoot, nextPid, 10_000, { handoffToken: token }))
             return { ok: true };
         await recoverFailedHandoff(stateRoot, owner, token, previousReady);
@@ -264,7 +266,8 @@ async function handleDaemonCommand(command, input) {
                 const current = await readCurrentSlot(input.stateRoot);
                 if (!current)
                     return daemonError(command, input.machineId, "BOOTSTRAP_REQUIRED", "No installed daemon slot is available", action);
-                const pid = await startDaemon({ stateRoot: input.stateRoot, nodeExecutable: process.execPath, daemonEntrypoint: daemonEntrypoint(current.slotPath), generation: `host-${Date.now()}` });
+                const nodeExecutable = await resolveStableNodeExecutable(input.stateRoot);
+                const pid = await startDaemon({ stateRoot: input.stateRoot, nodeExecutable, daemonEntrypoint: daemonEntrypoint(current.slotPath), generation: `host-${Date.now()}` });
                 const status = await waitForDaemonPid(input.stateRoot, pid, 5_000);
                 if (!status)
                     throw Object.assign(new Error("Daemon exited before becoming ready"), { code: "DAEMON_START_FAILED" });

package/apps/updater/dist/supervisor.js

@@ -11,7 +11,7 @@ import { resolveOfficialRelease, downloadAndVerifyRelease, installOfficialPackag
 import { daemonControlRequest } from "./control.js";
 import { daemonEntrypoint, localDaemonStatus, startDaemon, startUpdater, stopLocalDaemon, waitForUpdaterReady } from "./daemon.js";
 import { activeHostJobCount } from "./host-jobs.js";
-import { writeStableLaunchers } from "./launcher.js";
+import { resolveStableNodeExecutable, writeStableLaunchers } from "./launcher.js";
 import { installAutostart } from "./autostart.js";
 import { readDaemonConfig } from "./daemon-config.js";
 export async function supervisorStatus(options) {
@@ -19,7 +19,14 @@ export async function supervisorStatus(options) {
     const operation = await readOperation(stateRoot);
     const current = await readCurrentSlot(stateRoot);
     const daemon = await localDaemonStatus(stateRoot);
-    const node = await inspectNodeRuntime(options.nodeExecutable ?? process.execPath).catch((error) => ({ errorCode: errorCode(error), error: error instanceof Error ? error.message : String(error) }));
+    let node;
+    try {
+        const selectedNode = await resolveStableNodeExecutable(stateRoot, options.nodeExecutable);
+        node = await inspectNodeRuntime(selectedNode);
+    }
+    catch (error) {
+        node = { errorCode: errorCode(error), error: error instanceof Error ? error.message : String(error) };
+    }
     return {
         stateRoot,
         updaterVersion: options.updaterVersion ?? "0.1.0",
@@ -35,7 +42,7 @@ export async function bootstrapFromTarball(input) {
     const daemon = await localDaemonStatus(stateRoot);
     if (daemon.running)
         throw Object.assign(new Error("Bootstrap requires a local maintenance window; stop the existing daemon after confirming it is idle"), { code: "BOOTSTRAP_MAINTENANCE_REQUIRED" });
-    const node = await inspectNodeRuntime(input.nodeExecutable ?? process.execPath);
+    const node = await inspectNodeRuntime(await resolveStableNodeExecutable(stateRoot, input.nodeExecutable));
     const existingCurrent = await readCurrentSlot(stateRoot);
     if (existingCurrent?.version === input.version)
         throw Object.assign(new Error("The requested bootstrap version is already active"), { code: "UPDATE_ALREADY_CURRENT" });
@@ -93,7 +100,7 @@ export async function bootstrapFromTarball(input) {
 export async function installCurrentPackage(input) {
     const stateRoot = resolveStateRoot(input.stateRoot);
     const config = await readDaemonConfig(stateRoot);
-    const node = await inspectNodeRuntime(input.nodeExecutable ?? process.execPath);
+    const node = await inspectNodeRuntime(await resolveStableNodeExecutable(stateRoot, input.nodeExecutable));
     const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../..");
     const manifest = JSON.parse(await fs.readFile(path.join(packageRoot, "package.json"), "utf8"));
     const version = typeof manifest.version === "string" && manifest.version ? manifest.version : undefined;
@@ -150,7 +157,7 @@ async function waitForDaemonPid(stateRoot, pid, timeoutMs) {
 }
 export async function applyOfficialUpdate(input) {
     const stateRoot = resolveStateRoot(input.stateRoot);
-    const node = await inspectNodeRuntime(input.nodeExecutable ?? process.execPath);
+    const node = await inspectNodeRuntime(await resolveStableNodeExecutable(stateRoot, input.nodeExecutable));
     const existing = await readOperation(stateRoot);
     const operationId = input.operationId ?? randomId("upd");
     if (existing && existing.operationId === operationId) {
@@ -269,6 +276,7 @@ export async function commitDeferredUpdate(input) {
 }
 /** Restore the previous slot after a replacement updater fails its handoff. */
 export async function recoverDeferredUpdate(input) {
+    const nodeExecutable = await resolveStableNodeExecutable(input.stateRoot, input.nodeExecutable);
     const operation = await readOperation(input.stateRoot);
     if (!operation || operation.operationId !== input.operationId)
         throw Object.assign(new Error("Deferred update operation was not found"), { code: "UPDATE_OPERATION_MISSING" });
@@ -281,9 +289,9 @@ export async function recoverDeferredUpdate(input) {
             await stopLocalDaemon(input.stateRoot, 15_000).catch(() => undefined);
         await activateSlot(input.stateRoot, { version: previous.version, digest: operation.fromDigest ?? previous.digest, buildId: operation.fromBuildId ?? previous.buildId });
         if (operation.daemonWasRunning !== false) {
-            await startAndVerify({ stateRoot: input.stateRoot, machineId: input.machineId, nodeExecutable: input.nodeExecutable ?? process.execPath, version: previous.version, generation: operation.barrierGeneration ?? randomId("rollback") });
+            await startAndVerify({ stateRoot: input.stateRoot, machineId: input.machineId, nodeExecutable, version: previous.version, generation: operation.barrierGeneration ?? randomId("rollback") });
         }
-        await writeStableLaunchers(input.stateRoot, input.nodeExecutable ?? process.execPath);
+        await writeStableLaunchers(input.stateRoot, nodeExecutable);
         await clearBarrier(input.stateRoot, input.machineId, input.operationId).catch(() => undefined);
         return await updateOperation(input.stateRoot, { phase: "recovered", errorCode: input.errorCode ?? "UPDATE_HANDOFF_FAILED", error: input.error ?? "Replacement updater failed; the previous slot was restored.", recoveredFrom: operation.targetVersion, targetVersion: previous.version });
     }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.500",
+  "version": "0.1.0-beta.502",
   "description": "Remote controller for local coding agents with hosted or self-hosted relay support.",
-  "buildId": "48f1f04bc7d6747ed2bf59b3fb1e2a58",
+  "buildId": "9ee7dcc44e6e7465aaa011b2c13085c8",
   "type": "module",
   "bin": {
     "happy-elves": "./apps/cli/dist/index.js",

package/packages/headless-runtime/dist/codex-provider.js

@@ -594,6 +594,16 @@ class CodexHeadlessRuntimeProvider {
                 if (codexTurnId && !active.settled && !active.terminalObserved) {
                     active.codexTurnId = codexTurnId;
                     this.activeTurnsByCodexTurn.set(codexTurnId, active);
+                    // Persist ownership as soon as the provider materialises the native
+                    // turn. A failed/interrupted HE turn is still an HE-owned append;
+                    // waiting until `turn/completed` made a restart misclassify that
+                    // failed turn as an external native handoff.
+                    // Serialize the durable metadata write with provider event handling,
+                    // but do not await it here: app-servers may issue a tool/approval
+                    // request immediately after the `turn/start` response and before
+                    // the first notification. Blocking that response would let a fast
+                    // terminal notification fence the still-active request.
+                    this.enqueueActive(active, () => this.bindStartedCodexTurn(active, codexTurnId));
                 }
             };
             startProviderTurn(codexThreadId).catch(async (error) => {
@@ -1127,6 +1137,27 @@ class CodexHeadlessRuntimeProvider {
             providerMetadata,
         });
     }
+    async bindStartedCodexTurn(active, codexTurnId) {
+        const priorIds = Array.isArray(active.providerMetadata?.nativeHistoryTurnIds)
+            ? active.providerMetadata.nativeHistoryTurnIds.filter((value) => typeof value === "string")
+            : [];
+        const nativeHistoryTurnIds = priorIds.includes(codexTurnId) ? priorIds : [...priorIds, codexTurnId];
+        const ownedPriorIds = Array.isArray(active.providerMetadata?.headlessOwnedNativeTurnIds)
+            ? active.providerMetadata.headlessOwnedNativeTurnIds.filter((value) => typeof value === "string")
+            : [];
+        const headlessOwnedNativeTurnIds = ownedPriorIds.includes(codexTurnId) ? ownedPriorIds : [...ownedPriorIds, codexTurnId];
+        const providerMetadata = {
+            ...active.providerMetadata,
+            nativeHistoryTurnIds,
+            headlessOwnedNativeTurnIds,
+            nativeHistoryVersion: nativeHistoryVersionForTurnIds(nativeHistoryTurnIds),
+        };
+        active.providerMetadata = providerMetadata;
+        await active.context.bindThreadProvider({
+            providerSessionId: active.codexThreadId,
+            providerMetadata,
+        });
+    }
     enqueueActive(active, task) {
         if (active.settled)
             return;