comisai 1.0.37 → 1.0.40

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

@@ -0,0 +1,96 @@
+/**
+ * Cross-session messaging composition root.
+ *
+ * Hosts the `setupCrossSession` orchestrator + `CrossSessionResult` type +
+ * the cross-session sender / announcement batcher / dead-letter queue /
+ * result condenser / narrative caster / lifecycle hooks / sub-agent runner
+ * construction. Delegates graph-execution wiring to
+ * ./setup-cross-session-graph.js (buildExecuteSubAgent) and proxy typing
+ * event listeners to ./setup-cross-session-events.js
+ * (registerProxyTypingListeners).
+ *
+ * @module
+ */
+import type { SessionKey, DeliveryService, DeliverToChannelOptions, ClockPort, TimerPort, AppContainer, FileLockPort } from "@comis/core";
+import type { ComisLogger } from "@comis/infra";
+import { createSubAgentRunner } from "@comis/agent";
+import { createCrossSessionSender, createAnnouncementBatcher, createAnnouncementDeadLetterQueue } from "@comis/orchestrator";
+/** All services produced by the cross-session messaging setup. */
+export interface CrossSessionResult {
+    /** Cross-session message sender for agent-to-agent communication. */
+    crossSessionSender: ReturnType<typeof createCrossSessionSender>;
+    /** Sub-agent task runner for delegated execution. */
+    subAgentRunner: ReturnType<typeof createSubAgentRunner>;
+    /** Channel message sender for graph completion announcements */
+    sendToChannel: (channelType: string, channelId: string, text: string, options?: DeliverToChannelOptions) => Promise<boolean>;
+    /** Parent session announcement for graph results */
+    announceToParent: (callerAgentId: string, callerSessionKey: SessionKey, text: string, channelType: string, channelId: string) => Promise<void>;
+    /** Dead-letter queue for failed announcement persistence. */
+    deadLetterQueue?: ReturnType<typeof createAnnouncementDeadLetterQueue>;
+    /** Announcement batcher for coalescing concurrent graph/sub-agent completions. */
+    announcementBatcher: ReturnType<typeof createAnnouncementBatcher>;
+}
+/**
+ * Create cross-session messaging services: cross-session sender + sub-agent runner.
+ * The three callback closures (executeInSession, sendToChannel, executeSubAgent)
+ * are built internally from the provided dependencies; the graph/sub-agent
+ * branch is delegated to setup-cross-session-graph.ts.
+ */
+export declare function setupCrossSession(deps: {
+    sessionStore: {
+        loadByFormattedKey(key: string): {
+            messages: unknown[];
+            metadata: Record<string, unknown>;
+        } | undefined;
+        save(key: SessionKey, messages: unknown[], metadata: Record<string, unknown>): void;
+        delete(key: SessionKey): void;
+    };
+    container: AppContainer;
+    assembleToolsForAgent: (agentId: string, options?: import("../setup-tools.js").AssembleToolsOptions) => Promise<any[]>;
+    getExecutor: (agentId: string) => {
+        execute: (...args: any[]) => Promise<any>;
+    };
+    adaptersByType: Map<string, {
+        sendMessage(channelId: string, text: string, options?: import("@comis/core").SendMessageOptions): Promise<import("@comis/shared").Result<string, Error>>;
+        channelType: string;
+        platformAction?(action: string, params: Record<string, unknown>): Promise<import("@comis/shared").Result<unknown, Error>>;
+    }>;
+    /** Optional structured logger for cross-session subsystem. */
+    logger?: ComisLogger;
+    /** Optional memory adapter for persisting sub-agent completion summaries. */
+    memoryAdapter?: {
+        store(entry: Record<string, unknown>): Promise<{
+            ok: boolean;
+        }>;
+    };
+    /** Deferred gateway send callback (wired after setupGateway). */
+    gatewaySend?: {
+        ref?: (channelId: string, text: string) => boolean;
+    };
+    /** Optional active run registry for aborting in-flight SDK sessions on kill. */
+    activeRunRegistry?: {
+        get(sessionKey: string): {
+            abort(): Promise<void>;
+        } | undefined;
+    };
+    /** Optional composite-key resolver for sub-agent abort paths. */
+    sessionResolver?: {
+        resolveActiveSession(key: {
+            agentId: string;
+            channelType: string;
+            channelId: string;
+        }): {
+            abort(): Promise<void>;
+        } | undefined;
+    };
+    /** Delivery queue for crash-safe persistence */
+    deliveryQueue?: import("@comis/core").DeliveryQueuePort;
+    /** DeliveryService instance constructed at daemon composition root (setup-channels.ts). */
+    deliveryService: DeliveryService;
+    /** Canonical FileLockPort adapter, threaded into ephemeral session adapters. */
+    fileLock: FileLockPort;
+    /** Wall-clock + monotonic time reads. */
+    clock: ClockPort;
+    /** Timer scheduling. */
+    timers: TimerPort;
+}): CrossSessionResult;

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

