@platless/axom-cli 0.5.9 → 0.6.36

package/dist/workstation/control/protocol.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export const bindingSchema = z.object({ server: z.string().min(1), workstationId: z.string().min(1), ownerUserId: z.string().min(1).optional() });
+export const bindingGuardSchema = z.object({ revision: z.string().min(1), runtimeGeneration: z.string().nullable() });
+const activitySchema = z.object({ commands: z.number().int().nonnegative(), terminals: z.number().int().nonnegative(), agents: z.number().int().nonnegative(), transfers: z.number().int().nonnegative() });
+export const runtimeSnapshotSchema = z.object({
+    state: z.enum(['stopped', 'running', 'unknown']), binding: bindingSchema.nullable(), generation: z.string().nullable(),
+    mode: z.enum(['launchd', 'foreground', 'unknown']), connection: z.enum(['offline', 'connecting', 'online', 'reconnecting', 'rejected', 'unknown']), activity: activitySchema.nullable(),
+});
+export const cliInstallationSchema = z.object({
+    source: z.enum(['managed', 'existing']), version: z.string(), nodeVersion: z.string(),
+    nodePath: z.string(), cliPath: z.string(), npmPath: z.string(), npmPrefix: z.string(),
+});
+export const operationRecordSchema = z.object({
+    id: z.string().min(1), kind: z.enum(['register', 'switch', 'start', 'stop', 'remove', 'update']), phase: z.string().min(1).max(80),
+    target: z.object({ server: z.string().min(1), ownerUserId: z.string().min(1).nullable() }).strict(),
+    workstationId: z.string().min(1).optional(), outcome: z.enum(['pending', 'succeeded', 'failed', 'unknown']),
+}).strict();
+export const serviceSnapshotSchema = z.object({ installed: z.boolean(), enabled: z.boolean().nullable(), loaded: z.boolean(), running: z.boolean(), reason: z.string().optional() });
+export const localInspectionSchema = z.object({
+    schemaVersion: z.literal(1), installation: cliInstallationSchema, binding: bindingSchema.nullable(), revision: z.string().min(1),
+    identityState: z.enum(['absent', 'ready', 'incomplete', 'corrupt']), runtime: runtimeSnapshotSchema,
+    service: serviceSnapshotSchema.optional(),
+    keepers: z.enum(['stopped', 'running', 'unknown']), pending: operationRecordSchema.nullable(),
+});
+export const localErrorCodeSchema = z.enum(['UNSUPPORTED_INSTALLATION', 'UNSUPPORTED_PROTOCOL', 'BINDING_CONFLICT', 'INSTANCE_OCCUPIED', 'AUTHORIZATION_REQUIRED', 'OWNER_MISMATCH', 'NETWORK_FAILED', 'CORRUPT_IDENTITY', 'SERVICE_FAILED', 'BUSY', 'OUTCOME_UNKNOWN']);
+export const cliResultSchema = z.object({
+    status: z.enum(['succeeded', 'busy', 'pending', 'failed', 'conflict']), inspection: localInspectionSchema.nullable(),
+    error: z.object({ code: localErrorCodeSchema, message: z.string().max(1024) }).optional(),
+}).refine(value => value.status !== 'succeeded' || value.inspection !== null, 'Successful operations require inspection');
+export class LocalControlError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'LocalControlError';
+    }
+}
+export function stoppedRuntime() {
+    return { state: 'stopped', binding: null, generation: null, mode: 'unknown', connection: 'offline', activity: null };
+}

package/dist/workstation/control/restartGuard.js

