comisai 1.0.19 → 1.0.23

package/node_modules/@comis/daemon/dist/observability/obs-write-buffer.js

@@ -1,68 +0,0 @@
-/**
- * Generic batched write buffer for observability persistence.
- *
- * Sits between event bus listeners and ObservabilityStore: listeners push items
- * into the buffer; the buffer flushes batches to SQLite periodically or when
- * the buffer reaches its size threshold.
- *
- * Design:
- *  - Plain array (not ring buffer) per research recommendation
- *  - Dual trigger: size threshold (default 50) OR timer interval (default 500ms)
- *  - Timer uses unref() so it does not prevent Node.js process exit
- *  - drain() provides synchronous final flush for clean shutdown
- *  - flushFn is synchronous (better-sqlite3 db.transaction() is sync)
- *
- * @module obs-write-buffer
- */
-/**
- * Create a generic batched write buffer.
- *
- * Usage:
- * ```ts
- * const buf = createObsWriteBuffer<TokenUsageRow>({
- *   flushFn: (items) => store.insertTokenUsageBatch(items),
- *   maxSize: 50,
- *   intervalMs: 500,
- * });
- *
- * eventBus.on("token:usage", (entry) => buf.push(toRow(entry)));
- * // On shutdown:
- * buf.drain();
- * ```
- */
-export function createObsWriteBuffer(opts) {
-    const { flushFn, maxSize = 50, intervalMs = 500 } = opts;
-    let buffer = [];
-    // Start periodic flush timer. unref() ensures it does not keep the process alive.
-    const timer = setInterval(() => {
-        flush();
-    }, intervalMs);
-    timer.unref();
-    function flush() {
-        if (buffer.length === 0)
-            return;
-        // Swap-before-call: if flushFn throws, the batch is in the local variable,
-        // not lost back in the buffer. The caller of flushFn can decide recovery.
-        const batch = buffer;
-        buffer = [];
-        flushFn(batch);
-    }
-    function push(item) {
-        buffer.push(item);
-        if (buffer.length >= maxSize) {
-            flush();
-        }
-    }
-    function drain() {
-        clearInterval(timer);
-        flush();
-    }
-    return {
-        push,
-        flush,
-        drain,
-        get pending() {
-            return buffer.length;
-        },
-    };
-}

package/node_modules/@comis/daemon/dist/observability/types.d.ts

@@ -1,6 +0,0 @@
-import type { EventMap, EventHandler } from "@comis/core";
-/** Reference to a registered EventBus handler for cleanup. */
-export interface HandlerRef {
-    event: keyof EventMap;
-    handler: EventHandler<keyof EventMap>;
-}

package/node_modules/@comis/daemon/dist/observability/types.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,41 +0,0 @@
-/**
- * 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

@@ -1,84 +0,0 @@
-/**
- * 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");
-}

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

@@ -1,24 +0,0 @@
-/**
- * Delivery mirror wiring: adapter creation, hook-based recording, periodic prune.
- *
- * Phase 502: Session Mirroring.
- * @module
- */
-import type { AppConfig, DeliveryMirrorPort } from "@comis/core";
-import type { ComisLogger } from "@comis/infra";
-import type { PluginRegistry } from "@comis/core";
-export interface DeliveryMirrorResult {
-    /** The delivery mirror adapter (real or no-op), available immediately. */
-    deliveryMirror: DeliveryMirrorPort;
-    /** Starts the periodic prune timer. Call AFTER setupChannels. */
-    startPrune: () => void;
-    /** Clears the prune interval timer (call on shutdown). */
-    shutdown: () => void;
-}
-export declare function setupDeliveryMirror(deps: {
-    /** Raw better-sqlite3 database handle (typed as unknown to avoid cross-package type dep). */
-    db: unknown;
-    config: AppConfig;
-    pluginRegistry: PluginRegistry;
-    logger: ComisLogger;
-}): Promise<DeliveryMirrorResult>;

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

