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

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.487",
   "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.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) {
@@ -597,7 +602,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 {

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";
+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);

package/apps/daemon/dist/runtime/headless-manager.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { createHeadlessRuntimeClient, createHostedHeadlessRuntimeClient, ensureHeadlessRuntimeHost, resolveHeadlessRuntimeHostPaths, } from "../../../../packages/headless-runtime/dist/index.js";
@@ -44,7 +45,7 @@ export class HeadlessRuntimeManager {
     async invalidateClientForBinding(binding, cwd = this.options.defaultCwd) {
         if (!isDaemonHeadlessProvider(binding.provider))
             return;
-        const resolvedCwd = path.resolve(cwd);
+        const resolvedCwd = canonicalWorkspacePath(cwd);
         const hostOptions = this.hostOptions(binding.provider, resolvedCwd, binding.profile);
         const hostPaths = resolveHeadlessRuntimeHostPaths(hostOptions);
         const key = `${binding.provider}\0${hostPaths.profile}\0${resolvedCwd}`;
@@ -66,7 +67,7 @@ export class HeadlessRuntimeManager {
         if (!this.enabledProviders().includes(normalizedProvider)) {
             throw providerConfigError(`Headless Runtime provider ${normalizedProvider} is not enabled.`, "PROVIDER_NOT_ENABLED");
         }
-        const resolvedCwd = path.resolve(cwd);
+        const resolvedCwd = canonicalWorkspacePath(cwd);
         const hostOptions = this.hostOptions(normalizedProvider, resolvedCwd, profileOverride);
         const hostPaths = resolveHeadlessRuntimeHostPaths(hostOptions);
         const key = `${normalizedProvider}\0${hostPaths.profile}\0${resolvedCwd}`;
@@ -168,7 +169,7 @@ export class HeadlessRuntimeManager {
         const entry = await this.clientForProvider(provider, cwd);
         const catalog = await entry.client.listModels({ provider: entry.runtimeProvider, cwd }).catch(() => undefined);
         const base = baseProviderProfile(provider);
-        const models = catalog?.models
+        const catalogModels = catalog?.models
             ?.map((model) => ({
             id: model.id,
             ...(model.label ? { label: model.label } : {}),
@@ -186,6 +187,13 @@ export class HeadlessRuntimeManager {
                 : {}),
             ...(model.defaultThinkingLevel ? { defaultThinkingLevel: model.defaultThinkingLevel } : {}),
         })) ?? [];
+        // Some provider/app-server versions expose the effective default only as a
+        // scalar and omit it from the selectable array. Keep the actual default
+        // visible to Web/CLI without inventing a model name (for example a newer
+        // Astra build on a machine whose catalog is older).
+        const models = catalog?.defaultModel && !catalogModels.some((model) => model.id === catalog.defaultModel)
+            ? [...catalogModels, { id: catalog.defaultModel }]
+            : catalogModels;
         const thinkingLevels = catalog?.thinkingLevels
             ?.map((level) => ({
             id: level.id,
@@ -236,7 +244,34 @@ export class HeadlessRuntimeManager {
     }
 }
 function hashPath(input) {
-    return createHash("sha256").update(path.resolve(input)).digest("hex").slice(0, 16);
+    return createHash("sha256").update(canonicalWorkspacePath(input)).digest("hex").slice(0, 16);
+}
+/**
+ * Workspace identity must be stable across filesystem aliases. On macOS
+ * `/private/tmp` and `/tmp` are the same directory; on Windows realpath also
+ * normalizes drive and reparse-point aliases. Keep the absolute fallback for
+ * a not-yet-created leaf, while canonicalizing the existing parent.
+ */
+function canonicalWorkspacePath(input) {
+    const resolved = path.resolve(input);
+    try {
+        return realpathSync.native(resolved);
+    }
+    catch {
+        let current = resolved;
+        const suffix = [];
+        while (current !== path.dirname(current)) {
+            try {
+                const canonical = realpathSync.native(current);
+                return path.join(canonical, ...suffix.reverse());
+            }
+            catch {
+                suffix.push(path.basename(current));
+                current = path.dirname(current);
+            }
+        }
+        return resolved;
+    }
 }
 function headlessRuntimeProviderForDaemon(provider) {
     return provider === "pie" ? "command" : provider;

package/apps/daemon/dist/runtime/headless-session-history.js

@@ -37,8 +37,19 @@ export async function listHeadlessHistoricalSessions(input) {
     const cursorBuffer = effectiveCursor?.buffer
         ? await boundedCursorBuffer(effectiveCursor.buffer, cwd, input.agent, input.includeArchived, providers)
         : [];
-    if (providers.length === 0)
+    if (providers.length === 0) {
+        if (input.agent) {
+            return {
+                sessions: [],
+                warnings: [{
+                        provider: input.agent,
+                        code: "unconfigured",
+                        message: `Provider ${input.agent} is not enabled on this daemon; no native history was queried.`,
+                    }],
+            };
+        }
         return { sessions: [] };
+    }
     const states = new Map();
     const warnings = [];
     for (const provider of providers) {
@@ -230,6 +241,12 @@ function historicalSessionFromThread(thread, provider) {
         updatedAt: thread.updatedAt,
         runtimeState: thread.archived ? "archived" : "available",
         ...(thread.name ? { name: thread.name, runtimeSessionName: thread.name } : { runtimeSessionName: thread.id }),
+        ...(typeof thread.providerMetadata?.nativeIdentity === "string" && thread.providerMetadata.nativeIdentity.trim()
+            ? { nativeIdentity: thread.providerMetadata.nativeIdentity.trim() }
+            : {}),
+        ...(typeof thread.providerMetadata?.nativeHistoryVersion === "string" && thread.providerMetadata.nativeHistoryVersion.trim()
+            ? { nativeHistoryVersion: thread.providerMetadata.nativeHistoryVersion.trim() }
+            : {}),
     };
 }
 function nativeHistoricalSessionFromSummary(session, provider, profile, nativeDataRootFingerprint, machineId) {
@@ -446,6 +463,8 @@ function bufferedSessionFromUnknown(value) {
         ...(typeof record.runtimeSessionName === "string" ? { runtimeSessionName: record.runtimeSessionName } : {}),
         ...(record.historyStatus === "available" || record.historyStatus === "unsupported" || record.historyStatus === "unconfigured" || record.historyStatus === "permission-denied" ? { historyStatus: record.historyStatus } : {}),
         ...(typeof record.capabilityMessage === "string" ? { capabilityMessage: record.capabilityMessage } : {}),
+        ...(typeof record.nativeIdentity === "string" ? { nativeIdentity: record.nativeIdentity } : {}),
+        ...(typeof record.nativeHistoryVersion === "string" ? { nativeHistoryVersion: record.nativeHistoryVersion } : {}),
     };
 }
 async function boundedCursorBuffer(buffer, cwd, requestedAgent, includeArchived, providers) {

package/apps/daemon/dist/session/he-official/artifact-commands.js

@@ -195,7 +195,7 @@ export async function artifactList(input) {
         ...(stringArg(input.args, "taskId") ? { taskId: stringArg(input.args, "taskId") } : {}),
     };
     const message = machineId === input.config.machineId
-        ? await runMachineHandler(input.config, requestId, async (ws) => await handleArtifactCommand(ws, input.config, { ...command, type: "machine:artifact" }))
+        ? await runMachineHandler(input.config, requestId, async (ws) => await handleArtifactCommand(ws, input.config, { ...command, type: "machine:artifact" }), { cacheResponse: false })
         : await requestRemoteMachineResult(input.config, { targetMachineId: machineId, expectedType: "machine:artifactResult", command, timeoutMs: 20_000 }).catch((error) => ({
             type: "machine:error",
             requestId,
@@ -211,8 +211,9 @@ export async function artifactStatus(input) {
     const artifactId = stringArg(input.args, "artifactId");
     if (!artifactId)
         return missingArg("artifact.status", "artifactId");
-    const localProjection = await localArtifactStatus({ artifactId });
-    const producerMachineId = stringArg(input.args, "producerMachineId") ?? stringArg(input.args, "machineId") ?? localProjection?.producerMachineId ?? input.config.machineId;
+    const requestedProducerMachineId = stringArg(input.args, "producerMachineId") ?? stringArg(input.args, "machineId");
+    const localProjection = await localArtifactStatus({ artifactId, ...(requestedProducerMachineId ? { producerMachineId: requestedProducerMachineId } : {}) });
+    const producerMachineId = requestedProducerMachineId ?? localProjection?.producerMachineId ?? input.config.machineId;
     const requestId = readArtifactRequestId("artifact.status", input.args);
     const command = {
         type: "controller:artifact",
@@ -223,7 +224,7 @@ export async function artifactStatus(input) {
         artifactId,
     };
     const message = producerMachineId === input.config.machineId
-        ? await runMachineHandler(input.config, requestId, async (ws) => await handleArtifactCommand(ws, input.config, { ...command, type: "machine:artifact" }))
+        ? await runMachineHandler(input.config, requestId, async (ws) => await handleArtifactCommand(ws, input.config, { ...command, type: "machine:artifact" }), { cacheResponse: false })
         : await requestRemoteMachineResult(input.config, { targetMachineId: producerMachineId, expectedType: "machine:artifactResult", command, timeoutMs: 20_000 }).catch((error) => ({
             type: "machine:error",
             requestId,
@@ -239,8 +240,9 @@ export async function artifactFeedbackList(input) {
     const artifactId = stringArg(input.args, "artifactId");
     if (!artifactId)
         return missingArg("artifact.feedback.list", "artifactId");
-    const localProjection = await localArtifactStatus({ artifactId });
-    const producerMachineId = stringArg(input.args, "producerMachineId") ?? stringArg(input.args, "machineId") ?? localProjection?.producerMachineId ?? input.config.machineId;
+    const requestedProducerMachineId = stringArg(input.args, "producerMachineId") ?? stringArg(input.args, "machineId");
+    const localProjection = await localArtifactStatus({ artifactId, ...(requestedProducerMachineId ? { producerMachineId: requestedProducerMachineId } : {}) });
+    const producerMachineId = requestedProducerMachineId ?? localProjection?.producerMachineId ?? input.config.machineId;
     const requestId = readArtifactRequestId("artifact.feedback.list", input.args);
     const command = {
         type: "controller:artifact",
@@ -252,7 +254,7 @@ export async function artifactFeedbackList(input) {
         ...(stringArg(input.args, "after") ? { after: stringArg(input.args, "after") } : {}),
     };
     const message = producerMachineId === input.config.machineId
-        ? await runMachineHandler(input.config, requestId, async (ws) => await handleArtifactCommand(ws, input.config, { ...command, type: "machine:artifact" }))
+        ? await runMachineHandler(input.config, requestId, async (ws) => await handleArtifactCommand(ws, input.config, { ...command, type: "machine:artifact" }), { cacheResponse: false })
         : await requestRemoteMachineResult(input.config, { targetMachineId: producerMachineId, expectedType: "machine:artifactResult", command, timeoutMs: 20_000 }).catch((error) => ({
             type: "machine:error",
             requestId,