comisai 1.0.19 → 1.0.22

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;

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

@@ -1,52 +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 { createRpcDispatch, classifyRpcError } from "../rpc/rpc-dispatch.js";
-// ---------------------------------------------------------------------------
-// Setup function
-// ---------------------------------------------------------------------------
-/**
- * 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 function setupRpcBridge(deps) {
-    const { gatewayLogger } = deps;
-    // Deferred inner dispatch — assigned by wireDispatch() after all deps are ready
-    let rpcCallInner;
-    const rpcCall = async (method, params) => {
-        const rpcStartMs = Date.now();
-        try {
-            return await rpcCallInner(method, params);
-        }
-        catch (err) {
-            const errMsg = err instanceof Error ? err.message : String(err);
-            const classified = classifyRpcError(errMsg);
-            gatewayLogger.debug({
-                method,
-                err: errMsg,
-                durationMs: Date.now() - rpcStartMs,
-                hint: classified.hint,
-                errorKind: classified.errorKind,
-            }, "[rpcCall] failed");
-            throw err;
-        }
-    };
-    const wireDispatch = (dispatchDeps) => {
-        rpcCallInner = createRpcDispatch(dispatchDeps);
-    };
-    return { rpcCall, wireDispatch };
-}

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

@@ -1,41 +0,0 @@
-/**
- * Task extraction setup: per-agent task extractors with pluggable LLM extraction.
- *
- * Extracted as a wiring module following setup-monitoring.ts pattern.
- * Task extraction runs AFTER successful agent execution, extracting
- * commitments and follow-ups from conversation text.
- *
- * Feature-gated: config.scheduler.tasks.enabled (default: false).
- *
- * @module
- */
-import type { AppContainer } from "@comis/core";
-import type { ComisLogger } from "@comis/infra";
-import { type TaskExtractor } from "@comis/scheduler";
-/** Dependencies for task extraction setup. */
-export interface TaskExtractionDeps {
-    /** Bootstrap output (config.scheduler.tasks, eventBus). */
-    container: AppContainer;
-    /** Per-agent workspace directories (from setupAgents result). */
-    workspaceDirs: Map<string, string>;
-    /** Module-bound logger for scheduler subsystem. */
-    schedulerLogger: ComisLogger;
-}
-/** All services produced by the task extraction setup phase. */
-export interface TaskExtractionResult {
-    /** Per-agent task extractors (only for agents with tasks enabled). */
-    taskExtractors: Map<string, TaskExtractor>;
-    /**
-     * Callback for the execution pipeline. If task extraction is disabled
-     * for the given agent (or globally), this is a no-op.
-     */
-    extractFromConversation: (conversationText: string, sessionKey: string, agentId: string) => Promise<void>;
-}
-/**
- * Create per-agent task extractors and return an extraction callback
- * for the execution pipeline.
- *
- * The extraction callback is safe to call unconditionally -- it checks
- * the feature gate internally and returns immediately if disabled.
- */
-export declare function setupTaskExtraction(deps: TaskExtractionDeps): TaskExtractionResult;

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

