@cydm/happy-elves 0.1.0-beta.58 → 0.1.0-beta.59

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

@@ -1,4 +1,4 @@
-import type { SessionSnapshot } from "../../../../../packages/shared/dist/index.js";
+import type { PermissionMode, SessionSnapshot } from "../../../../../packages/shared/dist/index.js";
 import type { OrchestrationSummary } from "./types.js";
 import type { TurnSummary } from "./session-output.js";
 export type OrchestratorStatus = "idle" | "inProgress" | "completed" | "needsInput" | "blocked" | "failed" | "cancelled" | "offline" | "closed";
@@ -10,6 +10,7 @@ export type OrchestratorRequestRecord = {
     runtimeTurnId?: string;
     model?: string | null;
     thoughtLevel?: string | null;
+    permissionMode?: PermissionMode;
     createdAt: number;
 };
 export type OrchestratorMetadata = {

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

@@ -83,6 +83,9 @@ export function readOrchestratorMetadata(metadata) {
                     ...(typeof candidate.runtimeTurnId === "string" ? { runtimeTurnId: candidate.runtimeTurnId } : {}),
                     ...(candidate.model === null || typeof candidate.model === "string" ? { model: candidate.model } : {}),
                     ...(candidate.thoughtLevel === null || typeof candidate.thoughtLevel === "string" ? { thoughtLevel: candidate.thoughtLevel } : {}),
+                    ...(candidate.permissionMode === "approve-all" || candidate.permissionMode === "approve-reads" || candidate.permissionMode === "deny-all"
+                        ? { permissionMode: candidate.permissionMode }
+                        : {}),
                     createdAt: candidate.createdAt,
                 };
             }

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

@@ -31,8 +31,10 @@ Check local controller config, relay reachability, and daemon state.
   happy-elves remote revoke <deviceId> --json
 `,
     machine: `Usage:
-  happy-elves machine list [--verbose] [--json]
-  happy-elves machine status <machineId> [--verbose] [--json]
+  happy-elves machine list [--include-archived] [--verbose] [--json]
+  happy-elves machine status <machineId> [--include-archived] [--verbose] [--json]
+  happy-elves machine archive <machineId> [--json]
+  happy-elves machine unarchive <machineId> [--json]
   happy-elves machine diagnose <machineId> [--json]
   happy-elves machine directory <machineId> [--path <path>] [--json]
   happy-elves machine exec <machineId> --shell <command> [--cwd <path>] [--timeout-ms <ms>] [--wait-timeout-ms <ms>] [--json]
@@ -58,6 +60,9 @@ Codex-like orchestration:
   returns a deterministic turnId for the supplied request id. wait-thread waits
   for that exact turn id instead of following the latest turn. handoff injects
   bounded source turn context directly into the target prompt.
+  Permission defaults to trusted-local Yolo (approve-all). Use --permission-mode
+  default/ask/accept-edits/approve-reads/deny-all/read-only only to tighten one
+  turn.
 `,
     session: `Usage:
   happy-elves session create --machine <machineId> [--agent codex] [--cwd <path>] [--name <name>] [--permission-mode <mode>] [--model <key>] [--thought-level <key>|--thinking <key>] --json
