@zhihand/mcp 0.28.0 → 0.30.0

package/dist/core/registry.js

@@ -0,0 +1,288 @@
+/**
+ * Device registry — the single source of truth for all paired devices,
+ * their live state (profile, online flag, SSE connection), and multi-
+ * device routing.
+ *
+ * Holds a per-credential AbortController for SSE, a per-device heartbeat
+ * timer, and a single debounced notifier for list_changed.
+ */
+import { loadConfig, addDevice as configAddDevice, removeDevice as configRemoveDevice, renameDevice as configRenameDevice, setDefaultDevice as configSetDefault, updateLastSeen as configUpdateLastSeen, recordToRuntimeConfig, } from "./config.js";
+import { extractStatic, computeCapabilities, fetchDeviceProfileOnce, normalizeProfilePayload, } from "./device.js";
+import { connectSSEForCredential, handleSSEEvent } from "./sse.js";
+import { dbg } from "../daemon/logger.js";
+const HEARTBEAT_INTERVAL_MS = 30_000;
+const ONLINE_PROFILE_TTL_MS = 60_000;
+const LIST_CHANGED_DEBOUNCE_MS = 2500;
+class Registry {
+    devices = new Map();
+    listChangedSubs = new Set();
+    debounceTimer = null;
+    lastOnlineSet = new Set();
+    initialized = false;
+    get(credentialId) {
+        return this.devices.get(credentialId) ?? null;
+    }
+    list() {
+        return Array.from(this.devices.values());
+    }
+    listOnline() {
+        return this.list()
+            .filter((d) => d.online)
+            .sort((a, b) => b.lastSeenAtMs - a.lastSeenAtMs);
+    }
+    /**
+     * Priority:
+     *   1. If the user has explicitly set a default via `zhihand default <id>`
+     *      AND that device is online → return it. Honoring an explicit user
+     *      preference is the least-surprising UX.
+     *   2. Otherwise → most-recently-active online device (online[0] is sorted
+     *      desc by lastSeenAtMs).
+     *   3. No online devices → null.
+     */
+    resolveDefault() {
+        const online = this.listOnline();
+        if (online.length === 0)
+            return null;
+        const cfg = loadConfig();
+        if (cfg.default_credential_id) {
+            const d = this.devices.get(cfg.default_credential_id);
+            if (d && d.online)
+                return d;
+        }
+        return online[0];
+    }
+    toRuntimeConfig(state) {
+        return recordToRuntimeConfig(state.record);
+    }
+    subscribe(cb) {
+        this.listChangedSubs.add(cb);
+        return () => this.listChangedSubs.delete(cb);
+    }
+    computeOnlineSet() {
+        const out = new Set();
+        for (const d of this.devices.values()) {
+            if (d.online)
+                out.add(d.credentialId);
+        }
+        return out;
+    }
+    setsEqual(a, b) {
+        if (a.size !== b.size)
+            return false;
+        for (const x of a)
+            if (!b.has(x))
+                return false;
+        return true;
+    }
+    scheduleListChanged() {
+        const now = this.computeOnlineSet();
+        if (this.setsEqual(now, this.lastOnlineSet)) {
+            return;
+        }
+        if (this.debounceTimer)
+            return;
+        this.debounceTimer = setTimeout(() => {
+            this.debounceTimer = null;
+            const current = this.computeOnlineSet();
+            if (this.setsEqual(current, this.lastOnlineSet))
+                return;
+            this.lastOnlineSet = current;
+            for (const cb of this.listChangedSubs) {
+                try {
+                    cb();
+                }
+                catch { /* swallow */ }
+            }
+        }, LIST_CHANGED_DEBOUNCE_MS);
+    }
+    updateOnlineFlag(state) {
+        const profileFresh = state.profileReceivedAtMs > 0 &&
+            (Date.now() - state.profileReceivedAtMs) < ONLINE_PROFILE_TTL_MS;
+        const newOnline = state.sseConnected && profileFresh;
+        if (newOnline !== state.online) {
+            state.online = newOnline;
+            dbg(`[registry] ${state.credentialId} online=${newOnline}`);
+            this.scheduleListChanged();
+        }
+    }
+    touchLastSeen(state) {
+        state.lastSeenAtMs = Date.now();
+        const iso = new Date(state.lastSeenAtMs).toISOString();
+        try {
+            configUpdateLastSeen(state.credentialId, iso);
+            state.record.last_seen_at = iso;
+        }
+        catch {
+            // non-fatal
+        }
+    }
+    async refreshProfile(state) {
+        const cfg = this.toRuntimeConfig(state);
+        const result = await fetchDeviceProfileOnce(cfg);
+        if (!result) {
+            state.online = false;
+            this.scheduleListChanged();
+            return false;
+        }
+        state.rawAttributes = result.rawAttrs;
+        state.profileReceivedAtMs = result.receivedAtMs;
+        state.profile = extractStatic(result.rawAttrs);
+        state.capabilities = computeCapabilities(result.rawAttrs, result.receivedAtMs);
+        // Infer platform from profile
+        const plat = state.profile.platform;
+        if (plat === "ios" || plat === "android") {
+            state.platform = plat;
+            state.record.platform = plat;
+        }
+        this.touchLastSeen(state);
+        this.updateOnlineFlag(state);
+        return true;
+    }
+    startHeartbeat(state) {
+        if (state.heartbeatTimer)
+            return;
+        state.heartbeatTimer = setInterval(() => {
+            this.refreshProfile(state).catch(() => { });
+        }, HEARTBEAT_INTERVAL_MS);
+    }
+    stopHeartbeat(state) {
+        if (state.heartbeatTimer) {
+            clearInterval(state.heartbeatTimer);
+            state.heartbeatTimer = null;
+        }
+    }
+    startSSE(state) {
+        if (state.sseController)
+            return;
+        const cfg = this.toRuntimeConfig(state);
+        state.sseController = connectSSEForCredential(cfg, {
+            onEvent: (ev) => {
+                // Dispatch command ACKs globally
+                handleSSEEvent(ev);
+                if (ev.kind === "device_profile.updated" && ev.device_profile) {
+                    const attrs = normalizeProfilePayload(ev.device_profile);
+                    state.rawAttributes = attrs;
+                    state.profileReceivedAtMs = Date.now();
+                    state.profile = extractStatic(attrs);
+                    state.capabilities = computeCapabilities(attrs, state.profileReceivedAtMs);
+                    const plat = state.profile.platform;
+                    if (plat === "ios" || plat === "android") {
+                        state.platform = plat;
+                        state.record.platform = plat;
+                    }
+                    this.touchLastSeen(state);
+                    this.updateOnlineFlag(state);
+                }
+                else if (ev.kind === "credential.revoked") {
+                    dbg(`[registry] ${state.credentialId} credential.revoked`);
+                    state.online = false;
+                    this.scheduleListChanged();
+                }
+            },
+            onConnected: () => {
+                dbg(`[registry] SSE connected: ${state.credentialId}`);
+                state.sseConnected = true;
+                this.updateOnlineFlag(state);
+            },
+            onDisconnected: () => {
+                dbg(`[registry] SSE disconnected: ${state.credentialId}`);
+                state.sseConnected = false;
+                this.updateOnlineFlag(state);
+            },
+        });
+    }
+    stopSSE(state) {
+        state.sseController?.abort();
+        state.sseController = null;
+        state.sseConnected = false;
+    }
+    makeState(record) {
+        return {
+            credentialId: record.credential_id,
+            label: record.label,
+            platform: record.platform,
+            online: false,
+            lastSeenAtMs: 0,
+            profile: null,
+            capabilities: null,
+            profileReceivedAtMs: 0,
+            rawAttributes: {},
+            sseController: null,
+            sseConnected: false,
+            heartbeatTimer: null,
+            record,
+        };
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        this.initialized = true;
+        const cfg = loadConfig();
+        const records = Object.values(cfg.devices);
+        for (const r of records) {
+            const s = this.makeState(r);
+            this.devices.set(r.credential_id, s);
+            this.startSSE(s);
+            this.startHeartbeat(s);
+        }
+        // Fire off initial profile fetches in parallel, with overall ~5s cap
+        const fetches = records.map((r) => {
+            const s = this.devices.get(r.credential_id);
+            return this.refreshProfile(s).catch(() => false);
+        });
+        await Promise.race([
+            Promise.all(fetches),
+            new Promise((r) => setTimeout(r, 5000)),
+        ]);
+    }
+    async addDevice(record) {
+        configAddDevice(record);
+        let s = this.devices.get(record.credential_id);
+        if (!s) {
+            s = this.makeState(record);
+            this.devices.set(record.credential_id, s);
+        }
+        else {
+            s.record = record;
+            s.label = record.label;
+        }
+        this.startSSE(s);
+        this.startHeartbeat(s);
+        await this.refreshProfile(s).catch(() => false);
+    }
+    removeDevice(credentialId) {
+        const s = this.devices.get(credentialId);
+        if (s) {
+            this.stopSSE(s);
+            this.stopHeartbeat(s);
+            this.devices.delete(credentialId);
+        }
+        configRemoveDevice(credentialId);
+        this.scheduleListChanged();
+    }
+    renameDevice(credentialId, label) {
+        configRenameDevice(credentialId, label);
+        const s = this.devices.get(credentialId);
+        if (s) {
+            s.label = label;
+            s.record.label = label;
+        }
+    }
+    setDefault(credentialId) {
+        configSetDefault(credentialId);
+    }
+    shutdown() {
+        for (const s of this.devices.values()) {
+            this.stopSSE(s);
+            this.stopHeartbeat(s);
+        }
+        this.devices.clear();
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+        this.listChangedSubs.clear();
+        this.initialized = false;
+    }
+}
+export const registry = new Registry();

