@a5c-ai/agent-platform 5.0.1-staging.b436b3b3e611

package/dist/interaction/askUserQuestionTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"askUserQuestionTypes.d.ts","sourceRoot":"","sources":["../../src/interaction/askUserQuestionTypes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,qBAAqB,EAAE,CAAC;IAClC,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,uBAAuB,EAAE,CAAC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IACtE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IACxE,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC3D"}

package/dist/interaction/askUserQuestionTypes.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Type definitions for askUserQuestion.
+ * Extracted from askUserQuestion.ts for max-lines compliance.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interaction/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./askUserQuestion";
+export { resolveInteractionUxHints } from './interactionRouter';
+export type { InteractionUxHints } from './interactionRouter';
+//# sourceMappingURL=index.d.ts.map

package/dist/interaction/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/interaction/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAChE,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/interaction/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveInteractionUxHints = void 0;
+__exportStar(require("./askUserQuestion"), exports);
+var interactionRouter_1 = require("./interactionRouter");
+Object.defineProperty(exports, "resolveInteractionUxHints", { enumerable: true, get: function () { return interactionRouter_1.resolveInteractionUxHints; } });

package/dist/interaction/interactionRouter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * GAP-SEC-003: Interaction UX Routing
+ *
+ * Maps InteractionKind values to UX hints that harness adapters
+ * consume for kind-appropriate rendering.
+ *
+ * @module interaction/interactionRouter
+ */
+import type { InteractionKind } from '@a5c-ai/babysitter-sdk';
+/**
+ * UX hints for rendering a specific interaction kind.
+ */
+export interface InteractionUxHints {
+    urgency: 'low' | 'medium' | 'high';
+    requiresDecision: boolean;
+    presentAlwaysApprove: boolean;
+    defaultAutoApprove: boolean;
+    uiStyle: 'qa' | 'confirm' | 'alert' | 'banner' | 'summary';
+}
+/**
+ * Resolve UX hints for a given interaction kind.
+ * Pure function — no I/O.
+ */
+export declare function resolveInteractionUxHints(kind: InteractionKind): InteractionUxHints | undefined;
+//# sourceMappingURL=interactionRouter.d.ts.map

package/dist/interaction/interactionRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactionRouter.d.ts","sourceRoot":"","sources":["../../src/interaction/interactionRouter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IACnC,gBAAgB,EAAE,OAAO,CAAC;IAC1B,oBAAoB,EAAE,OAAO,CAAC;IAC9B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,OAAO,EAAE,IAAI,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;CAC5D;AAwCD;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,eAAe,GAAG,kBAAkB,GAAG,SAAS,CAE/F"}

package/dist/interaction/interactionRouter.js

@@ -0,0 +1,55 @@
+"use strict";
+/**
+ * GAP-SEC-003: Interaction UX Routing
+ *
+ * Maps InteractionKind values to UX hints that harness adapters
+ * consume for kind-appropriate rendering.
+ *
+ * @module interaction/interactionRouter
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveInteractionUxHints = resolveInteractionUxHints;
+const HINTS_MAP = {
+    clarification: {
+        urgency: 'low',
+        requiresDecision: true,
+        presentAlwaysApprove: false,
+        defaultAutoApprove: false,
+        uiStyle: 'qa',
+    },
+    approval: {
+        urgency: 'medium',
+        requiresDecision: true,
+        presentAlwaysApprove: true,
+        defaultAutoApprove: false,
+        uiStyle: 'confirm',
+    },
+    intervention: {
+        urgency: 'high',
+        requiresDecision: true,
+        presentAlwaysApprove: false,
+        defaultAutoApprove: false,
+        uiStyle: 'alert',
+    },
+    notification: {
+        urgency: 'low',
+        requiresDecision: false,
+        presentAlwaysApprove: false,
+        defaultAutoApprove: true,
+        uiStyle: 'banner',
+    },
+    handoff: {
+        urgency: 'low',
+        requiresDecision: false,
+        presentAlwaysApprove: false,
+        defaultAutoApprove: false,
+        uiStyle: 'summary',
+    },
+};
+/**
+ * Resolve UX hints for a given interaction kind.
+ * Pure function — no I/O.
+ */
+function resolveInteractionUxHints(kind) {
+    return HINTS_MAP[kind];
+}

