comisai 1.0.4

package/node_modules/@comis/daemon/dist/wiring/setup-health.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Health, process, and monitoring subsystem setup: process monitor, watchdog,
+ * device identity loading, and heartbeat runner with configurable monitoring
+ * sources.
+ * Extracted from daemon.ts steps 5 through 6.7 to isolate process lifecycle
+ * and monitoring concerns from the main startup sequence.
+ * @module
+ */
+import type { DeviceIdentity, AppContainer, ChannelPort } from "@comis/core";
+import type { ComisLogger } from "@comis/infra";
+import type { createProcessMonitor, ProcessMonitor } from "../process/process-monitor.js";
+import type { startWatchdog, WatchdogHandle } from "../health/watchdog.js";
+import { type HeartbeatRunner, type DuplicateDetector } from "@comis/scheduler";
+/** All services produced by the health/process setup phase. */
+export interface HealthResult {
+    processMonitor: ProcessMonitor;
+    watchdogHandle: WatchdogHandle;
+    deviceIdentity?: DeviceIdentity;
+}
+/**
+ * Create and start the process monitor, start the systemd watchdog,
+ * and load or create the device identity.
+ * @param deps.container - Bootstrap output (config, event bus)
+ * @param deps.logger - Root tracing logger (for identity load warnings)
+ * @param deps._createProcessMonitor - Factory (overridable for tests)
+ * @param deps._startWatchdog - Factory (overridable for tests)
+ */
+export declare function setupHealth(deps: {
+    container: AppContainer;
+    logger: ComisLogger;
+    daemonLogger: ComisLogger;
+    _createProcessMonitor: typeof createProcessMonitor;
+    _startWatchdog: typeof startWatchdog;
+}): HealthResult;
+/** Dependencies for monitoring setup. */
+export interface MonitoringDeps {
+    /** Bootstrap output (config.monitoring, config.scheduler, eventBus). */
+    container: AppContainer;
+    /** Module-bound logger for scheduler subsystem. */
+    schedulerLogger: ComisLogger;
+    /** Root logger for notification callbacks. */
+    logger: ComisLogger;
+    /** Channel adapters for heartbeat delivery (optional -- delivery skipped if not provided). */
+    adaptersByType?: ReadonlyMap<string, ChannelPort>;
+}
+/** All services produced by the monitoring setup phase. */
+export interface MonitoringResult {
+    /** Heartbeat runner for periodic health checks (optional). */
+    heartbeatRunner?: HeartbeatRunner;
+    /** Duplicate detector shared between global and per-agent heartbeat delivery. */
+    duplicateDetector?: DuplicateDetector;
+}
+/**
+ * Create monitoring heartbeat sources and runner based on config toggles.
+ * Synchronous setup -- creates sources array, builds runner if any are
+ * enabled, starts the runner, and returns the handle.
+ * @param deps - Monitoring dependencies
+ */
+export declare function setupMonitoring(deps: MonitoringDeps): MonitoringResult;

package/node_modules/@comis/daemon/dist/wiring/setup-health.js

