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

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

@@ -77,6 +77,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/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;
@@ -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)

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/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.52",
   "private": true,
   "type": "module"
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.51",
+  "version": "0.1.0-beta.52",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@cydm/happy-elves",
-      "version": "0.1.0-beta.51",
+      "version": "0.1.0-beta.52",
       "license": "Apache-2.0",
       "dependencies": {
         "@fastify/cors": "11.2.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.51",
+  "version": "0.1.0-beta.52",
   "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.js

@@ -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) {