@cydm/happy-elves 0.1.0-beta.52 → 0.1.0-beta.54

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

@@ -21,6 +21,8 @@ export function normalizeOrchestratorStatus(session, orchestration, latestTurn)
         return "needsInput";
     if (orchestration.blocked)
         return "blocked";
+    if (orchestration.statusConflict?.evidence === "running-turn")
+        return "inProgress";
     if (latestTurn?.status === "running" || session.status === "running" || session.status === "new")
         return "inProgress";
     if (latestTurn?.status === "failed" || session.status === "failed")

package/apps/cli/dist/commands/lib/session-view.js

@@ -39,6 +39,23 @@ function orchestrationStateFromStatus(status) {
     return "closed";
 }
 export function deriveOrchestration(session, events = []) {
+    const turns = summarizeTurns(events);
+    const latestTurn = turns[0];
+    const activeTurn = turns.find((turn) => turn.status === "running");
+    if (session.status === "failed" && latestTurn?.status === "running") {
+        return {
+            state: "active",
+            rawStatus: session.status,
+            needsUser: false,
+            blocked: false,
+            completed: false,
+            statusConflict: {
+                rawStatus: session.status,
+                evidence: "running-turn",
+                turnId: latestTurn.turnId,
+            },
+        };
+    }
     if (session.status !== "running") {
         const state = orchestrationStateFromStatus(session.status);
         return {
@@ -49,8 +66,6 @@ export function deriveOrchestration(session, events = []) {
             completed: state === "completed",
         };
     }
-    const turns = summarizeTurns(events);
-    const activeTurn = turns.find((turn) => turn.status === "running");
     const latestTerminalTurn = turns.find((turn) => turn.status !== "running");
     const relevantTurnId = activeTurn?.turnId ?? latestTerminalTurn?.turnId;
     const needsUserEvent = relevantTurnId

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

@@ -42,6 +42,11 @@ export type OrchestrationSummary = {
     completed: boolean;
     reason?: string;
     lastEventId?: number;
+    statusConflict?: {
+        rawStatus: SessionSnapshot["status"];
+        evidence: "running-turn";
+        turnId: string;
+    };
 };
 export type LoopRecord = {
     id: string;

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

@@ -143,7 +143,7 @@ async function readExactTurn(client, threadId, turnId) {
     return summarizeTurns(events).find((turn) => turn.turnId === turnId);
 }
 async function eventsForThreadSummary(client, session) {
-    if (session.status !== "running" && session.status !== "new")
+    if (session.status !== "running" && session.status !== "new" && session.status !== "failed")
         return [];
     return await client.history(session.id, defaultTurnHistoryLimit);
 }

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

@@ -496,6 +496,7 @@ export async function handleSession({ domain, action, positional, flags }) {
         const metadata = await client.decodeSessionMetadata(session);
         const latestPage = await client.collectPage(session.id, { limit });
         const turns = summarizeTurns(latestPage.events);
+        const orchestration = deriveOrchestration(session, latestPage.events);
         const latestCompletedTurn = turns.find((turn) => turn.status === "completed");
         const latestTerminalTurn = turns.find((turn) => turn.status !== "running");
         const runtimeBinding = shouldSearchRuntimeBindingCandidates(latestPage.events, metadata)
@@ -551,6 +552,7 @@ export async function handleSession({ domain, action, positional, flags }) {
                 first: turns.slice(0, 4).map(compactTurnRef),
                 last: turns.slice(-4).map(compactTurnRef),
             },
+            orchestration,
             diagnosis: {
                 importedRuntimeSessionId: stringMetadata(metadata, "importedFromRuntimeSessionId"),
                 latestPageEmpty: latestPage.events.length === 0,
@@ -561,6 +563,8 @@ export async function handleSession({ domain, action, positional, flags }) {
                 backfillStatus: stringMetadata(metadata, "historicalBackfillStatus") ?? stringMetadata(metadata, "historicalBackfill"),
                 wrongRuntimeBindingSuspected: runtimeBindingSuspected(runtimeBinding.candidates),
                 runtimeBindingCandidateCount: runtimeBinding.candidates.length,
+                statusConflictSuspected: Boolean(orchestration.statusConflict),
+                statusConflict: orchestration.statusConflict,
                 staleHeadSuspected: staleHeadSuspected(session, latestCompletedTurn),
                 headMatchesLatestCompletedTurn: headMatchesTurn(session, latestCompletedTurn),
             },

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

@@ -5,7 +5,7 @@ import path from "node:path";
 import { resolveCliCommand } from "../../../../packages/runtime-cli/dist/index.js";
 import { configDir } from "../paths.js";
 import { appendAudit } from "../audit.js";
-import { claimCommandRequest, sendCommandResponse } from "./send.js";
+import { claimCommandRequest, relayOutboxDiagnostics, sendCommandResponse } from "./send.js";
 const maxOutputLength = 16_000;
 const maxArtifactBytesPerStream = 1_000_000;
 const defaultTimeoutMs = 60_000;
@@ -94,6 +94,7 @@ async function collectDiagnostics() {
             HAPPY_ELVES_DEV_REMOTE_EXEC: process.env.HAPPY_ELVES_DEV_REMOTE_EXEC,
         },
         commands: await Promise.all(commandNames.map(commandDiagnostics)),
+        relayOutbox: relayOutboxDiagnostics(),
     };
 }
 async function commandDiagnostics(name) {

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

@@ -1,6 +1,15 @@
+import fs from "node:fs/promises";
 import type { MachineClientMessage } from "../../../../packages/shared/dist/index.js";
 import type { RuntimeTurn } from "../../../../packages/runtime/dist/index.js";
 import type { DaemonConfig } from "../types.js";
+type OutboxFs = Pick<typeof fs, "chmod" | "mkdir" | "readFile" | "rename" | "rm" | "writeFile">;
+export type OutboxPersistFailureDiagnostic = {
+    code?: string;
+    message: string;
+    path?: string;
+    at: string;
+    attempts: number;
+};
 export declare function send(ws: WebSocket, message: unknown): void;
 export declare function configureRelaySender(config: DaemonConfig): void;
 export declare function setActiveRelaySocket(ws: WebSocket): void;
@@ -8,9 +17,15 @@ export declare function clearActiveRelaySocket(ws: WebSocket): void;
 export declare function flushRelayOutbox(): Promise<void>;
 export declare function handleMachineMessageAck(messageId: string): Promise<void>;
 export declare function clearRelayOutboxForTests(): Promise<void>;
+export declare function setRelayOutboxFsForTests(fsOverride?: Partial<OutboxFs>): void;
+export declare function relayOutboxDiagnostics(): {
+    latestPersistFailure?: OutboxPersistFailureDiagnostic;
+};
+export declare function resetRelayOutboxLoadForTests(): void;
 export declare function sendReliable(message: MachineClientMessage, ws?: WebSocket): Promise<MachineClientMessage>;
 export declare function sendCommandResponse(ws: WebSocket, message: MachineClientMessage): Promise<void>;
 export declare function claimCommandRequest(ws: WebSocket, requestId: string): boolean;
 export declare function claimSessionTurn(sessionId: string, requestId: string, turnId: string, source: "prompt" | "loop"): boolean;
 export declare function attachClaimedTurn(sessionId: string, requestId: string, turnId: string, turn: RuntimeTurn): boolean;
 export declare function releaseSessionTurn(sessionId: string, requestId: string): void;
+export {};

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

@@ -20,9 +20,12 @@ const criticalMessageTypes = new Set([
 let activeRelaySocket = null;
 let relayConfig = null;
 let outboxLoaded = false;
+let outboxDiskStateUnknown = false;
 let outboxLoadPromise = null;
-let outboxWritePromise = Promise.resolve();
+let outboxWritePromise = Promise.resolve(true);
 let flushing = false;
+let outboxFs = fs;
+let latestPersistFailure;
 const outbox = new Map();
 export function send(ws, message) {
     const socket = openSocket(activeRelaySocket) ?? openSocket(ws);
@@ -63,9 +66,22 @@ export async function handleMachineMessageAck(messageId) {
 export async function clearRelayOutboxForTests() {
     outbox.clear();
     outboxLoaded = true;
+    outboxDiskStateUnknown = false;
     outboxLoadPromise = null;
+    latestPersistFailure = undefined;
     await persistOutbox();
 }
+export function setRelayOutboxFsForTests(fsOverride) {
+    outboxFs = fsOverride ? { ...fs, ...fsOverride } : fs;
+}
+export function relayOutboxDiagnostics() {
+    return latestPersistFailure ? { latestPersistFailure: { ...latestPersistFailure } } : {};
+}
+export function resetRelayOutboxLoadForTests() {
+    outboxLoaded = false;
+    outboxDiskStateUnknown = false;
+    outboxLoadPromise = null;
+}
 export async function sendReliable(message, ws) {
     if (!isCriticalMachineMessage(message)) {
         const socket = openSocket(activeRelaySocket) ?? openSocket(ws);
@@ -150,7 +166,7 @@ async function ensureOutboxLoaded() {
 async function loadOutbox() {
     outbox.clear();
     try {
-        const text = await fs.readFile(relayOutboxPath, "utf8");
+        const text = await outboxFs.readFile(relayOutboxPath, "utf8");
         for (const line of text.split(/\n/u)) {
             if (!line.trim())
                 continue;
@@ -159,25 +175,88 @@ async function loadOutbox() {
                 outbox.set(parsed.messageId, parsed);
             }
         }
+        outboxDiskStateUnknown = false;
     }
     catch (error) {
-        if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT")
-            throw error;
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            outboxDiskStateUnknown = false;
+            outboxLoaded = true;
+            return;
+        }
+        outboxDiskStateUnknown = true;
+        latestPersistFailure = persistFailureDiagnostic(error, relayOutboxPath, 1);
+        await appendPersistFailureAudit(latestPersistFailure);
     }
     outboxLoaded = true;
 }
 async function persistOutbox() {
-    outboxWritePromise = outboxWritePromise.then(writeOutbox, writeOutbox);
-    await outboxWritePromise;
+    if (outboxDiskStateUnknown) {
+        latestPersistFailure = {
+            code: "OUTBOX_DISK_STATE_UNKNOWN",
+            message: "Skipped relay outbox persistence because the existing outbox could not be loaded safely.",
+            path: relayOutboxPath,
+            at: new Date().toISOString(),
+            attempts: 0,
+        };
+        await appendPersistFailureAudit(latestPersistFailure);
+        return false;
+    }
+    outboxWritePromise = outboxWritePromise.then(writeOutboxWithRetries, writeOutboxWithRetries);
+    return outboxWritePromise;
+}
+async function writeOutboxWithRetries() {
+    const maxAttempts = 4;
+    let attempts = 0;
+    let lastError;
+    let lastTempPath;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        attempts = attempt;
+        lastTempPath = uniqueTempPath();
+        try {
+            await writeOutbox(lastTempPath);
+            if (latestPersistFailure?.path !== relayOutboxPath)
+                latestPersistFailure = undefined;
+            return true;
+        }
+        catch (error) {
+            lastError = error;
+            await outboxFs.rm(lastTempPath, { force: true }).catch(() => undefined);
+            if (!isTransientOutboxError(error) || attempt === maxAttempts)
+                break;
+            await delay(25 * attempt);
+        }
+    }
+    latestPersistFailure = persistFailureDiagnostic(lastError, lastTempPath, attempts);
+    await appendPersistFailureAudit(latestPersistFailure);
+    return false;
 }
-async function writeOutbox() {
-    await fs.mkdir(configDir, { recursive: true });
+async function writeOutbox(tempPath) {
+    await outboxFs.mkdir(configDir, { recursive: true });
     const text = [...outbox.values()].map((record) => JSON.stringify(record)).join("\n");
     const next = text ? `${text}\n` : "";
-    const tempPath = `${relayOutboxPath}.tmp`;
-    await fs.writeFile(tempPath, next, { mode: 0o600 });
-    await fs.rename(tempPath, relayOutboxPath);
-    await fs.chmod(relayOutboxPath, 0o600).catch(() => undefined);
+    await outboxFs.writeFile(tempPath, next, { mode: 0o600 });
+    await outboxFs.rename(tempPath, relayOutboxPath);
+    await outboxFs.chmod(relayOutboxPath, 0o600).catch(() => undefined);
+}
+function uniqueTempPath() {
+    return `${relayOutboxPath}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
+}
+function isTransientOutboxError(error) {
+    return error instanceof Error && "code" in error && ["EPERM", "EACCES", "EBUSY"].includes(String(error.code));
+}
+function persistFailureDiagnostic(error, pathValue, attempts) {
+    const err = error instanceof Error ? error : undefined;
+    const code = err && "code" in err ? String(err.code) : undefined;
+    return {
+        code,
+        message: err?.message ?? (error ? String(error) : "Unknown relay outbox persistence failure"),
+        path: pathValue,
+        at: new Date().toISOString(),
+        attempts,
+    };
+}
+async function delay(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function attemptSendRecord(record, ws) {
     const socket = openSocket(activeRelaySocket) ?? openSocket(ws);
@@ -212,5 +291,20 @@ async function appendOutboxAudit(record, status, error) {
             requestId: "requestId" in record.message ? record.message.requestId : undefined,
             error: error instanceof Error ? error.message : error ? String(error) : undefined,
         },
+    }).catch((auditError) => {
+        latestPersistFailure = persistFailureDiagnostic(auditError, undefined, 1);
     });
 }
+async function appendPersistFailureAudit(diagnostic) {
+    if (!relayConfig) {
+        console.warn(`Relay outbox persist failed: ${diagnostic.code ?? "UNKNOWN"} ${diagnostic.message}`);
+        return;
+    }
+    await appendAudit({
+        machineId: relayConfig.machineId,
+        actor: "system",
+        action: "relay.outbox.persist_failed",
+        summary: "Failed to persist reliable relay outbox",
+        evidence: diagnostic,
+    }).catch(() => undefined);
+}

package/apps/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-daemon",
-  "version": "0.1.0-beta.52",
+  "version": "0.1.0-beta.54",
   "private": true,
   "type": "module"
 }

package/apps/relay/dist/machine-command-result-handlers.js

@@ -487,7 +487,7 @@ function handleMachineError(context, connection, message, acknowledgeMachineMess
             acknowledgeMachineMessage();
             return;
         }
-        if (!nonFatalSessionErrors.has(message.code ?? "")) {
+        if (isFatalSessionMachineError(pending, message.code, nonFatalSessionErrors)) {
             context.clearAcceptedRunsForSession(connection.accountId, { machineId: connection.machineId, sessionId: message.sessionId });
             const session = context.setSessionStatus({ accountId: connection.accountId, machineId: connection.machineId, sessionId: message.sessionId, status: "failed" });
             if (session)
@@ -519,6 +519,29 @@ function handleMachineError(context, connection, message, acknowledgeMachineMess
     });
     acknowledgeMachineMessage();
 }
+function isFatalSessionMachineError(pending, code, nonFatalCodes) {
+    if (pending) {
+        if (isControlPlaneSessionAction(pending.action))
+            return false;
+        if (pending.action === "session.run")
+            return !nonFatalCodes.has(code ?? "");
+        if (pending.action === "session.create" || pending.action === "session.import")
+            return true;
+    }
+    return !nonFatalCodes.has(code ?? "");
+}
+function isControlPlaneSessionAction(action) {
+    return [
+        "directory.list",
+        "file.preview",
+        "machine.diagnose",
+        "machine.devExec",
+        "session.cancel",
+        "session.history",
+        "session.rename",
+        "session.resume",
+    ].includes(action);
+}
 function completeWithAck(context, connection, message) {
     context.completeCommandWithResponse(connection.accountId, connection.machineId, message.requestId, message);
     context.broadcastAck(connection.accountId, message);

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.52",
+  "version": "0.1.0-beta.54",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@cydm/happy-elves",
-      "version": "0.1.0-beta.52",
+      "version": "0.1.0-beta.54",
       "license": "Apache-2.0",
       "dependencies": {
         "@fastify/cors": "11.2.0",
@@ -1543,18 +1543,18 @@
       "license": "MIT"
     },
     "node_modules/toad-cache": {
-      "version": "3.7.1",
-      "resolved": "https://registry.npmjs.org/toad-cache/-/toad-cache-3.7.1.tgz",
-      "integrity": "sha512-5DXWzE4Vz7xNHsv+xQ+MGfJYyC78Aok3tEr0MNwHoRf7vZnga1mQXZ4/Nsodld4VR6Wd+VhfmqnNrsRJyYPfrQ==",
+      "version": "3.7.4",
+      "resolved": "https://registry.npmjs.org/toad-cache/-/toad-cache-3.7.4.tgz",
+      "integrity": "sha512-m1TdR/rvT7kgGJZhspNtXdsdYk0fddFpJJFlG5s+UkPFo6lkLoZ3YLOaovPYjq1R75NP5JfeTlSHaOsE09peCg==",
       "license": "MIT",
       "engines": {
         "node": ">=20"
       }
     },
     "node_modules/tsx": {
-      "version": "4.22.5",
-      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.22.5.tgz",
-      "integrity": "sha512-F7JnSfPl5ASt6LqwWyUQ3T8BwN3q0eQEbFMYa2iRWaVQmmudo0d7fRmwM4O002gsvW1bs0yBYioutsAjqLJMvQ==",
+      "version": "4.23.0",
+      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.23.0.tgz",
+      "integrity": "sha512-eUdUIaCr963q2h5u3+QwvYp0+eqPvn+egeqZUm0hwERCqqx1E3kK5ehbGCvqSE5MQAULr67ww0cA3jKc3YkM1w==",
       "license": "MIT",
       "dependencies": {
         "esbuild": "~0.28.0"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.52",
+  "version": "0.1.0-beta.54",
   "description": "Remote controller for local coding agents with hosted or self-hosted relay support.",
   "type": "module",
   "bin": {

package/packages/runtime-cli/dist/codex-protocol.d.ts

@@ -1,7 +1,6 @@
 import { type RuntimePermissionMode } from "./permissions.js";
 export declare function normalizeCodexPermissionMode(mode?: RuntimePermissionMode): RuntimePermissionMode;
 export declare function normalizeRuntimeSelection(value?: string | null): string | null;
-export declare function normalizeCodexReasoningEffort(value?: string | null): string | null;
 export declare function codexThreadStartParams(cwd: string, permissionMode: RuntimePermissionMode, model?: string | null): Record<string, unknown>;
 export declare function codexThreadResumeParams(threadId: string, cwd: string, permissionMode: RuntimePermissionMode, model?: string | null): Record<string, unknown>;
 export declare function codexTurnStartParams(threadId: string, cwd: string, text: string, permissionMode: RuntimePermissionMode, model?: string | null, thoughtLevel?: string | null): Record<string, unknown>;

package/packages/runtime-cli/dist/codex-protocol.js

@@ -8,7 +8,7 @@ export function normalizeRuntimeSelection(value) {
     const normalized = value.trim();
     return normalized && normalized !== "default" ? normalized : null;
 }
-export function normalizeCodexReasoningEffort(value) {
+function normalizeCodexReasoningEffort(value) {
     const normalized = normalizeRuntimeSelection(value);
     if (normalized === null)
         return null;

package/packages/shared/dist/protocol-schemas.d.ts

@@ -387,6 +387,15 @@ export declare const machineDiagnosticsSchema: z.ZodObject<{
         version: z.ZodOptional<z.ZodString>;
         error: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    relayOutbox: z.ZodOptional<z.ZodObject<{
+        latestPersistFailure: z.ZodOptional<z.ZodObject<{
+            code: z.ZodOptional<z.ZodString>;
+            message: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+            at: z.ZodString;
+            attempts: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const machineDevExecResultSchema: z.ZodObject<{
     command: z.ZodString;

package/packages/shared/dist/protocol-schemas.js

@@ -171,6 +171,15 @@ export const machineDiagnosticsSchema = z.object({
         version: z.string().optional(),
         error: z.string().optional(),
     })),
+    relayOutbox: z.object({
+        latestPersistFailure: z.object({
+            code: z.string().optional(),
+            message: z.string(),
+            path: z.string().optional(),
+            at: z.string(),
+            attempts: z.number().int().nonnegative(),
+        }).optional(),
+    }).optional(),
 });
 export const machineDevExecResultSchema = z.object({
     command: z.string().min(1),

package/packages/shared/dist/protocol-types.d.ts

@@ -149,6 +149,15 @@ export type MachineDiagnostics = {
         version?: string;
         error?: string;
     }>;
+    relayOutbox?: {
+        latestPersistFailure?: {
+            code?: string;
+            message: string;
+            path?: string;
+            at: string;
+            attempts: number;
+        };
+    };
 };
 export type MachineDevExecResult = {
     command: string;