@@ -0,0 +1,241 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Cross-session messaging composition root.
+ *
+ * Hosts the `setupCrossSession` orchestrator + `CrossSessionResult` type +
+ * the cross-session sender / announcement batcher / dead-letter queue /
+ * result condenser / narrative caster / lifecycle hooks / sub-agent runner
+ * construction. Delegates graph-execution wiring to
+ * ./setup-cross-session-graph.js (buildExecuteSubAgent) and proxy typing
+ * event listeners to ./setup-cross-session-events.js
+ * (registerProxyTypingListeners).
+ *
+ * @module
+ */
+import { tryGetContext, safePath, systemNowMs } from "@comis/core";
+import { createResultCondenser, createNarrativeCaster, createLifecycleHooks, resolveOperationModel, resolveProviderFamily, createSubAgentRunner } from "@comis/agent";
+import { createCrossSessionSender, createAnnouncementBatcher, createAnnouncementDeadLetterQueue, } from "@comis/orchestrator";
+import { randomUUID } from "node:crypto";
+import { buildExecuteSubAgent } from "./setup-cross-session-graph.js";
+import { registerProxyTypingListeners } from "./setup-cross-session-events.js";
+// ---------------------------------------------------------------------------
+// Setup function
+// ---------------------------------------------------------------------------
+/**
+ * Create cross-session messaging services: cross-session sender + sub-agent runner.
+ * The three callback closures (executeInSession, sendToChannel, executeSubAgent)
+ * are built internally from the provided dependencies; the graph/sub-agent
+ * branch is delegated to setup-cross-session-graph.ts.
+ */
+export function setupCrossSession(deps) {
+    const { sessionStore, container, assembleToolsForAgent, getExecutor, adaptersByType } = deps;
+    // Build the three callback closures from injected deps.
+    const executeInSession = async (agentId, sessionKey, text) => {
+        const msg = {
+            id: randomUUID(),
+            channelId: sessionKey.channelId,
+            channelType: "cross-session",
+            senderId: "cross-session-relay",
+            text,
+            timestamp: systemNowMs(),
+            attachments: [],
+            metadata: { crossSession: true },
+        };
+        const tools = await assembleToolsForAgent(agentId);
+        const result = await getExecutor(agentId).execute(msg, sessionKey, tools, undefined, agentId);
+        return { response: result.response, tokensUsed: result.tokensUsed, cost: result.cost };
+    };
+    const sendToChannel = async (channelType, channelId, text, options) => {
+        deps.logger?.debug({
+            channelType,
+            channelId,
+            textLength: text.length,
+            hasOptions: !!options,
+        }, "sendToChannel delivery attempt");
+        // Gateway messages route through WebSocket push, not adapter lookup
+        if (channelType === "gateway" && deps.gatewaySend?.ref) {
+            try {
+                const ok = deps.gatewaySend.ref(channelId, text);
+                deps.logger?.debug({ channelType, channelId, success: ok, gateway: true }, "sendToChannel delivery outcome");
+                return ok;
+            }
+            catch {
+                deps.logger?.debug({ channelType, channelId, success: false, gateway: true }, "sendToChannel delivery outcome");
+                return false;
+            }
+        }
+        const adapter = adaptersByType.get(channelType);
+        if (!adapter) {
+            deps.logger?.debug({ channelType, channelId, success: false, gateway: false }, "sendToChannel delivery outcome: no adapter");
+            return false;
+        }
+        // Delegate to the DeliveryService method form for format + chunk + retry + events.
+        const result = await deps.deliveryService.deliverToChannel(adapter, channelId, text, options);
+        const success = result.ok && result.value.ok;
+        deps.logger?.debug({ channelType, channelId, success, gateway: false }, "sendToChannel delivery outcome");
+        if (!result.ok)
+            return false;
+        return result.value.ok;
+    };
+    // executeSubAgent built via setup-cross-session-graph.ts.
+    const executeSubAgent = buildExecuteSubAgent({
+        container,
+        sessionStore: { loadByFormattedKey: (k) => sessionStore.loadByFormattedKey(k) },
+        assembleToolsForAgent,
+        getExecutor,
+        fileLock: deps.fileLock,
+        logger: deps.logger,
+    });
+    // Cross-session sender — fire-and-forget, wait, or ping-pong messaging
+    const crossSessionSender = createCrossSessionSender({
+        sessionStore: {
+            loadByFormattedKey: (key) => sessionStore.loadByFormattedKey(key),
+            save: (key, messages, metadata) => sessionStore.save(key, messages, metadata),
+        },
+        executeInSession,
+        sendToChannel,
+        eventBus: container.eventBus,
+        config: container.config.security.agentToAgent,
+    });
+    // Announce to parent session by injecting [System Message] and executing parent agent.
+    const announceToParent = async (callerAgentId, callerSessionKey, text, channelType, channelId) => {
+        deps.logger?.debug({
+            callerAgentId,
+            channelId: callerSessionKey.channelId,
+            textLength: text.length,
+            channelType,
+            targetChannelId: channelId,
+        }, "announceToParent invoked");
+        // Emit proxy typing around announcement delivery (not spawn-time).
+        const proxyId = `announce-${systemNowMs()}-${Math.random().toString(36).slice(2, 8)}`;
+        container.eventBus.emit("typing:proxy_start", {
+            runId: proxyId,
+            channelType,
+            channelId,
+            parentSessionKey: typeof callerSessionKey === "string"
+                ? callerSessionKey
+                : `${callerSessionKey.channelId}:${callerSessionKey.userId}:${callerSessionKey.tenantId}`,
+            agentId: callerAgentId,
+            timestamp: systemNowMs(),
+        });
+        try {
+            const result = await executeInSession(callerAgentId, callerSessionKey, text);
+            const trimmed = result.response.trim();
+            const isNoReply = !trimmed || trimmed === "NO_REPLY" || trimmed.startsWith("NO_REPLY");
+            deps.logger?.debug({
+                callerAgentId,
+                responseLength: trimmed.length,
+                willDeliver: !isNoReply,
+                isNoReply,
+            }, "announceToParent execution result");
+            if (!isNoReply) {
+                // Extract thread context from ALS delivery origin so announcements
+                // land in the correct Telegram topic / thread.
+                const ctx = tryGetContext();
+                const threadId = ctx?.deliveryOrigin?.threadId;
+                await sendToChannel(channelType, channelId, trimmed, threadId ? { threadId } : undefined);
+            }
+        }
+        finally {
+            container.eventBus.emit("typing:proxy_stop", {
+                runId: proxyId,
+                channelType,
+                channelId,
+                reason: "completed",
+                durationMs: 0,
+                timestamp: systemNowMs(),
+            });
+        }
+    };
+    // Dead-letter queue (created before batcher so batcher can reference it).
+    // AGENTS §2.2: paths via safePath; safePath requires absolute base; fall back to
+    // process.cwd() (not banned — only process.env + node:path's join/resolve are).
+    const deadLetterFilePath = safePath(container.config.dataDir || process.cwd(), "dead-letters.jsonl");
+    const deadLetterQueue = createAnnouncementDeadLetterQueue({
+        filePath: deadLetterFilePath,
+        maxRetries: 5,
+        retryIntervalMs: 60_000,
+        maxAgeMs: 3_600_000,
+        maxEntries: 100,
+        eventBus: container.eventBus,
+        logger: deps.logger?.child({ submodule: "dead-letter-queue" }),
+    });
+    // Announcement batcher coalesces near-simultaneous sub-agent completions.
+    const announcementBatcher = createAnnouncementBatcher({
+        announceToParent,
+        sendToChannel,
+        logger: deps.logger?.child({ submodule: "announcement-batcher" }),
+        deadLetterQueue,
+    });
+    // Resolve condensation model via 5-level priority chain
+    const subagentCtxConfigForCondenser = container.config.security?.agentToAgent?.subagentContext;
+    const defaultAgentConfig = container.config.agents?.["default"];
+    const condensationResolution = resolveOperationModel({
+        operationType: "condensation",
+        agentProvider: defaultAgentConfig?.provider ?? "anthropic",
+        agentModel: defaultAgentConfig?.model ?? "default",
+        operationModels: defaultAgentConfig?.operationModels ?? {},
+        providerFamily: resolveProviderFamily(defaultAgentConfig?.provider ?? "anthropic"),
+        agentPromptTimeoutMs: defaultAgentConfig?.promptTimeout?.promptTimeoutMs,
+    });
+    // Resolve API key from resolution.provider (enables cross-provider condensation)
+    const condenserProviderEntry = container.config.providers?.entries?.[condensationResolution.provider];
+    const condenserApiKeyName = condenserProviderEntry?.apiKeyName
+        || `${condensationResolution.provider.toUpperCase()}_API_KEY`;
+    const condenserApiKey = container.secretManager?.get(condenserApiKeyName) ?? "";
+    deps.logger?.debug({ model: condensationResolution.model, source: condensationResolution.source, provider: condensationResolution.provider }, "Condensation model resolved");
+    const resultCondenser = createResultCondenser({
+        maxResultTokens: subagentCtxConfigForCondenser?.maxResultTokens ?? 4000,
+        condensationStrategy: subagentCtxConfigForCondenser?.condensationStrategy ?? "auto",
+        dataDir: container.config.dataDir || ".",
+        logger: deps.logger
+            ? { info: deps.logger.info.bind(deps.logger), warn: deps.logger.warn.bind(deps.logger), debug: deps.logger.debug.bind(deps.logger) }
+            : { info: () => { }, warn: () => { }, debug: () => { } },
+    });
+    // Create NarrativeCaster for tagged result announcements
+    const narrativeCaster = createNarrativeCaster({
+        enabled: subagentCtxConfigForCondenser?.narrativeCasting ?? true,
+        tagPrefix: subagentCtxConfigForCondenser?.resultTagPrefix ?? "Subagent Result",
+    });
+    // Create lifecycle hooks for spawn preparation and completion
+    const lifecycleHooks = createLifecycleHooks({
+        logger: deps.logger
+            ? { info: deps.logger.info.bind(deps.logger), warn: deps.logger.warn.bind(deps.logger), debug: deps.logger.debug.bind(deps.logger) }
+            : { info: () => { }, warn: () => { }, debug: () => { } },
+        eventBus: container.eventBus,
+    });
+    // Sub-agent runner — async sub-agent spawning with allowlist + auto-archive
+    const subAgentRunner = createSubAgentRunner({
+        sessionStore: {
+            save: (key, messages, metadata) => sessionStore.save(key, messages, metadata),
+            delete: (key) => sessionStore.delete(key),
+        },
+        executeAgent: executeSubAgent,
+        sendToChannel,
+        announceToParent,
+        eventBus: container.eventBus,
+        config: container.config.security.agentToAgent,
+        tenantId: container.config.tenantId,
+        dataDir: container.config.dataDir || ".",
+        logger: deps.logger?.child({ submodule: "sub-agent-runner" }),
+        memoryAdapter: deps.memoryAdapter,
+        batcher: announcementBatcher,
+        activeRunRegistry: deps.activeRunRegistry,
+        sessionResolver: deps.sessionResolver,
+        resultCondenser,
+        condenserModel: condenserApiKey ? { id: condensationResolution.modelId, provider: condensationResolution.provider } : undefined,
+        condenserApiKey: condenserApiKey || undefined,
+        narrativeCaster,
+        lifecycleHooks,
+        deadLetterQueue,
+        clock: deps.clock,
+        timers: deps.timers,
+    });
+    // Register proxy typing event listeners (typing:proxy_start/stop + TTL sweep + shutdown)
+    registerProxyTypingListeners({
+        container,
+        adaptersByType: adaptersByType,
+        logger: deps.logger,
+    });
+    return { crossSessionSender, subAgentRunner, sendToChannel, announceToParent, deadLetterQueue, announcementBatcher };
+}

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