@@ -0,0 +1,46 @@
+import { execFile } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import { promisify } from 'node:util';
+import { LocalControlError } from './protocol.js';
+import { readControlFile, runtimeOwnerLive, runtimePaths } from './runtimeHost.js';
+const run = promisify(execFile);
+async function parentPid(pid) {
+    let value;
+    if (process.platform === 'linux') {
+        const stat = await fs.readFile(`/proc/${pid}/stat`, 'utf8');
+        value = stat.slice(stat.lastIndexOf(')') + 1).trim().split(/\s+/)[1];
+    }
+    else
+        value = (await run('ps', ['-o', 'ppid=', '-p', String(pid)], { timeout: 1000 })).stdout.trim();
+    const parent = Number(value);
+    if (!value || !Number.isSafeInteger(parent) || parent < 0)
+        throw new Error('Unknown process parent');
+    return parent;
+}
+export async function assertRuntimeRestartSafe(directory, generation, overrides = {}) {
+    const deps = { owner: async () => JSON.parse(await readControlFile(runtimePaths(directory).ownerFile)),
+        live: runtimeOwnerLive, parent: parentPid, pid: process.pid, ...overrides };
+    try {
+        const owner = await deps.owner();
+        if (owner.generation !== generation)
+            throw new LocalControlError('BINDING_CONFLICT', 'Workstation changed before restart');
+        if (!Number.isSafeInteger(owner.pid) || owner.pid <= 1 || !await deps.live(owner))
+            throw new Error('Unknown runtime process');
+        const seen = new Set();
+        const deadline = Date.now() + 3000;
+        let current = deps.pid;
+        while (current > 1 && !seen.has(current) && seen.size < 128 && Date.now() < deadline) {
+            if (current === owner.pid)
+                throw new LocalControlError('BUSY', 'This command is running inside the workstation daemon. Restarting it would terminate the current agent or command. Finish the session or move it to an independent keeper before restarting.');
+            seen.add(current);
+            current = await deps.parent(current);
+        }
+        if (current > 1)
+            throw new Error('Unknown process ancestry');
+    }
+    catch (error) {
+        if (error instanceof LocalControlError)
+            throw error;
+        throw new LocalControlError('OUTCOME_UNKNOWN', 'Cannot verify that workstation restart will preserve the calling session');
+    }
+}

package/dist/workstation/control/runtimeClient.js