@@ -88,7 +93,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] [--model <key>] [--thought-level <key>|--thinking <key>] [--json]
+  happy-elves turn run <sessionId> (--text <prompt> | --text-file <path>) [--detach] [--timeout 1000s] [--runtime-timeout 1000s] [--permission-mode <mode>] [--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
@@ -96,7 +101,9 @@ Session management:
 
 Turn management:
   run starts one agent execution. It waits by default; use --detach for
-  background execution.
+  background execution. Permission defaults to trusted-local Yolo (approve-all);
+  pass --permission-mode default/ask/accept-edits/approve-reads/deny-all/read-only
+  to tighten.
   wait/result inspect a specific turn.
   rewind/fork operate on a turn or checkpoint id supplied by runtime history.
 `,
@@ -164,7 +171,7 @@ export function commandUsage(command, exitCode = 1) {
 export function usageText() {
     return `happy-elves
 
-Happy Elves is a remote controller and orchestration layer for coding agents across machines. The local agent remains the authority for runtime state. Agents should run happy-elves --skill before using this CLI.
+Happy Elves is a remote controller and orchestration layer for coding agents across machines. The local agent remains the authority for runtime state. Agents should run happy-elves skill doctor --name happy-elves-orchestrator --json before orchestrating; happy-elves --skill remains legacy guidance.
 
 Core commands:
   machine list [--json]
@@ -248,6 +255,19 @@ Recommended agent workflow:
   5. orchestrator read-turn <threadId> <turnId> --json
   6. orchestrator handoff --from <sourceThreadId> --turn <sourceTurnId> --to <targetThreadId> --text <instruction> --request-id <stable-id> --json
 
+Permission defaults:
+  Happy Elves is trusted-local by default. If orchestrator send-message omits
+  --permission-mode, the effective permission is approve-all. Pass
+  --permission-mode default/ask/accept-edits/approve-reads/deny-all/read-only
+  only when you intentionally want to tighten a turn. Inspect
+  effectivePermissionMode and permissionSource before diagnosing sandbox, git,
+  desktop, or backend permission failures.
+
+Orchestrator idempotency:
+  Reusing the same request id with the same prompt/model/thinking/permission
+  returns the same turn. Reusing it with different prompt/model/thinking/
+  permission returns REQUEST_ID_CONFLICT.
+
 Concepts:
   Loaded session: a Happy Elves control-plane session that can be operated by
   this CLI.
@@ -282,8 +302,9 @@ 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/model/thinking returns the same turn;
-  reusing it with different prompt/model/thinking returns REQUEST_ID_CONFLICT.
+  same request id with the same prompt/model/thinking/permission returns the
+  same turn; reusing it with different prompt/model/thinking/permission returns
+  REQUEST_ID_CONFLICT.
   After send-message, keep the orchestrator turn open and wait on the exact
   returned turn id until terminal. Do not stop after dispatching the prompt.
   For direct handoff, prefer handoff or send-message --context-turn. The CLI

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

@@ -6,6 +6,8 @@ function structuredMachineSummary(machine) {
         machineId: machine.id,
         name: machine.metadata.name ?? machine.name,
         online: machine.online,
+        archived: Boolean(machine.archivedAt),
+        archivedAt: machine.archivedAt,
         sessionCount: summary.sessionCount,
         runningCount: summary.runningSessionCount,
         blockedCount: summary.blockedSessionCount,
@@ -15,6 +17,8 @@ function structuredMachineVerbose(machine) {
     return {
         machineId: machine.id,
         online: machine.online,
+        archived: Boolean(machine.archivedAt),
+        archivedAt: machine.archivedAt,
         lastSeen: machine.lastSeen,
         name: machine.metadata.name ?? machine.name,
         defaultCwd: machine.defaultCwd,
@@ -28,14 +32,17 @@ function structuredMachineVerbose(machine) {
 function printMachineLine(machine) {
     const name = machine.metadata.name ?? machine.name;
     const summary = machine.summary;
-    console.log(`${machine.id}  ${machine.online ? "online" : "offline"}  ${compactText(name, 32)}  sessions:${summary.sessionCount} running:${summary.runningSessionCount} blocked:${summary.blockedSessionCount}`);
+    const state = machine.archivedAt ? "archived" : machine.online ? "online" : "offline";
+    console.log(`${machine.id}  ${state}  ${compactText(name, 32)}  sessions:${summary.sessionCount} running:${summary.runningSessionCount} blocked:${summary.blockedSessionCount}`);
 }
 function printMachineDetails(machine) {
     const name = machine.metadata.name ?? machine.name;
     const agents = machine.capabilities.agents.map((agent) => agent.id).join(", ") || "-";
     const summary = machine.summary;
     console.log(`${name} (${machine.id})`);
-    console.log(`  status: ${machine.online ? "online" : "offline"}  agents: ${agents}`);
+    console.log(`  status: ${machine.archivedAt ? "archived" : machine.online ? "online" : "offline"}  agents: ${agents}`);
+    if (machine.archivedAt)
+        console.log(`  archived: ${new Date(machine.archivedAt).toISOString()}`);
     console.log(`  cwd: ${machine.defaultCwd ?? "-"}`);
     console.log(`  sessions: ${summary.sessionCount} total, ${summary.runningSessionCount} running, ${summary.readySessionCount} ready, ${summary.needsUserSessionCount} needs user`);
     console.log(`  sessions: happy-elves session list --machine ${machine.id} --limit 20`);
@@ -171,7 +178,7 @@ export async function handleMachine({ domain, action, positional, flags }) {
         return true;
     }
     if (action === "list") {
-        const snapshot = await client.snapshot();
+        const snapshot = await client.snapshot({ includeArchived: flags["include-archived"] === true });
         const machines = await Promise.all(snapshot.machines.map(async (machine) => ({
             ...(await showMachine(client, machine)),
             ...(await machineSessionOverview(client, snapshot.sessions, machine.id)),
@@ -192,9 +199,26 @@ export async function handleMachine({ domain, action, positional, flags }) {
         });
         return true;
     }
+    if (action === "archive" || action === "unarchive" || action === "restore") {
+        const machineId = requirePositional(positional[0], "machineId");
+        const machine = action === "archive"
+            ? await client.archiveMachine(machineId)
+            : await client.unarchiveMachine(machineId);
+        const projectedMachine = await showMachine(client, machine);
+        const overviewSnapshot = await client.snapshot({ includeArchived: true });
+        const overview = await machineSessionOverview(client, overviewSnapshot.sessions, machine.id);
+        if (!wantsJson(flags)) {
+            printMachineLine({ ...projectedMachine, ...overview });
+            return true;
+        }
+        ok(action === "archive" ? "machine.archive" : "machine.unarchive", {
+            machine: structuredMachineVerbose({ ...projectedMachine, ...overview }),
+        }, { machineId: machine.id });
+        return true;
+    }
     if (action === "status") {
         const machineId = requirePositional(positional[0], "machineId");
-        const snapshot = await client.snapshot();
+        const snapshot = await client.snapshot({ includeArchived: flags["include-archived"] === true });
         const machine = snapshot.machines.find((item) => item.id === machineId);
         if (!machine)
             throw new CliError("Machine not found", "MACHINE_NOT_FOUND");
@@ -212,7 +236,7 @@ export async function handleMachine({ domain, action, positional, flags }) {
                 machineId: machine.id,
                 name: projectedMachine.metadata.name ?? machine.name,
                 online: machine.online,
-                state: machine.online ? "available" : "offline",
+                state: machine.archivedAt ? "archived" : machine.online ? "available" : "offline",
                 summary: overview.summary,
             }),
         }, { machineId: machine.id });

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

@@ -105,7 +105,34 @@ async function readThreadContext(client, threadId) {
     }
     return { machines: snapshot.machines, session };
 }
-function requestRecordForExistingTurn(turn, hash, selection, inputSha256, sourceOutputSha256, createdAt) {
+function effectivePermissionMode(requestedPermissionMode) {
+    return requestedPermissionMode ?? "approve-all";
+}
+function permissionEvidence(requestedPermissionMode, record) {
+    if (record?.permissionMode) {
+        return {
+            effectivePermissionMode: record.permissionMode,
+            permissionSource: "stored-request",
+            ...(requestedPermissionMode !== undefined ? { requestedPermissionMode } : {}),
+        };
+    }
+    if (record) {
+        return {
+            permissionSource: "legacy-record",
+            ...(requestedPermissionMode !== undefined ? { requestedPermissionMode } : {}),
+            permissionWarning: "existing turn predates stored permission evidence",
+        };
+    }
+    return {
+        effectivePermissionMode: effectivePermissionMode(requestedPermissionMode),
+        permissionSource: requestedPermissionMode === undefined ? "product-default" : "request",
+        ...(requestedPermissionMode !== undefined ? { requestedPermissionMode } : {}),
+    };
+}
+function samePermissionShape(existing, permissionMode) {
+    return existing.permissionMode === undefined || existing.permissionMode === permissionMode;
+}
+function requestRecordForExistingTurn(turn, hash, selection, permissionMode, inputSha256, sourceOutputSha256, createdAt) {
     if (!turn)
         return undefined;
     return {
@@ -115,6 +142,7 @@ function requestRecordForExistingTurn(turn, hash, selection, inputSha256, source
         ...(sourceOutputSha256 ? { sourceOutputSha256 } : {}),
         ...(turn.runtimeTurnId ? { runtimeTurnId: turn.runtimeTurnId } : {}),
         ...selectionRecordFields(selection),
+        ...(permissionMode !== undefined ? { permissionMode } : {}),
         createdAt: turn.startedAt ?? turn.updatedAt ?? createdAt,
     };
 }
@@ -130,13 +158,15 @@ function sameRequestRecord(existing, expected) {
         existing.inputSha256 === expected.inputSha256 &&
         existing.sourceOutputSha256 === expected.sourceOutputSha256 &&
         existing.model === expected.model &&
-        existing.thoughtLevel === expected.thoughtLevel;
+        existing.thoughtLevel === expected.thoughtLevel &&
+        samePermissionShape(existing, expected.permissionMode ?? "approve-all");
 }
 function sameBaseRequestShape(existing, input) {
     return existing.turnId === input.turnId &&
         existing.inputSha256 === input.inputSha256 &&
         existing.model === input.model &&
-        existing.thoughtLevel === input.thoughtLevel;
+        existing.thoughtLevel === input.thoughtLevel &&
+        samePermissionShape(existing, input.permissionMode);
 }
 function sameEffectiveRequestShape(existing, input) {
     return existing.promptSha256 === input.promptSha256 &&
@@ -383,25 +413,26 @@ async function safeEventsForThreadSummary(client, session) {
         return { events: [], historyFailure: threadHistoryFailure(error) };
     }
 }
-async function persistRequestRecordBestEffort(client, threadId, requestId, record) {
+async function persistRequestRecord(client, threadId, requestId, record) {
     for (let attempt = 0; attempt < 3; attempt += 1) {
         const { session } = await readThreadContext(client, threadId);
         const metadata = await client.decodeSessionMetadata(session);
         const existing = readOrchestratorMetadata(metadata).requests?.[requestId];
         if (existing) {
             if (sameRequestRecord(existing, record))
-                return;
-            return;
+                return { metadata, session };
+            throw requestConflict(threadId, requestId, record.turnId);
         }
         try {
-            await client.updateSessionMetadata(session.id, withOrchestratorRequest(metadata, requestId, record), { expectedUpdatedAt: session.updatedAt });
-            return;
+            const updated = await client.updateSessionMetadata(session.id, withOrchestratorRequest(metadata, requestId, record), { expectedEncryptedMetadata: session.encryptedMetadata ?? null, expectedUpdatedAt: session.updatedAt });
+            return { metadata: await client.decodeSessionMetadata(updated), session: updated };
         }
         catch (error) {
             if (errorCode(error) !== "SESSION_METADATA_CONFLICT")
-                return;
+                throw error;
         }
     }
+    throw new OrchestratorError("Session metadata changed while recording request id; retry with the latest session.", "SESSION_METADATA_CONFLICT", { retryable: true, sessionId: threadId, turnId: record.turnId });
 }
 function terminalStatusForTurn(turn) {
     if (turn.status === "completed")
@@ -413,7 +444,7 @@ function terminalStatusForTurn(turn) {
     return "inProgress";
 }
 function requestConflict(threadId, requestId, turnId) {
-    return new OrchestratorError(`Request id already exists with different prompt, model, or thoughtLevel: ${requestId}`, "REQUEST_ID_CONFLICT", { retryable: false, sessionId: threadId, turnId });
+    return new OrchestratorError(`Request id already exists with different prompt, model, thoughtLevel, or permissionMode: ${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", {
@@ -477,6 +508,8 @@ async function sendOrchestratorMessage(client, flags, input) {
     const requestId = requireString(flags, "request-id");
     const turnId = deterministicTurnId(input.threadId, requestId);
     const relayRequestId = deterministicRelayRequestId(input.threadId, requestId);
+    const requestedPermissionMode = parsePermissionMode(flags["permission-mode"] ?? flags.permission);
+    const activePermissionMode = effectivePermissionMode(requestedPermissionMode);
     const model = parseRuntimeSelection(flags.model, "model");
     const thoughtLevel = parseThoughtLevel(flags);
     const selection = selectionRecordFields({ model, thoughtLevel });
@@ -495,6 +528,8 @@ async function sendOrchestratorMessage(client, flags, input) {
     const { session } = await readThreadContext(client, input.threadId);
     const metadata = await client.decodeSessionMetadata(session);
     const existingRequest = readOrchestratorMetadata(metadata).requests?.[requestId];
+    let existingRequestContext;
+    let existingRequestText;
     const earlyContextData = input.contextTurn ? {
         context: {
             sourceThreadId: input.contextTurn.sourceThreadId,
@@ -503,7 +538,7 @@ async function sendOrchestratorMessage(client, flags, input) {
         },
     } : {};
     if (existingRequest) {
-        if (!sameBaseRequestShape(existingRequest, { turnId, inputSha256, ...selection }))
+        if (!sameBaseRequestShape(existingRequest, { turnId, inputSha256, ...selection, permissionMode: activePermissionMode }))
             throw requestConflict(input.threadId, requestId, turnId);
         const existingTurn = await readExactTurn(client, input.threadId, turnId, metadata);
         let context;
@@ -517,8 +552,22 @@ async function sendOrchestratorMessage(client, flags, input) {
                 resolvedEffectivePrompt = false;
             }
         }
+        if (!resolvedEffectivePrompt) {
+            ok(input.responseType, {
+                threadId: input.threadId,
+                sessionId: input.threadId,
+                turnId,
+                requestId,
+                status: "inProgress",
+                rawStatus: existingTurn?.status ?? "pending",
+                ...permissionEvidence(requestedPermissionMode, existingRequest),
+                ...earlyContextData,
+            }, { requestId, sessionId: input.threadId, turnId });
+            return;
+        }
         if (resolvedEffectivePrompt) {
             const effectivePrompt = context?.prompt ?? input.instruction;
+            existingRequestText = effectivePrompt;
             if (!sameEffectiveRequestShape(existingRequest, {
                 promptSha256: promptSha256(effectivePrompt),
                 ...(context?.sourceOutputSha256 ? { sourceOutputSha256: context.sourceOutputSha256 } : {}),
@@ -541,6 +590,7 @@ async function sendOrchestratorMessage(client, flags, input) {
                     latest: output.latestPath,
                     metadata: output.metadataPath,
                 },
+                ...permissionEvidence(requestedPermissionMode, existingRequest),
                 ...(context ? {
                     context: {
                         sourceThreadId: context.source.threadId,
@@ -554,21 +604,25 @@ async function sendOrchestratorMessage(client, flags, input) {
             }, { requestId, sessionId: input.threadId, turnId });
             return;
         }
-        ok(input.responseType, {
-            threadId: input.threadId,
-            sessionId: input.threadId,
-            turnId,
-            requestId,
-            status: "inProgress",
-            rawStatus: existingTurn?.status ?? "pending",
-            ...earlyContextData,
-        }, { requestId, sessionId: input.threadId, turnId });
-        return;
+        if (existingTurn?.status === "running") {
+            ok(input.responseType, {
+                threadId: input.threadId,
+                sessionId: input.threadId,
+                turnId,
+                requestId,
+                status: "inProgress",
+                rawStatus: existingTurn.status,
+                ...permissionEvidence(requestedPermissionMode, existingRequest),
+                ...earlyContextData,
+            }, { requestId, sessionId: input.threadId, turnId });
+            return;
+        }
+        existingRequestContext = context;
     }
-    const context = input.contextTurn
+    const context = existingRequestContext ?? (input.contextTurn
         ? await buildContextPrompt(client, input.contextTurn, input.instruction, includeContextOutput)
-        : undefined;
-    const text = context?.prompt ?? input.instruction;
+        : undefined);
+    const text = existingRequestText ?? context?.prompt ?? input.instruction;
     const hash = promptSha256(text);
     const record = {
         turnId,
@@ -576,6 +630,7 @@ async function sendOrchestratorMessage(client, flags, input) {
         inputSha256,
         ...(context?.sourceOutputSha256 ? { sourceOutputSha256: context.sourceOutputSha256 } : {}),
         ...selection,
+        permissionMode: activePermissionMode,
         createdAt: Date.now(),
     };
     const contextData = context ? {
@@ -593,32 +648,21 @@ async function sendOrchestratorMessage(client, flags, input) {
     const existingTurn = await readExactTurn(client, input.threadId, turnId, metadata);
     if (existingTurn?.prompt && promptSha256(existingTurn.prompt) !== hash)
         throw requestConflict(input.threadId, requestId, turnId);
-    if (existingRequest && !existingTurn) {
-        ok(input.responseType, {
-            threadId: input.threadId,
-            sessionId: input.threadId,
-            turnId,
-            requestId,
-            status: "inProgress",
-            rawStatus: "pending",
-            ...contextData,
-        }, { requestId, sessionId: input.threadId, turnId });
-        return;
-    }
     const active = turns[0]?.status === "running" ? turns[0] : undefined;
     const latestCompleted = turns.find((turn) => turn.status === "completed");
     if (active && active.turnId !== turnId)
         throw threadBusy(input.threadId, active, latestCompleted);
     if (existingTurn && existingTurn.status !== "running") {
         const output = await rebuildOutputForTurn(client, input.threadId, existingTurn);
-        await persistRequestRecordBestEffort(client, input.threadId, requestId, requestRecordForExistingTurn(existingTurn, hash, selection, inputSha256, context?.sourceOutputSha256, Date.now()) ?? {
+        const existingTurnRecord = requestRecordForExistingTurn(existingTurn, hash, selection, undefined, inputSha256, context?.sourceOutputSha256, Date.now()) ?? {
             turnId,
             promptSha256: hash,
             inputSha256,
             ...(context?.sourceOutputSha256 ? { sourceOutputSha256: context.sourceOutputSha256 } : {}),
             ...selection,
             createdAt: Date.now(),
-        });
+        };
+        await persistRequestRecord(client, input.threadId, requestId, existingTurnRecord);
         ok(input.responseType, {
             threadId: input.threadId,
             sessionId: input.threadId,
@@ -632,11 +676,13 @@ async function sendOrchestratorMessage(client, flags, input) {
                 latest: output.latestPath,
                 metadata: output.metadataPath,
             },
+            ...permissionEvidence(requestedPermissionMode, existingTurnRecord),
             ...contextData,
         }, { requestId, sessionId: input.threadId, turnId });
         return;
     }
     if (existingTurn?.status === "running") {
+        const runningTurnRecord = requestRecordForExistingTurn(existingTurn, hash, selection, undefined, inputSha256, context?.sourceOutputSha256, Date.now());
         ok(input.responseType, {
             threadId: input.threadId,
             sessionId: input.threadId,
@@ -644,16 +690,19 @@ async function sendOrchestratorMessage(client, flags, input) {
             requestId,
             status: "inProgress",
             rawStatus: existingTurn?.status ?? "running",
+            ...permissionEvidence(requestedPermissionMode, runningTurnRecord),
             ...contextData,
         }, { requestId, sessionId: input.threadId, turnId });
         return;
     }
-    const permissionMode = parsePermissionMode(flags["permission-mode"] ?? flags.permission);
     const runtimeTimeoutMs = parseDurationMs(flags["runtime-timeout"], DEFAULT_COMMAND_TIMEOUT_MS);
+    const storedRecord = existingRequest ?? record;
+    if (!existingRequest)
+        await persistRequestRecord(client, input.threadId, requestId, record);
     try {
         await client.run(input.threadId, text, {
             wait: false,
-            permissionMode,
+            permissionMode: requestedPermissionMode,
             requestId: relayRequestId,
             turnId,
             promptHash: hash,
@@ -679,7 +728,6 @@ async function sendOrchestratorMessage(client, flags, input) {
         }
         throw error;
     }
-    await persistRequestRecordBestEffort(client, input.threadId, requestId, record);
     ok(input.responseType, {
         threadId: input.threadId,
         sessionId: input.threadId,
@@ -687,6 +735,7 @@ async function sendOrchestratorMessage(client, flags, input) {
         requestId,
         status: "inProgress",
         rawStatus: "running",
+        ...permissionEvidence(requestedPermissionMode, storedRecord),
         ...contextData,
     }, { requestId, sessionId: input.threadId, turnId });
 }
@@ -835,7 +884,10 @@ export async function handleOrchestrator({ domain, action, positional, flags })
         const metadata = await client.decodeSessionMetadata(session);
         let updated;
         try {
-            updated = await client.updateSessionMetadata(threadId, withOrchestratorTags(metadata, tags), { expectedUpdatedAt: session.updatedAt });
+            updated = await client.updateSessionMetadata(threadId, withOrchestratorTags(metadata, tags), {
+                expectedEncryptedMetadata: session.encryptedMetadata ?? null,
+                expectedUpdatedAt: session.updatedAt,
+            });
         }
         catch (error) {
             if (errorCode(error) !== "SESSION_METADATA_CONFLICT")

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

@@ -188,12 +188,27 @@ function numberMetadata(metadata, key) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function diagnosticPermission(metadata) {
+    const metadataPermissionMode = stringMetadata(metadata, "permissionMode");
+    if (metadataPermissionMode === "approve-all" || metadataPermissionMode === "approve-reads" || metadataPermissionMode === "deny-all") {
+        return {
+            effectivePermissionMode: metadataPermissionMode,
+            permissionSource: "session-metadata",
+            metadataPermissionMode,
+        };
+    }
+    return {
+        effectivePermissionMode: "approve-all",
+        permissionSource: "product-default",
+    };
+}
 function diagnosticSessionMetadata(metadata) {
     const runtime = isRecord(metadata.runtime) ? metadata.runtime : {};
     return {
         agent: stringMetadata(metadata, "agent"),
         cwd: stringMetadata(metadata, "cwd"),
         name: stringMetadata(metadata, "name"),
+        permissionMode: stringMetadata(metadata, "permissionMode"),
         providerName: stringMetadata(metadata, "providerName"),
         importedFromRuntimeSessionId: stringMetadata(metadata, "importedFromRuntimeSessionId"),
         runtime: {
@@ -510,6 +525,7 @@ export async function handleSession({ domain, action, positional, flags }) {
             : undefined;
         if (repair)
             session = repair.session;
+        const permission = diagnosticPermission(metadata);
         const data = {
             generatedAt: new Date().toISOString(),
             session: {
@@ -557,6 +573,9 @@ export async function handleSession({ domain, action, positional, flags }) {
             },
             orchestration,
             diagnosis: {
+                effectivePermissionMode: permission.effectivePermissionMode,
+                permissionSource: permission.permissionSource,
+                metadataPermissionMode: permission.metadataPermissionMode,
                 importedRuntimeSessionId: stringMetadata(metadata, "importedFromRuntimeSessionId"),
                 latestPageEmpty: latestPage.events.length === 0,
                 latestPageHasVisibleTranscript: latestPage.events.some(isVisibleTranscriptPayloadEvent),
@@ -598,6 +617,7 @@ export async function handleSession({ domain, action, positional, flags }) {
             console.log(`Machine: ${session.machineId}${machine ? `  ${machine.online ? "online" : "offline"}` : ""}`);
             const runtime = isRecord(metadata.runtime) ? metadata.runtime : {};
             console.log(`Runtime: ${stringMetadata(metadata, "importedFromRuntimeSessionId") ?? stringMetadata(runtime, "backendSessionId") ?? stringMetadata(runtime, "agentSessionId") ?? "-"}`);
+            console.log(`Permission: ${data.diagnosis.effectivePermissionMode}  source=${data.diagnosis.permissionSource}`);
             console.log(`Backfill: ${data.diagnosis.backfillStatus ?? "-"}  available=${data.diagnosis.backfillAvailableEvents ?? "-"} emitted=${data.diagnosis.backfillEmittedEvents ?? "-"}`);
             console.log(`Head: ${session.currentHead ?? "-"}  lastTurn=${session.lastTurnId ?? "-"}  stale=${data.diagnosis.staleHeadSuspected ? "yes" : "no"}`);
             console.log(`Latest page: ${latestPage.events.length} events, visible=${latestPage.events.filter(isVisibleTranscriptPayloadEvent).length}, hasMore=${latestPage.hasMoreBefore}`);
@@ -618,6 +638,7 @@ export async function handleSession({ domain, action, positional, flags }) {
             throw new CliError("Cannot repair binding for a running session", "SESSION_BINDING_REPAIR_RUNNING");
         const metadata = await client.decodeSessionMetadata(session);
         const { candidate, candidates } = await resolveRuntimeBindingRepairTarget(client, session, metadata, flags);
+        const permissionMode = parsePermissionMode(flags["permission-mode"] ?? flags.permission);
         const name = typeof flags.name === "string" && flags.name.trim()
             ? flags.name.trim()
             : stringMetadata(metadata, "name") ?? session.name ?? candidate.name ?? candidate.summary ?? candidate.runtimeSessionId;
@@ -627,6 +648,7 @@ export async function handleSession({ domain, action, positional, flags }) {
             cwd: candidate.cwd,
             runtimeSessionId: candidate.runtimeSessionId,
             name,
+            permissionMode,
             summary: candidate.summary,
             runtimeState: candidate.runtimeState,
             ...(candidate.name ? { providerName: candidate.name } : {}),
@@ -729,12 +751,14 @@ export async function handleSession({ domain, action, positional, flags }) {
         const name = typeof flags.name === "string" && flags.name.trim()
             ? flags.name.trim()
             : historical.name?.trim() || historical.summary?.trim() || historical.runtimeSessionName?.trim() || runtimeSessionId;
+        const permissionMode = parsePermissionMode(flags["permission-mode"] ?? flags.permission);
         const continued = await client.importHistoricalSession({
             machineId,
             agent: historical.agent,
             cwd: historical.cwd,
             runtimeSessionId,
             name,
+            permissionMode,
             summary: historical.summary,
             runtimeState: historical.runtimeState,
             ...(historical.name ? { providerName: historical.name } : {}),

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

@@ -53,6 +53,7 @@ async function cliVersion() {
 async function addCliEnvironmentChecks(checks, warnings) {
     const version = await cliVersion();
     checks.push({ name: "cli-version", status: "ok", detail: version });
+    checks.push({ name: "default-permission-mode", status: "ok", detail: "approve-all (trusted-local Yolo)" });
     const executable = process.argv[1] ? path.resolve(process.argv[1]) : process.execPath;
     const workspaceCli = path.resolve(process.cwd(), "apps", "cli", "dist", "index.js");
     try {

package/apps/cli/dist/skills/registry.js

@@ -1,7 +1,7 @@
 export const ORCHESTRATOR_SKILL_NAME = "happy-elves-orchestrator";
 const COMPUTER_USE_SKILL_NAME = "happy-elves-computer-use";
-const ORCHESTRATOR_SKILL_CONTRACT_VERSION = 2;
-const COMPUTER_USE_SKILL_CONTRACT_VERSION = 2;
+const ORCHESTRATOR_SKILL_CONTRACT_VERSION = 3;
+const COMPUTER_USE_SKILL_CONTRACT_VERSION = 3;
 function renderOrchestratorSkill(input) {
     return `---
 name: ${input.skillName}
@@ -32,8 +32,10 @@ Important rules:
 - First run \`happy-elves skill doctor --name happy-elves-orchestrator --json\` and verify the \`cli-executable\`, \`cli-version\`, \`workspace-cli\`, and \`git-commit-capability\` checks. If git commit capability is warning or a commit fails, report the blocker; do not claim staged-only changes are complete.
 - \`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/model/thinking returns the same turn.
-- Reusing the same request id with different prompt text, model, or thinking returns \`REQUEST_ID_CONFLICT\`.
+- Reusing the same request id with the same prompt/model/thinking/permission returns the same turn.
+- Reusing the same request id with different prompt text, model, thinking, or permission returns \`REQUEST_ID_CONFLICT\`.
+- Happy Elves defaults to trusted-local YOLO execution: if \`send-message\` omits \`--permission-mode\`, the effective permission is \`approve-all\`. Pass \`--permission-mode default\`, \`ask\`, \`accept-edits\`, \`approve-reads\`, \`deny-all\`, or \`read-only\` only when you intentionally want to tighten one turn.
+- Read \`effectivePermissionMode\` and \`permissionSource\` in \`send-message\` / \`handoff\` JSON before diagnosing sandbox, git, desktop, or backend permission failures.
 - 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.
@@ -158,7 +160,7 @@ open-computer-use call --calls '[
 
 Always call \`get_app_state\` before using an \`element_index\`. Prefer semantic element actions such as \`click\`, \`set_value\`, and \`type_text\` over raw coordinates.
 
-When a Happy Elves orchestrator asks a Codex-backed session to use this skill, the turn must be sent with \`--permission-mode approve-all\`. Creating the session with elevated permissions is not enough; later turns can otherwise fall back to a stricter permission mode and decline backend app-agent probes.
+Happy Elves orchestration defaults to \`approve-all\` for trusted local sessions. Do not add \`--permission-mode approve-all\` just for this skill; only pass a permission mode when intentionally tightening or debugging one turn. If desktop probes fail, check the orchestrator response \`effectivePermissionMode\` before blaming macOS, Open Computer Use, or app permissions.
 
 ## Background-Only Mode
 Use background-only mode when the user wants to keep using the computer while desktop dogfood runs. This mode is macOS-first; Windows and Linux support is best-effort and may require foreground desktop access.
@@ -252,6 +254,9 @@ const builtinSkills = [
             "keep this orchestrator turn open",
             "Strict handoff dogfood",
             "git-commit-capability",
+            "effectivePermissionMode",
+            "trusted-local YOLO",
+            "prompt/model/thinking/permission",
             "pnpm dogfood:orchestrator-real",
             "do not ask the target agent to read an intermediate markdown file",
         ],
@@ -268,7 +273,7 @@ const builtinSkills = [
             "OPEN_COMPUTER_USE_ALLOW_GLOBAL_POINTER_FALLBACKS",
             "pnpm dogfood:computer-use-background",
             "HAPPY_ELVES_CU_GATEWAY_CONFIRM=1",
-            "--permission-mode approve-all",
+            "effectivePermissionMode",
             "Live Feishu Gateway Dogfood",
             "FOREGROUND_STOLEN",
             "POINTER_MOVED",

package/apps/daemon/dist/gateway/runtime.js

@@ -271,6 +271,7 @@ async function loadGatewaySession(ws, config, gateway, binding, input) {
         agent,
         mode: "persistent",
         cwd,
+        permissionMode: "approve-all",
     });
     const session = {
         sessionId: binding.sessionId,