comisai 1.0.36 → 1.0.40

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

@@ -0,0 +1,361 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Cron-delivery event listener registration. Hosts the two `scheduler:job_*`
+ * event handlers: `scheduler:job_result` (cron-driven memory review,
+ * agent_turn dispatch, raw delivery) and `scheduler:job_suspended`
+ * (consecutive-failure suspension notification).
+ *
+ * Per-agent API-key resolution + cron operation-model resolution live here
+ * because each cron tick re-derives credentials from the daemon container
+ * (no per-cron-job cache); this leaf is the credentials-resolution + event
+ * dispatch concern boundary that the registry orchestrates.
+ *
+ * @module
+ */
+import { randomUUID } from "node:crypto";
+import { formatSessionKey, runWithContext, createDeliveryOrigin, systemNowMs } from "@comis/core";
+import { sanitizeAssistantResponse, resolveOperationModel, resolveProviderFamily, runMemoryReview, classifyError } from "@comis/agent";
+import { applyToolPolicy } from "@comis/skills";
+import { filterResponse } from "@comis/channels";
+/**
+ * Register the cron-driven event listeners on the daemon event bus.
+ *
+ * Two listeners are attached:
+ *   1. `scheduler:job_result` — delivers cron job output back to the
+ *      originating channel. Supports three payload kinds:
+ *      - `__MEMORY_REVIEW__` sentinel → run memory review for the agent
+ *      - `payloadKind === "agent_turn"` → execute the agent and deliver the
+ *        sanitized response (with rolling/fresh/accumulate session strategy)
+ *      - else (systemEvent) → deliver raw text
+ *   2. `scheduler:job_suspended` — notify the channel when a cron job is
+ *      auto-suspended after consecutive failures.
+ */
+export function registerCronEventListeners(deps) {
+    const { container, executors, defaultAgentId, sessionManager, logger, adaptersByType, deliveryService, } = deps;
+    const agents = container.config.agents;
+    container.eventBus.on("scheduler:job_result", async (payload) => {
+        // -- Memory review sentinel intercept --
+        const resultText = payload.result;
+        if (resultText === "__MEMORY_REVIEW__") {
+            const { agentId } = payload;
+            if (!agentId) {
+                logger.warn({ hint: "Memory review job fired without agentId", errorKind: "config" }, "Skipping memory review -- no agentId");
+                payload.onComplete?.({ status: "error", error: "No agentId for memory review" });
+                return;
+            }
+            const agentConfig = agents[agentId];
+            const memReviewConfig = agentConfig?.memoryReview;
+            if (!memReviewConfig?.enabled) {
+                logger.debug({ agentId }, "Memory review disabled for agent, skipping");
+                payload.onComplete?.({ status: "ok" });
+                return;
+            }
+            // Resolve cheap model for review via "cron" operation type
+            const resolved = resolveOperationModel({
+                operationType: "cron",
+                agentProvider: agentConfig.provider ?? "anthropic",
+                agentModel: agentConfig.model ?? "anthropic:claude-sonnet-4-20250514",
+                operationModels: agentConfig.operationModels ?? {},
+                providerFamily: resolveProviderFamily(agentConfig.provider ?? "anthropic"),
+            });
+            // Resolve API key for the provider
+            const providerEntry = container.config.providers?.entries?.[resolved.provider];
+            const apiKeyName = providerEntry?.apiKeyName || `${resolved.provider.toUpperCase()}_API_KEY`;
+            const apiKey = container.secretManager.get(apiKeyName) ?? "";
+            if (!apiKey) {
+                logger.warn({ agentId, provider: resolved.provider, hint: `Set ${apiKeyName} in secrets for memory review`, errorKind: "config" }, "Skipping memory review -- no API key");
+                payload.onComplete?.({ status: "error", error: `No API key for ${resolved.provider}` });
+                return;
+            }
+            const workspacePath = deps.workspaceDirs?.get(agentId) ?? "";
+            const reviewLogger = logger.child({ agentId, submodule: "memory-review" });
+            const reviewResult = await runMemoryReview({
+                agentId,
+                tenantId: deps.tenantId ?? container.config.tenantId ?? "default",
+                agentName: agentConfig.name ?? agentId,
+                config: memReviewConfig,
+                memoryPort: deps.memoryAdapter,
+                sessionStore: deps.sessionStore,
+                eventBus: container.eventBus,
+                workspacePath,
+                provider: resolved.provider,
+                modelId: resolved.modelId,
+                apiKey,
+                logger: reviewLogger,
+            });
+            if (!reviewResult.ok) {
+                logger.error({ agentId, err: reviewResult.error, hint: "Memory review failed -- will retry next cycle", errorKind: "internal" }, "Memory review error");
+            }
+            payload.onComplete?.({ status: reviewResult.ok ? "ok" : "error", error: reviewResult.ok ? undefined : reviewResult.error?.message });
+            return;
+        }
+        const { deliveryTarget, jobName, payloadKind } = payload;
+        if (!deliveryTarget?.channelType) {
+            logger.warn({ jobName, hint: "Delivery target missing channelType — ensure cron job was created from a channel context", errorKind: "config" }, "Cron job result has no delivery target channel type, skipping delivery");
+            payload.onComplete?.({ status: "error", error: "No delivery target channel type" });
+            return;
+        }
+        const adapter = adaptersByType.get(deliveryTarget.channelType);
+        if (!adapter) {
+            logger.warn({ channelType: deliveryTarget.channelType, jobName, hint: "Ensure the target channel adapter is started and registered", errorKind: "config" }, "No adapter found for cron delivery target");
+            payload.onComplete?.({ status: "error", error: `No adapter for ${deliveryTarget.channelType}` });
+            return;
+        }
+        // --- agentTurn: execute agent and deliver response ---
+        if (payloadKind === "agent_turn") {
+            const executor = executors.get(payload.agentId) ?? executors.get(defaultAgentId);
+            if (!executor) {
+                logger.error({ agentId: payload.agentId, jobName, hint: "Ensure executor is created for the agent referenced by the cron job", errorKind: "config" }, "No executor found for cron agentTurn");
+                // Fallback: send raw text so the user at least gets something
+                await deliveryService.deliverToChannel(adapter, deliveryTarget.channelId, resultText, undefined);
+                payload.onComplete?.({ status: "error", error: "No executor found for agent" });
+                return;
+            }
+            // Extract session strategy from event payload (defaults: fresh, 3 turns)
+            const sessionStrategy = payload.sessionStrategy ?? "fresh";
+            const maxHistoryTurns = payload.maxHistoryTurns ?? 3;
+            // Cadence-aware cache-waste guard: rolling/accumulate strategies on long cadences
+            // guarantee cache-write waste because the prompt cache TTL is short (5 min for "cron"
+            // operations — see OPERATION_CACHE_DEFAULTS.cron in @comis/agent). Threshold = 2x TTL
+            // so we don't warn on borderline-useful 6-9 min cadences. Operator intent is preserved
+            // (no auto-downgrade) — this is informational only. Scoped to schedule.kind === "every"
+            // because cron-expression cadence is not threaded through the event payload.
+            const CRON_CACHE_TTL_2X_MS = 600_000;
+            if (sessionStrategy !== "fresh" &&
+                payload.cadenceMs !== undefined &&
+                payload.cadenceMs > CRON_CACHE_TTL_2X_MS) {
+                logger.warn({
+                    jobName,
+                    agentId: payload.agentId,
+                    sessionStrategy,
+                    cadenceMs: payload.cadenceMs,
+                    hint: "Cadence exceeds cache TTL by 2x; rolling/accumulate guarantees per-tick cache-write waste. Set sessionStrategy:'fresh' unless cross-tick session memory is essential.",
+                    errorKind: "config",
+                }, "Cron sessionStrategy may waste cache writes at this cadence");
+            }
+            // Resolve cron operation model via 5-level priority chain
+            const agentConfig = agents[payload.agentId];
+            let cronOverrides;
+            if (agentConfig) {
+                const resolution = resolveOperationModel({
+                    operationType: "cron",
+                    agentProvider: agentConfig.provider,
+                    agentModel: agentConfig.model,
+                    operationModels: agentConfig.operationModels ?? {},
+                    providerFamily: resolveProviderFamily(agentConfig.provider),
+                    invocationOverride: payload.cronJobModel,
+                    agentPromptTimeoutMs: agentConfig.promptTimeout?.promptTimeoutMs,
+                });
+                cronOverrides = {
+                    model: resolution.model,
+                    operationType: "cron",
+                    promptTimeout: { promptTimeoutMs: resolution.timeoutMs },
+                    cacheRetention: payload.cacheRetention ?? resolution.cacheRetention,
+                };
+                logger.info({ jobName, model: resolution.model, source: resolution.source, agentId: payload.agentId }, "Cron model resolved");
+            }
+            const sessionKey = {
+                tenantId: deliveryTarget.tenantId,
+                userId: deliveryTarget.userId,
+                channelId: `cron:${payload.jobId}`,
+            };
+            // Fresh strategy — expire existing session before each execution
+            if (sessionStrategy === "fresh") {
+                sessionManager.expire(sessionKey);
+                const piAdapter = deps.piSessionAdapters?.get(payload.agentId)
+                    ?? deps.piSessionAdapters?.get(defaultAgentId);
+                if (piAdapter) {
+                    await piAdapter.destroySession(sessionKey);
+                }
+                else {
+                    logger.warn({ agentId: payload.agentId, jobName, hint: "No piSessionAdapter found — JSONL may accumulate", errorKind: "config" }, "Cron fresh strategy could not destroy JSONL");
+                }
+                container.eventBus.emit("session:expired", { sessionKey, reason: "cron-fresh" });
+            }
+            const syntheticMsg = {
+                id: `cron-${payload.jobId}-${systemNowMs()}`,
+                channelId: deliveryTarget.channelId,
+                channelType: deliveryTarget.channelType,
+                senderId: "system",
+                text: resultText,
+                timestamp: systemNowMs(),
+                attachments: [],
+                metadata: { isCronAgentTurn: true, jobId: payload.jobId, jobName },
+            };
+            const execStartTs = systemNowMs();
+            try {
+                const allTools = deps.assembleToolsForAgent
+                    ? await deps.assembleToolsForAgent(payload.agentId)
+                    : [];
+                // Resolve effective tool policy: job > agent > passthrough `{ profile: "full" }`.
+                // Opt-in per job — omitting payload.toolPolicy preserves the agent's interactive
+                // tool set. The explicit "full" fallback makes the no-silent-default contract
+                // readable in the call site.
+                const effectivePolicy = payload.toolPolicy ??
+                    agentConfig?.skills?.toolPolicy ??
+                    { profile: "full", allow: [], deny: [] };
+                const { tools, filtered: policyFiltered } = applyToolPolicy(allTools, effectivePolicy);
+                if (policyFiltered.length > 0) {
+                    logger.debug({
+                        jobName,
+                        agentId: payload.agentId,
+                        profile: effectivePolicy.profile,
+                        filteredCount: policyFiltered.length,
+                        filtered: policyFiltered.map((f) => ({ tool: f.toolName, reason: f.reason.kind })),
+                    }, "Cron tool policy applied");
+                }
+                logger.info({ jobName, agentId: payload.agentId, channelType: deliveryTarget.channelType, toolCount: Array.isArray(tools) ? tools.length : 0 }, "Executing cron agentTurn");
+                const execResult = await runWithContext({
+                    traceId: randomUUID(),
+                    tenantId: sessionKey.tenantId,
+                    userId: sessionKey.userId,
+                    sessionKey: formatSessionKey(sessionKey),
+                    startedAt: systemNowMs(),
+                    trustLevel: "user",
+                    channelType: deliveryTarget.channelType,
+                    deliveryOrigin: deliveryTarget ? createDeliveryOrigin({
+                        channelType: deliveryTarget.channelType,
+                        channelId: deliveryTarget.channelId,
+                        userId: deliveryTarget.userId,
+                        tenantId: deliveryTarget.tenantId,
+                    }) : undefined,
+                }, () => executor.execute(syntheticMsg, sessionKey, tools, undefined, payload.agentId, undefined, undefined, cronOverrides));
+                // Sanitize raw executor response: strip thinking tags, provider artifacts, unwrap <final>
+                const rawResponse = execResult.response;
+                const cleaned = sanitizeAssistantResponse(rawResponse);
+                // Rolling strategy — prune to last N turns after execution
+                if (sessionStrategy === "rolling") {
+                    const messages = sessionManager.loadOrCreate(sessionKey);
+                    if (messages.length > 0) {
+                        // Find the start index of the last N turns.
+                        // A "turn" starts at a user message and includes all following non-user messages.
+                        // Walk backwards, counting user messages as turn boundaries.
+                        let turnCount = 0;
+                        let keepFromIndex = 0; // default: keep all
+                        for (let i = messages.length - 1; i >= 0; i--) {
+                            const msg = messages[i];
+                            if (msg.role === "user") {
+                                turnCount++;
+                                if (turnCount <= maxHistoryTurns) {
+                                    keepFromIndex = i; // this user message starts a turn we want to keep
+                                }
+                                else {
+                                    break; // found more turns than maxHistoryTurns, stop
+                                }
+                            }
+                        }
+                        if (turnCount > maxHistoryTurns) {
+                            const pruned = messages.slice(keepFromIndex);
+                            sessionManager.save(sessionKey, pruned);
+                        }
+                    }
+                }
+                // Enriched completion log with token/cost/tool metrics
+                logger.info({
+                    jobName,
+                    agentId: payload.agentId,
+                    durationMs: systemNowMs() - execStartTs,
+                    responseLen: cleaned.length,
+                    totalTokens: execResult.tokensUsed.total,
+                    costUsd: execResult.cost.total,
+                    toolCalls: execResult.stepsExecuted,
+                    llmCalls: execResult.llmCalls,
+                }, "Cron agentTurn execution complete");
+                // Record enriched execution entry with token/cost metrics
+                const execTracker = deps.cronExecutionTrackers?.get(payload.agentId);
+                if (execTracker) {
+                    await execTracker.record({
+                        ts: systemNowMs(),
+                        jobId: payload.jobId,
+                        status: "ok",
+                        durationMs: systemNowMs() - execStartTs,
+                        summary: cleaned.slice(0, 200),
+                        totalTokens: execResult.tokensUsed.total,
+                        costUsd: execResult.cost.total,
+                        toolCalls: execResult.stepsExecuted,
+                        llmCalls: execResult.llmCalls,
+                    });
+                }
+                // Report execution result back to scheduler for consecutiveErrors tracking.
+                // errorContext is set when the executor caught a classified error (overloaded, auth, etc.)
+                // and returned the user-friendly message as the response instead of throwing.
+                if (execResult.errorContext) {
+                    payload.onComplete?.({ status: "error", error: execResult.errorContext.originalError ?? execResult.errorContext.errorType });
+                }
+                else {
+                    payload.onComplete?.({ status: "ok" });
+                }
+                // Suppress error message delivery for cron jobs.
+                // When errorContext is set, the executor caught a classified error
+                // (timeout, overloaded, auth, etc.) and set result.response to a
+                // user-facing error message. For cron jobs this is nonsensical.
+                // The error is already reported via onComplete above.
+                if (execResult.errorContext) {
+                    logger.info({ jobName, errorType: execResult.errorContext.errorType, hint: "Error already reported to scheduler — suppressing channel delivery" }, "Cron agentTurn error response suppressed");
+                    return;
+                }
+                // Filter out NO_REPLY / HEARTBEAT_OK / empty responses
+                const filtered = filterResponse(cleaned);
+                if (!filtered.shouldDeliver) {
+                    logger.debug({ jobName, suppressedBy: filtered.suppressedBy }, "Cron agentTurn response suppressed");
+                    return;
+                }
+                const sendResult = await deliveryService.deliverToChannel(adapter, deliveryTarget.channelId, filtered.cleanedText, undefined);
+                if (!sendResult.ok || !sendResult.value.ok) {
+                    logger.error({ err: sendResult.ok ? undefined : sendResult.error, jobName, hint: "Verify channel adapter is running and channel ID is valid", errorKind: "platform" }, "Cron agentTurn delivery failed");
+                }
+            }
+            catch (err) {
+                logger.error({ err, jobName, hint: "Agent execution failed, delivering raw text as fallback", errorKind: "internal" }, "Cron agentTurn execution failed");
+                // Record error execution entry
+                const execTracker = deps.cronExecutionTrackers?.get(payload.agentId);
+                if (execTracker) {
+                    await execTracker.record({
+                        ts: systemNowMs(),
+                        jobId: payload.jobId,
+                        status: "error",
+                        durationMs: systemNowMs() - execStartTs,
+                        error: err instanceof Error ? err.message : String(err),
+                    });
+                }
+                await deliveryService.deliverToChannel(adapter, deliveryTarget.channelId, resultText, undefined);
+                payload.onComplete?.({ status: "error", error: err instanceof Error ? err.message : String(err) });
+            }
+            return;
+        }
+        // --- systemEvent (or undefined): send raw text (existing behavior) ---
+        const sendResult = await deliveryService.deliverToChannel(adapter, deliveryTarget.channelId, resultText, undefined);
+        if (!sendResult.ok || !sendResult.value.ok) {
+            logger.error({ err: sendResult.ok ? undefined : sendResult.error, target: deliveryTarget, jobName, hint: "Verify channel adapter is running and channel ID is valid", errorKind: "platform" }, "Cron delivery failed");
+        }
+        else {
+            logger.debug({ jobName, channelId: deliveryTarget.channelId }, "Cron result delivered");
+        }
+    });
+    // Notify user when a cron job is auto-suspended
+    container.eventBus.on("scheduler:job_suspended", async (payload) => {
+        const { deliveryTarget, jobName, jobId, consecutiveErrors, lastError } = payload;
+        if (!deliveryTarget?.channelType) {
+            logger.warn({ jobName, hint: "Suspended job has no delivery target for notification", errorKind: "config" }, "Cannot notify user of job suspension — no delivery target");
+            return;
+        }
+        const adapter = adaptersByType.get(deliveryTarget.channelType);
+        if (!adapter) {
+            logger.warn({ channelType: deliveryTarget.channelType, jobName, hint: "Ensure the target channel adapter is started", errorKind: "config" }, "No adapter found for job suspension notification");
+            return;
+        }
+        const classified = classifyError(lastError);
+        const message = [
+            `Scheduled task "${jobName}" was suspended after ${consecutiveErrors} consecutive failures.`,
+            `Reason: ${classified.userMessage}`,
+            `Re-enable with /cron enable ${jobId}`,
+        ].join("\n");
+        try {
+            await deliveryService.deliverToChannel(adapter, deliveryTarget.channelId, message, undefined);
+            logger.info({ jobName, jobId, channelType: deliveryTarget.channelType }, "Job suspension notification delivered");
+        }
+        catch (err) {
+            logger.error({ jobName, jobId, err, hint: "Failed to deliver job suspension notification", errorKind: "internal" }, "Job suspension notification delivery failed");
+        }
+    });
+}

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

