comisai 1.0.4

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

@@ -0,0 +1,149 @@
+/**
+ * DaemonContext: The full typed container of all wired daemon services.
+ * This interface describes every service, adapter, and resolver that the
+ * daemon's main() function creates during startup. Extraction functions
+ * in Phases 169-172 accept DaemonContext (or a partial subset) as input
+ * and return partial results that assemble into it.
+ * DaemonContext is the single source of truth for the daemon's wired
+ * dependency graph -- eliminating ad-hoc parameter lists and preventing
+ * circular imports between extraction modules.
+ * @module
+ */
+import type { AppContainer, ChannelPort, EmbeddingPort, TTSPort, VisionProvider } from "@comis/core";
+import type { ComisLogger } from "@comis/infra";
+import type { AgentExecutor, createCostTracker, createBudgetGuard, createStepCounter, createSessionLifecycle, SessionResetScheduler } from "@comis/agent";
+import type { SqliteMemoryAdapter, createSessionStore, createEmbeddingQueue, MemoryApi } from "@comis/memory";
+import type { HeartbeatRunner, CronScheduler, createExecutionTracker } from "@comis/scheduler";
+import type { GatewayServerHandle } from "@comis/gateway";
+import type { BrowserService, RpcCall, LinkRunner } from "@comis/skills";
+import type { ChannelManager } from "@comis/channels";
+import type { DeviceIdentity } from "@comis/core";
+import type { LogLevelManager } from "../observability/log-infra.js";
+import type { TokenTracker } from "../observability/token-tracker.js";
+import type { LatencyRecorder } from "../observability/latency-recorder.js";
+import type { DiagnosticCollector } from "../observability/diagnostic-collector.js";
+import type { BillingEstimator } from "../observability/billing-estimator.js";
+import type { ChannelActivityTracker } from "../observability/channel-activity-tracker.js";
+import type { DeliveryTracer } from "../observability/delivery-tracer.js";
+import type { ProcessMonitor } from "../process/process-monitor.js";
+import type { WatchdogHandle } from "../health/watchdog.js";
+import type { ShutdownHandle } from "../process/graceful-shutdown.js";
+import type { createCrossSessionSender } from "../cross-session-sender.js";
+import type { createSubAgentRunner } from "../sub-agent-runner.js";
+/**
+ * The full container of wired daemon services, passed between
+ * `wireXxx()` and `setupXxx()` functions during daemon decomposition.
+ * Each field corresponds to a local variable in the current daemon.ts
+ * main() function. As extraction progresses (Phases 169-173), setup
+ * functions will populate subsets of this context incrementally.
+ */
+export interface DaemonContext {
+    /** Bootstrap output: config, event bus, secret manager. */
+    container: AppContainer;
+    /** Startup instance UUID (first 8 chars). */
+    instanceId: string;
+    /** High-resolution startup timer (Date.now() at entry). */
+    startupStartMs: number;
+    /** Root tracing logger (structured JSON with AsyncLocalStorage context). */
+    logger: ComisLogger;
+    /** Per-module runtime log level control. */
+    logLevelManager: LogLevelManager;
+    /** Module-bound logger: gateway subsystem. */
+    gatewayLogger: ComisLogger;
+    /** Module-bound logger: channels subsystem. */
+    channelsLogger: ComisLogger;
+    /** Module-bound logger: agent subsystem. */
+    agentLogger: ComisLogger;
+    /** Module-bound logger: scheduler subsystem. */
+    schedulerLogger: ComisLogger;
+    /** Module-bound logger: skills subsystem. */
+    skillsLogger: ComisLogger;
+    /** Module-bound logger: memory subsystem. */
+    memoryLogger: ComisLogger;
+    /** Daemon package version string (from package.json). */
+    daemonVersion: string;
+    /** Token usage tracking across all agents. */
+    tokenTracker: TokenTracker;
+    /** Latency recording for timed operations. */
+    latencyRecorder: LatencyRecorder;
+    /** Shared cost tracker for cross-agent billing aggregation. */
+    sharedCostTracker: ReturnType<typeof createCostTracker>;
+    /** Diagnostic event collector. */
+    diagnosticCollector: DiagnosticCollector;
+    /** Billing estimation from cost data. */
+    billingEstimator: BillingEstimator;
+    /** Per-channel activity tracking. */
+    channelActivityTracker: ChannelActivityTracker;
+    /** End-to-end message delivery tracing. */
+    deliveryTracer: DeliveryTracer;
+    /** System resource monitoring (CPU, memory, event loop). */
+    processMonitor: ProcessMonitor;
+    /** Systemd watchdog health gating handle. */
+    watchdogHandle: WatchdogHandle;
+    /** Device identity for pairing (optional -- warn on failure). */
+    deviceIdentity?: DeviceIdentity;
+    /** Raw embedding provider (optional -- FTS5-only if unavailable). */
+    embeddingPort?: EmbeddingPort;
+    /** Cached embedding provider wrapper (optional). */
+    cachedPort?: EmbeddingPort;
+    /** SQLite memory adapter with FTS5 + vector search. */
+    memoryAdapter: SqliteMemoryAdapter;
+    /** Session persistence store. */
+    sessionStore: ReturnType<typeof createSessionStore>;
+    /** High-level memory query/store API. */
+    memoryApi: MemoryApi;
+    /** Background embedding queue for new entries (optional). */
+    embeddingQueue?: ReturnType<typeof createEmbeddingQueue>;
+    /** Shared session manager across all agents. */
+    sessionManager: ReturnType<typeof createSessionLifecycle>;
+    /** Per-agent executor instances keyed by agentId. */
+    executors: Map<string, AgentExecutor>;
+    /** Per-agent workspace directory paths. */
+    workspaceDirs: Map<string, string>;
+    /** Per-agent cost trackers. */
+    costTrackers: Map<string, ReturnType<typeof createCostTracker>>;
+    /** Per-agent budget guards. */
+    budgetGuards: Map<string, ReturnType<typeof createBudgetGuard>>;
+    /** Per-agent step counters. */
+    stepCounters: Map<string, ReturnType<typeof createStepCounter>>;
+    /** Default agent ID from routing config. */
+    defaultAgentId: string;
+    /** Default agent workspace directory path. */
+    defaultWorkspaceDir: string;
+    /** Per-agent cron schedulers. */
+    cronSchedulers: Map<string, CronScheduler>;
+    /** Per-agent execution history trackers. */
+    executionTrackers: Map<string, ReturnType<typeof createExecutionTracker>>;
+    /** Per-agent session reset schedulers. */
+    resetSchedulers: Map<string, SessionResetScheduler>;
+    /** Per-agent browser automation services. */
+    browserServices: Map<string, BrowserService>;
+    /** Channel adapters keyed by platform type (telegram, discord, etc.). */
+    adaptersByType: Map<string, ChannelPort>;
+    /** Text-to-speech adapter (optional). */
+    ttsAdapter?: TTSPort;
+    /** Vision provider registry keyed by provider name (optional). */
+    visionRegistry?: Map<string, VisionProvider>;
+    /** Link understanding pipeline runner. */
+    linkRunner: LinkRunner;
+    /** Cross-session message sender for agent-to-agent communication. */
+    crossSessionSender: ReturnType<typeof createCrossSessionSender>;
+    /** Sub-agent task runner for delegated execution. */
+    subAgentRunner: ReturnType<typeof createSubAgentRunner>;
+    /** In-process RPC dispatcher for platform tools. */
+    rpcCall: RpcCall;
+    /** Heartbeat runner for periodic health checks (optional). */
+    heartbeatRunner?: HeartbeatRunner;
+    /** Gateway HTTP/WebSocket server handle (optional). */
+    gatewayHandle?: GatewayServerHandle;
+    /** Graceful shutdown orchestrator. */
+    shutdownHandle: ShutdownHandle;
+    /** Channel lifecycle manager (optional). */
+    channelManager?: ChannelManager;
+    /** Resolve executor for an agent ID, falling back to default agent. */
+    getExecutor: (agentId: string) => AgentExecutor;
+    /** Resolve the CronScheduler for a given agent ID. */
+    getAgentCronScheduler: (agentId: string) => CronScheduler;
+    /** Resolve the BrowserService for a given agent ID. */
+    getAgentBrowserService: (agentId: string) => BrowserService;
+}

