@cydm/happy-elves 0.1.0-beta.50 → 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/relay/register.js

@@ -24,6 +24,7 @@ function agentProfileForRegister(agent) {
         ...(agent.command ? { command: agent.command } : {}),
         ...(agent.historyModel ? { historyModel: agent.historyModel } : {}),
         ...(agent.sessionPrimitives ? { sessionPrimitives: runtimeAgentPrimitives(agent.sessionPrimitives) } : {}),
+        ...(agent.runtimeOptions ? { runtimeOptions: agent.runtimeOptions } : {}),
     };
 }
 function runtimeAgentPrimitives(primitives) {

package/apps/daemon/dist/runtime/external-provider.js

@@ -10,7 +10,7 @@ const maxJsonLineChars = 1024 * 1024;
 const stderrRingChars = 16 * 1024;
 const historicalEventPageLimit = 200;
 const historicalEventPageSafetyLimit = 1_000;
-const pieMinimumVersion = "1.0.20";
+const pieMinimumVersion = "1.0.21";
 const pieAutoProbeTimeoutMs = 5_000;
 export function externalProviderConfigsFromEnv() {
     const raw = process.env.HAPPY_ELVES_AGENT_PROVIDERS_JSON?.trim();
@@ -74,11 +74,12 @@ function pieCommandSupportsProvider(command) {
     const listResult = runPieProbe(command, ["sessions", "list", "--json", "--limit", "1"]);
     if (listResult.status !== 0)
         return false;
-    const modelsResult = runPieProbe(command, ["models", "validate"]);
+    const modelsResult = runPieProbe(command, ["models", "validate", "--json"]);
     if (modelsResult.status !== 0)
         return false;
     try {
         JSON.parse(listResult.stdout);
+        JSON.parse(modelsResult.stdout);
         return true;
     }
     catch {
@@ -315,6 +316,7 @@ export function createExternalAgentRuntimeProvider(options) {
                         rename: agent.capabilities.sessionPrimitives.rename ?? "unsupported",
                     }
                     : { resume: "unsupported", rewind: "unsupported", fork: "unsupported", rename: "unsupported" },
+                runtimeOptions: agent.capabilities?.runtimeOptions,
             }));
             const agentsById = new Map();
             for (const agent of externalAgents)
@@ -338,6 +340,8 @@ export function createExternalAgentRuntimeProvider(options) {
                 ...(input.resumeHandle ? { resumeHandle: sdkHandle(input.resumeHandle) } : {}),
                 cwd: input.cwd,
                 permissionMode: input.permissionMode,
+                model: input.model,
+                thoughtLevel: input.thoughtLevel,
                 restartableEmptySession: input.restartableEmptySession,
             }), "ensureSession result handle");
             return toRuntimeHandle(input.sessionKey, handle, input.cwd);
@@ -429,6 +433,8 @@ export function createExternalAgentRuntimeProvider(options) {
                 attachments: input.attachments,
                 mode: input.mode,
                 permissionMode: input.permissionMode,
+                model: input.model,
+                thoughtLevel: input.thoughtLevel,
                 requestId: input.requestId,
                 timeoutMs: input.timeoutMs,
             });

package/apps/daemon/dist/session/lifecycle.js

@@ -22,6 +22,8 @@ export async function handleCreateSession(ws, config, command) {
             mode: "persistent",
             cwd,
             permissionMode: metadata?.permissionMode,
+            model: metadata?.modelMode,
+            thoughtLevel: metadata?.thoughtLevel,
         });
         let providerName;
         const requestedRuntimeName = metadata?.requestedRuntimeName;
