@co0ontty/wand 4.85.1-beta.g18a596a → 4.87.0-beta.gd2f0f8f

package/README.md

@@ -269,6 +269,10 @@ wand config:set port 9443
 | `language` | `""` | Claude 回复语言偏好（偏好项，存 SQLite） |
 | `publicOrigin` | 未设置 | 客户端应使用的公开访问地址，如 `https://home.example.com:8443`。TLS 在 L4 反代终止时必填 |
 
+### 语音识别
+
+Web、Android、iOS 可在语音输入设置中选择「服务端识别」或「客户端本地识别」。服务端使用按需安装的 whisper.cpp 多语言模型，支持无 GPU CPU 服务器、Mac mini Metal 与可选 CUDA；模型不随普通构建下载。部署、模型大小、鉴权和隐私边界见 [服务端语音识别](docs/server-speech.md)。
+
 ### 可选本地决策（实验性）
 
 Apple Silicon 服务端可共享一份离线 Laya-MLX，为结构化 CLI 提供通用选择、评分和是非判断。它不是聊天模型，也不负责授权或自动派工。

package/dist/agent-dispatch.js

@@ -22,9 +22,6 @@ export function resolveTaskDispatchTarget(deps, task) {
 export async function dispatchAgentForTask(deps, input) {
     const { storage, config, structured, processes } = deps;
     const { agent } = input;
-    if (agent.engine === "sdk" && !input.employee) {
-        throw new Error("SDK 执行引擎只能通过员工候选启用。");
-    }
     if (input.employee) {
         if (agent.kind !== "structured")
             throw new Error("绑定员工只支持结构化会话。");
@@ -65,6 +62,11 @@ export async function dispatchAgentForTask(deps, input) {
             provider,
             model: resolvedModel,
             thinkingEffort: agent.thinkingEffort,
+            // 直接派发 Wand Agent（不进员工候选链）：先裁决进程内引擎是否可用，
+            // 不可用就让这次派发明确失败，不静默退回 CLI 冒充。
+            ...(agent.engine === "sdk"
+                ? { engine: structured.resolveNewSessionPiEngine("sdk").engine }
+                : {}),
             worktreeEnabled: false,
             sessionSource: "automation",
             automationId: input.automationId,

package/dist/ai-team-runner.js

@@ -127,6 +127,7 @@ function chatAuthor(member, sessionId, agent) {
         avatar: member.avatar && !member.avatar.startsWith("data:") ? member.avatar : undefined,
         leader: member.isLeader || undefined,
         provider: used?.provider ?? member.agent.provider,
+        engine: used?.engine,
         model: used?.model?.trim() || undefined,
         thinkingEffort: used?.thinkingEffort || undefined,
         sessionId: sessionId ?? undefined,

package/dist/ai-team-types.d.ts

@@ -106,6 +106,7 @@ export declare const DEFAULT_EMPLOYEE_ID = "e_wand_default";
 export declare const DEFAULT_EMPLOYEE_NAME = "\u8D5B\u535A\u864E\u599E";
 export declare const DEFAULT_EMPLOYEE_TAG = "\u9ED8\u8BA4\u7528\u6237";
 export declare function isDefaultSiliconEmployee(employee: Pick<SiliconEmployee, "systemKey"> | null | undefined): boolean;
+export declare function isDecisionExpertSiliconEmployee(employee: Pick<SiliconEmployee, "systemKey"> | null | undefined): boolean;
 export declare function isBuiltinSiliconEmployee(employee: Pick<SiliconEmployee, "systemKey"> | null | undefined): boolean;
 export declare const SILICON_EMPLOYEE_MAX_TAGS = 8;
 export declare const SILICON_EMPLOYEE_TAG_MAX_CHARS = 20;

package/dist/ai-team-types.js

@@ -1,3 +1,4 @@
+import { DECISION_EXPERT_KEY } from "./decision-expert-identity.js";
 export const AI_TEAM_MIN_MEMBERS = 2;
 export const AI_TEAM_MAX_MEMBERS = 8;
 export const AI_TEAM_DEFAULT_MAX_STEPS = 30;
@@ -47,14 +48,17 @@ export const DEFAULT_EMPLOYEE_TAG = "默认用户";
 export function isDefaultSiliconEmployee(employee) {
     return employee?.systemKey === DEFAULT_EMPLOYEE_KEY;
 }
+export function isDecisionExpertSiliconEmployee(employee) {
+    return employee?.systemKey === DECISION_EXPERT_KEY;
+}
 export function isBuiltinSiliconEmployee(employee) {
-    return isSystemSiliconEmployee(employee) || isDefaultSiliconEmployee(employee);
+    return isSystemSiliconEmployee(employee) || isDefaultSiliconEmployee(employee) || isDecisionExpertSiliconEmployee(employee);
 }
 export const SILICON_EMPLOYEE_MAX_TAGS = 8;
 export const SILICON_EMPLOYEE_TAG_MAX_CHARS = 20;
 /** 内置标识只由真实员工身份投影，不能用自定义标签冒充。 */
 export function siliconEmployeeTags(employee) {
-    if (isSystemSiliconEmployee(employee))
+    if (isSystemSiliconEmployee(employee) || isDecisionExpertSiliconEmployee(employee))
         return [SYSTEM_EMPLOYEE_TAG];
     if (isDefaultSiliconEmployee(employee))
         return [DEFAULT_EMPLOYEE_TAG];

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "18a596a0dddbd8bd978f9e023fa2e163e33ee531",
-  "builtAt": "2026-10-08T02:06:19.406Z",
-  "version": "4.85.1-beta.g18a596a",
+  "commit": "d2f0f8fd339f2c9b668c596b443fb8d1b0756783",
+  "builtAt": "2026-10-09T02:34:16.136Z",
+  "version": "4.87.0-beta.gd2f0f8f",
   "channel": "beta"
 }

package/dist/cli.js

@@ -201,12 +201,18 @@ async function main() {
                 || !existsSync(pythonPath) || !existsSync(join(modelPath, "model.safetensors")))) {
                 throw new Error("用法：wand decision:configure --python <Python绝对路径> --model <已下载模型目录>；或 --disable。");
             }
-            const { config } = await loadConfigForCli(configPath);
-            config.localDecision = disabling
-                ? { enabled: false, pythonPath: config.localDecision?.pythonPath ?? "", modelPath: config.localDecision?.modelPath ?? "" }
-                : { enabled: true, pythonPath, modelPath };
-            await saveConfig(configPath, config);
-            process.stdout.write("本地决策配置已保存，重启 Wand 服务后生效。未修改系统 Python，也未下载模型。\n");
+            const { config, dbPath } = await loadConfigForCli(configPath);
+            const { WandStorage } = await import("./storage.js");
+            const storage = new WandStorage(dbPath);
+            try {
+                writePreferenceToStorage(config, storage, "localDecision", disabling
+                    ? { enabled: false, pythonPath: config.localDecision?.pythonPath ?? "", modelPath: config.localDecision?.modelPath ?? "" }
+                    : { enabled: true, pythonPath, modelPath });
+            }
+            finally {
+                storage.close();
+            }
+            process.stdout.write("本地决策配置已保存，CLI 修改需重启 Wand 服务后生效；设置页管理可热更新。未修改系统 Python，也未下载模型。\n");
             break;
         }
         case "decision:skills": {

package/dist/config.d.ts

@@ -7,7 +7,7 @@ import type { WandStorage } from "./storage.js";
  * 升级路径：老 JSON 里仍存有这些字段时，首次启动会被搬到 DB（见 migrateLegacyPreferencesToDb），
  * 然后下一次 saveConfig 写回 JSON 时它们会被剥离（见 stripPreferenceFields）。
  */
-export declare const PREFERENCE_KEYS: readonly ["defaultProvider", "defaultSessionKind", "defaultTaskWorktree", "defaultMode", "defaultCwd", "defaultModel", "defaultCodexModel", "defaultOpenCodeModel", "defaultGrokModel", "defaultQoderModel", "defaultPiModel", "defaultGeminiModel", "modelGroups", "commitCli", "commitModel", "systemAiCli", "systemAiModel", "defaultThinkingEffort", "language", "cardDefaults", "inheritEnv", "taskRetention", "userProfile"];
+export declare const PREFERENCE_KEYS: readonly ["defaultProvider", "defaultSessionKind", "defaultEngine", "defaultTaskWorktree", "defaultMode", "defaultCwd", "defaultModel", "defaultCodexModel", "defaultOpenCodeModel", "defaultGrokModel", "defaultQoderModel", "defaultPiModel", "defaultGeminiModel", "modelGroups", "commitCli", "commitModel", "systemAiCli", "systemAiModel", "defaultThinkingEffort", "language", "cardDefaults", "inheritEnv", "taskRetention", "userProfile", "localDecision"];
 export type PreferenceKey = (typeof PREFERENCE_KEYS)[number];
 /**
  * 每个 provider 的默认模型偏好字段。新增 provider 时只改这一处：

package/dist/config.js

@@ -10,6 +10,7 @@ import { isThinkingEffort } from "./structured-provider-common.js";
 import { normalizeModelGroups } from "./model-groups.js";
 import { normalizeUserProfile, parseUserProfile } from "./user-profile.js";
 import { defaultTaskRetention, normalizeTaskRetention, parseTaskRetention } from "./task-retention.js";
+import { parseLocalDecisionConfig } from "./decision-types.js";
 const DEFAULT_CONFIG_DIR = ".wand";
 const DEFAULT_CONFIG_FILE = "config.json";
 /**
@@ -22,6 +23,7 @@ const DEFAULT_CONFIG_FILE = "config.json";
 export const PREFERENCE_KEYS = [
     "defaultProvider",
     "defaultSessionKind",
+    "defaultEngine",
     "defaultTaskWorktree",
     "defaultMode",
     "defaultCwd",
@@ -43,6 +45,7 @@ export const PREFERENCE_KEYS = [
     "inheritEnv",
     "taskRetention",
     "userProfile",
+    "localDecision",
 ];
 /**
  * 每个 provider 的默认模型偏好字段。新增 provider 时只改这一处：
@@ -98,6 +101,8 @@ export const defaultConfig = () => ({
     password: "change-me",
     defaultProvider: "claude",
     defaultSessionKind: "structured",
+    // 新建会话默认走 CLI；只有用户在新建面板显式选过 Wand Agent 才会改成 sdk。
+    defaultEngine: "cli",
     defaultTaskWorktree: true,
     // 非 root 启动时才有资格用 Claude 的 permission-bypass（root 会被 Claude CLI 拒绝），
     // 所以这种环境下把默认执行模式抬到「托管」——开箱即得自动确认权限的全自主体验。
@@ -249,6 +254,7 @@ export async function loadConfigWithStorage(configPath, storage) {
     });
     // 默认任务伙伴独立于系统运维；重启保留短期偏好与用户维护的候选。
     storage.ensureDefaultSiliconEmployee(config.defaultProvider);
+    storage.ensureDecisionExpertEmployee();
     // 如果 JSON 里有偏好字段（说明是老版本配置或刚迁移），重写一次干净版本
     const hasLegacyPrefs = PREFERENCE_KEYS.some((key) => key in rawInput);
     const hasLegacySecrets = "password" in rawInput || "appSecret" in rawInput;
@@ -345,6 +351,11 @@ export function applyStoragePreferences(config, storage) {
         if (v === "pty" || v === "structured")
             config.defaultSessionKind = v;
     }
+    if (storage.hasPreference(preferenceStorageKey("defaultEngine"))) {
+        const v = storage.getPreference(preferenceStorageKey("defaultEngine"), defaults.defaultEngine ?? "cli");
+        if (v === "cli" || v === "sdk")
+            config.defaultEngine = v;
+    }
     if (storage.hasPreference(preferenceStorageKey("defaultTaskWorktree"))) {
         const v = storage.getPreference(preferenceStorageKey("defaultTaskWorktree"), defaults.defaultTaskWorktree ?? true);
         if (typeof v === "boolean")
@@ -415,6 +426,14 @@ export function applyStoragePreferences(config, storage) {
     if (storage.hasPreference(preferenceStorageKey("userProfile"))) {
         config.userProfile = normalizeUserProfile(storage.getPreference(preferenceStorageKey("userProfile"), null));
     }
+    if (storage.hasPreference(preferenceStorageKey("localDecision"))) {
+        try {
+            config.localDecision = parseLocalDecisionConfig(storage.getPreference(preferenceStorageKey("localDecision"), defaults.localDecision));
+        }
+        catch {
+            config.localDecision = { ...defaults.localDecision };
+        }
+    }
     return config;
 }
 /** Write a single preference value to DB and (in-place) update the live config object. */
@@ -429,6 +448,12 @@ export function writePreferenceToStorage(config, storage, key, value) {
         return;
     }
     switch (key) {
+        case "localDecision": {
+            const decision = parseLocalDecisionConfig(value);
+            storage.setPreference(dbKey, decision);
+            config.localDecision = decision;
+            break;
+        }
         case "modelGroups": {
             const groups = normalizeModelGroups(value);
             storage.setPreference(dbKey, groups);
@@ -449,6 +474,13 @@ export function writePreferenceToStorage(config, storage, key, value) {
             config.defaultSessionKind = value;
             break;
         }
+        case "defaultEngine": {
+            if (value !== "cli" && value !== "sdk")
+                throw new Error(`无效执行引擎: ${String(value)}`);
+            storage.setPreference(dbKey, value);
+            config.defaultEngine = value;
+            break;
+        }
         case "defaultTaskWorktree": {
             if (typeof value !== "boolean")
                 throw new Error("defaultTaskWorktree 必须是布尔值。");
@@ -772,6 +804,7 @@ function mergeWithDefaults(input) {
         taskRetention: normalizeTaskRetention(input.taskRetention),
         defaultProvider: isSessionProvider(input.defaultProvider) ? input.defaultProvider : "claude",
         defaultSessionKind: input.defaultSessionKind === "pty" ? "pty" : "structured",
+        defaultEngine: input.defaultEngine === "sdk" ? "sdk" : "cli",
         defaultTaskWorktree: typeof input.defaultTaskWorktree === "boolean" ? input.defaultTaskWorktree : defaults.defaultTaskWorktree,
         ...providerModelOverrides(input, defaults),
         modelGroups: normalizeModelGroups(input.modelGroups ?? []),

package/dist/core-runner.js

@@ -344,7 +344,7 @@ export class CoreRunner {
         const session = context.session;
         if (session.piSettings?.resources || session.piSettings?.codemodeOverride
             || session.piSettings?.autoResources || session.piSettings?.lockedSkills?.length) {
-            return "当前 SDK 候选尚不支持会话级 Skills / MCP 选择，没有改用全局资源。";
+            return "Wand Agent 尚不支持会话级 Skills / MCP 选择，没有改用全局资源。";
         }
         const injectedStreamFn = this.options.streamFn;
         // 测试环境必须显式注入模型缝隙：避免单测无意中发出真实付费请求（或挂在网络上）。

package/dist/daemon-maintenance-state.d.ts

@@ -0,0 +1,6 @@
+/** Public projection: no daemon credentials, paths, process IDs or raw failures. */
+export interface DaemonMaintenanceStatus {
+    pending: boolean;
+    phase: "idle" | "waiting" | "updating" | "retrying";
+}
+export declare function daemonMaintenanceMessage(status: DaemonMaintenanceStatus): string;

package/dist/daemon-maintenance-state.js

@@ -0,0 +1,9 @@
+export function daemonMaintenanceMessage(status) {
+    if (!status.pending)
+        return "";
+    if (status.phase === "updating")
+        return "底层组件正在自动更新。无需操作。";
+    if (status.phase === "retrying")
+        return "底层组件更新尚未完成，系统会自动重试。无需操作。";
+    return "底层组件更新正在等待执行与队列结束，届时自动更新。无需操作。";
+}

package/dist/daemon-maintenance-targets.d.ts

@@ -0,0 +1,20 @@
+import type { DaemonInspection, DaemonMaintenanceTarget } from "./daemon-maintenance.js";
+import { type UpgradeAwareTerminalHost } from "./render-host.js";
+import type { RenderStructuredClient } from "./render-structured-client.js";
+interface OwnerSnapshot extends DaemonInspection {
+    pid: number;
+    atomicShutdown?: boolean;
+}
+/** Unknown/malformed inventories must not be interpreted as zero live sessions. */
+export declare function countRunningDaemonEntries(value: unknown): number;
+/** Persist the once-only shutdown intent: a second Render drain escalates to kill. */
+export declare function persistentDaemonTarget(options: {
+    name: string;
+    checkpointPath: string;
+    snapshot(includeInventory?: boolean): Promise<OwnerSnapshot>;
+    shutdown(snapshot: OwnerSnapshot): Promise<boolean | void>;
+    ensure(): Promise<void>;
+    reconnect(): Promise<void>;
+}): DaemonMaintenanceTarget;
+export declare function createDaemonMaintenanceTargets(configPath: string, pty: UpgradeAwareTerminalHost, structured: RenderStructuredClient | null, configuredRenderBinary?: string): Promise<DaemonMaintenanceTarget[]>;
+export {};

package/dist/daemon-maintenance-targets.js

@@ -0,0 +1,183 @@
+import { createHash } from "node:crypto";
+import { readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { setTimeout as delay } from "node:timers/promises";
+import { readRenderBinaryVersion, resolveRenderBinaryPath } from "./render-binary.js";
+import { RenderDaemonClient } from "./render-daemon-client.js";
+import { createRenderTerminalHost, shouldUpgradeRenderDaemon } from "./render-host.js";
+import { renderPaths } from "./render-protocol.js";
+import { resolveStructuredRenderBinary, startStructuredRenderHost } from "./render-structured-host.js";
+import { structuredRenderPaths } from "./render-structured-protocol.js";
+import { createTerminalHost } from "./terminal-daemon-client.js";
+import { TERMINAL_DAEMON_BUILD_ID } from "./terminal-daemon-build.js";
+import { terminalDaemonPaths } from "./terminal-daemon-protocol.js";
+function live(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ESRCH")
+            return false;
+        throw error; // permission/unknown is never evidence of an idle or dead owner
+    }
+}
+function readCheckpoint(file) {
+    try {
+        const value = JSON.parse(readFileSync(file, "utf8"));
+        if (!Number.isSafeInteger(value.pid) || value.pid <= 0 || typeof value.identity !== "string") {
+            throw new Error("Invalid daemon maintenance checkpoint");
+        }
+        return value;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function identity(pid, tokenPath) {
+    if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0)
+        throw new Error("Daemon did not report an authenticated PID");
+    const token = readFileSync(tokenPath, "utf8").trim();
+    if (!token)
+        throw new Error("Daemon credentials are unavailable");
+    return { pid, identity: `${pid}:${createHash("sha256").update(token).digest("hex")}` };
+}
+/** Unknown/malformed inventories must not be interpreted as zero live sessions. */
+export function countRunningDaemonEntries(value) {
+    if (!Array.isArray(value))
+        throw new Error("Daemon inventory is unavailable");
+    let running = 0;
+    for (const entry of value) {
+        if (!entry || (entry.status !== "running" && entry.status !== "exited"))
+            throw new Error("Daemon inventory has unknown state");
+        if (entry.status === "running")
+            running++;
+    }
+    return running;
+}
+/** Persist the once-only shutdown intent: a second Render drain escalates to kill. */
+export function persistentDaemonTarget(options) {
+    const recover = async () => {
+        const checkpoint = readCheckpoint(options.checkpointPath);
+        if (checkpoint && !live(checkpoint.pid)) {
+            await options.ensure();
+            await options.reconnect();
+        }
+    };
+    return {
+        name: options.name,
+        async inspect(includeInventory = true) {
+            await recover();
+            const snapshot = await options.snapshot(includeInventory);
+            if (!snapshot.pending && readCheckpoint(options.checkpointPath))
+                unlinkSync(options.checkpointPath);
+            return snapshot;
+        },
+        async restart(expected) {
+            const current = await options.snapshot();
+            if (current.identity !== expected.identity || !current.pending || current.running !== 0) {
+                throw new Error(`${options.name} changed while preparing its update`);
+            }
+            const checkpoint = readCheckpoint(options.checkpointPath);
+            if (checkpoint?.identity !== current.identity) {
+                const temporary = `${options.checkpointPath}.${process.pid}.tmp`;
+                writeFileSync(temporary, JSON.stringify({ identity: current.identity, pid: current.pid }), { mode: 0o600 });
+                renameSync(temporary, options.checkpointPath);
+                if (await options.shutdown(current) === false) {
+                    unlinkSync(options.checkpointPath); // explicit refusal: no shutdown was accepted
+                    throw new Error(`${options.name} became busy; leaving it alive`);
+                }
+            }
+            const deadline = Date.now() + 5_000;
+            while (live(current.pid)) {
+                if (Date.now() >= deadline)
+                    throw new Error(`${options.name} is still draining; leaving it alive`);
+                await delay(50);
+            }
+            await options.ensure();
+            // Existing manager/host references remain valid across token rotation.
+            await options.reconnect();
+            const replacement = await options.snapshot();
+            if (replacement.identity === current.identity || replacement.pending)
+                throw new Error(`${options.name} replacement is not current`);
+            unlinkSync(options.checkpointPath);
+        },
+    };
+}
+export async function createDaemonMaintenanceTargets(configPath, pty, structured, configuredRenderBinary) {
+    const targets = [];
+    const render = pty.renderHost;
+    if (render instanceof RenderDaemonClient) {
+        const binary = configuredRenderBinary?.trim() || resolveRenderBinaryPath(configPath);
+        const version = binary ? await readRenderBinaryVersion(binary) : null;
+        const paths = renderPaths(configPath);
+        targets.push(persistentDaemonTarget({
+            name: "Render", checkpointPath: `${paths.tokenPath}.update.json`,
+            async snapshot(includeInventory = true) {
+                const { hello, sessions } = await render.maintenanceSnapshot(includeInventory);
+                return { ...identity(hello.pid, paths.tokenPath),
+                    pending: shouldUpgradeRenderDaemon(hello.version, version, 0), running: includeInventory ? countRunningDaemonEntries(sessions) : null };
+            },
+            shutdown: () => render.requestShutdownDrain(),
+            async ensure() { const client = await createRenderTerminalHost(configPath, { binaryPath: binary ?? undefined }); client.disconnect(); },
+            reconnect: () => render.connect(),
+        }));
+    }
+    const legacy = pty.legacyHost;
+    if (legacy) {
+        const paths = terminalDaemonPaths(configPath);
+        targets.push(persistentDaemonTarget({
+            name: "terminald", checkpointPath: `${paths.tokenPath}.update.json`,
+            async snapshot(includeInventory = true) {
+                const hello = await legacy.request("hello");
+                let running = null;
+                if (includeInventory) {
+                    const [sessions, runs] = await Promise.all([legacy.request("list"), legacy.request("structuredList")]);
+                    running = countRunningDaemonEntries(sessions) + countRunningDaemonEntries(runs);
+                }
+                return { ...identity(hello.pid, paths.tokenPath), pending: hello.buildId !== TERMINAL_DAEMON_BUILD_ID,
+                    running, atomicShutdown: hello.shutdownIfIdle === true };
+            },
+            async shutdown(snapshot) {
+                if (snapshot.atomicShutdown) {
+                    const result = await legacy.request("shutdownIfIdle");
+                    if (result?.accepted === false)
+                        return false;
+                    if (result?.accepted !== true)
+                        throw new Error("terminald shutdown result is unknown");
+                }
+                else {
+                    // One-time migration for pre-capability terminald. Server is the sole
+                    // execution admission owner; both RPC inventories were checked under
+                    // its shared barrier. Never signal a guessed pid or escalate to KILL.
+                    const hello = await legacy.request("hello");
+                    if (identity(hello.pid, paths.tokenPath).identity !== snapshot.identity)
+                        throw new Error("terminald owner changed");
+                    process.kill(snapshot.pid, "SIGTERM");
+                }
+            },
+            async ensure() { const client = await createTerminalHost(configPath); client.disconnect(); },
+            reconnect: () => legacy.connect(),
+        }));
+    }
+    if (structured) {
+        const binary = resolveStructuredRenderBinary(configPath);
+        // v1 and v2 are separately released; never read the sibling PTY sidecar.
+        const version = binary ? await readRenderBinaryVersion(binary, `${binary}.version`) : null;
+        const paths = structuredRenderPaths(configPath);
+        targets.push(persistentDaemonTarget({
+            name: "Structured Render", checkpointPath: `${paths.tokenPath}.update.json`,
+            async snapshot(includeInventory = true) {
+                const hello = await structured.request("hello");
+                const result = includeInventory ? await structured.request("list") : null;
+                return { ...identity(hello.pid, paths.tokenPath), pending: shouldUpgradeRenderDaemon(hello.version, version, 0),
+                    running: result ? countRunningDaemonEntries(result.runs) : null };
+            },
+            async shutdown() { await structured.request("shutdown", { mode: "drain" }); },
+            async ensure() { const client = await startStructuredRenderHost(configPath); client.disconnect(); },
+            reconnect: () => structured.connect(),
+        }));
+    }
+    return targets;
+}

package/dist/daemon-maintenance.d.ts

@@ -0,0 +1,53 @@
+import type { StructuredExecHost } from "./structured-exec-host.js";
+import type { TerminalHost } from "./terminal-host.js";
+import type { DaemonMaintenanceStatus } from "./daemon-maintenance-state.js";
+/** One admission barrier for PTY and structured starts, not for ongoing input/output. */
+export declare class DaemonAdmission {
+    private barrier;
+    private active;
+    private settled;
+    run<T>(operation: () => Promise<T>): Promise<T>;
+    exclusive<T>(operation: () => Promise<T>): Promise<T>;
+    terminal(host: TerminalHost): TerminalHost;
+    structured(host: StructuredExecHost): StructuredExecHost;
+}
+export interface DaemonInspection {
+    /** Authenticated incarnation, never a pid-file guess or a cached UI count. */
+    identity: string;
+    pending: boolean;
+    /** null = inventory deliberately not fetched while manager-owned work is busy. */
+    running: number | null;
+}
+export interface DaemonMaintenanceTarget {
+    name: string;
+    inspect(includeInventory?: boolean): Promise<DaemonInspection>;
+    /** Must recheck identity and use graceful shutdown, never a force-kill. */
+    restart(expected: DaemonInspection): Promise<void>;
+}
+export interface DaemonMaintenanceOptions {
+    targets: DaemonMaintenanceTarget[];
+    admission: DaemonAdmission;
+    /** Includes Core, starting runs, final checkpoints and queued input. */
+    busy(): boolean;
+    beginCoreDrain(): () => void;
+    available(): boolean;
+    log(error: unknown): void;
+    now?: () => number;
+    quietMs?: number;
+}
+/** Lifecycle-owned worker. GET only projects its state; it never performs maintenance. */
+export declare class DaemonMaintenance {
+    private readonly options;
+    private state;
+    private timer;
+    private flight;
+    private stopped;
+    private idleSince;
+    private failures;
+    constructor(options: DaemonMaintenanceOptions);
+    status(): DaemonMaintenanceStatus;
+    start(): void;
+    check(): Promise<void>;
+    stop(): Promise<void>;
+    private inspectAndUpdate;
+}