package/dist/core/screenshot.d.ts

@@ -1,2 +1,13 @@
-import type { ZhiHandConfig } from "./config.ts";
-export declare function fetchScreenshotBinary(config: ZhiHandConfig): Promise<Buffer>;
+import type { ZhiHandRuntimeConfig } from "./config.ts";
+export declare function getSnapshotStaleThresholdMs(): number;
+export interface ScreenshotResult {
+    buffer: Buffer;
+    ageMs: number;
+    width: number;
+    height: number;
+    capturedAt: string | null;
+    sequence: number;
+    stale: boolean;
+}
+export declare function fetchScreenshot(config: ZhiHandRuntimeConfig): Promise<ScreenshotResult>;
+export declare function fetchScreenshotBinary(config: ZhiHandRuntimeConfig): Promise<Buffer>;

package/dist/core/screenshot.js

@@ -1,5 +1,24 @@
 import { dbg } from "../daemon/logger.js";
-export async function fetchScreenshotBinary(config) {
+// Snapshot is considered stale if the server-reported age exceeds this
+// threshold. Configurable via env ZHIHAND_SNAPSHOT_MAX_AGE_MS.
+// Default 5s: typical HID command + capture + upload is well under 2s;
+// anything beyond 5s suggests the phone is no longer actively sharing.
+export function getSnapshotStaleThresholdMs() {
+    const raw = process.env.ZHIHAND_SNAPSHOT_MAX_AGE_MS;
+    if (raw) {
+        const n = Number(raw);
+        if (Number.isFinite(n) && n > 0)
+            return n;
+    }
+    return 5000;
+}
+function parseIntHeader(h) {
+    if (!h)
+        return -1;
+    const n = Number(h);
+    return Number.isFinite(n) ? n : -1;
+}
+export async function fetchScreenshot(config) {
     const controller = new AbortController();
     const timeoutMs = config.timeoutMs ?? 10_000;
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
@@ -20,10 +39,31 @@ export async function fetchScreenshotBinary(config) {
             throw new Error(`Screenshot fetch failed: ${response.status}`);
         }
         const buf = Buffer.from(await response.arrayBuffer());
-        dbg(`[screenshot] OK: ${(buf.length / 1024).toFixed(0)}KB in ${Date.now() - t0}ms`);
-        return buf;
+        const ageMs = parseIntHeader(response.headers.get("x-snapshot-age"));
+        const width = parseIntHeader(response.headers.get("x-snapshot-width"));
+        const height = parseIntHeader(response.headers.get("x-snapshot-height"));
+        const sequence = parseIntHeader(response.headers.get("x-snapshot-sequence"));
+        const capturedAt = response.headers.get("x-snapshot-captured-at");
+        const threshold = getSnapshotStaleThresholdMs();
+        const stale = ageMs >= 0 && ageMs > threshold;
+        dbg(`[screenshot] OK: ${(buf.length / 1024).toFixed(0)}KB in ${Date.now() - t0}ms, age=${ageMs}ms, stale=${stale}`);
+        return {
+            buffer: buf,
+            ageMs,
+            width: Math.max(width, 0),
+            height: Math.max(height, 0),
+            capturedAt,
+            sequence,
+            stale,
+        };
     }
     finally {
         clearTimeout(timeout);
     }
 }
