@cydm/happy-elves 0.1.0-beta.51 → 0.1.0-beta.53

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

@@ -16,6 +16,7 @@ const valueFlags = new Set([
     "machine-id",
     "name",
     "mode",
+    "model",
     "output",
     "path",
     "port",
@@ -49,6 +50,8 @@ const valueFlags = new Set([
     "text-file",
     "timeout",
     "timeout-ms",
+    "thought-level",
+    "thinking",
     "wait-timeout-ms",
     "runtime-timeout",
     "to",

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

@@ -6,6 +6,8 @@ export type OrchestratorStatus = "idle" | "inProgress" | "completed" | "needsInp
 export type OrchestratorRequestRecord = {
     turnId: string;
     promptSha256: string;
+    model?: string | null;
+    thoughtLevel?: string | null;
     createdAt: number;
 };
 export type OrchestratorMetadata = {

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")
@@ -77,6 +79,8 @@ export function readOrchestratorMetadata(metadata) {
                 requests[requestId] = {
                     turnId: candidate.turnId,
                     promptSha256: candidate.promptSha256,
+                    ...(candidate.model === null || typeof candidate.model === "string" ? { model: candidate.model } : {}),
+                    ...(candidate.thoughtLevel === null || typeof candidate.thoughtLevel === "string" ? { thoughtLevel: candidate.thoughtLevel } : {}),
                     createdAt: candidate.createdAt,
                 };
             }

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

@@ -9,6 +9,8 @@ export declare function requireScopedLoop(scope: ScopedTokenScope | undefined, l
 export declare function loopVisibleToScope(loop: LoopRecord, scope: ScopedTokenScope | undefined, tokenId?: string, machineId?: string | undefined): boolean;
 export declare function parseEventCursor(value: string | boolean | undefined): `cursor_${number}` | number | undefined;
 export declare function parsePermissionMode(value: string | boolean | undefined): PermissionMode | undefined;
+export declare function parseRuntimeSelection(value: string | boolean | undefined, label: string): string | null | undefined;
+export declare function parseThoughtLevel(flags: Record<string, string | boolean>): string | null | undefined;
 export declare function parseControllerJoinUrl(value: string): {
     relayUrl: string;
     code: string;

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

@@ -82,6 +82,24 @@ export function parsePermissionMode(value) {
         return "approve-reads";
     throw new CliError(`Invalid permission mode: ${value}`, "INVALID_ARGUMENT");
 }
+export function parseRuntimeSelection(value, label) {
+    if (value === undefined || value === false)
+        return undefined;
+    if (value === true)
+        throw new CliError(`Missing --${label} value`, "MISSING_ARGUMENT");
+    const normalized = value.trim();
+    if (!normalized)
+        throw new CliError(`Invalid --${label}: empty value`, "INVALID_ARGUMENT");
+    return normalized.toLowerCase() === "default" ? null : normalized;
+}
+export function parseThoughtLevel(flags) {
+    const canonical = flags["thought-level"];
+    const alias = flags.thinking;
+    if (canonical !== undefined && canonical !== false && alias !== undefined && alias !== false) {
+        throw new CliError("Use only one of --thought-level or --thinking", "INVALID_ARGUMENT");
+    }
+    return parseRuntimeSelection(canonical !== undefined && canonical !== false ? canonical : alias, canonical !== undefined && canonical !== false ? "thought-level" : "thinking");
+}
 export function parseControllerJoinUrl(value) {
     let url;
     try {

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/lib/usage.js

@@ -47,7 +47,7 @@ Check local controller config, relay reachability, and daemon state.
     orchestrator: `Usage:
   happy-elves orchestrator list-threads [--query <q>] [--tag <tag>] [--machine <id>] [--limit n] [--all] --json
   happy-elves orchestrator read-thread <threadId> [--messages latest|all] [--limit n] [--include-output] --json
-  happy-elves orchestrator send-message <threadId> (--text <prompt> | --text-file <path>) --request-id <id> [--permission-mode <mode>] [--runtime-timeout 1000s] --json
+  happy-elves orchestrator send-message <threadId> (--text <prompt> | --text-file <path>) --request-id <id> [--permission-mode <mode>] [--model <key>] [--thought-level <key>|--thinking <key>] [--runtime-timeout 1000s] --json
   happy-elves orchestrator wait-thread <threadId> --turn <turnId> [--timeout 1000s] --json
   happy-elves orchestrator set-thread-tags <threadId> --tags worker,reviewer --json
 
@@ -57,7 +57,7 @@ Codex-like orchestration:
   for that exact turn id instead of following the latest turn.
 `,
     session: `Usage:
-  happy-elves session create --machine <machineId> [--agent codex] [--cwd <path>] [--name <name>] [--permission-mode <mode>] --json
+  happy-elves session create --machine <machineId> [--agent codex] [--cwd <path>] [--name <name>] [--permission-mode <mode>] [--model <key>] [--thought-level <key>|--thinking <key>] --json
   happy-elves session list [--machine <machineId>] [--agent <agent>] [--cwd <cwd>] [--name <name>] [--limit n] [--all] [--verbose] [--json]
   happy-elves session history --machine <machineId> [--cwd <path>] [--agent <agent>] [--include-archived] [--limit 20] --json
   happy-elves session continue <runtimeSessionId> --machine <machineId> [--name <name>] --json
@@ -85,7 +85,7 @@ Session management:
   happy-elves turn list <sessionId> [--limit 10] [--verbose] [--json]
   happy-elves turn status <sessionId> <turnId> [--verbose] [--json]
   happy-elves turn result <sessionId> [<turnId>] [--verbose] [--json]
-  happy-elves turn run <sessionId> (--text <prompt> | --text-file <path>) [--detach] [--timeout 1000s] [--runtime-timeout 1000s] [--permission-mode approve-reads|approve-all|deny-all] [--json]
+  happy-elves turn run <sessionId> (--text <prompt> | --text-file <path>) [--detach] [--timeout 1000s] [--runtime-timeout 1000s] [--permission-mode approve-reads|approve-all|deny-all] [--model <key>] [--thought-level <key>|--thinking <key>] [--json]
   happy-elves turn wait <sessionId> <turnId> [--timeout 1000s] --json
   happy-elves turn cancel <sessionId> <turnId> [--reason <reason>] --json
   happy-elves turn rewind <sessionId> <turn-or-checkpoint-id> --json
@@ -260,8 +260,8 @@ Output modes:
   thread's history is unavailable, the item reports historyStatus/historyError
   instead of pretending to be healthy inProgress.
   send-message requires --request-id and is detached by default. Reusing the
-  same request id with the same prompt returns the same turn; reusing it with a
-  different prompt returns REQUEST_ID_CONFLICT.
+  same request id with the same prompt/model/thinking returns the same turn;
+  reusing it with different prompt/model/thinking returns REQUEST_ID_CONFLICT.
 
 Debug commands:
   machine/session/turn commands remain available for lower-level inspection,

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

@@ -1,4 +1,4 @@
-import { CliError, ControllerClient, DEFAULT_COMMAND_TIMEOUT_MS, collectExactTurnEvents, compactText, conciseEvents, deterministicRelayRequestId, deterministicTurnId, deriveOrchestration, normalizeOrchestratorStatus, normalizeOrchestratorTag, normalizeOrchestratorTags, ok, parseDurationMs, parsePermissionMode, promptSha256, readConfig, readOrchestratorMetadata, readPromptTextFile, rebuildTurnOutput, requirePositional, requireString, summarizeTurns, withOrchestratorRequest, withOrchestratorTags, } from "./lib/index.js";
+import { CliError, ControllerClient, DEFAULT_COMMAND_TIMEOUT_MS, collectExactTurnEvents, compactText, conciseEvents, deterministicRelayRequestId, deterministicTurnId, deriveOrchestration, normalizeOrchestratorStatus, normalizeOrchestratorTag, normalizeOrchestratorTags, ok, parseDurationMs, parsePermissionMode, parseRuntimeSelection, parseThoughtLevel, promptSha256, readConfig, readOrchestratorMetadata, readPromptTextFile, rebuildTurnOutput, requirePositional, requireString, summarizeTurns, withOrchestratorRequest, withOrchestratorTags, } from "./lib/index.js";
 const defaultTurnHistoryLimit = 1000;
 const defaultMessageLimit = 50;
 class OrchestratorError extends CliError {
@@ -101,15 +101,28 @@ async function readThreadContext(client, threadId) {
     }
     return { machines: snapshot.machines, session };
 }
-function requestRecordForExistingTurn(turn, hash, createdAt) {
+function requestRecordForExistingTurn(turn, hash, selection, createdAt) {
     if (!turn)
         return undefined;
     return {
         turnId: turn.turnId,
         promptSha256: hash,
+        ...selectionRecordFields(selection),
         createdAt: turn.startedAt ?? turn.updatedAt ?? createdAt,
     };
 }
+function selectionRecordFields(selection) {
+    return {
+        ...(selection.model !== undefined ? { model: selection.model } : {}),
+        ...(selection.thoughtLevel !== undefined ? { thoughtLevel: selection.thoughtLevel } : {}),
+    };
+}
+function sameRequestRecord(existing, expected) {
+    return existing.turnId === expected.turnId &&
+        existing.promptSha256 === expected.promptSha256 &&
+        existing.model === expected.model &&
+        existing.thoughtLevel === expected.thoughtLevel;
+}
 function errorCode(error) {
     const candidate = error;
     return typeof candidate?.code === "string" ? candidate.code : undefined;
@@ -130,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);
 }
@@ -148,7 +161,7 @@ async function persistRequestRecordBestEffort(client, threadId, requestId, recor
         const metadata = await client.decodeSessionMetadata(session);
         const existing = readOrchestratorMetadata(metadata).requests?.[requestId];
         if (existing) {
-            if (existing.turnId === record.turnId && existing.promptSha256 === record.promptSha256)
+            if (sameRequestRecord(existing, record))
                 return;
             return;
         }
@@ -172,7 +185,7 @@ function terminalStatusForTurn(turn) {
     return "inProgress";
 }
 function requestConflict(threadId, requestId, turnId) {
-    return new OrchestratorError(`Request id already exists with different prompt content: ${requestId}`, "REQUEST_ID_CONFLICT", { retryable: false, sessionId: threadId, turnId });
+    return new OrchestratorError(`Request id already exists with different prompt, model, or thoughtLevel: ${requestId}`, "REQUEST_ID_CONFLICT", { retryable: false, sessionId: threadId, turnId });
 }
 function threadBusy(threadId, active, latestCompleted) {
     return new OrchestratorError(`Thread already has a running turn: ${active.turnId}`, "THREAD_BUSY", {
@@ -284,11 +297,19 @@ export async function handleOrchestrator({ domain, action, positional, flags })
         const turnId = deterministicTurnId(threadId, requestId);
         const relayRequestId = deterministicRelayRequestId(threadId, requestId);
         const hash = promptSha256(text);
+        const model = parseRuntimeSelection(flags.model, "model");
+        const thoughtLevel = parseThoughtLevel(flags);
+        const selection = selectionRecordFields({ model, thoughtLevel });
+        const record = { turnId, promptSha256: hash, ...selection, createdAt: Date.now() };
         const self = await client.tokenSelf();
         if (!self.full) {
             throw new OrchestratorError("orchestrator send-message requires a full controller token.", "SCOPED_TOKEN_FORBIDDEN", { retryable: false, sessionId: threadId, turnId });
         }
-        await readThreadContext(client, threadId);
+        const { session } = await readThreadContext(client, threadId);
+        const metadata = await client.decodeSessionMetadata(session);
+        const existingRequest = readOrchestratorMetadata(metadata).requests?.[requestId];
+        if (existingRequest && !sameRequestRecord(existingRequest, record))
+            throw requestConflict(threadId, requestId, turnId);
         const events = await client.history(threadId, defaultTurnHistoryLimit);
         const turns = summarizeTurns(events);
         const existingTurn = await readExactTurn(client, threadId, turnId);
@@ -299,9 +320,10 @@ export async function handleOrchestrator({ domain, action, positional, flags })
         if (active && active.turnId !== turnId)
             throw threadBusy(threadId, active, latestCompleted);
         if (existingTurn && existingTurn.status !== "running") {
-            await persistRequestRecordBestEffort(client, threadId, requestId, requestRecordForExistingTurn(existingTurn, hash, Date.now()) ?? {
+            await persistRequestRecordBestEffort(client, threadId, requestId, requestRecordForExistingTurn(existingTurn, hash, selection, Date.now()) ?? {
                 turnId,
                 promptSha256: hash,
+                ...selection,
                 createdAt: Date.now(),
             });
             ok("orchestrator.sendMessage", {
@@ -326,7 +348,6 @@ export async function handleOrchestrator({ domain, action, positional, flags })
             }, { requestId, sessionId: threadId, turnId });
             return true;
         }
-        const record = { turnId, promptSha256: hash, createdAt: Date.now() };
         const permissionMode = parsePermissionMode(flags["permission-mode"] ?? flags.permission);
         const runtimeTimeoutMs = parseDurationMs(flags["runtime-timeout"], DEFAULT_COMMAND_TIMEOUT_MS);
         try {
@@ -336,6 +357,8 @@ export async function handleOrchestrator({ domain, action, positional, flags })
                 requestId: relayRequestId,
                 turnId,
                 promptHash: hash,
+                model,
+                thoughtLevel,
                 ackTimeoutMs: 15_000,
                 runtimeTimeoutMs,
             });

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

@@ -1,4 +1,4 @@
-import { CliError, ControllerClient, compareSessionEventLogicalOrder, compactSessionListItem, compactText, conciseSessionSummary, deriveOrchestration, listWorkspaceHistoricalSessions, ok, parsePermissionMode, readConfig, readStoredTurnOutput, requirePositional, requireString, showSession, structuredSessionProjection, summarizeTurns, wantsJson, wantsVerbose } from "./lib/index.js";
+import { CliError, ControllerClient, compareSessionEventLogicalOrder, compactSessionListItem, compactText, conciseSessionSummary, deriveOrchestration, listWorkspaceHistoricalSessions, ok, parsePermissionMode, parseRuntimeSelection, parseThoughtLevel, readConfig, readStoredTurnOutput, requirePositional, requireString, showSession, structuredSessionProjection, summarizeTurns, wantsJson, wantsVerbose } from "./lib/index.js";
 function formatTurnTimestamp(value) {
     return value === undefined ? "-" : new Date(value).toISOString();
 }
@@ -355,8 +355,10 @@ export async function handleSession({ domain, action, positional, flags }) {
         const requestedRuntimeName = typeof flags.name === "string" ? flags.name : undefined;
         const name = "main";
         const permissionMode = parsePermissionMode(flags["permission-mode"] ?? flags.permission);
+        const model = parseRuntimeSelection(flags.model, "model");
+        const thoughtLevel = parseThoughtLevel(flags);
         const client = await makeClient();
-        const result = await client.createSession({ machineId, agent, cwd, name, runtimeName: requestedRuntimeName, permissionMode });
+        const result = await client.createSession({ machineId, agent, cwd, name, runtimeName: requestedRuntimeName, permissionMode, model, thoughtLevel });
         const session = result.sessionId ? await client.getSession(result.sessionId) : undefined;
         const projectedSession = session
             ? wantsVerbose(flags)
@@ -494,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)
@@ -549,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,
@@ -559,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/cli/dist/commands/skill.js

@@ -42,8 +42,10 @@ happy-elves orchestrator wait-thread <threadId> --turn <turnId> --json
 Important rules:
 - \`threadId\` is the same value as Happy Elves \`sessionId\`.
 - Use stable request ids such as \`orch_round_3_worker_fix\`.
-- Reusing the same request id with the same prompt returns the same turn.
-- Reusing the same request id with different prompt text returns \`REQUEST_ID_CONFLICT\`.
+- Reusing the same request id with the same prompt/model/thinking returns the same turn.
+- Reusing the same request id with different prompt text, model, or thinking returns \`REQUEST_ID_CONFLICT\`.
+- To override runtime selection, pass \`--model <key>\` and \`--thought-level <key>\`; \`--thinking <key>\` is an alias. Use \`default\` to return to provider defaults.
+- Runtime failures such as \`CODEX_EMPTY_COMPLETION\` are terminal failed turns; inspect \`wait-thread --turn\` or \`turn result\` for the full error text.
 - If \`send-message\` returns \`THREAD_BUSY\`, wait/read the active turn instead of sending another prompt.
 - For waiting, use the exact \`turnId\` returned by \`send-message\`; do not follow "latest" in multi-actor workflows.
 - After installing or updating this skill, open a fresh Codex thread or reload skills before relying on the new instructions.

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

@@ -1,4 +1,4 @@
-import { CliError, ControllerClient, DEFAULT_COMMAND_TIMEOUT_MS, collectExactTurnEvents, compactText, displayPath, ok, parseDurationMs, parsePermissionMode, printConciseEvents, readConfig, readPromptTextFile, rebuildTurnOutput, requirePositional, requireProjectedSession, requireString, structuredOutputForRunningTurn, structuredOutputForStoredTurn, structuredOutputForTurn, summarizeTurns, wantsJson, wantsVerbose, writeTurnOutput } from "./lib/index.js";
+import { CliError, ControllerClient, DEFAULT_COMMAND_TIMEOUT_MS, collectExactTurnEvents, compactText, displayPath, ok, parseDurationMs, parsePermissionMode, parseRuntimeSelection, parseThoughtLevel, printConciseEvents, readConfig, readPromptTextFile, rebuildTurnOutput, requirePositional, requireProjectedSession, requireString, structuredOutputForRunningTurn, structuredOutputForStoredTurn, structuredOutputForTurn, summarizeTurns, wantsJson, wantsVerbose, writeTurnOutput } from "./lib/index.js";
 function formatTurnTimestamp(value) {
     return value === undefined ? "-" : new Date(value).toISOString();
 }
@@ -120,11 +120,13 @@ export async function handleTurn({ domain, action, positional, flags }) {
         if (!text.trim())
             throw new CliError("Missing --text or --text-file", "MISSING_ARGUMENT");
         const permissionMode = parsePermissionMode(flags["permission-mode"] ?? flags.permission);
+        const model = parseRuntimeSelection(flags.model, "model");
+        const thoughtLevel = parseThoughtLevel(flags);
         const wait = flags.detach !== true && flags["no-wait"] !== true;
         const watchTimeoutMs = parseDurationMs(flags.timeout, DEFAULT_COMMAND_TIMEOUT_MS);
         const ackTimeoutMs = 15_000;
         const runtimeTimeoutMs = parseDurationMs(flags["runtime-timeout"], DEFAULT_COMMAND_TIMEOUT_MS);
-        const result = await client.run(sessionId, text, { wait, permissionMode, waitTimeoutMs: watchTimeoutMs, ackTimeoutMs, runtimeTimeoutMs });
+        const result = await client.run(sessionId, text, { wait, permissionMode, model, thoughtLevel, waitTimeoutMs: watchTimeoutMs, ackTimeoutMs, runtimeTimeoutMs });
         const events = await client.decodeEvents(result.events);
         const output = wait && result.turnId ? await writeTurnOutput(sessionId, result.turnId, events) : undefined;
         if (wantsJson(flags)) {

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/dist/session/prompt.js

@@ -47,6 +47,9 @@ export async function handlePrompt(ws, config, command) {
     };
     try {
         const previousBackendSessionId = session.handle.backendSessionId;
+        const previousMetadata = await commandSessionMetadata(config, command.encryptedMetadata);
+        const effectiveModel = command.model !== undefined ? command.model : previousMetadata?.modelMode;
+        const effectiveThoughtLevel = command.thoughtLevel !== undefined ? command.thoughtLevel : previousMetadata?.thoughtLevel;
         let result;
         try {
             const prompt = await decryptJson(config.accountSecret, command.encryptedPrompt);
@@ -60,8 +63,8 @@ export async function handlePrompt(ws, config, command) {
                 text,
                 mode: "prompt",
                 permissionMode: command.permissionMode,
-                model: command.model,
-                thoughtLevel: command.thoughtLevel,
+                model: effectiveModel,
+                thoughtLevel: effectiveThoughtLevel,
                 requestId: command.requestId,
                 timeoutMs: command.timeoutMs,
             });
@@ -80,8 +83,8 @@ export async function handlePrompt(ws, config, command) {
                     turnId: command.turnId,
                     promptChars: text.length,
                     permissionMode: command.permissionMode ?? "approve-reads",
-                    model: command.model ?? undefined,
-                    thoughtLevel: command.thoughtLevel ?? undefined,
+                    ...(effectiveModel !== undefined ? { model: effectiveModel } : {}),
+                    ...(effectiveThoughtLevel !== undefined ? { thoughtLevel: effectiveThoughtLevel } : {}),
                 },
             });
             pumpRuntimeEvents(turn, ws, config, command);
@@ -98,7 +101,7 @@ export async function handlePrompt(ws, config, command) {
                 evidence: { requestId: command.requestId, turnId: command.turnId, error: errorMessage(error) },
             });
         }
-        const refreshedMetadata = await refreshedRuntimeMetadata(config, command, session, result);
+        const refreshedMetadata = await refreshedRuntimeMetadata(config, command, session, result, previousMetadata, effectiveModel, effectiveThoughtLevel);
         if (session.handle.backendSessionId && session.handle.backendSessionId !== previousBackendSessionId) {
             await appendAudit({
                 sessionId: command.sessionId,
@@ -175,13 +178,10 @@ function pumpRuntimeEvents(turn, ws, config, command) {
         }
     })();
 }
-async function refreshedRuntimeMetadata(config, command, session, result) {
+async function refreshedRuntimeMetadata(config, command, session, result, previousMetadata, modelMode, thoughtLevel) {
     if (!session.handle.backendSessionId)
         return undefined;
     try {
-        const previousMetadata = await commandSessionMetadata(config, command.encryptedMetadata);
-        const modelMode = command.model !== undefined ? command.model : previousMetadata?.modelMode;
-        const thoughtLevel = command.thoughtLevel !== undefined ? command.thoughtLevel : previousMetadata?.thoughtLevel;
         return await encryptedSessionMetadata(config, command.sessionId, session, {
             currentHead: result.currentHead,
             emptyRuntimeSession: result.status === "failed" && !result.currentHead && !result.lastTurnId,

package/apps/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-daemon",
-  "version": "0.1.0-beta.51",
+  "version": "0.1.0-beta.53",
   "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.51",
+  "version": "0.1.0-beta.53",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@cydm/happy-elves",
-      "version": "0.1.0-beta.51",
+      "version": "0.1.0-beta.53",
       "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.51",
+  "version": "0.1.0-beta.53",
   "description": "Remote controller for local coding agents with hosted or self-hosted relay support.",
   "type": "module",
   "bin": {

package/packages/runtime-cli/dist/claude-turn.d.ts

@@ -10,5 +10,4 @@ export declare function startClaudeTurn(input: {
     model?: string | null;
     thoughtLevel?: string | null;
     resume: boolean;
-    name?: string;
 }): RuntimeTurn;

package/packages/runtime-cli/dist/claude-turn.js

@@ -18,7 +18,6 @@ export function startClaudeTurn(input) {
         "stream-json",
         "--verbose",
         ...sessionArgs,
-        ...(input.name ? ["--name", input.name] : []),
         ...(model ? ["--model", model] : []),
         ...(effort ? ["--effort", effort] : []),
         "--permission-mode",
@@ -85,14 +84,21 @@ export function startClaudeTurn(input) {
             queue.push({ type: "status", text: "Claude session resumed", tag: typeof message.session_id === "string" ? message.session_id : undefined });
         }
     });
-    proc.stderr.on("data", (chunk) => queue.push({ type: "status", text: chunk.toString(), tag: "stderr" }));
+    const stderrTail = [];
+    proc.stderr.on("data", (chunk) => {
+        const text = chunk.toString();
+        stderrTail.push(text);
+        if (stderrTail.length > 25)
+            stderrTail.shift();
+        queue.push({ type: "status", text, tag: "stderr" });
+    });
     proc.on("exit", (code, signal) => {
         if (timer)
             clearTimeout(timer);
         if (!settled && code === 0)
             finish({ status: "completed" });
         if (!settled)
-            finish({ status: code === null && signal ? "cancelled" : "failed", error: { message: `Claude exited (${code ?? signal})` } });
+            finish({ status: code === null && signal ? "cancelled" : "failed", error: { message: claudeExitMessage(code, signal, stderrTail) } });
     });
     return {
         requestId: input.requestId,
@@ -108,6 +114,10 @@ export function startClaudeTurn(input) {
         },
     };
 }
+function claudeExitMessage(code, signal, stderrTail) {
+    const detail = stderrTail.map((line) => line.trim()).filter(Boolean).at(-1);
+    return `Claude exited (${code ?? signal})${detail ? `: ${detail}` : ""}`;
+}
 function normalizeClaudeModel(value) {
     if (value === undefined || value === null)
         return undefined;

package/packages/runtime-cli/dist/codex-app-server.d.ts

@@ -15,7 +15,9 @@ export declare class CodexAppServerSession {
     private readonly pendingCancelInterruptedTurns;
     private cancelSettlementTimer;
     private activeTurnOutputCount;
+    private activeTurnToolEventCount;
     private activeTurnStderr;
+    private activeTurnSelection;
     private completedTurnIds;
     private readonly timedOutTurnIds;
     private appliedPermissionMode;
@@ -71,4 +73,5 @@ export declare class CodexAppServerSession {
     private notificationBelongsToActiveTurn;
     private recordStderr;
     private emptyCompletionFailure;
+    private failedCompletionResult;
 }

package/packages/runtime-cli/dist/codex-app-server.js

@@ -21,7 +21,9 @@ export class CodexAppServerSession {
     pendingCancelInterruptedTurns = new Set();
     cancelSettlementTimer;
     activeTurnOutputCount = 0;
+    activeTurnToolEventCount = 0;
     activeTurnStderr = [];
+    activeTurnSelection = null;
     completedTurnIds = [];
     timedOutTurnIds = new Set();
     appliedPermissionMode;
@@ -114,7 +116,9 @@ export class CodexAppServerSession {
         const queue = new AsyncQueue();
         this.turnQueue = queue;
         this.activeTurnOutputCount = 0;
+        this.activeTurnToolEventCount = 0;
         this.activeTurnStderr = [];
+        this.activeTurnSelection = null;
         let settled = false;
         let resolveResult;
         const result = new Promise((resolve) => {
@@ -229,6 +233,10 @@ export class CodexAppServerSession {
     async sendTurn(text, timeoutMs = 10 * 60 * 1000, permissionMode, model, thoughtLevel, resolveTurn = this.turnResolve) {
         const threadId = await this.ensure(permissionMode, model);
         this.activeThreadId = threadId;
+        this.activeTurnSelection = {
+            model: this.appliedModel ?? null,
+            thoughtLevel: thoughtLevel === undefined ? undefined : normalizeRuntimeSelection(thoughtLevel),
+        };
         const completion = new Promise((resolve) => {
             this.activeCompletionResolve = resolve;
         });
@@ -318,6 +326,7 @@ export class CodexAppServerSession {
         this.activeThreadId = null;
         this.activeTurnId = null;
         this.activeTurnStart = null;
+        this.activeTurnSelection = null;
         this.pendingCancelReason = null;
         this.pendingCancelInterruptedTurns.clear();
     }
@@ -386,6 +395,21 @@ export class CodexAppServerSession {
             if (turnId && !this.completedTurnIds.includes(turnId))
                 this.completedTurnIds.push(turnId);
             this.restartableEmptyThread = false;
+            const turnStatus = stringField(recordFrom(payload.turn), "status");
+            if (turnStatus === "cancelled") {
+                this.activeCompletionResolve?.({
+                    status: "cancelled",
+                    currentHead: turnId ?? this.activeTurnId ?? undefined,
+                    lastTurnId: turnId ?? this.activeTurnId ?? undefined,
+                });
+                return;
+            }
+            if (turnStatus === "failed") {
+                const failedResult = this.failedCompletionResult(payload, turnId);
+                this.turnQueue?.push({ type: "error", message: failedResult.error.message, code: failedResult.error.code, retryable: failedResult.error.retryable });
+                this.activeCompletionResolve?.(failedResult);
+                return;
+            }
             const emptyFailure = this.emptyCompletionFailure();
             if (emptyFailure) {
                 this.turnQueue?.push({ type: "error", message: emptyFailure, code: "CODEX_EMPTY_COMPLETION", retryable: true });
@@ -398,7 +422,7 @@ export class CodexAppServerSession {
                 return;
             }
             this.activeCompletionResolve?.({
-                status: stringField(recordFrom(payload.turn), "status") === "cancelled" ? "cancelled" : "completed",
+                status: "completed",
                 currentHead: turnId ?? this.activeTurnId ?? undefined,
                 lastTurnId: turnId ?? this.activeTurnId ?? undefined,
             });
@@ -419,6 +443,7 @@ export class CodexAppServerSession {
         if (method === "item/started" || method === "item/completed") {
             const tool = codexToolEventFromItem(item, method === "item/started" ? "started" : "completed");
             if (tool?.type === "tool_call") {
+                this.activeTurnToolEventCount += 1;
                 queue.push({ type: "tool_call", text: tool.text, title: tool.title, status: tool.status, toolCallId: tool.toolCallId });
             }
         }
@@ -453,19 +478,48 @@ export class CodexAppServerSession {
     emptyCompletionFailure() {
         if (this.activeTurnOutputCount > 0)
             return undefined;
+        if (this.activeTurnToolEventCount > 0)
+            return undefined;
         const stderr = this.activeTurnStderr.join("\n");
+        const selection = this.activeTurnSelection
+            ? ` (model=${this.activeTurnSelection.model ?? "default"}, thoughtLevel=${this.activeTurnSelection.thoughtLevel ?? "default"})`
+            : "";
         if (!stderr.trim())
-            return undefined;
+            return `Codex turn completed without assistant output or tool activity${selection}`;
         const runtimeErrorPattern = /(401 Unauthorized|Missing bearer|failed to connect|stream disconnected|sampling request|tls handshake|unexpected status|Unsupported service_tier)/iu;
         if (!runtimeErrorPattern.test(stderr)) {
             const detail = this.activeTurnStderr.map((line) => codexStderrMessage(line)).filter(Boolean).at(-1);
-            return `Codex turn completed without assistant output after runtime diagnostics${detail ? `: ${detail}` : ""}`;
+            return `Codex turn completed without assistant output after runtime diagnostics${selection}${detail ? `: ${detail}` : ""}`;
         }
         const detail = this.activeTurnStderr
             .map((line) => codexStderrMessage(line))
             .filter((line) => runtimeErrorPattern.test(line))
             .at(-1);
-        return `Codex turn completed without assistant output after runtime errors${detail ? `: ${detail}` : ""}`;
+        return `Codex turn completed without assistant output after runtime errors${selection}${detail ? `: ${detail}` : ""}`;
+    }
+    failedCompletionResult(payload, turnId) {
+        const turn = recordFrom(payload.turn);
+        const error = recordFrom(turn.error ?? payload.error);
+        const detail = this.activeTurnStderr.map((line) => codexStderrMessage(line)).filter(Boolean).at(-1);
+        const message = stringField(error, "message") ??
+            stringField(turn, "message", "error") ??
+            stringField(payload, "message", "error") ??
+            detail ??
+            "Codex turn failed";
+        const code = stringField(error, "code");
+        const detailCode = stringField(error, "detailCode", "detail_code");
+        const retryable = typeof error.retryable === "boolean" ? error.retryable : undefined;
+        return {
+            status: "failed",
+            currentHead: turnId ?? this.activeTurnId ?? undefined,
+            lastTurnId: turnId ?? this.activeTurnId ?? undefined,
+            error: {
+                message,
+                ...(code ? { code } : {}),
+                ...(detailCode ? { detailCode } : {}),
+                ...(retryable !== undefined ? { retryable } : {}),
+            },
+        };
     }
 }
 function codexRuntimeOptionsFromModelList(value) {

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;
@@ -49,14 +49,13 @@ export function codexThreadResumeParams(threadId, cwd, permissionMode, model) {
     };
 }
 export function codexTurnStartParams(threadId, cwd, text, permissionMode, model, thoughtLevel) {
-    const normalizedModel = normalizeRuntimeSelection(model);
+    void model;
     const effort = normalizeCodexReasoningEffort(thoughtLevel);
     return {
         threadId,
         cwd,
         input: [{ type: "text", text }],
-        ...(normalizedModel ? { model: normalizedModel } : {}),
-        ...(effort ? { effort } : {}),
+        ...(effort ? { reasoningEffort: effort } : {}),
         approvalPolicy: codexApprovalPolicy(permissionMode),
         sandboxPolicy: codexTurnSandboxPolicy(permissionMode),
     };

package/packages/runtime-cli/dist/index.js

@@ -131,23 +131,41 @@ export function createCliRuntimeProvider(options) {
                 model: input.model,
                 thoughtLevel: input.thoughtLevel,
                 resume: session.claudeStarted === true,
-                name: session.pendingClaudeName,
             });
-            session.activeClaudeTurn = turn;
+            const pendingName = session.pendingClaudeName;
+            const result = turn.result.then(async (value) => {
+                if (value.status === "completed" && pendingName && input.handle.backendSessionId) {
+                    if (session.pendingClaudeName !== pendingName)
+                        return value;
+                    try {
+                        await renameClaudeSession({
+                            cwd: input.handle.cwd ?? options.cwd,
+                            sessionId: input.handle.backendSessionId,
+                            name: pendingName,
+                        });
+                        if (session.pendingClaudeName === pendingName)
+                            session.pendingClaudeName = undefined;
+                        return value;
+                    }
+                    catch (error) {
+                        return {
+                            status: "failed",
+                            currentHead: value.currentHead,
+                            lastTurnId: value.lastTurnId,
+                            error: { message: `Claude session rename failed after first turn: ${error instanceof Error ? error.message : String(error)}` },
+                        };
+                    }
+                }
+                return value;
+            });
+            const namedTurn = { ...turn, result };
+            session.activeClaudeTurn = namedTurn;
             session.claudeStarted = true;
-            turn.result.finally(() => {
-                if (session.activeClaudeTurn === turn)
+            namedTurn.result.finally(() => {
+                if (session.activeClaudeTurn === namedTurn)
                     session.activeClaudeTurn = undefined;
             });
-            if (session.pendingClaudeName) {
-                const pendingName = session.pendingClaudeName;
-                turn.result.then((result) => {
-                    if (result.status === "completed" && session.pendingClaudeName === pendingName) {
-                        session.pendingClaudeName = undefined;
-                    }
-                });
-            }
-            return turn;
+            return namedTurn;
         },
         async cancel(input) {
             assertNotExternalProviderHandle(input.handle);
@@ -218,6 +236,8 @@ export function createCliRuntimeProvider(options) {
                 return { handle: input.handle, name: input.name };
             }
             const name = await renameClaudeSession({ cwd, sessionId, name: input.name });
+            if (session)
+                session.pendingClaudeName = undefined;
             return { handle: input.handle, name };
         },
         async forkSession(input) {

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;