package/node_modules/@comis/daemon/dist/wiring/daemon-context.js

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * DaemonContext: The full typed container of all wired daemon services.
+ * This interface describes every service, adapter, and resolver that the
+ * daemon's main() function creates during startup. Extraction functions
+ * in Phases 169-172 accept DaemonContext (or a partial subset) as input
+ * and return partial results that assemble into it.
+ * DaemonContext is the single source of truth for the daemon's wired
+ * dependency graph -- eliminating ad-hoc parameter lists and preventing
+ * circular imports between extraction modules.
+ * @module
+ */
+export {};

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

@@ -0,0 +1,40 @@
+/**
+ * Shared helper utilities for daemon RPC handlers and wiring modules.
+ * Extracted from daemon.ts to enable independent imports during decomposition.
+ * @module
+ */
+import type { ChannelPort } from "@comis/core";
+/** Resolve a channel adapter by type, throwing if not found. */
+export declare function resolveAdapter(channelType: string, registry: Map<string, ChannelPort>): ChannelPort;
+/**
+ * Channel-scoped authorization: same-channel + admin bypass.
+ * Admin users can access any channel. Non-admin users can only
+ * operate on the channel they originated from.
+ */
+export declare function authorizeChannelAccess(originChannelId: string | undefined, targetChannelId: string, trustLevel: string | undefined): void;
+/**
+ * Build a CronSchedule from rpcCall params.
+ */
+export declare function buildCronSchedule(kind: string, params: Record<string, unknown>): {
+    kind: "cron";
+    expr: string;
+    tz: string | undefined;
+} | {
+    kind: "every";
+    everyMs: number;
+} | {
+    kind: "at";
+    at: string;
+};
+/**
+ * Guess MIME type from file extension (image files only).
+ */
+export declare function guessMimeFromExtension(filePath: string): string;
+/**
+ * Detect MIME type from base64-decoded buffer magic bytes.
+ */
+export declare function detectMimeFromMagicBytes(buffer: Buffer): string | undefined;
+/**
+ * Map audio MIME type to file extension.
+ */
+export declare function mimeToExtension(mimeType: string): string;