@@ -0,0 +1,97 @@
+import net from 'node:net';
+import { runtimePaths, readControlFile, runtimeOwnerLive } from './runtimeHost.js';
+import { runtimeSnapshotSchema, stoppedRuntime, LocalControlError } from './protocol.js';
+import { pidAlive } from '../keepers/kit/lock.js';
+export async function runtimeRequest(directory, action, expectedGeneration, extra = {}) {
+    const paths = runtimePaths(directory);
+    const owner = JSON.parse(await readControlFile(paths.ownerFile));
+    if (typeof owner.generation !== 'string' || !pidAlive(owner.pid))
+        throw new LocalControlError('OUTCOME_UNKNOWN', 'Runtime owner cannot be verified');
+    if (expectedGeneration && owner.generation !== expectedGeneration)
+        throw new LocalControlError('BINDING_CONFLICT', 'Runtime changed');
+    const token = await readControlFile(paths.tokenFile);
+    return new Promise((resolve, reject) => {
+        const socket = net.createConnection(paths.socket);
+        let data = '';
+        let done = false;
+        const fail = (error) => { if (!done) {
+            done = true;
+            socket.destroy();
+            reject(error);
+        } };
+        socket.setTimeout(3000, () => fail(new LocalControlError('OUTCOME_UNKNOWN', 'Runtime did not respond')));
+        socket.on('error', () => fail(new LocalControlError('OUTCOME_UNKNOWN', 'Cannot contact runtime')));
+        socket.on('end', () => { if (!done)
+            fail(new LocalControlError('OUTCOME_UNKNOWN', 'Incomplete runtime response')); });
+        socket.on('connect', () => socket.write(JSON.stringify({ ...extra, action, generation: owner.generation, token }) + '\n'));
+        socket.on('data', chunk => {
+            data += chunk.toString();
+            if (Buffer.byteLength(data) > 65_536) {
+                fail(Error('Oversized response'));
+                return;
+            }
+            if (!data.includes('\n') || done)
+                return;
+            try {
+                const result = JSON.parse(data.split('\n')[0]);
+                if (!result.ok)
+                    throw new LocalControlError(result.code === 'BINDING_CONFLICT' ? result.code : 'SERVICE_FAILED', 'Runtime rejected the request');
+                done = true;
+                socket.destroy();
+                resolve(result.value);
+            }
+            catch (error) {
+                fail(error);
+            }
+        });
+    });
+}
+export async function inspectRuntime(directory) {
+    try {
+        return runtimeSnapshotSchema.parse(await runtimeRequest(directory, 'inspect'));
+    }
+    catch (error) {
+        try {
+            const owner = JSON.parse(await readControlFile(runtimePaths(directory).ownerFile));
+            if (Number.isSafeInteger(owner.pid) && owner.pid > 0 && typeof owner.command === 'string' && typeof owner.generation === 'string' && !await runtimeOwnerLive(owner))
+                return stoppedRuntime();
+        }
+        catch { /* Partial ownership evidence remains unknown. */ }
+        if (error.code === 'ENOENT') {
+            // No control files at all is stopped; partial state must remain uncertain.
+            const p = runtimePaths(directory);
+            const { promises: fs } = await import('node:fs');
+            try {
+                await fs.lstat(p.socket);
+            }
+            catch (e) {
+                if (e.code === 'ENOENT') {
+                    try {
+                        await fs.lstat(p.ownerFile);
+                    }
+                    catch (e2) {
+                        if (e2.code === 'ENOENT')
+                            return stoppedRuntime();
+                    }
+                }
+            }
+        }
+        return { ...stoppedRuntime(), state: 'unknown', connection: 'unknown' };
+    }
+}
+export async function stopRuntime(directory, expectedGeneration) {
+    await runtimeRequest(directory, 'stop', expectedGeneration);
+    const deadline = Date.now() + 10_000;
+    while (Date.now() < deadline) {
+        const state = await inspectRuntime(directory);
+        if (state.state === 'stopped')
+            return;
+        if (state.generation && state.generation !== expectedGeneration)
+            throw new LocalControlError('BINDING_CONFLICT', 'A new daemon started');
+        await new Promise(resolve => setTimeout(resolve, 50));
+    }
+    throw new LocalControlError('OUTCOME_UNKNOWN', 'Workstation shutdown has not been confirmed');
+}
+export async function requestRuntimeUpdate(directory, release, operationId) {
+    return await runtimeRequest(directory, 'update', undefined, { release, operationId });
+}

package/dist/workstation/control/runtimeHost.js