@@ -1,86 +0,0 @@
-/**
- * Task extraction setup: per-agent task extractors with pluggable LLM extraction.
- *
- * Extracted as a wiring module following setup-monitoring.ts pattern.
- * Task extraction runs AFTER successful agent execution, extracting
- * commitments and follow-ups from conversation text.
- *
- * Feature-gated: config.scheduler.tasks.enabled (default: false).
- *
- * @module
- */
-import { safePath } from "@comis/core";
-import { createTaskExtractor, createTaskStore, } from "@comis/scheduler";
-// ---------------------------------------------------------------------------
-// Setup function
-// ---------------------------------------------------------------------------
-/**
- * Create per-agent task extractors and return an extraction callback
- * for the execution pipeline.
- *
- * The extraction callback is safe to call unconditionally -- it checks
- * the feature gate internally and returns immediately if disabled.
- */
-export function setupTaskExtraction(deps) {
-    const { container, workspaceDirs, schedulerLogger } = deps;
-    const tasksConfig = container.config.scheduler.tasks;
-    const agents = container.config.agents;
-    const taskExtractors = new Map();
-    if (!tasksConfig.enabled) {
-        schedulerLogger.debug("Task extraction disabled globally");
-        return {
-            taskExtractors,
-            extractFromConversation: async () => { },
-        };
-    }
-    for (const [agentId] of Object.entries(agents)) {
-        const agentWorkspace = workspaceDirs.get(agentId);
-        if (!agentWorkspace)
-            continue;
-        const storePath = safePath(agentWorkspace, ".scheduler", "tasks.json");
-        const store = createTaskStore(storePath);
-        // Pluggable extraction function -- in production this would wrap an LLM call.
-        // For now, create a placeholder that returns empty tasks. The daemon can
-        // override this with a real LLM-based extraction when the agent executor
-        // integration is fully wired (Phase TBD).
-        const extractFn = async () => {
-            // TODO: Wire to agent executor LLM call for real extraction
-            return { tasks: [], reasoning: "Extraction function not yet wired to LLM" };
-        };
-        const extractor = createTaskExtractor({
-            extractFn,
-            store,
-            logger: schedulerLogger.child({ agentId, component: "task-extractor" }),
-            config: {
-                enabled: tasksConfig.enabled,
-                confidenceThreshold: tasksConfig.confidenceThreshold,
-            },
-            eventBus: container.eventBus,
-        });
-        taskExtractors.set(agentId, extractor);
-        schedulerLogger.debug({ agentId }, "Task extractor created");
-    }
-    if (taskExtractors.size > 0) {
-        schedulerLogger.info({ extractorCount: taskExtractors.size }, "Task extraction enabled for agents");
-    }
-    async function extractFromConversation(conversationText, sessionKey, agentId) {
-        const extractor = taskExtractors.get(agentId);
-        if (!extractor)
-            return;
-        try {
-            const tasks = await extractor.extract(conversationText, sessionKey);
-            if (tasks.length > 0) {
-                schedulerLogger.info({ agentId, taskCount: tasks.length, sessionKey }, "Tasks extracted from conversation");
-            }
-        }
-        catch (err) {
-            schedulerLogger.warn({
-                agentId,
-                err: err instanceof Error ? err.message : String(err),
-                hint: "Task extraction failed but does not block message processing",
-                errorKind: "internal",
-            }, "Task extraction error");
-        }
-    }
-    return { taskExtractors, extractFromConversation };
-}

package/node_modules/@comis/memory/dist/embedding-cache.d.ts

@@ -1,36 +0,0 @@
-/**
- * Cached embedding port decorator (MEM-07).
- *
- * Wraps any EmbeddingPort with an LRU cache keyed by SHA-256 content
- * hashes. Previously-seen text returns immediately without calling
- * the inner provider. embedBatch splits texts into cache hits and
- * misses, only calling the inner provider for misses.
- */
-import type { EmbeddingPort } from "@comis/core";
-export interface EmbeddingCacheOptions {
-    /** Maximum number of cached embeddings. Default: 10_000 */
-    maxEntries: number;
-    /** TTL in milliseconds. Default: undefined (no TTL, LRU only).
-     *  Recommended: 86_400_000 (24 hours) for long-running daemons. */
-    ttlMs?: number;
-}
-/** Snapshot of embedding cache statistics (Phase 511). */
-export interface EmbeddingCacheStats {
-    entries: number;
-    maxEntries: number;
-    hitRate: number;
-    hits: number;
-    misses: number;
-    provider: string;
-}
-/**
- * Create a cached EmbeddingPort decorator that wraps the given inner
- * provider with an LRU content-hash cache.
- *
- * @param inner - The underlying EmbeddingPort to delegate cache misses to
- * @param options - Cache configuration (maxEntries)
- * @returns An EmbeddingPort with transparent caching
- */
-export declare function createCachedEmbeddingPort(inner: EmbeddingPort, options: EmbeddingCacheOptions): EmbeddingPort & {
-    getCacheStats(): EmbeddingCacheStats;
-};