@@ -68,6 +70,9 @@ export async function handleCreateSession(ws, config, command) {
             ...(providerName ? { name: providerName } : {}),
             encryptedMetadata: await encryptedSessionMetadata(config, command.sessionId, state, {
                 emptyRuntimeSession: true,
+                modelMode: metadata?.modelMode,
+                thoughtLevel: metadata?.thoughtLevel,
+                runtimeOptions: handle.runtimeOptions,
                 ...(providerName ? { providerName, renamedAt: new Date().toISOString() } : {}),
                 readyAt: new Date().toISOString(),
             }),

package/apps/daemon/dist/session/prompt.js

@@ -6,7 +6,7 @@ import { activePromptRequests, completedPromptRequests, sessions, sessionTurns }
 import { attachClaimedTurn, claimSessionTurn, releaseSessionTurn, sendCommandResponse, sendReliable } from "../relay/send.js";
 import { emitEvent, runtimeEventToPayload } from "./events.js";
 import { replaceAuthoritativeTranscript, resumeSession, usesAuthoritativeTranscript } from "./lifecycle.js";
-import { encryptedSessionMetadata, sessionFallbackFromCommand } from "./metadata.js";
+import { commandSessionMetadata, encryptedSessionMetadata, sessionFallbackFromCommand } from "./metadata.js";
 export async function handlePrompt(ws, config, command) {
     if (command.type !== "machine:prompt")
         return;
@@ -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,6 +63,8 @@ export async function handlePrompt(ws, config, command) {
                 text,
                 mode: "prompt",
                 permissionMode: command.permissionMode,
+                model: effectiveModel,
+                thoughtLevel: effectiveThoughtLevel,
                 requestId: command.requestId,
                 timeoutMs: command.timeoutMs,
             });
@@ -78,6 +83,8 @@ export async function handlePrompt(ws, config, command) {
                     turnId: command.turnId,
                     promptChars: text.length,
                     permissionMode: command.permissionMode ?? "approve-reads",
+                    ...(effectiveModel !== undefined ? { model: effectiveModel } : {}),
+                    ...(effectiveThoughtLevel !== undefined ? { thoughtLevel: effectiveThoughtLevel } : {}),
                 },
             });
             pumpRuntimeEvents(turn, ws, config, command);
@@ -94,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,
@@ -171,13 +178,16 @@ 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 {
         return await encryptedSessionMetadata(config, command.sessionId, session, {
             currentHead: result.currentHead,
             emptyRuntimeSession: result.status === "failed" && !result.currentHead && !result.lastTurnId,
+            ...(modelMode !== undefined ? { modelMode } : {}),
+            ...(thoughtLevel !== undefined ? { thoughtLevel } : {}),
+            ...(previousMetadata?.runtimeOptions !== undefined ? { runtimeOptions: previousMetadata.runtimeOptions } : {}),
             runtimeMetadataRefreshedAt: new Date().toISOString(),
         });
     }

package/apps/daemon/dist/types.d.ts

@@ -1,5 +1,5 @@
 import type { SessionHeadAdvanceBasis } from "../../../packages/shared/dist/index.js";