@@ -0,0 +1,148 @@
+import { createHash, randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import { privateDirectory, socketLimit } from '../keepers/kit/paths.js';
+import { pidAlive, processCommand } from '../keepers/kit/lock.js';
+import { processStartTime } from '../keepers/kit/orphanSweep.js';
+import { LocalControlError } from './protocol.js';
+import { withPrivateLock } from './locks.js';
+export function runtimePaths(directory) {
+    const root = path.join(path.resolve(directory), 'control');
+    const key = createHash('sha256').update(`${process.getuid?.() ?? 'user'}:${path.resolve(directory)}`).digest('hex').slice(0, 24);
+    const local = path.join(root, 'runtime.sock');
+    return { socket: Buffer.byteLength(local) < socketLimit() ? local : `/tmp/axom-control-${process.getuid?.() ?? 'user'}/${key}.sock`, tokenFile: path.join(root, 'runtime.token'), ownerFile: path.join(root, 'runtime.owner.json') };
+}
+export async function readControlFile(file) {
+    const stat = await fs.lstat(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 65_536 || (process.getuid && stat.uid !== process.getuid()) || (stat.mode & 0o077))
+        throw Error('Unsafe control file');
+    return fs.readFile(file, 'utf8');
+}
+/** A persisted PID can belong to another process after a container restart or reboot. */
+export async function runtimeOwnerLive(owner) {
+    if (!pidAlive(owner.pid))
+        return false;
+    const command = await processCommand(owner.pid);
+    if (command !== null && command !== owner.command)
+        return false;
+    if (typeof owner.startTime === 'string') {
+        const startTime = await processStartTime(owner.pid);
+        if (startTime !== null && startTime !== owner.startTime)
+            return false;
+    }
+    // Inability to read the process identity is not evidence that it stopped.
+    return true;
+}
+export async function openRuntimeHost(options) {
+    const paths = runtimePaths(options.directory);
+    await privateDirectory(path.dirname(paths.ownerFile));
+    await privateDirectory(path.dirname(paths.socket));
+    return withPrivateLock(path.join(options.directory, 'control/runtime-start'), async () => {
+        try {
+            const owner = JSON.parse(await readControlFile(paths.ownerFile));
+            if (!Number.isSafeInteger(owner.pid) || owner.pid <= 0 || typeof owner.command !== 'string')
+                throw Error('Unknown runtime owner');
+            if (await runtimeOwnerLive(owner))
+                throw new LocalControlError('INSTANCE_OCCUPIED', 'A workstation daemon already owns this computer');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                if (error instanceof LocalControlError)
+                    throw error;
+                throw new LocalControlError('INSTANCE_OCCUPIED', 'Cannot verify the existing workstation daemon');
+            }
+            // A socket with no owner cannot safely be reclaimed.
+            try {
+                await fs.lstat(paths.socket);
+                throw new LocalControlError('INSTANCE_OCCUPIED', 'Unverified workstation socket');
+            }
+            catch (e) {
+                if (e.code !== 'ENOENT')
+                    throw e;
+            }
+        }
+        await fs.rm(paths.socket, { force: true });
+        const generation = randomUUID();
+        const token = randomBytes(32).toString('hex');
+        const binding = { ...options.binding };
+        let closed = false;
+        const clients = new Set();
+        const server = net.createServer(socket => {
+            clients.add(socket);
+            socket.on('close', () => clients.delete(socket));
+            socket.on('error', () => { });
+            socket.setTimeout(3000, () => socket.destroy());
+            let body = '';
+            let handled = false;
+            socket.on('data', chunk => {
+                body += chunk.toString();
+                if (Buffer.byteLength(body) > 65_536) {
+                    socket.destroy();
+                    return;
+                }
+                if (handled || !body.includes('\n'))
+                    return;
+                handled = true;
+                void (async () => {
+                    try {
+                        const request = JSON.parse(body.split('\n')[0]);
+                        if (typeof request.token !== 'string' || request.token.length !== token.length || !timingSafeEqual(Buffer.from(token), Buffer.from(request.token)))
+                            throw Error('Unauthorized');
+                        if (request.generation !== generation)
+                            throw new LocalControlError('BINDING_CONFLICT', 'Runtime generation changed');
+                        let value;
+                        if (request.action === 'inspect')
+                            value = { ...await options.snapshot(), state: 'running', binding, generation, mode: options.mode };
+                        else if (request.action === 'stop')
+                            value = { accepted: true };
+                        else if (request.action === 'update') {
+                            const r = request.release;
+                            if (typeof request.operationId !== 'string' || request.operationId.length > 128 || !r || typeof r.version !== 'string' || typeof r.url !== 'string' || typeof r.sha512 !== 'string' || !Number.isSafeInteger(r.size))
+                                throw Error('Invalid update request');
+                            value = await options.update(r, request.operationId);
+                        }
+                        else
+                            throw Error('Invalid action');
+                        socket.end(JSON.stringify({ ok: true, value }) + '\n');
+                        if (request.action === 'stop')
+                            setImmediate(() => { void options.shutdown().catch(() => { }); });
+                    }
+                    catch (error) {
+                        socket.end(JSON.stringify({ ok: false, code: error instanceof LocalControlError ? error.code : 'SERVICE_FAILED' }) + '\n');
+                    }
+                })();
+            });
+        });
+        const close = async () => {
+            if (closed)
+                return;
+            closed = true;
+            for (const socket of clients)
+                socket.destroy();
+            await new Promise(resolve => server.close(() => resolve()));
+            // Only remove our own generation.
+            try {
+                if (JSON.parse(await readControlFile(paths.ownerFile)).generation === generation) {
+                    await fs.rm(paths.ownerFile, { force: true });
+                    await fs.rm(paths.tokenFile, { force: true });
+                    await fs.rm(paths.socket, { force: true });
+                }
+            }
+            catch { /* never remove another owner */ }
+        };
+        try {
+            await new Promise((resolve, reject) => { server.once('error', reject); server.listen(paths.socket, () => { server.removeListener('error', reject); resolve(); }); });
+            await fs.chmod(paths.socket, 0o600);
+            await fs.writeFile(paths.tokenFile, token, { mode: 0o600 });
+            await fs.chmod(paths.tokenFile, 0o600);
+            await fs.writeFile(paths.ownerFile, JSON.stringify({ schemaVersion: 1, pid: process.pid, command: await processCommand(process.pid), startTime: await processStartTime(process.pid), generation }), { mode: 0o600 });
+            await fs.chmod(paths.ownerFile, 0o600);
+            return { generation, close };
+        }
+        catch (error) {
+            await close();
+            throw error;
+        }
+    });
+}