@@ -12,8 +12,7 @@
  * Session Mirroring.
  * @module setup-delivery — Delivery subsystem wiring (queue + mirror)
  */
-import type { AppConfig, TypedEventBus, DeliveryQueuePort, DeliveryMirrorPort } from "@comis/core";
-import { type DeliveryAdapter } from "@comis/channels";
+import type { AppConfig, TypedEventBus, DeliveryQueuePort, DeliveryMirrorPort, DeliveryAdapter } from "@comis/core";
 import type { ComisLogger } from "@comis/infra";
 import type { PluginRegistry } from "@comis/core";
 export interface DeliveryQueueResult {

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

@@ -13,9 +13,8 @@
  * Session Mirroring.
  * @module setup-delivery — Delivery subsystem wiring (queue + mirror)
  */
-import { createNoOpDeliveryQueue, createNoOpDeliveryMirror } from "@comis/core";
+import { createNoOpDeliveryQueue, createNoOpDeliveryMirror, isPermanentError, computeQueueBackoff, systemNowMs, systemSetInterval, systemClearInterval, } from "@comis/core";
 import { createSqliteDeliveryQueue, createSqliteDeliveryMirror } from "@comis/memory";
-import { isPermanentError, computeQueueBackoff } from "@comis/channels";
 import { ok, suppressError } from "@comis/shared";
 import { createHash } from "node:crypto";
 // ---------------------------------------------------------------------------
@@ -68,7 +67,7 @@ export async function setupDeliveryQueue(deps) {
             await runOneDrainPass();
         }
         // --- Step 3: Recurring drain timer. ---
-        drainInterval = setInterval(() => {
+        drainInterval = systemSetInterval(() => {
             if (draining)
                 return; // single-tick gate
             draining = runOneDrainPass().finally(() => { draining = null; });
@@ -86,14 +85,14 @@ export async function setupDeliveryQueue(deps) {
         // field is a placeholder until the underlying pruneExpired() is
         // extended with per-class breakdown. Canonical Pino object-first;
         // durationMs is the canonical name (CLAUDE.md logging conventions).
-        pruneInterval = setInterval(async () => {
-            const startMs = Date.now();
+        pruneInterval = systemSetInterval(async () => {
+            const startMs = systemNowMs();
             const result = await deliveryQueue.pruneExpired();
             if (result.ok && result.value > 0) {
                 logger.debug({
                     pruned: result.value,
                     class: "delivery_queue",
-                    durationMs: Date.now() - startMs,
+                    durationMs: systemNowMs() - startMs,
                 }, "Delivery queue pruned");
             }
         }, queueConfig.pruneIntervalMs);
@@ -101,11 +100,11 @@ export async function setupDeliveryQueue(deps) {
     };
     const shutdown = () => {
         if (drainInterval) {
-            clearInterval(drainInterval);
+            systemClearInterval(drainInterval);
             drainInterval = undefined;
         }
         if (pruneInterval) {
-            clearInterval(pruneInterval);
+            systemClearInterval(pruneInterval);
             pruneInterval = undefined;
         }
     };
@@ -116,7 +115,7 @@ export async function setupDeliveryQueue(deps) {
 // ---------------------------------------------------------------------------
 export async function drainDeliveryQueue(deps) {
     const { deliveryQueue, channelAdapters, eventBus, logger, drainBudgetMs, defaultMaxAttempts } = deps;
-    const drainStart = Date.now();
+    const drainStart = systemNowMs();
     const deadline = drainStart + drainBudgetMs;
     const pendingResult = await deliveryQueue.pendingEntries();
     if (!pendingResult.ok) {
@@ -133,7 +132,7 @@ export async function drainDeliveryQueue(deps) {
     let failed = 0;
     for (const entry of entries) {
         // Budget exhaustion check
-        if (Date.now() > deadline) {
+        if (systemNowMs() > deadline) {
             logger.info({ budgetMs: drainBudgetMs, attempted, remaining: entries.length - attempted }, "Delivery queue drain: budget exhausted");
             break;
         }
@@ -163,7 +162,7 @@ export async function drainDeliveryQueue(deps) {
                     channelId: entry.channelId,
                     messageId: sendResult.value,
                     durationMs: 0, // Per-entry duration not tracked in drain; 0 is sentinel
-                    timestamp: Date.now(),
+                    timestamp: systemNowMs(),
                 });
             }
         }
@@ -174,19 +173,19 @@ export async function drainDeliveryQueue(deps) {
                 failed++;
             }
             else {
-                const nextRetryAt = Date.now() + computeQueueBackoff(entry.attemptCount);
+                const nextRetryAt = systemNowMs() + computeQueueBackoff(entry.attemptCount);
                 await deliveryQueue.nack(entry.id, errorMsg, nextRetryAt);
                 failed++;
             }
         }
     }
-    const durationMs = Date.now() - drainStart;
+    const durationMs = systemNowMs() - drainStart;
     eventBus.emit("delivery:queue_drained", {
         entriesAttempted: attempted,
         entriesDelivered: delivered,
         entriesFailed: failed,
         durationMs,
-        timestamp: Date.now(),
+        timestamp: systemNowMs(),
     });
     logger.info({ entriesAttempted: attempted, entriesDelivered: delivered, entriesFailed: failed, durationMs }, "Delivery queue drained");
 }
@@ -230,7 +229,7 @@ export async function setupDeliveryMirror(deps) {
             api.registerHook("after_delivery", async (event, ctx) => {
                 if (!ctx.sessionKey)
                     return; // No session context -- skip
-                const now = Date.now();
+                const now = systemNowMs();
                 const idempotencyKey = computeIdempotencyKey(ctx.sessionKey, event.text, now);
                 const result = await deliveryMirror.record({
                     sessionKey: ctx.sessionKey,
@@ -252,7 +251,7 @@ export async function setupDeliveryMirror(deps) {
     // 3. Prune timer
     let pruneInterval;
     const startPrune = () => {
-        pruneInterval = setInterval(async () => {
+        pruneInterval = systemSetInterval(async () => {
             const result = await deliveryMirror.pruneOld(mirrorConfig.retentionMs);
             if (result.ok && result.value > 0) {
                 logger.debug({ pruned: result.value }, "Delivery mirror pruned");
@@ -262,7 +261,7 @@ export async function setupDeliveryMirror(deps) {
     };
     const shutdown = () => {
         if (pruneInterval) {
-            clearInterval(pruneInterval);
+            systemClearInterval(pruneInterval);
             pruneInterval = undefined;
         }
     };

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

@@ -0,0 +1,22 @@
+/**
+ * Daemon gateway-subsystem wiring.
+ *
+ * Barrel re-export of the canonical public API of the former setup-gateway.ts
+ * monolith. No aliases — every export keeps its canonical name.
+ *
+ * Decomposition:
+ *   - setup-gateway-admin.ts   ≤200L — deriveTrustLevel, handleConfigChatCommand, buildExecutionRequestedLogFields, buildGreetingGenerator
+ *   - setup-gateway-rpc.ts     ≤500L — setupRpcBridge (deferred dispatch) + RPC adapter builder + extractAttachmentMarkers + dynamic router registration
+ *   - setup-gateway-routes.ts  ≤300L — setupGateway orchestrator + GatewayDeps/GatewayResult + gateway server creation + mountGatewayRoutes call + start
+ *
+ * NOTE: The sibling top-level `packages/daemon/src/wiring/setup-gateway-routes.ts`
+ * (one directory up) is the older `mountGatewayRoutes` helper; the leaf in
+ * this subdirectory imports from it.
+ *
+ * @module
+ */
+export type { GatewayDeps, GatewayResult } from "./setup-gateway-routes.js";
+export { setupGateway } from "./setup-gateway-routes.js";
+export type { RpcBridgeResult } from "./setup-gateway-rpc.js";
+export { setupRpcBridge } from "./setup-gateway-rpc.js";
+export { buildExecutionRequestedLogFields, deriveTrustLevel, handleConfigChatCommand, } from "./setup-gateway-admin.js";

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

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Daemon gateway-subsystem wiring.
+ *
+ * Barrel re-export of the canonical public API of the former setup-gateway.ts
+ * monolith. No aliases — every export keeps its canonical name.
+ *
+ * Decomposition:
+ *   - setup-gateway-admin.ts   ≤200L — deriveTrustLevel, handleConfigChatCommand, buildExecutionRequestedLogFields, buildGreetingGenerator
+ *   - setup-gateway-rpc.ts     ≤500L — setupRpcBridge (deferred dispatch) + RPC adapter builder + extractAttachmentMarkers + dynamic router registration
+ *   - setup-gateway-routes.ts  ≤300L — setupGateway orchestrator + GatewayDeps/GatewayResult + gateway server creation + mountGatewayRoutes call + start
+ *
+ * NOTE: The sibling top-level `packages/daemon/src/wiring/setup-gateway-routes.ts`
+ * (one directory up) is the older `mountGatewayRoutes` helper; the leaf in
+ * this subdirectory imports from it.
+ *
+ * @module
+ */
+export { setupGateway } from "./setup-gateway-routes.js";
+export { setupRpcBridge } from "./setup-gateway-rpc.js";
+export { buildExecutionRequestedLogFields, deriveTrustLevel, handleConfigChatCommand, } from "./setup-gateway-admin.js";

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

@@ -0,0 +1,100 @@
+/**
+ * Gateway admin-scope + auth-gate helpers.
+ *
+ * Hosts the pure trust-level derivation, the redacted execution-requested
+ * log-field builder, and the `/config` chat command handler (with its
+ * admin-only trust gate). Plus the optional GreetingGenerator construction
+ * that the gateway uses to produce LLM-powered /new and /reset greetings.
+ *
+ * @module
+ */
+import type { AppConfig, AppContainer, SessionKey } from "@comis/core";
+import type { RpcCall } from "@comis/skills";
+import { type GreetingGenerator, type CostTracker } from "@comis/agent";
+import { createCommandHandler, type CommandHandlerDeps } from "@comis/orchestrator";
+/**
+ * Build the structured log fields for the gateway "Agent execution requested"
+ * INFO line. Replaces the previous behavior of logging the first 200 chars
+ * of the raw user message, which violated AGENTS.md §2.2 (no message bodies
+ * in logs at any level). Emits message length plus a short SHA-256 prefix
+ * for correlation, never the body itself.
+ *
+ * @param input.agentId       Resolved agent ID (already trust-derived).
+ * @param input.message       Raw user message (may be empty / undefined).
+ * @param input.connectionId  Optional WebSocket connection ID.
+ * @returns Object suitable for `logger.info(obj, "Agent execution requested")`.
+ */
+export declare function buildExecutionRequestedLogFields(input: {
+    agentId: string;
+    message: string | undefined;
+    connectionId: string | undefined;
+}): {
+    agentId: string;
+    messageLen: number;
+    messageHash?: string;
+    connectionId?: string;
+};
+/**
+ * Derive user trust level from token scopes.
+ * Admin scope or wildcard grants admin trust. All others default to user
+ * (fail-closed). This matches the checkScope wildcard behavior in token-auth.ts.
+ */
+export declare function deriveTrustLevel(scopes: readonly string[] | undefined): "admin" | "user";
+/**
+ * Handle /config chat command via RPC dispatch.
+ * Supports: show [section], set <path> <value>, history
+ */
+export declare function handleConfigChatCommand(args: string[], rpcCall: RpcCall, scopes?: readonly string[]): Promise<{
+    handled: boolean;
+    response?: string;
+}>;
+/**
+ * Create the GreetingGenerator that the gateway uses to produce LLM-powered
+ * greetings for session reset commands (/new, /reset). Returns undefined when
+ * the default agent's provider has no API key (greeting falls back to static
+ * "Session reset." in handleSlashCommand).
+ */
+export declare function buildGreetingGenerator(input: {
+    agents: AppConfig["agents"];
+    defaultAgentId: string;
+    container: AppContainer;
+}): GreetingGenerator | undefined;
+/**
+ * Inputs required to build the CommandHandlerDeps for the gateway slash
+ * command handler (parity-matched to the pre-split adapter at
+ * setup-gateway.ts:773-864).
+ */
+export interface SlashCommandDepsInput {
+    execAgentId: string;
+    defaultAgentId: string;
+    execAgentConfig: AppConfig["agents"][string] | undefined;
+    container: AppContainer;
+    costTrackers: Map<string, CostTracker>;
+    workspaceDirs: Map<string, string>;
+    piSessionAdapters?: Map<string, {
+        destroySession(key: SessionKey): Promise<void>;
+        getSessionStats(key: SessionKey): {
+            messageCount: number;
+            createdAt?: number;
+            tokens?: {
+                input: number;
+                output: number;
+                cacheRead: number;
+                cacheWrite: number;
+                total: number;
+            };
+            cost?: number;
+            userMessages?: number;
+            assistantMessages?: number;
+            toolCalls?: number;
+            toolResults?: number;
+        } | undefined;
+    }>;
+}
+/**
+ * Build CommandHandlerDeps for the gateway slash command path. Extracted
+ * to keep the rpc leaf under its size cap while preserving the full
+ * per-command behavior contract.
+ */
+export declare function buildSlashCommandDeps(input: SlashCommandDepsInput): CommandHandlerDeps;
+export { createCommandHandler };