@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Health, process, and monitoring subsystem setup: process monitor, watchdog,
+ * device identity loading, and heartbeat runner with configurable monitoring
+ * sources.
+ * Extracted from daemon.ts steps 5 through 6.7 to isolate process lifecycle
+ * and monitoring concerns from the main startup sequence.
+ * @module
+ */
+import { loadOrCreateDeviceIdentity } from "../device/device-identity.js";
+import { createHeartbeatRunner, createDuplicateDetector, deliverHeartbeatNotification, } from "@comis/scheduler";
+import { createDiskSpaceSource, createSystemResourcesSource, createSystemdServiceSource, createSecurityUpdateSource, createGitWatcherSource, } from "../monitoring/index.js";
+// ---------------------------------------------------------------------------
+// Setup function
+// ---------------------------------------------------------------------------
+/**
+ * Create and start the process monitor, start the systemd watchdog,
+ * and load or create the device identity.
+ * @param deps.container - Bootstrap output (config, event bus)
+ * @param deps.logger - Root tracing logger (for identity load warnings)
+ * @param deps._createProcessMonitor - Factory (overridable for tests)
+ * @param deps._startWatchdog - Factory (overridable for tests)
+ */
+export function setupHealth(deps) {
+    const { container, daemonLogger, _createProcessMonitor, _startWatchdog } = deps;
+    // 5. Create and start process monitor
+    const processMonitor = _createProcessMonitor({ eventBus: container.eventBus });
+    processMonitor.start();
+    // 6. Start watchdog (gracefully degrades to no-op on macOS)
+    const watchdogHandle = _startWatchdog({
+        logger: daemonLogger,
+        processMonitor,
+    });
+    // 6.4.5. Load or create device identity (optional -- warn but continue on failure)
+    let deviceIdentity;
+    const stateDir = container.config.dataDir || ".";
+    {
+        const identityResult = loadOrCreateDeviceIdentity(stateDir);
+        if (identityResult.ok) {
+            deviceIdentity = identityResult.value;
+            daemonLogger.info({ deviceId: deviceIdentity.deviceId }, "Device identity loaded");
+        }
+        else {
+            daemonLogger.warn({ err: identityResult.error.message, hint: "Check file permissions in data directory", errorKind: "internal" }, "Device identity not available (non-fatal)");
+        }
+    }
+    return {
+        processMonitor,
+        watchdogHandle,
+        deviceIdentity,
+    };
+}
+// ---------------------------------------------------------------------------
+// Setup function
+// ---------------------------------------------------------------------------
+/**
+ * Create monitoring heartbeat sources and runner based on config toggles.
+ * Synchronous setup -- creates sources array, builds runner if any are
+ * enabled, starts the runner, and returns the handle.
+ * @param deps - Monitoring dependencies
+ */
+export function setupMonitoring(deps) {
+    const { container, schedulerLogger, logger, adaptersByType } = deps;
+    let heartbeatRunner;
+    const monitoringConfig = container.config.monitoring;
+    const schedulerConfig = container.config.scheduler;
+    const monitoringSources = [];
+    // Create shared duplicate detector for 24h dedup
+    const duplicateDetector = createDuplicateDetector();
+    if (monitoringConfig.disk.enabled) {
+        monitoringSources.push(createDiskSpaceSource(monitoringConfig.disk));
+    }
+    if (monitoringConfig.resources.enabled) {
+        monitoringSources.push(createSystemResourcesSource(monitoringConfig.resources));
+    }
+    if (monitoringConfig.systemd.enabled) {
+        monitoringSources.push(createSystemdServiceSource(monitoringConfig.systemd));
+    }
+    if (monitoringConfig.securityUpdates.enabled) {
+        monitoringSources.push(createSecurityUpdateSource(monitoringConfig.securityUpdates));
+    }
+    if (monitoringConfig.git.enabled) {
+        monitoringSources.push(createGitWatcherSource(monitoringConfig.git));
+    }
+    if (monitoringSources.length > 0) {
+        heartbeatRunner = createHeartbeatRunner({
+            sources: monitoringSources,
+            eventBus: container.eventBus,
+            logger: schedulerLogger,
+            config: {
+                intervalMs: schedulerConfig.heartbeat.intervalMs,
+                showOk: schedulerConfig.heartbeat.showOk,
+                showAlerts: schedulerConfig.heartbeat.showAlerts,
+            },
+            quietHoursConfig: schedulerConfig.quietHours,
+            criticalBypass: schedulerConfig.quietHours.criticalBypass,
+            onNotification: (notification) => {
+                const msg = `Monitoring: ${notification.text}`;
+                if (notification.level === "critical") {
+                    logger.error({ sourceId: notification.sourceId, level: notification.level, hint: "Investigate the monitoring source for critical conditions", errorKind: "resource" }, msg);
+                }
+                else if (notification.level === "alert") {
+                    logger.warn({ sourceId: notification.sourceId, level: notification.level, hint: "Review the monitoring source alert details", errorKind: "resource" }, msg);
+                }
+                else {
+                    logger.info({ sourceId: notification.sourceId, level: notification.level }, msg);
+                }
+                // Deliver to configured target channel (fire-and-forget)
+                // Global heartbeat uses scheduler.heartbeat config -- per-agent delivery targets are wired in
+                if (adaptersByType && adaptersByType.size > 0) {
+                    const globalTarget = resolveGlobalDeliveryTarget(container.config);
+                    if (globalTarget) {
+                        void deliverHeartbeatNotification({ adaptersByType, duplicateDetector, eventBus: container.eventBus, logger: schedulerLogger }, globalTarget, notification, { agentId: "system" }).catch((err) => {
+                            const errMsg = err instanceof Error ? err.message : String(err);
+                            schedulerLogger.warn({ err: errMsg, hint: "Heartbeat delivery failed unexpectedly", errorKind: "internal" }, "Heartbeat delivery error");
+                        });
+                    }
+                }
+            },
+        });
+        heartbeatRunner.start();
+        schedulerLogger.info({ sourceCount: monitoringSources.length }, "Monitoring heartbeat runner started");
+    }
+    return { heartbeatRunner, duplicateDetector };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/**
+ * Resolve global heartbeat delivery target from config.
+ * Currently returns undefined -- global system monitoring does not have a
+ * delivery target. Per-agent delivery is handled by PerAgentHeartbeatRunner
+ * This function exists so that adding a global delivery target
+ * in a future phase is a one-line change.
+ */
+function resolveGlobalDeliveryTarget(_config) {
+    return undefined;
+}

package/node_modules/@comis/daemon/dist/wiring/setup-heartbeat.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Heartbeat wiring: creates PerAgentHeartbeatRunner with AgentHeartbeatSource
+ * as its onTick callback for LLM-driven per-agent heartbeat turns.
+ * Extracted from daemon.ts step 6.7.0.0 to isolate per-agent heartbeat
+ * initialization from the main wiring sequence.
+ * Agent Heartbeat Source
+ * @module
+ */
+import type { AppContainer, ChannelPort } from "@comis/core";
+import type { ComisLogger } from "@comis/infra";
+import { type PerAgentHeartbeatRunner, type DuplicateDetector, type SystemEventQueue } from "@comis/scheduler";
+/** Minimal ActiveRunRegistry -- only needs has() for queue-busy check. */
+interface HeartbeatActiveRunRegistry {
+    has(sessionKey: string): boolean;
+}
+/** 8-param executor interface matching AgentExecutor.execute (used in deps map). */
+interface InnerExecutor {
+    execute(msg: unknown, sessionKey: unknown, tools?: unknown[], onDelta?: unknown, agentId?: string, directives?: unknown, prevTimestamp?: number, overrides?: unknown): Promise<{
+        response: string;
+    }>;
+}
+/** Dependencies for per-agent heartbeat setup. */
+export interface HeartbeatSetupDeps {
+    /** Bootstrap output (config.agents, config.scheduler, eventBus). */
+    container: AppContainer;
+    /** Per-agent executors map (8-param AgentExecutor instances). */
+    executors: Map<string, InnerExecutor>;
+    /** Tool pipeline assembler for an agent. */
+    assembleToolsForAgent: (agentId: string) => Promise<unknown[]>;
+    /** Per-agent workspace directories. */
+    workspaceDirs: Map<string, string>;
+    /** Active run registry for queue-busy detection (optional). */
+    activeRunRegistry?: HeartbeatActiveRunRegistry;
+    /** Duplicate detector shared between global and per-agent heartbeat delivery. */
+    duplicateDetector?: DuplicateDetector;
+    /** Channel adapters for heartbeat delivery (optional). */
+    adaptersByType?: ReadonlyMap<string, ChannelPort>;
+    /** System event queue for trigger resolution. */
+    systemEventQueue: SystemEventQueue;
+    /** Memory API for fetching memory stats (optional, for heartbeat prompt injection). */
+    memoryApi?: {
+        stats: (tenantId?: string, agentId?: string) => {
+            totalEntries: number;
+            oldestCreatedAt: number | null;
+        };
+    };
+    /** Module-bound logger for scheduler subsystem. */
+    schedulerLogger: ComisLogger;
+}
+/** All services produced by the per-agent heartbeat setup phase. */
+export interface HeartbeatSetupResult {
+    /** Per-agent heartbeat runner for shutdown cleanup (optional). */
+    perAgentRunner?: PerAgentHeartbeatRunner;
+}
+/**
+ * Create per-agent heartbeat runner with AgentHeartbeatSource as its
+ * onTick callback for LLM-driven heartbeat turns.
+ * Synchronous agent filtering, async file gate closure. Returns the
+ * runner handle for shutdown registration.
+ * @param deps - Per-agent heartbeat dependencies
+ */
+export declare function setupHeartbeat(deps: HeartbeatSetupDeps): HeartbeatSetupResult;
+export {};

package/node_modules/@comis/daemon/dist/wiring/setup-heartbeat.js

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Heartbeat wiring: creates PerAgentHeartbeatRunner with AgentHeartbeatSource
+ * as its onTick callback for LLM-driven per-agent heartbeat turns.
+ * Extracted from daemon.ts step 6.7.0.0 to isolate per-agent heartbeat
+ * initialization from the main wiring sequence.
+ * Agent Heartbeat Source
+ * @module
+ */
+import { readFile } from "node:fs/promises";
+import { safePath } from "@comis/core";
+import { isHeartbeatContentEffectivelyEmpty } from "@comis/agent";
+import { resolveEffectiveHeartbeatConfig, createAgentHeartbeatSource, createPerAgentHeartbeatRunner, createDuplicateDetector, } from "@comis/scheduler";
+// ---------------------------------------------------------------------------
+// Setup function
+// ---------------------------------------------------------------------------
+/**
+ * Create per-agent heartbeat runner with AgentHeartbeatSource as its
+ * onTick callback for LLM-driven heartbeat turns.
+ * Synchronous agent filtering, async file gate closure. Returns the
+ * runner handle for shutdown registration.
+ * @param deps - Per-agent heartbeat dependencies
+ */
+export function setupHeartbeat(deps) {
+    const { container, executors, assembleToolsForAgent, workspaceDirs, activeRunRegistry, duplicateDetector, adaptersByType, systemEventQueue, memoryApi, schedulerLogger, } = deps;
+    const agents = container.config.agents;
+    const globalHeartbeat = container.config.scheduler.heartbeat;
+    // 1. Build per-agent state map (only heartbeat-enabled agents)
+    const agentStates = new Map();
+    for (const [agentId, agentConfig] of Object.entries(agents)) {
+        const effectiveConfig = resolveEffectiveHeartbeatConfig(globalHeartbeat, agentConfig.scheduler?.heartbeat);
+        if (!effectiveConfig.enabled) {
+            continue;
+        }
+        agentStates.set(agentId, {
+            agentId,
+            config: effectiveConfig,
+            lastRunMs: 0,
+            nextDueMs: 0,
+            consecutiveErrors: 0,
+            backoffUntilMs: 0,
+            tickStartedAtMs: 0,
+            lastAlertMs: 0,
+            lastErrorKind: null,
+        });
+    }
+    // 2. No agents have heartbeat enabled -> nothing to wire
+    if (agentStates.size === 0) {
+        return { perAgentRunner: undefined };
+    }
+    // 3. File gate closure: check HEARTBEAT.md content for empty-file gate
+    async function checkFileGate(agentId) {
+        const workspaceDir = workspaceDirs.get(agentId);
+        if (!workspaceDir)
+            return false; // no workspace = don't skip
+        try {
+            const filePath = safePath(workspaceDir, "HEARTBEAT.md");
+            const content = await readFile(filePath, "utf-8");
+            return isHeartbeatContentEffectivelyEmpty(content);
+        }
+        catch {
+            return false; // missing file = don't skip
+        }
+    }
+    // 3.5 Memory stats getter for heartbeat prompt injection
+    const getMemoryStats = memoryApi
+        ? (agentId, tenantId) => {
+            const stats = memoryApi.stats(tenantId, agentId);
+            if (stats.totalEntries === 0 || stats.oldestCreatedAt === null)
+                return undefined;
+            const ageDays = Math.floor((Date.now() - stats.oldestCreatedAt) / 86_400_000);
+            return { totalEntries: stats.totalEntries, oldestEntryAgeDays: ageDays };
+        }
+        : undefined;
+    // 4. Build AgentHeartbeatSource dependencies
+    const source = createAgentHeartbeatSource({
+        getExecutor: (agentId) => {
+            const inner = executors.get(agentId);
+            return {
+                execute: (msg, sessionKey, tools, hbAgentId, overrides) => inner.execute(msg, sessionKey, tools, undefined, hbAgentId, undefined, undefined, overrides),
+            };
+        },
+        assembleToolsForAgent,
+        getEffectiveConfig: (agentId) => resolveEffectiveHeartbeatConfig(globalHeartbeat, agents[agentId].scheduler?.heartbeat),
+        getAgentConfig: (agentId) => ({
+            model: agents[agentId].model,
+            tenantId: container.config.tenantId,
+        }),
+        checkFileGate,
+        systemEventQueue,
+        deliveryBridge: {
+            adaptersByType: adaptersByType ?? new Map(),
+            duplicateDetector: duplicateDetector ?? createDuplicateDetector(),
+            eventBus: container.eventBus,
+            logger: schedulerLogger,
+        },
+        activeRunRegistry,
+        getMemoryStats,
+        logger: schedulerLogger,
+    });
+    // 5. Create and start the per-agent runner
+    const runner = createPerAgentHeartbeatRunner({
+        agents: agentStates,
+        eventBus: container.eventBus,
+        logger: schedulerLogger,
+        onTick: source.onTick,
+    });
+    runner.start();
+    schedulerLogger.info({ agentCount: agentStates.size }, "Per-agent heartbeat runner started");
+    return { perAgentRunner: runner };
+}

package/node_modules/@comis/daemon/dist/wiring/setup-logging.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Logging subsystem setup: file transport, tracing logger, log level
+ * manager, module-bound loggers, and daemon version detection.
+ * Extracted from daemon.ts steps 1.5 through 3.7 to isolate
+ * infrastructure concerns from the main wiring sequence.
+ * @module
+ */
+import type { AppContainer } from "@comis/core";
+import type { ComisLogger } from "@comis/infra";
+import type { createTracingLogger } from "../observability/trace-logger.js";
+import type { createLogLevelManager, LogLevelManager } from "../observability/log-infra.js";
+/** All services produced by the logging setup phase. */
+export interface LoggingResult {
+    logger: ComisLogger;
+    logLevelManager: LogLevelManager;
+    daemonLogger: ComisLogger;
+    gatewayLogger: ComisLogger;
+    channelsLogger: ComisLogger;
+    agentLogger: ComisLogger;
+    schedulerLogger: ComisLogger;
+    skillsLogger: ComisLogger;
+    memoryLogger: ComisLogger;
+    daemonVersion: string;
+}
+/**
+ * Create the full logging subsystem: tracing logger with optional file
+ * transport, per-module log level manager, six module-bound loggers,
+ * and daemon version string.
+ * @param deps.container  - Bootstrap output (config, event bus)
+ * @param deps._createTracingLogger - Factory (overridable for tests)
+ * @param deps._createLogLevelManager - Factory (overridable for tests)
+ */
+export declare function setupLogging(deps: {
+    container: AppContainer;
+    instanceId: string;
+    _createTracingLogger: typeof createTracingLogger;
+    _createLogLevelManager: typeof createLogLevelManager;
+}): LoggingResult;

package/node_modules/@comis/daemon/dist/wiring/setup-logging.js

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Logging subsystem setup: file transport, tracing logger, log level
+ * manager, module-bound loggers, and daemon version detection.
+ * Extracted from daemon.ts steps 1.5 through 3.7 to isolate
+ * infrastructure concerns from the main wiring sequence.
+ * @module
+ */
+import { createFileTransport, isPm2Managed } from "../observability/log-infra.js";
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+// ---------------------------------------------------------------------------
+// Setup function
+// ---------------------------------------------------------------------------
+/**
+ * Create the full logging subsystem: tracing logger with optional file
+ * transport, per-module log level manager, six module-bound loggers,
+ * and daemon version string.
+ * @param deps.container  - Bootstrap output (config, event bus)
+ * @param deps._createTracingLogger - Factory (overridable for tests)
+ * @param deps._createLogLevelManager - Factory (overridable for tests)
+ */
+export function setupLogging(deps) {
+    const { container, instanceId, _createTracingLogger, _createLogLevelManager } = deps;
+    // 1.5. Construct file transport from logging config
+    const loggingConfig = container.config.daemon?.logging;
+    const configLogLevel = container.config.logLevel ?? "info";
+    const fileTransport = loggingConfig ? createFileTransport(loggingConfig, configLogLevel) : undefined;
+    // 2. Create tracing logger (use config logLevel or default to "info")
+    const rawLogger = _createTracingLogger({
+        name: "comis-daemon",
+        level: configLogLevel,
+        ...(fileTransport ? { transport: fileTransport } : {}),
+    });
+    // Bind instanceId to root logger — all children inherit it
+    const logger = rawLogger.child({ instanceId });
+    // Log transport mode so operators can verify PM2-aware selection
+    const pm2Detected = isPm2Managed();
+    logger.debug({ pm2Detected, fileTransportEnabled: !!loggingConfig, stdoutEnabled: !pm2Detected }, "Log transport configured");
+    // 3. Create log level manager
+    const logLevelManager = _createLogLevelManager(logger);
+    // 3.5. Create module-bound loggers for each subsystem
+    const daemonLogger = logLevelManager.getLogger("daemon");
+    const gatewayLogger = logLevelManager.getLogger("gateway");
+    const channelsLogger = logLevelManager.getLogger("channels");
+    const agentLogger = logLevelManager.getLogger("agent");
+    const schedulerLogger = logLevelManager.getLogger("scheduler");
+    const skillsLogger = logLevelManager.getLogger("skills");
+    const memoryLogger = logLevelManager.getLogger("memory");
+    // 3.6. Read daemon version from package.json for startup banner
+    let daemonVersion = "unknown";
+    try {
+        const daemonDir = dirname(fileURLToPath(import.meta.url));
+        const pkgPath = resolve(daemonDir, "../../package.json");
+        const pkgJson = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        daemonVersion = pkgJson.version ?? "unknown";
+    }
+    catch (err) {
+        logger.warn({
+            err: err instanceof Error ? err.message : String(err),
+            hint: "Check that packages/daemon/package.json exists and is readable",
+            errorKind: "config",
+        }, "Failed to read daemon version from package.json");
+    }
+    return {
+        logger,
+        logLevelManager,
+        daemonLogger,
+        gatewayLogger,
+        channelsLogger,
+        agentLogger,
+        schedulerLogger,
+        skillsLogger,
+        memoryLogger,
+        daemonVersion,
+    };
+}

package/node_modules/@comis/daemon/dist/wiring/setup-mcp.d.ts

@@ -0,0 +1,47 @@
+/**
+ * MCP server connection setup: reads integrations.mcp.servers from config,
+ * creates an McpClientManager, and connects to each enabled server.
+ * Non-fatal: connection failures are logged as WARN and do not prevent
+ * daemon startup. Tools from successfully connected servers are still
+ * available to agents.
+ * @module
+ */
+import type { McpServerEntry, TypedEventBus } from "@comis/core";
+import type { ComisLogger } from "@comis/infra";
+import { type McpClientManager } from "@comis/skills";
+/** Dependencies for MCP server setup. */
+export interface McpDeps {
+    /** MCP server entries from config (integrations.mcp.servers). */
+    readonly servers: readonly McpServerEntry[];
+    /** Logger for MCP connection lifecycle. */
+    readonly logger: ComisLogger;
+    /** Timeout for individual MCP tool calls in milliseconds (default: 120000). */
+    readonly callToolTimeoutMs?: number;
+    /** Default working directory for stdio MCP servers (typically the workspace directory). Per-server cwd in config overrides this. */
+    readonly defaultCwd?: string;
+    /** EventBus for MCP connection lifecycle events. */
+    readonly eventBus?: TypedEventBus;
+    /** Default concurrent calls for stdio MCP servers (default: 1). */
+    readonly stdioDefaultConcurrency?: number;
+    /** Default concurrent calls for HTTP/SSE MCP servers (default: 4). */
+    readonly httpDefaultConcurrency?: number;
+}
+/** Result of MCP server setup. */
+export interface McpResult {
+    /**
+     * The MCP client manager. Always defined — created unconditionally so
+     * runtime `mcp.connect` RPCs work even when no servers were configured
+     * at startup. The factory (`createMcpClientManager`) is a pure in-memory
+     * state holder (Maps/Sets, no I/O), so constructing it is cheap and safe.
+     */
+    readonly mcpClientManager: McpClientManager;
+}
+/**
+ * Connect to configured MCP servers and return the client manager.
+ * The manager is always returned (never undefined) so that runtime
+ * `mcp.connect` / `.disconnect` / `.reconnect` / `.status` RPCs work
+ * even when zero servers were configured at startup. Individual server
+ * connection failures are logged but do not block the remaining servers
+ * or daemon startup.
+ */
+export declare function setupMcp(deps: McpDeps): Promise<McpResult>;