@cydm/happy-elves 0.1.0-beta.312 → 0.1.0-beta.313

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

@@ -4,15 +4,19 @@ import { handleAccount } from "./account.js";
 import { handleCollect } from "./collect.js";
 import { handleConfig } from "./config.js";
 import { handleDaemon } from "./daemon.js";
+import { handleDispatch } from "./dispatch.js";
+import { handleArtifact } from "./artifact.js";
 import { handleGateway } from "./gateway.js";
 import { handleLoop } from "./loop.js";
 import { handleMachine } from "./machine.js";
 import { handleMemory } from "./memory.js";
+import { handleQueue } from "./queue.js";
 import { handleRelay } from "./relay.js";
 import { handleRelease } from "./release.js";
 import { handleSchedule } from "./schedule.js";
 import { handleRemote } from "./remote.js";
 import { handleSession } from "./session.js";
+import { handleSidechat } from "./sidechat.js";
 import { handleToken } from "./token.js";
 import { handleTurn } from "./turn.js";
 import { handleWorkspace } from "./workspace.js";
@@ -25,6 +29,10 @@ const domainHandlers = [
     handleToken,
     handleGateway,
     handleLoop,
+    handleDispatch,
+    handleQueue,
+    handleArtifact,
+    handleSidechat,
     handleDaemon,
     handleRelay,
     handleRelease,

package/apps/cli/dist/commands/artifact.d.ts

@@ -0,0 +1,2 @@
+import type { CommandInput } from "./command.js";
+export declare function handleArtifact({ domain, action, positional, flags }: CommandInput): Promise<boolean>;

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

@@ -0,0 +1,97 @@
+import { CliError, ControllerClient, ok, readConfig, requirePositional, requireString, wantsJson, } from "./lib/index.js";
+export async function handleArtifact({ domain, action, positional, flags }) {
+    if (domain !== "artifact")
+        return false;
+    const config = await readConfig(flags);
+    const client = new ControllerClient(config);
+    if (action === "register") {
+        const machineId = requireString(flags, "machine");
+        const consumerSessionId = requireString(flags, "consumer-session");
+        const file = requireString(flags, "file");
+        const publish = typeof flags.publish === "string" ? flags.publish : undefined;
+        if (publish !== undefined && publish !== "relay") {
+            throw new CliError(`Unsupported --publish value: ${publish}`, "INVALID_ARGUMENT");
+        }
+        const result = await client.artifactRegister({
+            machineId,
+            consumerSessionId,
+            file,
+            ...(typeof flags["artifact-id"] === "string" ? { artifactId: flags["artifact-id"] } : {}),
+            ...(typeof flags["task-id"] === "string" ? { taskId: flags["task-id"] } : {}),
+            ...(typeof flags["crew-session"] === "string" ? { crewSessionId: flags["crew-session"] } : {}),
+            ...(typeof flags["turn-id"] === "string" ? { turnId: flags["turn-id"] } : {}),
+            ...(typeof flags.title === "string" ? { title: flags.title } : {}),
+            ...(typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}),
+            ...(publish === "relay" ? { publish: "relay" } : {}),
+        });
+        if (!wantsJson(flags)) {
+            console.log(`${result.artifactId}  rev:${result.revision}  ${result.admission}/${result.publishState}  ${result.url}`);
+            if (result.publishState === "failed")
+                process.exitCode = 1;
+            return true;
+        }
+        ok("artifact.register", result, { requestId: result.requestId, machineId }, result.publishState !== "failed");
+        if (result.publishState === "failed")
+            process.exitCode = 1;
+        return true;
+    }
+    if (action === "list") {
+        const machineId = requireString(flags, "machine");
+        const result = await client.artifactList({
+            machineId,
+            ...(typeof flags["consumer-session"] === "string" ? { consumerSessionId: flags["consumer-session"] } : {}),
+            ...(typeof flags["task-id"] === "string" ? { taskId: flags["task-id"] } : {}),
+            ...(typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}),
+        });
+        if (!wantsJson(flags)) {
+            if (result.records.length === 0)
+                console.log("No artifacts.");
+            else
+                for (const record of result.records) {
+                    console.log(`${record.artifactId}  rev:${record.revision}  ${record.publishState}  consumer:${record.consumerSessionId}  task:${record.taskId ?? "-"}`);
+                }
+            return true;
+        }
+        ok("artifact.list", result, { requestId: result.requestId, machineId });
+        return true;
+    }
+    if (action === "status") {
+        const machineId = requireString(flags, "machine");
+        const artifactId = requirePositional(positional[0], "artifactId");
+        const result = await client.artifactStatus({
+            machineId,
+            artifactId,
+            ...(typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}),
+        });
+        if (!wantsJson(flags)) {
+            const artifact = result.artifact;
+            console.log(artifact ? `${artifact.artifactId}  rev:${artifact.revision}  ${artifact.publishState}  feedback:${artifact.feedbackCursor ?? "-"}` : "Artifact not found.");
+            return true;
+        }
+        ok("artifact.status", result, { requestId: result.requestId, machineId });
+        return true;
+    }
+    if (action === "feedback" && positional[0] === "list") {
+        const machineId = requireString(flags, "machine");
+        const artifactId = requirePositional(positional[1], "artifactId");
+        const result = await client.artifactFeedbackList({
+            machineId,
+            artifactId,
+            ...(typeof flags.after === "string" ? { after: flags.after } : {}),
+            ...(typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}),
+        });
+        if (!wantsJson(flags)) {
+            if (result.records.length === 0)
+                console.log("No feedback.");
+            else
+                for (const record of result.records) {
+                    console.log(`${record.feedbackCursor}  ${record.kind}  rev:${record.revision}  ${record.prompt}`);
+                }
+            return true;
+        }
+        ok("artifact.feedback.list", result, { requestId: result.requestId, machineId });
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=artifact.js.map

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