package/node_modules/@comis/daemon/dist/wiring/daemon-utils.js

@@ -0,0 +1,109 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Shared helper utilities for daemon RPC handlers and wiring modules.
+ * Extracted from daemon.ts to enable independent imports during decomposition.
+ * @module
+ */
+/** Resolve a channel adapter by type, throwing if not found. */
+export function resolveAdapter(channelType, registry) {
+    const adapter = registry.get(channelType);
+    if (!adapter) {
+        throw new Error(`No adapter found for channel type: ${channelType}. Available: ${Array.from(registry.keys()).join(", ") || "none"}`);
+    }
+    return adapter;
+}
+/**
+ * Channel-scoped authorization: same-channel + admin bypass.
+ * Admin users can access any channel. Non-admin users can only
+ * operate on the channel they originated from.
+ */
+export function authorizeChannelAccess(originChannelId, targetChannelId, trustLevel) {
+    // Admin can always access any channel
+    if (trustLevel === "admin")
+        return;
+    // Same-channel access is always allowed
+    if (originChannelId === targetChannelId)
+        return;
+    // If no origin context, allow (daemon-initiated operations like cron delivery)
+    if (!originChannelId)
+        return;
+    // Cross-channel access denied for non-admin
+    throw new Error(`Channel access denied: cannot operate on channel ${targetChannelId} from ${originChannelId}. Admin access required for cross-channel operations.`);
+}
+/**
+ * Build a CronSchedule from rpcCall params.
+ */
+export function buildCronSchedule(kind, params) {
+    switch (kind) {
+        case "cron":
+            return {
+                kind: "cron",
+                expr: params.schedule_expr,
+                tz: params.timezone,
+            };
+        case "every":
+            return { kind: "every", everyMs: params.schedule_every_ms };
+        case "at":
+            return { kind: "at", at: params.schedule_at };
+        default:
+            throw new Error(`Unknown schedule kind: ${kind}`);
+    }
+}
+/**
+ * Guess MIME type from file extension (image files only).
+ */
+export function guessMimeFromExtension(filePath) {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    const map = {
+        jpg: "image/jpeg",
+        jpeg: "image/jpeg",
+        png: "image/png",
+        gif: "image/gif",
+        webp: "image/webp",
+        svg: "image/svg+xml",
+        bmp: "image/bmp",
+        tiff: "image/tiff",
+        tif: "image/tiff",
+    };
+    return map[ext ?? ""] ?? "image/jpeg";
+}
+/**
+ * Detect MIME type from base64-decoded buffer magic bytes.
+ */
+export function detectMimeFromMagicBytes(buffer) {
+    if (buffer.length < 4)
+        return undefined;
+    // PNG: 89 50 4E 47
+    if (buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4e && buffer[3] === 0x47) {
+        return "image/png";
+    }
+    // JPEG: FF D8 FF
+    if (buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
+        return "image/jpeg";
+    }
+    // GIF: 47 49 46 38
+    if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x38) {
+        return "image/gif";
+    }
+    // WebP: 52 49 46 46 ... 57 45 42 50
+    if (buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46 &&
+        buffer.length >= 12 &&
+        buffer[8] === 0x57 && buffer[9] === 0x45 && buffer[10] === 0x42 && buffer[11] === 0x50) {
+        return "image/webp";
+    }
+    return undefined;
+}
+/**
+ * Map audio MIME type to file extension.
+ */
+export function mimeToExtension(mimeType) {
+    const map = {
+        "audio/mpeg": "mp3",
+        "audio/opus": "opus",
+        "audio/wav": "wav",
+        "audio/aac": "aac",
+        "audio/flac": "flac",
+        "audio/ogg": "ogg",
+    };
+    return map[mimeType] ?? "mp3";
+}

