@xrkseek/harness 0.4.0 → 0.4.2

package/node_modules/@xrkseek/server-host/dist/index.js

@@ -0,0 +1,1573 @@
+import { createLocalAttachmentStore, resolveLocalAttachmentsRoot } from "@xrkseek/attachment-local";
+import { createMemorySessionStore, createPersistentSessionStore, createSessionDrainHub, newSession, readSessionEvents, SessionsDirInUseError, } from "@xrkseek/core-session";
+import { createProviderRegistry } from "@xrkseek/llm-registry";
+import { loadPolicyRulesetFile } from "@xrkseek/policy";
+import { flattenText, isHumanUserMessageSource } from "@xrkseek/protocol";
+import { consolidateCuratedMemoryPhase1, createCuratedMemoryStore, } from "@xrkseek/exec-memory";
+import { resolveSecretStore } from "@xrkseek/secrets";
+import { hostSettingsPath, defaultSpillDir, resolveXrkHome } from "@xrkseek/server-config";
+import { installOutboundHttpProxy } from "./http-proxy.js";
+import { mountInvariantsFailFast } from "./invariants-fail-fast.js";
+import { watchPolicyFile } from "./policy-file-watch.js";
+import { applyXrkProductBootPolicy, chainPublicHandlers, ensureDshCompatHostPlugin, createLiveHostPluginsPublicHandler, createHttpServer, createXrkPluginPublicHandler, createSidebarPublicHandler, prewarmDshCompatAdapters, shutdownDshCompatServices, applyHostPackageByName, stopHostPackageFiber, listHostAppliedPackages, invokeDshCompatRpc, attachDshCompatUpgrades, DSH_SETTINGS_NAMESPACES, DSH_SETTINGS_DEFAULTS, runPluginMutate, ensureXrkPlatformClientBootEntries, injectBootIntoHtml, injectMobileAccessShellIntoHtml, loadBootManifestFromWebDist, mergeWebBootManifests, resolveWebBootManifest, createXrkWalletPort, createMobileAccessGateChecker, createMobileAccessGateHandler, loadSidebarPrefs, } from "@xrkseek/server-http";
+import { attachFaceUpgrades, bindSubagentTools, bindSessionQueryTools, createFaceRuntime, effectiveHostApiKey, isLoopbackAddress, peekSettingsYamlSection, publishRemoteEvent, createSessionRoutingLlm, liveRouteAllowsImageInput, resolveSessionCwd, canonicalAgentPresetId, resolveAgentPresetProfile, DEFAULT_MAX_DEPTH, DEFAULT_MAX_ACTIVE_CHILDREN, tryHandleFaceHttp, isPluginSoftDisabledAt, readDisabledPluginIdsAt, readManagedPackageIndexAt, reconcileManagedProcessPlugins, snapshotSessionWorkspace, } from "@xrkseek/server-face";
+import { createPluginLoader, composeHostPolicyEngine, wireCompositionChannels, wireCompositionLlm, collectChannelPluginRegistrations, } from "@xrkseek/server-loader";
+import { existsSync } from "node:fs";
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { createHostAgentCache } from "./agent-cache.js";
+import { createHostCron } from "@xrkseek/server-cron";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { wireDrainStatus, publishDrainIdle } from "./drain-status.js";
+import { attachSidebarPtyUpgrades } from "./sidebar-pty.js";
+import { AgentOpenRegistry } from "./sidebar-agent-opens.js";
+import { AgentPtyRegistry } from "./sidebar-agent-pty.js";
+import { createSshDirectoryBackend } from "./ssh-directory-backend.js";
+import { bindSidebarAgentTools } from "./sidebar-agent-tools.js";
+import { createUsageStatsBridgeFromFace } from "./usage-stats-bridge.js";
+import { createCostMeterUsageBridge } from "./cost-meter-bridge.js";
+import { createHarnessConnectorBridgeFromFace } from "./harness-connector-bridge.js";
+import { createAutoReviewBridgeFromHost } from "./auto-review-bridge.js";
+import { createWalletFaceBridgeFromFace } from "./wallet-bridge.js";
+import { createSidebarFaceBridgeFromFace } from "./sidebar-face-bridge.js";
+import { mcpDraftsToSpecs, parseMcpServersEnv, readMcpAllowFromHostSettings, readMcpServersFromHostSettings, reconcileMcpToolPlugins, } from "./mcp-wire.js";
+import { createMcpDeferredDispose } from "./mcp-deferred-dispose.js";
+import { createStandingToolRegistry } from "./standing-tools.js";
+import { createDefaultPtyAccess } from "@xrkseek/exec-pty";
+import { createLocalShell } from "@xrkseek/exec-shell";
+import { createBrowserRuntimeRegistry } from "@xrkseek/exec-web";
+import { createLocalSubprocess } from "@xrkseek/exec-subprocess";
+import { createSshExecutionWorld, resolveSshConfig, } from "@xrkseek/exec-ssh";
+/** True while an unattended cron agent turn is running — skip cron tools to avoid recursion. */
+const cronAgentDepth = new AsyncLocalStorage();
+export { createHostAgentCache, HOST_PLUGINS_KEY } from "./agent-cache.js";
+export { createStandingToolRegistry } from "./standing-tools.js";
+export { loadMcpToolPlugins, mcpDraftsToSpecs, mcpFingerprint, parseMcpServersEnv, readMcpAllowFromHostSettings, readMcpServersFromHostSettings, reconcileMcpToolPlugins, resetLastGoodHostMcpWireCaches, } from "./mcp-wire.js";
+function logMcpReconcile(log, label, result) {
+    if (!log)
+        return;
+    const parkBit = result.parked.length > 0 ? ` park=${result.parked.length}` : "";
+    log.info(`mcp ${label}: +${result.added.length} -${result.removed.length} keep=${result.kept.length}${parkBit}`);
+    for (const id of result.added)
+        log.info(`mcp connected ${id}`);
+    for (const id of result.removed)
+        log.info(`mcp removed ${id}`);
+    if (result.parked.length > 0) {
+        log.info(`mcp parked ${result.parked.join(", ")} (enable Allow connect in Settings > Plugins > MCP)`);
+    }
+    for (const f of result.failures) {
+        log.warn(`mcp connect failed ${f.serverName}: ${f.message}`);
+    }
+}
+async function resolveWebPluginOverlay(pluginsDir) {
+    if (!pluginsDir)
+        return undefined;
+    const overlay = path.resolve(pluginsDir, "web");
+    try {
+        await access(overlay);
+        return overlay;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Env/config MCP list (empty → Face host-settings.json is the source). */
+function configuredMcpSpecs(config) {
+    const fromConfig = config.runtime.mcpServers;
+    if (fromConfig && fromConfig.length > 0) {
+        return mcpDraftsToSpecs(fromConfig);
+    }
+    return parseMcpServersEnv(process.env.XRK_MCP_SERVERS);
+}
+/** Env/config win; empty → Face dump `~/.xrk/host-settings.json`. */
+function resolveMcpSpecs(config) {
+    const configured = configuredMcpSpecs(config);
+    if (configured.length > 0)
+        return configured;
+    return readMcpServersFromHostSettings(hostSettingsPath());
+}
+/**
+ * Connect allow: env `XRK_MCP_ALLOW` (CI/headless) wins, else Face
+ * `mcp.allowConnect` in host-settings.json (Web Settings).
+ */
+function resolveMcpAllowConnect(config, faceAllow) {
+    if (config.runtime.mcpAllowConnect)
+        return true;
+    if (faceAllow === true)
+        return true;
+    if (faceAllow === false)
+        return false;
+    return readMcpAllowFromHostSettings(hostSettingsPath());
+}
+export function createHostManager() {
+    const instances = new Map();
+    let seq = 0;
+    return {
+        async spawn(config, factory, options) {
+            const log = options?.logger;
+            if (installOutboundHttpProxy()) {
+                log?.info("outbound HTTP proxy installed (HTTP(S)_PROXY / ALL_PROXY / NO_PROXY)");
+            }
+            const id = `host_${++seq}`;
+            const sessionsDir = config.runtime.sessionsDir?.trim();
+            let store;
+            try {
+                store = sessionsDir
+                    ? createPersistentSessionStore(sessionsDir)
+                    : createMemorySessionStore();
+            }
+            catch (err) {
+                if (err instanceof SessionsDirInUseError) {
+                    log?.error(err.message);
+                    throw err;
+                }
+                throw err;
+            }
+            let invariantsRegistry;
+            if (config.runtime.invariantsFailFast) {
+                const mounted = mountInvariantsFailFast(store);
+                store = mounted.store;
+                invariantsRegistry = mounted.registry;
+                log?.info("runtime invariants fail-fast enabled (XRK_INVARIANTS_FAIL_FAST)");
+            }
+            const loader = createPluginLoader();
+            const registry = createProviderRegistry();
+            // Face / mutate / soft-disable always share this absolute path. Config may
+            // omit pluginsDir until ~/.xrk/plugins exists; still reconcile when the
+            // directory is present so Settings install/disable works in-process.
+            const configuredPluginsDir = config.runtime.pluginsDir?.trim();
+            const resolvedPluginsDir = configuredPluginsDir
+                ? path.resolve(configuredPluginsDir)
+                : path.join(resolveXrkHome(), "plugins");
+            const managedPluginsRootReady = () => existsSync(resolvedPluginsDir);
+            let loadedPluginIds = [];
+            if (managedPluginsRootReady()) {
+                // Single path with Settings soft-disable: discover+load enabled,
+                // skip soft-disabled (never mcp:*). Optional load failures warn;
+                // required failures throw (abort spawn).
+                const bootPlugins = await reconcileManagedProcessPlugins(loader, resolvedPluginsDir);
+                loadedPluginIds = [...bootPlugins.ids];
+                for (const failure of bootPlugins.failures) {
+                    log?.warn(`plugin load failed (${failure.id}): ${failure.message}`);
+                }
+            }
+            // File rules first, then kind:policy plugins. Delegate so a later
+            // plugin refresh / policy-file watch rebuilds without swapping captures.
+            let filePolicy = config.runtime.policyFile
+                ? await loadPolicyRulesetFile(config.runtime.policyFile)
+                : undefined;
+            let policyEngine = composeHostPolicyEngine({
+                ...(filePolicy !== undefined ? { file: filePolicy } : {}),
+                plugins: loader.list(),
+            });
+            const policy = {
+                evaluate: (subject) => policyEngine.evaluate(subject),
+            };
+            const rebuildPolicyEngine = () => {
+                policyEngine = composeHostPolicyEngine({
+                    ...(filePolicy !== undefined ? { file: filePolicy } : {}),
+                    plugins: loader.list(),
+                });
+            };
+            const policyFileWatch = config.runtime.policyFile
+                ? watchPolicyFile({
+                    filePath: config.runtime.policyFile,
+                    onReload: (next) => {
+                        filePolicy = next;
+                        rebuildPolicyEngine();
+                        log?.info(`policy reloaded (${config.runtime.policyFile})`);
+                    },
+                    onError: (err) => {
+                        const msg = err instanceof Error ? err.message : String(err);
+                        log?.warn(`policy reload skipped: ${msg}`);
+                    },
+                })
+                : undefined;
+            const hostPublic = {
+                host: config.runtime.host,
+                port: config.runtime.port,
+                workspaceRoot: config.runtime.workspaceRoot,
+                preset: config.runtime.preset,
+                corsOrigin: String(config.runtime.corsOrigin),
+                rateLimitPerMinute: config.runtime.rateLimitPerMinute,
+                // Always absolute so Face inventory / soft-disable match mutate + overlay.
+                pluginsDir: resolvedPluginsDir,
+                webDistConfigured: Boolean(config.runtime.webDist),
+                cordisHostApplied: [],
+                cordisHostPackages: [],
+                processChannels: [],
+            };
+            const mcpSpecs = resolveMcpSpecs(config);
+            const mcpFileSourced = configuredMcpSpecs(config).length === 0;
+            let mcpAllowConnect = resolveMcpAllowConnect(config);
+            if (mcpSpecs.length > 0) {
+                log?.info(`mcp desired ${mcpSpecs.length} (source=${mcpFileSourced ? "host-settings" : "env/config"}; allow=${mcpAllowConnect ? "on" : "off"})`);
+            }
+            let invalidateAgents = async () => { };
+            /** Sessions skipped mid-turn; invalidate once drain goes idle. */
+            const pendingAgentInvalidate = new Set();
+            const drainActiveBox = {
+                isActive: () => false,
+                activeIds: () => [],
+            };
+            /** Soft-detach MCP while drains hold mid-turn tool handles. */
+            const mcpDeferred = createMcpDeferredDispose({
+                detach: (id) => loader.detach(id),
+                unregister: (id) => loader.unregister(id),
+                isBusy: () => drainActiveBox.activeIds().length > 0 ||
+                    pendingAgentInvalidate.size > 0,
+            });
+            const mcpUnregister = async (pluginId) => {
+                await mcpDeferred.remove(pluginId);
+                loadedPluginIds = loadedPluginIds.filter((x) => x !== pluginId);
+            };
+            /** Mutable Face inventory — Host splices after MCP reconcile / health. */
+            const facePlugins = [];
+            const refreshFacePlugins = () => {
+                facePlugins.splice(0, facePlugins.length, ...loader.list());
+                wireCompositionLlm(registry, { plugins: loader.list() });
+                wireCompositionChannels({ plugins: loader.list() });
+                rebuildPolicyEngine();
+                hostPublic.processChannels = collectChannelPluginRegistrations(loader.list()).map((row) => ({
+                    pluginId: row.pluginId,
+                    channelId: row.channelId,
+                    ...(row.displayName !== undefined
+                        ? { displayName: row.displayName }
+                        : {}),
+                }));
+            };
+            let notifyMcpOverlay = () => {
+                refreshFacePlugins();
+            };
+            const attachments = createLocalAttachmentStore({
+                xrkHome: resolveXrkHome(),
+            });
+            const attachmentsRoot = resolveLocalAttachmentsRoot(resolveXrkHome());
+            /** Filled after Face boot — MCP image gate reads live Registry modalities. */
+            const faceForModality = {};
+            const mcpImageAdmission = {
+                attachments,
+                allowsImageInput: () => faceForModality.current
+                    ? liveRouteAllowsImageInput(faceForModality.current)
+                    : false,
+            };
+            const mcpHooks = {
+                onToolsChanged: () => invalidateAgents(),
+                onHealthChanged: () => {
+                    notifyMcpOverlay();
+                },
+            };
+            if (mcpSpecs.length > 0) {
+                const boot = await reconcileMcpToolPlugins({
+                    desired: mcpSpecs,
+                    list: () => loader.list(),
+                    register: (plugin) => {
+                        loader.register(plugin);
+                        if (!loadedPluginIds.includes(plugin.id)) {
+                            loadedPluginIds = [...loadedPluginIds, plugin.id];
+                        }
+                    },
+                    unregister: mcpUnregister,
+                    retained: () => mcpDeferred.retained(),
+                    policy,
+                    allowConnect: mcpAllowConnect,
+                    workspaceRoot: config.runtime.workspaceRoot,
+                    imageAdmission: mcpImageAdmission,
+                    ...mcpHooks,
+                });
+                logMcpReconcile(log, "boot", boot);
+            }
+            refreshFacePlugins();
+            const agentCache = createHostAgentCache(loader.list(), { hostId: id });
+            // MCP remount / settings_mutate runs inside an active drain. Aborting that
+            // agent mid-tool yields "Error: tool call aborted". Skip active sessions
+            // and invalidate them after the turn settles. Soft-detach (not dispose)
+            // MCP clients until those drains go idle — see mcpDeferred.
+            invalidateAgents = async () => {
+                await agentCache.invalidateAll({
+                    skip: (sessionId) => {
+                        if (!drainActiveBox.isActive(sessionId))
+                            return false;
+                        pendingAgentInvalidate.add(sessionId);
+                        return true;
+                    },
+                });
+                await mcpDeferred.flush();
+            };
+            let mcpSyncTail = Promise.resolve();
+            const lastDrainResult = new Map();
+            // Local Host + remote cwd: swap fs/shell (Hermes/DSH provider pattern).
+            // Env `XRK_SSH_HOST` CI-bypasses Face; else peek settings.yaml before Face
+            // (SSH world must own workspaceRoot before createFaceRuntime).
+            let sshWorld;
+            /** Local Host cwd before SSH workspace swap (browse/settings anchor). */
+            let localHostRoot;
+            try {
+                const sshProduct = peekSettingsYamlSection(resolveXrkHome(), "ssh-remote");
+                const sshConfig = resolveSshConfig(process.env, sshProduct);
+                if (sshConfig) {
+                    localHostRoot = config.runtime.workspaceRoot;
+                    sshWorld = createSshExecutionWorld({ config: sshConfig });
+                    // Tool coordinates are the remote workspace; Face session cwd follows.
+                    config.runtime.workspaceRoot =
+                        sshWorld.workspaceRoot;
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                throw new Error(`SSH remote workspace: ${message}`, { cause: err });
+            }
+            const sharedPty = !sshWorld &&
+                (config.runtime.preset === "harness" ||
+                    config.runtime.preset === "server")
+                ? createDefaultPtyAccess({
+                    workspaceRoot: config.runtime.workspaceRoot,
+                })
+                : undefined;
+            const sharedShell = config.runtime.preset === "harness" || config.runtime.preset === "server"
+                ? createLocalShell({
+                    subprocess: sshWorld
+                        ? sshWorld.subprocess
+                        : createLocalSubprocess(),
+                    defaultCwd: config.runtime.workspaceRoot,
+                })
+                : undefined;
+            /** Session-keyed browser pages — survives agent invalidate (Hermes task_id map). */
+            const sharedBrowser = config.runtime.preset === "harness" || config.runtime.preset === "server"
+                ? createBrowserRuntimeRegistry()
+                : undefined;
+            const ensureSession = (sid) => newSession(store, sid).id;
+            const faceBox = {};
+            /** Session-end Phase1: fold leftover human notes into MEMORY.md (disk only). */
+            const consolidateCuratedMemoryForSession = (sessionId) => {
+                try {
+                    const rt = faceBox.runtime;
+                    const memEnvRaw = String(process.env.XRK_CURATED_MEMORY ?? "").trim();
+                    let enabled = memEnvRaw !== "" ? memEnvRaw !== "0" : true;
+                    if (memEnvRaw === "" && rt) {
+                        const memNs = rt.settingsNamespaces.view("curated-memory")
+                            .value;
+                        enabled = memNs.enabled !== false;
+                    }
+                    if (!enabled)
+                        return;
+                    const userTexts = [];
+                    for (const event of readSessionEvents(store, sessionId)) {
+                        if (event.type !== "user/message")
+                            continue;
+                        if (!isHumanUserMessageSource(event.source))
+                            continue;
+                        const text = flattenText(event.content).trim();
+                        if (text)
+                            userTexts.push(text);
+                    }
+                    if (userTexts.length === 0)
+                        return;
+                    void consolidateCuratedMemoryPhase1(createCuratedMemoryStore(), {
+                        userTexts,
+                    });
+                }
+                catch {
+                    /* best-effort — Host stop / archive must continue */
+                }
+            };
+            const llmResolverBox = {};
+            const pluginSettingsBox = {};
+            const sessionCwdBox = {};
+            const sessionPresetBox = {};
+            const hostStatusBox = {};
+            const lineage = {
+                parentOf: () => undefined,
+            };
+            // Sidebar agent-opens / agent-terminals — Host registries (not plugin host.mjs).
+            const agentOpenRegistry = new AgentOpenRegistry();
+            const agentPtyRegistry = new AgentPtyRegistry();
+            const cronBox = {};
+            const resolveAgent = async (sessionId) => {
+                // Cache composition binding only — never treat AgentHandle as transcript source (ADR-0003).
+                const parentSessionId = lineage.parentOf(sessionId);
+                const sessionRoot = sessionCwdBox.get?.(sessionId) ?? config.runtime.workspaceRoot;
+                const agentPreset = sessionPresetBox.get?.(sessionId);
+                const wsId = faceRuntime.workspaces.workspaceIdOf(sessionId);
+                const wsRow = wsId ? faceRuntime.workspaces.get(wsId) : undefined;
+                return agentCache.resolve(sessionId, async () => {
+                    const pluginSettings = pluginSettingsBox.read?.() ?? {};
+                    const agent = await factory({
+                        sessionId,
+                        store,
+                        workspaceRoot: sessionRoot,
+                        ...(wsRow?.title ? { workspaceDisplayTitle: wsRow.title } : {}),
+                        plugins: loader.list(),
+                        attachments,
+                        // Spill subtree + attachments only — never resolveXrkHome().
+                        hostReadableRoots: [
+                            attachmentsRoot,
+                            defaultSpillDir(),
+                        ],
+                        routeAllowsImage: () => faceForModality.current
+                            ? liveRouteAllowsImageInput(faceForModality.current, sessionId)
+                            : false,
+                        ...(agentPreset ? { agentPreset } : {}),
+                        resolveImage: async (attachmentId) => {
+                            const stored = await attachments.readImage(attachmentId);
+                            return {
+                                mediaType: stored.ref.mediaType,
+                                data: stored.data,
+                                ref: stored.ref,
+                            };
+                        },
+                        resolveFilePath: (ref) => attachments.fileHostPath?.(ref),
+                        ...(sharedPty ? { ptyService: sharedPty.service } : {}),
+                        ...(sharedShell ? { shellJobs: sharedShell } : {}),
+                        ...(sharedBrowser ? { browserRuntime: sharedBrowser } : {}),
+                        ...(cronBox.scheduler && !cronAgentDepth.getStore()
+                            ? { cronScheduler: cronBox.scheduler }
+                            : {}),
+                        ...(sshWorld
+                            ? {
+                                fs: sshWorld.fs,
+                                remoteExecution: true,
+                                codeRuntime: sshWorld.codeRuntime,
+                            }
+                            : {}),
+                        ...(llmResolverBox.resolve
+                            ? { resolveLlm: llmResolverBox.resolve }
+                            : {}),
+                        ...(pluginSettings.maxParallelToolCalls !== undefined
+                            ? { maxParallelToolCalls: pluginSettings.maxParallelToolCalls }
+                            : {}),
+                        ...(pluginSettings.maxSteps !== undefined
+                            ? { maxSteps: pluginSettings.maxSteps }
+                            : {}),
+                        ...(pluginSettings.toolOrder !== undefined
+                            ? { toolOrder: pluginSettings.toolOrder }
+                            : {}),
+                        ...(pluginSettings.toolSettle !== undefined
+                            ? { toolSettle: pluginSettings.toolSettle }
+                            : {}),
+                        ...(pluginSettings.llmRetryMaxRetries !== undefined
+                            ? { llmRetryMaxRetries: pluginSettings.llmRetryMaxRetries }
+                            : {}),
+                        ...(pluginSettings.bashLimits
+                            ? { bashLimits: pluginSettings.bashLimits }
+                            : {}),
+                        ...(pluginSettings.compaction
+                            ? { compaction: pluginSettings.compaction }
+                            : {}),
+                        ...(pluginSettings.toolResultMaxInlineBytes !== undefined
+                            ? {
+                                toolResultMaxInlineBytes: pluginSettings.toolResultMaxInlineBytes,
+                            }
+                            : {}),
+                        ...(pluginSettings.locale
+                            ? { locale: pluginSettings.locale }
+                            : {}),
+                        ...(pluginSettings.webSearch
+                            ? { webSearch: pluginSettings.webSearch }
+                            : {}),
+                        ...(pluginSettings.workspaceInject
+                            ? { workspaceInject: pluginSettings.workspaceInject }
+                            : {}),
+                        ...(pluginSettings.sessionTelemetry
+                            ? { sessionTelemetry: pluginSettings.sessionTelemetry }
+                            : {}),
+                        ...(pluginSettings.sandbox
+                            ? { sandbox: pluginSettings.sandbox }
+                            : {}),
+                        ...(pluginSettings.computerUseProduct
+                            ? { computerUseProduct: pluginSettings.computerUseProduct }
+                            : {}),
+                        ...(pluginSettings.computerUseEnv
+                            ? { computerUseEnv: pluginSettings.computerUseEnv }
+                            : {}),
+                        ...(pluginSettings.browserProduct
+                            ? { browserProduct: pluginSettings.browserProduct }
+                            : {}),
+                        ...(pluginSettings.voiceProduct
+                            ? { voiceProduct: pluginSettings.voiceProduct }
+                            : {}),
+                        ...(pluginSettings.voiceEnv
+                            ? { voiceEnv: pluginSettings.voiceEnv }
+                            : {}),
+                        ...(pluginSettings.imageGenProduct
+                            ? { imageGenProduct: pluginSettings.imageGenProduct }
+                            : {}),
+                        ...(pluginSettings.imageGenEnv
+                            ? { imageGenEnv: pluginSettings.imageGenEnv }
+                            : {}),
+                        ...(pluginSettings.videoGenProduct
+                            ? { videoGenProduct: pluginSettings.videoGenProduct }
+                            : {}),
+                        ...(pluginSettings.videoGenEnv
+                            ? { videoGenEnv: pluginSettings.videoGenEnv }
+                            : {}),
+                        ...(pluginSettings.curatedMemory === false
+                            ? { curatedMemory: false }
+                            : {}),
+                    });
+                    if (faceBox.approvals) {
+                        agent.setApprovalHandler(faceBox.approvals.handlerFor(sessionId));
+                    }
+                    // ask_user / exit_plan_mode: Face resolveAgent rebinds once.
+                    if (agent.tools && faceBox.runtime) {
+                        const profile = resolveAgentPresetProfile(agentPreset ?? config.runtime.preset, config.runtime.preset);
+                        if (profile.subagents.mode === "on") {
+                            const faceDepth = pluginSettings.maxSubagentDepth ?? DEFAULT_MAX_DEPTH;
+                            const faceActive = pluginSettings.maxActiveSubagents ??
+                                DEFAULT_MAX_ACTIVE_CHILDREN;
+                            const presetDepth = profile.subagents.maxDepth;
+                            const presetActive = profile.subagents.maxActiveChildren;
+                            const maxDepth = presetDepth !== undefined
+                                ? Math.min(faceDepth, presetDepth)
+                                : faceDepth;
+                            const maxActiveChildren = presetActive !== undefined
+                                ? Math.min(faceActive, presetActive)
+                                : faceActive;
+                            bindSubagentTools(agent.tools, {
+                                runtime: faceBox.runtime,
+                                parentSessionId: sessionId,
+                                maxDepth,
+                                maxActiveChildren,
+                            });
+                        }
+                        bindSessionQueryTools(agent.tools, {
+                            runtime: faceBox.runtime,
+                            parentSessionId: sessionId,
+                        });
+                        const prefs = loadSidebarPrefs(resolveXrkHome()).value;
+                        if (prefs.agentOpenTools === true ||
+                            prefs.agentTerminalTools === true) {
+                            bindSidebarAgentTools(agent.tools, {
+                                sessionId,
+                                agentOpens: agentOpenRegistry,
+                                agentPty: agentPtyRegistry,
+                                resolveCwd: (sid) => resolveSessionCwd(faceBox.runtime, sid) ??
+                                    faceBox.runtime.workspaceRoot,
+                                readPrefs: () => loadSidebarPrefs(resolveXrkHome()).value,
+                                readShellOverrides: () => {
+                                    const p = loadSidebarPrefs(resolveXrkHome()).value;
+                                    const shell = typeof p.terminalShell === "string" &&
+                                        p.terminalShell.trim()
+                                        ? p.terminalShell.trim()
+                                        : undefined;
+                                    const shellArgsRaw = typeof p.terminalShellArgs === "string"
+                                        ? p.terminalShellArgs.trim()
+                                        : "";
+                                    const shellArgs = shellArgsRaw.length > 0
+                                        ? shellArgsRaw.split(/\s+/).filter(Boolean)
+                                        : undefined;
+                                    return {
+                                        ...(shell ? { shell } : {}),
+                                        ...(shellArgs ? { shellArgs } : {}),
+                                    };
+                                },
+                            });
+                        }
+                    }
+                    return agent;
+                }, parentSessionId ? { parentSessionId } : undefined);
+            };
+            const hub = createSessionDrainHub({
+                createDrain: (sessionId) => async ({ signal }) => {
+                    try {
+                        const agent = await resolveAgent(sessionId);
+                        // Delivery queue rule (docs/session-delivery.md §3):
+                        // one continueTurn ⇒ one promote; runTurn owns tool continuation
+                        // without promoting further inbox items. Loop until inbox empty.
+                        while (agent.pendingAdmits().length > 0) {
+                            if (signal.aborted) {
+                                throw new DOMException("aborted", "AbortError");
+                            }
+                            // Worktree snapshot before tools mutate files (Hermes-style
+                            // checkpoint). Best-effort — never blocks the turn.
+                            const face = faceBox.runtime;
+                            if (face) {
+                                await snapshotSessionWorkspace(face, sessionId);
+                            }
+                            const result = await agent.continueTurn({ signal });
+                            lastDrainResult.set(sessionId, result);
+                        }
+                    }
+                    finally {
+                        publishDrainIdle(hub, sessionId, (sid, running) => {
+                            if (!running &&
+                                "flush" in store &&
+                                typeof store.flush === "function") {
+                                store.flush();
+                            }
+                            if (!running && pendingAgentInvalidate.has(sid)) {
+                                pendingAgentInvalidate.delete(sid);
+                                void agentCache.invalidate(sid).then(() => mcpDeferred.flush());
+                            }
+                            else if (!running) {
+                                void mcpDeferred.flush();
+                            }
+                            hostStatusBox.publish?.(sid, running);
+                        });
+                    }
+                },
+            });
+            const drain = wireDrainStatus(hub, (sessionId, running) => {
+                hostStatusBox.publish?.(sessionId, running);
+            }, lastDrainResult);
+            drainActiveBox.isActive = (sessionId) => drain.isActive(sessionId);
+            drainActiveBox.activeIds = () => hub.activeIds();
+            const cronHostOptions = {
+                productHome: resolveXrkHome(),
+                workspaceRoot: config.runtime.workspaceRoot,
+                runAgent: async (job, signal) => {
+                    const run = job.run;
+                    if (run.kind !== "agent") {
+                        return {
+                            ok: false,
+                            output: "",
+                            error: "not an agent job",
+                        };
+                    }
+                    return cronAgentDepth.run(true, async () => {
+                        const session = store.create();
+                        const agent = await resolveAgent(session.id);
+                        const result = await agent.continueTurn({
+                            text: `[cron ${job.id}${job.name ? ` ${job.name}` : ""}]\n${run.prompt}`,
+                            ...(signal ? { signal } : {}),
+                        });
+                        return {
+                            ok: true,
+                            output: result.text,
+                            sessionId: session.id,
+                        };
+                    });
+                },
+                onError: (err) => {
+                    log?.warn(`cron: ${err instanceof Error ? err.message : String(err)}`);
+                },
+            };
+            /**
+             * Face `cron.enabled` SoT when `XRK_CRON` unset; env non-empty is CI bypass.
+             * Returns whether the scheduler presence changed (tools need invalidate).
+             */
+            const applyCronScheduler = (product) => {
+                const next = createHostCron({
+                    ...cronHostOptions,
+                    ...(product ? { product } : {}),
+                });
+                if (!next) {
+                    if (!cronBox.scheduler)
+                        return false;
+                    cronBox.scheduler.stop();
+                    cronBox.scheduler = undefined;
+                    log?.info("cron ticker stopped");
+                    return true;
+                }
+                if (cronBox.scheduler)
+                    return false;
+                cronBox.scheduler = next;
+                next.start();
+                log?.info("cron ticker started (~/.xrk/cron/jobs.json)");
+                return true;
+            };
+            // Env-only until Face is ready; re-applied below with Settings product.
+            applyCronScheduler();
+            const webOverlay = await resolveWebPluginOverlay(resolvedPluginsDir);
+            const overlayBoot = webOverlay
+                ? loadBootManifestFromWebDist(webOverlay)
+                : undefined;
+            // Defense only: reconcileBoot already omits soft-disabled ids. Still
+            // filter here so a stale web/boot.json cannot load a disabled client
+            // (including inventory key/name aliases).
+            const disabledIds = readDisabledPluginIdsAt(resolvedPluginsDir);
+            const packageIndex = readManagedPackageIndexAt(resolvedPluginsDir);
+            const filteredOverlay = overlayBoot === undefined || disabledIds.size === 0
+                ? overlayBoot
+                : {
+                    rev: overlayBoot.rev,
+                    entries: overlayBoot.entries.filter((e) => !isPluginSoftDisabledAt(e.id, disabledIds, packageIndex)),
+                };
+            const boot = applyXrkProductBootPolicy(ensureXrkPlatformClientBootEntries(mergeWebBootManifests(resolveWebBootManifest(config.runtime.webDist), filteredOverlay), config.runtime.webDist));
+            // Mutable like facePlugins: soft-disable / remove rewrite boot.json, so
+            // inventory must re-read overlay or removed clients stay as active ghosts.
+            const faceWebPlugins = [];
+            const refreshFaceWebPlugins = async () => {
+                if (!config.runtime.webDist) {
+                    faceWebPlugins.splice(0, faceWebPlugins.length);
+                    return;
+                }
+                const overlayRoot = await resolveWebPluginOverlay(resolvedPluginsDir);
+                const nextOverlay = overlayRoot
+                    ? loadBootManifestFromWebDist(overlayRoot)
+                    : undefined;
+                const disabled = readDisabledPluginIdsAt(resolvedPluginsDir);
+                const index = readManagedPackageIndexAt(resolvedPluginsDir);
+                const filtered = nextOverlay === undefined || disabled.size === 0
+                    ? nextOverlay
+                    : {
+                        rev: nextOverlay.rev,
+                        entries: nextOverlay.entries.filter((e) => !isPluginSoftDisabledAt(e.id, disabled, index)),
+                    };
+                const nextBoot = applyXrkProductBootPolicy(ensureXrkPlatformClientBootEntries(mergeWebBootManifests(resolveWebBootManifest(config.runtime.webDist), filtered), config.runtime.webDist));
+                faceWebPlugins.splice(0, faceWebPlugins.length, ...nextBoot.entries.map((e) => ({ id: e.id })));
+            };
+            faceWebPlugins.push(...boot.entries.map((e) => ({ id: e.id })));
+            const hostWireRef = {};
+            const syncCordisHostApplied = () => {
+                hostPublic.cordisHostApplied = listHostAppliedPackages().map((row) => row.packageName);
+                hostPublic.cordisHostPackages = listHostAppliedPackages().map((row) => ({
+                    packageName: row.packageName,
+                    rpcChannels: [...row.rpcChannels],
+                }));
+            };
+            const secretStore = await resolveSecretStore(process.env);
+            const faceRuntime = createFaceRuntime({
+                store,
+                resolveAgent,
+                workspaceRoot: config.runtime.workspaceRoot,
+                ...(sshWorld
+                    ? {
+                        remoteExecution: true,
+                        ...(localHostRoot !== undefined ? { localHostRoot } : {}),
+                        directoryBackend: createSshDirectoryBackend(sshWorld),
+                    }
+                    : {}),
+                // Face settings / credentials / workspaces.json / host-settings → harness home.
+                productDir: resolveXrkHome(),
+                ...(secretStore ? { secretStore } : {}),
+                tools: createStandingToolRegistry({
+                    workspaceRoot: config.runtime.workspaceRoot,
+                    preset: config.runtime.preset,
+                }),
+                version: "0.0.0",
+                defaultAgentPreset: canonicalAgentPresetId(config.runtime.preset),
+                registry,
+                attachments,
+                // Face intake only (InputBar paste). Live adapter modalities come from
+                // Registry — official DeepSeek text models stay text-only; vision-exp
+                // declares image; MCP/prompt gate on that.
+                inputModalities: ["text", "image"],
+                ...(sessionsDir
+                    ? {
+                        subagentPersistPath: path.join(sessionsDir, "subagents.json"),
+                        goalPersistPath: path.join(sessionsDir, "goals.json"),
+                        feedbackSlicesDir: path.join(sessionsDir, "feedback-slices"),
+                        listProjectionCachePath: path.join(sessionsDir, "projection-list-cache.json"),
+                    }
+                    : {}),
+                plugins: facePlugins,
+                removeUserPlugin: async (spec) => {
+                    const result = await runPluginMutate({
+                        action: "remove",
+                        spec,
+                        pluginsDir: resolvedPluginsDir,
+                    });
+                    return result.ok
+                        ? { ok: true }
+                        : { ok: false, error: result.error ?? result.stderr };
+                },
+                updateUserPlugin: async (spec) => {
+                    const result = await runPluginMutate({
+                        action: "add",
+                        spec,
+                        pluginsDir: resolvedPluginsDir,
+                    });
+                    return result.ok
+                        ? { ok: true }
+                        : { ok: false, error: result.error ?? result.stderr };
+                },
+                syncManagedProcessPlugins: async () => {
+                    if (!managedPluginsRootReady())
+                        return;
+                    const synced = await reconcileManagedProcessPlugins(loader, resolvedPluginsDir);
+                    loadedPluginIds = [...synced.ids];
+                    for (const failure of synced.failures) {
+                        log?.warn(`plugin load failed (${failure.id}): ${failure.message}`);
+                    }
+                    refreshFacePlugins();
+                    await refreshFaceWebPlugins();
+                    await invalidateAgents();
+                },
+                ...(mcpFileSourced
+                    ? {
+                        syncMcpServers: async (servers, options) => {
+                            const run = mcpSyncTail.then(async () => {
+                                mcpAllowConnect = resolveMcpAllowConnect(config, options?.allowConnect);
+                                const result = await reconcileMcpToolPlugins({
+                                    desired: mcpDraftsToSpecs(servers),
+                                    list: () => loader.list(),
+                                    register: (plugin) => {
+                                        loader.register(plugin);
+                                        if (!loadedPluginIds.includes(plugin.id)) {
+                                            loadedPluginIds = [...loadedPluginIds, plugin.id];
+                                        }
+                                    },
+                                    unregister: mcpUnregister,
+                                    retained: () => mcpDeferred.retained(),
+                                    policy,
+                                    allowConnect: mcpAllowConnect,
+                                    workspaceRoot: config.runtime.workspaceRoot,
+                                    imageAdmission: mcpImageAdmission,
+                                    ...mcpHooks,
+                                });
+                                logMcpReconcile(log, "reconcile", result);
+                                refreshFacePlugins();
+                                await invalidateAgents();
+                                return {
+                                    failures: result.failures,
+                                    parked: result.parked,
+                                };
+                            });
+                            // Keep the chain alive even if one reconcile rejects.
+                            mcpSyncTail = run.then(() => undefined, () => undefined);
+                            return run;
+                        },
+                    }
+                    : {}),
+                ...(config.runtime.webDist
+                    ? { webPlugins: faceWebPlugins }
+                    : {}),
+                hostPublic,
+                cordisHostBridge: {
+                    applyHostHalf: async (packageName) => {
+                        const ctx = hostWireRef.ctx;
+                        if (!ctx) {
+                            return { ok: false, message: "Host wire not initialized" };
+                        }
+                        const ok = await applyHostPackageByName(ctx, packageName);
+                        if (ok)
+                            syncCordisHostApplied();
+                        return ok
+                            ? { ok: true }
+                            : {
+                                ok: false,
+                                message: "host.mjs apply failed or package missing",
+                            };
+                    },
+                    invokeRpc: async (channel, endpoint, rpcPayload) => {
+                        const ctx = hostWireRef.ctx;
+                        if (!ctx) {
+                            throw new Error("Host wire not initialized");
+                        }
+                        return invokeDshCompatRpc(ctx, channel, endpoint, rpcPayload);
+                    },
+                    stopHostHalf: async (packageName) => {
+                        await stopHostPackageFiber(packageName);
+                    },
+                },
+                bootstrapApiKey: config.credentials.apiKey,
+                policy,
+                ...(config.runtime.policyFile
+                    ? { settingsDocumentPath: path.resolve(config.runtime.policyFile) }
+                    : {}),
+                invalidateAgent: (sessionId) => agentCache.invalidate(sessionId),
+                onSessionFinalize: (sessionId) => {
+                    consolidateCuratedMemoryForSession(sessionId);
+                    sharedBrowser?.drop(sessionId);
+                },
+                ...createAutoReviewBridgeFromHost(resolveXrkHome()),
+                ...(sharedPty
+                    ? {
+                        // Agent terminal_* registry only — never sidebar user PTYs.
+                        hasPtyActivity: () => sharedPty.service.hasActivity(),
+                    }
+                    : {}),
+                drain: {
+                    wake: (sessionId) => drain.wake(sessionId),
+                    cancel: (sessionId) => drain.cancel(sessionId),
+                    isActive: (sessionId) => drain.isActive(sessionId),
+                    run: (sessionId) => hub.run(sessionId),
+                },
+                ...(sharedShell ? { shell: sharedShell } : {}),
+            });
+            // Authorize DSH client settings namespaces so panels do not fail
+            // "Host 未授权设置 RPC" when Cordis Host is absent (empty docs).
+            for (const ns of DSH_SETTINGS_NAMESPACES) {
+                const slot = faceRuntime.settingsNamespaces.ensure(ns);
+                const seed = DSH_SETTINGS_DEFAULTS[ns];
+                if (seed && Object.keys(slot.base).length === 0) {
+                    slot.base = { ...seed };
+                }
+            }
+            faceForModality.current = faceRuntime;
+            faceBox.approvals = faceRuntime.approvals;
+            faceBox.questions = faceRuntime.questions;
+            faceBox.runtime = faceRuntime;
+            // Face hydrate may migrate legacy settings.yaml mcp → host-settings after
+            // boot reconcile already ran with []. Remount once when file-sourced.
+            if (mcpFileSourced && mcpSpecs.length === 0) {
+                const mcpUser = faceRuntime.settingsNamespaces.ensure("mcp").user;
+                const drafts = Array.isArray(mcpUser.servers)
+                    ? mcpUser.servers
+                    : [];
+                const desired = mcpDraftsToSpecs(drafts);
+                if (desired.length > 0) {
+                    mcpAllowConnect = resolveMcpAllowConnect(config, mcpUser.allowConnect === true);
+                    const migrated = await reconcileMcpToolPlugins({
+                        desired,
+                        list: () => loader.list(),
+                        register: (plugin) => {
+                            loader.register(plugin);
+                            if (!loadedPluginIds.includes(plugin.id)) {
+                                loadedPluginIds = [...loadedPluginIds, plugin.id];
+                            }
+                        },
+                        unregister: mcpUnregister,
+                        retained: () => mcpDeferred.retained(),
+                        policy,
+                        allowConnect: mcpAllowConnect,
+                        workspaceRoot: config.runtime.workspaceRoot,
+                        imageAdmission: mcpImageAdmission,
+                        ...mcpHooks,
+                    });
+                    logMcpReconcile(log, "yaml-migrate", migrated);
+                    refreshFacePlugins();
+                    await invalidateAgents();
+                }
+            }
+            sessionCwdBox.get = (sessionId) => resolveSessionCwd(faceRuntime, sessionId);
+            sessionPresetBox.get = (sessionId) => faceRuntime.sessionAgentPresets.get(sessionId);
+            hostStatusBox.publish = (sessionId, running) => {
+                faceRuntime.bus.publishHost({
+                    type: "host/session-status",
+                    sessionId,
+                    running,
+                });
+                faceRuntime.onSessionDrainStatus(sessionId, running);
+            };
+            llmResolverBox.resolve = (sessionId) => createSessionRoutingLlm(faceRuntime, sessionId);
+            pluginSettingsBox.read = () => {
+                const loop = faceRuntime.settingsNamespaces.view("agent-loop").value;
+                const bash = faceRuntime.settingsNamespaces.view("bash").value;
+                const webSearchNs = faceRuntime.settingsNamespaces.view("web-search")
+                    .value;
+                const injectNs = faceRuntime.settingsNamespaces.view("workspace-inject")
+                    .value;
+                const telemetryNs = faceRuntime.settingsNamespaces.view("session-telemetry")
+                    .value;
+                const maxParallelToolCalls = typeof loop.maxParallelToolCalls === "number" &&
+                    Number.isFinite(loop.maxParallelToolCalls) &&
+                    loop.maxParallelToolCalls > 0
+                    ? Math.floor(loop.maxParallelToolCalls)
+                    : undefined;
+                const maxSteps = typeof loop.maxSteps === "number" &&
+                    Number.isFinite(loop.maxSteps) &&
+                    loop.maxSteps > 0
+                    ? Math.floor(loop.maxSteps)
+                    : undefined;
+                const toolOrderRaw = loop.toolOrder;
+                const toolOrder = Array.isArray(toolOrderRaw) &&
+                    toolOrderRaw.length > 0 &&
+                    toolOrderRaw.every((x) => typeof x === "string")
+                    ? (toolOrderRaw)
+                    : undefined;
+                const toolSettleRaw = loop.toolSettle;
+                const toolSettle = toolSettleRaw === "serial" || toolSettleRaw === "parallel"
+                    ? toolSettleRaw
+                    : undefined;
+                const llmRetryMaxRetriesRaw = loop.llmRetryMaxRetries;
+                const llmRetryMaxRetries = typeof llmRetryMaxRetriesRaw === "number" &&
+                    Number.isFinite(llmRetryMaxRetriesRaw) &&
+                    llmRetryMaxRetriesRaw >= 0
+                    ? Math.floor(llmRetryMaxRetriesRaw)
+                    : undefined;
+                const maxRequestTokens = typeof loop.maxRequestTokens === "number" &&
+                    Number.isFinite(loop.maxRequestTokens) &&
+                    loop.maxRequestTokens >= 8_000
+                    ? Math.floor(loop.maxRequestTokens)
+                    : undefined;
+                const keepTokens = typeof loop.keepTokens === "number" &&
+                    Number.isFinite(loop.keepTokens) &&
+                    loop.keepTokens >= 2_000
+                    ? Math.floor(loop.keepTokens)
+                    : undefined;
+                const bufferTokens = typeof loop.bufferTokens === "number" &&
+                    Number.isFinite(loop.bufferTokens) &&
+                    loop.bufferTokens >= 0
+                    ? Math.floor(loop.bufferTokens)
+                    : undefined;
+                const toolResultMaxInlineBytes = typeof loop.toolResultMaxInlineBytes === "number" &&
+                    Number.isFinite(loop.toolResultMaxInlineBytes) &&
+                    loop.toolResultMaxInlineBytes >= 0
+                    ? Math.floor(loop.toolResultMaxInlineBytes)
+                    : undefined;
+                const maxSubagentDepth = typeof loop.maxSubagentDepth === "number" &&
+                    Number.isFinite(loop.maxSubagentDepth) &&
+                    loop.maxSubagentDepth >= 1
+                    ? Math.min(3, Math.floor(loop.maxSubagentDepth))
+                    : undefined;
+                const maxActiveSubagents = typeof loop.maxActiveSubagents === "number" &&
+                    Number.isFinite(loop.maxActiveSubagents) &&
+                    loop.maxActiveSubagents >= 1
+                    ? Math.min(16, Math.floor(loop.maxActiveSubagents))
+                    : undefined;
+                const timeoutMs = typeof bash.timeoutMs === "number" &&
+                    Number.isFinite(bash.timeoutMs) &&
+                    bash.timeoutMs > 0
+                    ? Math.floor(bash.timeoutMs)
+                    : undefined;
+                // DSH bash-local default 64_000 — always present so capture is bounded.
+                const maxOutputBytes = typeof bash.maxOutputBytes === "number" &&
+                    Number.isFinite(bash.maxOutputBytes) &&
+                    bash.maxOutputBytes > 0
+                    ? Math.floor(bash.maxOutputBytes)
+                    : 64_000;
+                const foregroundYieldMs = typeof bash.foregroundYieldMs === "number" &&
+                    Number.isFinite(bash.foregroundYieldMs) &&
+                    bash.foregroundYieldMs >= 250
+                    ? Math.min(30_000, Math.floor(bash.foregroundYieldMs))
+                    : undefined;
+                const provider = typeof webSearchNs.provider === "string"
+                    ? webSearchNs.provider.trim()
+                    : "";
+                const region = typeof webSearchNs.region === "string"
+                    ? webSearchNs.region.trim()
+                    : "";
+                const tavily = faceRuntime.credentials.peek("web.tavily");
+                const brave = faceRuntime.credentials.peek("web.brave");
+                const webSearch = {
+                    ...(provider && provider !== "auto" ? { provider } : {}),
+                    ...(region ? { region } : {}),
+                    ...(tavily || process.env.XRK_TAVILY_API_KEY?.trim()
+                        ? {
+                            tavilyApiKey: tavily ?? process.env.XRK_TAVILY_API_KEY?.trim() ?? "",
+                        }
+                        : {}),
+                    ...(brave || process.env.XRK_BRAVE_SEARCH_API_KEY?.trim()
+                        ? {
+                            braveApiKey: brave ?? process.env.XRK_BRAVE_SEARCH_API_KEY?.trim() ?? "",
+                        }
+                        : {}),
+                };
+                const injectMaxCharsRaw = injectNs.injectMaxChars;
+                const injectMaxChars = typeof injectMaxCharsRaw === "number" &&
+                    Number.isFinite(injectMaxCharsRaw) &&
+                    injectMaxCharsRaw >= 4_000
+                    ? Math.min(128_000, Math.floor(injectMaxCharsRaw))
+                    : undefined;
+                const telModeRaw = typeof telemetryNs.mode === "string"
+                    ? telemetryNs.mode.trim().toLowerCase()
+                    : "off";
+                const telMode = telModeRaw === "memory" || telModeRaw === "otlp" || telModeRaw === "off"
+                    ? telModeRaw
+                    : "off";
+                const telEndpoint = typeof telemetryNs.endpoint === "string" && telemetryNs.endpoint.trim()
+                    ? telemetryNs.endpoint.trim()
+                    : undefined;
+                const sessionTelemetry = {
+                    mode: telMode,
+                    ...(telEndpoint ? { endpoint: telEndpoint } : {}),
+                };
+                const sandboxNs = faceRuntime.settingsNamespaces.view("sandbox")
+                    .value;
+                const sbBackendRaw = typeof sandboxNs.backend === "string"
+                    ? sandboxNs.backend.trim().toLowerCase()
+                    : "workspace";
+                const sbBackend = sbBackendRaw === "docker" ||
+                    sbBackendRaw === "bwrap" ||
+                    sbBackendRaw === "windows" ||
+                    sbBackendRaw === "workspace"
+                    ? sbBackendRaw
+                    : "workspace";
+                const sbImage = typeof sandboxNs.dockerImage === "string" && sandboxNs.dockerImage.trim()
+                    ? sandboxNs.dockerImage.trim()
+                    : undefined;
+                const sbNetRaw = typeof sandboxNs.dockerNetwork === "string"
+                    ? sandboxNs.dockerNetwork.trim().toLowerCase()
+                    : "";
+                const sbNetwork = sbNetRaw === "bridge" || sbNetRaw === "none" ? sbNetRaw : undefined;
+                const sbModeRaw = typeof sandboxNs.windowsMode === "string"
+                    ? sandboxNs.windowsMode.trim()
+                    : "";
+                const sbMode = sbModeRaw === "workspace-write" ||
+                    sbModeRaw === "read-only" ||
+                    sbModeRaw === "danger-full-access"
+                    ? sbModeRaw
+                    : undefined;
+                const sandbox = {
+                    backend: sbBackend,
+                    ...(sbImage ? { dockerImage: sbImage } : {}),
+                    ...(sbNetwork ? { dockerNetwork: sbNetwork } : {}),
+                    ...(sbMode ? { windowsMode: sbMode } : {}),
+                };
+                const computerUseNs = faceRuntime.settingsNamespaces.view("computer-use")
+                    .value;
+                const cuModeRaw = typeof computerUseNs.mode === "string"
+                    ? computerUseNs.mode.trim().toLowerCase()
+                    : "off";
+                const computerUseProduct = {
+                    mode: cuModeRaw === "uia" || cuModeRaw === "background"
+                        ? cuModeRaw
+                        : "off",
+                };
+                const backgroundHelper = faceRuntime.credentials.peek("computer.background")?.trim() ||
+                    process.env.XRK_COMPUTER_USE_BACKGROUND?.trim() ||
+                    "";
+                const computerUseEnv = backgroundHelper
+                    ? {
+                        ...process.env,
+                        XRK_COMPUTER_USE_BACKGROUND: backgroundHelper,
+                    }
+                    : undefined;
+                const browserNs = faceRuntime.settingsNamespaces.view("browser")
+                    .value;
+                const brModeRaw = typeof browserNs.mode === "string"
+                    ? browserNs.mode.trim().toLowerCase()
+                    : "http";
+                const brCdpUrl = typeof browserNs.cdpUrl === "string" && browserNs.cdpUrl.trim()
+                    ? browserNs.cdpUrl.trim()
+                    : undefined;
+                const browserProduct = {
+                    mode: brModeRaw === "cdp" ? "cdp" : "http",
+                    ...(brCdpUrl ? { cdpUrl: brCdpUrl } : {}),
+                };
+                const voiceNs = faceRuntime.settingsNamespaces.view("voice")
+                    .value;
+                const voiceModeRaw = typeof voiceNs.mode === "string"
+                    ? voiceNs.mode.trim().toLowerCase()
+                    : "off";
+                const voiceBase = typeof voiceNs.baseUrl === "string" && voiceNs.baseUrl.trim()
+                    ? voiceNs.baseUrl.trim()
+                    : undefined;
+                const voiceProduct = {
+                    mode: voiceModeRaw === "openai" ? "openai" : "off",
+                    ...(voiceBase ? { baseUrl: voiceBase } : {}),
+                };
+                const voiceKey = faceRuntime.credentials.peek("voice.openai")?.trim() ||
+                    process.env.XRK_VOICE_OPENAI_KEY?.trim() ||
+                    "";
+                const voiceEnv = voiceKey
+                    ? { ...process.env, XRK_VOICE_OPENAI_KEY: voiceKey }
+                    : undefined;
+                const imageNs = faceRuntime.settingsNamespaces.view("image-gen")
+                    .value;
+                const imageModeRaw = typeof imageNs.mode === "string"
+                    ? imageNs.mode.trim().toLowerCase()
+                    : "off";
+                const imageBase = typeof imageNs.baseUrl === "string" && imageNs.baseUrl.trim()
+                    ? imageNs.baseUrl.trim()
+                    : undefined;
+                const imageModel = typeof imageNs.model === "string" && imageNs.model.trim()
+                    ? imageNs.model.trim()
+                    : undefined;
+                const imageGenProduct = {
+                    mode: imageModeRaw === "openai" ? "openai" : "off",
+                    ...(imageBase ? { baseUrl: imageBase } : {}),
+                    ...(imageModel ? { model: imageModel } : {}),
+                };
+                const imageKey = faceRuntime.credentials.peek("image.openai")?.trim() ||
+                    process.env.XRK_IMAGE_GEN_OPENAI_KEY?.trim() ||
+                    "";
+                const imageGenEnv = imageKey
+                    ? { ...process.env, XRK_IMAGE_GEN_OPENAI_KEY: imageKey }
+                    : undefined;
+                const videoNs = faceRuntime.settingsNamespaces.view("video-gen")
+                    .value;
+                const videoModeRaw = typeof videoNs.mode === "string"
+                    ? videoNs.mode.trim().toLowerCase()
+                    : "off";
+                const videoBase = typeof videoNs.baseUrl === "string" && videoNs.baseUrl.trim()
+                    ? videoNs.baseUrl.trim()
+                    : undefined;
+                const videoModel = typeof videoNs.model === "string" && videoNs.model.trim()
+                    ? videoNs.model.trim()
+                    : undefined;
+                const videoGenProduct = {
+                    mode: videoModeRaw === "openai" ? "openai" : "off",
+                    ...(videoBase ? { baseUrl: videoBase } : {}),
+                    ...(videoModel ? { model: videoModel } : {}),
+                };
+                const videoKey = faceRuntime.credentials.peek("video.openai")?.trim() ||
+                    process.env.XRK_VIDEO_GEN_OPENAI_KEY?.trim() ||
+                    "";
+                const videoGenEnv = videoKey
+                    ? { ...process.env, XRK_VIDEO_GEN_OPENAI_KEY: videoKey }
+                    : undefined;
+                const localeNs = faceRuntime.settingsNamespaces.view("locale")
+                    .value;
+                const asLocale = (raw) => raw === "zh" || raw === "en" ? raw : undefined;
+                // Explicit Settings choice wins; older desktop builds stored the shell
+                // language in the `ui` namespace (`ui.locale`) and never wrote
+                // `locale.preference`, so honour it instead of dropping to the
+                // language-agnostic prompt fallback (reasoning drifted to English).
+                const localePref = asLocale(localeNs.preference) ??
+                    asLocale(faceRuntime.settingsNamespaces.view("ui")
+                        .value.locale);
+                const memNs = faceRuntime.settingsNamespaces.view("curated-memory")
+                    .value;
+                const memFaceOn = memNs.enabled !== false;
+                const memEnvRaw = String(process.env.XRK_CURATED_MEMORY ?? "").trim();
+                const curatedMemoryEnabled = memEnvRaw !== "" ? memEnvRaw !== "0" : memFaceOn;
+                return {
+                    ...(maxParallelToolCalls !== undefined ? { maxParallelToolCalls } : {}),
+                    ...(maxSteps !== undefined ? { maxSteps } : {}),
+                    ...(toolOrder !== undefined ? { toolOrder } : {}),
+                    ...(toolSettle !== undefined ? { toolSettle } : {}),
+                    ...(llmRetryMaxRetries !== undefined ? { llmRetryMaxRetries } : {}),
+                    ...(maxRequestTokens !== undefined ||
+                        keepTokens !== undefined ||
+                        bufferTokens !== undefined
+                        ? {
+                            compaction: {
+                                ...(maxRequestTokens !== undefined
+                                    ? { maxRequestTokens }
+                                    : {}),
+                                ...(keepTokens !== undefined ? { keepTokens } : {}),
+                                ...(bufferTokens !== undefined ? { bufferTokens } : {}),
+                            },
+                        }
+                        : {}),
+                    ...(toolResultMaxInlineBytes !== undefined
+                        ? { toolResultMaxInlineBytes }
+                        : {}),
+                    ...(maxSubagentDepth !== undefined ? { maxSubagentDepth } : {}),
+                    ...(maxActiveSubagents !== undefined ? { maxActiveSubagents } : {}),
+                    bashLimits: {
+                        ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+                        maxOutputBytes,
+                        ...(foregroundYieldMs !== undefined
+                            ? { foregroundYieldMs }
+                            : {}),
+                    },
+                    webSearch,
+                    ...(injectMaxChars !== undefined
+                        ? { workspaceInject: { maxChars: injectMaxChars } }
+                        : {}),
+                    sessionTelemetry,
+                    sandbox,
+                    computerUseProduct,
+                    ...(computerUseEnv ? { computerUseEnv } : {}),
+                    browserProduct,
+                    voiceProduct,
+                    ...(voiceEnv ? { voiceEnv } : {}),
+                    imageGenProduct,
+                    ...(imageGenEnv ? { imageGenEnv } : {}),
+                    videoGenProduct,
+                    ...(videoGenEnv ? { videoGenEnv } : {}),
+                    ...(!curatedMemoryEnabled ? { curatedMemory: false } : {}),
+                    ...(localePref ? { locale: localePref } : {}),
+                };
+            };
+            {
+                const cronNs = faceRuntime.settingsNamespaces.view("cron")
+                    .value;
+                applyCronScheduler({ enabled: cronNs.enabled !== false });
+            }
+            faceRuntime.bus.subscribeHost((_rpcId, frame) => {
+                if (frame.type !== "host/remote-event")
+                    return;
+                const event = frame.event;
+                if (event === "llm/adapters-updated" ||
+                    event === "credentials/updated") {
+                    void invalidateAgents();
+                    return;
+                }
+                if (event === "settings/document-updated") {
+                    const ns = frame.args[0];
+                    if (ns === "cron") {
+                        const cronNs = faceRuntime.settingsNamespaces.view("cron")
+                            .value;
+                        const changed = applyCronScheduler({
+                            enabled: cronNs.enabled !== false,
+                        });
+                        if (changed)
+                            void invalidateAgents();
+                        return;
+                    }
+                    if (ns === "agent-default-model" ||
+                        ns === "llm-deepseek" ||
+                        ns === "llm-pi-ai" ||
+                        ns === "agent-loop" ||
+                        ns === "bash" ||
+                        ns === "web-search" ||
+                        ns === "sandbox" ||
+                        ns === "computer-use" ||
+                        ns === "browser" ||
+                        ns === "voice" ||
+                        ns === "image-gen" ||
+                        ns === "video-gen" ||
+                        ns === "curated-memory" ||
+                        ns === "locale") {
+                        void invalidateAgents();
+                    }
+                }
+            });
+            lineage.parentOf = (sessionId) => faceRuntime.subagents.getByChild(sessionId)?.parentSessionId;
+            notifyMcpOverlay = () => {
+                refreshFacePlugins();
+                const slot = faceRuntime.settingsNamespaces.ensure("mcp");
+                publishRemoteEvent(faceRuntime.bus, "settings/document-updated", [
+                    "mcp",
+                    slot.revision,
+                ]);
+            };
+            const mobileAccessGate = createMobileAccessGateChecker({
+                xrkHome: resolveXrkHome(),
+            });
+            const faceCheckAuth = (r) => {
+                if (!mobileAccessGate(r))
+                    return false;
+                const expected = effectiveHostApiKey(faceRuntime);
+                if (!expected)
+                    return true;
+                const auth = r.headers.authorization;
+                const headerKey = r.headers["x-api-key"];
+                const bearer = typeof auth === "string" && auth.startsWith("Bearer ")
+                    ? auth.slice("Bearer ".length)
+                    : undefined;
+                const key = bearer ?? (typeof headerKey === "string" ? headerKey : undefined);
+                if (key === expected)
+                    return true;
+                // DSH Web 同源不带 Authorization；本机回环放行。
+                return !key && isLoopbackAddress(r.socket.remoteAddress);
+            };
+            await ensureDshCompatHostPlugin(loader);
+            refreshFacePlugins();
+            const hostWireCtx = {
+                pluginsDir: resolvedPluginsDir,
+                xrkHome: resolveXrkHome(),
+                workspaceRoot: faceRuntime.workspaceRoot,
+                defaultCwd: faceRuntime.workspaceRoot,
+                resolveSessionCwd: (sessionId) => resolveSessionCwd(faceRuntime, sessionId),
+                resolveAutoReviewClassifierProduct: () => {
+                    const ns = faceRuntime.settingsNamespaces.view("auto-review")
+                        .value;
+                    const classifierUrl = typeof ns.classifierUrl === "string" ? ns.classifierUrl.trim() : "";
+                    const classifierToken = faceRuntime.credentials.peek("auto-review.classifier")?.trim() ||
+                        process.env.XRK_AUTO_REVIEW_CLASSIFIER_TOKEN?.trim() ||
+                        "";
+                    return {
+                        ...(classifierUrl ? { classifierUrl } : {}),
+                        ...(classifierToken ? { classifierToken } : {}),
+                    };
+                },
+                resolveMemoryEmbedProduct: () => {
+                    const ns = faceRuntime.settingsNamespaces.view("memory-embed")
+                        .value;
+                    const url = typeof ns.url === "string" ? ns.url.trim() : "";
+                    const collection = typeof ns.collection === "string" ? ns.collection.trim() : "";
+                    const token = faceRuntime.credentials.peek("memory-embed.token")?.trim() ||
+                        process.env.XRK_MEMORY_EMBED_TOKEN?.trim() ||
+                        "";
+                    return {
+                        ...(url ? { url } : {}),
+                        ...(token ? { token } : {}),
+                        ...(collection ? { collection } : {}),
+                    };
+                },
+                tokenLedger: {
+                    ...createCostMeterUsageBridge(faceRuntime),
+                    ...createUsageStatsBridgeFromFace(faceRuntime),
+                },
+                walletPort: createXrkWalletPort({
+                    xrkHome: resolveXrkHome(),
+                    face: createWalletFaceBridgeFromFace(faceRuntime),
+                }),
+                sidebarFace: createSidebarFaceBridgeFromFace(faceRuntime, {
+                    ...(sharedShell ? { shell: sharedShell } : {}),
+                }),
+                harnessConnector: createHarnessConnectorBridgeFromFace(faceRuntime),
+                policy,
+                resolvePolicyAsk: async (args) => {
+                    if (!args.sessionId)
+                        return undefined;
+                    return faceRuntime.approvals.requestHostGate(args.sessionId, {
+                        kind: args.subject.kind,
+                        reason: args.reason,
+                        summary: JSON.stringify(args.subject),
+                    });
+                },
+            };
+            hostWireRef.ctx = hostWireCtx;
+            await prewarmDshCompatAdapters(hostWireCtx);
+            syncCordisHostApplied();
+            const http = createHttpServer({
+                host: config.runtime.host,
+                port: config.runtime.port,
+                apiKey: config.credentials.apiKey,
+                corsOrigin: config.runtime.corsOrigin,
+                rateLimitPerMinute: config.runtime.rateLimitPerMinute,
+                store,
+                ensureSession,
+                resolveAgent,
+                drain,
+                tryHandlePublic: chainPublicHandlers(createMobileAccessGateHandler({ xrkHome: resolveXrkHome() }), createSidebarPublicHandler({
+                    xrkHome: resolveXrkHome(),
+                    defaultCwd: faceRuntime.workspaceRoot,
+                    resolveSessionCwd: (sessionId) => resolveSessionCwd(faceRuntime, sessionId),
+                    sidebarFace: hostWireCtx.sidebarFace,
+                    pluginsDir: resolvedPluginsDir,
+                    agentRegistries: {
+                        closeAgentPty: (uuid) => agentPtyRegistry.close(uuid),
+                    },
+                    policy,
+                    resolvePolicyAsk: hostWireCtx.resolvePolicyAsk,
+                    onPrefsChanged: (_value, patch) => {
+                        if (Object.prototype.hasOwnProperty.call(patch, "agentOpenTools") ||
+                            Object.prototype.hasOwnProperty.call(patch, "agentTerminalTools")) {
+                            void invalidateAgents();
+                        }
+                    },
+                }), createXrkPluginPublicHandler({
+                    pluginsDir: resolvedPluginsDir,
+                    xrkHome: resolveXrkHome(),
+                }), createLiveHostPluginsPublicHandler(() => loader.list(), hostWireCtx)),
+                ...(log
+                    ? {
+                        onAccess: (info) => {
+                            log.debug(`http ${info.method} ${info.path} → ${info.status}`);
+                        },
+                    }
+                    : {}),
+                ...(config.runtime.webDist
+                    ? {
+                        webStatic: {
+                            root: config.runtime.webDist,
+                            ...(webOverlay ? { extraRoots: [webOverlay] } : {}),
+                            transformIndex: (html) => injectMobileAccessShellIntoHtml(injectBootIntoHtml(html, boot)),
+                        },
+                    }
+                    : {}),
+                tryHandleExtraApi: (req, res) => tryHandleFaceHttp(req, res, faceRuntime, {
+                    apiKey: effectiveHostApiKey(faceRuntime),
+                    checkAuth: faceCheckAuth,
+                }),
+                attachExtras: (server) => {
+                    const face = attachFaceUpgrades(server, faceRuntime, {
+                        apiKey: effectiveHostApiKey(faceRuntime),
+                        checkAuth: faceCheckAuth,
+                    });
+                    const dshUpgrades = attachDshCompatUpgrades(server, {
+                        checkAuth: faceCheckAuth,
+                    });
+                    // Sidebar interactive PTY is Host-local node-pty — not SSH. Skip when
+                    // remote so defaultCwd is never a remote POSIX path on the Host disk.
+                    const sidebarPty = sshWorld
+                        ? { close() { } }
+                        : attachSidebarPtyUpgrades(server, {
+                            defaultCwd: faceRuntime.workspaceRoot,
+                            checkAuth: faceCheckAuth,
+                            agentPty: agentPtyRegistry,
+                            agentOpens: agentOpenRegistry,
+                        });
+                    return {
+                        close() {
+                            sidebarPty.close();
+                            agentPtyRegistry.disposeAll();
+                            agentOpenRegistry.dispose();
+                            dshUpgrades.close();
+                            face.close();
+                            shutdownDshCompatServices();
+                        },
+                    };
+                },
+            });
+            const shouldListen = config.runtime.listen !== false;
+            const addr = shouldListen
+                ? await http.listen()
+                : { host: config.runtime.host, port: 0 };
+            if (shouldListen) {
+                log?.info(`listening ${config.runtime.host}:${addr.port}`);
+            }
+            else {
+                log?.info("http stack ready (listen disabled — pipe / fetch transport)");
+            }
+            let status = "running";
+            let stopPromise;
+            const instance = {
+                id,
+                config,
+                store,
+                loader,
+                get loadedPluginIds() {
+                    return loadedPluginIds;
+                },
+                http,
+                drain,
+                get status() {
+                    return status;
+                },
+                health() {
+                    return {
+                        ok: status === "running",
+                        status,
+                        ...(shouldListen ? { port: addr.port } : {}),
+                        mcpAllowConnect,
+                        ...(loadedPluginIds.length
+                            ? { plugins: loadedPluginIds }
+                            : {}),
+                    };
+                },
+                async stop() {
+                    if (stopPromise)
+                        return stopPromise;
+                    status = "stopped";
+                    stopPromise = (async () => {
+                        cronBox.scheduler?.stop();
+                        policyFileWatch?.dispose();
+                        // Phase1 consolidate before agents/store go away (Hermes finalize).
+                        for (const sessionId of store.list()) {
+                            consolidateCuratedMemoryForSession(sessionId);
+                        }
+                        await http.close();
+                        await agentCache.dispose();
+                        if (sharedShell) {
+                            try {
+                                await sharedShell.dispose();
+                            }
+                            catch {
+                                // Host stop must continue even if jobs teardown partially fails.
+                            }
+                        }
+                        if (sharedBrowser) {
+                            try {
+                                sharedBrowser.dispose();
+                            }
+                            catch {
+                                // Host stop must continue even if browser CDP teardown fails.
+                            }
+                        }
+                        if (sshWorld) {
+                            try {
+                                sshWorld.dispose();
+                            }
+                            catch {
+                                // Host stop must continue even if SSH ControlMaster exit fails.
+                            }
+                        }
+                        if (sharedPty) {
+                            try {
+                                await sharedPty.service.dispose();
+                            }
+                            catch {
+                                // Host stop must continue even if PTY cleanup partially fails.
+                            }
+                        }
+                        if ("close" in store && typeof store.close === "function") {
+                            store.close();
+                        }
+                        invariantsRegistry?.dispose();
+                        for (const p of loader.list()) {
+                            await loader.unregister(p.id);
+                        }
+                        instances.delete(id);
+                    })();
+                    return stopPromise;
+                },
+            };
+            instances.set(id, instance);
+            return instance;
+        },
+        get(id) {
+            return instances.get(id);
+        },
+        list() {
+            return [...instances.values()];
+        },
+        async stop(id) {
+            const inst = instances.get(id);
+            if (inst)
+                await inst.stop();
+        },
+        async stopAll() {
+            await Promise.all([...instances.values()].map((i) => i.stop()));
+        },
+    };
+}
+//# sourceMappingURL=index.js.map