@a5c-ai/genty-platform 5.1.1-staging.00ceebd28cf2

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,16 @@
+/**
+ * MCP Channels — interactive messaging and approval routing.
+ * Moved from @a5c-ai/babysitter-sdk.
+ *
+ * Status: Integrated with agent-platform MCP orchestration wiring.
+ *
+ * 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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/mcp/channels/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,YAAY,EACV,iBAAiB,EACjB,aAAa,EACb,cAAc,EACd,cAAc,EACd,sBAAsB,EACtB,qBAAqB,EACrB,sBAAsB,EACtB,uBAAuB,EACvB,aAAa,EACb,oBAAoB,EACpB,6BAA6B,GAC9B,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,gCAAgC,EAChC,yBAAyB,GAC1B,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACpB,qBAAqB,EACrB,aAAa,EACb,aAAa,EACb,aAAa,EACb,kBAAkB,GACnB,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,mBAAmB,EACnB,KAAK,YAAY,EACjB,KAAK,mBAAmB,GACzB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,cAAc,EACd,KAAK,qBAAqB,EAC1B,KAAK,eAAe,GACrB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,qBAAqB,EACrB,cAAc,EACd,6BAA6B,EAC7B,KAAK,kBAAkB,GACxB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,KAAK,sBAAsB,EAC3B,KAAK,WAAW,GACjB,MAAM,mBAAmB,CAAC"}

package/dist/mcp/channels/index.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * MCP Channels — interactive messaging and approval routing.
+ * Moved from @a5c-ai/babysitter-sdk.
+ *
+ * Status: Integrated with agent-platform MCP orchestration wiring.
+ *
+ * GAP-MCPC-001/002/003/004
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createApprovalRace = exports.ChannelPermissionRelay = exports.DEFAULT_CHANNEL_TOOL_MAPPINGS = exports.formatTemplate = exports.OutboundChannelSender = exports.ChannelManager = exports.InboundMessageQueue = exports.getEnabledChannels = exports.toggleChannel = exports.removeChannel = exports.upsertChannel = exports.writeChannelAllowlist = exports.readChannelAllowlist = exports.getChannelAllowlistPath = exports.DEFAULT_APPROVAL_SECURITY = exports.CHANNEL_ALLOWLIST_SCHEMA_VERSION = void 0;
+var types_1 = require("./types");
+Object.defineProperty(exports, "CHANNEL_ALLOWLIST_SCHEMA_VERSION", { enumerable: true, get: function () { return types_1.CHANNEL_ALLOWLIST_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "DEFAULT_APPROVAL_SECURITY", { enumerable: true, get: function () { return types_1.DEFAULT_APPROVAL_SECURITY; } });
+// Allowlist
+var allowlist_1 = require("./allowlist");
+Object.defineProperty(exports, "getChannelAllowlistPath", { enumerable: true, get: function () { return allowlist_1.getChannelAllowlistPath; } });
+Object.defineProperty(exports, "readChannelAllowlist", { enumerable: true, get: function () { return allowlist_1.readChannelAllowlist; } });
+Object.defineProperty(exports, "writeChannelAllowlist", { enumerable: true, get: function () { return allowlist_1.writeChannelAllowlist; } });
+Object.defineProperty(exports, "upsertChannel", { enumerable: true, get: function () { return allowlist_1.upsertChannel; } });
+Object.defineProperty(exports, "removeChannel", { enumerable: true, get: function () { return allowlist_1.removeChannel; } });
+Object.defineProperty(exports, "toggleChannel", { enumerable: true, get: function () { return allowlist_1.toggleChannel; } });
+Object.defineProperty(exports, "getEnabledChannels", { enumerable: true, get: function () { return allowlist_1.getEnabledChannels; } });
+// Inbound queue
+var inboundQueue_1 = require("./inboundQueue");
+Object.defineProperty(exports, "InboundMessageQueue", { enumerable: true, get: function () { return inboundQueue_1.InboundMessageQueue; } });
+// Channel manager
+var channelManager_1 = require("./channelManager");
+Object.defineProperty(exports, "ChannelManager", { enumerable: true, get: function () { return channelManager_1.ChannelManager; } });
+// Outbound sender
+var outbound_1 = require("./outbound");
+Object.defineProperty(exports, "OutboundChannelSender", { enumerable: true, get: function () { return outbound_1.OutboundChannelSender; } });
+Object.defineProperty(exports, "formatTemplate", { enumerable: true, get: function () { return outbound_1.formatTemplate; } });
+Object.defineProperty(exports, "DEFAULT_CHANNEL_TOOL_MAPPINGS", { enumerable: true, get: function () { return outbound_1.DEFAULT_CHANNEL_TOOL_MAPPINGS; } });
+// Permission relay
+var permissionRelay_1 = require("./permissionRelay");
+Object.defineProperty(exports, "ChannelPermissionRelay", { enumerable: true, get: function () { return permissionRelay_1.ChannelPermissionRelay; } });
+Object.defineProperty(exports, "createApprovalRace", { enumerable: true, get: function () { return permissionRelay_1.createApprovalRace; } });

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

@@ -0,0 +1,33 @@
+/**
+ * GAP-MCPC-002: Outbound Channel Sender.
+ *
+ * Sends messages to channels via MCP server tools.
+ * Supports template-based message formatting.
+ */
+import type { OutboundMessageRequest, OutboundMessageResult } from "./types";
+import type { McpClientManager } from "../client/manager";
+/** Map of channel types to their send-message tool names. */
+export interface ChannelToolMapping {
+    /** MCP tool name used for sending messages on this channel type. */
+    sendToolName: string;
+    /** Argument mapping: which parameter receives the channel ID. */
+    channelArg: string;
+    /** Argument mapping: which parameter receives the message text. */
+    textArg: string;
+}
+export declare const DEFAULT_CHANNEL_TOOL_MAPPINGS: Record<string, ChannelToolMapping>;
+/** Format a message with simple {{var}} template substitution. */
+export declare function formatTemplate(template: string, vars: Record<string, string>): string;
+export declare class OutboundChannelSender {
+    private readonly _clientManager;
+    private readonly _toolMappings;
+    constructor(clientManager: McpClientManager, toolMappings?: Record<string, ChannelToolMapping>);
+    /**
+     * Send a message to a channel.
+     * Resolves the channel source (serverName:channelId) to determine
+     * which MCP server and tool to use.
+     */
+    send(request: OutboundMessageRequest): Promise<OutboundMessageResult>;
+    private _resolveToolMapping;
+}
+//# sourceMappingURL=outbound.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"outbound.d.ts","sourceRoot":"","sources":["../../../src/mcp/channels/outbound.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAC7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAO1D,6DAA6D;AAC7D,MAAM,WAAW,kBAAkB;IACjC,oEAAoE;IACpE,YAAY,EAAE,MAAM,CAAC;IACrB,iEAAiE;IACjE,UAAU,EAAE,MAAM,CAAC;IACnB,mEAAmE;IACnE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,6BAA6B,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAI5E,CAAC;AAMF,kEAAkE;AAClE,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3B,MAAM,CAER;AAMD,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAmB;IAClD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqC;gBAGjE,aAAa,EAAE,gBAAgB,EAC/B,YAAY,GAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAiC;IAMlF;;;;OAIG;IACG,IAAI,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC;YAgD7D,mBAAmB;CAelC"}