@@ -1,6 +1,6 @@
 import os from "node:os";
 import path from "node:path";
-import { CliError, compactText, ControllerClient, configDir, configPath, daemonPidPath, deriveOrchestration, ensureDaemonRunning, idleSessionStatuses, localDaemonStatus, ok, parsePairingClaimResponse, randomId, readConfig, readDaemonConfig, readLocalAuditLog, readRelayJson, redactedDaemonConfig, requirePositional, requireRelayUrl, requireString, restartDaemonForNewConfig, showMachine, spawnDaemonStart, stopLocalDaemon, throwRelayHttpError, waitForMachineProjection, wantsJson, writeDaemonConfig } from "./lib/index.js";
+import { CliError, compactText, ControllerClient, configDir, configPath, deriveOrchestration, ensureDaemonRunning, idleSessionStatuses, localDaemonStatus, ok, parsePairingClaimResponse, randomId, readConfig, readDaemonConfig, readLocalAuditLog, readRelayJson, redactedDaemonConfig, requirePositional, requireRelayUrl, requireString, restartDaemonForNewConfig, showMachine, stopLocalDaemon, throwRelayHttpError, waitForMachineProjection, wantsJson, writeDaemonConfig } from "./lib/index.js";
 export async function handleDaemon({ domain, action, flags }) {
     if (domain === "daemon" && action === "pair") {
         const relayUrl = requireRelayUrl(flags);
@@ -205,10 +205,10 @@ export async function handleDaemon({ domain, action, flags }) {
             ok("daemon.start", { ...status, started: false });
             return true;
         }
-        await readDaemonConfig();
-        const startArgs = typeof flags.relay === "string" ? ["--relay", flags.relay] : [];
-        const pid = spawnDaemonStart(startArgs);
-        ok("daemon.start", { pid, pidPath: daemonPidPath, started: true });
+        const daemonConfig = await readDaemonConfig();
+        const relayUrl = typeof flags.relay === "string" ? requireRelayUrl(flags) : daemonConfig.relayUrl;
+        const started = await ensureDaemonRunning(relayUrl);
+        ok("daemon.start", { ...started.local, started: started.started, startedPid: started.startedPid, startupLogPath: path.join(configDir, "daemon.startup.log") });
         return true;
     }
     if (domain === "daemon" && action === "stop") {
@@ -216,11 +216,10 @@ export async function handleDaemon({ domain, action, flags }) {
         return true;
     }
     if (domain === "daemon" && action === "restart") {
-        await readDaemonConfig();
-        const stop = await stopLocalDaemon();
-        const startArgs = typeof flags.relay === "string" ? ["--relay", flags.relay] : [];
-        const pid = spawnDaemonStart(startArgs);
-        ok("daemon.restart", { stop, startedPid: pid, pidPath: daemonPidPath });
+        const daemonConfig = await readDaemonConfig();
+        const relayUrl = typeof flags.relay === "string" ? requireRelayUrl(flags) : daemonConfig.relayUrl;
+        const restarted = await restartDaemonForNewConfig(relayUrl);
+        ok("daemon.restart", { stop: restarted.stopped, ...restarted.local, startedPid: restarted.startedPid, startupLogPath: path.join(configDir, "daemon.startup.log") });
         return true;
     }
     if (domain === "daemon" && action === "status" && flags.local === true) {

package/apps/cli/dist/commands/dispatch.d.ts

@@ -0,0 +1,2 @@
+import type { CommandInput } from "./command.js";
+export declare function handleDispatch({ domain, action, positional, flags }: CommandInput): Promise<boolean>;

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

@@ -0,0 +1,130 @@
+import { CliError, ControllerClient, ok, parsePermissionMode, readConfig, readPromptTextFile, requirePositional, requireString, wantsJson, } from "./lib/index.js";
+export async function handleDispatch({ domain, action, positional, flags }) {
+    if (domain !== "dispatch")
+        return false;
+    const config = await readConfig(flags);
+    const client = new ControllerClient(config);
+    if (action === "run") {
+        const machineId = requireString(flags, "machine");
+        const consumerSessionId = requireString(flags, "consumer-session");
+        const agent = requireString(flags, "agent");
+        const cwd = requireString(flags, "cwd");
+        const briefFile = requireString(flags, "brief-file");
+        const brief = await readPromptTextFile(briefFile);
+        if (!brief.trim())
+            throw new CliError("--brief-file is empty", "MISSING_ARGUMENT");
+        if (typeof flags["crew-session"] === "string" && typeof flags["fork-from-crew"] === "string") {
+            throw new CliError("--crew-session and --fork-from-crew are mutually exclusive", "INVALID_ARGUMENT");
+        }
+        const routeDecision = routeDecisionFromFlags(flags);
+        const permissionMode = parsePermissionMode(flags["permission-mode"] ?? flags.permission);
+        const result = await client.dispatchRun({
+            machineId,
+            consumerSessionId,
+            agent,
+            cwd,
+            brief,
+            ...(typeof flags["task-id"] === "string" ? { taskId: flags["task-id"] } : {}),
+            ...(typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}),
+            ...(typeof flags["crew-session"] === "string" ? { crewSessionId: flags["crew-session"] } : {}),
+            ...(typeof flags["fork-from-crew"] === "string" ? { forkFromCrewSessionId: flags["fork-from-crew"] } : {}),
+            ...(typeof flags["fork-checkpoint"] === "string" ? { forkCheckpointId: flags["fork-checkpoint"] } : {}),
+            ...(routeDecision ? { routeDecision } : {}),
+            ...(permissionMode ? { permissionMode } : {}),
+            ...(typeof flags.model === "string" ? { model: flags.model } : {}),
+            ...(typeof flags["thinking-level"] === "string" ? { thinkingLevel: flags["thinking-level"] } : {}),
+            subscribe: flags.subscribe !== false,
+        });
+        if (!wantsJson(flags)) {
+            console.log(`${result.taskId}  ${result.admission}/${result.dispatch}  owner:${result.consumerMachineId ?? "-"}  crewMachine:${result.crewMachineId ?? machineId}  crew:${result.crewSessionId ?? "-"}  turn:${result.turnId ?? "-"}`);
+            return true;
+        }
+        ok("dispatch.run", result, {
+            requestId: result.requestId,
+            machineId: result.consumerMachineId ?? machineId,
+            consumerMachineId: result.consumerMachineId ?? machineId,
+            crewMachineId: result.crewMachineId ?? machineId,
+            sessionId: result.crewSessionId,
+            turnId: result.turnId,
+        }, result.dispatch !== "failed");
+        return true;
+    }
+    if (action === "status") {
+        const machineId = requireString(flags, "machine");
+        const taskId = requirePositional(positional[0], "taskId");
+        const result = await client.dispatchStatus({
+            machineId,
+            taskId,
+            ...(typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}),
+        });
+        if (!wantsJson(flags)) {
+            const admission = result.admission;
+            const attention = result.attention;
+            console.log(`${result.taskId}  admission:${admission?.admission ?? "-"}  dispatch:${admission?.dispatch ?? "-"}  attention:${attention?.status ?? "-"}`);
+            return true;
+        }
+        ok("dispatch.status", result, { requestId: result.requestId, machineId });
+        return true;
+    }
+    if (action === "list") {
+        const machineId = requireString(flags, "machine");
+        const result = await client.dispatchList({
+            machineId,
+            ...(typeof flags["consumer-session"] === "string" ? { consumerSessionId: flags["consumer-session"] } : {}),
+            ...(typeof flags["request-id"] === "string" ? { requestId: flags["request-id"] } : {}),
+        });
+        if (!wantsJson(flags)) {
+            for (const record of result.records) {
+                const attention = record.attention;
+                const reason = attention?.reasons.at(-1) ?? record.error ?? record.briefPreview ?? "";
+                console.log([
+                    record.taskId,
+                    `dispatch:${record.dispatch}`,
+                    `attention:${attention?.status ?? "-"}`,
+                    `crew:${record.crewSessionId ?? "-"}`,
+                    reason ? `reason:${reason}` : "",
+                ].filter(Boolean).join("  "));
+            }
+            return true;
+        }
+        ok("dispatch.list", result, { requestId: result.requestId, machineId });
+        return true;
+    }
+    return false;
+}
+function routeDecisionFromFlags(flags) {
+    const raw = flags["route-decision"];
+    const ifBusy = flags["if-busy"];
+    if (ifBusy !== undefined && ifBusy !== "queue") {
+        throw new CliError("--if-busy must be queue", "INVALID_ARGUMENT");
+    }
+    if (typeof raw !== "string") {
+        if (ifBusy === "queue" && typeof flags["crew-session"] === "string" && typeof flags["fork-from-crew"] !== "string") {
+            return { kind: "reuse", crewSessionId: flags["crew-session"], ifBusy };
+        }
+        if (ifBusy === "queue")
+            throw new CliError("--if-busy queue requires --crew-session or --route-decision reuse", "INVALID_ARGUMENT");
+        return undefined;
+    }
+    if (raw === "new") {
+        if (ifBusy === "queue")
+            throw new CliError("--if-busy queue is only valid with --route-decision reuse", "INVALID_ARGUMENT");
+        return { kind: "new" };
+    }
+    if (raw === "reuse") {
+        const crewSessionId = requireString(flags, "crew-session");
+        return { kind: "reuse", crewSessionId, ...(ifBusy === "queue" ? { ifBusy } : {}) };
+    }
+    if (ifBusy === "queue")
+        throw new CliError("--if-busy queue is only valid with --route-decision reuse", "INVALID_ARGUMENT");
+    if (raw === "fork") {
+        const crewSessionId = requireString(flags, "fork-from-crew");
+        return {
+            kind: "fork",
+            crewSessionId,
+            ...(typeof flags["fork-checkpoint"] === "string" ? { forkCheckpointId: flags["fork-checkpoint"] } : {}),
+        };
+    }
+    throw new CliError("--route-decision must be one of new, reuse, or fork", "INVALID_ARGUMENT");
+}
+//# sourceMappingURL=dispatch.js.map

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

@@ -2,21 +2,28 @@ import { parseFlags as parseSharedFlags } from "../../../../../packages/shared/d
 import { CliError } from "../../errors.js";
 const valueFlags = new Set([
     "agent",
+    "account",
     "app-id",
+    "artifact-id",
     "at",
     "channel",
     "code",
     "conversation",
+    "consumer-session",
     "cron",
     "controller",
+    "crew-session",
     "cwd",
     "date",
     "device-id",
     "device-name",
+    "brief-file",
     "every-ms",
     "execution",
+    "file",
     "from",
     "host",
+    "if-busy",
     "domain",
     "invite-secret",
     "inbound",
@@ -33,6 +40,7 @@ const valueFlags = new Set([
     "memory-top-n",
     "name",
     "model",
+    "thinking-level",
     "mode",
     "output",
     "path",
@@ -40,18 +48,20 @@ const valueFlags = new Set([
     "permission",
     "permission-mode",
     "profile",
+    "prefix",
     "project",
+    "publish",
     "query",
     "prompt",
     "prompt-file",
     "every",
     "reason",
+    "request-id",
     "release-tag",
     "reaction-emoji",
     "relay",
+    "route-decision",
     "root",
-    "runtime-limit",
-    "runtime-session",
     "shell",
     "actions",
     "ack-timeout",
@@ -65,16 +75,23 @@ const valueFlags = new Set([
     "session",
     "secret",
     "since",
+    "slot",
+    "slot-secret",
     "source",
+    "status",
+    "stream",
     "stop-on",
+    "strategy",
     "tail",
     "tag",
     "tags",
+    "task-id",
     "text",
     "text-file",
     "timeout",
     "timeout-ms",
     "timezone",
+    "through",
     "wait-timeout-ms",
     "inactivity-timeout",
     "runtime-timeout",
@@ -84,7 +101,9 @@ const valueFlags = new Set([
     "title",
     "url",
     "turn",
+    "turn-id",
     "until",
+    "import-token",
     "reviewer-tag",
     "dogfood-tag",
 ]);
@@ -107,11 +126,15 @@ const booleanFlags = new Set([
     "no-open",
     "no-start",
     "no-wait",
+    "preserve-secret",
     "repair-head",
+    "skip-local-daemon",
     "strict",
     "summary",
+    "subscribe",
     "verbose",
     "wait",
+    "decode",
     "manual",
 ]);
 const knownFlags = new Set([...valueFlags, ...booleanFlags]);

package/apps/cli/dist/commands/lib/bootstrap-daemon.js

@@ -1,5 +1,6 @@
+import path from "node:path";
 import { CliError } from "../../errors.js";
-import { startDaemonTimeoutMs } from "./paths.js";
+import { configDir, startDaemonTimeoutMs } from "./paths.js";
 import { readDaemonConfig } from "./config.js";
 import { daemonBinaryUpdatedAfterStart, daemonConfigUpdatedAfterStart, localDaemonStatus, spawnDaemonStart, stopLocalDaemon } from "./local-daemon.js";
 export async function ensureDaemonRunning(relayUrl, cwd = process.cwd()) {
@@ -19,9 +20,15 @@ export async function ensureDaemonRunning(relayUrl, cwd = process.cwd()) {
         const local = await localDaemonStatus();
         if (local.running)
             return { local, started: true, startedPid };
+        try {
+            process.kill(startedPid, 0);
+        }
+        catch {
+            throw new CliError(`Daemon exited before becoming locally ready. Startup output: ${path.join(configDir, "daemon.startup.log")}`, "DAEMON_START_FAILED");
+        }
         await new Promise((resolve) => setTimeout(resolve, 250));
     }
-    throw new CliError("Daemon did not become ready in time. Run happy-elves daemon doctor and happy-elves daemon logs.", "DAEMON_START_FAILED");
+    throw new CliError(`Daemon did not become locally ready in time. Startup output: ${path.join(configDir, "daemon.startup.log")}`, "DAEMON_START_FAILED");
 }
 export async function restartDaemonForNewConfig(relayUrl, cwd = process.cwd()) {
     const stopped = await stopLocalDaemon();

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

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { CliError } from "../../errors.js";
 import { configDir, configPath } from "./paths.js";
+const daemonProviderKinds = new Set(["mock", "codex", "claude", "pie"]);
 export function requireString(flags, key) {
     const value = flags[key];
     if (typeof value !== "string" || !value.trim()) {
@@ -53,10 +54,41 @@ function assertControllerConfigShape(value) {
         throw new CliError("Controller config is invalid.", "CONFIG_INVALID");
     }
     const candidate = value;
+    const previousRelayUrls = Array.isArray(candidate.previousRelayUrls)
+        ? candidate.previousRelayUrls.filter((item) => typeof item === "string" && item.length > 0)
+        : undefined;
+    const relayMigration = parseRelayMigrationConfig(candidate.relayMigration);
     return {
         relayUrl: assertRelayUrl(assertStringField(candidate, "relayUrl", "Controller"), "Controller"),
         controllerToken: assertStringField(candidate, "controllerToken", "Controller"),
         accountSecret: assertStringField(candidate, "accountSecret", "Controller"),
+        ...(previousRelayUrls && previousRelayUrls.length > 0 ? { previousRelayUrls } : {}),
+        ...(relayMigration ? { relayMigration } : {}),
+    };
+}
+function parseRelayMigrationConfig(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const candidate = value;
+    const migrationId = candidate.migrationId;
+    const state = candidate.state;
+    const fromRelayUrl = candidate.fromRelayUrl;
+    const toRelayUrl = candidate.toRelayUrl;
+    const updatedAt = candidate.updatedAt;
+    if (typeof migrationId !== "string" ||
+        typeof state !== "string" ||
+        !["rebound", "migrated", "draining", "drained", "cutover"].includes(state) ||
+        typeof fromRelayUrl !== "string" ||
+        typeof toRelayUrl !== "string" ||
+        typeof updatedAt !== "string") {
+        return undefined;
+    }
+    return {
+        migrationId,
+        state: state,
+        fromRelayUrl,
+        toRelayUrl,
+        updatedAt,
     };
 }
 function assertDaemonConfigShape(value) {
@@ -72,6 +104,7 @@ function assertDaemonConfigShape(value) {
                 runtimeEnv[key] = runtimeValue;
         }
     }
+    const providers = parseProviders(candidate.providers);
     return {
         relayUrl: assertRelayUrl(assertStringField(candidate, "relayUrl", "Daemon"), "Daemon"),
         accountId: assertStringField(candidate, "accountId", "Daemon"),
@@ -79,9 +112,26 @@ function assertDaemonConfigShape(value) {
         machineName: assertStringField(candidate, "machineName", "Daemon"),
         machineToken: assertStringField(candidate, "machineToken", "Daemon"),
         accountSecret: assertStringField(candidate, "accountSecret", "Daemon"),
+        ...(providers ? { providers } : {}),
         ...(Object.keys(runtimeEnv).length > 0 ? { runtimeEnv } : {}),
     };
 }
+function parseProviders(value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new CliError("Daemon config providers must be a non-empty array.", "CONFIG_INVALID");
+    }
+    const providers = [];
+    for (const item of value) {
+        if (typeof item !== "string" || !daemonProviderKinds.has(item)) {
+            throw new CliError("Daemon config providers must contain only mock, codex, claude, or pie.", "CONFIG_INVALID");
+        }
+        if (!providers.includes(item))
+            providers.push(item);
+    }
+    return providers;
+}
 async function readJsonConfigFile(filePath, label) {
     try {
         return JSON.parse(stripJsonBom(await fs.readFile(filePath, "utf8")));
@@ -108,6 +158,7 @@ export async function readConfig(flags) {
     }
     const stored = assertControllerConfigShape(await readJsonConfigFile(configPath, "Controller"));
     return {
+        ...stored,
         relayUrl: assertRelayUrl(relayUrl ?? stored.relayUrl, "Controller"),
         controllerToken: controllerToken ?? stored.controllerToken,
         accountSecret: accountSecret ?? stored.accountSecret,
@@ -129,6 +180,7 @@ export function redactedDaemonConfig(config) {
         accountId: config.accountId,
         machineId: config.machineId,
         machineName: config.machineName,
+        ...(config.providers && config.providers.length > 0 ? { providers: config.providers } : {}),
         hasMachineToken: Boolean(config.machineToken),
         hasAccountSecret: Boolean(config.accountSecret),
         ...(config.runtimeEnv ? { runtimeEnv: Object.fromEntries(Object.keys(config.runtimeEnv).map((key) => [key, true])) } : {}),

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

@@ -16,6 +16,7 @@ export * from "./local-daemon.js";
 export * from "./loop-store.js";
 export * from "./paths.js";
 export * from "./relay-db-audit.js";
+export * from "./relay-debug.js";
 export * from "./relay-http.js";
 export * from "./scope.js";
 export * from "./session-output.js";

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

@@ -16,6 +16,7 @@ export * from "./local-daemon.js";
 export * from "./loop-store.js";
 export * from "./paths.js";
 export * from "./relay-db-audit.js";
+export * from "./relay-debug.js";
 export * from "./relay-http.js";
 export * from "./scope.js";
 export * from "./session-output.js";

package/apps/cli/dist/commands/lib/local-daemon.js

@@ -1,5 +1,6 @@
 import { execFileSync, spawn } from "node:child_process";
 import fs from "node:fs/promises";
+import { appendFileSync, closeSync, mkdirSync, openSync } from "node:fs";
 import path from "node:path";
 import { configDir, daemonPidPath } from "./paths.js";
 function daemonCliPath() {
@@ -117,15 +118,30 @@ export async function daemonConfigUpdatedAfterStart(status) {
     }
 }
 export function spawnDaemonStart(args, cwd = process.cwd()) {
-    const child = spawn(process.execPath, [daemonCliPath(), "start", ...args], {
-        cwd,
-        env: { ...process.env, HAPPY_ELVES_HOME: configDir },
-        detached: true,
-        stdio: "ignore",
-        windowsHide: true,
-    });
-    child.unref();
-    return child.pid ?? 0;
+    const logPath = path.join(configDir, "daemon.startup.log");
+    mkdirSync(configDir, { recursive: true });
+    const logFd = openSync(logPath, "a", 0o600);
+    try {
+        appendFileSync(logFd, `\n[${new Date().toISOString()}] Starting daemon (${process.version})\n`);
+        const child = spawn(process.execPath, [daemonCliPath(), "start", ...args], {
+            cwd,
+            env: { ...process.env, HAPPY_ELVES_HOME: configDir },
+            detached: true,
+            stdio: ["ignore", logFd, logFd],
+            windowsHide: true,
+        });
+        child.once("error", (error) => {
+            try {
+                appendFileSync(logPath, `Daemon spawn failed: ${error.message}\n`);
+            }
+            catch { /* Parent still reports a failed start. */ }
+        });
+        child.unref();
+        return child.pid ?? 0;
+    }
+    finally {
+        closeSync(logFd);
+    }
 }
 export async function stopLocalDaemon(timeoutMs = 5000) {
     const status = await localDaemonStatus();

package/apps/cli/dist/commands/lib/loop-store.js

@@ -1,4 +1,5 @@
 import fs from "node:fs/promises";
+import { RecoverableFileLockError, withRecoverableFileLock } from "../../../../../packages/shared/dist/file-lock.js";
 import { CliError } from "../../errors.js";
 import { configDir, loopStoreLockPath, loopStorePath } from "./paths.js";
 function emptyLoopStore() {
@@ -28,24 +29,14 @@ async function writeLoopStore(store) {
 }
 async function withLoopStoreLock(operation) {
     await fs.mkdir(configDir, { recursive: true });
-    const deadline = Date.now() + 5000;
-    let handle;
-    while (!handle) {
-        try {
-            handle = await fs.open(loopStoreLockPath, "wx", 0o600);
-        }
-        catch (error) {
-            if (error.code !== "EEXIST" || Date.now() > deadline)
-                throw error;
-            await new Promise((resolve) => setTimeout(resolve, 25));
-        }
-    }
-    await handle.close();
     try {
-        return await operation();
+        return await withRecoverableFileLock({ lockPath: loopStoreLockPath, label: "happy-elves loop store" }, operation);
     }
-    finally {
-        await fs.unlink(loopStoreLockPath).catch(() => { });
+    catch (error) {
+        if (error instanceof RecoverableFileLockError) {
+            throw new CliError(error.message, error.code);
+        }
+        throw error;
     }
 }
 export function parseStopOn(value) {