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

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.489",
   "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/paths.d.ts

@@ -2,6 +2,7 @@ export declare const configDir: string;
 export declare const configPath: string;
 export declare const auditLogPath: string;
 export declare const relayOutboxPath: string;
+export declare const relayRetainedOutboxPath: string;
 export declare const inboundPromptAdmissionStorePath: string;
 export declare const sessionProjectionStorePath: string;
 export declare const loopStorePath: string;

package/apps/daemon/dist/paths.js

@@ -7,6 +7,7 @@ export const configDir = process.env.HAPPY_ELVES_HOME
 export const configPath = path.join(configDir, "daemon.json");
 export const auditLogPath = path.join(configDir, "audit.jsonl");
 export const relayOutboxPath = path.join(configDir, "outbox.jsonl");
+export const relayRetainedOutboxPath = path.join(configDir, "retained-outbox.jsonl");
 export const inboundPromptAdmissionStorePath = path.join(configDir, "inbound-prompt-admissions.json");
 export const sessionProjectionStorePath = path.join(configDir, "sessions.json");
 export const loopStorePath = path.join(configDir, "loops.json");

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>;