package/dist/workstation/control/serverIdentity.js

@@ -0,0 +1,35 @@
+const ENDPOINTS = new Set(['/workstation/register', '/download/client/manifest.json', '/rest/auth/me', '/rest/auth/scopes/check']);
+export function normalizeWorkstationServer(value) {
+    if (/[\u0000-\u0020\\]/.test(value))
+        throw new Error('Invalid workstation server URL');
+    // Inspect the original path: URL construction silently removes encoded dot segments.
+    const rawPath = /^[A-Za-z][A-Za-z0-9+.-]*:\/\/[^/?#]*(\/[^?#]*)?/.exec(value)?.[1] ?? '';
+    for (const part of rawPath.split('/')) {
+        const decoded = decodeURIComponent(part);
+        if (decoded === '.' || decoded === '..' || /[\/\\\u0000-\u001f\u007f]/.test(decoded))
+            throw new Error('Invalid workstation server path');
+    }
+    const url = new URL(value);
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
+        throw new Error('Workstation server must be an HTTP(S) URL without credentials, query or fragment');
+    }
+    return url.origin + url.pathname.replace(/\/+$/, '');
+}
+export function workstationEndpoint(server, apiPath) {
+    if (!ENDPOINTS.has(apiPath))
+        throw new Error('Unrecognized workstation endpoint');
+    return new URL(normalizeWorkstationServer(server) + apiPath);
+}
+/** Catalog URLs are deployment-relative even when a reverse proxy adds a path prefix. */
+export function deploymentDownloadURL(server, value) {
+    const base = normalizeWorkstationServer(server);
+    const configured = new URL(base);
+    const candidate = value.startsWith('/download/client/') ? base + value : new URL(value, base + '/').toString();
+    const normalized = normalizeWorkstationServer(candidate);
+    const url = new URL(normalized);
+    if (url.origin !== configured.origin)
+        throw new Error('Artifact URL must use the configured server origin');
+    if (!url.pathname.startsWith(configured.pathname.replace(/\/$/, '') + '/download/client/'))
+        throw new Error('Artifact URL must stay in the configured deployment');
+    return normalized;
+}

package/dist/workstation/daemon.js

@@ -1,9 +1,13 @@
+import { claimDaemonIdentity } from './control/daemonIdentity.js';
+import { openRuntimeHost } from './control/runtimeHost.js';
+import { stoppedRuntime } from './control/protocol.js';
+import { normalizeWorkstationServer } from './control/serverIdentity.js';
 import { promises as fs } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { AGENT_WIRE_MIN_VERSION } from './protocol/agent.js';