@@ -0,0 +1,183 @@
+/**
+ * Channel-subsystem composition root: bootstraps adapters (delegated to
+ * setup-channels-adapters.ts), assembles the media pipeline (delegated to
+ * setup-channels-media.ts), registers cron-delivery event listeners
+ * (delegated to setup-channels-credentials.ts), and constructs the
+ * ChannelManager + lifecycle reactors + approval notifier (delegated to
+ * setup-channels-runtime.ts).
+ *
+ * Holds the `ChannelsDeps` / `ChannelsResult` interfaces and the
+ * `setupChannels` entry that the daemon composition root calls.
+ *
+ * @module
+ */
+import type { AppContainer, ChannelPort, ChannelPluginPort, NormalizedMessage, SessionKey, TranscriptionPort, TTSPort, ImageAnalysisPort, FileExtractionPort, FileExtractionConfig, MemoryPort, QueueConfig, DeliveryService } from "@comis/core";
+import type { ComisLogger } from "@comis/infra";
+import type { AgentExecutor, createSessionLifecycle, ActiveRunRegistry, BackgroundSessionResolver } from "@comis/agent";
+import type { createSessionStore } from "@comis/memory";
+import type { CommandQueue } from "@comis/orchestrator";
+import type { VoiceResponsePipelineDeps, ApprovalNotifier, LifecycleReactor } from "@comis/channels";
+import type { ChannelManager } from "@comis/orchestrator";
+import type { MediaResolverPort } from "@comis/core";
+import type { SsrfGuardedFetcher, RpcCall, LinkRunner, AudioConverter, MediaTempManager, MediaSemaphore } from "@comis/skills";
+import type { ExecutionLogEntry } from "@comis/scheduler";
+export type { VoiceResponsePipelineDeps, LifecycleReactor };
+/** All services produced by the channel bootstrap phase. */
+export interface ChannelsResult {
+    /** Channel adapters keyed by platform type (telegram, discord, etc.). */
+    adaptersByType: Map<string, ChannelPort>;
+    /** Channel lifecycle manager (optional -- undefined when no adapters enabled). */
+    channelManager?: ChannelManager;
+    /** Composite media resolver routing to per-platform resolvers (optional -- undefined when no ssrfFetcher). */
+    compositeResolver?: MediaResolverPort;
+    /** Attachment resolver callback for media URL resolution -- used by RPC handlers. */
+    resolveAttachment: (url: string) => Promise<Buffer | null>;
+    /** Lifecycle reactors created per eligible adapter (for shutdown cleanup). */
+    lifecycleReactors: LifecycleReactor[];
+    /** Approval notifier for forwarding approval events to chat channels (optional -- undefined when no adapters enabled). */
+    approvalNotifier?: ApprovalNotifier;
+    /** Full plugin objects keyed by channel type for capabilities RPC */
+    channelPlugins: Map<string, ChannelPluginPort>;
+    /** Per-channel capability info (notably `replyToMetaKey` — the metadata
+     *  field carrying the platform-native message id). Used by the inbound
+     *  UUID resolver so message.delete/edit/react can translate daemon UUIDs
+     *  back to native ids before calling the channel adapter. */
+    channelCapabilities: Map<string, import("../setup-channels-adapters.js").ChannelCapabilityInfo>;
+    /** The command queue instance for parent session TTL extension during graph execution. */
+    commandQueue?: CommandQueue;
+    /** DeliveryService constructed once at the daemon composition root. Threaded
+     *  through setupCrossSession + createMessageHandlers so all production callers
+     *  share a single closure-captured deps record. */
+    deliveryService: DeliveryService;
+}
+/** Dependencies for channel adapter bootstrap. */
+export interface ChannelsDeps {
+    /** Bootstrap output: config, event bus, secret manager. */
+    container: AppContainer;
+    /** Per-agent executor instances keyed by agentId. */
+    executors: Map<string, AgentExecutor>;
+    /** Default agent ID from routing config. */
+    defaultAgentId: string;
+    /** Shared session manager across all agents. */
+    sessionManager: ReturnType<typeof createSessionLifecycle>;
+    /** Session persistence store (for getResetTriggers). */
+    sessionStore: ReturnType<typeof createSessionStore>;
+    /** Root logger (for cron delivery logs). */
+    logger: ComisLogger;
+    /** Module-bound logger for channels subsystem. */
+    channelsLogger: ComisLogger;
+    /** Link understanding runner for message text enrichment. */
+    linkRunner: LinkRunner;
+    /** SSRF-guarded fetcher for media downloads. */
+    ssrfFetcher: SsrfGuardedFetcher;
+    /** STT transcriber for audio preflight (optional -- config/key may be missing). */
+    transcriber?: TranscriptionPort;
+    /** Maximum media file size in bytes for inbound pre-check. */
+    maxMediaBytes: number;
+    /** Tool assembler passed through to channel-manager deps. Options.sessionKey threads
+     *  the inbound session's persistent FileStateTracker via SessionTrackerRegistry. Cron
+     *  delivery path (L370) intentionally omits options -- cron is heartbeat-style, no
+     *  conversation session. */
+    assembleToolsForAgent?: (agentId: string, options?: {
+        sessionKey?: SessionKey;
+    }) => Promise<any[]>;
+    /** TTS adapter for voice response pipeline (optional -- TTS may not be configured). */
+    ttsAdapter?: TTSPort;
+    /** Audio converter for MP3-to-OGG/Opus conversion (optional -- ffmpeg may be absent). */
+    audioConverter?: AudioConverter;
+    /** Media temp manager for scratch files. */
+    mediaTempManager?: MediaTempManager;
+    /** Media semaphore for concurrency limiting. */
+    mediaSemaphore?: MediaSemaphore;
+    /** Optional image analyzer for text-description fallback when model lacks vision capability. */
+    imageAnalyzer?: ImageAnalysisPort;
+    /** File extractor for document attachment processing (optional -- documents skipped when absent). */
+    fileExtractor?: FileExtractionPort;
+    /** File extraction config for budget limits and feature flags. */
+    fileExtractionConfig?: FileExtractionConfig;
+    /** Per-agent workspace directory paths (for media file persistence). */
+    workspaceDirs?: Map<string, string>;
+    /** Default agent workspace directory path. */
+    defaultWorkspaceDir?: string;
+    /** Memory adapter for storing media file references. */
+    memoryAdapter?: MemoryPort;
+    /** Default tenant ID for memory storage. */
+    tenantId?: string;
+    /** Embedding queue for new memory entries (optional). */
+    embeddingQueue?: {
+        enqueue(id: string, content: string): void;
+    };
+    /** Queue configuration for per-session serialization. When enabled, creates a CommandQueue for the ChannelManager. */
+    queueConfig?: QueueConfig;
+    /** Delivery queue for crash-safe persistence */
+    deliveryQueue?: import("@comis/core").DeliveryQueuePort;
+    /** Optional active run registry for SDK-native steer+followup inbound routing */
+    activeRunRegistry?: ActiveRunRegistry;
+    /**
+     * Optional composite-key resolver. Wired by the daemon as
+     * `createBackgroundSessionResolver({ activeRunRegistry })`; supersedes
+     * `activeRunRegistry.has/.get` for production lookups in the inbound
+     * pipeline.
+     */
+    sessionResolver?: BackgroundSessionResolver;
+    /** RPC call dispatcher for /config chat commands (deferred dispatch -- safe to pass before wireDispatch). */
+    rpcCall?: RpcCall;
+    /** Optional callback for task extraction after successful agent execution (gated by config.scheduler.tasks.enabled). */
+    onTaskExtraction?: (conversationText: string, sessionKey: string, agentId: string) => Promise<void>;
+    /**
+     * Optional callback fired BEFORE each inbound message is dispatched to the
+     * executor. Used by the restart continuation tracker so the session is
+     * visible in tracker state before any tool call could trigger SIGUSR2.
+     * Bypassed for early-return paths (no-adapter, graph-report intercept).
+     */
+    onMessageReceived?: (msg: NormalizedMessage, channelType: string) => void;
+    /** Optional callback fired AFTER each successful inbound message processing. Used by post-processing state (e.g. notification session activity recording). */
+    onMessageProcessed?: (msg: NormalizedMessage, channelType: string) => void;
+    /** Optional approval gate for /approve and /deny chat commands in inbound pipeline. */
+    approvalGate?: import("@comis/core").ApprovalGate;
+    /** Per-agent PI session adapters for session stats/destroy in slash commands. */
+    piSessionAdapters?: Map<string, {
+        getSessionStats(key: SessionKey): {
+            messageCount: number;
+            createdAt?: number;
+            tokens?: {
+                input: number;
+                output: number;
+                cacheRead: number;
+                cacheWrite: number;
+                total: number;
+            };
+            userMessages?: number;
+            assistantMessages?: number;
+            toolCalls?: number;
+            toolResults?: number;
+            cost?: number;
+        } | undefined;
+        destroySession(key: SessionKey): Promise<void>;
+    }>;
+    /** Per-agent cost trackers for /usage and /status cost data. */
+    costTrackers?: Map<string, {
+        getByProvider(): Array<{
+            provider: string;
+            model: string;
+            totalTokens: number;
+            totalCost: number;
+            callCount: number;
+        }>;
+        getBySession(key: string): {
+            totalTokens: number;
+            totalCost: number;
+        };
+    }>;
+    /** Per-agent cron execution trackers for enriched JSONL entries. */
+    cronExecutionTrackers?: Map<string, {
+        record(entry: ExecutionLogEntry): Promise<void>;
+    }>;
+}
+/**
+ * Bootstrap all enabled channel adapters from config, wire cron delivery and
+ * tool audit event listeners, and create + start the ChannelManager.
+ * @param deps - Channel bootstrap dependencies
+ * @returns Channel adapters map and optional channel manager
+ */
+export declare function setupChannels(deps: ChannelsDeps): Promise<ChannelsResult>;