package/node_modules/@comis/daemon/dist/wiring/index.d.ts

@@ -0,0 +1,19 @@
+export type { DaemonContext } from "./daemon-context.js";
+export { resolveAdapter, authorizeChannelAccess, buildCronSchedule, guessMimeFromExtension, detectMimeFromMagicBytes, mimeToExtension, } from "./daemon-utils.js";
+export { setupLogging, type LoggingResult } from "./setup-logging.js";
+export { setupObservability, type ObservabilityResult } from "./setup-observability.js";
+export { setupHealth, type HealthResult, setupMonitoring, type MonitoringResult } from "./setup-health.js";
+export { setupMemory, type MemoryResult } from "./setup-memory.js";
+export { setupMedia, type MediaResult } from "./setup-media.js";
+export { setupCrossSession, type CrossSessionResult } from "./setup-cross-session.js";
+export { setupAgents, type AgentsResult } from "./setup-agents.js";
+export { setupSchedulers, type SchedulersResult, setupTaskExtraction, type TaskExtractionResult } from "./setup-schedulers.js";
+export { setupChannels, type ChannelsResult } from "./setup-channels.js";
+export { setupMcp, type McpResult } from "./setup-mcp.js";
+export { setupTools, type ToolsResult } from "./setup-tools.js";
+export { setupHeartbeat, type HeartbeatSetupDeps, type HeartbeatSetupResult } from "./setup-heartbeat.js";
+export { setupShutdown, type ShutdownResult } from "./setup-shutdown.js";
+export { setupGateway, type GatewayDeps, type GatewayResult, setupRpcBridge, type RpcBridgeResult } from "./setup-gateway.js";
+export { setupDeliveryQueue, type DeliveryQueueResult, setupDeliveryMirror, type DeliveryMirrorResult } from "./setup-delivery.js";
+export { setupNotifications, type NotificationContext } from "./setup-notifications.js";
+export { setupBackgroundTasks, type BackgroundTasksContext } from "./setup-background-tasks.js";

package/node_modules/@comis/daemon/dist/wiring/index.js