package/dist/mcp/channels/allowlist.d.ts

@@ -0,0 +1,19 @@
+/**
+ * GAP-MCPC-001: Channel Allowlist.
+ *
+ * Controls which MCP channels are active. Channels require explicit opt-in.
+ * Uses atomic write pattern consistent with other SDK state modules.
+ */
+import type { ChannelConfig, ChannelAllowlistFile } from "./types";
+export declare function getChannelAllowlistPath(stateDir: string): string;
+export declare function readChannelAllowlist(stateDir: string): Promise<ChannelAllowlistFile>;
+export declare function writeChannelAllowlist(stateDir: string, allowlist: ChannelAllowlistFile): Promise<void>;
+/** Add or update a channel in the allowlist. */
+export declare function upsertChannel(stateDir: string, channel: ChannelConfig): Promise<ChannelAllowlistFile>;
+/** Remove a channel from the allowlist. Returns true if removed. */
+export declare function removeChannel(stateDir: string, serverName: string, channelId: string): Promise<boolean>;
+/** Toggle a channel's enabled state. Returns the new enabled state. */
+export declare function toggleChannel(stateDir: string, serverName: string, channelId: string, enabled?: boolean): Promise<boolean | undefined>;
+/** Get all enabled channels. */
+export declare function getEnabledChannels(allowlist: ChannelAllowlistFile): ChannelConfig[];
+//# sourceMappingURL=allowlist.d.ts.map

package/dist/mcp/channels/allowlist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"allowlist.d.ts","sourceRoot":"","sources":["../../../src/mcp/channels/allowlist.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAenE,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED,wBAAsB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA+B1F;AAED,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,oBAAoB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAGf;AAED,gDAAgD;AAChD,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,oBAAoB,CAAC,CAa/B;AAED,oEAAoE;AACpE,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC,CAUlB;AAED,uEAAuE;AACvE,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC,CAU9B;AAED,gCAAgC;AAChC,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,oBAAoB,GAAG,aAAa,EAAE,CAEnF"}

