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

package/apps/cli/package.json

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

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

@@ -500,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,
@@ -509,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 [];
@@ -1221,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/relay/connection.js

@@ -25,7 +25,7 @@ import { applyRelayMachinePresence, applyRelayMachineSnapshot, reconcileRelayMac
 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));
@@ -253,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>;

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

@@ -32,7 +32,8 @@ let relayConfig = null;
 let outboxLoaded = false;
 let outboxLoadPromise = null;
 let outboxWritePromise = Promise.resolve();
-let flushing = false;
+let outboxDrainPromise = null;
+let outboxFlushTimer;
 const outbox = new Map();
 const directSockets = new WeakSet();
 const retainedVersions = new Map();
@@ -41,6 +42,14 @@ const transcriptWindows = new Map();
 const controllerProjectionChannel = "product:controllers";
 const retainedTranscriptWindowSize = 200;
 const retainedTranscriptMaxPayloadBytes = 650_000;
+const outboxFlushBatchSize = 32;
+const outboxInFlightWindow = 32;
+const outboxFlushBatchBytes = 4 * 1024 * 1024;
+const outboxInFlightBytes = 8 * 1024 * 1024;
+const outboxAckTimeoutMs = 15_000;
+const outboxRetryBaseMs = 1_000;
+const outboxRetryMaxMs = 30_000;
+const relayStoredTtlMs = 24 * 60 * 60 * 1000;
 export function markDirectSocket(ws) {
     directSockets.add(ws);
 }