@@ -0,0 +1,18 @@
+export { resolveAdapter, authorizeChannelAccess, buildCronSchedule, guessMimeFromExtension, detectMimeFromMagicBytes, mimeToExtension, } from "./daemon-utils.js";
+export { setupLogging } from "./setup-logging.js";
+export { setupObservability } from "./setup-observability.js";
+export { setupHealth, setupMonitoring } from "./setup-health.js";
+export { setupMemory } from "./setup-memory.js";
+export { setupMedia } from "./setup-media.js";
+export { setupCrossSession } from "./setup-cross-session.js";
+export { setupAgents } from "./setup-agents.js";
+export { setupSchedulers, setupTaskExtraction } from "./setup-schedulers.js";
+export { setupChannels } from "./setup-channels.js";
+export { setupMcp } from "./setup-mcp.js";
+export { setupTools } from "./setup-tools.js";
+export { setupHeartbeat } from "./setup-heartbeat.js";
+export { setupShutdown } from "./setup-shutdown.js";
+export { setupGateway, setupRpcBridge } from "./setup-gateway.js";
+export { setupDeliveryQueue, setupDeliveryMirror } from "./setup-delivery.js";
+export { setupNotifications } from "./setup-notifications.js";
+export { setupBackgroundTasks } from "./setup-background-tasks.js";

package/node_modules/@comis/daemon/dist/wiring/restart-continuation.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Restart continuation: capture active sessions on shutdown, replay on startup.
+ * When the daemon shuts down via SIGUSR2 (config-change restart), recently-active
+ * sessions are written to a JSON file. On startup, synthetic inbound messages are
+ * injected for each record so the LLM auto-resumes in-progress conversations.
+ * @module
+ */
+import type { ComisLogger } from "@comis/infra";
+import type { McpConnection } from "@comis/skills";
+/** A single session to resume after daemon restart. */
+export interface ContinuationRecord {
+    agentId: string;
+    channelType: string;
+    channelId: string;
+    userId: string;
+    peerId?: string;
+    guildId?: string;
+    threadId?: string;
+    tenantId: string;
+    timestamp: number;
+}
+/** In-memory tracker for recently-active sessions. */
+export interface RestartContinuationTracker {
+    /** Upsert a session record (called after each successful inbound message). */
+    track(record: ContinuationRecord): void;
+    /** Check if a session has been active since the tracker was created. */
+    isTracked(record: Pick<ContinuationRecord, "channelType" | "channelId" | "userId" | "peerId">): boolean;
+    /** Write recent records to disk. Returns the count written. */
+    capture(filePath: string, recentWindowMs: number): number;
+}
+/**
+ * Create an in-memory tracker that stores the most recent activity per session.
+ * On shutdown, `capture()` writes records within the recent window to a JSON file.
+ */
+export declare function createRestartContinuationTracker(): RestartContinuationTracker;
+/**
+ * Load continuation records from disk, filter stale entries, delete the file.
+ * @param filePath - Path to the continuation JSON file.
+ * @param staleTtlMs - Maximum age in ms before a record is considered stale (default 5 min).
+ * @param logger - Logger for warnings on parse errors.
+ * @returns Non-stale continuation records (empty array if file missing or corrupt).
+ */
+export declare function loadContinuations(filePath: string, staleTtlMs: number, logger: ComisLogger): ContinuationRecord[];
+/**
+ * Build a one-line `[MCP Status]` summary for the synthetic restart message.
+ *
+ * Returns `undefined` when every connection is healthy so the happy path stays
+ * quiet. The agent LLM reads this line and self-corrects instead of claiming
+ * success for servers that never completed handshake after a config-change
+ * restart.
+ *
+ * Only `status === "error"` connections are reported. Transient states
+ * (`reconnecting`, `disconnected`) are already handled by the manager's
+ * reconnect loop and would spam the agent on normal network hiccups.
+ *
+ * @param connections - All known MCP connections (typically from `McpClientManager.getAllConnections()`).
+ * @returns A formatted status line, or `undefined` when no connections are errored.
+ */
+export declare function buildMcpStatusLine(connections: readonly McpConnection[]): string | undefined;

package/node_modules/@comis/daemon/dist/wiring/restart-continuation.js

