@cydm/happy-elves 0.1.0-beta.65 → 0.1.0-beta.66

package/apps/cli/dist/commands/account.d.ts

@@ -1,2 +1,6 @@
 import type { CommandInput } from "./command.js";
+export declare function confirmReset(flags: Record<string, string | boolean>, testIo?: {
+    interactive: boolean;
+    question?: () => Promise<string>;
+}): Promise<void>;
 export declare function handleAccount({ domain, action, flags }: CommandInput): Promise<boolean>;

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

@@ -1,7 +1,234 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { configDir, configPath, generateAccountSecret, ok, parsePairingStartResponse, randomId, readRelayJson, requireRelayUrl, stopLocalDaemon, throwRelayHttpError, writeConfig } from "./lib/index.js";
+import { createInterface } from "node:readline/promises";
+import { CliError, configDir, configPath, generateAccountSecret, ok, parsePairingStartResponse, randomId, readRelayJson, requireRelayUrl, stopLocalDaemon, throwRelayHttpError, writeConfig } from "./lib/index.js";
+const daemonConfigPath = path.join(configDir, "daemon.json");
+const accountConfigFiles = ["config.json", "daemon.json"];
+function accountConfigTarget(file) {
+    return file === "config.json" ? configPath : daemonConfigPath;
+}
+export async function confirmReset(flags, testIo) {
+    if (flags.json === true) {
+        if (flags.yes === true)
+            return;
+        throw new CliError("account reset --json requires --yes", "CONFIRMATION_REQUIRED");
+    }
+    const interactive = testIo?.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    if (!interactive) {
+        if (flags.yes === true)
+            return;
+        throw new CliError("account reset requires --yes in non-interactive mode", "CONFIRMATION_REQUIRED");
+    }
+    if (testIo?.question) {
+        const answer = await testIo.question();
+        if (answer.trim() !== "RESET")
+            throw new CliError("Account reset cancelled", "CONFIRMATION_REQUIRED");
+        return;
+    }
+    const prompt = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await prompt.question("Type RESET to remove this controller and daemon configuration: ");
+        if (answer.trim() !== "RESET")
+            throw new CliError("Account reset cancelled", "CONFIRMATION_REQUIRED");
+    }
+    finally {
+        prompt.close();
+    }
+}
+async function confirmRestore(flags, requiresConfirmation, testIo) {
+    if (!requiresConfirmation)
+        return;
+    if (flags.json === true) {
+        if (flags.yes === true)
+            return;
+        throw new CliError("account restore --json requires --yes when replacing or removing configuration", "CONFIRMATION_REQUIRED");
+    }
+    const interactive = testIo?.interactive ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    if (!interactive) {
+        if (flags.yes === true)
+            return;
+        throw new CliError("account restore requires --yes in non-interactive mode when replacing or removing configuration", "CONFIRMATION_REQUIRED");
+    }
+    if (testIo?.question) {
+        const answer = await testIo.question();
+        if (answer.trim() !== "RESTORE")
+            throw new CliError("Account restore cancelled", "CONFIRMATION_REQUIRED");
+        return;
+    }
+    const prompt = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await prompt.question("Type RESTORE to replace the current controller and daemon configuration: ");
+        if (answer.trim() !== "RESTORE")
+            throw new CliError("Account restore cancelled", "CONFIRMATION_REQUIRED");
+    }
+    finally {
+        prompt.close();
+    }
+}
+async function copyConfigIfPresent(source, target) {
+    try {
+        const stat = await fs.lstat(source);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new CliError(`Refusing to copy non-regular config file: ${source}`, "CONFIG_BACKUP_UNSAFE");
+        await fs.copyFile(source, target);
+        await fs.chmod(target, 0o600);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function backupAccountConfig(prefix = "account-reset") {
+    const stamp = new Date().toISOString().replace(/[:.]/gu, "-");
+    const backupPath = path.join(configDir, "backups", `${prefix}-${stamp}`);
+    await fs.mkdir(backupPath, { recursive: true, mode: 0o700 });
+    await fs.chmod(backupPath, 0o700);
+    const files = [];
+    if (await copyConfigIfPresent(configPath, path.join(backupPath, "config.json")))
+        files.push("config.json");
+    if (await copyConfigIfPresent(daemonConfigPath, path.join(backupPath, "daemon.json")))
+        files.push("daemon.json");
+    await fs.writeFile(path.join(backupPath, "manifest.json"), JSON.stringify({ version: 1, createdAt: new Date().toISOString(), files }, null, 2) + "\n", { mode: 0o600 });
+    return { path: backupPath, files };
+}
+async function requireDaemonStopped() {
+    let stop;
+    try {
+        stop = await stopLocalDaemon();
+    }
+    catch (error) {
+        if (error instanceof CliError && ["DAEMON_PID_UNVERIFIED", "DAEMON_PID_VERSION_UNSUPPORTED", "DAEMON_PID_INVALID"].includes(error.code))
+            throw error;
+        throw new CliError(`Could not stop the local daemon: ${error instanceof Error ? error.message : String(error)}`, "DAEMON_STOP_FAILED");
+    }
+    if (stop.running) {
+        throw new CliError(`The local daemon${stop.pid ? ` (pid ${stop.pid})` : ""} did not stop. Configuration was not changed; stop it and retry.`, "DAEMON_STOP_FAILED");
+    }
+    return stop;
+}
+async function requireRegularBackupFile(filePath) {
+    let stat;
+    try {
+        stat = await fs.lstat(filePath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            throw new CliError(`Account backup is missing ${path.basename(filePath)}.`, "ACCOUNT_BACKUP_INVALID");
+        }
+        throw error;
+    }
+    if (!stat.isFile() || stat.isSymbolicLink()) {
+        throw new CliError(`Account backup contains an unsafe ${path.basename(filePath)}.`, "ACCOUNT_BACKUP_INVALID");
+    }
+}
+async function stageAccountRestore(backupPath, files) {
+    await fs.mkdir(configDir, { recursive: true, mode: 0o700 });
+    await fs.chmod(configDir, 0o700);
+    const stagingPath = await fs.mkdtemp(path.join(configDir, ".account-restore-"));
+    await fs.chmod(stagingPath, 0o700);
+    try {
+        for (const file of files) {
+            const source = path.join(backupPath, file);
+            await requireRegularBackupFile(source);
+            const contents = await fs.readFile(source, "utf8");
+            try {
+                JSON.parse(contents);
+            }
+            catch {
+                throw new CliError(`Account backup ${file} is not valid JSON.`, "ACCOUNT_BACKUP_INVALID");
+            }
+            const staged = path.join(stagingPath, file);
+            await fs.writeFile(staged, contents, { mode: 0o600, flag: "wx" });
+            await fs.chmod(staged, 0o600);
+        }
+        return { path: stagingPath, files };
+    }
+    catch (error) {
+        await fs.rm(stagingPath, { recursive: true, force: true });
+        throw error;
+    }
+}
+async function currentAccountConfigFiles() {
+    const existing = [];
+    for (const file of accountConfigFiles) {
+        const target = accountConfigTarget(file);
+        try {
+            const stat = await fs.lstat(target);
+            if (!stat.isFile() || stat.isSymbolicLink()) {
+                throw new CliError(`Refusing to replace unsafe account config: ${target}`, "ACCOUNT_RESTORE_UNSAFE");
+            }
+            existing.push(file);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                continue;
+            throw error;
+        }
+    }
+    return existing;
+}
+async function applyAccountRestore(staged) {
+    const existing = await currentAccountConfigFiles();
+    const rollbackPath = await fs.mkdtemp(path.join(configDir, ".account-restore-rollback-"));
+    await fs.chmod(rollbackPath, 0o700);
+    const moved = [];
+    const installed = [];
+    let result;
+    let preserveRollback = false;
+    try {
+        for (const file of existing) {
+            await fs.rename(accountConfigTarget(file), path.join(rollbackPath, file));
+            moved.push(file);
+        }
+        for (const file of staged.files) {
+            const target = accountConfigTarget(file);
+            await fs.rename(path.join(staged.path, file), target);
+            installed.push(file);
+            await fs.chmod(target, 0o600);
+        }
+        result = {
+            restored: staged.files.map(accountConfigTarget),
+            removed: existing.filter((file) => !staged.files.includes(file)).map(accountConfigTarget),
+        };
+    }
+    catch (error) {
+        const rollbackFailures = [];
+        for (const file of [...installed].reverse()) {
+            try {
+                await fs.rm(accountConfigTarget(file), { force: true });
+            }
+            catch (rollbackError) {
+                rollbackFailures.push(`${file} cleanup: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+            }
+        }
+        for (const file of [...moved].reverse()) {
+            try {
+                const target = accountConfigTarget(file);
+                await fs.rename(path.join(rollbackPath, file), target);
+                await fs.chmod(target, 0o600);
+            }
+            catch (rollbackError) {
+                rollbackFailures.push(`${file} rollback: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+            }
+        }
+        const detail = error instanceof Error ? error.message : String(error);
+        if (rollbackFailures.length > 0) {
+            preserveRollback = true;
+            throw new CliError(`Account restore failed and rollback was incomplete: ${detail}. ${rollbackFailures.join("; ")}. Recovery files remain in ${rollbackPath}`, "ACCOUNT_RESTORE_ROLLBACK_FAILED");
+        }
+        throw new CliError(`Account restore failed; the previous configuration was restored: ${detail}`, "ACCOUNT_RESTORE_FAILED");
+    }
+    finally {
+        if (!preserveRollback)
+            await fs.rm(rollbackPath, { recursive: true, force: true });
+    }
+    if (!result)
+        throw new CliError("Account restore did not produce a result", "ACCOUNT_RESTORE_FAILED");
+    return result;
+}
 export async function handleAccount({ domain, action, flags }) {
     if (domain === "account" && action === "create") {
         const relayUrl = requireRelayUrl(flags);
@@ -36,16 +263,58 @@ export async function handleAccount({ domain, action, flags }) {
         return true;
     }
     if (domain === "account" && action === "reset") {
-        const stop = await stopLocalDaemon().catch((error) => ({
-            error: error instanceof Error ? error.message : String(error),
-        }));
+        await confirmReset(flags);
+        const stop = await requireDaemonStopped();
+        const backup = await backupAccountConfig();
         await fs.rm(configPath, { force: true });
-        await fs.rm(path.join(configDir, "daemon.json"), { force: true });
+        await fs.rm(daemonConfigPath, { force: true });
         ok("account.reset", {
-            removed: [configPath, path.join(configDir, "daemon.json")],
+            removed: [configPath, daemonConfigPath],
+            backup,
+            restoreCommand: `happy-elves account restore --from ${JSON.stringify(backup.path)} --yes --json`,
             stop,
         });
         return true;
     }
+    if (domain === "account" && action === "restore") {
+        const backupPath = typeof flags.from === "string" && flags.from.trim() ? path.resolve(flags.from) : undefined;
+        if (!backupPath)
+            throw new CliError("Missing --from", "MISSING_ARGUMENT");
+        const manifestPath = path.join(backupPath, "manifest.json");
+        let manifest;
+        try {
+            await requireRegularBackupFile(manifestPath);
+            manifest = JSON.parse(await fs.readFile(manifestPath, "utf8"));
+        }
+        catch (error) {
+            throw new CliError(`Invalid account backup: ${error instanceof Error ? error.message : String(error)}`, "ACCOUNT_BACKUP_INVALID");
+        }
+        if (manifest.version !== 1 ||
+            !Array.isArray(manifest.files) ||
+            !manifest.files.every((file) => accountConfigFiles.includes(file)) ||
+            new Set(manifest.files).size !== manifest.files.length) {
+            throw new CliError("Account backup manifest is invalid", "ACCOUNT_BACKUP_INVALID");
+        }
+        const files = manifest.files;
+        const staged = await stageAccountRestore(backupPath, files);
+        try {
+            const existing = await currentAccountConfigFiles();
+            await confirmRestore(flags, files.length === 0 || existing.length > 0);
+            const stop = await requireDaemonStopped();
+            const preRestoreBackup = await backupAccountConfig("account-pre-restore");
+            const restored = await applyAccountRestore({ path: staged.path, files });
+            ok("account.restore", {
+                backupPath,
+                ...restored,
+                preRestoreBackup,
+                restorePreviousCommand: `happy-elves account restore --from ${JSON.stringify(preRestoreBackup.path)} --yes --json`,
+                stop,
+            });
+        }
+        finally {
+            await fs.rm(staged.path, { recursive: true, force: true });
+        }
+        return true;
+    }
     return false;
 }

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

@@ -1,5 +1,3 @@
-import fs from "node:fs";
-import path from "node:path";
 import { handleAccount } from "./account.js";
 import { handleCollect } from "./collect.js";
 import { handleConfig } from "./config.js";
@@ -7,6 +5,7 @@ import { handleDaemon } from "./daemon.js";
 import { handleGateway } from "./gateway.js";
 import { handleLoop } from "./loop.js";
 import { handleMachine } from "./machine.js";
+import { handleMemory } from "./memory.js";
 import { handleOrchestrator } from "./orchestrator.js";
 import { handleRelay } from "./relay.js";
 import { handleRemote } from "./remote.js";
@@ -14,7 +13,7 @@ import { handleSession } from "./session.js";
 import { handleSkill } from "./skill.js";
 import { handleToken } from "./token.js";
 import { handleTurn } from "./turn.js";
-import { commandUsage, commandUsageText, handleCliError, parseCliFlags, skillText, startBootstrap, topLevelDoctor, topLevelStatus, usage, usageText } from "./lib/index.js";
+import { buildIdentity, cliVersion, commandUsage, commandUsageText, handleCliError, ok, parseCliFlags, skillText, startBootstrap, topLevelDoctor, topLevelStatus, usage, usageText } from "./lib/index.js";
 export { handleCliError };
 const domainHandlers = [
     handleAccount,
@@ -25,6 +24,7 @@ const domainHandlers = [
     handleDaemon,
     handleRelay,
     handleMachine,
+    handleMemory,
     handleGateway,
     handleOrchestrator,
     handleSession,
@@ -46,10 +46,18 @@ export async function main() {
         console.log(usageText());
         return;
     }
-    if (domain === "--version" || domain === "-v" || domain === "version") {
+    if (domain === "--version" || domain === "-v") {
         console.log(cliVersion());
         return;
     }
+    if (domain === "version") {
+        const { flags } = parseCliFlags(argv.slice(1));
+        if (flags.json === true)
+            ok("version", buildIdentity());
+        else
+            console.log(cliVersion());
+        return;
+    }
     const topLevelHelpRequested = argv[1] === "help" || argv.slice(1).some((arg) => arg === "--help" || arg === "-h");
     if (topLevelHelpRequested && commandUsageText(domain)) {
         console.log(commandUsageText(domain));
@@ -87,20 +95,3 @@ export async function main() {
     }
     usage();
 }
-function cliVersion() {
-    for (const candidate of [
-        path.resolve(import.meta.dirname, "..", "..", "..", "..", "package.json"),
-        path.resolve(import.meta.dirname, "..", "..", "..", "package.json"),
-        path.resolve(import.meta.dirname, "..", "..", "package.json"),
-    ]) {
-        try {
-            const parsed = JSON.parse(fs.readFileSync(candidate, "utf8"));
-            if (typeof parsed.version === "string" && parsed.version.trim())
-                return parsed.version.trim();
-        }
-        catch {
-            // Try the next packaged/source layout.
-        }
-    }
-    return "0.1.0";
-}

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

@@ -1,6 +1,94 @@
 import os from "node:os";
 import path from "node:path";
-import { CliError, compactText, ControllerClient, configDir, configPath, daemonPidPath, deriveOrchestration, idleSessionStatuses, localDaemonStatus, ok, parsePairingClaimResponse, randomId, readConfig, readDaemonConfig, readLocalAuditLog, readRelayJson, redactedDaemonConfig, requirePositional, requireRelayUrl, requireString, showMachine, spawnDaemonStart, stopLocalDaemon, throwRelayHttpError, wantsJson, writeDaemonConfig } from "./lib/index.js";
+import { assertLocalDaemonVerified, CliError, compactText, ControllerClient, configDir, configPath, daemonPidPath, deriveOrchestration, idleSessionStatuses, localDaemonStatus, ok, parsePairingClaimResponse, randomId, readConfig, readDaemonConfig, readLocalAuditLog, readRelayJson, redactedDaemonConfig, requirePositional, requireRelayUrl, requireString, showMachine, spawnDaemonStart, stopLocalDaemon, throwRelayHttpError, wantsJson, writeDaemonConfig } from "./lib/index.js";
+function positiveLimit(flags, fallback) {
+    const value = flags.limit;
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== "string")
+        throw new CliError("Missing --limit value", "MISSING_ARGUMENT");
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0 || parsed > 200)
+        throw new CliError(`Invalid --limit: ${value}`, "INVALID_ARGUMENT");
+    return parsed;
+}
+async function boundedMap(values, concurrency, map) {
+    const result = new Array(values.length);
+    let nextIndex = 0;
+    await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, async () => {
+        while (nextIndex < values.length) {
+            const index = nextIndex;
+            nextIndex += 1;
+            result[index] = await map(values[index]);
+        }
+    }));
+    return result;
+}
+function overviewUnsupported(error) {
+    return error.code === "OVERVIEW_UNSUPPORTED";
+}
+async function daemonOverview(client, input) {
+    try {
+        const sessions = [];
+        let cursor = input.cursor;
+        let first;
+        let loadNextPage = true;
+        while (loadNextPage) {
+            const page = await client.overview({
+                machineId: input.machineId,
+                limit: input.includeSessions ? (input.all ? 200 : input.limit) : 0,
+                cursor,
+            });
+            first ??= page;
+            if (input.includeSessions)
+                sessions.push(...page.sessions);
+            cursor = page.page.nextCursor;
+            loadNextPage = input.all && page.page.hasMore && Boolean(cursor);
+        }
+        const overview = first;
+        if (!overview)
+            throw new CliError("Overview response is empty", "RELAY_RESPONSE_INVALID");
+        return {
+            machines: overview.machines,
+            sessions,
+            counts: overview.sessionCounts,
+            page: {
+                returned: sessions.length,
+                total: overview.page.total,
+                hasMore: input.includeSessions && !input.all ? overview.page.hasMore : false,
+                ...(input.includeSessions && !input.all ? { limit: input.limit } : {}),
+                ...(!input.all && overview.page.nextCursor ? { nextCursor: overview.page.nextCursor } : {}),
+                source: "overview",
+            },
+        };
+    }
+    catch (error) {
+        if (!overviewUnsupported(error))
+            throw error;
+        if (input.cursor)
+            throw new CliError("This relay does not support daemon status cursors; retry without --cursor", "OVERVIEW_CURSOR_UNSUPPORTED");
+        const snapshot = await client.snapshot();
+        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 sessions = input.includeSessions ? (input.all ? allSessions : allSessions.slice(0, input.limit)) : [];
+        return {
+            machines,
+            sessions,
+            counts,
+            page: {
+                returned: sessions.length,
+                total: allSessions.length,
+                hasMore: input.includeSessions && sessions.length < allSessions.length,
+                ...(input.includeSessions && !input.all ? { limit: input.limit } : {}),
+                source: "bootstrap-fallback",
+            },
+        };
+    }
+}
 export async function handleDaemon({ domain, action, flags }) {
     if (domain === "daemon" && action === "pair") {
         const relayUrl = requireRelayUrl(flags);
@@ -113,6 +201,7 @@ export async function handleDaemon({ domain, action, flags }) {
     }
     if (domain === "daemon" && action === "start") {
         const status = await localDaemonStatus();
+        assertLocalDaemonVerified(status);
         if (status.running) {
             ok("daemon.start", { ...status, started: false });
             return true;
@@ -138,7 +227,7 @@ export async function handleDaemon({ domain, action, flags }) {
     if (domain === "daemon" && action === "status" && flags.local === true) {
         const local = await localDaemonStatus();
         if (!wantsJson(flags)) {
-            console.log(local.running ? `Daemon: running${local.pid ? ` pid ${local.pid}` : ""}` : "Daemon: stopped");
+            console.log(local.running ? `Daemon: running${local.pid ? ` pid ${local.pid}` : ""}` : local.state === "unverified" ? `Daemon: unverified live pid${local.pid ? ` ${local.pid}` : ""}` : "Daemon: stopped");
             console.log(`Pid file: ${local.pidPath}`);
             return true;
         }
@@ -150,17 +239,30 @@ export async function handleDaemon({ domain, action, flags }) {
         const client = new ControllerClient(config);
         const local = await localDaemonStatus();
         const response = await fetch(`${config.relayUrl}/health`);
-        const snapshot = await client.snapshot();
         const machineFilter = flags.machine === true ? requirePositional(undefined, "machineId") : typeof flags.machine === "string" ? flags.machine : undefined;
-        const machines = machineFilter
-            ? snapshot.machines.filter((machine) => machine.id === machineFilter)
-            : snapshot.machines;
+        const includeSessions = flags.verbose === true || flags.all === true;
+        const all = flags.all === true;
+        const cursor = typeof flags.cursor === "string" && flags.cursor.trim() ? flags.cursor.trim() : undefined;
+        if (all && flags.limit !== undefined)
+            throw new CliError("--all and --limit are mutually exclusive", "INVALID_ARGUMENT");
+        if (all && cursor)
+            throw new CliError("--all and --cursor are mutually exclusive", "INVALID_ARGUMENT");
+        if (cursor && !includeSessions)
+            throw new CliError("--cursor requires --verbose", "INVALID_ARGUMENT");
+        if (!all && flags.limit !== undefined && flags.verbose !== true) {
+            throw new CliError("--limit requires --verbose", "INVALID_ARGUMENT");
+        }
+        const limit = positiveLimit(flags, 20);
+        const overview = await daemonOverview(client, { machineId: machineFilter, includeSessions, all, limit, cursor });
+        const machines = overview.machines;
         if (machineFilter && machines.length === 0)
             throw new CliError("Machine not found", "MACHINE_NOT_FOUND");
-        const machineIds = new Set(machines.map((machine) => machine.id));
-        const sessions = snapshot.sessions.filter((session) => machineIds.has(session.machineId));
-        const projectedMachines = await Promise.all(machines.map((machine) => showMachine(client, machine)));
-        const projectedSessions = await Promise.all(sessions.map(async (session) => ({
+        const projectedMachines = includeSessions
+            ? await Promise.all((await client.snapshot()).machines
+                .filter((machine) => machines.some((summary) => summary.id === machine.id))
+                .map((machine) => showMachine(client, machine)))
+            : [];
+        const projectedSessions = includeSessions ? await boundedMap(overview.sessions, 4, async (session) => ({
             sessionId: session.id,
             machineId: session.machineId,
             agent: session.agent,
@@ -168,46 +270,66 @@ export async function handleDaemon({ domain, action, flags }) {
             orchestration: deriveOrchestration(session, await client.history(session.id, 20)),
             updatedAt: session.updatedAt,
             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 data = {
             configPath,
             local,
             relayUrl: config.relayUrl,
             relayReachable: response.ok,
             relay: response.ok ? await response.json() : await response.text(),
-            machines: projectedMachines.map((machine) => ({
+            machines: includeSessions ? projectedMachines.map((machine) => ({
                 machineId: machine.id,
                 name: machine.metadata.name ?? machine.name,
                 online: machine.online,
                 lastSeen: machine.lastSeen,
-                defaultCwd: machine.defaultCwd,
                 daemonVersion: machine.capabilities.daemonVersion,
+                defaultCwd: machine.defaultCwd,
                 acpxVersion: machine.capabilities.acpxVersion,
                 sessionPrimitives: machine.capabilities.sessionPrimitives,
                 agents: machine.capabilities.agents,
                 metadata: machine.metadata,
+            })) : machines.map((machine) => ({
+                machineId: machine.id,
+                name: machine.name,
+                online: machine.online,
+                lastSeen: machine.lastSeen,
             })),
-            sessions: projectedSessions,
+            ...(includeSessions ? { sessions: projectedSessions, page: overview.page } : {}),
             summary: {
                 machineCount: machines.length,
                 onlineMachineCount: machines.filter((machine) => machine.online).length,
-                sessionCount: projectedSessions.length,
-                runningSessionCount: projectedSessions.filter((session) => session.status === "running").length,
-                idleSessionCount: projectedSessions.filter((session) => idleSessionStatuses.includes(session.status)).length,
-                blockedSessionCount: projectedSessions.filter((session) => session.orchestration.blocked).length,
-                activeSessionCount: projectedSessions.filter((session) => session.orchestration.state === "active").length,
-                completedSessionCount: projectedSessions.filter((session) => session.orchestration.completed).length,
-                needsUserSessionCount: projectedSessions.filter((session) => session.orchestration.needsUser).length,
+                sessionCount,
+                runningSessionCount,
+                idleSessionCount,
+                statusCounts: overview.counts,
+                ...(includeSessions ? {
+                    blockedSessionCount: projectedSessions.filter((session) => session.orchestration.blocked).length,
+                    activeSessionCount: projectedSessions.filter((session) => session.orchestration.state === "active").length,
+                    completedSessionCount: projectedSessions.filter((session) => session.orchestration.completed).length,
+                    needsUserSessionCount: projectedSessions.filter((session) => session.orchestration.needsUser).length,
+                } : {}),
             },
         };
         if (!wantsJson(flags)) {
             console.log(`Relay: ${data.relayUrl} ${data.relayReachable ? "ok" : "unreachable"}`);
             console.log(data.local.running ? `Local daemon: running${data.local.pid ? ` pid ${data.local.pid}` : ""}` : "Local daemon: stopped");
             console.log(`Machines: ${data.summary.onlineMachineCount}/${data.summary.machineCount} online`);
-            console.log(`Sessions: ${data.summary.sessionCount} total, ${data.summary.runningSessionCount} running, ${data.summary.needsUserSessionCount} needs user`);
+            console.log(`Sessions: ${data.summary.sessionCount} total, ${data.summary.runningSessionCount} running`);
             for (const machine of data.machines) {
                 console.log(`- ${machine.name} (${machine.machineId}) ${machine.online ? "online" : "offline"}`);
-                console.log(`  cwd: ${machine.defaultCwd ?? "-"}`);
+                if ("defaultCwd" in machine)
+                    console.log(`  cwd: ${machine.defaultCwd ?? "-"}`);
+            }
+            if (includeSessions) {
+                for (const session of projectedSessions) {
+                    console.log(`- ${session.sessionId}  ${session.status}  ${session.orchestration.state}  ${session.agent}  machine:${session.machineId}`);
+                }
+                console.log(`Page: ${overview.page.returned} of ${overview.page.total} sessions${overview.page.hasMore ? "; more available" : "; complete"}`);
+                if (overview.page.nextCursor)
+                    console.log(`Next cursor: ${overview.page.nextCursor}`);
             }
             return true;
         }