package/dist/mcp/channels/allowlist.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * GAP-MCPC-001: Channel Allowlist.
+ *
+ * Controls which MCP channels are active. Channels require explicit opt-in.
+ * Uses atomic write pattern consistent with other SDK state modules.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChannelAllowlistPath = getChannelAllowlistPath;
+exports.readChannelAllowlist = readChannelAllowlist;
+exports.writeChannelAllowlist = writeChannelAllowlist;
+exports.upsertChannel = upsertChannel;
+exports.removeChannel = removeChannel;
+exports.toggleChannel = toggleChannel;
+exports.getEnabledChannels = getEnabledChannels;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const atomic_1 = require("../../storage/atomic");
+const types_1 = require("./types");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function emptyAllowlist() {
+    return { schemaVersion: types_1.CHANNEL_ALLOWLIST_SCHEMA_VERSION, channels: [] };
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+function getChannelAllowlistPath(stateDir) {
+    return path.join(stateDir, "channel-allowlist.json");
+}
+async function readChannelAllowlist(stateDir) {
+    const filePath = getChannelAllowlistPath(stateDir);
+    let raw;
+    try {
+        raw = await node_fs_1.promises.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return emptyAllowlist();
+        throw error;
+    }
+    try {
+        const data = JSON.parse(raw);
+        const rawChannels = Array.isArray(data.channels) ? data.channels : [];
+        const validChannels = rawChannels.filter((c) => {
+            if (typeof c !== "object" || c === null)
+                return false;
+            const obj = c;
+            return (typeof obj.serverName === "string" &&
+                typeof obj.channelId === "string" &&
+                typeof obj.enabled === "boolean");
+        });
+        return {
+            schemaVersion: typeof data.schemaVersion === "string" ? data.schemaVersion : types_1.CHANNEL_ALLOWLIST_SCHEMA_VERSION,
+            channels: validChannels,
+        };
+    }
+    catch {
+        return emptyAllowlist();
+    }
+}
+async function writeChannelAllowlist(stateDir, allowlist) {
+    const filePath = getChannelAllowlistPath(stateDir);
+    await (0, atomic_1.writeFileAtomic)(filePath, JSON.stringify(allowlist, null, 2));
+}
+/** Add or update a channel in the allowlist. */
+async function upsertChannel(stateDir, channel) {
+    const allowlist = await readChannelAllowlist(stateDir);
+    const key = `${channel.serverName}:${channel.channelId}`;
+    const idx = allowlist.channels.findIndex((c) => `${c.serverName}:${c.channelId}` === key);
+    if (idx >= 0) {
+        allowlist.channels[idx] = channel;
+    }
+    else {
+        allowlist.channels.push(channel);
+    }
+    await writeChannelAllowlist(stateDir, allowlist);
+    return allowlist;
+}
+/** Remove a channel from the allowlist. Returns true if removed. */
+async function removeChannel(stateDir, serverName, channelId) {
+    const allowlist = await readChannelAllowlist(stateDir);
+    const key = `${serverName}:${channelId}`;
+    const before = allowlist.channels.length;
+    allowlist.channels = allowlist.channels.filter((c) => `${c.serverName}:${c.channelId}` !== key);
+    if (allowlist.channels.length === before)
+        return false;
+    await writeChannelAllowlist(stateDir, allowlist);
+    return true;
+}
+/** Toggle a channel's enabled state. Returns the new enabled state. */
+async function toggleChannel(stateDir, serverName, channelId, enabled) {
+    const allowlist = await readChannelAllowlist(stateDir);
+    const key = `${serverName}:${channelId}`;
+    const channel = allowlist.channels.find((c) => `${c.serverName}:${c.channelId}` === key);
+    if (!channel)
+        return undefined;
+    channel.enabled = enabled ?? !channel.enabled;
+    await writeChannelAllowlist(stateDir, allowlist);
+    return channel.enabled;
+}
+/** Get all enabled channels. */
+function getEnabledChannels(allowlist) {
+    return allowlist.channels.filter((c) => c.enabled);
+}

package/dist/mcp/channels/channelManager.d.ts

@@ -0,0 +1,64 @@
+/**
+ * GAP-MCPC-001: Channel Manager.
+ *
+ * Detects channel capability on connected MCP servers and manages
+ * channel bindings. Integrates with McpClientManager and InboundMessageQueue.
+ */
+import type { ChannelCapability, ChannelConfig, ChannelMessage } from "./types";
+import type { McpClientManager } from "../client/manager";
+import { InboundMessageQueue, type WakeCallback } from "./inboundQueue";
+export interface ChannelManagerOptions {
+    /** State directory for reading allowlist. */
+    stateDir: string;
+    /** MCP client manager for server connections. */
+    clientManager: McpClientManager;
+    /** Wake callback for sleeping runs. */
+    onWake?: WakeCallback;
+    /** Maximum inbound queue size per run. */
+    maxQueueSize?: number;
+}
+/** Detected channel server. */
+export interface DetectedChannel {
+    serverName: string;
+    capability: ChannelCapability;
+}
+export declare class ChannelManager {
+    private readonly _stateDir;
+    private readonly _clientManager;
+    private readonly _queue;
+    private readonly _detectedChannels;
+    constructor(options: ChannelManagerOptions);
+    /**
+     * Detect channel capability on connected MCP servers.
+     * A server declares channel capability by exposing tools matching
+     * known channel patterns (e.g. slack_send_message, gmail_create_draft).
+     */
+    detectChannels(): Promise<DetectedChannel[]>;
+    /** Get detected channel capabilities. */
+    getDetectedChannels(): DetectedChannel[];
+    /** Check if a server has channel capability. */
+    hasChannelCapability(serverName: string): boolean;
+    /**
+     * Process an inbound channel message.
+     * Routes to bound run and queues for retrieval.
+     */
+    processInboundMessage(message: ChannelMessage): void;
+    /** Bind a channel to a run for message routing. */
+    bindChannelToRun(channelSource: string, runId: string): void;
+    /** Unbind a channel from its run. */
+    unbindChannel(channelSource: string): void;
+    /** Get messages for a run. */
+    getMessages(runId: string, limit?: number): ChannelMessage[];
+    /** Dequeue messages for a run. */
+    consumeMessages(runId: string, limit?: number): ChannelMessage[];
+    /** Check if a run has pending messages. */
+    hasMessages(runId: string): boolean;
+    /**
+     * Load enabled channels from the allowlist.
+     * Returns configs for channels that are both allowed and connected.
+     */
+    getActiveChannels(): Promise<ChannelConfig[]>;
+    /** Access the underlying queue (for advanced use). */
+    get queue(): InboundMessageQueue;
+}
+//# sourceMappingURL=channelManager.d.ts.map

package/dist/mcp/channels/channelManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channelManager.d.ts","sourceRoot":"","sources":["../../../src/mcp/channels/channelManager.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,iBAAiB,EACjB,aAAa,EACb,cAAc,EACf,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,mBAAmB,EAAE,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAUxE,MAAM,WAAW,qBAAqB;IACpC,6CAA6C;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,aAAa,EAAE,gBAAgB,CAAC;IAChC,uCAAuC;IACvC,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,0CAA0C;IAC1C,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,+BAA+B;AAC/B,MAAM,WAAW,eAAe;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,iBAAiB,CAAC;CAC/B;AAMD,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAmB;IAClD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAwC;gBAE9D,OAAO,EAAE,qBAAqB;IAS1C;;;;OAIG;IACG,cAAc,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IAuClD,yCAAyC;IACzC,mBAAmB,IAAI,eAAe,EAAE;IAOxC,gDAAgD;IAChD,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAIjD;;;OAGG;IACH,qBAAqB,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAIpD,mDAAmD;IACnD,gBAAgB,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAI5D,qCAAqC;IACrC,aAAa,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI;IAI1C,8BAA8B;IAC9B,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,cAAc,EAAE;IAIxD,kCAAkC;IAClC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,cAAc,EAAE;IAI5D,2CAA2C;IAC3C,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAInC;;;OAGG;IACG,iBAAiB,IAAI,OAAO,CAAC,aAAa,EAAE,CAAC;IAYnD,sDAAsD;IACtD,IAAI,KAAK,IAAI,mBAAmB,CAE/B;CACF"}

package/dist/mcp/channels/channelManager.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * GAP-MCPC-001: Channel Manager.
+ *
+ * Detects channel capability on connected MCP servers and manages
+ * channel bindings. Integrates with McpClientManager and InboundMessageQueue.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelManager = void 0;
+const inboundQueue_1 = require("./inboundQueue");
+const allowlist_1 = require("./allowlist");
+// ---------------------------------------------------------------------------
+// ChannelManager
+// ---------------------------------------------------------------------------
+class ChannelManager {
+    _stateDir;
+    _clientManager;
+    _queue;
+    _detectedChannels = new Map();
+    constructor(options) {
+        this._stateDir = options.stateDir;
+        this._clientManager = options.clientManager;
+        this._queue = new inboundQueue_1.InboundMessageQueue({
+            maxQueueSize: options.maxQueueSize,
+            onWake: options.onWake,
+        });
+    }
+    /**
+     * Detect channel capability on connected MCP servers.
+     * A server declares channel capability by exposing tools matching
+     * known channel patterns (e.g. slack_send_message, gmail_create_draft).
+     */
+    async detectChannels() {
+        const connections = this._clientManager.listConnections();
+        const detected = [];
+        for (const conn of connections) {
+            if (conn.status !== "connected")
+                continue;
+            try {
+                const tools = await this._clientManager.listTools(conn.name);
+                const toolNames = tools.map((t) => t.name);
+                const channelType = inferChannelType(toolNames);
+                // Only consider servers that match a known channel type
+                if (!channelType)
+                    continue;
+                const capability = {
+                    inbound: toolNames.some((n) => n.includes("read_channel") || n.includes("read_message") || n.includes("read_thread")),
+                    outbound: toolNames.some((n) => n.includes("send_message") || n.includes("create_draft")),
+                    permissionRelay: false,
+                    channelType,
+                };
+                if (capability.inbound || capability.outbound) {
+                    this._detectedChannels.set(conn.name, capability);
+                    detected.push({ serverName: conn.name, capability });
+                }
+            }
+            catch {
+                // Skip servers that fail to list tools
+            }
+        }
+        return detected;
+    }
+    /** Get detected channel capabilities. */
+    getDetectedChannels() {
+        return [...this._detectedChannels.entries()].map(([serverName, capability]) => ({
+            serverName,
+            capability,
+        }));
+    }
+    /** Check if a server has channel capability. */
+    hasChannelCapability(serverName) {
+        return this._detectedChannels.has(serverName);
+    }
+    /**
+     * Process an inbound channel message.
+     * Routes to bound run and queues for retrieval.
+     */
+    processInboundMessage(message) {
+        this._queue.enqueue(message);
+    }
+    /** Bind a channel to a run for message routing. */
+    bindChannelToRun(channelSource, runId) {
+        this._queue.bindChannel(channelSource, runId);
+    }
+    /** Unbind a channel from its run. */
+    unbindChannel(channelSource) {
+        this._queue.unbindChannel(channelSource);
+    }
+    /** Get messages for a run. */
+    getMessages(runId, limit = 10) {
+        return this._queue.peek(runId, limit);
+    }
+    /** Dequeue messages for a run. */
+    consumeMessages(runId, limit = 10) {
+        return this._queue.dequeue(runId, limit);
+    }
+    /** Check if a run has pending messages. */
+    hasMessages(runId) {
+        return this._queue.hasMessages(runId);
+    }
+    /**
+     * Load enabled channels from the allowlist.
+     * Returns configs for channels that are both allowed and connected.
+     */
+    async getActiveChannels() {
+        const allowlist = await (0, allowlist_1.readChannelAllowlist)(this._stateDir);
+        const enabled = (0, allowlist_1.getEnabledChannels)(allowlist);
+        const connected = new Set(this._clientManager
+            .listConnections()
+            .filter((c) => c.status === "connected")
+            .map((c) => c.name));
+        return enabled.filter((c) => connected.has(c.serverName));
+    }
+    /** Access the underlying queue (for advanced use). */
+    get queue() {
+        return this._queue;
+    }
+}
+exports.ChannelManager = ChannelManager;
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Infer channel type from tool name prefixes. */
+function inferChannelType(toolNames) {
+    const hasPrefix = (prefix) => toolNames.some((n) => n.startsWith(prefix));
+    if (hasPrefix("slack_"))
+        return "slack";
+    if (hasPrefix("discord_"))
+        return "discord";
+    if (hasPrefix("gmail_") || hasPrefix("email_"))
+        return "email";
+    if (hasPrefix("telegram_"))
+        return "telegram";
+    if (hasPrefix("teams_"))
+        return "teams";
+    return undefined;
+}

package/dist/mcp/channels/inboundQueue.d.ts

@@ -0,0 +1,47 @@
+/**
+ * GAP-MCPC-001: Inbound Message Queue.
+ *
+ * Stores inbound channel messages in-memory and provides wake-up
+ * triggers for sleeping runs. Messages do not survive process restarts.
+ */
+import type { ChannelMessage, ChannelBinding } from "./types";
+export type WakeCallback = (runId: string, message: ChannelMessage) => void;
+export interface InboundQueueOptions {
+    /** Maximum messages to buffer per run before dropping oldest. */
+    maxQueueSize?: number;
+    /** Callback fired when a bound run receives a message (for wake-up). */
+    onWake?: WakeCallback;
+}
+export declare class InboundMessageQueue {
+    private readonly _queues;
+    private readonly _bindings;
+    private readonly _maxQueueSize;
+    private readonly _onWake;
+    constructor(options?: InboundQueueOptions);
+    /** Bind a channel to a run for message routing. */
+    bindChannel(channelSource: string, runId: string): void;
+    /** Unbind a channel from its run. */
+    unbindChannel(channelSource: string): void;
+    /** Get the run ID a channel is bound to (if any). */
+    getBoundRunId(channelSource: string): string | undefined;
+    /** Get all active bindings. */
+    getBindings(): ChannelBinding[];
+    /**
+     * Enqueue an inbound message. Routes to bound run if one exists.
+     * Fires the wake callback if a binding exists.
+     */
+    enqueue(message: ChannelMessage): void;
+    /** Peek at messages for a run (does not remove). */
+    peek(runId: string, limit?: number): ChannelMessage[];
+    /** Dequeue (remove and return) messages for a run. */
+    dequeue(runId: string, limit?: number): ChannelMessage[];
+    /** Get the number of queued messages for a run. */
+    queueSize(runId: string): number;
+    /** Check if there are any messages for a run. */
+    hasMessages(runId: string): boolean;
+    /** Get unbound messages (not routed to any run). */
+    getUnboundMessages(limit?: number): ChannelMessage[];
+    /** Clear all queues and bindings. */
+    clear(): void;
+}
+//# sourceMappingURL=inboundQueue.d.ts.map

package/dist/mcp/channels/inboundQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inboundQueue.d.ts","sourceRoot":"","sources":["../../../src/mcp/channels/inboundQueue.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAM9D,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;AAE5E,MAAM,WAAW,mBAAmB;IAClC,iEAAiE;IACjE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wEAAwE;IACxE,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AAMD,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuC;IAC/D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqC;IAC/D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;gBAEvC,OAAO,CAAC,EAAE,mBAAmB;IAKzC,mDAAmD;IACnD,WAAW,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAQvD,qCAAqC;IACrC,aAAa,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI;IAI1C,qDAAqD;IACrD,aAAa,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAIxD,+BAA+B;IAC/B,WAAW,IAAI,cAAc,EAAE;IAI/B;;;OAGG;IACH,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAuBtC,oDAAoD;IACpD,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,cAAc,EAAE;IAMjD,sDAAsD;IACtD,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAK,GAAG,cAAc,EAAE;IAMpD,mDAAmD;IACnD,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAIhC,iDAAiD;IACjD,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAInC,oDAAoD;IACpD,kBAAkB,CAAC,KAAK,SAAK,GAAG,cAAc,EAAE;IAIhD,qCAAqC;IACrC,KAAK,IAAI,IAAI;CAId"}

package/dist/mcp/channels/inboundQueue.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * GAP-MCPC-001: Inbound Message Queue.
+ *
+ * Stores inbound channel messages in-memory and provides wake-up
+ * triggers for sleeping runs. Messages do not survive process restarts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InboundMessageQueue = void 0;
+// ---------------------------------------------------------------------------
+// InboundMessageQueue
+// ---------------------------------------------------------------------------
+class InboundMessageQueue {
+    _queues = new Map();
+    _bindings = new Map();
+    _maxQueueSize;
+    _onWake;
+    constructor(options) {
+        this._maxQueueSize = options?.maxQueueSize ?? 100;
+        this._onWake = options?.onWake;
+    }
+    /** Bind a channel to a run for message routing. */
+    bindChannel(channelSource, runId) {
+        this._bindings.set(channelSource, {
+            channelSource,
+            runId,
+            boundAt: new Date().toISOString(),
+        });
+    }
+    /** Unbind a channel from its run. */
+    unbindChannel(channelSource) {
+        this._bindings.delete(channelSource);
+    }
+    /** Get the run ID a channel is bound to (if any). */
+    getBoundRunId(channelSource) {
+        return this._bindings.get(channelSource)?.runId;
+    }
+    /** Get all active bindings. */
+    getBindings() {
+        return [...this._bindings.values()];
+    }
+    /**
+     * Enqueue an inbound message. Routes to bound run if one exists.
+     * Fires the wake callback if a binding exists.
+     */
+    enqueue(message) {
+        const runId = this._bindings.get(message.source)?.runId;
+        const queueKey = runId ?? "__unbound__";
+        let queue = this._queues.get(queueKey);
+        if (!queue) {
+            queue = [];
+            this._queues.set(queueKey, queue);
+        }
+        queue.push(message);
+        // Trim if over max
+        if (queue.length > this._maxQueueSize) {
+            queue.shift();
+        }
+        // Fire wake callback for bound runs
+        if (runId && this._onWake) {
+            this._onWake(runId, message);
+        }
+    }
+    /** Peek at messages for a run (does not remove). */
+    peek(runId, limit = 10) {
+        const queue = this._queues.get(runId);
+        if (!queue)
+            return [];
+        return queue.slice(-limit);
+    }
+    /** Dequeue (remove and return) messages for a run. */
+    dequeue(runId, limit = 10) {
+        const queue = this._queues.get(runId);
+        if (!queue || queue.length === 0)
+            return [];
+        return queue.splice(0, Math.min(limit, queue.length));
+    }
+    /** Get the number of queued messages for a run. */
+    queueSize(runId) {
+        return this._queues.get(runId)?.length ?? 0;
+    }
+    /** Check if there are any messages for a run. */
+    hasMessages(runId) {
+        return this.queueSize(runId) > 0;
+    }
+    /** Get unbound messages (not routed to any run). */
+    getUnboundMessages(limit = 10) {
+        return this.peek("__unbound__", limit);
+    }
+    /** Clear all queues and bindings. */
+    clear() {
+        this._queues.clear();
+        this._bindings.clear();
+    }
+}
+exports.InboundMessageQueue = InboundMessageQueue;

package/dist/mcp/channels/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * MCP Channels — interactive messaging and approval routing.
+ * Moved from @a5c-ai/babysitter-sdk.
+ *
+ * Status: NOT INTEGRATED YET — these modules are implemented but not wired
+ * into the harness's interaction/governance layer.
+ *
+ * GAP-MCPC-001/002/003/004
+ */
+export type { ChannelCapability, ChannelConfig, ChannelMessage, ChannelBinding, OutboundMessageRequest, OutboundMessageResult, ChannelApprovalRequest, ChannelApprovalResponse, ApprovalClaim, ChannelAllowlistFile, ChannelApprovalSecurityConfig, } from "./types";
+export { CHANNEL_ALLOWLIST_SCHEMA_VERSION, DEFAULT_APPROVAL_SECURITY, } from "./types";
+export { getChannelAllowlistPath, readChannelAllowlist, writeChannelAllowlist, upsertChannel, removeChannel, toggleChannel, getEnabledChannels, } from "./allowlist";
+export { InboundMessageQueue, type WakeCallback, type InboundQueueOptions, } from "./inboundQueue";
+export { ChannelManager, type ChannelManagerOptions, type DetectedChannel, } from "./channelManager";
+export { OutboundChannelSender, formatTemplate, DEFAULT_CHANNEL_TOOL_MAPPINGS, type ChannelToolMapping, } from "./outbound";
+export { ChannelPermissionRelay, createApprovalRace, type PermissionRelayOptions, type RelayResult, } from "./permissionRelay";
+//# sourceMappingURL=index.d.ts.map