-import { clientDir, loadClientConfig, readKeys, updateServiceContext } from './config.js';
+import { clientDir, loadClientConfig, updateServiceContext } from './config.js';
 import { AgentSessionManager } from './agentSessions.js';
 import { AcpAgents } from './acp/acpAgents.js';
 import { ConnectionSupervisor } from './connection/supervisor.js';
@@ -11,6 +15,7 @@ import { ManagementChannel } from './channels/management.js';
 import { ComputerChannel } from './channels/computer.js';
 import { AgentChannel, dispatchAgentFrame as dispatchAgentChannelFrame } from './channels/agent.js';
 import { TaskRegistry } from './update/taskRegistry.js';
+import { RdUpkeep } from './rd/upkeep.js';
 import { createUpdateCoordinator } from './update/runUpdate.js';
 import { resolveCliPath } from './daemonctl.js';
 import { SystemMetricsSampler } from './systemMetrics.js';
@@ -29,6 +34,7 @@ import { keeperGenerations } from './acp/processor/transport/generations.js';
 import { ExecPolicy } from './exec/policy.js';
 import { LegacyToolsKeeper } from './keepers/legacy.js';
 import { TerminalRouter, terminalEnv, terminalShell } from './tools/terminalRouter.js';
+import { ToolchainProbe } from './toolchain.js';
 /**
  * The path `runDaemon` hands `createUpdateCoordinator` as `cliPath`, used to re-provision the OS
  * service after an update (see runUpdate.ts's `provisionService`).
@@ -281,6 +287,30 @@ export function startExclusivePoll(poll, intervalMs) {
     return () => clearInterval(timer);
 }
 export async function runDaemon(options = {}) {
+    const directory = clientDir();
+    const shutdown = new AbortController();
+    const state = { snapshot: async () => ({ ...stoppedRuntime(), connection: 'connecting' }) };
+    const { host, identity } = await claimDaemonIdentity(directory, async (identity) => {
+        const config = identity.config;
+        const host = await openRuntimeHost({ directory, binding: { server: normalizeWorkstationServer(config.server), workstationId: config.workstationId, ...(config.ownerUserId ? { ownerUserId: config.ownerUserId } : {}) },
+            mode: options.supervisedByServiceManager ? 'launchd' : 'foreground', snapshot: () => state.snapshot(), shutdown: async () => { shutdown.abort(); },
+            update: async (release, operationId) => {
+                if (!state.update)
+                    return { phase: 'BUSY', commandId: operationId };
+                void state.update.handle({ commandId: operationId, release, force: false }).catch(error => console.error('[update] local request failed', error));
+                return { phase: 'REQUESTED', commandId: operationId, version: release.version };
+            },
+        });
+        return { host, identity };
+    });
+    try {
+        await runOwnedDaemon(options, shutdown, state, identity);
+    }
+    finally {
+        await host.close();
+    }
+}
+async function runOwnedDaemon(options, shutdown, localState, identity) {
     // Last line of defence for the whole process. Node's default for an unhandled rejection is to
     // *exit*, and this daemon is the only thing keeping every session on this workstation alive —
     // dying because one async callback rejected is strictly worse than logging and carrying on.
@@ -290,8 +320,25 @@ export async function runDaemon(options = {}) {
         console.error(`[daemon] unhandled rejection (ignored, daemon stays up): ${detail}`);
     });
     const dir = clientDir();
-    const cfg = await loadClientConfig(dir);
-    const { clientKey, serverPub } = await readKeys(dir);
+    const cfg = identity.config;
+    let activateRdAfterReadiness;
+    if (process.platform === 'linux') {
+        const { synchronizeRd } = await import('./rd/update.js');
+        activateRdAfterReadiness = await synchronizeRd(dir, cfg.server);
+    }
+    const { NativeProvider } = await import('./desktopControl/nativeProvider.js');
+    const { DeviceSockets } = await import('./desktopControl/deviceSockets.js');
+    const { DesktopSessionSupervisor } = await import('./desktopControl/supervisor.js');
+    const { MacProvider } = await import('./desktopControl/macProvider.js');
+    const { LinuxDesktopProvider } = await import('./rd/provider.js');
+    const legacyDesktop = cfg.desktopProvider ? new NativeProvider({ ...cfg.desktopProvider, validateSession: async () => {
+            const { readRdState } = await import('./rd/state.js');
+            if (await readRdState(dir))
+                throw new Error('Remote desktop configuration changed');
+        } }) : undefined;
+    const desktopProvider = options.desktopProvider ?? (process.platform === 'linux' ? new LinuxDesktopProvider(dir, cfg.server, legacyDesktop) :
+        legacyDesktop ?? (process.platform === 'darwin' && process.arch === 'arm64' ? new MacProvider(dir, cfg) : undefined));
+    const { clientKey, serverPub } = identity;
     // Repair the first fixed release even when it was installed by an older ignore-scripts updater,
     // before a newly started keeper-terminal snapshots native dependency availability.
     await preflightOptionalPty(updateServiceContext(dir));
@@ -317,6 +364,7 @@ export async function runDaemon(options = {}) {
         // invoked*, not on what the host merely supports.
         serviceLifecycle: resolveServiceLifecycle(options),
     });
+    localState.update = updates;
     // One ACP client for every external agent; the roster it reports is the ACP agent registry, keyed
     // by registry agent id (ruling R2) — the same key `agent_open.bridge` now carries.
     // Live sessions run in keeper-acp (spec §5.3) — the adapters outlive the daemon there — or, when it cannot be reached, in the
@@ -326,7 +374,7 @@ export async function runDaemon(options = {}) {
     // Sessions keeper-acp still runs from a previous daemon (a restart, an upgrade, a crash) are adopted where they are — across
     // keeper-acp generations (spec §5.5, §6.3) — before the agent channel's reconnect offer is answered.
     const acpGenerations = keeperGenerations({ launcher: acpLauncher, current: acpTransport });
-    const acp = new AcpAgents({ cacheDir: dir, transports: { keeper: acpTransport }, keeperGenerations: acpGenerations });
+    const acp = new AcpAgents({ cacheDir: dir, serverOrigin: cfg.server, transports: { keeper: acpTransport }, keeperGenerations: acpGenerations });
     const agents = new AgentSessionManager(acp, null, path.join(dir, 'agents'), tasks);
     void agents.adoptSessions();
     let bridges = await acp.roster();
@@ -448,14 +496,54 @@ export async function runDaemon(options = {}) {
     });
     const metrics = new SystemMetricsSampler(cfg.workspaces ?? []);
     await metrics.start();
+    const toolchain = new ToolchainProbe(() => terminalShell(), () => terminalEnv());
+    toolchain.start();
+    const desktopSupervisor = desktopProvider && !options.onDesktopCommand ? new DesktopSessionSupervisor({ provider: desktopProvider,
+        sockets: new DeviceSockets(cfg.server, process.env.AXOM_DESKTOP_ALLOW_PRIVATE_WS === '1'),
+        report: (generation, frame) => management.sendDesktopState(generation, frame),
+        refreshCapabilities: generation => management.refreshDesktopCapabilities(generation), }) : undefined;
+    let rdGeneration;
+    const rdUpkeep = process.platform === 'linux' && desktopSupervisor ? new RdUpkeep({
+        synchronize: async () => {
+            if (!rdGeneration || shutdown.signal.aborted)
+                return;
+            const { synchronizeRd } = await import('./rd/update.js');
+            return synchronizeRd(dir, cfg.server, { deferActivation: true });
+        },
+        whenIdle: operation => desktopSupervisor.whenIdle(async () => {
+            if (!tasks.canUpdate() || !rdGeneration || shutdown.signal.aborted)
+                return;
+            await operation();
+        }),
+        refresh: () => { if (rdGeneration)
+            management.refreshDesktopCapabilities(rdGeneration); },
+        log: message => console.error(`${new Date().toISOString()} ${message}`),
+    }) : undefined;
+    const stopRdUpkeep = rdUpkeep ? startExclusivePoll(() => rdUpkeep.tick(), 60_000) : () => { };
     const management = new ManagementChannel({
         server: cfg.server, workstationId: cfg.workstationId, workstation: cfg.workstationId, clientKey, serverPub,
         bridges: () => bridges,
         workspaces: cfg.workspaces,
         playgroundCwd,
         metrics: () => metrics.snapshot(),
+        toolchain: () => toolchain.current(),
         allowInsecureWs,
-        onReady: (ready) => updates.managementReady(ready.release, ready.generation),
+        onReady: async (ready) => {
+            await updates.managementReady(ready.release, ready.generation);
+            await activateRdAfterReadiness?.();
+            if (ready.selectedWire >= 9)
+                desktopSupervisor?.managementReady(ready.generation);
+            rdGeneration = ready.selectedWire >= 9 ? ready.generation : undefined;
+            void rdUpkeep?.tick();
+        },
+        desktopProvider,
+        onDesktopCommand: options.onDesktopCommand ?? ((frame, generation) => desktopSupervisor?.dispatch(frame, generation) ?? Promise.resolve()),
+        onClosed: generation => {
+            if (rdGeneration === generation)
+                rdGeneration = undefined;
+            desktopSupervisor?.managementClosed(generation);
+            options.onDesktopManagementClosed?.(generation);
+        },
         onUpdate: (command) => updates.handle(command),
         onExternalAgentsScan: async () => {
             bridges = await scanRoster();
@@ -465,6 +553,7 @@ export async function runDaemon(options = {}) {
         keepers: () => buildKeeperStatuses(keeperPolicy, () => tasks.countedKeeperExecs),
         onKeeperControl: (frame) => keeperPolicy.control(frame),
     });
+    options.onDesktopManagement?.(management);
     const agent = new AgentChannel({ server: cfg.server, agents, bridges: () => bridges, allowInsecureWs });
     // Spec §6.2: first take over what an older CLI left (`_npx` copies, pre-build binary dirs) so agents
     // that worked keep working; then §6.1: a version this CLI certifies (runtime.json/catalog pin) or a
@@ -501,7 +590,14 @@ export async function runDaemon(options = {}) {
     });
     const stopIdleSweep = startIdleSweep(agents);
     const stopSwitchUpkeep = startSwitchUpkeep(agents, acp);
-    const shutdown = new AbortController();
+    localState.snapshot = async () => {
+        const channels = supervisor.channelSnapshot();
+        const active = await buildManagementSnapshot(supervisor, tasks, updates);
+        const keepers = await buildKeeperStatuses(keeperPolicy, () => tasks.countedKeeperExecs);
+        const sum = (key) => keepers?.reduce((n, k) => n + (k.metrics[key] ?? 0), 0) ?? 0;
+        return { ...stoppedRuntime(), connection: channels.management === 'CONNECTED' ? 'online' : 'reconnecting',
+            activity: keepers === null ? null : { commands: Math.max(0, active.activeShellTasks + sum('execRunning') - sum('execCounted')), terminals: sum('ptyOpen'), agents: active.activeAgentTasks + sum('sessions'), transfers: 0 } };
+    };
     const stop = () => shutdown.abort();
     process.once('SIGINT', stop);
     process.once('SIGTERM', stop);
@@ -509,11 +605,15 @@ export async function runDaemon(options = {}) {
         await supervisor.run(shutdown.signal);
     }
     finally {
+        stopRdUpkeep();
+        rdUpkeep?.stop();
+        await desktopSupervisor?.close();
         process.removeListener('SIGINT', stop);
         process.removeListener('SIGTERM', stop);
         stopIdleSweep();
         stopSwitchUpkeep();
         metrics.stop();
+        toolchain.stop();
         stopRootsPoll();
         stopLegacyPoll();
         stopKeeperPolicy();