@cydm/happy-elves 0.1.0-beta.486 → 0.1.0-beta.488

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

@@ -33,12 +33,14 @@ const valueFlags = new Set([
     "limit",
     "machine",
     "machine-id",
+    "native-identity",
     "memory",
     "memory-mode",
     "message-id",
     "memory-project",
     "memory-top-n",
     "name",
+    "observed-at",
     "model",
     "thinking-level",
     "mode",
@@ -69,6 +71,7 @@ const valueFlags = new Set([
     "allow-sender",
     "expires-in",
     "format",
+    "history-version",
     "loops",
     "machines",
     "sessions",
@@ -112,6 +115,7 @@ const booleanFlags = new Set([
     "allow-any-sender",
     "app-secret-stdin",
     "confirm-risk",
+    "confirm-native-handoff",
     "copy-tags",
     "detach",
     "disable-reaction",

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

@@ -53,7 +53,7 @@ Check local controller config, relay reachability, and daemon state.
   happy-elves session tag remove <sessionId> --tag <tag> --json
   happy-elves session tag list <sessionId> --json
   happy-elves session history --machine <machineId> [--cwd <path>] [--agent <agent>] [--include-archived] [--limit 20] --json
-  happy-elves session continue <runtimeSessionId> --machine <machineId> [--name <name>] --json
+  happy-elves session continue <runtimeSessionId> --machine <machineId> [--name <name>] [--confirm-native-handoff] [--observed-at <ms>] [--history-version <version>] --json
   happy-elves session status <sessionId> [--verbose] [--json]
   happy-elves session diagnose <sessionId> [--limit 200] [--repair-head] [--json]
   happy-elves session close <sessionId> [--reason <reason>] --json
@@ -271,7 +271,7 @@ Core commands:
   session list [--machine <machineId>] [--cwd <path>] [--limit 20] [--json]
   session create --machine <machineId> [--agent codex] [--cwd <path>] [--name <name>] --json
   session history --machine <machineId> [--cwd <path>] [--limit 20] --json
-  session continue <runtimeSessionId> --machine <machineId> --json
+  session continue <runtimeSessionId> --machine <machineId> [--confirm-native-handoff] [--observed-at <ms>] [--history-version <version>] --json
   session status <sessionId> [--verbose] [--json]
   session diagnose <sessionId> [--limit 200] [--repair-head] [--json]
   session close <sessionId> [--reason <reason>] --json
@@ -326,7 +326,7 @@ Usage:
 
 Common flows:
   Discover: machine list --json; session list --machine <machineId> --json
-  Continue: session history --machine <machineId> --json; session continue <runtimeSessionId> --machine <machineId> --json
+  Continue: session history --machine <machineId> --json; session continue <runtimeSessionId> --machine <machineId> --confirm-native-handoff --json
   Execute: turn run <sessionId> --text <prompt> --json; turn result <sessionId> <turnId> --json
   Branch: turn rewind <sessionId> <turnId> --json; turn fork <sessionId> <turnId> --name <name> --json
 

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

@@ -1,5 +1,5 @@
 import type { ControllerClient } from "../../../../../packages/client/dist/index.js";
-import type { HistoricalSessionSnapshot } from "../../../../../packages/shared/dist/index.js";
+import type { HistoricalSessionSnapshot, HistoricalSessionWarning } from "../../../../../packages/shared/dist/index.js";
 export type WorkspaceHistoricalSession = HistoricalSessionSnapshot & {
     machineId: string;
     machineName: string;
@@ -18,6 +18,11 @@ export declare function listWorkspaceHistoricalSessions(client: ControllerClient
         code?: string;
         message: string;
     }>;
+    warnings: Array<{
+        machineId: string;
+        machineName: string;
+        warning: HistoricalSessionWarning;
+    }>;
     machines: Array<{
         machineId: string;
         machineName: string;

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

@@ -18,6 +18,7 @@ export async function listWorkspaceHistoricalSessions(client, input) {
         const machineName = projected.metadata.name ?? projected.metadata.hostname ?? machine.name;
         try {
             const sessions = [];
+            const warnings = [];
             let cursor;
             const seenCursors = new Set();
             while (sessions.length < input.limit) {
@@ -30,6 +31,7 @@ export async function listWorkspaceHistoricalSessions(client, input) {
                     cursor,
                 });
                 sessions.push(...page.sessions);
+                warnings.push(...(page.warnings ?? []));
                 if (!page.hasMore || !page.nextCursor)
                     break;
                 if (seenCursors.has(page.nextCursor))
@@ -42,6 +44,7 @@ export async function listWorkspaceHistoricalSessions(client, input) {
                     .filter((session) => input.includeArchived === true || session.runtimeState !== "archived")
                     .map((session) => ({ ...session, machineId: machine.id, machineName })),
                 error: undefined,
+                warnings,
                 machine: { machineId: machine.id, machineName },
             };
         }
@@ -55,6 +58,7 @@ export async function listWorkspaceHistoricalSessions(client, input) {
                     code: enriched.code,
                     message: error instanceof Error ? error.message : String(error),
                 },
+                warnings: [],
                 machine: { machineId: machine.id, machineName },
             };
         }
@@ -65,6 +69,7 @@ export async function listWorkspaceHistoricalSessions(client, input) {
             .sort((left, right) => right.updatedAt - left.updatedAt || left.runtimeSessionId.localeCompare(right.runtimeSessionId))
             .slice(0, input.limit)),
         errors: rows.flatMap((row) => row.error ? [row.error] : []),
+        warnings: rows.flatMap((row) => row.warnings.map((warning) => ({ machineId: row.machine.machineId, machineName: row.machine.machineName, warning }))),
         machines: rows.map((row) => row.machine),
     };
 }

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

@@ -546,13 +546,23 @@ export async function handleSession({ domain, action, positional, flags }) {
                     returned: result.sessions.length,
                     hasMore: result.sessions.length >= limit,
                 },
+                warnings: result.warnings,
                 ...(wantsVerbose(flags) ? { errors: result.errors, machines: result.machines } : {}),
             }, { machineId });
         }
         else if (sessions.length === 0) {
+            for (const { machineName, warning } of result.warnings) {
+                console.log(`Warning: ${machineName} · ${warning.provider}: ${warning.message}`);
+            }
+            for (const error of result.errors) {
+                console.log(`Warning: ${error.machineName}: ${error.message}`);
+            }
             console.log("No runtime historical sessions found.");
         }
         else {
+            for (const { machineName, warning } of result.warnings) {
+                console.log(`Warning: ${machineName} · ${warning.provider}: ${warning.message}`);
+            }
             for (const session of sessions) {
                 const loaded = session.sessionId ?? "-";
                 const state = session.runtimeState === "archived" ? "  archived" : "";
@@ -576,10 +586,25 @@ export async function handleSession({ domain, action, positional, flags }) {
             includeArchived: true,
             limit: 200,
         });
-        const historical = result.sessions.find((session) => session.runtimeSessionId === runtimeSessionId);
-        if (!historical)
+        const historical = result.sessions.find((session) => session.runtimeSessionId === runtimeSessionId)
+            ?? result.sessions.find((session) => session.providerSessionId === runtimeSessionId && session.nativeIdentity);
+        if (!historical) {
+            const warning = result.warnings[0]?.warning;
+            if (warning) {
+                const code = warning.code === "permission-denied" ? "PROVIDER_PERMISSION_DENIED"
+                    : warning.code === "unsupported" ? "PROVIDER_CAPABILITY_UNAVAILABLE"
+                        : "PROVIDER_UNAVAILABLE";
+                throw new CliError(`${warning.provider}: ${warning.message}`, code);
+            }
             throw new CliError(`Runtime session not found: ${runtimeSessionId}`, "RUNTIME_SESSION_NOT_FOUND");
-        if (historical.loadedSessionId) {
+        }
+        // Imported native sessions are represented by a stable HE runtime id in
+        // the canonical headless row, while the provider UUID remains the
+        // durable native provenance. Accept either id, but retain the native
+        // handoff path whenever that provenance is present.
+        const isNative = historical.source === "native" || Boolean(historical.nativeIdentity && historical.providerSessionId);
+        const resolvedRuntimeSessionId = historical.runtimeSessionId;
+        if (historical.loadedSessionId && !isNative) {
             ok("session.continue", {
                 sessionId: historical.loadedSessionId,
                 runtimeSessionId,
@@ -591,19 +616,43 @@ export async function handleSession({ domain, action, positional, flags }) {
         const name = typeof flags.name === "string" && flags.name.trim()
             ? flags.name.trim()
             : historical.name?.trim() || historical.summary?.trim() || historical.runtimeSessionName?.trim() || runtimeSessionId;
+        if (isNative && flags["confirm-native-handoff"] !== true && flags.manual !== true) {
+            throw new CliError("Native session takeover requires explicit confirmation. Re-run with --confirm-native-handoff (and optionally --observed-at/--history-version from this listing).", "NATIVE_HANDOFF_CONFIRMATION_REQUIRED");
+        }
+        const observedAtValue = flags["observed-at"];
+        const observedAt = observedAtValue === undefined || observedAtValue === true ? Date.now() : Number(observedAtValue);
+        if (!Number.isSafeInteger(observedAt) || observedAt <= 0)
+            throw new CliError("Invalid --observed-at", "INVALID_ARGUMENT");
+        const suppliedIdentity = typeof flags["native-identity"] === "string" ? flags["native-identity"].trim() : historical.nativeIdentity;
+        const suppliedHistoryVersion = typeof flags["history-version"] === "string" ? flags["history-version"].trim() : historical.nativeHistoryVersion;
+        const nativeIdentity = suppliedIdentity;
+        if (isNative && !nativeIdentity)
+            throw new CliError("Native session listing did not include a handoff identity; refresh the history listing.", "NATIVE_HANDOFF_PROOF_MISSING");
+        if (isNative && historical.nativeIdentity && nativeIdentity !== historical.nativeIdentity)
+            throw new CliError("--native-identity does not match the freshly listed native session.", "NATIVE_HANDOFF_RECONFIRM_REQUIRED");
+        if (isNative && historical.nativeHistoryVersion && suppliedHistoryVersion !== historical.nativeHistoryVersion)
+            throw new CliError("--history-version does not match the freshly listed native session.", "NATIVE_HANDOFF_RECONFIRM_REQUIRED");
+        const manualHandoffProof = isNative && nativeIdentity
+            ? {
+                identity: nativeIdentity,
+                observedAt,
+                ...(suppliedHistoryVersion ? { historyVersion: suppliedHistoryVersion } : {}),
+            }
+            : undefined;
         const continued = await client.importHistoricalSession({
             machineId,
             agent: historical.agent,
             cwd: historical.cwd,
-            runtimeSessionId,
+            runtimeSessionId: resolvedRuntimeSessionId,
             name,
             ...(historical.name ? { providerName: historical.name } : {}),
             ...(historical.provider ? { provider: historical.provider } : {}),
             ...(historical.providerSessionId ? { providerSessionId: historical.providerSessionId } : {}),
-            ...(historical.source ? { source: historical.source } : {}),
+            ...(isNative ? { source: "native" } : historical.source ? { source: historical.source } : {}),
             summary: historical.summary,
             runtimeState: historical.runtimeState,
             ...(historical.nativeIdentity ? { nativeIdentity: historical.nativeIdentity } : {}),
+            ...(manualHandoffProof ? { manualHandoff: true, manualHandoffProof } : {}),
         });
         ok("session.continue", {
             sessionId: continued.sessionId,

package/apps/cli/package.json

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

package/apps/daemon/dist/orchestration/crew-queue.js

@@ -5,7 +5,7 @@ import { publishRemoteControllerCommand } from "../relay/remote-command.js";
 import { claimCommandRequest, sendCommandResponse } from "../relay/send.js";
 import { runtimeTurnSummaryForTask } from "../session/runtime-truth.js";
 import { crewSessionRuntimeState, deliverQueuedCrewAdmission, publishRemoteCrewQueueEnqueue } from "./handler.js";
-import { applyConsumerQueueUpdateToStore, claimCrewQueueHead, completeMaterializedQueueAdmission, failQueuedCrewBacklog, findAdmissionByTaskAndRequest, listPendingCrewQueueNotifications, listPendingConsumerQueueEnqueues, listCrewQueueHeads, markCrewQueueNotificationAttempt, markCrewQueueNotificationApplied, releaseCrewQueueBackoff, recordAdmission, retryClaimedQueueAdmission, runtimeTurnIdForCrewTurn, updatePendingConsumerQueueEnqueue, upsertCrewQueueNotification, upsertSubscription, } from "./store.js";
+import { applyConsumerQueueUpdateToStore, claimCrewQueueHead, completeMaterializedQueueAdmission, failQueuedCrewBacklog, findAdmissionByTaskAndRequest, listPendingCrewQueueNotifications, listPendingConsumerQueueEnqueues, listCrewQueueHeads, markCrewQueueNotificationAttempt, markCrewQueueNotificationApplied, markCrewQueueNotificationDeadLetter, releaseCrewQueueBackoff, recordAdmission, retryClaimedQueueAdmission, runtimeTurnIdForCrewTurn, updatePendingConsumerQueueEnqueue, upsertCrewQueueNotification, upsertSubscription, } from "./store.js";
 import { catchUpSubscriptionEvents } from "./watcher.js";
 const activeDrains = new Map();
 const pendingDrains = new Set();
@@ -16,6 +16,8 @@ const notificationRetryTimers = new Map();
 const consumerEnqueueRetryTimers = new Map();
 let notificationFlushRun;
 let notificationFlushRequested = false;
+let consumerEnqueueRetryRun;
+let consumerEnqueueRetryRequested = false;
 let recoveryRun;
 export async function signalCrewQueue(config, signal) {
     const key = crewQueueKey(signal);
@@ -242,6 +244,7 @@ export async function handleCrewQueueUpdateCommand(ws, config, command) {
         ownerRevision: command.ownerRevision,
         currentRevision: applied.currentRevision,
         applied: applied.applied,
+        status: applied.applied ? "applied" : "permanent-rejected",
     });
     if (applied.subscription) {
         void catchUpSubscriptionEvents({ config, subscription: applied.subscription }).catch((error) => {
@@ -341,6 +344,21 @@ async function completeMaterializedCrewQueueHead(config, queue) {
     return terminalRuntimeStatus(summary.status) ? "terminal" : "active";
 }
 async function retryPendingConsumerQueueEnqueues(config) {
+    if (consumerEnqueueRetryRun) {
+        consumerEnqueueRetryRequested = true;
+        return await consumerEnqueueRetryRun;
+    }
+    consumerEnqueueRetryRun = (async () => {
+        do {
+            consumerEnqueueRetryRequested = false;
+            await retryPendingConsumerQueueEnqueuesOnce(config);
+        } while (consumerEnqueueRetryRequested);
+    })().finally(() => {
+        consumerEnqueueRetryRun = undefined;
+    });
+    await consumerEnqueueRetryRun;
+}
+async function retryPendingConsumerQueueEnqueuesOnce(config) {
     const pending = await listPendingConsumerQueueEnqueues({ consumerMachineId: config.machineId });
     for (const admission of pending) {
         const key = consumerEnqueueRetryKey(admission);
@@ -611,6 +629,18 @@ async function flushCrewQueueNotificationsOnce(config) {
                 expectedType: "machine:crewQueueUpdateApplied",
                 timeoutMs: 15_000,
             });
+            if (response?.type === "machine:crewQueueUpdateApplied" && response.status === "permanent-rejected") {
+                await markCrewQueueNotificationDeadLetter(notification.notificationId);
+                await appendAudit({
+                    machineId: config.machineId,
+                    sessionId: notification.crewSessionId,
+                    actor: "system",
+                    action: "orchestration.queue.consumer_update_dead_letter",
+                    summary: `Consumer permanently rejected queue update for ${notification.taskId}`,
+                    evidence: { taskId: notification.taskId, dispatchRequestId: notification.dispatchRequestId, ownerRevision: notification.ownerRevision },
+                }).catch(() => undefined);
+                return;
+            }
             if (!crewQueueUpdateAppliedCovers(notification, response)) {
                 throw new Error(`Consumer did not apply queue update revision ${notification.ownerRevision} for task ${notification.taskId}`);
             }
@@ -684,7 +714,8 @@ function crewQueueUpdateAppliedCovers(notification, response) {
         response.crewSessionId === notification.crewSessionId &&
         response.ownerRevision === notification.ownerRevision &&
         response.currentRevision >= notification.ownerRevision &&
-        response.applied;
+        response.applied &&
+        (response.status === undefined || response.status === "applied" || response.status === "covered");
 }
 function consumerProjectionCoversUpdate(admission, command, currentRevision) {
     if (!admission)

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

@@ -1,4 +1,4 @@
-import { type DispatchTaskProjection, type MachineCommand, type RuntimeTurnReadSummary } from "../../../../packages/shared/dist/index.js";
+import { type DispatchTaskProjection, type LoadedSessionInventory, type MachineCommand, type RuntimeTurnReadSummary } from "../../../../packages/shared/dist/index.js";
 import type { DaemonConfig } from "../types.js";
 import { type StoredDispatchAdmissionRecord } from "./store.js";
 type DispatchCommand = Extract<MachineCommand, {
@@ -18,6 +18,10 @@ export type DispatchListResult = {
 export declare function handleDispatchCommand(ws: WebSocket, config: DaemonConfig, command: DispatchCommand): Promise<void>;
 export declare function handleQueueCommand(ws: WebSocket, config: DaemonConfig, command: QueueCommand): Promise<void>;
 export declare function dispatchListResultForCommand(config: DaemonConfig, command: DispatchListCommand): Promise<DispatchListResult>;
+export declare function remoteLoadedSessionInventory(config: DaemonConfig, machineId: string, filters?: {
+    cwd?: string;
+    agent?: string;
+}): Promise<LoadedSessionInventory[]>;
 export declare function publishRemoteCrewQueueEnqueue(config: DaemonConfig, admission: StoredDispatchAdmissionRecord): Promise<void>;
 export declare function deliverQueuedCrewAdmission(config: DaemonConfig, admission: StoredDispatchAdmissionRecord): Promise<StoredDispatchAdmissionRecord>;
 export type CrewSessionRuntimeState = {

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

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { decryptJson, dispatchRouteCandidates, encryptJson, filterDispatchRouteCandidates, parseMachineClientMessage, randomId } from "../../../../packages/shared/dist/index.js";
 import { appendAudit } from "../audit.js";
-import { sessions, sessionTurns } from "../state.js";
+import { completedCommandResponses, sessions, sessionTurns } from "../state.js";
 import { admitMachineCreateSession, admitMachineFork, admitMachinePrompt } from "../relay/admission.js";
 import { publishRemoteControllerCommand, readRetainedMachineMessage, RemoteCommandError, requestRemoteMachineResult } from "../relay/remote-command.js";
 import { claimCommandRequest, sendCommandResponse } from "../relay/send.js";
@@ -11,6 +11,11 @@ import { listArtifacts } from "../artifact/store.js";
 import { ackAttention, completeClaimedQueueAdmission, crewQueueHasBacklog, deadAttention, failClaimedQueueAdmission, findAdmissionByTask, findAdmissionByTaskAndRequest, latestAttentionForTask, listAdmissions, listAttentions, recordAdmission, recordTurnRuntimeBinding, reopenUnresolvedArtifactFeedbackAttentions, retryAttention, retryClaimedQueueAdmission, runtimeTurnIdForCrewTurn, updateAdmission, updatePendingConsumerQueueEnqueue, upsertSubscription, } from "./store.js";
 import { catchUpSubscriptionEvents } from "./watcher.js";
 export async function handleDispatchCommand(ws, config, command) {
+    // Status/list are read projections, not mutation retries. A caller may use
+    // the same correlation id while the durable admission changes; never replay
+    // the 24h mutation response cache for these reads.
+    if (command.action === "status" || command.action === "list")
+        completedCommandResponses.delete(command.requestId);
     if (!claimCommandRequest(ws, command.requestId))
         return;
     if (command.machineId !== config.machineId) {
@@ -495,6 +500,7 @@ async function applyFirstAgentRouteGate(config, consumer, command, crewMachineId
     const candidates = filterDispatchRouteCandidates([
         ...dispatchRouteCandidates(records),
         ...await artifactLineageRouteCandidates(config, command, crewMachineId),
+        ...await remoteLoadedCrewRouteCandidates(config, crewMachineId, command.cwd),
     ], {
         cwd: command.cwd,
         crewMachineId,
@@ -504,6 +510,41 @@ async function applyFirstAgentRouteGate(config, consumer, command, crewMachineId
         return { error: routeError };
     return { command: routed };
 }
+export async function remoteLoadedSessionInventory(config, machineId, filters = {}) {
+    if (!machineId || machineId === config.machineId)
+        return [];
+    const message = await requestRemoteMachineResult(config, {
+        targetMachineId: machineId,
+        expectedType: "machine:historicalSessions",
+        command: {
+            type: "controller:listHistoricalSessions",
+            requestId: randomId("req_session_inventory"),
+            machineId,
+            ...(filters.cwd ? { cwd: filters.cwd } : {}),
+            ...(filters.agent ? { agent: filters.agent } : {}),
+            limit: 200,
+        },
+        timeoutMs: 20_000,
+    });
+    return (message.loadedSessions ?? []).filter((session) => session.status !== "closed");
+}
+async function remoteLoadedCrewRouteCandidates(config, crewMachineId, cwd) {
+    const loaded = await remoteLoadedSessionInventory(config, crewMachineId, cwd ? { cwd } : {}).catch(() => []);
+    return loaded.map((session) => {
+        const busy = session.status === "running" || session.status === "waiting_for_option";
+        const checkpointId = session.currentHead ?? session.lastTurnId;
+        return {
+            crewSessionId: session.sessionId,
+            crewMachineId,
+            agent: session.agent,
+            cwd: session.cwd,
+            availability: busy ? "busy" : "idle",
+            recentTasks: [],
+            ...(busy ? { queueArgs: { crewSessionId: session.sessionId, ifBusy: "queue" } } : { reuseArgs: { crewSessionId: session.sessionId } }),
+            ...(checkpointId ? { forkArgs: { forkFromCrewSessionId: session.sessionId, forkCheckpointId: checkpointId } } : {}),
+        };
+    });
+}
 async function artifactLineageRouteCandidates(config, command, crewMachineId) {
     if (!command.taskId || !command.routeDecision || command.routeDecision.kind === "new")
         return [];
@@ -597,7 +638,12 @@ function validateRouteDecisionCandidate(decision, candidates) {
         };
     }
     if (candidate.availability !== "idle") {
-        if (decision.kind === "reuse" && decision.ifBusy === "queue" && candidate.availability === "busy")
+        // An explicit Queue Reuse decision is a durable admission strategy. A
+        // remote runtime snapshot may be temporarily unknown while the owner is
+        // reconnecting; do not turn that observation into a route rejection or
+        // pretend it is idle. The owner-side enqueue will re-check runtime truth
+        // and either retain the inbox item or fail a permanently unavailable Crew.
+        if (decision.kind === "reuse" && decision.ifBusy === "queue" && (candidate.availability === "busy" || candidate.availability === "unknown"))
             return undefined;
         if (decision.kind === "fork" && candidate.availability === "unknown") {
             return {
@@ -1211,7 +1257,22 @@ async function crewSessionProjection(config, crewMachineId, crewSessionId) {
         return session ? projectCrewSession(session, crewMachineId) : undefined;
     }
     const sessionMessage = await readRetainedMachineMessage(config, `node:${crewMachineId}:session:${crewSessionId}`).catch(() => undefined);
-    return sessionMessage ? projectRemoteCrewSession(crewMachineId, sessionMessage) : undefined;
+    if (sessionMessage)
+        return projectRemoteCrewSession(crewMachineId, sessionMessage);
+    const loaded = await remoteLoadedSessionInventory(config, crewMachineId).catch(() => []);
+    const inventory = loaded.find((session) => session.sessionId === crewSessionId);
+    if (!inventory)
+        return undefined;
+    return {
+        crewMachineId,
+        crewSessionId: inventory.sessionId,
+        agent: inventory.agent,
+        cwd: inventory.cwd,
+        name: inventory.name,
+        status: inventory.status === "running" || inventory.status === "waiting_for_option" ? "running" : "ready",
+        ...(inventory.currentHead ? { currentHead: inventory.currentHead } : {}),
+        ...(inventory.lastTurnId ? { lastTurnId: inventory.lastTurnId } : {}),
+    };
 }
 async function dispatchTaskProjection(config, admission) {
     const crewMachineId = admission.crewMachineId ?? config.machineId;

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

@@ -153,6 +153,7 @@ export declare function markCrewQueueNotificationApplied(input: {
     ownerRevision: number;
     currentRevision: number;
 }): Promise<boolean>;
+export declare function markCrewQueueNotificationDeadLetter(notificationId: string): Promise<boolean>;
 export declare function markCrewQueueNotificationAttempt(input: {
     notificationId: string;
     error: string;

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

@@ -166,6 +166,18 @@ export async function markCrewQueueNotificationApplied(input) {
     });
     return removed;
 }
+export async function markCrewQueueNotificationDeadLetter(notificationId) {
+    let removed = false;
+    await updateOrchestrationStore((current) => {
+        const index = current.queueNotifications.findIndex((record) => record.notificationId === notificationId);
+        if (index < 0)
+            return current;
+        current.queueNotifications.splice(index, 1);
+        removed = true;
+        return current;
+    });
+    return removed;
+}
 export async function markCrewQueueNotificationAttempt(input) {
     const now = new Date();
     const updatedAt = now.toISOString();

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

@@ -1,4 +1,4 @@
-import { decryptJson, parseControllerClientMessage, parseInternalControllerMessage, parseRelayServerWireMessage, randomId, } from "../../../../packages/shared/dist/index.js";
+import { decryptJson, parseControllerClientMessage, parseInternalControllerMessage, parseMachineClientMessage, parseRelayServerWireMessage, randomId, } from "../../../../packages/shared/dist/index.js";
 import { appendAudit } from "../audit.js";
 import { drainPendingArtifactFeedbackAttentions, handleArtifactCommand } from "../artifact/handler.js";
 import { handleGatewayCommand } from "../gateway/handler.js";
@@ -21,11 +21,42 @@ import { nativeImportSessionId } from "../session/native-identity.js";
 import { encryptedSessionMetadata } from "../session/metadata.js";
 import { loadSessionProjections } from "../session/store.js";
 import { relayWsUrl } from "../relay-http.js";
-import { sessions, sessionTurns } from "../state.js";
+import { applyRelayMachinePresence, applyRelayMachineSnapshot, reconcileRelayMachinePresence, relayMachineRegistry, sessions, sessionTurns } from "../state.js";
 import { handleDevExec, handleDiagnose } from "./devtools.js";
 import { handleInboundPromptCommand, recoverInboundPromptAdmissions } from "./inbound-prompt.js";
 import { registerMachine } from "./register.js";
-import { clearActiveRelaySocket, configureRelaySender, flushRelayOutbox, handleMachineMessageAck, handleRetainedPacketAck, handleRetainedPacketError, sendCommandResponse, setActiveRelaySocket, } from "./send.js";
+import { clearActiveRelaySocket, configureRelaySender, flushRelayOutbox, handleMachineMessageAck, handleMachineMessageError, handleRetainedPacketAck, handleRetainedPacketError, sendCommandResponse, setActiveRelaySocket, } from "./send.js";
+async function applyMachineManifest(config, retained, presence) {
+    try {
+        const message = parseMachineClientMessage(await decryptJson(config.accountSecret, retained.encryptedPayload));
+        if (message.type !== "machine:register")
+            return;
+        let name = retained.updatedByNodeId;
+        if (message.encryptedMetadata) {
+            const metadata = await decryptJson(config.accountSecret, message.encryptedMetadata);
+            if (typeof metadata.name === "string" && metadata.name.trim())
+                name = metadata.name.trim();
+            else if (typeof metadata.hostname === "string" && metadata.hostname.trim())
+                name = metadata.hostname.trim();
+        }
+        const previous = relayMachineRegistry.get(retained.updatedByNodeId);
+        applyRelayMachineSnapshot({
+            id: retained.updatedByNodeId,
+            name,
+            // A retained manifest describes identity/capabilities only. Preserve
+            // the authoritative presence projection when no live presence record
+            // accompanied it; never infer online from a static retained packet.
+            online: presence?.online ?? previous?.online ?? false,
+            lastSeen: presence?.lastSeen ?? previous?.lastSeen ?? retained.updatedAt,
+            capabilities: message.capabilities,
+            encryptedMetadata: message.encryptedMetadata,
+        });
+    }
+    catch {
+        // Retained manifests are encrypted account state; malformed/unrelated
+        // packets must not prevent discovery of other machines.
+    }
+}
 export async function handleServerMessage(ws, config, message) {
     if (message.type === "server:hello") {
         await registerMachine(ws, config);
@@ -186,6 +217,34 @@ async function handleRelayWireMessage(ws, config, message) {
         });
         return;
     }
+    if (message.type === "server:snapshot") {
+        for (const presence of message.presence)
+            applyRelayMachinePresence(presence);
+        reconcileRelayMachinePresence(message.presence);
+        for (const presence of message.presence) {
+            if (presence.manifest)
+                await applyMachineManifest(config, presence.manifest, presence);
+        }
+        for (const retained of message.retainedPackets) {
+            try {
+                const retainedMessage = parseMachineClientMessage(await decryptJson(config.accountSecret, retained.encryptedPayload));
+                if (retainedMessage.type === "machine:register") {
+                    await applyMachineManifest(config, retained);
+                }
+            }
+            catch {
+                // Retained packets are encrypted per account; an unrelated/invalid
+                // retained entry must not prevent presence discovery for other nodes.
+            }
+        }
+        return;
+    }
+    if (message.type === "server:presence") {
+        applyRelayMachinePresence(message.presence);
+        if (message.presence.manifest)
+            await applyMachineManifest(config, message.presence.manifest, message.presence);
+        return;
+    }
     if (message.type === "server:ack") {
         if (message.packetId)
             await handleMachineMessageAck(message.packetId);
@@ -194,6 +253,8 @@ async function handleRelayWireMessage(ws, config, message) {
         return;
     }
     if (message.type === "server:error") {
+        if (message.packetId)
+            await handleMachineMessageError(message.packetId, message.message);
         if (message.retainedKey)
             handleRetainedPacketError(message.retainedKey);
         console.error(`Relay error${message.code ? ` ${message.code}` : ""}: ${message.message}`);

package/apps/daemon/dist/relay/remote-command.js

@@ -25,6 +25,7 @@ export async function publishRemoteControllerCommand(config, input) {
     return await new Promise((resolve, reject) => {
         const ws = new WebSocket(relayWsUrl(config.relayUrl));
         let settled = false;
+        let commandSent = false;
         const timer = globalThis.setTimeout(() => {
             finish(undefined, new RemoteCommandError(`Timed out waiting for remote command ${input.command.requestId}`, "REMOTE_COMMAND_TIMEOUT"));
         }, timeoutMs);
@@ -45,6 +46,11 @@ export async function publishRemoteControllerCommand(config, input) {
                 token: config.machineToken,
                 nodeKind: "machine",
                 nodeId: config.machineId,
+                // This is an ephemeral RPC socket, not the daemon's durable command
+                // consumer. Do not replay unrelated toNode packets into it: the
+                // durable daemon connection (with its own cursor) must remain the
+                // only consumer that can acknowledge those commands.
+                cursor: Number.MAX_SAFE_INTEGER,
             }));
         });
         ws.addEventListener("error", () => {
@@ -57,6 +63,18 @@ export async function publishRemoteControllerCommand(config, input) {
                 targetMachineId: input.targetMachineId,
                 expectedType: input.expectedType,
                 send: (message) => ws.send(JSON.stringify(message)),
+                sendCommand: async (cursor) => {
+                    if (commandSent)
+                        return;
+                    commandSent = true;
+                    const subscribe = {
+                        type: "subscribe",
+                        channelId: controllerProjectionChannel,
+                        ...(cursor === undefined ? {} : { cursor }),
+                    };
+                    ws.send(JSON.stringify(subscribe));
+                    ws.send(JSON.stringify(await remoteCommandPacket(config, packetId, input.targetMachineId, input.command)));
+                },
                 finish,
             }).catch((error) => finish(undefined, error));
         });
@@ -77,8 +95,14 @@ export async function readRetainedMachineMessage(config, retainedKey) {
 async function handleRelayMessage(config, raw, context) {
     const wire = parseRelayServerWireMessage(JSON.parse(String(raw)));
     if (wire.type === "server:hello") {
-        context.send({ type: "subscribe", channelId: controllerProjectionChannel });
-        context.send(await remoteCommandPacket(config, context.packetId, context.targetMachineId, context.command));
+        // Wait for the snapshot cursor before subscribing. Short-lived RPC
+        // connections must not replay the entire product:controllers history;
+        // the snapshot cursor gives the subscription a precise lower bound while
+        // still catching packets committed between the snapshot and subscribe.
+        return;
+    }
+    if (wire.type === "server:snapshot") {
+        await context.sendCommand(wire.cursor);
         return;
     }
     if (wire.type === "server:error") {
@@ -92,7 +116,6 @@ async function handleRelayMessage(config, raw, context) {
     }
     if (wire.type !== "server:packet")
         return;
-    context.send({ type: "ackPacket", packetId: wire.packet.packetId, serverSeq: wire.packet.serverSeq });
     let message;
     try {
         message = parseMachineClientMessage(await decryptJson(config.accountSecret, wire.packet.encryptedPayload));
@@ -102,6 +125,10 @@ async function handleRelayMessage(config, raw, context) {
     }
     if (!("requestId" in message) || message.requestId !== context.command.requestId)
         return;
+    // A short-lived RPC socket can share a machine id with the durable daemon
+    // connection. Only acknowledge the response that belongs to this request;
+    // unrelated packets must remain available for the durable consumer.
+    context.send({ type: "ackPacket", packetId: wire.packet.packetId, serverSeq: wire.packet.serverSeq });
     if (message.type === "machine:error") {
         context.finish(undefined, new RemoteCommandError(message.message, message.code ?? "REMOTE_MACHINE_ERROR", false));
         return;

package/apps/daemon/dist/relay/send.d.ts

@@ -9,6 +9,7 @@ export declare function setActiveRelaySocket(ws: WebSocket): void;
 export declare function clearActiveRelaySocket(ws: WebSocket): void;
 export declare function flushRelayOutbox(): Promise<void>;
 export declare function handleMachineMessageAck(messageId: string): Promise<void>;
+export declare function handleMachineMessageError(messageId: string, error?: string): Promise<void>;
 export declare function handleRetainedPacketAck(retainedKey: string, version: number | undefined): void;
 export declare function handleRetainedPacketError(retainedKey: string): void;
 export declare function clearRelayOutboxForTests(): Promise<void>;