comisai 1.0.37 → 1.0.40

package/node_modules/@comis/channels/dist/shared/execution-pipeline.d.ts

@@ -1,103 +0,0 @@
-/**
- * Execution Pipeline: Thin orchestrator for outbound delivery.
- *
- * Delegates to 4 focused phase modules:
- *   1. execution-policy  — send policy gate, trust level, elevated reply routing
- *   2. execution-execute — LLM execution with timeout, thinking filter, abort
- *   3. execution-filter  — response sanitization, filtering, media, voice, prefix
- *   4. execution-deliver — chunking, coalescing, block pacing, delivery
- *
- * Keeps follow-up trigger logic here (needs full closure deps for re-enqueue).
- *
- * @module
- */
-import type { ChannelPort, NormalizedMessage, SessionKey, TypedEventBus, DeliveryQueuePort } from "@comis/core";
-import type { PerChannelStreamingConfig, StreamingConfig } from "@comis/core";
-import type { SendPolicyConfig, ElevatedReplyConfig } from "@comis/core";
-import type { SendMessageOptions } from "@comis/core";
-import type { ComisLogger } from "@comis/infra";
-import type { Result } from "@comis/shared";
-import type { AgentExecutor } from "@comis/agent";
-import type { CommandQueue } from "@comis/agent";
-import type { FollowupTrigger } from "@comis/agent";
-import type { BlockPacer } from "./block-pacer.js";
-import type { TypingLifecycleController } from "./typing-lifecycle-controller.js";
-import type { ChannelRegistry } from "./channel-registry.js";
-import type { SendOverrideStore } from "./send-policy.js";
-import type { RetryEngine } from "./retry-engine.js";
-import type { VoiceResponsePipelineDeps } from "./voice-response-pipeline.js";
-/** Maps channelType to the metadata key containing the platform message ID for reply-to. */
-export declare const REPLY_TO_META_KEY: Record<string, string>;
-/**
- * Metadata keys that carry thread context -- must be propagated to followup messages.
- * Mirror of TELEGRAM_THREAD_META_KEYS in thread-context.ts -- kept in sync via
- * cross-reference unit test.
- */
-export declare const THREAD_PROPAGATION_KEYS: readonly ["threadId", "telegramThreadId", "telegramIsForum", "telegramThreadScope"];
-/**
- * Build thread-related SendMessageOptions from inbound message metadata.
- * Returns undefined when no thread context present.
- */
-export declare function buildThreadSendOpts(metadata?: Record<string, unknown>): Pick<SendMessageOptions, "threadId" | "extra"> | undefined;
-/** Narrow deps interface for the execution pipeline. */
-export interface ExecutionPipelineDeps {
-    eventBus: TypedEventBus;
-    logger: ComisLogger;
-    streamingConfig?: StreamingConfig;
-    sendPolicyConfig?: SendPolicyConfig;
-    getElevatedReplyConfig?: (agentId: string) => ElevatedReplyConfig | undefined;
-    channelRegistry?: ChannelRegistry;
-    retryEngine?: RetryEngine;
-    followupTrigger?: FollowupTrigger;
-    followupConfig?: {
-        maxFollowupRuns: number;
-    };
-    commandQueue?: CommandQueue;
-    assembleToolsForAgent?: (agentId: string, options?: {
-        sessionKey?: SessionKey;
-    }) => Promise<any[]>;
-    voiceResponsePipeline?: VoiceResponsePipelineDeps;
-    parseOutboundMedia?: (text: string) => {
-        text: string;
-        mediaUrls: string[];
-    };
-    outboundMediaFetch?: (url: string) => Promise<Result<{
-        buffer: Buffer;
-        mimeType?: string;
-    }, Error>>;
-    /** Optional callback for task extraction after successful agent execution. */
-    onTaskExtraction?: (conversationText: string, sessionKey: string, agentId: string) => Promise<void>;
-    /** Response prefix config for template-based prefix/suffix on agent responses. */
-    responsePrefixConfig?: {
-        template: string;
-        position: "prepend" | "append";
-    };
-    /** Template context builder for response prefix variables. */
-    buildTemplateContext?: (agentId: string, channelType: string, msg: NormalizedMessage) => Record<string, string>;
-    /** Wall-clock timeout for agent execution, in ms. Default: 600,000 (10 min). */
-    executionTimeoutMs?: number;
-    /** Delivery queue for crash-safe persistence. */
-    deliveryQueue?: DeliveryQueuePort;
-    /**
-     * Per-instance set of in-flight outbound sendMessage promises. Threaded
-     * through DeliverToChannelDeps so deliver-to-channel can register active
-     * sends. Drained in stopAll() with a 5s deadline so SIGUSR2 cannot tear
-     * down adapters mid-send. Created by the channel-manager factory; do not
-     * pass externally.
-     */
-    inFlightSends?: Set<Promise<unknown>>;
-    /** When true, only content inside <final> blocks reaches users. */
-    enforceFinalTag?: boolean;
-}
-/**
- * Resolve per-channel streaming configuration.
- *
- * Priority: per-channel override > global defaults > hardcoded defaults.
- */
-export declare function resolveStreamingConfig(channelType: string, streamingConfig?: StreamingConfig): PerChannelStreamingConfig;
-/**
- * Execute a message with block streaming delivery.
- *
- * Orchestrates 4 phases: policy -> execute -> filter -> deliver.
- */
-export declare function executeAndDeliver(deps: ExecutionPipelineDeps, adapter: ChannelPort, effectiveMsg: NormalizedMessage, originalMsg: NormalizedMessage, executor: AgentExecutor, sessionKey: SessionKey, agentId: string, blockStreamCfg: PerChannelStreamingConfig, activePacers: Set<BlockPacer>, sendOverrides: SendOverrideStore, typingLifecycle?: TypingLifecycleController, directives?: Record<string, unknown>): Promise<void>;