@@ -1,88 +0,0 @@
-/**
- * Delivery mirror wiring: adapter creation, hook-based recording, periodic prune.
- *
- * Phase 502: Session Mirroring.
- * @module
- */
-import { createNoOpDeliveryMirror } from "@comis/core";
-import { createSqliteDeliveryMirror } from "@comis/memory";
-import { ok } from "@comis/shared";
-import { createHash } from "node:crypto";
-// ---------------------------------------------------------------------------
-// Idempotency key computation
-// ---------------------------------------------------------------------------
-/**
- * Compute an idempotency key for a mirror entry.
- * Uses session key + text hash + 1-second time bucket to deduplicate
- * repeated deliveries of the same text within the same second.
- */
-function computeIdempotencyKey(sessionKey, text, timestamp) {
-    const textHash = createHash("sha256").update(text).digest("hex").slice(0, 16);
-    const bucket = Math.floor(timestamp / 1000);
-    return `${sessionKey}:${textHash}:${bucket}`;
-}
-// ---------------------------------------------------------------------------
-// Setup function
-// ---------------------------------------------------------------------------
-export async function setupDeliveryMirror(deps) {
-    const { db, config, pluginRegistry, logger } = deps;
-    const mirrorConfig = config.deliveryMirror;
-    // 1. No-op when disabled
-    if (!mirrorConfig?.enabled) {
-        logger.debug("Delivery mirror disabled by config");
-        return {
-            deliveryMirror: createNoOpDeliveryMirror(),
-            startPrune: () => { },
-            shutdown: () => { },
-        };
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- db is better-sqlite3 Database; typed as unknown to avoid cross-package type dependency
-    const deliveryMirror = createSqliteDeliveryMirror(db);
-    logger.info({ retentionMs: mirrorConfig.retentionMs, maxEntriesPerInjection: mirrorConfig.maxEntriesPerInjection, maxCharsPerInjection: mirrorConfig.maxCharsPerInjection }, "Delivery mirror enabled");
-    // 2. Hook registration: record delivered text via after_delivery hook
-    pluginRegistry.register({
-        id: "comis:delivery-mirror",
-        name: "Delivery Mirror",
-        version: "1.0.0",
-        register(api) {
-            api.registerHook("after_delivery", async (event, ctx) => {
-                if (!ctx.sessionKey)
-                    return; // No session context -- skip (Pitfall 1)
-                const now = Date.now();
-                const idempotencyKey = computeIdempotencyKey(ctx.sessionKey, event.text, now);
-                const result = await deliveryMirror.record({
-                    sessionKey: ctx.sessionKey,
-                    text: event.text,
-                    mediaUrls: [], // Phase 502 baseline -- HookAfterDeliveryEvent has no mediaUrls field; media URL mirroring deferred
-                    channelType: event.channelType,
-                    channelId: event.channelId,
-                    origin: event.origin,
-                    idempotencyKey,
-                });
-                if (result.ok) {
-                    logger.debug({ sessionKey: ctx.sessionKey, channelType: event.channelType, idempotencyKey }, "Mirror entry recorded");
-                }
-                // Recording failures are silently tolerated (fire-and-forget hook)
-            });
-            return ok(undefined);
-        },
-    });
-    // 3. Prune timer
-    let pruneInterval;
-    const startPrune = () => {
-        pruneInterval = setInterval(async () => {
-            const result = await deliveryMirror.pruneOld(mirrorConfig.retentionMs);
-            if (result.ok && result.value > 0) {
-                logger.debug({ pruned: result.value }, "Delivery mirror pruned");
-            }
-        }, mirrorConfig.pruneIntervalMs);
-        pruneInterval.unref();
-    };
-    const shutdown = () => {
-        if (pruneInterval) {
-            clearInterval(pruneInterval);
-            pruneInterval = undefined;
-        }
-    };
-    return { deliveryMirror, startPrune, shutdown };
-}

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

@@ -1,31 +0,0 @@
-/**
- * Delivery queue wiring: adapter creation, startup drain, periodic prune.
- *
- * Two-phase lifecycle resolves the circular dependency between the queue and
- * channel adapters:
- *   1. setupDeliveryQueue() creates the adapter immediately (before setupChannels).
- *   2. drainAndStartPrune() runs drain + starts prune timer AFTER setupChannels
- *      populates channelAdapters.
- *
- * Phase 499: Crash-Safe Delivery Queue.
- * @module
- */
-import type { AppConfig, TypedEventBus, DeliveryQueuePort } from "@comis/core";
-import { type DeliveryAdapter } from "@comis/channels";
-import type { ComisLogger } from "@comis/infra";
-export interface DeliveryQueueResult {
-    /** The delivery queue adapter (real or no-op), available immediately. */
-    deliveryQueue: DeliveryQueuePort;
-    /** Runs startup drain then starts periodic prune timer. Call AFTER setupChannels. */
-    drainAndStartPrune: () => Promise<void>;
-    /** Clears the prune interval timer (call on shutdown). */
-    shutdown: () => void;
-}
-export declare function setupDeliveryQueue(deps: {
-    /** Raw better-sqlite3 database handle (typed as unknown to avoid cross-package type dep). */
-    db: unknown;
-    config: AppConfig;
-    eventBus: TypedEventBus;
-    logger: ComisLogger;
-    channelAdapters: Map<string, DeliveryAdapter>;
-}): Promise<DeliveryQueueResult>;

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

@@ -1,132 +0,0 @@
-/**
- * Delivery queue wiring: adapter creation, startup drain, periodic prune.
- *
- * Two-phase lifecycle resolves the circular dependency between the queue and
- * channel adapters:
- *   1. setupDeliveryQueue() creates the adapter immediately (before setupChannels).
- *   2. drainAndStartPrune() runs drain + starts prune timer AFTER setupChannels
- *      populates channelAdapters.
- *
- * Phase 499: Crash-Safe Delivery Queue.
- * @module
- */
-import { createNoOpDeliveryQueue } from "@comis/core";
-import { createSqliteDeliveryQueue } from "@comis/memory";
-import { isPermanentError, computeQueueBackoff } from "@comis/channels";
-// ---------------------------------------------------------------------------
-// Setup function
-// ---------------------------------------------------------------------------
-export async function setupDeliveryQueue(deps) {
-    const { db, config, eventBus, logger, channelAdapters } = deps;
-    const queueConfig = config.deliveryQueue;
-    // 1. Adapter creation: no-op when disabled
-    if (!queueConfig.enabled) {
-        logger.debug("Delivery queue disabled by config");
-        return {
-            deliveryQueue: createNoOpDeliveryQueue(),
-            drainAndStartPrune: async () => { },
-            shutdown: () => { },
-        };
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- db is better-sqlite3 Database; typed as unknown to avoid cross-package type dependency
-    const deliveryQueue = createSqliteDeliveryQueue(db);
-    logger.info({ maxQueueDepth: queueConfig.maxQueueDepth, defaultMaxAttempts: queueConfig.defaultMaxAttempts }, "Delivery queue enabled");
-    let pruneInterval;
-    // 2. Startup drain + 3. Periodic prune (deferred until channelAdapters populated)
-    const drainAndStartPrune = async () => {
-        // --- Drain ---
-        if (queueConfig.drainOnStartup) {
-            await drainDeliveryQueue({
-                deliveryQueue,
-                channelAdapters,
-                eventBus,
-                logger,
-                drainBudgetMs: queueConfig.drainBudgetMs,
-                defaultMaxAttempts: queueConfig.defaultMaxAttempts,
-            });
-        }
-        // --- Prune timer ---
-        pruneInterval = setInterval(async () => {
-            const result = await deliveryQueue.pruneExpired();
-            if (result.ok && result.value > 0) {
-                logger.debug({ pruned: result.value }, "Delivery queue pruned");
-            }
-        }, queueConfig.pruneIntervalMs);
-        pruneInterval.unref();
-    };
-    const shutdown = () => {
-        if (pruneInterval) {
-            clearInterval(pruneInterval);
-            pruneInterval = undefined;
-        }
-    };
-    return { deliveryQueue, drainAndStartPrune, shutdown };
-}
-// ---------------------------------------------------------------------------
-// Drain implementation
-// ---------------------------------------------------------------------------
-async function drainDeliveryQueue(deps) {
-    const { deliveryQueue, channelAdapters, eventBus, logger, drainBudgetMs, defaultMaxAttempts } = deps;
-    const drainStart = Date.now();
-    const deadline = drainStart + drainBudgetMs;
-    const pendingResult = await deliveryQueue.pendingEntries();
-    if (!pendingResult.ok) {
-        logger.warn({ err: pendingResult.error, hint: "Could not fetch pending entries for drain cycle", errorKind: "internal" }, "Delivery queue drain: failed to fetch pending entries");
-        return;
-    }
-    const entries = pendingResult.value;
-    if (entries.length === 0) {
-        logger.debug("Delivery queue drain: no pending entries");
-        return;
-    }
-    let attempted = 0;
-    let delivered = 0;
-    let failed = 0;
-    for (const entry of entries) {
-        // Budget exhaustion check
-        if (Date.now() > deadline) {
-            logger.info({ budgetMs: drainBudgetMs, attempted, remaining: entries.length - attempted }, "Delivery queue drain: budget exhausted");
-            break;
-        }
-        attempted++;
-        const adapter = channelAdapters.get(entry.channelType);
-        if (!adapter) {
-            await deliveryQueue.fail(entry.id, `No adapter for channel type: ${entry.channelType}`);
-            failed++;
-            continue;
-        }
-        let options = {};
-        try {
-            options = JSON.parse(entry.optionsJson);
-        }
-        catch {
-            // Invalid JSON -- send without options
-        }
-        const sendResult = await adapter.sendMessage(entry.channelId, entry.text, options);
-        if (sendResult.ok) {
-            await deliveryQueue.ack(entry.id, sendResult.value);
-            delivered++;
-        }
-        else {
-            const errorMsg = sendResult.error.message;
-            if (isPermanentError(errorMsg) || entry.attemptCount >= (entry.maxAttempts || defaultMaxAttempts)) {
-                await deliveryQueue.fail(entry.id, errorMsg);
-                failed++;
-            }
-            else {
-                const nextRetryAt = Date.now() + computeQueueBackoff(entry.attemptCount);
-                await deliveryQueue.nack(entry.id, errorMsg, nextRetryAt);
-                failed++;
-            }
-        }
-    }
-    const durationMs = Date.now() - drainStart;
-    eventBus.emit("delivery:queue_drained", {
-        entriesAttempted: attempted,
-        entriesDelivered: delivered,
-        entriesFailed: failed,
-        durationMs,
-        timestamp: Date.now(),
-    });
-    logger.info({ entriesAttempted: attempted, entriesDelivered: delivered, entriesFailed: failed, durationMs }, "Delivery queue drained");
-}

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

@@ -1,38 +0,0 @@
-/**
- * Monitoring setup: heartbeat runner with configurable monitoring sources.
- *
- * Extracted from daemon.ts step 6.7 to isolate heartbeat/monitoring
- * initialization from the main wiring sequence.
- *
- * @module
- */
-import type { AppContainer, ChannelPort } from "@comis/core";
-import type { ComisLogger } from "@comis/infra";
-import { type HeartbeatRunner, type DuplicateDetector } from "@comis/scheduler";
-/** 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-monitoring.js

@@ -1,100 +0,0 @@
-/**
- * Monitoring setup: heartbeat runner with configurable monitoring sources.
- *
- * Extracted from daemon.ts step 6.7 to isolate heartbeat/monitoring
- * initialization from the main wiring sequence.
- *
- * @module
- */
-import { createHeartbeatRunner, createDuplicateDetector, deliverHeartbeatNotification, } from "@comis/scheduler";
-import { createDiskSpaceSource, createSystemResourcesSource, createSystemdServiceSource, createSecurityUpdateSource, createGitWatcherSource, } from "../monitoring/index.js";
-// ---------------------------------------------------------------------------
-// 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 (DLVR-07)
-    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 Phase 329.
-                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
- * (Phase 329). This function exists so that adding a global delivery target
- * in a future phase is a one-line change.
- */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-function resolveGlobalDeliveryTarget(_config) {
-    return undefined;
-}

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

@@ -1,34 +0,0 @@
-/**
- * RPC bridge setup: rpcCall outer wrapper with deferred dispatch wiring.
- *
- * Extracted from daemon.ts to isolate the rpcCall closure pattern (debug/error
- * logging, classifyRpcError) and the deferred rpcCallInner assignment. The
- * rpcCall function is needed by setupTools (early in the boot sequence), but
- * rpcCallInner depends on heartbeatRunner from setupMonitoring (later in the
- * sequence). This module encapsulates the deferred wiring via wireDispatch().
- *
- * @module
- */
-import type { ComisLogger } from "@comis/infra";
-import type { RpcCall } from "@comis/skills";
-import type { RpcDispatchDeps } from "../rpc/rpc-dispatch.js";
-/** All services produced by the RPC bridge setup phase. */
-export interface RpcBridgeResult {
-    /** The rpcCall function usable immediately (delegates to inner dispatch once wired). */
-    rpcCall: RpcCall;
-    /** Call after setupMonitoring to wire the real dispatch with all deps including heartbeatRunner. */
-    wireDispatch: (deps: RpcDispatchDeps) => void;
-}
-/**
- * Create the rpcCall wrapper and deferred dispatch mechanism.
- *
- * The returned rpcCall can be passed to setupTools immediately. After
- * setupMonitoring resolves the heartbeatRunner TDZ, call wireDispatch()
- * with the full RpcDispatchDeps to wire the real dispatch function.
- *
- * @param deps.gatewayLogger - Logger for RPC call tracing
- * @returns rpcCall function and wireDispatch callback
- */
-export declare function setupRpcBridge(deps: {
-    gatewayLogger: ComisLogger;
-}): RpcBridgeResult;