@@ -0,0 +1,113 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Restart continuation: capture active sessions on shutdown, replay on startup.
+ * When the daemon shuts down via SIGUSR2 (config-change restart), recently-active
+ * sessions are written to a JSON file. On startup, synthetic inbound messages are
+ * injected for each record so the LLM auto-resumes in-progress conversations.
+ * @module
+ */
+import { writeFileSync, readFileSync, unlinkSync, existsSync } from "node:fs";
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+/**
+ * Create an in-memory tracker that stores the most recent activity per session.
+ * On shutdown, `capture()` writes records within the recent window to a JSON file.
+ */
+export function createRestartContinuationTracker() {
+    const records = new Map();
+    function makeKey(r) {
+        return `${r.channelType}:${r.channelId}:${r.userId}:${r.peerId ?? ""}`;
+    }
+    return {
+        track(record) {
+            records.set(makeKey(record), { ...record, timestamp: Date.now() });
+        },
+        isTracked(record) {
+            return records.has(makeKey(record));
+        },
+        capture(filePath, recentWindowMs) {
+            const now = Date.now();
+            const recent = Array.from(records.values()).filter((r) => now - r.timestamp < recentWindowMs);
+            if (recent.length === 0)
+                return 0;
+            writeFileSync(filePath, JSON.stringify(recent, null, 2), "utf-8");
+            return recent.length;
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Load + consume
+// ---------------------------------------------------------------------------
+/**
+ * Load continuation records from disk, filter stale entries, delete the file.
+ * @param filePath - Path to the continuation JSON file.
+ * @param staleTtlMs - Maximum age in ms before a record is considered stale (default 5 min).
+ * @param logger - Logger for warnings on parse errors.
+ * @returns Non-stale continuation records (empty array if file missing or corrupt).
+ */
+export function loadContinuations(filePath, staleTtlMs, logger) {
+    if (!existsSync(filePath))
+        return [];
+    try {
+        const raw = readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        unlinkSync(filePath);
+        const now = Date.now();
+        const valid = parsed.filter((r) => now - r.timestamp < staleTtlMs);
+        const discarded = parsed.length - valid.length;
+        if (discarded > 0) {
+            logger.debug({ discarded, total: parsed.length }, "Discarded stale continuation records");
+        }
+        return valid;
+    }
+    catch (err) {
+        logger.warn({
+            err,
+            filePath,
+            hint: "Continuation file may be corrupted; skipping replay",
+            errorKind: "internal",
+        }, "Failed to load continuation records");
+        try {
+            unlinkSync(filePath);
+        }
+        catch {
+            /* ignore cleanup failure */
+        }
+        return [];
+    }
+}
+// ---------------------------------------------------------------------------
+// MCP status line
+// ---------------------------------------------------------------------------
+const MCP_ERROR_TRUNCATE = 120;
+const MCP_MAX_NAMES = 5;
+/**
+ * Build a one-line `[MCP Status]` summary for the synthetic restart message.
+ *
+ * Returns `undefined` when every connection is healthy so the happy path stays
+ * quiet. The agent LLM reads this line and self-corrects instead of claiming
+ * success for servers that never completed handshake after a config-change
+ * restart.
+ *
+ * Only `status === "error"` connections are reported. Transient states
+ * (`reconnecting`, `disconnected`) are already handled by the manager's
+ * reconnect loop and would spam the agent on normal network hiccups.
+ *
+ * @param connections - All known MCP connections (typically from `McpClientManager.getAllConnections()`).
+ * @returns A formatted status line, or `undefined` when no connections are errored.
+ */
+export function buildMcpStatusLine(connections) {
+    const failed = connections.filter((c) => c.status === "error");
+    if (failed.length === 0)
+        return undefined;
+    const shown = failed.slice(0, MCP_MAX_NAMES).map((c) => {
+        const raw = (c.error ?? "").trim();
+        const msg = raw.length === 0 ? "unknown error" : raw;
+        const truncated = msg.length > MCP_ERROR_TRUNCATE ? `${msg.slice(0, MCP_ERROR_TRUNCATE)}…` : msg;
+        return `${c.name} (${truncated})`;
+    });
+    const overflow = failed.length - shown.length;
+    const suffix = overflow > 0 ? `, +${overflow} more` : "";
+    return `[MCP Status] ${failed.length} server(s) failed to connect: ${shown.join(", ")}${suffix}`;
+}

package/node_modules/@comis/daemon/dist/wiring/seed-bundled-skills.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Idempotent seeding of bundled skills from the repo's skills/ directory
+ * into the user data directory (~/.comis/skills/).
+ *
+ * On first startup, copies each skill directory that does not already exist
+ * in the target. Existing user skills are never overwritten.
+ *
+ * @module
+ */
+/** Minimal Pino-compatible logger for seeding diagnostics. */
+interface SeedLogger {
+    info(obj: Record<string, unknown>, msg: string): void;
+    debug(obj: Record<string, unknown>, msg: string): void;
+}
+/** Result of a seeding operation. */
+export interface SeedResult {
+    /** Skill directory names that were newly copied into targetDir. */
+    seeded: string[];
+    /** Skill directory names that already existed in targetDir and were skipped. */
+    skipped: string[];
+}
+/**
+ * Seed bundled skills from sourceDir into targetDir (idempotent).
+ *
+ * For each subdirectory in sourceDir, checks whether a same-named directory
+ * already exists in targetDir. If not, copies the entire directory tree
+ * recursively. Existing skill directories are never overwritten.
+ *
+ * @param opts.sourceDir - Absolute path to the repo's skills/ directory.
+ *                         If omitted, resolves from __dirname (../../../../skills).
+ * @param opts.targetDir - Absolute path to the user data skills directory
+ *                         (e.g., ~/.comis/skills/).
+ * @param opts.logger    - Optional structured logger for diagnostics.
+ * @returns SeedResult with seeded and skipped skill names.
+ */
+export declare function seedBundledSkills(opts: {
+    sourceDir?: string;
+    targetDir: string;
+    logger?: SeedLogger;
+}): SeedResult;
+export {};

package/node_modules/@comis/daemon/dist/wiring/seed-bundled-skills.js

@@ -0,0 +1,84 @@
+/**
+ * Idempotent seeding of bundled skills from the repo's skills/ directory
+ * into the user data directory (~/.comis/skills/).
+ *
+ * On first startup, copies each skill directory that does not already exist
+ * in the target. Existing user skills are never overwritten.
+ *
+ * @module
+ */
+import { existsSync, mkdirSync, readdirSync, cpSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Seed bundled skills from sourceDir into targetDir (idempotent).
+ *
+ * For each subdirectory in sourceDir, checks whether a same-named directory
+ * already exists in targetDir. If not, copies the entire directory tree
+ * recursively. Existing skill directories are never overwritten.
+ *
+ * @param opts.sourceDir - Absolute path to the repo's skills/ directory.
+ *                         If omitted, resolves from __dirname (../../../../skills).
+ * @param opts.targetDir - Absolute path to the user data skills directory
+ *                         (e.g., ~/.comis/skills/).
+ * @param opts.logger    - Optional structured logger for diagnostics.
+ * @returns SeedResult with seeded and skipped skill names.
+ */
+export function seedBundledSkills(opts) {
+    const seeded = [];
+    const skipped = [];
+    // Resolve source directory: either provided or derived from module location
+    const sourceDir = opts.sourceDir ?? resolveDefaultSourceDir();
+    // Handle missing source directory gracefully
+    if (!existsSync(sourceDir)) {
+        opts.logger?.debug({ sourceDir }, "Bundled skills source directory not found, skipping seed");
+        return { seeded, skipped };
+    }
+    // Ensure target directory exists
+    mkdirSync(opts.targetDir, { recursive: true });
+    // Enumerate skill directories in source
+    let entries;
+    try {
+        entries = readdirSync(sourceDir);
+    }
+    catch {
+        return { seeded, skipped };
+    }
+    for (const entry of entries) {
+        const srcPath = resolve(sourceDir, entry);
+        // Only process directories (skip files like README.md)
+        try {
+            if (!statSync(srcPath).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const destPath = resolve(opts.targetDir, entry);
+        if (existsSync(destPath)) {
+            skipped.push(entry);
+            opts.logger?.debug({ skill: entry }, "Bundled skill already exists in target, skipping");
+        }
+        else {
+            cpSync(srcPath, destPath, { recursive: true });
+            seeded.push(entry);
+            opts.logger?.debug({ skill: entry }, "Bundled skill seeded into target");
+        }
+    }
+    if (seeded.length > 0 || skipped.length > 0) {
+        opts.logger?.info({ seeded: seeded.length, skipped: skipped.length }, "Bundled skills seeded");
+    }
+    return { seeded, skipped };
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/**
+ * Resolve the default bundled skills source directory relative to this module.
+ * From packages/daemon/dist/wiring/ -> repo root skills/
+ */
+function resolveDefaultSourceDir() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = resolve(__filename, "..");
+    return resolve(__dirname, "../../../../skills");
+}