@@ -67,24 +76,52 @@ export function configureRelaySender(config) {
 }
 export function setActiveRelaySocket(ws) {
     activeRelaySocket = ws;
+    scheduleOutboxFlush(0);
 }
 export function clearActiveRelaySocket(ws) {
-    if (activeRelaySocket === ws)
-        activeRelaySocket = null;
-}
-export async function flushRelayOutbox() {
-    await ensureOutboxLoaded();
-    if (flushing)
+    if (activeRelaySocket !== ws)
         return;
-    flushing = true;
-    try {
-        const records = [...outbox.values()].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
-        for (const record of records) {
-            await attemptSendRecord(record);
-        }
+    activeRelaySocket = null;
+    if (outboxFlushTimer) {
+        clearTimeout(outboxFlushTimer);
+        outboxFlushTimer = undefined;
     }
-    finally {
-        flushing = false;
+}
+export function flushRelayOutbox() {
+    outboxDrainPromise ??= flushRelayOutboxOnce().finally(() => {
+        outboxDrainPromise = null;
+        scheduleOutboxFlush();
+    });
+    return outboxDrainPromise;
+}
+async function flushRelayOutboxOnce() {
+    await ensureOutboxLoaded();
+    const records = [...outbox.values()].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+    const now = Date.now();
+    const inFlight = records.filter((record) => isInFlight(record, now));
+    const inFlightCount = inFlight.length;
+    const inFlightBytes = inFlight.reduce((total, record) => total + recordWireBytes(record), 0);
+    let attempted = 0;
+    let attemptedBytes = 0;
+    for (const record of records) {
+        if (attempted >= outboxFlushBatchSize)
+            break;
+        if (inFlightCount + attempted >= outboxInFlightWindow)
+            break;
+        if (record.nextAttemptAt && Date.parse(record.nextAttemptAt) > now)
+            continue;
+        const bytes = recordWireBytes(record);
+        const exceedsInFlightBudget = inFlightBytes + attemptedBytes + bytes > outboxInFlightBytes;
+        const exceedsBatchBudget = attemptedBytes + bytes > outboxFlushBatchBytes;
+        // A single record larger than a budget is allowed only when it is the
+        // sole packet in this drain. This keeps durable large projections from
+        // being stranded forever while ensuring no second packet can join it.
+        const allowOversizedSingle = attempted === 0 && inFlightCount === 0;
+        if ((exceedsInFlightBudget && !allowOversizedSingle) || (exceedsBatchBudget && !allowOversizedSingle))
+            break;
+        await attemptSendRecord(record);
+        attempted += 1;
+        attemptedBytes += bytes;
     }
 }
 export async function handleMachineMessageAck(messageId) {
@@ -92,6 +129,17 @@ export async function handleMachineMessageAck(messageId) {
     if (!outbox.delete(messageId))
         return;
     await persistOutbox();
+    scheduleOutboxFlush(0);
+}
+export async function handleMachineMessageError(messageId, error) {
+    await ensureOutboxLoaded();
+    const record = outbox.get(messageId);
+    if (!record)
+        return;
+    record.nextAttemptAt = new Date(Date.now() + retryDelayMs(record.attemptCount)).toISOString();
+    await persistOutbox();
+    await appendOutboxAudit(record, "send-failed", error);
+    scheduleOutboxFlush();
 }
 export function handleRetainedPacketAck(retainedKey, version) {
     if (version !== undefined)
@@ -101,6 +149,10 @@ export function handleRetainedPacketError(retainedKey) {
     retainedVersions.delete(retainedKey);
 }
 export async function clearRelayOutboxForTests() {
+    if (outboxFlushTimer) {
+        clearTimeout(outboxFlushTimer);
+        outboxFlushTimer = undefined;
+    }
     outbox.clear();
     outboxLoaded = true;
     outboxLoadPromise = null;
@@ -133,10 +185,13 @@ export async function sendReliable(message, ws) {
             attemptCount: 0,
         };
     if (!existing) {
-        outbox.set(record.messageId, record);
+        replaceCoalescedOutboxRecord(record);
         await persistOutbox();
     }
-    await attemptSendRecord(record, ws);
+    // All reliable messages, including live command responses, enter the same
+    // durable single-flight drain. Direct sockets remain an explicit local
+    // transport above and do not use this relay outbox.
+    await flushRelayOutbox();
     return record.message;
 }
 export async function sendCommandResponse(ws, message, options = {}) {
@@ -227,6 +282,149 @@ function withMessageId(message) {
         messageId: existing ?? `msg_${randomUUID()}`,
     };
 }
+function outboxCoalesceKey(message) {
+    if (!("sessionId" in message) || typeof message.sessionId !== "string" || !message.sessionId)
+        return undefined;
+    if (!isReplaceableProjection(message))
+        return undefined;
+    if (message.type === "machine:sessionReady")
+        return `session-ready:${message.sessionId}`;
+    if (message.type === "machine:sessionTranscriptReplaced")
+        return `session-transcript:${message.sessionId}`;
+    return undefined;
+}
+function isReplaceableProjection(message) {
+    if (message.type !== "machine:sessionReady" && message.type !== "machine:sessionTranscriptReplaced")
+        return false;
+    const requestId = "requestId" in message && typeof message.requestId === "string" ? message.requestId : undefined;
+    if (!requestId)
+        return true;
+    // These are daemon-generated retained projection refreshes, not responses
+    // to a caller. Correlated create/resume/sync responses must never be
+    // coalesced away even when they share a session id.
+    return requestId.startsWith("req_projection_refresh_") || requestId.startsWith("req_direct_projection_");
+}
+function replaceCoalescedOutboxRecord(record) {
+    const key = outboxCoalesceKey(record.message);
+    if (key) {
+        record.coalesceKey = key;
+        const now = Date.now();
+        for (const [messageId, existing] of outbox) {
+            if (messageId !== record.messageId
+                && (existing.coalesceKey ?? outboxCoalesceKey(existing.message)) === key
+                // A packet that was already sent but has not been ACKed still
+                // consumes the in-flight byte window. Keep it durable and counted;
+                // only unsent/expired projections may be replaced.
+                && !isInFlight(existing, now)) {
+                outbox.delete(messageId);
+            }
+        }
+    }
+    outbox.set(record.messageId, record);
+}
+function retryDelayMs(attemptCount) {
+    const exponent = Math.max(0, Math.min(attemptCount - 1, 5));
+    return Math.min(outboxRetryMaxMs, outboxRetryBaseMs * (2 ** exponent));
+}
+function scheduleOutboxFlush(delayOverrideMs) {
+    if (!openSocket(activeRelaySocket))
+        return;
+    if (outboxFlushTimer) {
+        clearTimeout(outboxFlushTimer);
+        outboxFlushTimer = undefined;
+    }
+    const now = Date.now();
+    const records = [...outbox.values()];
+    if (records.length === 0)
+        return;
+    const nextFlushAt = nextOutboxFlushAt(records, now);
+    // If a live in-flight window cannot fit the next record, wait for an ACK or
+    // retry deadline. Scheduling on the mere fact that some bytes remain would
+    // create a zero-delay loop while the head record is still blocked.
+    if (nextFlushAt === undefined && delayOverrideMs === undefined)
+        return;
+    const delay = delayOverrideMs ?? Math.max(0, (nextFlushAt ?? now) - now);
+    outboxFlushTimer = setTimeout(() => {
+        outboxFlushTimer = undefined;
+        void flushRelayOutbox().catch((error) => {
+            console.error(`Relay outbox flush failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    }, Math.max(0, delay));
+}
+function nextOutboxFlushAt(records, now) {
+    const sorted = [...records].sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+    const inFlight = sorted.filter((record) => isInFlight(record, now));
+    const inFlightCount = inFlight.length;
+    const inFlightBytes = inFlight.reduce((total, record) => total + recordWireBytes(record), 0);
+    let attempted = 0;
+    let attemptedBytes = 0;
+    let nextWakeAt;
+    for (const record of sorted) {
+        const dueAt = record.nextAttemptAt ? Date.parse(record.nextAttemptAt) : now;
+        if (!Number.isFinite(dueAt))
+            continue;
+        if (isInFlight(record, now)) {
+            nextWakeAt = nextWakeAt === undefined ? dueAt : Math.min(nextWakeAt, dueAt);
+            continue;
+        }
+        if (dueAt > now) {
+            nextWakeAt = nextWakeAt === undefined ? dueAt : Math.min(nextWakeAt, dueAt);
+            continue;
+        }
+        if (attempted >= outboxFlushBatchSize || inFlightCount + attempted >= outboxInFlightWindow)
+            break;
+        const bytes = recordWireBytes(record);
+        const allowOversizedSingle = attempted === 0 && inFlightCount === 0;
+        if ((inFlightBytes + attemptedBytes + bytes > outboxInFlightBytes && !allowOversizedSingle)
+            || (attemptedBytes + bytes > outboxFlushBatchBytes && !allowOversizedSingle))
+            break;
+        return now;
+    }
+    return nextWakeAt;
+}
+function isInFlight(record, now) {
+    return Boolean(record.lastAttemptAt && record.nextAttemptAt && Date.parse(record.nextAttemptAt) > now);
+}
+function recordWireBytes(record) {
+    const payloadBytes = Buffer.byteLength(JSON.stringify(record.message), "utf8");
+    const message = record.message;
+    const requestId = typeof message.requestId === "string" ? message.requestId : undefined;
+    const sessionId = typeof message.sessionId === "string" ? message.sessionId : undefined;
+    const scope = `packet:${record.messageId}`;
+    // encryptJson has fixed-size AES-GCM overhead: a 32-byte wrapped key plus
+    // tag, 12-byte nonces, and one 16-byte data tag. Base64 expands each byte
+    // deterministically, so this skeleton is the exact JSON wire size without
+    // performing encryption during scheduling.
+    const encryptedPayload = {
+        v: 1,
+        alg: "A256GCM",
+        scope,
+        key: {
+            nonce: "0".repeat(16),
+            ciphertext: "0".repeat(64),
+        },
+        data: {
+            nonce: "0".repeat(16),
+            ciphertext: "0".repeat(base64EncodedLength(payloadBytes + 16)),
+        },
+    };
+    const packet = {
+        type: "publishPacket",
+        packet: {
+            packetId: record.messageId,
+            channelId: controllerProjectionChannel,
+            ...(sessionId ? { streamId: sessionId } : {}),
+            ...(requestId ? { correlationId: requestId, idempotencyKey: requestId } : {}),
+            ttlMs: relayStoredTtlMs,
+            ackMode: "stored",
+            encryptedPayload,
+        },
+    };
+    return Buffer.byteLength(JSON.stringify(packet), "utf8");
+}
+function base64EncodedLength(byteLength) {
+    return Math.ceil(byteLength / 3) * 4;
+}
 async function ensureOutboxLoaded() {
     if (outboxLoaded)
         return;
@@ -235,6 +433,7 @@ async function ensureOutboxLoaded() {
 }
 async function loadOutbox() {
     outbox.clear();
+    let compacted = false;
     try {
         const text = await fs.readFile(relayOutboxPath, "utf8");
         for (const line of text.split(/\n/u)) {
@@ -242,7 +441,10 @@ async function loadOutbox() {
                 continue;
             const parsed = JSON.parse(line);
             if (parsed.messageId && parsed.message?.messageId === parsed.messageId) {
-                outbox.set(parsed.messageId, parsed);
+                const before = outbox.size;
+                replaceCoalescedOutboxRecord(parsed);
+                if (outbox.size < before + 1)
+                    compacted = true;
             }
         }
     }
@@ -251,6 +453,8 @@ async function loadOutbox() {
             throw error;
     }
     outboxLoaded = true;
+    if (compacted)
+        await persistOutbox();
 }
 async function persistOutbox() {
     outboxWritePromise = outboxWritePromise.then(writeOutbox, writeOutbox);
@@ -272,7 +476,12 @@ async function attemptSendRecord(record, ws) {
         return;
     }
     record.attemptCount += 1;
-    record.lastAttemptAt = new Date().toISOString();
+    const attemptedAt = Date.now();
+    record.lastAttemptAt = new Date(attemptedAt).toISOString();
+    // A stored ACK may be lost after the packet is accepted. Keep the record
+    // retryable with bounded exponential backoff instead of flooding every
+    // reconnect with the entire historical outbox.
+    record.nextAttemptAt = new Date(attemptedAt + Math.max(outboxAckTimeoutMs, retryDelayMs(record.attemptCount))).toISOString();
     await persistOutbox();
     try {
         if (directSockets.has(socket)) {
@@ -301,7 +510,7 @@ async function sendPacket(socket, payload, options) {
             channelId: controllerProjectionChannel,
             ...(sessionId ? { streamId: sessionId } : {}),
             ...(requestId ? { correlationId: requestId, idempotencyKey: requestId } : {}),
-            ttlMs: options.ackMode === "stored" ? 24 * 60 * 60 * 1000 : 10 * 60 * 1000,
+            ttlMs: options.ackMode === "stored" ? relayStoredTtlMs : 10 * 60 * 1000,
             ackMode: options.ackMode,
             encryptedPayload: await encryptJson(relayConfig.accountSecret, `packet:${options.packetId}`, payload),
         },

package/apps/daemon/dist/runtime/headless-event-projector.d.ts

@@ -5,8 +5,13 @@ export type HeadlessRuntimeEventMappingState = {
     emittedCursors: Set<string>;
     itemTypes: Map<string, ThreadItem["type"]>;
     deltaItems: Set<string>;
+    textItems: Set<string>;
+    authoritativeTextItems: Set<string>;
 };
-export declare function createHeadlessRuntimeEventMappingState(): HeadlessRuntimeEventMappingState;
+export declare function createHeadlessRuntimeEventMappingState(initial?: {
+    deltaItems?: Iterable<string>;
+    authoritativeTextItems?: Iterable<string>;
+}): HeadlessRuntimeEventMappingState;
 export declare function mapHeadlessRuntimeEvent(event: HeadlessRuntimeEvent, state?: HeadlessRuntimeEventMappingState): RuntimeEvent[];
 export declare function mapHeadlessRuntimeEventsToHistoricalEvents(runtimeEvents: HeadlessRuntimeEvent[]): RuntimeHistoricalEvent[];
 export declare function selectThreadEventsBeforeItem(client: HeadlessRuntimeClient, threadId: string, beforeItemId: string | undefined, limit: number): Promise<{

package/apps/daemon/dist/runtime/headless-event-projector.js

@@ -1,8 +1,10 @@
-export function createHeadlessRuntimeEventMappingState() {
+export function createHeadlessRuntimeEventMappingState(initial) {
     return {
         emittedCursors: new Set(),
         itemTypes: new Map(),
-        deltaItems: new Set(),
+        deltaItems: new Set(initial?.deltaItems),
+        textItems: new Set(),
+        authoritativeTextItems: new Set(initial?.authoritativeTextItems),
     };
 }
 export function mapHeadlessRuntimeEvent(event, state = createHeadlessRuntimeEventMappingState()) {
@@ -17,10 +19,17 @@ export function mapHeadlessRuntimeEvent(event, state = createHeadlessRuntimeEven
     if (event.method === "item/created") {
         if (!item)
             return [];
-        if (item.type === "agentMessage" && item.text)
+        // Some providers include a full text snapshot on item/created and then
+        // emit item/delta chunks for the same item. Prefer the deltas; emitting
+        // both makes the authoritative turn.result contain the final text twice.
+        if (item.type === "agentMessage" && item.text && !state.authoritativeTextItems.has(item.id) && !state.deltaItems.has(item.id) && item.status === "completed") {
+            state.textItems.add(item.id);
             return [{ type: "text_delta", text: item.text, stream: "output", ...itemIdentity }];
-        if (item.type === "reasoning" && item.text)
+        }
+        if (item.type === "reasoning" && item.text && !state.authoritativeTextItems.has(item.id) && !state.deltaItems.has(item.id) && item.status === "completed") {
+            state.textItems.add(item.id);
             return [{ type: "text_delta", text: item.text, stream: "thought", ...itemIdentity }];
+        }
         return toolEventsFromItem(item);
     }
     if (event.method === "item/delta") {
@@ -28,6 +37,8 @@ export function mapHeadlessRuntimeEvent(event, state = createHeadlessRuntimeEven
         if (!delta)
             return [];
         const itemId = typeof event.itemId === "string" ? event.itemId : typeof params.itemId === "string" ? params.itemId : undefined;
+        if (itemId && state.authoritativeTextItems.has(itemId))
+            return [];
         if (itemId)
             state.deltaItems.add(itemId);
         const type = itemId ? state.itemTypes.get(itemId) : undefined;
@@ -37,10 +48,16 @@ export function mapHeadlessRuntimeEvent(event, state = createHeadlessRuntimeEven
         if (!item)
             return [];
         if (item.type === "agentMessage") {
-            return state.deltaItems.has(item.id) || !item.text ? [] : [{ type: "text_delta", text: item.text, stream: "output", ...itemIdentity }];
+            if ((!state.authoritativeTextItems.has(item.id) && (state.deltaItems.has(item.id) || state.textItems.has(item.id))) || !item.text)
+                return [];
+            state.textItems.add(item.id);
+            return [{ type: "text_delta", text: item.text, stream: "output", ...itemIdentity }];
         }
         if (item.type === "reasoning") {
-            return state.deltaItems.has(item.id) || !item.text ? [] : [{ type: "text_delta", text: item.text, stream: "thought", ...itemIdentity }];
+            if ((!state.authoritativeTextItems.has(item.id) && (state.deltaItems.has(item.id) || state.textItems.has(item.id))) || !item.text)
+                return [];
+            state.textItems.add(item.id);
+            return [{ type: "text_delta", text: item.text, stream: "thought", ...itemIdentity }];
         }
         return toolEventsFromItem(item);
     }
@@ -303,8 +320,17 @@ export async function selectThreadEventsAfterItem(client, threadId, afterItemId,
     };
 }
 export function historicalEventsFromRuntimeEvents(runtimeEvents) {
-    const state = createHeadlessRuntimeEventMappingState();
+    const deltaItemIds = runtimeEvents
+        .filter((event) => event.method === "item/delta")
+        .map((event) => logicalItemIdFromHeadlessEvent(event))
+        .filter((itemId) => Boolean(itemId));
     const completedTextItemIds = completedTextItemIdsFromRuntimeEvents(runtimeEvents);
+    const state = createHeadlessRuntimeEventMappingState({
+        // If a completed item snapshot is present, it is authoritative even when
+        // the bounded history page also contains partial deltas for that item.
+        deltaItems: deltaItemIds.filter((itemId) => !completedTextItemIds.has(itemId)),
+        authoritativeTextItems: completedTextItemIds,
+    });
     const events = [];
     const userPromptKeys = new Set();
     const addEvent = (event) => {

package/apps/daemon/dist/session/he-official/common.d.ts

@@ -200,6 +200,7 @@ export declare function messageResult(message: MachineClientMessage | undefined,
             requestId: string;
             machineId: string;
             sessions: import("../../../../../packages/shared/dist/index.js").HistoricalSessionSnapshot[];
+            loadedSessions?: import("../../../../../packages/shared/dist/index.js").LoadedSessionInventory[];
             hasMore?: boolean;
             nextCursor?: string;
             warnings?: import("../../../../../packages/shared/dist/index.js").HistoricalSessionWarning[];

package/apps/daemon/dist/session/he-official/orchestration-commands.d.ts

@@ -1,4 +1,4 @@
-import { type DispatchRouteDecision, type DispatchTaskProjection, type HeOfficialToolResult, type TaskAttentionStatus } from "../../../../../packages/shared/dist/index.js";
+import { type DispatchRouteDecision, type DispatchTaskProjection, type HeOfficialToolResult, type LoadedSessionInventory, type TaskAttentionStatus } from "../../../../../packages/shared/dist/index.js";
 import { type CommandHandlerInput } from "./common.js";
 export declare function dispatchRun(input: CommandHandlerInput): Promise<HeOfficialToolResult>;
 export declare function dispatchStatus(input: CommandHandlerInput): Promise<HeOfficialToolResult>;
@@ -13,6 +13,7 @@ export type FirstAgentDispatchListProjectionLimits = {
     maxRecentTasks?: number;
     recordBriefMax?: number;
     recentTaskBriefMax?: number;
+    remoteLoadedSessions?: LoadedSessionInventory[];
 };
 export declare function firstAgentDispatchListProjection(data: {
     action: "list";
@@ -30,7 +31,7 @@ export declare function firstAgentDispatchListProjection(data: {
         crewMachineId: string | undefined;
         agent: string | undefined;
         cwd: string | undefined;
-        availability: "unknown" | "idle" | "busy";
+        availability: "unknown" | "busy" | "idle";
         updatedAt: string | undefined;
         reuseArgs: {
             crewSessionId: string;