@cydm/happy-elves 0.1.0-beta.79 → 0.1.0-beta.80

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

@@ -2,7 +2,7 @@ import { createHash, timingSafeEqual } from "node:crypto";
 import os from "node:os";
 import path from "node:path";
 import { daemonLifecycleRequestIdV1Schema, } from "../../../../packages/shared/dist/index.js";
-import { assertLocalDaemonRuntimeMatchesConfig, assertLocalDaemonVerified, assertNoPendingEnrollmentAuthority, canonicalRelayUrl, cliErrorFromFetch, CliError, compactText, ControllerClient, configDir, configPath, daemonPidPath, deriveOrchestration, diagnoseInstallation, emitDoctorResult, ensureDaemonRunning, idleSessionStatuses, localDaemonStatus, ok, parsePairingClaimResponse, randomId, readConfig, readDaemonConfig, readDaemonProjectionBaseline, readLocalAuditLog, readRelayJson, redactedDaemonConfig, requirePositional, requireRelayUrl, requireString, restartDaemonForBootstrap, showMachine, startDaemonTimeoutMs, stopLocalDaemon, stopSpawnedDaemon, throwRelayHttpError, waitForDaemonReadiness, waitForDaemonSelfReadiness, wantsJson, withAccountConfigTransaction } from "./lib/index.js";
+import { assertLocalDaemonRuntimeMatchesConfig, assertLocalDaemonVerified, assertNoPendingEnrollmentAuthority, canonicalRelayUrl, cliErrorFromFetch, CliError, compactText, ControllerClient, configDir, configPath, daemonPidPath, deriveOrchestration, diagnoseInstallation, emitDoctorResult, ensureDaemonRunning, localDaemonStatus, machineAvailabilityLabel, machineIsAvailable, ok, parsePairingClaimResponse, randomId, readConfig, readDaemonConfig, readDaemonProjectionBaseline, readLocalAuditLog, readRelayJson, redactedDaemonConfig, requirePositional, requireRelayUrl, requireString, restartDaemonForBootstrap, showMachine, startDaemonTimeoutMs, stopLocalDaemon, stopSpawnedDaemon, throwRelayHttpError, waitForDaemonReadiness, waitForDaemonSelfReadiness, wantsJson, withAccountConfigTransaction } from "./lib/index.js";
 function positiveLimit(flags, fallback) {
     const value = flags.limit;
     if (value === undefined)
@@ -57,7 +57,7 @@ async function waitForLocalDaemonReadiness(client, config, baseline, daemon, req
         if (readiness.phase === "process-exited" || readiness.phase === "owner-changed") {
             throw new CliError("Daemon exited before it authenticated with the relay. Run happy-elves daemon doctor and happy-elves daemon logs.", "DAEMON_START_FAILED");
         }
-        if (readiness.phase !== "relay-authenticated" || !readiness.machine?.online) {
+        if (readiness.phase !== "relay-authenticated" || !machineIsAvailable(readiness.machine)) {
             const relayDetail = readiness.lastRelayErrorCode ? ` Last relay error: ${readiness.lastRelayErrorCode}.` : "";
             throw new CliError(`Daemon is running, but it did not authenticate with the relay before the startup deadline.${relayDetail} Run happy-elves daemon doctor and happy-elves daemon logs.`, "DAEMON_ONLINE_TIMEOUT");
         }
@@ -107,8 +107,8 @@ async function remoteDaemonLifecycle(flags, action) {
     if (matches.length !== 1) {
         throw new CliError(`Relay returned duplicate Daemon identities: ${machineId}`, "RELAY_RESPONSE_INVALID");
     }
-    if (!machine.online)
-        throw new CliError(`Daemon is offline: ${machineId}`, "MACHINE_OFFLINE");
+    if (!machineIsAvailable(machine))
+        throw new CliError(`Daemon is not available: ${machineId}`, "MACHINE_UNAVAILABLE");
     const capability = machine.capabilities.daemonLifecycleV1;
     const expectedInstanceGeneration = machine.capabilities.daemonInstanceGeneration;
     const supported = capability !== undefined &&
@@ -181,9 +181,13 @@ async function daemonOverview(client, input) {
         const machines = input.machineId ? snapshot.machines.filter((machine) => machine.id === input.machineId) : snapshot.machines;
         const machineIds = new Set(machines.map((machine) => machine.id));
         const allSessions = snapshot.sessions.filter((session) => machineIds.has(session.machineId));
-        const counts = {};
-        for (const session of allSessions)
-            counts[session.status] = (counts[session.status] ?? 0) + 1;
+        const counts = { supervision: {}, execution: {} };
+        for (const session of allSessions) {
+            const supervision = session.supervision.status;
+            const execution = session.execution.status;
+            counts.supervision[supervision] = (counts.supervision[supervision] ?? 0) + 1;
+            counts.execution[execution] = (counts.execution[execution] ?? 0) + 1;
+        }
         const sessions = input.includeSessions ? (input.all ? allSessions : allSessions.slice(0, input.limit)) : [];
         return {
             machines,
@@ -437,8 +441,9 @@ export async function handleDaemon({ domain, action, flags }) {
             capabilities: session.capabilities,
         })) : [];
         const sessionCount = overview.page.total;
-        const runningSessionCount = overview.counts.running ?? 0;
-        const idleSessionCount = idleSessionStatuses.reduce((sum, status) => sum + (overview.counts[status] ?? 0), 0);
+        const activeExecutionCount = overview.counts.execution.active ?? 0;
+        const unresolvedExecutionCount = (overview.counts.execution.unknown ?? 0) +
+            (overview.counts.execution["legacy-unresolved"] ?? 0);
         const data = {
             configPath,
             local,
@@ -448,7 +453,9 @@ export async function handleDaemon({ domain, action, flags }) {
             machines: includeSessions ? projectedMachines.map((machine) => ({
                 machineId: machine.id,
                 name: machine.metadata.name ?? machine.name,
-                online: machine.online,
+                available: machineIsAvailable(machine),
+                daemon: machine.daemon,
+                connection: machine.connection,
                 lastSeen: machine.lastSeen,
                 daemonVersion: machine.capabilities.daemonVersion,
                 defaultCwd: machine.defaultCwd,
@@ -459,17 +466,20 @@ export async function handleDaemon({ domain, action, flags }) {
             })) : machines.map((machine) => ({
                 machineId: machine.id,
                 name: machine.name,
-                online: machine.online,
+                available: machineIsAvailable(machine),
+                daemon: machine.daemon,
+                connection: machine.connection,
                 lastSeen: machine.lastSeen,
             })),
             ...(includeSessions ? { sessions: projectedSessions, page: overview.page } : {}),
             summary: {
                 machineCount: machines.length,
-                onlineMachineCount: machines.filter((machine) => machine.online).length,
+                availableMachineCount: machines.filter(machineIsAvailable).length,
                 sessionCount,
-                runningSessionCount,
-                idleSessionCount,
-                statusCounts: overview.counts,
+                activeExecutionCount,
+                unresolvedExecutionCount,
+                supervisionCounts: overview.counts.supervision,
+                executionCounts: overview.counts.execution,
                 ...(includeSessions ? {
                     blockedSessionCount: projectedSessions.filter((session) => session.orchestration.blocked).length,
                     activeSessionCount: projectedSessions.filter((session) => session.orchestration.state === "active").length,
@@ -481,10 +491,10 @@ export async function handleDaemon({ domain, action, flags }) {
         if (!wantsJson(flags)) {
             console.log(`Account: ${data.relayReachable ? "connected" : "unavailable"}`);
             console.log(data.local.running ? `Local daemon: running${data.local.pid ? ` pid ${data.local.pid}` : ""}` : "Local daemon: stopped");
-            console.log(`Daemons: ${data.summary.onlineMachineCount}/${data.summary.machineCount} online`);
-            console.log(`Sessions: ${data.summary.sessionCount} total, ${data.summary.runningSessionCount} running`);
+            console.log(`Daemons: ${data.summary.availableMachineCount}/${data.summary.machineCount} available`);
+            console.log(`Sessions: ${data.summary.sessionCount} total, ${data.summary.activeExecutionCount} active execution, ${data.summary.unresolvedExecutionCount} unresolved`);
             for (const machine of data.machines) {
-                console.log(`- ${machine.name} (${machine.machineId}) ${machine.online ? "online" : "offline"}`);
+                console.log(`- ${machine.name} (${machine.machineId}) ${"daemon" in machine && "connection" in machine ? machineAvailabilityLabel(machine) : "unavailable"}`);
                 if ("defaultCwd" in machine)
                     console.log(`  cwd: ${machine.defaultCwd ?? "-"}`);
             }

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

@@ -30,10 +30,10 @@ export async function handleGateway({ domain, action, positional, flags }) {
             statePath: gatewayStatePath,
         });
         if (!wantsJson(flags)) {
-            console.log(`Gateway store artifacts: ${inspection.repairRequired ? "repair required" : "healthy"}`);
+            console.log(`Gateway store: ${gatewayStoreInspectionLabel(inspection)}`);
             console.log(`artifact digest: ${inspection.artifactDigest}`);
             for (const [name, file] of Object.entries(inspection.files)) {
-                console.log(`${name}: ${file.status}`);
+                console.log(`${name}: ${file.status}; contents ${file.contentValidation.status}${file.contentValidation.errorCode ? ` (${file.contentValidation.errorCode})` : ""}`);
             }
             return true;
         }
@@ -681,8 +681,12 @@ async function handleRemoteGateway(action, positional, flags, machineId) {
     if (action === "store" && positional[0] === "inspect") {
         const result = await client.inspectGatewayStore(machineId);
         if (!wantsJson(flags)) {
-            console.log(`Gateway store on Daemon ${machineId}: ${result.repairRequired ? "repair required" : "healthy"}`);
+            console.log(`Gateway store on Daemon ${machineId}: ${gatewayStoreInspectionLabel(result)}`);
             console.log(`artifact digest: ${result.artifactDigest}`);
+            for (const [name, file] of Object.entries(result.files)) {
+                const content = file.contentValidation;
+                console.log(`${name}: ${file.status}; contents ${content?.status ?? "status unavailable"}${content?.errorCode ? ` (${content.errorCode})` : ""}`);
+            }
         }
         else
             ok("gateway.store.inspect", { machineId, ...result }, { machineId });
@@ -1188,6 +1192,21 @@ function stringFlag(flags, key) {
     const value = flags[key];
     return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
+function gatewayStoreInspectionLabel(inspection) {
+    if (inspection.repairRequired)
+        return "repair required";
+    const validations = Object.values(inspection.files).map((file) => file.contentValidation?.status);
+    if (validations.some((status) => status === "invalid"))
+        return "content invalid";
+    if (validations.some((status) => status === "unsupported"))
+        return "content version unsupported";
+    if (validations.some((status) => status === "unreadable"))
+        return "content unreadable";
+    // An older Daemon cannot prove the store content it did not inspect.
+    if (validations.some((status) => status === undefined))
+        return "content status unavailable";
+    return "healthy";
+}
 function isRecord(value) {
     return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }

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

@@ -97,7 +97,7 @@ const valueFlags = new Set([
     "thought-level",
     "thinking",
     "wait-timeout-ms",
-    "runtime-timeout",
+    "inactivity-timeout",
     "to",
     "token",
     "ttl",
@@ -110,6 +110,7 @@ const booleanFlags = new Set([
     "all",
     "allow-all-users",
     "clear-default-chat",
+    "confirm-risk",
     "close-source",
     "daily",
     "deny-all-users",
@@ -141,6 +142,7 @@ const booleanFlags = new Set([
     "respond-all",
     "summary",
     "starred",
+    "strict",
     "verbose",
     "wait",
     "yes",

package/apps/cli/dist/commands/lib/bootstrap-daemon.d.ts

@@ -47,7 +47,7 @@ type DaemonReadinessOptions = {
      * before it is considered ready. This prevents an online snapshot left by
      * the previous connection from satisfying a new start.
      */
-    baseline?: Pick<MachineSnapshot, "online" | "lastSeen">;
+    baseline?: Pick<MachineSnapshot, "daemon" | "connection" | "lastSeen">;
     expectedInstanceGeneration?: string;
     requireFreshProjection?: boolean;
     readLocalStatus?: typeof localDaemonStatus;

package/apps/cli/dist/commands/lib/bootstrap-daemon.js

@@ -4,6 +4,7 @@ import { CliError } from "../../errors.js";
 import { startDaemonTimeoutMs } from "./paths.js";
 import { readDaemonConfig } from "./config.js";
 import { assertLocalDaemonRuntimeMatchesConfig, assertLocalDaemonVerified, inspectLocalDaemonRuntime, localDaemonStatus, readLocalDaemonPidIdentity, spawnDaemonStartTracked, stopLocalDaemon, stopSpawnedDaemon, } from "./local-daemon.js";
+import { machineIsAvailable } from "./machine-state.js";
 const committedConfigMayBeInUseErrors = new WeakSet();
 export function startFailureMayUseCommittedConfig(error) {
     return Boolean(error && typeof error === "object" && committedConfigMayBeInUseErrors.has(error));
@@ -331,7 +332,7 @@ export async function waitForDaemonReadiness(client, machineId, options = {}) {
             continue;
         }
         machine = snapshot.machines.find((candidate) => candidate.id === machineId);
-        if (machine?.online && projectionIsFresh(machine, options)) {
+        if (machine && machineIsAvailable(machine) && projectionIsFresh(machine, options)) {
             // Close the process/projection TOCTOU window: the relay may still expose
             // a fresh online row for a daemon that exited while snapshot() was in
             // flight. Re-verify the local owner before declaring startup complete.
@@ -484,7 +485,7 @@ function projectionIsFresh(machine, options) {
         return true;
     if (!options.baseline)
         return true;
-    if (options.baseline.online !== true)
+    if (!machineIsAvailable(options.baseline))
         return true;
     return machine.lastSeen > options.baseline.lastSeen;
 }

package/apps/cli/dist/commands/lib/bootstrap-device-recovery.js

@@ -9,6 +9,7 @@ import { CliError } from "../../errors.js";
 import { ok } from "./json.js";
 import { assertLocalDaemonVerified, localDaemonStatus, stopSpawnedDaemon, } from "./local-daemon.js";
 import { withAccountConfigTransaction } from "./config.js";
+import { machineIsAvailable } from "./machine-state.js";
 import { controllerBaseUrl } from "./bootstrap-config.js";
 import { readDaemonProjectionBaseline, restartDaemonForBootstrap, waitForDaemonReadiness, } from "./bootstrap-daemon.js";
 import { openUrl } from "./bootstrap-output.js";
@@ -232,7 +233,7 @@ export async function startDeviceRecoveryBootstrap(params) {
     const daemonDisplayName = daemon.name && daemon.name !== daemonConfig.machineId
         ? daemon.name
         : daemonConfig.machineName;
-    console.log(`Daemon ${daemonDisplayName} is ${daemon.online ? "online" : "connected; needs attention"}.`);
+    console.log(`Daemon ${daemonDisplayName} is ${daemon.online ? "available" : "connected; needs attention"}.`);
     if (params.flags["no-open"] === true) {
         console.log("");
         console.log("Open Happy Elves:");
@@ -301,7 +302,7 @@ async function ensureRecoveredDaemonReady(params) {
                 timeoutMs: Math.min(startDaemonTimeoutMs, 5_000),
             });
             return {
-                online: machine?.online === true,
+                online: machineIsAvailable(machine),
                 name: machine?.name ?? params.daemonConfig.machineName,
             };
         }
@@ -346,7 +347,7 @@ async function ensureRecoveredDaemonReady(params) {
                 requireFreshProjection: started.started || started.restarted,
                 timeoutMs: startDaemonTimeoutMs,
             });
-            if (readiness.phase !== "relay-authenticated" || !readiness.machine?.online) {
+            if (readiness.phase !== "relay-authenticated" || !machineIsAvailable(readiness.machine)) {
                 throw new CliError("The Daemon did not authenticate before the startup deadline.", "DAEMON_ONLINE_TIMEOUT");
             }
             const confirmedDaemonConfig = await transaction.readDaemon();

package/apps/cli/dist/commands/lib/bootstrap-output.d.ts

@@ -7,7 +7,7 @@ export declare function writeHumanStartOutput(data: {
     openError?: string;
     daemon: {
         name: string;
-        online: boolean;
+        status: string;
         pid?: number;
     };
 }): void;

package/apps/cli/dist/commands/lib/bootstrap-output.js

@@ -18,7 +18,7 @@ export function writeHumanStartOutput(data) {
         console.log("This one-time link expires in 2 minutes.");
     console.log("");
     console.log("Daemon");
-    console.log(`${data.daemon.online ? "online" : "starting"}, ${data.daemon.name}${data.daemon.pid ? ` (pid ${data.daemon.pid})` : ""}`);
+    console.log(`${data.daemon.status}, ${data.daemon.name}${data.daemon.pid ? ` (pid ${data.daemon.pid})` : ""}`);
 }
 export function openUrl(url, options = {}) {
     try {

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

@@ -14,6 +14,7 @@ import { readDaemonProjectionBaseline, restartDaemonForBootstrap, startFailureMa
 import { openUrl, writeHumanStartOutput } from "./bootstrap-output.js";
 import { startJoinBootstrap } from "./bootstrap-join.js";
 import { reconcileSatisfiedDeviceRecoveryPending, startDeviceRecoveryBootstrap } from "./bootstrap-device-recovery.js";
+import { machineIsAvailable } from "./machine-state.js";
 import { clearFreshStartIntent, freshStartIntentMatchesConfigs, loadOrCreateFreshStartIntent, readFreshStartIntent, } from "./fresh-start-intent.js";
 export async function startBootstrap(flags) {
     if (typeof flags.join === "string") {
@@ -208,7 +209,7 @@ export async function startBootstrap(flags) {
             if (readiness.phase === "process-exited" || readiness.phase === "owner-changed") {
                 throw new CliError("Daemon exited before it authenticated with the relay. Run happy-elves doctor and happy-elves daemon logs.", "DAEMON_START_FAILED");
             }
-            if (readiness.phase !== "relay-authenticated" || !machine?.online) {
+            if (readiness.phase !== "relay-authenticated" || !machineIsAvailable(machine)) {
                 const relayDetail = readiness.lastRelayErrorCode ? ` Last relay error: ${readiness.lastRelayErrorCode}.` : "";
                 throw new CliError(`Daemon is running, but it did not authenticate with the relay before the startup deadline.${relayDetail} Run happy-elves doctor and happy-elves daemon logs.`, "DAEMON_ONLINE_TIMEOUT");
             }
@@ -307,13 +308,15 @@ export async function startBootstrap(flags) {
         machine: {
             id: daemonState.config.machineId,
             name: machine?.name ?? daemonState.config.machineName,
-            online: machine?.online ?? false,
+            available: machineIsAvailable(machine),
+            daemon: machine?.daemon,
+            connection: machine?.connection,
             lastSeen: machine?.lastSeen,
         },
         daemon: {
             status: daemonNeedsAttention
                 ? "needs-attention"
-                : daemon.local.running ? "online" : "starting",
+                : daemon.local.running ? "running" : "starting",
             pid: daemon.local.pid ?? daemon.startedPid,
             pidPath: daemon.local.pidPath,
             started: daemon.started,
@@ -346,7 +349,7 @@ export async function startBootstrap(flags) {
         openError: openResult.error,
         daemon: {
             name: data.machine.name,
-            online: data.machine.online,
+            status: data.machine.available ? "available" : data.machine.connection?.status ?? "starting",
             pid: data.daemon.pid,
         },
     });

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

@@ -17,6 +17,7 @@ export * from "./doctor.js";
 export * from "./exit.js";
 export * from "./json.js";
 export * from "./local-daemon.js";
+export * from "./machine-state.js";
 export * from "./orchestrator.js";
 export * from "./pending-enrollment.js";
 export * from "./paths.js";

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

@@ -17,6 +17,7 @@ export * from "./doctor.js";
 export * from "./exit.js";
 export * from "./json.js";
 export * from "./local-daemon.js";
+export * from "./machine-state.js";
 export * from "./orchestrator.js";
 export * from "./pending-enrollment.js";
 export * from "./paths.js";

package/apps/cli/dist/commands/lib/machine-state.d.ts

@@ -0,0 +1,3 @@
+import type { MachineSnapshot } from "../../../../../packages/shared/dist/index.js";
+export declare function machineIsAvailable(machine: Pick<MachineSnapshot, "daemon" | "connection"> | undefined): boolean;
+export declare function machineAvailabilityLabel(machine: Pick<MachineSnapshot, "daemon" | "connection">): string;

package/apps/cli/dist/commands/lib/machine-state.js

@@ -0,0 +1,14 @@
+export function machineIsAvailable(machine) {
+    return machine?.daemon.status === "running" && machine.connection.status === "connected";
+}
+export function machineAvailabilityLabel(machine) {
+    if (machine.daemon.status === "stopped")
+        return "daemon-stopped";
+    if (machine.daemon.status === "unknown")
+        return "daemon-unknown";
+    if (machine.connection.status === "reconnecting")
+        return "reconnecting";
+    if (machine.connection.status === "disconnected")
+        return "disconnected";
+    return "available";
+}

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

@@ -32,7 +32,7 @@ export declare const orchestratorRequestMetadataCapacity = 256;
 export declare function promptSha256(text: string): string;
 export declare function deterministicTurnId(threadId: string, requestId: string): string;
 export declare function deterministicRelayRequestId(threadId: string, requestId: string): string;
-export declare function normalizeOrchestratorStatus(session: Pick<SessionSnapshot, "status">, orchestration: OrchestrationSummary, latestTurn?: Pick<TurnSummary, "status">): OrchestratorStatus;
+export declare function normalizeOrchestratorStatus(session: Pick<SessionSnapshot, "status" | "daemon" | "connection" | "supervision" | "execution">, orchestration: OrchestrationSummary, _latestTurn?: Pick<TurnSummary, "status">): OrchestratorStatus;
 export declare function normalizeOrchestratorTag(value: string): string;
 export declare function normalizeOrchestratorTags(values: readonly string[]): string[];
 export declare function readOrchestratorMetadata(metadata: Record<string, unknown>): OrchestratorMetadata;

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

@@ -16,25 +16,28 @@ export function deterministicRelayRequestId(threadId, requestId) {
     const digest = createHash("sha256").update("orchestrator").update("\0").update(threadId).update("\0").update(requestId).digest("base64url");
     return `req_${digest.slice(0, 28)}`;
 }
-export function normalizeOrchestratorStatus(session, orchestration, latestTurn) {
+export function normalizeOrchestratorStatus(session, orchestration, _latestTurn) {
     if (session.status === "closed")
         return "closed";
-    if (session.status === "offline")
-        return "offline";
     if (orchestration.needsUser)
         return "needsInput";
-    if (orchestration.blocked)
+    if (session.supervision.status === "failed" ||
+        session.execution.status === "unknown" ||
+        session.execution.status === "legacy-unresolved")
         return "blocked";
-    if (orchestration.statusConflict?.evidence === "running-turn")
-        return "inProgress";
-    if (latestTurn?.status === "running" || session.status === "running" || session.status === "new")
+    if (session.execution.status === "active" ||
+        session.supervision.status === "watching" ||
+        session.supervision.status === "reconciling" ||
+        session.supervision.status === "settling")
         return "inProgress";
-    if (latestTurn?.status === "failed" || session.status === "failed")
+    if (session.execution.status === "failed")
         return "failed";
-    if (latestTurn?.status === "cancelled" || session.status === "cancelled")
+    if (session.execution.status === "cancelled")
         return "cancelled";
-    if (latestTurn?.status === "completed" || orchestration.completed || session.status === "completed")
+    if (session.execution.status === "completed")
         return "completed";
+    if (session.daemon.status !== "running" || session.connection.status !== "connected")
+        return "offline";
     return "idle";
 }
 export function normalizeOrchestratorTag(value) {

package/apps/cli/dist/commands/lib/session-output.d.ts

@@ -1,4 +1,5 @@
-import type { ControllerClient, DecodedSessionEvent } from "../../../../../packages/client/dist/index.js";
+import { type ControllerClient, type DecodedSessionEvent } from "../../../../../packages/client/dist/index.js";
+import type { TurnSnapshotV2 } from "../../../../../packages/shared/dist/index.js";
 export declare function compactText(value: string, max?: number): string;
 export declare function lastAssistantOutput(events: DecodedSessionEvent[]): string;
 export declare function compareSessionEventLogicalOrder(left: DecodedSessionEvent, right: DecodedSessionEvent): number;
@@ -31,6 +32,12 @@ export type TurnSummary = {
     lastEventId: number;
     eventCount: number;
 };
+/**
+ * Keep transcript content for display, but derive settlement exclusively from
+ * the immutable turn record. A plain/backfilled `done` event is not proof of
+ * provider completion and therefore remains projected as running.
+ */
+export declare function applyAuthoritativeTurnSnapshot(summary: TurnSummary | undefined, turn: TurnSnapshotV2 | undefined, requestedTurnId: string): TurnSummary | undefined;
 export type StructuredCommandOutput = {
     state: string;
     sessionId: string;

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

@@ -1,5 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { authoritativeTerminalTurnStatus, } from "../../../../../packages/client/dist/index.js";
 import { CliError } from "../../errors.js";
 import { outputRoot } from "./paths.js";
 function eventText(event) {
@@ -86,6 +87,40 @@ export function displayPath(filePath) {
     const relative = path.relative(process.cwd(), filePath);
     return relative.startsWith("..") ? filePath : relative || ".";
 }
+/**
+ * Keep transcript content for display, but derive settlement exclusively from
+ * the immutable turn record. A plain/backfilled `done` event is not proof of
+ * provider completion and therefore remains projected as running.
+ */
+export function applyAuthoritativeTurnSnapshot(summary, turn, requestedTurnId) {
+    if (!summary && !turn)
+        return undefined;
+    const terminalStatus = authoritativeTerminalTurnStatus(turn);
+    if (summary) {
+        return {
+            ...summary,
+            status: terminalStatus ?? "running",
+            completedAt: terminalStatus === undefined ? undefined : (summary.completedAt ?? turn?.updatedAt),
+            updatedAt: Math.max(summary.updatedAt, turn?.updatedAt ?? 0),
+        };
+    }
+    if (!turn)
+        return undefined;
+    return {
+        turnId: turn.turnId,
+        ...(requestedTurnId === turn.turnId ? {} : { runtimeTurnId: requestedTurnId }),
+        status: terminalStatus ?? "running",
+        prompt: "",
+        output: "",
+        terminalText: "",
+        startedAt: turn.createdAt,
+        ...(terminalStatus === undefined ? {} : { completedAt: turn.updatedAt }),
+        updatedAt: turn.updatedAt,
+        firstEventId: 0,
+        lastEventId: 0,
+        eventCount: 0,
+    };
+}
 function terminalTextForDone(events, turnId) {
     const done = [...events].reverse().find((event) => event.turnId === turnId && event.decoded?.type === "done")?.decoded;
     if (done?.type !== "done")

package/apps/cli/dist/commands/lib/session-view.d.ts

@@ -1,6 +1,6 @@
 import type { ControllerClient, DecodedSessionEvent } from "../../../../../packages/client/dist/index.js";
 import type { MachineSnapshot, SessionSnapshot } from "../../../../../packages/shared/dist/index.js";
-import { type MachineMetadata, type OrchestrationSummary, type OrchestrationState } from "./types.js";
+import type { MachineMetadata, OrchestrationSummary, OrchestrationState } from "./types.js";
 import { type TurnSummary } from "./session-output.js";
 export declare function showMachine(client: ControllerClient, machine: MachineSnapshot): Promise<MachineSnapshot & {
     defaultCwd?: string;

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

@@ -1,6 +1,5 @@
 import path from "node:path";
 import { CliError } from "../../errors.js";
-import { idleSessionStatuses } from "./types.js";
 import { summarizeTurns } from "./session-output.js";
 export async function showMachine(client, machine) {
     const metadata = (await client.decodeMachineMetadata(machine));
@@ -25,26 +24,42 @@ function eventNeedsUser(event) {
         return true;
     return false;
 }
-function orchestrationStateFromStatus(status) {
-    if (status === "new")
-        return "pending";
-    if (status === "running")
+function orchestrationStateFromSnapshot(session) {
+    if (session.status === "closed")
+        return "closed";
+    if (session.supervision.status === "failed")
+        return "blocked";
+    if (session.execution.status === "unknown" || session.execution.status === "legacy-unresolved")
+        return "blocked";
+    if (session.execution.status === "failed")
+        return "blocked";
+    if (session.execution.status === "active" || session.supervision.status === "watching")
+        return "active";
+    if (session.supervision.status === "reconciling" || session.supervision.status === "settling")
         return "active";
-    if (status === "ready" || status === "cancelled")
-        return "idle";
-    if (status === "completed")
+    if (session.execution.status === "completed")
         return "completed";
-    if (status === "failed" || status === "offline")
-        return "blocked";
-    return "closed";
+    if (session.status === "new" && session.execution.status === "idle")
+        return "pending";
+    return "idle";
+}
+function canTrustVisibleRunningTurn(session) {
+    return session.status !== "closed" &&
+        (session.execution.status === "active" || session.supervision.status === "watching");
 }
-function canTrustVisibleRunningTurn(status) {
-    return status !== "closed" && status !== "offline" && status !== "cancelled";
+function operationalProjection(session) {
+    return {
+        daemon: session.daemon.status,
+        connection: session.connection.status,
+        supervision: session.supervision.status,
+        execution: session.execution.status,
+        rawStatus: session.status,
+    };
 }
 function visibleRunningTurnSummary(session, turnId) {
     return {
         state: "active",
-        rawStatus: session.status,
+        ...operationalProjection(session),
         needsUser: false,
         blocked: false,
         completed: false,
@@ -71,35 +86,16 @@ export function deriveOrchestration(session, events = [], focusTurn) {
     if (needsUserEvent && latestTerminalTurn && latestTerminalTurn.status !== "completed") {
         return needsUserSummary(session, needsUserEvent);
     }
-    if (latestTurn?.status === "running" && canTrustVisibleRunningTurn(session.status)) {
+    if (latestTurn?.status === "running" && canTrustVisibleRunningTurn(session)) {
         return visibleRunningTurnSummary(session, latestTurn.turnId);
     }
-    if (focusTurn?.status === "running" && canTrustVisibleRunningTurn(session.status)) {
+    if (focusTurn?.status === "running" && canTrustVisibleRunningTurn(session)) {
         return visibleRunningTurnSummary(session, focusTurn.turnId);
     }
-    if (session.status !== "running") {
-        const state = orchestrationStateFromStatus(session.status);
-        return {
-            state,
-            rawStatus: session.status,
-            needsUser: false,
-            blocked: state === "blocked",
-            completed: state === "completed",
-        };
-    }
-    if (activeTurn) {
-        return {
-            state: "active",
-            rawStatus: session.status,
-            needsUser: false,
-            blocked: false,
-            completed: false,
-        };
-    }
-    const state = orchestrationStateFromStatus(session.status);
+    const state = orchestrationStateFromSnapshot(session);
     return {
         state,
-        rawStatus: session.status,
+        ...operationalProjection(session),
         needsUser: false,
         blocked: state === "blocked",
         completed: state === "completed",
@@ -114,7 +110,7 @@ function needsUserSummary(session, event) {
             : undefined;
     return {
         state: "needs-user",
-        rawStatus: session.status,
+        ...operationalProjection(session),
         needsUser: true,
         blocked: true,
         completed: false,
@@ -202,17 +198,19 @@ export async function machineSessionOverview(client, sessions, machineId) {
             lastTurnId: session.lastTurnId,
         };
     }));
+    const openSessions = projectedSessions.filter((session) => session.status !== "closed");
+    const settledSessions = openSessions.filter((session) => session.orchestration.supervision === "idle");
     return {
         summary: {
             sessionCount: machineSessions.length,
-            runningSessionCount: projectedSessions.filter((session) => session.status === "running").length,
-            idleSessionCount: projectedSessions.filter((session) => idleSessionStatuses.includes(session.status)).length,
+            runningSessionCount: openSessions.filter((session) => session.orchestration.execution === "active").length,
+            idleSessionCount: settledSessions.filter((session) => session.status !== "new" && ["idle", "completed", "cancelled"].includes(session.orchestration.execution)).length,
             blockedSessionCount: projectedSessions.filter((session) => session.orchestration.blocked).length,
-            readySessionCount: projectedSessions.filter((session) => session.status === "ready").length,
+            readySessionCount: settledSessions.filter((session) => session.status !== "new" && session.orchestration.execution === "idle").length,
             completedSessionCount: projectedSessions.filter((session) => session.orchestration.completed).length,
-            failedSessionCount: projectedSessions.filter((session) => session.status === "failed").length,
-            cancelledSessionCount: projectedSessions.filter((session) => session.status === "cancelled").length,
-            offlineSessionCount: projectedSessions.filter((session) => session.status === "offline").length,
+            failedSessionCount: openSessions.filter((session) => session.orchestration.execution === "failed").length,
+            cancelledSessionCount: openSessions.filter((session) => session.orchestration.execution === "cancelled").length,
+            offlineSessionCount: openSessions.filter((session) => session.orchestration.daemon !== "running" || session.orchestration.connection !== "connected").length,
             closedSessionCount: projectedSessions.filter((session) => session.status === "closed").length,
             activeSessionCount: projectedSessions.filter((session) => session.orchestration.state === "active").length,
             needsUserSessionCount: projectedSessions.filter((session) => session.orchestration.needsUser).length,