comisai 1.0.37 → 1.0.41

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

@@ -0,0 +1,429 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Channel adapter lifecycle wiring. Hosts the ChannelManager construction
+ * (with voice response pipeline, command queue, slash-command handler,
+ * lifecycle reactors, approval notifier).
+ *
+ * The registry orchestrator invokes `buildAndStartChannelManager` after the
+ * adapters and media pipeline have been bootstrapped; this helper returns
+ * the manager handle + lifecycle reactors + approval notifier + command
+ * queue so the registry can assemble the final ChannelsResult.
+ *
+ * @module
+ */
+import { readdir, readFile, stat } from "node:fs/promises";
+import { formatSessionKey, safePath, systemNowDate } from "@comis/core";
+import { createCommandHandler, parseSlashCommand, createMessageRouter, createCommandQueue } from "@comis/orchestrator";
+import { createApprovalNotifier, createLifecycleReactor, reactWithFallback, } from "@comis/channels";
+import { createChannelManager, processInboundMessage } from "@comis/orchestrator";
+import { RetryConfigSchema, createRetryEngine } from "@comis/core";
+import { shouldAutoTts, resolveOutputFormat, parseOutboundMedia, } from "@comis/skills";
+/**
+ * Construct and start the ChannelManager (voice response pipeline +
+ * command queue + slash-command handler + retry engine), then wire the
+ * lifecycle reactors and approval notifier for each registered adapter.
+ *
+ * Returns the four handles the registry needs to assemble ChannelsResult.
+ * No-op when `adaptersByType.size === 0`.
+ */
+export async function buildAndStartChannelManager(deps) {
+    const { container, executors, defaultAgentId, sessionManager, channelsLogger, ssrfFetcher, deliveryService, adaptersByType, channelCapabilities, preprocessMessageCallback, preflightFn, } = deps;
+    const agents = container.config.agents;
+    const routingConfig = container.config.routing;
+    const messageRouter = createMessageRouter(routingConfig);
+    let channelManager;
+    // Build voice response pipeline deps
+    let voiceResponsePipeline;
+    if (deps.ttsAdapter) {
+        const ttsConfig = container.config.integrations.media.tts;
+        // Derive providerFormatKey from the configured TTS provider.
+        // This tells the pipeline which field of ResolvedOutputFormat to pass to synthesize().
+        // - "openai" -> "opus" (OpenAI understands "opus", "mp3", etc.)
+        // - "elevenlabs" -> "opus_48000_64" (ElevenLabs needs underscore-delimited format)
+        // - "edge" -> SSML format string
+        const providerFormatKey = ttsConfig.provider === "elevenlabs" ? "elevenlabs"
+            : ttsConfig.provider === "edge" ? "edge"
+                : "openai";
+        voiceResponsePipeline = {
+            ttsAdapter: deps.ttsAdapter,
+            audioConverter: deps.audioConverter,
+            mediaTempManager: deps.mediaTempManager
+                ? { getManagedDir: () => deps.mediaTempManager.getManagedDir() }
+                : { getManagedDir: () => undefined },
+            mediaSemaphore: deps.mediaSemaphore
+                ? { run: (fn) => deps.mediaSemaphore.run(fn) }
+                : { run: async (fn) => fn() },
+            shouldAutoTts,
+            resolveOutputFormat: resolveOutputFormat,
+            ttsConfig: {
+                autoMode: ttsConfig.autoMode,
+                tagPattern: ttsConfig.tagPattern,
+                voice: ttsConfig.voice,
+                maxTextLength: ttsConfig.maxTextLength,
+                outputFormats: ttsConfig.outputFormats,
+                providerFormatKey,
+            },
+            logger: channelsLogger,
+        };
+        channelsLogger.debug({ autoMode: ttsConfig.autoMode, providerFormatKey }, "Voice response pipeline wired");
+    }
+    // Create command queue when enabled in config
+    let commandQueue;
+    if (deps.queueConfig?.enabled) {
+        commandQueue = createCommandQueue({
+            eventBus: container.eventBus,
+            config: deps.queueConfig,
+            logger: channelsLogger,
+        });
+        channelsLogger.info({ mode: deps.queueConfig.defaultMode }, "Command queue enabled");
+    }
+    // Lifecycle reactions config
+    const lifecycleReactionsConfig = container.config.lifecycleReactions;
+    const lifecycleEnabled = lifecycleReactionsConfig.enabled;
+    const lifecycleReactors = [];
+    if (adaptersByType.size > 0) {
+        // Create retry engine for resilient message delivery (rate limit retry + HTML parse fallback)
+        const retryConfig = RetryConfigSchema.parse({});
+        const retryEngine = createRetryEngine(retryConfig, container.eventBus, channelsLogger);
+        channelManager = createChannelManager({
+            eventBus: container.eventBus,
+            messageRouter,
+            commandQueue,
+            sessionManager,
+            retryEngine,
+            deliveryQueue: deps.deliveryQueue,
+            deliveryService,
+            // Required dep — orchestrator-side inbound pipeline entrypoint.
+            // Routed through ChannelManagerDeps so channels does not create a
+            // back-edge import of @comis/orchestrator.
+            processInboundMessage,
+            createExecutor: (agentId) => executors.get(agentId) ?? executors.get(defaultAgentId),
+            adapters: Array.from(adaptersByType.values()),
+            logger: channelsLogger,
+            preprocessMessage: preprocessMessageCallback,
+            audioPreflight: preflightFn,
+            streamingConfig: container.config.streaming,
+            autoReplyEngineConfig: container.config.autoReplyEngine,
+            sendPolicyConfig: container.config.sendPolicy,
+            getResetTriggers: (agentId) => {
+                const agentConfig = agents[agentId];
+                return agentConfig?.session?.resetPolicy?.resetTriggers ?? [];
+            },
+            assembleToolsForAgent: deps.assembleToolsForAgent,
+            voiceResponsePipeline,
+            parseOutboundMedia,
+            activeRunRegistry: deps.activeRunRegistry,
+            sessionResolver: deps.sessionResolver,
+            queueConfig: deps.queueConfig,
+            getElevatedReplyConfig: (agentId) => {
+                const agentConfig = agents[agentId];
+                return agentConfig?.elevatedReply;
+            },
+            getEnforceFinalTag: (agentId) => {
+                const agentConfig = agents[agentId];
+                return agentConfig?.enforceFinalTag;
+            },
+            getAllowFrom: (channelType) => {
+                const cfg = container.config.channels?.[channelType];
+                if (!cfg || typeof cfg !== "object" || !("allowFrom" in cfg))
+                    return [];
+                return cfg.allowFrom ?? [];
+            },
+            outboundMediaFetch: async (url) => {
+                const result = await ssrfFetcher.fetch(url);
+                if (!result.ok)
+                    return { ok: false, error: result.error };
+                return { ok: true, value: { buffer: result.value.buffer, mimeType: result.value.mimeType } };
+            },
+            // /config chat command handling via RPC dispatch
+            handleConfigCommand: deps.rpcCall ? async (args, _channelType) => {
+                const subcommand = args[0] ?? "show";
+                try {
+                    if (subcommand === "show" || subcommand === "history") {
+                        // Channel-originated messages always have user trust
+                        return "Config read requires admin trust. Use the CLI or gateway client with admin scope.";
+                    }
+                    if (subcommand === "set") {
+                        // Channel-originated messages always have user trust
+                        return "Config modification requires admin trust. Use the CLI or gateway client with admin scope.";
+                    }
+                    return `Unknown config subcommand: ${subcommand}. Available: show, set, history`;
+                }
+                catch (err) {
+                    return `Config command failed: ${err instanceof Error ? err.message : String(err)}`;
+                }
+            } : undefined,
+            // Task extraction callback (gated by config.scheduler.tasks.enabled)
+            onTaskExtraction: deps.onTaskExtraction,
+            onMessageReceived: deps.onMessageReceived,
+            onMessageProcessed: deps.onMessageProcessed,
+            // Graph report button callback intercept: deliver full report as .md file attachment
+            onGraphReportRequest: async (graphId, _channelType, channelId, adapter, threadId) => {
+                const dataDir = container.config.dataDir || ".";
+                try {
+                    // Validate graphId format (alphanumeric + hyphens, UUID-like)
+                    if (!/^[a-f0-9-]{8,64}$/i.test(graphId)) {
+                        channelsLogger.warn({ graphId, hint: "Invalid graphId format in report request", errorKind: "validation" }, "Graph report request rejected");
+                        return;
+                    }
+                    let graphDir;
+                    // Two-step safePath composition matches the canonical daemon-wiring
+                    // pattern in setup-output-retention.ts. Both safePath calls throw on
+                    // traversal; the surrounding catch handles either failure with a
+                    // single operator-facing WARN.
+                    try {
+                        const graphRunsDir = safePath(dataDir, "graph-runs");
+                        graphDir = safePath(graphRunsDir, graphId);
+                    }
+                    catch {
+                        channelsLogger.warn({ graphId, hint: "Path traversal attempt in graphId", errorKind: "validation" }, "Graph report request rejected");
+                        return;
+                    }
+                    // Check directory exists
+                    try {
+                        await stat(graphDir);
+                    }
+                    catch {
+                        channelsLogger.warn({ graphId, graphDir, hint: "Graph run directory not found", errorKind: "validation" }, "Graph report directory missing");
+                        await adapter.sendMessage(channelId, "Report not available — graph run data not found.", threadId ? { extra: { threadId } } : undefined);
+                        return;
+                    }
+                    // Find the leaf output file
+                    const files = await readdir(graphDir);
+                    const outputFiles = files.filter((f) => f.endsWith("-output.md"));
+                    if (outputFiles.length === 0) {
+                        await adapter.sendMessage(channelId, "Report not available — no output files found.", threadId ? { extra: { threadId } } : undefined);
+                        return;
+                    }
+                    // Try to identify leaf nodes from metadata
+                    let leafOutputFile;
+                    try {
+                        const metadataRaw = await readFile(safePath(graphDir, "_run-metadata.json"), "utf8");
+                        const metadata = JSON.parse(metadataRaw);
+                        const completedNodes = Object.entries(metadata.nodes)
+                            .filter(([, v]) => v.status === "completed")
+                            .map(([k]) => k);
+                        // Match output files to completed nodes, pick largest
+                        let maxSize = 0;
+                        for (const f of outputFiles) {
+                            const nodeId = f.replace(/-output\.md$/, "");
+                            if (completedNodes.includes(nodeId)) {
+                                const fileStat = await stat(safePath(graphDir, f));
+                                if (fileStat.size > maxSize) {
+                                    maxSize = fileStat.size;
+                                    leafOutputFile = f;
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        // Metadata read failed -- fall back to largest output file
+                    }
+                    if (!leafOutputFile) {
+                        // Fallback: pick largest output file
+                        let maxSize = 0;
+                        for (const f of outputFiles) {
+                            const fileStat = await stat(safePath(graphDir, f));
+                            if (fileStat.size > maxSize) {
+                                maxSize = fileStat.size;
+                                leafOutputFile = f;
+                            }
+                        }
+                    }
+                    if (!leafOutputFile) {
+                        await adapter.sendMessage(channelId, "Report not available — could not identify output file.", threadId ? { extra: { threadId } } : undefined);
+                        return;
+                    }
+                    const filePath = safePath(graphDir, leafOutputFile);
+                    const nodeId = leafOutputFile.replace(/-output\.md$/, "");
+                    const caption = `Full report — ${nodeId} (graph ${graphId.slice(0, 8)})`;
+                    await adapter.sendAttachment(channelId, {
+                        type: "file",
+                        url: filePath,
+                        fileName: `report-${graphId.slice(0, 8)}.md`,
+                        mimeType: "text/markdown",
+                        caption,
+                    }, threadId ? { extra: { threadId } } : undefined);
+                    channelsLogger.debug({ graphId, nodeId, channelId }, "Graph report delivered as file attachment");
+                }
+                catch (err) {
+                    channelsLogger.warn({ graphId, err, hint: "Failed to deliver graph report file", errorKind: "internal" }, "Graph report delivery failed");
+                }
+            },
+            // /approve and /deny chat command interception
+            approvalGate: deps.approvalGate,
+            // General slash command handling via createCommandHandler
+            handleSlashCommand: async (text, sessionKey, agentId) => {
+                const parsed = parseSlashCommand(text);
+                // /config and /stop are handled by dedicated inbound pipeline blocks
+                if (parsed.command === "config" || parsed.command === "stop")
+                    return undefined;
+                const execAgentConfig = agents[agentId] ?? agents[defaultAgentId];
+                const cmdDeps = {
+                    getSessionInfo: (key) => {
+                        const adapter = deps.piSessionAdapters?.get(agentId);
+                        if (adapter) {
+                            const stats = adapter.getSessionStats(key);
+                            return {
+                                messageCount: stats?.messageCount ?? 0,
+                                createdAt: stats?.createdAt,
+                                tokensUsed: stats?.tokens,
+                            };
+                        }
+                        return { messageCount: 0 };
+                    },
+                    getAgentConfig: () => ({
+                        name: execAgentConfig?.name ?? "Unknown",
+                        model: execAgentConfig?.model ?? "unknown",
+                        provider: execAgentConfig?.provider ?? "unknown",
+                        maxSteps: execAgentConfig?.maxSteps ?? 10,
+                    }),
+                    destroySession: (key) => {
+                        const adapter = deps.piSessionAdapters?.get(agentId);
+                        if (adapter) {
+                            // eslint-disable-next-line no-restricted-syntax -- intentional fire-and-forget
+                            adapter.destroySession(key).catch(() => { });
+                            container.eventBus.emit("session:expired", { sessionKey: key, reason: "chat-reset" });
+                            return;
+                        }
+                        // Fallback: expire via session manager
+                        sessionManager.expire(key);
+                        container.eventBus.emit("session:expired", { sessionKey: key, reason: "chat-reset" });
+                    },
+                    getAvailableModels: () => [],
+                    getUsageBreakdown: () => {
+                        const tracker = deps.costTrackers?.get(agentId) ?? deps.costTrackers?.get(defaultAgentId);
+                        return tracker?.getByProvider() ?? [];
+                    },
+                    getSessionCost: (key) => {
+                        const tracker = deps.costTrackers?.get(agentId) ?? deps.costTrackers?.get(defaultAgentId);
+                        return tracker?.getBySession(formatSessionKey(key)) ?? { totalTokens: 0, totalCost: 0 };
+                    },
+                    getSDKSessionStats: (key) => {
+                        const adapter = deps.piSessionAdapters?.get(agentId);
+                        if (!adapter)
+                            return undefined;
+                        const stats = adapter.getSessionStats(key);
+                        if (!stats)
+                            return undefined;
+                        return {
+                            userMessages: stats.userMessages ?? 0,
+                            assistantMessages: stats.assistantMessages ?? 0,
+                            toolCalls: stats.toolCalls ?? 0,
+                            toolResults: stats.toolResults ?? 0,
+                            totalMessages: stats.messageCount,
+                            tokens: {
+                                input: stats.tokens?.input ?? 0,
+                                output: stats.tokens?.output ?? 0,
+                                cacheRead: stats.tokens?.cacheRead ?? 0,
+                                cacheWrite: stats.tokens?.cacheWrite ?? 0,
+                                total: stats.tokens?.total ?? 0,
+                            },
+                            cost: stats.cost ?? 0,
+                        };
+                    },
+                    getContextUsage: () => undefined,
+                    getBudgetInfo: () => undefined,
+                };
+                const handler = createCommandHandler(cmdDeps);
+                const result = handler.handle(parsed, sessionKey);
+                // For /new and /reset, the static response from command handler is used.
+                // Greeting generation (LLM-powered) is available in the gateway; channels
+                // use the simpler "New session created." / "Session reset." responses.
+                return {
+                    handled: result.handled,
+                    response: result.response,
+                    directives: result.directives,
+                    cleanedText: parsed.cleanedText,
+                };
+            },
+            // Lifecycle reactions: skip ack reaction when lifecycle reactor handles queued/thinking
+            lifecycleReactionsEnabled: lifecycleEnabled,
+            // Response prefix template engine
+            responsePrefixConfig: container.config.responsePrefix,
+            buildTemplateContext: (agentId, channelType, msg) => {
+                const agentConfig = agents[agentId] ?? agents[defaultAgentId];
+                const modelsConfig = container.config.models;
+                const resolvedModel = agentConfig?.model === "default"
+                    ? modelsConfig?.defaultModel ?? ""
+                    : agentConfig?.model ?? "";
+                const resolvedProvider = agentConfig?.provider === "default"
+                    ? modelsConfig?.defaultProvider ?? ""
+                    : agentConfig?.provider ?? "";
+                const now = systemNowDate();
+                return {
+                    agent: agentConfig?.name ?? agentId,
+                    "agent.emoji": "",
+                    "identity.name": agentConfig?.name ?? agentId,
+                    model: resolvedModel,
+                    "model.full": `${resolvedProvider}/${resolvedModel}`,
+                    provider: resolvedProvider,
+                    thinking: agentConfig?.thinkingLevel ?? "",
+                    channel: channelType,
+                    "chat.type": msg.metadata?.telegramChatType ?? "",
+                    time: now.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", hour12: false }),
+                    date: now.toISOString().slice(0, 10),
+                    uptime: `${Math.floor(process.uptime() / 60)}m`,
+                };
+            },
+        });
+        await channelManager.startAll();
+        channelsLogger.info({ activeCount: channelManager.activeCount }, "ChannelManager started");
+        // -----------------------------------------------------------------------
+        // Lifecycle reactors
+        // Create one reactor per eligible adapter. Gated on:
+        // 1. Global lifecycleReactions.enabled
+        // 2. Per-channel capabilities (features.reactions must be true)
+        // 3. Per-channel override (lifecycleReactions.perChannel[type]?.enabled)
+        // -----------------------------------------------------------------------
+        if (lifecycleEnabled) {
+            for (const [channelType, adapter] of adaptersByType) {
+                const caps = channelCapabilities.get(channelType);
+                if (!caps?.supportsReactions) {
+                    channelsLogger.debug({ channelType }, "Lifecycle reactor skipped: reactions not supported");
+                    continue;
+                }
+                // Check per-channel override
+                const perChannelConfig = lifecycleReactionsConfig.perChannel[channelType];
+                if (perChannelConfig?.enabled === false) {
+                    channelsLogger.debug({ channelType }, "Lifecycle reactor skipped: per-channel disabled");
+                    continue;
+                }
+                const reactor = createLifecycleReactor({
+                    eventBus: container.eventBus,
+                    adapter,
+                    channelType,
+                    replyToMetaKey: caps.replyToMetaKey,
+                    config: lifecycleReactionsConfig,
+                    logger: channelsLogger,
+                    // Telegram-specific emoji fallback for REACTION_INVALID errors
+                    reactWithFallback: channelType === "telegram" ? reactWithFallback : undefined,
+                });
+                lifecycleReactors.push(reactor);
+                channelsLogger.debug({ channelType }, "Lifecycle reactor created");
+            }
+            if (lifecycleReactors.length > 0) {
+                channelsLogger.info({ reactorCount: lifecycleReactors.length }, "Lifecycle reactors initialized");
+            }
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Approval notifier: forward approval:requested to chat channel
+    // -----------------------------------------------------------------------
+    let approvalNotifier;
+    if (adaptersByType.size > 0) {
+        approvalNotifier = createApprovalNotifier({
+            eventBus: container.eventBus,
+            getAdapter: (channelType) => adaptersByType.get(channelType),
+            logger: channelsLogger,
+            deliveryService,
+        });
+        approvalNotifier.start();
+        channelsLogger.debug("Approval notifier started");
+        // Clean up notifier on shutdown
+        container.eventBus.on("system:shutdown", () => {
+            approvalNotifier?.stop();
+        });
+    }
+    return { channelManager, lifecycleReactors, approvalNotifier, commandQueue };
+}

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

@@ -45,13 +45,20 @@ export async function bootstrapAdapters(deps) {
         if (channelConfig.telegram.enabled) {
             const token = channelConfig.telegram.botToken || getSecret("TELEGRAM_BOT_TOKEN");
             if (token) {
-                const validation = await validateBotToken(token);
+                // E2E redirection seam: when channels.telegram.apiRoot is set,
+                // point grammy's Bot constructor at the override URL. Production
+                // leaves it unset.
+                const telegramApiRoot = channelConfig.telegram.apiRoot && channelConfig.telegram.apiRoot.length > 0
+                    ? channelConfig.telegram.apiRoot
+                    : undefined;
+                const validation = await validateBotToken(token, telegramApiRoot);
                 if (validation.ok) {
                     const plugin = createTelegramPlugin({
                         botToken: token,
                         webhookSecret: channelConfig.telegram.webhookUrl ? (getSecret("TELEGRAM_WEBHOOK_SECRET") ?? undefined) : undefined,
                         webhookUrl: channelConfig.telegram.webhookUrl,
                         logger: channelsLogger,
+                        ...(telegramApiRoot ? { apiRoot: telegramApiRoot } : {}),
                     });
                     tgPlugin = plugin;
                     adaptersByType.set("telegram", plugin.adapter);
@@ -71,11 +78,19 @@ export async function bootstrapAdapters(deps) {
         if (channelConfig.discord.enabled) {
             const token = channelConfig.discord.botToken || getSecret("DISCORD_BOT_TOKEN");
             if (token) {
-                const validation = await validateDiscordToken(token);
+                // E2E redirection seam: when discord.apiRoot is set, both validation
+                // (/users/@me) and runtime traffic (REST + gateway-discovery via
+                // /gateway/bot) hit the override URL. Production leaves it unset and
+                // discord.js uses https://discord.com/api.
+                const discordApiRoot = channelConfig.discord.apiRoot && channelConfig.discord.apiRoot.length > 0
+                    ? channelConfig.discord.apiRoot
+                    : undefined;
+                const validation = await validateDiscordToken(token, discordApiRoot);
                 if (validation.ok) {
                     const plugin = createDiscordPlugin({
                         botToken: token,
                         logger: channelsLogger,
+                        ...(discordApiRoot ? { apiRoot: discordApiRoot } : {}),
                     });
                     adaptersByType.set("discord", plugin.adapter);
                     channelCapabilities.set("discord", { supportsReactions: true, replyToMetaKey: "discordMessageId" });
@@ -97,7 +112,20 @@ export async function bootstrapAdapters(deps) {
             if (token) {
                 const appToken = mode === "socket" ? (channelConfig.slack.appToken || getSecret("SLACK_APP_TOKEN")) : undefined;
                 const signingSecret = mode === "http" ? (channelConfig.slack.signingSecret || getSecret("SLACK_SIGNING_SECRET")) : undefined;
-                const validation = await validateSlackCredentials({ botToken: token, mode, appToken, signingSecret });
+                // E2E redirection seam: when slack.apiRoot is set, both auth.test()
+                // validation and runtime WebClient traffic hit the override URL via
+                // clientOptions.slackApiUrl. Socket-mode WebSocket connections cannot
+                // be redirected — E2E tests use mode='http'.
+                const slackApiRoot = channelConfig.slack.apiRoot && channelConfig.slack.apiRoot.length > 0
+                    ? channelConfig.slack.apiRoot
+                    : undefined;
+                const validation = await validateSlackCredentials({
+                    botToken: token,
+                    mode,
+                    appToken,
+                    signingSecret,
+                    ...(slackApiRoot ? { apiRoot: slackApiRoot } : {}),
+                });
                 if (validation.ok) {
                     const plugin = createSlackPlugin({
                         botToken: token,
@@ -105,6 +133,7 @@ export async function bootstrapAdapters(deps) {
                         appToken,
                         signingSecret,
                         logger: channelsLogger,
+                        ...(slackApiRoot ? { apiRoot: slackApiRoot } : {}),
                     });
                     adaptersByType.set("slack", plugin.adapter);
                     channelCapabilities.set("slack", { supportsReactions: true, replyToMetaKey: "slackTs" });
@@ -123,11 +152,18 @@ export async function bootstrapAdapters(deps) {
         if (channelConfig.whatsapp.enabled) {
             const authDir = channelConfig.whatsapp.authDir || safePath(safePath(os.homedir(), ".comis"), "whatsapp-auth");
             const validation = await validateWhatsAppAuth({ authDir, printQR: channelConfig.whatsapp.printQR });
+            // E2E redirection seam: when whatsapp.apiRoot is set, Baileys's
+            // WebSocket connects to the override URL instead of
+            // wss://web.whatsapp.com/ws/chat. Production leaves unset.
+            const whatsappApiRoot = channelConfig.whatsapp.apiRoot && channelConfig.whatsapp.apiRoot.length > 0
+                ? channelConfig.whatsapp.apiRoot
+                : undefined;
             if (validation.ok) {
                 const plugin = createWhatsAppPlugin({
                     authDir,
                     printQR: channelConfig.whatsapp.printQR,
                     logger: channelsLogger,
+                    ...(whatsappApiRoot ? { apiRoot: whatsappApiRoot } : {}),
                 });
                 adaptersByType.set("whatsapp", plugin.adapter);
                 channelCapabilities.set("whatsapp", { supportsReactions: true, replyToMetaKey: "whatsappMessageId" });
@@ -162,13 +198,24 @@ export async function bootstrapAdapters(deps) {
             const accessToken = channelConfig.line.botToken || getSecret("LINE_CHANNEL_ACCESS_TOKEN");
             const channelSecret = channelConfig.line.channelSecret || getSecret("LINE_CHANNEL_SECRET");
             if (accessToken && channelSecret) {
-                const validation = await validateLineCredentials({ channelAccessToken: accessToken, channelSecret });
+                // E2E redirection seam: when line.apiRoot is set, the LINE SDK
+                // client targets the override URL (instead of api.line.me).
+                // Production leaves unset.
+                const lineApiRoot = channelConfig.line.apiRoot && channelConfig.line.apiRoot.length > 0
+                    ? channelConfig.line.apiRoot
+                    : undefined;
+                const validation = await validateLineCredentials({
+                    channelAccessToken: accessToken,
+                    channelSecret,
+                    ...(lineApiRoot ? { apiRoot: lineApiRoot } : {}),
+                });
                 if (validation.ok) {
                     const plugin = createLinePlugin({
                         channelAccessToken: accessToken,
                         channelSecret,
                         webhookPath: channelConfig.line.webhookPath,
                         logger: channelsLogger,
+                        ...(lineApiRoot ? { apiRoot: lineApiRoot } : {}),
                     });
                     linePlugin = plugin;
                     adaptersByType.set("line", plugin.adapter);

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

@@ -11,8 +11,8 @@ import { randomUUID } from "node:crypto";
 import { isVisionCapable } from "@comis/agent";
 import { createWhatsAppResolver, createSlackResolver, createIMessageResolver, audioPreflight, } from "@comis/channels";
 import { createCompositeResolver, createMediaPersistenceService, preprocessMessage, sanitizeImageForApi, createVisionProviderRegistry, selectVisionProvider, } from "@comis/skills";
-import { getModel } from "@mariozechner/pi-ai";
-import { safePath } from "@comis/core";
+import { getModel } from "@earendil-works/pi-ai";
+import { safePath, systemNowMs } from "@comis/core";
 import os from "node:os";
 // ---------------------------------------------------------------------------
 // Build function
@@ -243,7 +243,7 @@ export async function buildMediaPipeline(deps) {
                     chars: fe.extractedChars,
                     truncated: fe.truncated,
                     durationMs: fe.durationMs,
-                    timestamp: Date.now(),
+                    timestamp: systemNowMs(),
                 });
             }
             // Store memory entries linking persisted files to text descriptions
@@ -270,7 +270,7 @@ export async function buildMediaPipeline(deps) {
                             trustLevel: "learned",
                             source: { who: senderInfo, channel: channelType },
                             tags: ["media-file", pf.mediaKind],
-                            createdAt: Date.now(),
+                            createdAt: systemNowMs(),
                         });
                         if (storeResult.ok && deps.embeddingQueue) {
                             deps.embeddingQueue.enqueue(entryId, content);
@@ -289,7 +289,7 @@ export async function buildMediaPipeline(deps) {
                         sizeBytes: pf.sizeBytes,
                         mediaKind: pf.mediaKind,
                         agentId,
-                        timestamp: Date.now(),
+                        timestamp: systemNowMs(),
                     });
                 }
                 channelsLogger.debug?.({ count: persistedFiles.length, paths: persistedFiles.map(f => f.relativePath) }, "Media persistence batch complete");

package/node_modules/@comis/daemon/dist/wiring/setup-cross-session/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Daemon cross-session-subsystem wiring.
+ *
+ * Barrel re-export of the canonical public API. No aliases — every export
+ * keeps its canonical name.
+ *
+ * Decomposition:
+ *   - setup-cross-session-runtime.ts — setupCrossSession orchestrator + sendToChannel + announceToParent + crossSessionSender + announcement batcher + result condenser + sub-agent runner construction
+ *   - setup-cross-session-graph.ts   — buildExecuteSubAgent + resolveGraphCacheRetention + SUB_AGENT_TOOL_DENYLIST + MIN_SUB_AGENT_STEPS
+ *   - setup-cross-session-events.ts  — registerProxyTypingListeners (typing:proxy_start/stop + TTL sweep + shutdown)
+ *
+ * @module
+ */
+export type { CrossSessionResult } from "./setup-cross-session-runtime.js";
+export { setupCrossSession } from "./setup-cross-session-runtime.js";
+export { resolveGraphCacheRetention, MIN_SUB_AGENT_STEPS, SUB_AGENT_TOOL_DENYLIST, } from "./setup-cross-session-graph.js";

package/node_modules/@comis/daemon/dist/wiring/setup-cross-session/index.js

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Daemon cross-session-subsystem wiring.
+ *
+ * Barrel re-export of the canonical public API. No aliases — every export
+ * keeps its canonical name.
+ *
+ * Decomposition:
+ *   - setup-cross-session-runtime.ts — setupCrossSession orchestrator + sendToChannel + announceToParent + crossSessionSender + announcement batcher + result condenser + sub-agent runner construction
+ *   - setup-cross-session-graph.ts   — buildExecuteSubAgent + resolveGraphCacheRetention + SUB_AGENT_TOOL_DENYLIST + MIN_SUB_AGENT_STEPS
+ *   - setup-cross-session-events.ts  — registerProxyTypingListeners (typing:proxy_start/stop + TTL sweep + shutdown)
+ *
+ * @module
+ */
+export { setupCrossSession } from "./setup-cross-session-runtime.js";
+export { resolveGraphCacheRetention, MIN_SUB_AGENT_STEPS, SUB_AGENT_TOOL_DENYLIST, } from "./setup-cross-session-graph.js";

package/node_modules/@comis/daemon/dist/wiring/setup-cross-session/setup-cross-session-events.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Proxy typing event listener registration for cross-session messaging.
+ *
+ * Hosts the `typing:proxy_start` / `typing:proxy_stop` event handlers and
+ * the TTL sweep timer that the registry orchestrator wires after
+ * sub-agent runner construction. The handlers create per-run
+ * TypingController instances scoped to the parent-channel adapter and
+ * clean up on graceful shutdown.
+ *
+ * @module
+ */
+import type { AppContainer, ChannelPort } from "@comis/core";
+import type { ComisLogger } from "@comis/infra";
+/**
+ * Closure-captured dependencies for the proxy typing event handlers.
+ */
+export interface ProxyTypingListenerDeps {
+    container: AppContainer;
+    adaptersByType: Map<string, ChannelPort & {
+        platformAction?(action: string, params: Record<string, unknown>): Promise<unknown>;
+    }>;
+    logger?: ComisLogger;
+}
+/**
+ * Register the proxy typing event handlers on the daemon event bus. Three
+ * listeners are attached:
+ *   1. `typing:proxy_start` — create TypingController for parent channel
+ *      (no-op when the platform lacks typing support or the runId is already
+ *      tracked).
+ *   2. `typing:proxy_stop` — stop the controller and remove the entry.
+ *   3. `system:shutdown` — stop every active controller + clear the TTL
+ *      sweep timer.
+ *
+ * Additionally schedules a TTL sweep timer that stops any controller older
+ * than 5 minutes (mirrors the sub-agent watchdog timeout).
+ */
+export declare function registerProxyTypingListeners(deps: ProxyTypingListenerDeps): void;