-import type { RuntimeHandle, RuntimeTurn } from "../../../packages/runtime/dist/index.js";
+import type { RuntimeHandle, RuntimeOptions, RuntimeTurn } from "../../../packages/runtime/dist/index.js";
 export type DirectoryListResult = {
     machineId: string;
     path: string;
@@ -57,6 +57,9 @@ export type SessionMetadata = {
     providerName?: string;
     requestedRuntimeName?: string;
     permissionMode?: PermissionMode;
+    modelMode?: string | null;
+    thoughtLevel?: string | null;
+    runtimeOptions?: RuntimeOptions;
     importedFromRuntimeSessionId?: string;
     importedSummary?: string;
     sourceSessionId?: string;

package/apps/daemon/package.json

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

package/apps/relay/dist/connections.d.ts

@@ -9,6 +9,7 @@ export type PendingCommandContext = {
     command?: string;
     cwd?: string;
     machineId: string;
+    model?: string | null;
     name?: string;
     promptHash?: string;
     recipientDeviceId?: string;
@@ -19,6 +20,7 @@ export type PendingCommandContext = {
     sourceSessionId?: string;
     targetSessionId?: string;
     timeoutMs?: number;
+    thoughtLevel?: string | null;
     turnId?: string;
 };
 export declare function machineKey(accountId: string, machineId: string): string;

package/apps/relay/dist/controller-handlers.js

@@ -169,12 +169,16 @@ export function handleControllerMessage(context, connection, message) {
             return;
         }
         rememberAcceptedRun(connection, { machineId: sessionRow.machine_id, sessionId: sessionRow.id, turnId: message.turnId });
+        const model = normalizeRuntimeSelectionContext(message.model);
+        const thoughtLevel = normalizeRuntimeSelectionContext(message.thoughtLevel);
         markCommandPending(connection.accountId, sessionRow.machine_id, message.requestId, {
             action: "session.run",
             blocksSessionTurn: true,
+            model,
             promptHash: message.promptHash,
             recipientDeviceId: connection.deviceId ?? undefined,
             sessionId: sessionRow.id,
+            thoughtLevel,
             turnId: message.turnId,
         });
         sendAck(connection, { type: "server:ack", requestId: message.requestId, ok: true, machineId: sessionRow.machine_id, sessionId: sessionRow.id, action: "session.run" });
@@ -198,6 +202,8 @@ export function handleControllerMessage(context, connection, message) {
             encryptedPrompt: message.encryptedPrompt,
             encryptedMetadata: sessionRow.encrypted_metadata ? parseJson(sessionRow.encrypted_metadata, undefined) : undefined,
             permissionMode: message.permissionMode,
+            model,
+            thoughtLevel,
             timeoutMs: message.timeoutMs,
         });
         return;
@@ -730,7 +736,15 @@ function controllerMessageCommandContext(message, targetMachineId) {
         case "controller:createSession":
             return { action: "session.create", agent: message.agent, cwd: message.cwd, machineId: message.machineId, name: message.name };
         case "controller:prompt":
-            return { action: "session.run", machineId: targetMachineId, promptHash: message.promptHash, sessionId: message.sessionId, turnId: message.turnId };
+            return {
+                action: "session.run",
+                machineId: targetMachineId,
+                model: normalizeRuntimeSelectionContext(message.model),
+                promptHash: message.promptHash,
+                sessionId: message.sessionId,
+                thoughtLevel: normalizeRuntimeSelectionContext(message.thoughtLevel),
+                turnId: message.turnId,
+            };
         case "controller:cancel":
             return { action: "session.cancel", machineId: targetMachineId, sessionId: message.sessionId, turnId: message.turnId };
         case "controller:resume":
@@ -791,6 +805,8 @@ function pendingCommandMatchesMessage(pending, expected) {
         return false;
     if (!matchesDefined(pending.name, expected.name))
         return false;
+    if (expected.action === "session.run" && !matchesRuntimeSelection(pending.model, expected.model))
+        return false;
     if (!matchesDefined(pending.promptHash, expected.promptHash))
         return false;
     if (!matchesDefined(pending.runtimeSessionId, expected.runtimeSessionId))
@@ -801,6 +817,8 @@ function pendingCommandMatchesMessage(pending, expected) {
         return false;
     if (!matchesDefined(pending.targetSessionId, expected.targetSessionId))
         return false;
+    if (expected.action === "session.run" && !matchesRuntimeSelection(pending.thoughtLevel, expected.thoughtLevel))
+        return false;
     if (!matchesDefined(pending.turnId, expected.turnId))
         return false;
     if (!matchesDefined(pending.checkpoint, expected.checkpoint))
@@ -833,6 +851,8 @@ function retainedResponseMatchesCommand(previous, expected) {
         return false;
     if (!matchesDefined(responseTurnId(response), expected.turnId))
         return false;
+    if (expected.action === "session.run" && (expected.model !== undefined || expected.thoughtLevel !== undefined))
+        return false;
     if (expected.action === "machine.devExec" && !legacyDevExecResponseMatches(response, expected))
         return false;
     return true;
@@ -911,6 +931,17 @@ function responseTurnId(response) {
 function matchesDefined(actual, expected) {
     return expected === undefined || actual === expected;
 }
+function matchesRuntimeSelection(actual, expected) {
+    return actual === expected;
+}
+function normalizeRuntimeSelectionContext(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === null)
+        return null;
+    const normalized = value.trim();
+    return normalized.length === 0 || normalized.toLowerCase() === "default" ? null : normalized;
+}
 function sendRequestIdConflict(connection, send, requestId) {
     send(connection.socket, {
         type: "server:error",

package/apps/relay/dist/projections.js

@@ -21,6 +21,38 @@ function primitiveSupport(value) {
 function historyModel(value) {
     return value === "append-only" || value === "authoritative-linear" ? value : undefined;
 }
+function runtimeSelectionOption(value) {
+    if (!isRecord(value) || typeof value.key !== "string" || value.key.length === 0 || typeof value.label !== "string" || value.label.length === 0) {
+        return undefined;
+    }
+    return {
+        key: value.key,
+        label: value.label,
+        ...(typeof value.description === "string" || value.description === null ? { description: value.description } : {}),
+    };
+}
+function runtimeSelectionOptions(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const options = value.flatMap((item) => {
+        const option = runtimeSelectionOption(item);
+        return option ? [option] : [];
+    });
+    return options.length > 0 ? options : undefined;
+}
+function runtimeOptions(value) {
+    if (!isRecord(value))
+        return undefined;
+    const models = runtimeSelectionOptions(value.models);
+    const thoughtLevels = runtimeSelectionOptions(value.thoughtLevels);
+    const normalized = {
+        ...(models ? { models } : {}),
+        ...(thoughtLevels ? { thoughtLevels } : {}),
+        ...(typeof value.currentModel === "string" && value.currentModel.length > 0 ? { currentModel: value.currentModel } : {}),
+        ...(typeof value.currentThoughtLevel === "string" && value.currentThoughtLevel.length > 0 ? { currentThoughtLevel: value.currentThoughtLevel } : {}),
+    };
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
 export function normalizeMachineCapabilities(value) {
     const record = isRecord(value) ? value : {};
     const agents = Array.isArray(record.agents)
@@ -32,6 +64,7 @@ export function normalizeMachineCapabilities(value) {
                     label: agent.label,
                     ...(typeof agent.command === "string" ? { command: agent.command } : {}),
                     ...(historyModel(agent.historyModel) ? { historyModel: historyModel(agent.historyModel) } : {}),
+                    ...(runtimeOptions(agent.runtimeOptions) ? { runtimeOptions: runtimeOptions(agent.runtimeOptions) } : {}),
                     ...(isRecord(agent.sessionPrimitives)
                         ? {
                             sessionPrimitives: {

package/apps/relay/dist/relay-context.js

@@ -285,6 +285,7 @@ export function createRelayContext(options) {
             ...(pending.command !== undefined ? { command: pending.command } : {}),
             ...(pending.cwd !== undefined ? { cwd: pending.cwd } : {}),
             machineId: pending.machineId,
+            ...(pending.model !== undefined ? { model: pending.model } : {}),
             ...(pending.name !== undefined ? { name: pending.name } : {}),
             ...(pending.promptHash !== undefined ? { promptHash: pending.promptHash } : {}),
             ...(pending.runtimeSessionId !== undefined ? { runtimeSessionId: pending.runtimeSessionId } : {}),
@@ -293,6 +294,7 @@ export function createRelayContext(options) {
             ...(pending.sourceSessionId !== undefined ? { sourceSessionId: pending.sourceSessionId } : {}),
             ...(pending.targetSessionId !== undefined ? { targetSessionId: pending.targetSessionId } : {}),
             ...(pending.timeoutMs !== undefined ? { timeoutMs: pending.timeoutMs } : {}),
+            ...(pending.thoughtLevel !== undefined ? { thoughtLevel: pending.thoughtLevel } : {}),
             ...(pending.turnId !== undefined ? { turnId: pending.turnId } : {}),
         });
     }
@@ -319,6 +321,7 @@ export function createRelayContext(options) {
                 ...(typeof parsed.command === "string" ? { command: parsed.command } : {}),
                 ...(typeof parsed.cwd === "string" ? { cwd: parsed.cwd } : {}),
                 machineId: parsed.machineId,
+                ...(runtimeSelectionContext(parsed.model) !== undefined ? { model: runtimeSelectionContext(parsed.model) } : {}),
                 ...(typeof parsed.name === "string" ? { name: parsed.name } : {}),
                 ...(typeof parsed.promptHash === "string" ? { promptHash: parsed.promptHash } : {}),
                 requestId: "",
@@ -328,6 +331,7 @@ export function createRelayContext(options) {
                 ...(typeof parsed.sourceSessionId === "string" ? { sourceSessionId: parsed.sourceSessionId } : {}),
                 ...(typeof parsed.targetSessionId === "string" ? { targetSessionId: parsed.targetSessionId } : {}),
                 ...(typeof parsed.timeoutMs === "number" ? { timeoutMs: parsed.timeoutMs } : {}),
+                ...(runtimeSelectionContext(parsed.thoughtLevel) !== undefined ? { thoughtLevel: runtimeSelectionContext(parsed.thoughtLevel) } : {}),
                 ...(typeof parsed.turnId === "string" ? { turnId: parsed.turnId } : {}),
             };
         }
@@ -335,6 +339,11 @@ export function createRelayContext(options) {
             return undefined;
         }
     }
+    function runtimeSelectionContext(value) {
+        if (value === null)
+            return null;
+        return typeof value === "string" ? value : undefined;
+    }
     function rememberDirectCommandResponse(accountId, machineId, requestId, response) {
         const pending = pendingWithMachine(accountId, machineId, requestId);
         const recipientDeviceId = pending?.recipientDeviceId;