package/node_modules/@comis/channels/dist/shared/execution-pipeline.js

@@ -1,294 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Execution Pipeline: Thin orchestrator for outbound delivery.
- *
- * Delegates to 4 focused phase modules:
- *   1. execution-policy  — send policy gate, trust level, elevated reply routing
- *   2. execution-execute — LLM execution with timeout, thinking filter, abort
- *   3. execution-filter  — response sanitization, filtering, media, voice, prefix
- *   4. execution-deliver — chunking, coalescing, block pacing, delivery
- *
- * Keeps follow-up trigger logic here (needs full closure deps for re-enqueue).
- *
- * @module
- */
-import { randomUUID } from "node:crypto";
-import { formatSessionKey, runWithContext, createDeliveryOrigin } from "@comis/core";
-// Phase module imports
-import { evaluateExecutionPolicy } from "./execution-policy.js";
-import { executeLlm } from "./execution-execute.js";
-import { filterExecutionResponse } from "./execution-filter.js";
-import { deliverExecutionResponse } from "./execution-deliver.js";
-// ---------------------------------------------------------------------------
-// Platform-specific configuration
-// ---------------------------------------------------------------------------
-/** Maps channelType to the metadata key containing the platform message ID for reply-to. */
-export const REPLY_TO_META_KEY = {
-    telegram: "telegramMessageId",
-    discord: "discordMessageId",
-    slack: "slackTs",
-    whatsapp: "whatsappMessageId",
-};
-/**
- * Metadata keys that carry thread context -- must be propagated to followup messages.
- * Mirror of TELEGRAM_THREAD_META_KEYS in thread-context.ts -- kept in sync via
- * cross-reference unit test.
- */
-export const THREAD_PROPAGATION_KEYS = [
-    "threadId", "telegramThreadId", "telegramIsForum", "telegramThreadScope",
-];
-/**
- * Build thread-related SendMessageOptions from inbound message metadata.
- * Returns undefined when no thread context present.
- */
-export function buildThreadSendOpts(metadata) {
-    const threadId = metadata?.threadId;
-    if (!threadId)
-        return undefined;
-    return {
-        threadId,
-        extra: metadata?.telegramThreadScope
-            ? { telegramThreadScope: metadata.telegramThreadScope }
-            : undefined,
-    };
-}
-// ---------------------------------------------------------------------------
-// Streaming config resolution
-// ---------------------------------------------------------------------------
-/**
- * Resolve per-channel streaming configuration.
- *
- * Priority: per-channel override > global defaults > hardcoded defaults.
- */
-export function resolveStreamingConfig(channelType, streamingConfig) {
-    const global = streamingConfig;
-    if (!global) {
-        return {
-            enabled: true,
-            chunkMode: "paragraph",
-            chunkMinChars: 100,
-            deliveryTiming: { mode: "natural", minMs: 800, maxMs: 2500, jitterMs: 200, firstBlockDelayMs: 0 },
-            coalescer: { minChars: 0, maxChars: 500, idleMs: 1500, codeBlockPolicy: "standalone", adaptiveIdle: false },
-            typingMode: "thinking",
-            typingRefreshMs: 6000,
-            typingCircuitBreakerThreshold: 3,
-            typingTtlMs: 60000,
-            useMarkdownIR: true,
-            tableMode: "code",
-            replyMode: "first",
-        };
-    }
-    const perChannel = global.perChannel[channelType];
-    if (perChannel)
-        return perChannel;
-    return {
-        enabled: global.enabled,
-        chunkMode: global.defaultChunkMode,
-        chunkMinChars: 100,
-        deliveryTiming: global.defaultDeliveryTiming,
-        coalescer: global.defaultCoalescer,
-        typingMode: global.defaultTypingMode,
-        typingRefreshMs: global.defaultTypingRefreshMs,
-        typingCircuitBreakerThreshold: 3,
-        typingTtlMs: 60000,
-        useMarkdownIR: global.defaultUseMarkdownIR ?? true,
-        tableMode: global.defaultTableMode ?? "code",
-        replyMode: global.defaultReplyMode ?? "first",
-    };
-}
-// ---------------------------------------------------------------------------
-// Main execution pipeline (thin orchestrator)
-// ---------------------------------------------------------------------------
-/**
- * Execute a message with block streaming delivery.
- *
- * Orchestrates 4 phases: policy -> execute -> filter -> deliver.
- */
-export async function executeAndDeliver(deps, adapter, effectiveMsg, originalMsg, executor, sessionKey, agentId, blockStreamCfg, activePacers, sendOverrides, typingLifecycle, directives) {
-    // Track lifecycle timing for diagnostic:message_processed event
-    const receivedAt = Date.now();
-    /** Emit diagnostic:message_processed with current lifecycle state. */
-    function emitDiagnostic(tokensUsed, cost, finishReason) {
-        deps.eventBus.emit("diagnostic:message_processed", {
-            messageId: effectiveMsg.id,
-            channelId: effectiveMsg.channelId,
-            channelType: adapter.channelType,
-            agentId,
-            sessionKey: formatSessionKey(sessionKey),
-            receivedAt,
-            executionDurationMs: Date.now() - receivedAt,
-            deliveryDurationMs: 0,
-            totalDurationMs: Date.now() - receivedAt,
-            tokensUsed,
-            cost,
-            success: true,
-            finishReason,
-            timestamp: Date.now(),
-        });
-    }
-    // Resolve tools for this agent.
-    // Pass sessionKey so setup-tools can thread the session's persistent
-    // FileStateTracker (per SessionTrackerRegistry) through the assembled
-    // tool pipeline -- keeps cross-turn file read state alive and removes
-    // the [not_read] bootstrap trap for seeded workspace files.
-    const tools = deps.assembleToolsForAgent
-        ? await deps.assembleToolsForAgent(agentId, { sessionKey })
-        : undefined;
-    if (tools) {
-        deps.logger.debug({ agentId, toolCount: tools.length }, "Tools assembled for agent");
-    }
-    // Phase 1: Send policy gate, trust level, elevated reply routing
-    const policy = evaluateExecutionPolicy(deps, adapter, effectiveMsg, originalMsg, sessionKey, agentId, sendOverrides);
-    if (!policy.allowed) {
-        // Still execute the agent (for session history), just skip sending
-        const policyResult = await runWithContext({
-            traceId: randomUUID(),
-            tenantId: sessionKey.tenantId,
-            userId: sessionKey.userId,
-            sessionKey: formatSessionKey(sessionKey),
-            startedAt: Date.now(),
-            trustLevel: policy.trustLevel,
-            channelType: adapter.channelType,
-            deliveryOrigin: createDeliveryOrigin({
-                channelType: adapter.channelType,
-                channelId: effectiveMsg.channelId,
-                userId: sessionKey.userId,
-                threadId: effectiveMsg.metadata?.threadId,
-                tenantId: sessionKey.tenantId,
-            }),
-        }, () => executor.execute(effectiveMsg, sessionKey, tools, undefined, agentId, directives, undefined, { operationType: "interactive" }));
-        emitDiagnostic(policyResult.tokensUsed.total, policyResult.cost.total, policyResult.finishReason);
-        return;
-    }
-    // Phase 2: LLM execution with timeout, thinking filter, abort signal
-    const execResult = await executeLlm(deps, adapter, policy.effectiveMsg, sessionKey, agentId, executor, policy.trustLevel, blockStreamCfg, policy.replyTo, typingLifecycle, tools, directives);
-    try {
-        if (execResult.timedOut) {
-            emitDiagnostic(0, 0, "timeout");
-            return;
-        }
-        // Follow-up trigger check — stays in orchestrator for closure access
-        handleFollowupTrigger(deps, adapter, policy.effectiveMsg, sessionKey, agentId, executor, execResult.result, execResult.finishReason, blockStreamCfg, activePacers, sendOverrides);
-        // Signal execution complete for thinking mode
-        if (typingLifecycle && blockStreamCfg.typingMode !== "message") {
-            typingLifecycle.markRunComplete();
-        }
-        // Phase 3: Response sanitization, filtering, media, voice, prefix
-        const filterResult = await filterExecutionResponse(deps, adapter, policy.effectiveMsg, originalMsg, sessionKey, agentId, execResult.result, execResult.accumulated, policy.replyTo, execResult.resourceAborted, execResult.abortReason, execResult.finishReason);
-        if (!filterResult.deliver) {
-            if (filterResult.reason === "filtered") {
-                emitDiagnostic(execResult.tokensUsed, execResult.cost, "filtered");
-            }
-            else if (filterResult.reason === "voice_delivered") {
-                emitDiagnostic(execResult.tokensUsed, execResult.cost, execResult.finishReason);
-            }
-            else {
-                emitDiagnostic(execResult.tokensUsed, execResult.cost, execResult.finishReason);
-            }
-            return;
-        }
-        // Phase 4: Chunking, coalescing, block pacing, delivery
-        await deliverExecutionResponse(deps, adapter, policy.effectiveMsg, filterResult.text, blockStreamCfg, activePacers, policy.replyTo, execResult.deliverySignal, typingLifecycle);
-        // Emit message:sent event with the cleaned response content
-        deps.eventBus.emit("message:sent", {
-            channelId: policy.effectiveMsg.channelId,
-            messageId: "block-delivery",
-            content: filterResult.text,
-        });
-        // Task extraction: extract commitments/follow-ups from the conversation (non-blocking)
-        if (deps.onTaskExtraction && filterResult.text) {
-            deps.onTaskExtraction(filterResult.text, formatSessionKey(sessionKey), agentId).catch((err) => {
-                deps.logger.debug({ err: err instanceof Error ? err.message : String(err) }, "Task extraction callback error (non-blocking)");
-            });
-        }
-        // Emit diagnostic:message_processed for full lifecycle tracking
-        emitDiagnostic(execResult.tokensUsed, execResult.cost, execResult.finishReason);
-    }
-    finally {
-        // Cleanup event listeners from execution phase
-        execResult.cleanup();
-        // Ensure typing is always stopped on error/completion
-        if (typingLifecycle) {
-            const wasActive = typingLifecycle.controller.isActive;
-            const startedAt = typingLifecycle.controller.startedAt;
-            typingLifecycle.dispose();
-            if (wasActive) {
-                deps.eventBus.emit("typing:stopped", {
-                    channelId: adapter.channelId,
-                    chatId: policy.effectiveMsg.channelId,
-                    durationMs: Date.now() - startedAt,
-                    timestamp: Date.now(),
-                });
-            }
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// Follow-up trigger (kept in orchestrator for closure deps access)
-// ---------------------------------------------------------------------------
-/** Check and enqueue follow-up if trigger conditions are met. */
-function handleFollowupTrigger(deps, adapter, effectiveMsg, sessionKey, agentId, executor, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-result, diagFinishReason, blockStreamCfg, activePacers, sendOverrides) {
-    if (!deps.followupTrigger || !deps.commandQueue)
-        return;
-    const resultMeta = {};
-    const resMeta = result.metadata;
-    if (resMeta?.needs_followup)
-        resultMeta.needs_followup = true;
-    if (resMeta?.compaction_triggered)
-        resultMeta.compaction_triggered = true;
-    if (diagFinishReason === "compaction")
-        resultMeta.compaction_triggered = true;
-    if (!deps.followupTrigger.shouldFollowup(resultMeta))
-        return;
-    const chainId = effectiveMsg.metadata?.followupChainId ?? randomUUID();
-    const currentDepth = deps.followupTrigger.getChainDepth(chainId);
-    const maxDepth = deps.followupConfig?.maxFollowupRuns ?? 3;
-    if (currentDepth >= maxDepth) {
-        deps.eventBus.emit("followup:depth_exceeded", {
-            sessionKey: formatSessionKey(sessionKey),
-            chainId,
-            maxDepth,
-            timestamp: Date.now(),
-        });
-        return;
-    }
-    const newDepth = deps.followupTrigger.incrementChain(chainId);
-    const threadMeta = {};
-    for (const key of THREAD_PROPAGATION_KEYS) {
-        if (effectiveMsg.metadata?.[key] != null) {
-            threadMeta[key] = effectiveMsg.metadata[key];
-        }
-    }
-    const followupMsg = deps.followupTrigger.createFollowupMessage(sessionKey, adapter.channelType, effectiveMsg.channelId, resultMeta.compaction_triggered ? "compaction" : "tool_result", chainId, newDepth, Object.keys(threadMeta).length > 0 ? threadMeta : undefined);
-    deps.eventBus.emit("followup:enqueued", {
-        sessionKey: formatSessionKey(sessionKey),
-        channelType: adapter.channelType,
-        reason: resultMeta.compaction_triggered ? "compaction" : "tool_result",
-        chainId,
-        chainDepth: newDepth,
-        timestamp: Date.now(),
-    });
-    // Re-enqueue follow-up through command queue (fire-and-forget)
-    deps.commandQueue.enqueue(sessionKey, followupMsg, adapter.channelType, async (messages) => {
-        const fMsg = messages[0];
-        await executeAndDeliver(deps, adapter, fMsg, fMsg, executor, sessionKey, agentId, blockStreamCfg, activePacers, sendOverrides, undefined);
-    }).then((enqueueResult) => {
-        if (!enqueueResult.ok) {
-            deps.logger.warn({
-                err: enqueueResult.error.message,
-                hint: "Check if command queue is shut down or overflow policy rejected the message",
-                errorKind: "resource",
-                channelType: adapter.channelType,
-            }, "Follow-up enqueue failed");
-        }
-    }).catch((e) => {
-        deps.logger.warn({
-            err: e instanceof Error ? e.message : String(e),
-            hint: "Unexpected error during follow-up enqueue",
-            errorKind: "internal",
-            channelType: adapter.channelType,
-        }, "Follow-up enqueue failed");
-    });
-}

package/node_modules/@comis/channels/dist/shared/execution-policy.d.ts

@@ -1,34 +0,0 @@
-/**
- * Execution Pipeline Phase 1: Send Policy and Trust Routing.
- *
- * Evaluates the send policy gate, resolves sender trust level,
- * and applies elevated reply model/prompt routing.
- *
- * @module
- */
-import type { ChannelPort, NormalizedMessage, SessionKey } from "@comis/core";
-import type { ExecutionPipelineDeps } from "./execution-pipeline.js";
-import type { SendOverrideStore } from "./send-policy.js";
-/** Minimal deps needed for the policy phase. */
-export type PolicyDeps = Pick<ExecutionPipelineDeps, "eventBus" | "logger" | "sendPolicyConfig" | "getElevatedReplyConfig" | "channelRegistry">;
-/** Result of policy evaluation. */
-export interface PolicyResult {
-    /** Whether the message should proceed to execution+delivery. */
-    allowed: boolean;
-    /** Resolved sender trust level. */
-    trustLevel: "guest" | "user" | "admin";
-    /** Message with elevated reply metadata injected (model route, prompt override). */
-    effectiveMsg: NormalizedMessage;
-    /** Metadata key for reply-to. */
-    replyToMetaKey: string | undefined;
-    /** Message ID for reply-to (group only). */
-    replyTo: string | undefined;
-}
-/**
- * Evaluate send policy, resolve trust level, and apply elevated reply routing.
- *
- * When `allowed` is false, the caller should still run execution (for session
- * history) but skip delivery. The caller is responsible for running the
- * silent execution in that case.
- */
-export declare function evaluateExecutionPolicy(deps: PolicyDeps, adapter: ChannelPort, effectiveMsg: NormalizedMessage, originalMsg: NormalizedMessage, sessionKey: SessionKey, agentId: string, sendOverrides: SendOverrideStore): PolicyResult;

package/node_modules/@comis/channels/dist/shared/execution-policy.js

@@ -1,128 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Execution Pipeline Phase 1: Send Policy and Trust Routing.
- *
- * Evaluates the send policy gate, resolves sender trust level,
- * and applies elevated reply model/prompt routing.
- *
- * @module
- */
-import { formatSessionKey } from "@comis/core";
-import { isGroupMessage } from "./auto-reply-engine.js";
-import { evaluateSendPolicy, applySessionOverride } from "./send-policy.js";
-import { REPLY_TO_META_KEY } from "./execution-pipeline.js";
-// ---------------------------------------------------------------------------
-// Phase function
-// ---------------------------------------------------------------------------
-/**
- * Evaluate send policy, resolve trust level, and apply elevated reply routing.
- *
- * When `allowed` is false, the caller should still run execution (for session
- * history) but skip delivery. The caller is responsible for running the
- * silent execution in that case.
- */
-export function evaluateExecutionPolicy(deps, adapter, effectiveMsg, originalMsg, sessionKey, agentId, sendOverrides) {
-    // Capability-driven config lookup (falls back to hardcoded maps)
-    const caps = deps.channelRegistry?.getCapabilities(adapter.channelType);
-    const metaKey = caps?.replyToMetaKey ?? REPLY_TO_META_KEY[adapter.channelType];
-    // In DMs, skip reply-to -- quoting the user's own message adds noise in 1-on-1 chats.
-    const replyTo = isGroupMessage(originalMsg) && metaKey && originalMsg.metadata?.[metaKey]
-        ? String(originalMsg.metadata[metaKey])
-        : undefined;
-    // Resolve sender trust level from elevatedReply config (defaults to "user")
-    let resolvedTrustLevel = "user";
-    if (deps.getElevatedReplyConfig) {
-        const elevCfg = deps.getElevatedReplyConfig(agentId);
-        if (elevCfg?.enabled) {
-            const senderId = effectiveMsg.senderId;
-            const mapped = elevCfg.senderTrustMap[senderId] ?? elevCfg.defaultTrustLevel;
-            if (mapped === "admin" || mapped === "user" || mapped === "guest") {
-                resolvedTrustLevel = mapped;
-            }
-        }
-    }
-    // -------------------------------------------------------------------
-    // SEND POLICY GATE (checked once before any delivery path)
-    // -------------------------------------------------------------------
-    if (deps.sendPolicyConfig?.enabled) {
-        const policyCtx = {
-            channelId: adapter.channelId,
-            channelType: adapter.channelType,
-            chatType: originalMsg.chatType ?? "dm",
-        };
-        let policyDecision = evaluateSendPolicy(policyCtx, deps.sendPolicyConfig);
-        // Apply per-session override
-        const overrideKey = formatSessionKey(sessionKey);
-        const override = sendOverrides.get(overrideKey);
-        policyDecision = applySessionOverride(policyDecision, override);
-        if (!policyDecision.allowed) {
-            deps.eventBus.emit("sendpolicy:denied", {
-                channelId: adapter.channelId,
-                channelType: adapter.channelType,
-                chatType: policyCtx.chatType,
-                reason: policyDecision.reason,
-                timestamp: Date.now(),
-            });
-            deps.logger.info({ channelId: adapter.channelId, reason: policyDecision.reason }, "Send policy denied outbound message");
-            return {
-                allowed: false,
-                trustLevel: resolvedTrustLevel,
-                effectiveMsg,
-                replyToMetaKey: metaKey,
-                replyTo,
-            };
-        }
-        deps.eventBus.emit("sendpolicy:allowed", {
-            channelId: adapter.channelId,
-            channelType: adapter.channelType,
-            chatType: policyCtx.chatType,
-            reason: policyDecision.reason,
-            timestamp: Date.now(),
-        });
-    }
-    // -------------------------------------------------------------------
-    // ELEVATED REPLY MODE
-    // -------------------------------------------------------------------
-    let msg = effectiveMsg;
-    if (deps.getElevatedReplyConfig) {
-        const elevConfig = deps.getElevatedReplyConfig(agentId);
-        if (elevConfig?.enabled) {
-            const senderId = msg.senderId;
-            const trustLevel = elevConfig.senderTrustMap[senderId] ?? elevConfig.defaultTrustLevel;
-            const modelRoute = elevConfig.trustModelRoutes[trustLevel];
-            if (modelRoute) {
-                deps.eventBus.emit("elevated:model_routed", {
-                    sessionKey: formatSessionKey(sessionKey),
-                    senderTrustLevel: trustLevel,
-                    modelRoute,
-                    agentId,
-                    timestamp: Date.now(),
-                });
-                msg = {
-                    ...msg,
-                    metadata: {
-                        ...(msg.metadata ?? {}),
-                        modelRoute,
-                    },
-                };
-            }
-            const promptOverride = elevConfig.trustPromptOverrides[trustLevel];
-            if (promptOverride) {
-                msg = {
-                    ...msg,
-                    metadata: {
-                        ...(msg.metadata ?? {}),
-                        systemPromptOverride: promptOverride,
-                    },
-                };
-            }
-        }
-    }
-    return {
-        allowed: true,
-        trustLevel: resolvedTrustLevel,
-        effectiveMsg: msg,
-        replyToMetaKey: metaKey,
-        replyTo,
-    };
-}

package/node_modules/@comis/channels/dist/shared/inbound-gate.d.ts

@@ -1,35 +0,0 @@
-/**
- * Inbound Pipeline Phase 3: Message Gate.
- *
- * Evaluates auto-reply rules, handles slash commands (/send, /approve,
- * /deny, /config, /stop, general commands), reset triggers, and prompt
- * skill detection. Returns a gate decision indicating whether the message
- * should be processed, skipped, or was handled inline (command response sent).
- *
- * @module
- */
-import type { ChannelPort, NormalizedMessage, SessionKey } from "@comis/core";
-import type { InboundPipelineDeps } from "./inbound-pipeline.js";
-import type { SendOverrideStore } from "./send-policy.js";
-/** Minimal deps needed for the gate phase. */
-export type GateDeps = Pick<InboundPipelineDeps, "logger" | "eventBus" | "sessionManager" | "autoReplyEngineConfig" | "groupHistoryBuffer" | "commandQueue" | "sessionLabelStore" | "getResetTriggers" | "greetingGenerator" | "loadPromptSkill" | "getUserInvocableSkillNames" | "approvalGate" | "handleConfigCommand" | "handleSlashCommand" | "activeRunRegistry" | "sessionResolver">;
-/** Gate decision: what should happen with this message. */
-export type GateDecision = {
-    action: "process";
-    processedMsg: NormalizedMessage;
-    directives?: Record<string, unknown>;
-} | {
-    action: "handled";
-} | {
-    action: "skip";
-};
-/**
- * Evaluate all message gates: auto-reply engine, slash commands, reset
- * triggers, and prompt skill detection.
- *
- * Returns a `GateDecision`:
- * - `"process"`: message should continue to routing/execution (may have modified msg/directives)
- * - `"handled"`: a command was intercepted and a response already delivered
- * - `"skip"`: message was suppressed (auto-reply gate, inject-history)
- */
-export declare function evaluateInboundGate(deps: GateDeps, adapter: ChannelPort, processedMsg: NormalizedMessage, sessionKey: SessionKey, agentId: string, sendOverrides: SendOverrideStore): Promise<GateDecision>;