+// Backward-compatible wrapper — returns only the Buffer.
+// New code should prefer fetchScreenshot() for staleness info.
+export async function fetchScreenshotBinary(config) {
+    const res = await fetchScreenshot(config);
+    return res.buffer;
+}

package/dist/core/sse.d.ts

@@ -1,4 +1,4 @@
-import type { ZhiHandConfig } from "./config.ts";
+import type { ZhiHandRuntimeConfig } from "./config.ts";
 import type { QueuedCommandRecord, WaitForCommandAckResult } from "./command.ts";
 export interface SSEEvent {
     id: string;
@@ -6,29 +6,26 @@ export interface SSEEvent {
     kind: string;
     credential_id: string;
     command?: QueuedCommandRecord;
+    device_profile?: Record<string, unknown>;
     sequence: number;
 }
 export declare function handleSSEEvent(event: SSEEvent): void;
 export declare function subscribeToCommandAck(commandId: string, callback: (cmd: QueuedCommandRecord) => void): () => void;
+export interface SSEHandlers {
+    onEvent: (e: SSEEvent) => void;
+    onConnected: () => void;
+    onDisconnected: () => void;
+}
 /**
- * Connect to the SSE event stream for command ACKs.
- * Maintains a persistent connection that dispatches events to registered callbacks.
- * Reconnects automatically on connection loss.
- */
-export declare function connectSSE(config: ZhiHandConfig): void;
-/**
- * Disconnect the SSE event stream.
- */
-export declare function disconnectSSE(): void;
-/**
- * Whether the SSE stream is currently connected.
+ * Open a per-credential SSE connection. Caller owns the returned AbortController.
+ * The loop auto-reconnects with exponential backoff until aborted.
  */
-export declare function isSSEConnected(): boolean;
+export declare function connectSSEForCredential(config: ZhiHandRuntimeConfig, handlers: SSEHandlers): AbortController;
 /**
- * Wait for command ACK via SSE push.
- * Falls back to polling if SSE is not active.
+ * Wait for command ACK via SSE push (which should already be connected by the
+ * registry). Falls back to polling.
  */
-export declare function waitForCommandAck(config: ZhiHandConfig, options: {
+export declare function waitForCommandAck(config: ZhiHandRuntimeConfig, options: {
     commandId: string;
     timeoutMs?: number;
     signal?: AbortSignal;

package/dist/core/sse.js

@@ -1,10 +1,7 @@
 import { getCommand } from "./command.js";
 import { dbg } from "../daemon/logger.js";
-// Per-commandId callback registry for SSE-based ACK
+// Per-commandId callback registry for SSE-based ACK (global — ids are globally unique)
 const ackCallbacks = new Map();
-// Active SSE connection state
-let sseAbortController = null;
-let sseConnected = false;
 export function handleSSEEvent(event) {
     dbg(`[sse-cmd] Event: kind=${event.kind}, command=${event.command?.id ?? "-"}`);
     if (event.kind === "command.acked" && event.command) {
@@ -21,16 +18,15 @@ export function subscribeToCommandAck(commandId, callback) {
     return () => { ackCallbacks.delete(commandId); };
 }
 /**
- * Connect to the SSE event stream for command ACKs.
- * Maintains a persistent connection that dispatches events to registered callbacks.
- * Reconnects automatically on connection loss.
+ * Open a per-credential SSE connection. Caller owns the returned AbortController.
+ * The loop auto-reconnects with exponential backoff until aborted.
  */
-export function connectSSE(config) {
-    if (sseAbortController)
-        return; // Already connected
-    sseAbortController = new AbortController();
-    const { signal } = sseAbortController;
-    const url = `${config.controlPlaneEndpoint}/v1/credentials/${encodeURIComponent(config.credentialId)}/events/stream?topic=commands`;
+export function connectSSEForCredential(config, handlers) {
+    const controller = new AbortController();
+    const { signal } = controller;
+    const url = `${config.controlPlaneEndpoint}/v1/credentials/${encodeURIComponent(config.credentialId)}/events/stream`;
+    let backoffMs = 1000;
+    const BACKOFF_MAX = 30_000;
     (async () => {
         while (!signal.aborted) {
             try {
@@ -44,12 +40,14 @@ export function connectSSE(config) {
                 if (!response.ok) {
                     throw new Error(`SSE connect failed: ${response.status}`);
                 }
-                sseConnected = true;
+                handlers.onConnected();
+                backoffMs = 1000;
                 const reader = response.body?.getReader();
                 if (!reader)
                     throw new Error("No response body for SSE");
                 const decoder = new TextDecoder();
                 let buffer = "";
+                let eventData = "";
                 while (!signal.aborted) {
                     const { done, value } = await reader.read();
                     if (done)
@@ -57,18 +55,17 @@ export function connectSSE(config) {
                     buffer += decoder.decode(value, { stream: true });
                     const lines = buffer.split("\n");
                     buffer = lines.pop() ?? "";
-                    let eventData = "";
                     for (const line of lines) {
                         if (line.startsWith("data: ")) {
-                            eventData += line.slice(6);
+                            eventData += (eventData ? "\n" : "") + line.slice(6);
                         }
                         else if (line === "" && eventData) {
                             try {
-                                const event = JSON.parse(eventData);
-                                handleSSEEvent(event);
+                                const ev = JSON.parse(eventData);
+                                handlers.onEvent(ev);
                             }
                             catch {
-                                // Malformed event, skip
+                                // malformed, skip
                             }
                             eventData = "";
                         }
@@ -78,37 +75,22 @@ export function connectSSE(config) {
             catch (err) {
                 if (signal.aborted)
                     break;
-                sseConnected = false;
-                // Backoff before reconnect
-                await new Promise((r) => setTimeout(r, 3000));
+                handlers.onDisconnected();
+                await new Promise((r) => setTimeout(r, backoffMs));
+                backoffMs = Math.min(backoffMs * 2, BACKOFF_MAX);
             }
         }
-        sseConnected = false;
+        handlers.onDisconnected();
     })();
+    return controller;
 }
 /**
- * Disconnect the SSE event stream.
- */
-export function disconnectSSE() {
-    sseAbortController?.abort();
-    sseAbortController = null;
-    sseConnected = false;
-}
-/**
- * Whether the SSE stream is currently connected.
- */
-export function isSSEConnected() {
-    return sseConnected;
-}
-/**
- * Wait for command ACK via SSE push.
- * Falls back to polling if SSE is not active.
+ * Wait for command ACK via SSE push (which should already be connected by the
+ * registry). Falls back to polling.
  */
 export async function waitForCommandAck(config, options) {
     const timeoutMs = options.timeoutMs ?? 15_000;
     dbg(`[sse-cmd] Waiting for ACK: commandId=${options.commandId}, timeout=${timeoutMs}ms`);
-    // Ensure SSE is connected for real-time ACKs
-    connectSSE(config);
     return new Promise((resolve, reject) => {
         let resolved = false;
         let pollInterval;
@@ -123,28 +105,38 @@ export async function waitForCommandAck(config, options) {
             cleanup();
             resolve({ acked: true, command: ackedCommand });
         });
-        // Also poll as fallback (SSE may not be connected yet or may be reconnecting)
-        pollInterval = setInterval(async () => {
+        // Delay polling startup by 2s so SSE push ACK normally wins in the
+        // registry-connected path. CLI (zhihand test) still resolves via polling
+        // after the initial delay. This avoids hammering the backend with 500ms
+        // HTTP polls for every command when SSE is healthy.
+        const POLL_START_DELAY_MS = 2000;
+        const POLL_INTERVAL_MS = 500;
+        const startPolling = setTimeout(() => {
             if (resolved)
                 return;
-            try {
-                const cmd = await getCommand(config, options.commandId);
-                if (cmd.acked_at) {
-                    resolved = true;
-                    cleanup();
-                    resolve({ acked: true, command: cmd });
+            pollInterval = setInterval(async () => {
+                if (resolved)
+                    return;
+                try {
+                    const cmd = await getCommand(config, options.commandId);
+                    if (cmd.acked_at) {
+                        resolved = true;
+                        cleanup();
+                        resolve({ acked: true, command: cmd });
+                    }
                 }
-            }
-            catch {
-                // Polling failure is non-fatal; SSE or next poll may succeed
-            }
-        }, 500);
+                catch {
+                    // non-fatal
+                }
+            }, POLL_INTERVAL_MS);
+        }, POLL_START_DELAY_MS);
         options.signal?.addEventListener("abort", () => {
             cleanup();
             reject(new Error("The operation was aborted"));
         }, { once: true });
         function cleanup() {
             clearTimeout(timeout);
+            clearTimeout(startPolling);
             unsubscribe();
             if (pollInterval)
                 clearInterval(pollInterval);

package/dist/daemon/dispatcher.d.ts

@@ -1,4 +1,5 @@
-import type { ZhiHandConfig, BackendName } from "../core/config.ts";
+import type { ZhiHandRuntimeConfig, BackendName } from "../core/config.ts";
+type ZhiHandConfig = ZhiHandRuntimeConfig;
 export interface DispatchResult {
     text: string;
     success: boolean;
@@ -10,3 +11,4 @@ export interface DispatchResult {
 export declare function killActiveChild(): Promise<void>;
 export declare function dispatchToCLI(backend: Exclude<BackendName, "openclaw">, prompt: string, log: (msg: string) => void, model?: string): Promise<DispatchResult>;
 export declare function postReply(config: ZhiHandConfig, promptId: string, text: string): Promise<boolean>;
+export {};

package/dist/daemon/dispatcher.js

@@ -5,7 +5,7 @@ import os from "node:os";
 import { fileURLToPath } from "node:url";
 import { DEFAULT_MODELS } from "../core/config.js";
 import { resolveGemini, resolveClaude, resolveCodex } from "../core/resolve-path.js";
-import { getStaticContext, isDeviceProfileLoaded } from "../core/device.js";
+import { registry } from "../core/registry.js";
 import { dbg } from "./logger.js";
 const CLI_TIMEOUT = 300_000; // 300s (5min) per prompt — MCP tool chains need multiple turns
 const SIGKILL_DELAY = 2_000; // 2s after SIGTERM
@@ -357,7 +357,8 @@ export async function killActiveChild() {
  * so the AI sends correct platform-specific parameters (e.g. appPackage vs bundleId).
  */
 function buildSystemContext() {
-    const static_ = isDeviceProfileLoaded() ? getStaticContext() : null;
+    const defaultState = registry.resolveDefault();
+    const static_ = defaultState?.profile ?? null;
     const deviceLine = static_
         ? `Connected device: ${static_.platform} ${static_.model} (${static_.osVersion}), ${static_.screenWidthPx}x${static_.screenHeightPx}, ${static_.formFactor}, ${static_.locale}`
         : "Connected device: unknown platform";

package/dist/daemon/heartbeat.d.ts

@@ -1,4 +1,4 @@
-import type { ZhiHandConfig } from "../core/config.ts";
+import type { ZhiHandRuntimeConfig } from "../core/config.ts";
 /** Brain metadata included in every heartbeat, so the app always knows the current backend/model. */
 export interface BrainMeta {
     backend?: string | null;
@@ -6,7 +6,7 @@ export interface BrainMeta {
 }
 /** Update the backend/model metadata that will be sent with the next heartbeat. */
 export declare function setBrainMeta(meta: BrainMeta): void;
-export declare function sendBrainOnline(config: ZhiHandConfig): Promise<boolean>;
-export declare function sendBrainOffline(config: ZhiHandConfig): Promise<boolean>;
-export declare function startHeartbeatLoop(config: ZhiHandConfig, log: (msg: string) => void): void;
+export declare function sendBrainOnline(config: ZhiHandRuntimeConfig): Promise<boolean>;
+export declare function sendBrainOffline(config: ZhiHandRuntimeConfig): Promise<boolean>;
+export declare function startHeartbeatLoop(config: ZhiHandRuntimeConfig, log: (msg: string) => void): void;
 export declare function stopHeartbeatLoop(): void;

package/dist/daemon/index.js

@@ -11,7 +11,7 @@ import { startHeartbeatLoop, stopHeartbeatLoop, sendBrainOffline, setBrainMeta }
 import { PromptListener } from "./prompt-listener.js";
 import { dispatchToCLI, postReply, killActiveChild } from "./dispatcher.js";
 import { setDebugEnabled, dbg } from "./logger.js";
-import { fetchDeviceProfile, getStaticContext, isDeviceProfileLoaded } from "../core/device.js";
+import { registry } from "../core/registry.js";
 const DEFAULT_PORT = 18686;
 const PID_FILE = "daemon.pid";
 // ── State ──────────────────────────────────────────────────
@@ -190,10 +190,11 @@ export async function startDaemon(options) {
     else {
         log(`[config] No backend configured. Use: zhihand gemini / zhihand claude / zhihand codex`);
     }
-    // Fetch device profile (platform, model, screen size) — non-blocking, best-effort
-    await fetchDeviceProfile(config);
-    if (isDeviceProfileLoaded()) {
-        const s = getStaticContext();
+    // Init the multi-device registry (single-device in daemon context) and log profile.
+    await registry.init();
+    const defaultState = registry.resolveDefault();
+    if (defaultState?.profile) {
+        const s = defaultState.profile;
         log(`[device] ${s.platform} ${s.model} (${s.osVersion}), ${s.screenWidthPx}x${s.screenHeightPx}, ${s.locale}`);
     }
     else {
@@ -244,7 +245,7 @@ export async function startDaemon(options) {
                 }
                 else if (!sessionId) {
                     // New session: create dedicated McpServer + Transport
-                    const server = createMcpServer(options?.deviceName);
+                    const server = createMcpServer();
                     const transport = new StreamableHTTPServerTransport({
                         sessionIdGenerator: () => randomUUID(),
                         onsessioninitialized: (sid) => {
@@ -341,6 +342,7 @@ export async function startDaemon(options) {
             catch { /* ignore */ }
         }
         mcpSessions.clear();
+        registry.shutdown();
         httpServer.close();
         removePid();
         log("Daemon stopped.");