package/dist/mcp/channels/outbound.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * GAP-MCPC-002: Outbound Channel Sender.
+ *
+ * Sends messages to channels via MCP server tools.
+ * Supports template-based message formatting.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutboundChannelSender = exports.DEFAULT_CHANNEL_TOOL_MAPPINGS = void 0;
+exports.formatTemplate = formatTemplate;
+exports.DEFAULT_CHANNEL_TOOL_MAPPINGS = {
+    slack: { sendToolName: "slack_send_message", channelArg: "channel", textArg: "text" },
+    discord: { sendToolName: "discord_send_message", channelArg: "channel_id", textArg: "content" },
+    email: { sendToolName: "gmail_create_draft", channelArg: "to", textArg: "body" },
+};
+// ---------------------------------------------------------------------------
+// Template formatting
+// ---------------------------------------------------------------------------
+/** Format a message with simple {{var}} template substitution. */
+function formatTemplate(template, vars) {
+    return template.replace(/\{\{(\w+)\}\}/g, (_match, key) => vars[key] ?? `{{${key}}}`);
+}
+// ---------------------------------------------------------------------------
+// OutboundChannelSender
+// ---------------------------------------------------------------------------
+class OutboundChannelSender {
+    _clientManager;
+    _toolMappings;
+    constructor(clientManager, toolMappings = exports.DEFAULT_CHANNEL_TOOL_MAPPINGS) {
+        this._clientManager = clientManager;
+        this._toolMappings = toolMappings;
+    }
+    /**
+     * Send a message to a channel.
+     * Resolves the channel source (serverName:channelId) to determine
+     * which MCP server and tool to use.
+     */
+    async send(request) {
+        const colonIdx = request.channelSource.indexOf(":");
+        if (colonIdx < 0) {
+            return {
+                success: false,
+                error: `Invalid channel source "${request.channelSource}" — expected "serverName:channelId"`,
+            };
+        }
+        const serverName = request.channelSource.slice(0, colonIdx);
+        const channelId = request.channelSource.slice(colonIdx + 1);
+        // Resolve text: apply template if provided
+        let text = request.text;
+        if (request.template && request.templateVars) {
+            text = formatTemplate(request.template, request.templateVars);
+        }
+        // Find tool mapping by trying to detect channel type from server tools
+        const mapping = await this._resolveToolMapping(serverName);
+        if (!mapping) {
+            return {
+                success: false,
+                error: `No send-message tool mapping found for server "${serverName}"`,
+            };
+        }
+        try {
+            const args = {
+                [mapping.channelArg]: channelId,
+                [mapping.textArg]: text,
+            };
+            const result = await this._clientManager.callTool(serverName, mapping.sendToolName, args);
+            return {
+                success: result.success,
+                messageId: result.content[0]?.text,
+                error: result.error,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { success: false, error: message };
+        }
+    }
+    async _resolveToolMapping(serverName) {
+        try {
+            const tools = await this._clientManager.listTools(serverName);
+            const toolNames = tools.map((t) => t.name);
+            for (const [_type, mapping] of Object.entries(this._toolMappings)) {
+                if (toolNames.includes(mapping.sendToolName)) {
+                    return mapping;
+                }
+            }
+        }
+        catch {
+            // Server not connected or tools unavailable
+        }
+        return undefined;
+    }
+}
+exports.OutboundChannelSender = OutboundChannelSender;

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

@@ -0,0 +1,62 @@
+/**
+ * GAP-MCPC-003: Channel Permission Relay.
+ *
+ * Routes breakpoint approval prompts through messaging channels.
+ * Uses a racing claim() pattern: channel response races against
+ * local interaction, first resolver wins.
+ */
+import type { ChannelApprovalRequest, ChannelApprovalResponse, ApprovalClaim, ChannelApprovalSecurityConfig } from "./types";
+import type { OutboundChannelSender } from "./outbound";
+export interface PermissionRelayOptions {
+    /** Outbound sender for dispatching approval requests to channels. */
+    sender: OutboundChannelSender;
+    /** Security configuration for channel approvals. */
+    security?: ChannelApprovalSecurityConfig;
+}
+/** Result of a relay attempt. */
+export interface RelayResult {
+    /** Whether the relay was dispatched (false if blocked by security). */
+    relayed: boolean;
+    /** Reason if not relayed. */
+    reason?: string;
+    /** Request ID for tracking. */
+    requestId?: string;
+}
+/**
+ * Creates a claimable approval slot.
+ * Multiple resolvers can race to claim it; only the first wins.
+ */
+export declare function createApprovalRace(): {
+    claim: (source: string, response?: ChannelApprovalResponse) => ApprovalClaim;
+    getWinner: () => ApprovalClaim | undefined;
+    promise: Promise<ApprovalClaim>;
+};
+export declare class ChannelPermissionRelay {
+    private readonly _sender;
+    private readonly _security;
+    private readonly _pendingRequests;
+    constructor(options: PermissionRelayOptions);
+    /**
+     * Check whether a breakpoint can be relayed through channels.
+     * Returns false for terminal-only breakpoints or when relay is disabled.
+     */
+    canRelay(breakpointId: string, tags?: string[]): boolean;
+    /**
+     * Relay a breakpoint approval request to all active channels.
+     * Returns relay result. Does NOT wait for responses — use handleResponse()
+     * to process incoming channel approvals.
+     */
+    relay(request: ChannelApprovalRequest, channelSources: string[], tags?: string[]): Promise<RelayResult>;
+    /**
+     * Handle a response from a channel.
+     * Returns the matched request if it was still pending (not expired).
+     */
+    handleResponse(response: ChannelApprovalResponse): ChannelApprovalRequest | undefined;
+    /** Get a pending request by ID (returns undefined if expired). */
+    getPendingRequest(requestId: string): ChannelApprovalRequest | undefined;
+    /** Get all pending (non-expired) requests. */
+    getPendingRequests(): ChannelApprovalRequest[];
+    /** Get the security configuration. */
+    get security(): ChannelApprovalSecurityConfig;
+}
+//# sourceMappingURL=permissionRelay.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"permissionRelay.d.ts","sourceRoot":"","sources":["../../../src/mcp/channels/permissionRelay.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,sBAAsB,EACtB,uBAAuB,EACvB,aAAa,EACb,6BAA6B,EAC9B,MAAM,SAAS,CAAC;AAEjB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAMxD,MAAM,WAAW,sBAAsB;IACrC,qEAAqE;IACrE,MAAM,EAAE,qBAAqB,CAAC;IAC9B,oDAAoD;IACpD,QAAQ,CAAC,EAAE,6BAA6B,CAAC;CAC1C;AAED,iCAAiC;AACjC,MAAM,WAAW,WAAW;IAC1B,uEAAuE;IACvE,OAAO,EAAE,OAAO,CAAC;IACjB,6BAA6B;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,+BAA+B;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAMD;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI;IACpC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,uBAAuB,KAAK,aAAa,CAAC;IAC7E,SAAS,EAAE,MAAM,aAAa,GAAG,SAAS,CAAC;IAC3C,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;CACjC,CAwBA;AAMD,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;IAChD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgC;IAC1D,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA6C;gBAElE,OAAO,EAAE,sBAAsB;IAK3C;;;OAGG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO;IAsBxD;;;;OAIG;IACG,KAAK,CACT,OAAO,EAAE,sBAAsB,EAC/B,cAAc,EAAE,MAAM,EAAE,EACxB,IAAI,CAAC,EAAE,MAAM,EAAE,GACd,OAAO,CAAC,WAAW,CAAC;IAuCvB;;;OAGG;IACH,cAAc,CAAC,QAAQ,EAAE,uBAAuB,GAAG,sBAAsB,GAAG,SAAS;IAerF,kEAAkE;IAClE,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,sBAAsB,GAAG,SAAS;IAWxE,8CAA8C;IAC9C,kBAAkB,IAAI,sBAAsB,EAAE;IAc9C,sCAAsC;IACtC,IAAI,QAAQ,IAAI,6BAA6B,CAE5C;CACF"}

package/dist/mcp/channels/permissionRelay.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * GAP-MCPC-003: Channel Permission Relay.
+ *
+ * Routes breakpoint approval prompts through messaging channels.
+ * Uses a racing claim() pattern: channel response races against
+ * local interaction, first resolver wins.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelPermissionRelay = void 0;
+exports.createApprovalRace = createApprovalRace;
+const types_1 = require("./types");
+// ---------------------------------------------------------------------------
+// Approval claim racing
+// ---------------------------------------------------------------------------
+/**
+ * Creates a claimable approval slot.
+ * Multiple resolvers can race to claim it; only the first wins.
+ */
+function createApprovalRace() {
+    let winner;
+    let resolvePromise;
+    const promise = new Promise((resolve) => {
+        resolvePromise = resolve;
+    });
+    function claim(source, response) {
+        if (winner) {
+            return { claimed: false, source };
+        }
+        winner = { claimed: true, source, response };
+        if (resolvePromise) {
+            resolvePromise(winner);
+        }
+        return winner;
+    }
+    return {
+        claim,
+        getWinner: () => winner,
+        promise,
+    };
+}
+// ---------------------------------------------------------------------------
+// ChannelPermissionRelay
+// ---------------------------------------------------------------------------
+class ChannelPermissionRelay {
+    _sender;
+    _security;
+    _pendingRequests = new Map();
+    constructor(options) {
+        this._sender = options.sender;
+        this._security = options.security ?? types_1.DEFAULT_APPROVAL_SECURITY;
+    }
+    /**
+     * Check whether a breakpoint can be relayed through channels.
+     * Returns false for terminal-only breakpoints or when relay is disabled.
+     */
+    canRelay(breakpointId, tags) {
+        if (!this._security.enabled)
+            return false;
+        // Check terminal-only tags
+        if (tags) {
+            for (const tag of tags) {
+                if (this._security.terminalOnlyTags.includes(tag)) {
+                    return false;
+                }
+            }
+        }
+        // Check breakpoint ID prefixes for terminal-only categories
+        for (const restrictedTag of this._security.terminalOnlyTags) {
+            if (breakpointId.startsWith(`${restrictedTag}.`)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Relay a breakpoint approval request to all active channels.
+     * Returns relay result. Does NOT wait for responses — use handleResponse()
+     * to process incoming channel approvals.
+     */
+    async relay(request, channelSources, tags) {
+        if (!this.canRelay(request.breakpointId, tags)) {
+            return {
+                relayed: false,
+                reason: `Breakpoint "${request.breakpointId}" is restricted to terminal-only approval`,
+            };
+        }
+        if (channelSources.length === 0) {
+            return { relayed: false, reason: "No active channels to relay to" };
+        }
+        this._pendingRequests.set(request.requestId, request);
+        // Send to all channels
+        const template = `Breakpoint approval needed:\n**{{description}}**\nRun: {{runId}}\nOptions: {{options}}\n\nReply to approve or reject.`;
+        const templateVars = {
+            description: request.description,
+            runId: request.runId,
+            options: request.options.join(", "),
+        };
+        // formatTemplate is applied by OutboundChannelSender when both template and templateVars are present.
+        // text is set as fallback in case template rendering fails.
+        const fallbackText = `Approval needed: ${request.description} (${request.options.join(", ")})`;
+        await Promise.allSettled(channelSources.map((source) => this._sender.send({
+            channelSource: source,
+            text: fallbackText,
+            template,
+            templateVars,
+        })));
+        return { relayed: true, requestId: request.requestId };
+    }
+    /**
+     * Handle a response from a channel.
+     * Returns the matched request if it was still pending (not expired).
+     */
+    handleResponse(response) {
+        const request = this._pendingRequests.get(response.requestId);
+        if (!request)
+            return undefined;
+        // Check if the request has expired
+        const elapsed = Date.now() - new Date(request.createdAt).getTime();
+        if (elapsed > request.timeoutMs) {
+            this._pendingRequests.delete(response.requestId);
+            return undefined;
+        }
+        this._pendingRequests.delete(response.requestId);
+        return request;
+    }
+    /** Get a pending request by ID (returns undefined if expired). */
+    getPendingRequest(requestId) {
+        const request = this._pendingRequests.get(requestId);
+        if (!request)
+            return undefined;
+        const elapsed = Date.now() - new Date(request.createdAt).getTime();
+        if (elapsed > request.timeoutMs) {
+            this._pendingRequests.delete(requestId);
+            return undefined;
+        }
+        return request;
+    }
+    /** Get all pending (non-expired) requests. */
+    getPendingRequests() {
+        const now = Date.now();
+        const results = [];
+        for (const [id, request] of this._pendingRequests) {
+            const elapsed = now - new Date(request.createdAt).getTime();
+            if (elapsed > request.timeoutMs) {
+                this._pendingRequests.delete(id);
+            }
+            else {
+                results.push(request);
+            }
+        }
+        return results;
+    }
+    /** Get the security configuration. */
+    get security() {
+        return this._security;
+    }
+}
+exports.ChannelPermissionRelay = ChannelPermissionRelay;

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

@@ -0,0 +1,135 @@
+/**
+ * GAP-MCPC-001/002/003: MCP Channel types.
+ *
+ * Defines types for messaging channels backed by MCP servers.
+ * Channels enable inbound/outbound messaging and breakpoint approval
+ * routing through external platforms (Slack, Discord, email, etc.).
+ */
+/** Channel capability declaration from an MCP server. */
+export interface ChannelCapability {
+    /** Whether the server supports channel notifications. */
+    inbound: boolean;
+    /** Whether the server supports outbound messaging tools. */
+    outbound: boolean;
+    /** Whether the server supports permission relay. */
+    permissionRelay: boolean;
+    /** Human-readable channel type (slack, discord, email, etc.). */
+    channelType?: string;
+}
+/** Configuration for a channel binding. */
+export interface ChannelConfig {
+    /** MCP server name (matches McpServerConfig.name). */
+    serverName: string;
+    /** Display name shown in notifications. */
+    displayName: string;
+    /** Channel identifier (e.g. Slack channel ID). */
+    channelId: string;
+    /** Channel type for routing. */
+    channelType: string;
+    /** Whether the channel is currently enabled. */
+    enabled: boolean;
+}
+/** A message received from a channel. */
+export interface ChannelMessage {
+    /** Unique message identifier. */
+    messageId: string;
+    /** Channel source identifier (serverName:channelId). */
+    source: string;
+    /** Sender identifier (platform-specific). */
+    sender: string;
+    /** Message content. */
+    content: string;
+    /** ISO timestamp of when the message was received. */
+    receivedAt: string;
+    /** Optional metadata from the channel platform. */
+    metadata?: Record<string, unknown>;
+}
+/** Binding of a channel to a specific run. */
+export interface ChannelBinding {
+    /** Channel source (serverName:channelId). */
+    channelSource: string;
+    /** Run ID this channel is bound to. */
+    runId: string;
+    /** ISO timestamp of when the binding was created. */
+    boundAt: string;
+}
+/** Request to send an outbound message through a channel. */
+export interface OutboundMessageRequest {
+    /** Target channel source (serverName:channelId). */
+    channelSource: string;
+    /** Message text. */
+    text: string;
+    /** Optional template name for formatting. */
+    template?: string;
+    /** Template variables for substitution. */
+    templateVars?: Record<string, string>;
+}
+/** Result of sending an outbound message. */
+export interface OutboundMessageResult {
+    success: boolean;
+    /** Platform-specific message ID if available. */
+    messageId?: string;
+    error?: string;
+}
+/** A breakpoint approval request sent to a channel. */
+export interface ChannelApprovalRequest {
+    /** Unique request identifier. */
+    requestId: string;
+    /** Breakpoint ID being approved. */
+    breakpointId: string;
+    /** Run ID. */
+    runId: string;
+    /** Effect ID. */
+    effectId: string;
+    /** Human-readable description of the breakpoint. */
+    description: string;
+    /** Options available (e.g. ["approve", "reject"]). */
+    options: string[];
+    /** ISO timestamp of when the request was created. */
+    createdAt: string;
+    /** Timeout in ms for the channel response. */
+    timeoutMs: number;
+}
+/** Response to a breakpoint approval request from a channel. */
+export interface ChannelApprovalResponse {
+    /** Request ID being responded to. */
+    requestId: string;
+    /** Whether the breakpoint was approved. */
+    approved: boolean;
+    /** Optional feedback text. */
+    feedback?: string;
+    /** Who responded (platform-specific identifier). */
+    respondedBy: string;
+    /** Which channel the response came from. */
+    channelSource: string;
+    /** ISO timestamp of the response. */
+    respondedAt: string;
+}
+/**
+ * An approval claim. Multiple resolvers race; the first to claim() wins.
+ */
+export interface ApprovalClaim {
+    /** Whether this claim was the winning one. */
+    claimed: boolean;
+    /** Source of the claim (e.g. "channel:slack:general", "local:terminal"). */
+    source: string;
+    /** The response if this claim won. */
+    response?: ChannelApprovalResponse;
+}
+/** Persisted channel allowlist. */
+export interface ChannelAllowlistFile {
+    schemaVersion: string;
+    channels: ChannelConfig[];
+}
+export declare const CHANNEL_ALLOWLIST_SCHEMA_VERSION = "2026.01.channel-allowlist-v1";
+/** Per-tag or per-level security constraints for channel approvals. */
+export interface ChannelApprovalSecurityConfig {
+    /** Tags that require terminal-only approval (no channel relay). */
+    terminalOnlyTags: string[];
+    /** Whether channel approval is enabled at all. */
+    enabled: boolean;
+    /** Default timeout for channel approval requests (ms). */
+    defaultTimeoutMs: number;
+}
+export declare const DEFAULT_APPROVAL_SECURITY: ChannelApprovalSecurityConfig;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/mcp/channels/types.ts"],"names":[],"mappings":"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"}