package/node_modules/@comis/memory/dist/embedding-cache.js

@@ -1,94 +0,0 @@
-/**
- * Cached embedding port decorator (MEM-07).
- *
- * Wraps any EmbeddingPort with an LRU cache keyed by SHA-256 content
- * hashes. Previously-seen text returns immediately without calling
- * the inner provider. embedBatch splits texts into cache hits and
- * misses, only calling the inner provider for misses.
- */
-import { ok } from "@comis/shared";
-import { createHash } from "node:crypto";
-import { LRUCache } from "lru-cache";
-/**
- * Create a cached EmbeddingPort decorator that wraps the given inner
- * provider with an LRU content-hash cache.
- *
- * @param inner - The underlying EmbeddingPort to delegate cache misses to
- * @param options - Cache configuration (maxEntries)
- * @returns An EmbeddingPort with transparent caching
- */
-export function createCachedEmbeddingPort(inner, options) {
-    const cache = new LRUCache({
-        max: options.maxEntries,
-        ...(options.ttlMs ? { ttl: options.ttlMs } : {}),
-    });
-    let hits = 0;
-    let misses = 0;
-    function hashText(text) {
-        return createHash("sha256").update(text).digest("hex");
-    }
-    return {
-        provider: inner.provider,
-        dimensions: inner.dimensions,
-        modelId: inner.modelId,
-        async embed(text) {
-            const key = hashText(text);
-            const cached = cache.get(key);
-            if (cached) {
-                hits++;
-                return ok(cached);
-            }
-            misses++;
-            const result = await inner.embed(text);
-            if (result.ok)
-                cache.set(key, result.value);
-            return result;
-        },
-        async embedBatch(texts) {
-            // Split into hits and misses
-            const results = [];
-            const missIndices = [];
-            const missTexts = [];
-            for (let i = 0; i < texts.length; i++) {
-                const key = hashText(texts[i]);
-                const cached = cache.get(key);
-                if (cached) {
-                    hits++;
-                    results.push(cached);
-                }
-                else {
-                    misses++;
-                    results.push(null);
-                    missIndices.push(i);
-                    missTexts.push(texts[i]);
-                }
-            }
-            // If all cached, return immediately
-            if (missTexts.length === 0) {
-                return ok(results);
-            }
-            // Embed misses in a single batch
-            const batchResult = await inner.embedBatch(missTexts);
-            if (!batchResult.ok)
-                return batchResult;
-            // Merge: fill in misses and cache them
-            for (let j = 0; j < missIndices.length; j++) {
-                const idx = missIndices[j];
-                results[idx] = batchResult.value[j];
-                cache.set(hashText(missTexts[j]), batchResult.value[j]);
-            }
-            return ok(results);
-        },
-        getCacheStats() {
-            const total = hits + misses;
-            return {
-                entries: cache.size,
-                maxEntries: cache.max,
-                hitRate: total > 0 ? hits / total : 0,
-                hits,
-                misses,
-                provider: inner.provider,
-            };
-        },
-    };
-}

package/node_modules/@comis/skills/dist/bridge/tool-output-schemas.d.ts

@@ -1,17 +0,0 @@
-/**
- * Per-tool output schemas (Phase 568: SCHEMA-01 through SCHEMA-05).
- *
- * Registers outputSchema for 6 priority tools to describe their actual output
- * format. Schemas are informational only -- delivered to the LLM via JIT guide
- * injection to help predict result structure. Never validated at runtime.
- *
- * - grep, find: Text output (type: "string") -- NOT JSON
- * - exec, memory_search, web_search, sessions_list: JSON output (type: "object")
- *
- * Import this module for side effects only -- it runs registerToolMetadata()
- * calls at module scope. Imported from tool-bridge.ts to ensure schemas are
- * registered before assembleToolPipeline() runs.
- *
- * @module
- */
-export {};