@chrisromp/copilot-bridge 0.6.0-dev.2

package/dist/core/session-manager.js

@@ -0,0 +1,1732 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { getChannelSession, setChannelSession, clearChannelSession, getChannelPrefs, setChannelPrefs, checkPermission, addPermissionRule, getWorkspaceOverride, setWorkspaceOverride, listWorkspaceOverrides, recordAgentCall, } from '../state/store.js';
+import { getChannelConfig, getChannelBotName, evaluateConfigPermissions, isBotAdmin, getConfig, getInterAgentConfig, isHardDeny } from '../config.js';
+import { getWorkspacePath, getWorkspaceAllowPaths, ensureWorkspacesDir } from './workspace-manager.js';
+import { onboardProject } from './onboarding.js';
+import { addJob, removeJob, pauseJob, resumeJob, listJobs, formatInTimezone } from './scheduler.js';
+import { canCall, createContext, extendContext, getBotWorkspaceMap, buildWorkspacePrompt, buildCallerPrompt, resolveAgentDefinition, } from './inter-agent.js';
+import { createLogger } from '../logger.js';
+const log = createLogger('session');
+/** Custom tools auto-approved without interactive prompt (they enforce workspace boundaries internally). */
+export const BRIDGE_CUSTOM_TOOLS = ['send_file', 'show_file_in_chat', 'ask_agent', 'schedule'];
+/** Simple mutex for serializing env-sensitive session creation. */
+let envLock = Promise.resolve();
+/**
+ * Parse a .env file into a key-value map.
+ * Handles KEY=VALUE, KEY="VALUE", KEY='VALUE', comments, and blank lines.
+ */
+function parseEnvFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const vars = {};
+        for (const line of content.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const eqIdx = trimmed.indexOf('=');
+            if (eqIdx === -1)
+                continue;
+            const key = trimmed.slice(0, eqIdx).trim();
+            let value = trimmed.slice(eqIdx + 1).trim();
+            // Strip matching quotes
+            if ((value.startsWith('"') && value.endsWith('"')) ||
+                (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1);
+            }
+            if (key)
+                vars[key] = value;
+        }
+        return vars;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Run an async function with workspace env vars temporarily injected into process.env.
+ * Uses a mutex to prevent concurrent sessions from seeing each other's env vars.
+ */
+async function withWorkspaceEnv(workingDirectory, fn) {
+    const envPath = path.join(workingDirectory, '.env');
+    const vars = parseEnvFile(envPath);
+    // Always hold the lock for the full duration of fn() so we never run
+    // while another workspace's secrets are injected into process.env.
+    const prev = envLock;
+    let release;
+    envLock = new Promise(resolve => { release = resolve; });
+    await prev;
+    if (Object.keys(vars).length === 0) {
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+        }
+    }
+    // Save originals, inject workspace vars
+    const saved = {};
+    for (const [key, value] of Object.entries(vars)) {
+        saved[key] = process.env[key];
+        process.env[key] = value;
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        // Restore originals
+        for (const [key] of Object.entries(vars)) {
+            if (saved[key] === undefined) {
+                delete process.env[key];
+            }
+            else {
+                process.env[key] = saved[key];
+            }
+        }
+        release();
+    }
+}
+/**
+ * Load MCP server configs from ~/.copilot/mcp-config.json and installed plugins.
+ * Merges them into a single Record, with user config taking precedence over plugins.
+ */
+function loadMcpServers() {
+    const home = process.env.HOME;
+    if (!home)
+        return {};
+    const servers = {};
+    // 1. Load from installed plugins (.mcp.json files)
+    const pluginsDir = path.join(home, '.copilot', 'installed-plugins');
+    if (fs.existsSync(pluginsDir)) {
+        const walk = (dir) => {
+            try {
+                for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                    const full = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        // Check for .mcp.json in this directory
+                        const mcpFile = path.join(full, '.mcp.json');
+                        if (fs.existsSync(mcpFile)) {
+                            try {
+                                const cfg = JSON.parse(fs.readFileSync(mcpFile, 'utf8'));
+                                if (cfg.mcpServers) {
+                                    for (const [name, config] of Object.entries(cfg.mcpServers)) {
+                                        if (!servers[name]) {
+                                            servers[name] = config;
+                                            log.debug(`Loaded MCP "${name}" from plugin ${path.relative(pluginsDir, full)}`);
+                                        }
+                                    }
+                                }
+                            }
+                            catch (err) {
+                                log.warn(`Failed to parse ${mcpFile}: ${err}`);
+                            }
+                        }
+                        walk(full);
+                    }
+                }
+            }
+            catch { /* permission errors etc */ }
+        };
+        walk(pluginsDir);
+    }
+    // 2. Load from user mcp-config.json (overrides plugins)
+    const userConfig = path.join(home, '.copilot', 'mcp-config.json');
+    if (fs.existsSync(userConfig)) {
+        try {
+            const cfg = JSON.parse(fs.readFileSync(userConfig, 'utf8'));
+            if (cfg.mcpServers) {
+                for (const [name, config] of Object.entries(cfg.mcpServers)) {
+                    servers[name] = config;
+                    log.debug(`Loaded MCP "${name}" from mcp-config.json`);
+                }
+            }
+        }
+        catch (err) {
+            log.warn(`Failed to parse ${userConfig}: ${err}`);
+        }
+    }
+    normalizeMcpServers(servers);
+    const count = Object.keys(servers).length;
+    if (count > 0) {
+        log.info(`Loaded ${count} MCP server(s): ${Object.keys(servers).join(', ')}`);
+    }
+    return servers;
+}
+/** Ensure all MCP server entries have a tools field (SDK requires it). */
+function normalizeMcpServers(servers) {
+    for (const config of Object.values(servers)) {
+        if (!config.tools) {
+            config.tools = ['*'];
+        }
+    }
+}
+/**
+ * Load workspace-specific MCP servers from <workspacePath>/mcp-config.json.
+ * Injects workspace .env vars into each local server's env field so the CLI
+ * subprocess passes them through to MCP server processes (the CLI subprocess
+ * is long-lived and does not inherit bridge process.env changes).
+ * Also expands ${VAR} references in env values from .env or process.env.
+ */
+function loadWorkspaceMcpServers(workspacePath) {
+    const workspaceEnv = parseEnvFile(path.join(workspacePath, '.env'));
+    const configFile = path.join(workspacePath, 'mcp-config.json');
+    if (!fs.existsSync(configFile))
+        return { servers: {}, env: workspaceEnv };
+    try {
+        const cfg = JSON.parse(fs.readFileSync(configFile, 'utf8'));
+        if (!cfg.mcpServers || typeof cfg.mcpServers !== 'object')
+            return { servers: {}, env: workspaceEnv };
+        const servers = {};
+        for (const [name, config] of Object.entries(cfg.mcpServers)) {
+            const serverConfig = config;
+            // Expand ${VAR} references in config-defined env values BEFORE merging .env
+            // (only config-authored keys get expansion; .env values are always literal)
+            const configEnv = serverConfig.env ? { ...serverConfig.env } : {};
+            for (const [key, value] of Object.entries(configEnv)) {
+                if (typeof value === 'string' && value.includes('${')) {
+                    configEnv[key] = value.replace(/\$\{(\w+)\}/g, (_, varName) => workspaceEnv[varName] ?? process.env[varName] ?? '');
+                }
+            }
+            // Inject workspace .env vars into local MCP servers
+            const isLocal = !serverConfig.type || serverConfig.type === 'local' || serverConfig.type === 'stdio';
+            if (isLocal && Object.keys(workspaceEnv).length > 0) {
+                // Workspace .env as base, expanded config env overrides
+                serverConfig.env = { ...workspaceEnv, ...configEnv };
+            }
+            else {
+                serverConfig.env = configEnv;
+            }
+            servers[name] = serverConfig;
+            log.debug(`Loaded workspace MCP "${name}" from ${configFile}`);
+        }
+        normalizeMcpServers(servers);
+        return { servers, env: workspaceEnv };
+    }
+    catch (err) {
+        log.warn(`Failed to parse workspace MCP config ${configFile}: ${err}`);
+        return { servers: {}, env: workspaceEnv };
+    }
+}
+/**
+ * Extract individual command names from a shell command string.
+ * Handles chained commands: "ls -la && grep -r foo . | head" → ["ls", "grep", "head"]
+ */
+const SHELL_WRAPPERS = new Set(['bash', 'sh', 'zsh', 'dash', 'fish', 'env', 'sudo', 'nohup', 'xargs', 'exec', 'eval']);
+export function extractCommandPatterns(input) {
+    if (!input || typeof input !== 'object')
+        return [];
+    const obj = input;
+    const cmd = obj.fullCommandText || obj.command || obj.description || obj.path;
+    if (typeof cmd !== 'string')
+        return [];
+    const segments = cmd.split(/\s*(?:&&|\|\||[|;])\s*/);
+    const names = segments
+        .map((seg) => seg.trim().split(/\s+/)[0])
+        .filter(Boolean);
+    return [...new Set(names)];
+}
+/**
+ * Discover skill directories following Copilot CLI conventions:
+ * - ~/.copilot/skills/ (user-level)
+ * - <workspace>/.github/skills/ (project-level)
+ * - <workspace>/.agents/skills/ (project-level, legacy)
+ */
+function discoverSkillDirectories(workingDirectory) {
+    const home = process.env.HOME;
+    const roots = [];
+    // User-level skills
+    if (home)
+        roots.push(path.join(home, '.copilot', 'skills'));
+    // Project-level skills (standard)
+    roots.push(path.join(workingDirectory, '.github', 'skills'));
+    // Project-level skills (legacy)
+    roots.push(path.join(workingDirectory, '.agents', 'skills'));
+    const dirs = [];
+    for (const skillsRoot of roots) {
+        if (!fs.existsSync(skillsRoot))
+            continue;
+        try {
+            for (const entry of fs.readdirSync(skillsRoot, { withFileTypes: true })) {
+                if (entry.isDirectory()) {
+                    dirs.push(path.join(skillsRoot, entry.name));
+                }
+            }
+        }
+        catch { /* permission errors etc */ }
+    }
+    if (dirs.length > 0) {
+        log.info(`Discovered ${dirs.length} skill(s): ${dirs.map(d => path.basename(d)).join(', ')}`);
+    }
+    return dirs;
+}
+export class SessionManager {
+    bridge;
+    channelSessions = new Map(); // channelId → sessionId
+    sessionChannels = new Map(); // sessionId → channelId (reverse)
+    sessionUnsubscribes = new Map(); // sessionId → unsubscribe fn
+    eventHandler = null;
+    mcpServers; // global (plugin + user) MCP servers
+    // Pending permission requests (queue per channel to avoid overwrites)
+    pendingPermissions = new Map();
+    // Pending user input requests (queue per channel to avoid overwrites)
+    pendingUserInput = new Map();
+    // Cached context usage from session.usage_info events
+    contextUsage = new Map();
+    lastMessageUserIds = new Map(); // channelId → userId of last message sender
+    // Handler for send_file tool (set by index.ts, calls adapter.sendFile)
+    sendFileHandler = null;
+    getAdapterForChannel = null;
+    constructor(bridge) {
+        this.bridge = bridge;
+        this.mcpServers = loadMcpServers();
+        ensureWorkspacesDir();
+    }
+    /** Register a handler for session events (streaming, tool calls, etc.) */
+    onSessionEvent(handler) {
+        this.eventHandler = handler;
+    }
+    /** Register handler for the send_file custom tool. */
+    onSendFile(handler) {
+        this.sendFileHandler = handler;
+    }
+    /** Register adapter resolver for onboarding tools. */
+    onGetAdapter(resolver) {
+        this.getAdapterForChannel = resolver;
+    }
+    /**
+     * Resolve MCP servers for a workspace: workspace config (highest priority)
+     * merged on top of global servers (plugin + user config).
+     */
+    resolveMcpServers(workingDirectory) {
+        const { servers: workspaceServers, env: workspaceEnv } = loadWorkspaceMcpServers(workingDirectory);
+        // Clone global servers and inject workspace .env into local ones
+        const merged = {};
+        for (const [name, config] of Object.entries(this.mcpServers)) {
+            const serverConfig = { ...config };
+            const isLocal = !serverConfig.type || serverConfig.type === 'local' || serverConfig.type === 'stdio';
+            if (isLocal && Object.keys(workspaceEnv).length > 0) {
+                serverConfig.env = { ...workspaceEnv, ...(serverConfig.env || {}) };
+            }
+            merged[name] = serverConfig;
+        }
+        if (Object.keys(workspaceServers).length === 0)
+            return merged;
+        return { ...merged, ...workspaceServers };
+    }
+    /** Get annotated MCP server info for a channel, showing which layer each server came from. */
+    getMcpServerInfo(channelId) {
+        const workingDirectory = this.resolveWorkingDirectory(channelId);
+        const { servers: workspaceServers } = loadWorkspaceMcpServers(workingDirectory);
+        const globalNames = new Set(Object.keys(this.mcpServers));
+        const result = [];
+        // All user-level servers — mark project overrides accordingly
+        for (const name of globalNames) {
+            if (name in workspaceServers) {
+                result.push({ name, source: 'workspace (override)' });
+            }
+            else {
+                result.push({ name, source: 'user' });
+            }
+        }
+        // Project-only servers (not in user-level)
+        for (const name of Object.keys(workspaceServers)) {
+            if (!globalNames.has(name)) {
+                result.push({ name, source: 'workspace' });
+            }
+        }
+        return result.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    /** Get skill info for a channel — discovers skills and reads their descriptions from SKILL.md frontmatter. */
+    getSkillInfo(channelId) {
+        const workingDirectory = this.resolveWorkingDirectory(channelId);
+        const dirs = discoverSkillDirectories(workingDirectory);
+        const skills = [];
+        for (const dir of dirs) {
+            const name = path.basename(dir);
+            const skillFile = path.join(dir, 'SKILL.md');
+            let description = '';
+            let source = 'user';
+            // Determine source from path (normalize separators for cross-platform)
+            const normalized = dir.split(path.sep).join('/');
+            if (normalized.includes('.copilot/skills'))
+                source = 'user';
+            else if (normalized.includes('.github/skills'))
+                source = 'workspace';
+            else if (normalized.includes('.agents/skills'))
+                source = 'workspace';
+            // Try to read description from SKILL.md (matches first description: line)
+            if (fs.existsSync(skillFile)) {
+                try {
+                    const content = fs.readFileSync(skillFile, 'utf8');
+                    const descMatch = content.match(/^description:\s*["']?(.+?)["']?\s*$/m);
+                    if (descMatch)
+                        description = descMatch[1];
+                }
+                catch { /* skip */ }
+            }
+            skills.push({ name, description, source });
+        }
+        return skills.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    /** Get or create a session for a channel. */
+    async ensureSession(channelId) {
+        // Check in-memory cache first
+        const cachedSessionId = this.channelSessions.get(channelId);
+        if (cachedSessionId && this.bridge.getSession(cachedSessionId)) {
+            return { sessionId: cachedSessionId, isNew: false };
+        }
+        // Check SQLite for persisted session
+        const storedSessionId = getChannelSession(channelId);
+        if (storedSessionId) {
+            try {
+                await this.attachSession(channelId, storedSessionId);
+                return { sessionId: storedSessionId, isNew: false };
+            }
+            catch (err) {
+                log.warn(`Failed to resume session ${storedSessionId} for channel ${channelId}, creating new:`, err);
+                clearChannelSession(channelId);
+            }
+        }
+        // Create new session
+        const sessionId = await this.createNewSession(channelId);
+        return { sessionId, isNew: true };
+    }
+    /** Create a brand new session for a channel (used by /new command). */
+    async newSession(channelId) {
+        // Clean up existing session
+        const existingId = this.channelSessions.get(channelId);
+        if (existingId) {
+            const unsub = this.sessionUnsubscribes.get(existingId);
+            if (unsub) {
+                unsub();
+                this.sessionUnsubscribes.delete(existingId);
+            }
+            try {
+                this.bridge.destroySession(existingId);
+            }
+            catch { /* best-effort */ }
+            this.channelSessions.delete(channelId);
+            this.sessionChannels.delete(existingId);
+            this.contextUsage.delete(channelId);
+            this.lastMessageUserIds.delete(channelId);
+        }
+        clearChannelSession(channelId);
+        return this.createNewSession(channelId);
+    }
+    /** Reload the current session — detach and re-attach to pick up AGENTS.md / config changes. */
+    async reloadSession(channelId) {
+        const existingId = this.channelSessions.get(channelId) ?? getChannelSession(channelId) ?? undefined;
+        if (!existingId) {
+            // No session to reload — just create one
+            return this.createNewSession(channelId);
+        }
+        // Detach event listeners and release the bridge handle
+        const unsub = this.sessionUnsubscribes.get(existingId);
+        if (unsub) {
+            unsub();
+            this.sessionUnsubscribes.delete(existingId);
+        }
+        this.bridge.releaseSession(existingId);
+        // Re-attach the same session (re-reads workspace config, AGENTS.md, MCP, etc.)
+        this.contextUsage.delete(channelId);
+        this.lastMessageUserIds.delete(channelId);
+        try {
+            await this.attachSession(channelId, existingId);
+            log.info(`Reloaded session ${existingId} for channel ${channelId}`);
+            return existingId;
+        }
+        catch (err) {
+            // Session no longer exists server-side (e.g., workspace was deleted and re-created)
+            log.warn(`Stale session ${existingId} for channel ${channelId}: ${err?.message ?? err}. Creating new session.`);
+            this.channelSessions.delete(channelId);
+            this.sessionChannels.delete(existingId);
+            this.contextUsage.delete(channelId);
+            this.lastMessageUserIds.delete(channelId);
+            clearChannelSession(channelId);
+            return this.createNewSession(channelId);
+        }
+    }
+    /** Resume a specific past session by ID. */
+    async resumeToSession(channelId, targetSessionId) {
+        // If already attached to this session, just reload it
+        const existingId = this.channelSessions.get(channelId);
+        if (existingId === targetSessionId) {
+            return this.reloadSession(channelId);
+        }
+        // Clean up current session for this channel
+        if (existingId) {
+            const unsub = this.sessionUnsubscribes.get(existingId);
+            if (unsub) {
+                unsub();
+                this.sessionUnsubscribes.delete(existingId);
+            }
+            this.bridge.releaseSession(existingId);
+            this.channelSessions.delete(channelId);
+            this.sessionChannels.delete(existingId);
+            this.contextUsage.delete(channelId);
+            this.lastMessageUserIds.delete(channelId);
+        }
+        // If target session is active on another channel, release it first
+        const otherChannel = this.sessionChannels.get(targetSessionId);
+        if (otherChannel) {
+            const unsub = this.sessionUnsubscribes.get(targetSessionId);
+            if (unsub) {
+                unsub();
+                this.sessionUnsubscribes.delete(targetSessionId);
+            }
+            this.bridge.releaseSession(targetSessionId);
+            this.channelSessions.delete(otherChannel);
+            this.sessionChannels.delete(targetSessionId);
+            this.contextUsage.delete(otherChannel);
+            clearChannelSession(otherChannel);
+        }
+        // Attach to the target session — fail hard if it doesn't exist
+        // (user explicitly asked for this session, don't silently replace it)
+        await this.attachSession(channelId, targetSessionId);
+        setChannelSession(channelId, targetSessionId);
+        log.info(`Resumed session ${targetSessionId} for channel ${channelId}`);
+        return targetSessionId;
+    }
+    /** Send a message to a channel's session. Returns immediately; responses come via events. */
+    async sendMessage(channelId, text, attachments, userId) {
+        if (userId)
+            this.lastMessageUserIds.set(channelId, userId);
+        // Auto-deny any pending permissions so the session unblocks
+        this.clearPendingPermissions(channelId);
+        const { sessionId } = await this.ensureSession(channelId);
+        const session = this.bridge.getSession(sessionId);
+        if (!session)
+            throw new Error(`Session ${sessionId} not found after ensure`);
+        const sendOpts = { prompt: text, attachments };
+        try {
+            const messageId = await session.send(sendOpts);
+            return messageId;
+        }
+        catch (err) {
+            const msg = String(err?.message ?? err);
+            log.error(`Send failed for session ${sessionId}:`, msg);
+            // Try to reconnect to the same session (CLI subprocess may have restarted)
+            try {
+                log.info(`Attempting to re-attach session ${sessionId}...`);
+                this.bridge.releaseSession(sessionId);
+                const unsub = this.sessionUnsubscribes.get(sessionId);
+                if (unsub) {
+                    unsub();
+                    this.sessionUnsubscribes.delete(sessionId);
+                }
+                await this.attachSession(channelId, sessionId);
+                const reconnected = this.bridge.getSession(sessionId);
+                if (reconnected) {
+                    log.info(`Re-attached session ${sessionId} successfully`);
+                    return reconnected.send(sendOpts);
+                }
+            }
+            catch (retryErr) {
+                log.warn(`Re-attach failed:`, retryErr?.message ?? retryErr);
+            }
+            // Last resort: create a new session
+            log.info(`Creating new session for channel ${channelId}...`);
+            const newSessionId = await this.newSession(channelId);
+            const newSession = this.bridge.getSession(newSessionId);
+            if (!newSession)
+                throw new Error(`New session ${newSessionId} not found`);
+            return newSession.send(sendOpts);
+        }
+    }
+    /** Send a mid-turn message to an active session using immediate mode (steering).
+     *  Throws if no active session exists or if send fails. */
+    async sendMidTurn(channelId, text, userId) {
+        if (userId)
+            this.lastMessageUserIds.set(channelId, userId);
+        const sessionId = this.channelSessions.get(channelId);
+        if (!sessionId)
+            throw new Error(`No active session for channel ${channelId}`);
+        const session = this.bridge.getSession(sessionId);
+        if (!session)
+            throw new Error(`Session ${sessionId} not found`);
+        log.info(`Mid-turn send (immediate) for channel ${channelId.slice(0, 8)}...: "${text.slice(0, 100)}"`);
+        return session.send({ prompt: text, mode: 'immediate' });
+    }
+    /** Deny all pending permissions for a channel (e.g., when user sends a new message instead). */
+    clearPendingPermissions(channelId) {
+        const queue = this.pendingPermissions.get(channelId);
+        if (queue && queue.length > 0) {
+            log.info(`Auto-denying ${queue.length} pending permission(s) for channel ${channelId}`);
+            for (const entry of queue) {
+                entry.resolve({ kind: 'denied-interactively-by-user' });
+            }
+            this.pendingPermissions.delete(channelId);
+        }
+        const inputQueue = this.pendingUserInput.get(channelId);
+        if (inputQueue && inputQueue.length > 0) {
+            log.info(`Cancelling ${inputQueue.length} pending input request(s) for channel ${channelId}`);
+            for (const entry of inputQueue) {
+                entry.resolve({ answer: '', wasFreeform: true });
+            }
+            this.pendingUserInput.delete(channelId);
+        }
+    }
+    /** Switch the model for a channel's session. */
+    async switchModel(channelId, model) {
+        const sessionId = this.channelSessions.get(channelId);
+        if (sessionId) {
+            try {
+                await this.bridge.switchSessionModel(sessionId, model);
+            }
+            catch (err) {
+                log.warn(`RPC model switch failed:`, err);
+            }
+        }
+        setChannelPrefs(channelId, { model });
+    }
+    /** Switch the agent for a channel's session. */
+    async switchAgent(channelId, agent) {
+        const sessionId = this.channelSessions.get(channelId);
+        if (sessionId) {
+            try {
+                if (agent) {
+                    await this.bridge.selectAgent(sessionId, agent);
+                }
+                else {
+                    await this.bridge.deselectAgent(sessionId);
+                }
+            }
+            catch (err) {
+                log.warn(`RPC agent switch failed:`, err);
+            }
+        }
+        setChannelPrefs(channelId, { agent });
+    }
+    /** Get effective preferences for a channel (config merged with runtime overrides). */
+    getEffectivePrefs(channelId) {
+        const configChannel = getChannelConfig(channelId);
+        const storedPrefs = getChannelPrefs(channelId);
+        return {
+            model: storedPrefs?.model ?? configChannel.model ?? 'claude-sonnet-4.6',
+            agent: storedPrefs?.agent !== undefined ? storedPrefs.agent : configChannel.agent,
+            verbose: storedPrefs?.verbose ?? configChannel.verbose,
+            triggerMode: configChannel.triggerMode,
+            threadedReplies: storedPrefs?.threadedReplies ?? configChannel.threadedReplies,
+            permissionMode: storedPrefs?.permissionMode ?? configChannel.permissionMode,
+            reasoningEffort: storedPrefs?.reasoningEffort ?? configChannel.reasoningEffort ?? null,
+        };
+    }
+    /** Get model info (for checking capabilities like reasoning effort). */
+    async getModelInfo(modelId) {
+        try {
+            const models = await this.bridge.listModels();
+            return models.find(m => m.id === modelId) ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** List all available models. */
+    async listModels() {
+        return this.bridge.listModels();
+    }
+    /** Check if the Copilot CLI is authenticated. */
+    async getAuthStatus() {
+        try {
+            return await this.bridge.getAuthStatus();
+        }
+        catch {
+            return { isAuthenticated: false, statusMessage: 'Unable to check auth status' };
+        }
+    }
+    /** Resolve a pending permission request (first in queue). */
+    resolvePermission(channelId, allow, remember) {
+        const queue = this.pendingPermissions.get(channelId);
+        if (!queue || queue.length === 0)
+            return false;
+        const pending = queue.shift();
+        if (remember) {
+            const action = allow ? 'allow' : 'deny';
+            if (pending.serverName) {
+                // MCP tool: save at server level so all tools on this server are covered
+                addPermissionRule(channelId, `mcp:${pending.serverName}`, '*', action);
+                log.info(`Saved ${action} rule for MCP server "${pending.serverName}" in channel ${channelId}`);
+            }
+            else if (pending.commands.length > 0) {
+                for (const cmd of pending.commands) {
+                    addPermissionRule(channelId, pending.toolName, cmd, action);
+                }
+            }
+            else {
+                addPermissionRule(channelId, pending.toolName, '*', action);
+            }
+        }
+        pending.resolve(allow
+            ? { kind: 'approved' }
+            : { kind: 'denied-interactively-by-user' });
+        if (queue.length === 0) {
+            this.pendingPermissions.delete(channelId);
+        }
+        else {
+            // Surface the next queued permission request
+            const next = queue[0];
+            this.eventHandler?.(next.sessionId, channelId, {
+                type: 'bridge.permission_request',
+                data: {
+                    toolName: next.toolName,
+                    serverName: next.serverName,
+                    input: next.toolInput,
+                    commands: next.commands,
+                },
+            });
+        }
+        return true;
+    }
+    /** Resolve a pending user input request (first in queue). */
+    resolveUserInput(channelId, answer) {
+        const queue = this.pendingUserInput.get(channelId);
+        if (!queue || queue.length === 0)
+            return false;
+        const pending = queue.shift();
+        pending.resolve({ answer, wasFreeform: true });
+        if (queue.length === 0) {
+            this.pendingUserInput.delete(channelId);
+        }
+        else {
+            // Surface the next queued user input request
+            const next = queue[0];
+            this.eventHandler?.(next.sessionId, channelId, {
+                type: 'bridge.user_input_request',
+                data: {
+                    question: next.question,
+                    choices: next.choices,
+                    allowFreeform: next.allowFreeform,
+                },
+            });
+        }
+        return true;
+    }
+    /** Check if channel has a pending permission request. */
+    hasPendingPermission(channelId) {
+        const queue = this.pendingPermissions.get(channelId);
+        return !!queue && queue.length > 0;
+    }
+    /** Get the current session ID for a channel (if any). */
+    getSessionId(channelId) {
+        return this.channelSessions.get(channelId) ?? getChannelSession(channelId) ?? undefined;
+    }
+    /** Abort the current turn for a channel's session. */
+    async abortSession(channelId) {
+        const sessionId = this.channelSessions.get(channelId);
+        if (sessionId) {
+            await this.bridge.abortSession(sessionId);
+        }
+    }
+    /** Check if channel has a pending user input request. */
+    hasPendingUserInput(channelId) {
+        const queue = this.pendingUserInput.get(channelId);
+        return !!queue && queue.length > 0;
+    }
+    /** Get info about the current session for a channel. */
+    getSessionInfo(channelId) {
+        const sessionId = this.channelSessions.get(channelId);
+        if (!sessionId)
+            return null;
+        const prefs = this.getEffectivePrefs(channelId);
+        return { sessionId, model: prefs.model, agent: prefs.agent ?? null };
+    }
+    /** Get cached context window usage for a channel. */
+    getContextUsage(channelId) {
+        return this.contextUsage.get(channelId) ?? null;
+    }
+    /** List past sessions for this channel's working directory. */
+    async listChannelSessions(channelId) {
+        const workingDirectory = this.resolveWorkingDirectory(channelId);
+        const sessions = await this.bridge.listSessions({ cwd: workingDirectory });
+        const currentId = this.channelSessions.get(channelId);
+        return sessions.map(s => ({
+            sessionId: s.sessionId,
+            startTime: s.startTime,
+            modifiedTime: s.modifiedTime,
+            summary: s.summary,
+            isCurrent: s.sessionId === currentId,
+        }));
+    }
+    // --- Private helpers ---
+    /** Resolve working directory: SQLite workspace override → channel config → default workspace path. */
+    resolveWorkingDirectory(channelId) {
+        const botName = getChannelBotName(channelId);
+        const override = getWorkspaceOverride(botName);
+        if (override)
+            return override.workingDirectory;
+        const config = getChannelConfig(channelId);
+        if (config.workingDirectory)
+            return config.workingDirectory;
+        return getWorkspacePath(botName);
+    }
+    async createNewSession(channelId) {
+        const prefs = this.getEffectivePrefs(channelId);
+        const workingDirectory = this.resolveWorkingDirectory(channelId);
+        const defaultConfigDir = process.env.HOME ? `${process.env.HOME}/.copilot` : undefined;
+        const reasoningEffort = prefs.reasoningEffort;
+        const skillDirectories = discoverSkillDirectories(workingDirectory);
+        const customTools = this.buildCustomTools(channelId);
+        const session = await withWorkspaceEnv(workingDirectory, () => this.bridge.createSession({
+            model: prefs.model,
+            workingDirectory,
+            configDir: defaultConfigDir,
+            reasoningEffort: reasoningEffort ?? undefined,
+            mcpServers: this.resolveMcpServers(workingDirectory),
+            skillDirectories: skillDirectories.length > 0 ? skillDirectories : undefined,
+            onPermissionRequest: (request, invocation) => this.handlePermissionRequest(channelId, request, invocation),
+            onUserInputRequest: (request, invocation) => this.handleUserInputRequest(channelId, request, invocation),
+            tools: customTools.length > 0 ? customTools : undefined,
+        }));
+        const sessionId = session.sessionId;
+        this.channelSessions.set(channelId, sessionId);
+        this.sessionChannels.set(sessionId, channelId);
+        setChannelSession(channelId, sessionId);
+        this.attachSessionEvents(session, channelId);
+        log.info(`Created session ${sessionId} for channel ${channelId}`);
+        return sessionId;
+    }
+    async attachSession(channelId, sessionId) {
+        const prefs = this.getEffectivePrefs(channelId);
+        const workingDirectory = this.resolveWorkingDirectory(channelId);
+        const defaultConfigDir = process.env.HOME ? `${process.env.HOME}/.copilot` : undefined;
+        const reasoningEffort = prefs.reasoningEffort;
+        const skillDirectories = discoverSkillDirectories(workingDirectory);
+        const customTools = this.buildCustomTools(channelId);
+        const session = await withWorkspaceEnv(workingDirectory, () => this.bridge.resumeSession(sessionId, {
+            onPermissionRequest: (request, invocation) => this.handlePermissionRequest(channelId, request, invocation),
+            onUserInputRequest: (request, invocation) => this.handleUserInputRequest(channelId, request, invocation),
+            configDir: defaultConfigDir,
+            workingDirectory,
+            reasoningEffort: reasoningEffort ?? undefined,
+            mcpServers: this.resolveMcpServers(workingDirectory),
+            skillDirectories: skillDirectories.length > 0 ? skillDirectories : undefined,
+            tools: customTools.length > 0 ? customTools : undefined,
+        }));
+        this.channelSessions.set(channelId, sessionId);
+        this.sessionChannels.set(sessionId, channelId);
+        this.attachSessionEvents(session, channelId);
+    }
+    /**
+     * Execute an ephemeral inter-agent call: create a fresh session for the target bot,
+     * send the message, collect the response, and tear down.
+     */
+    async executeEphemeralCall(opts) {
+        const iaConfig = getInterAgentConfig();
+        const timeout = Math.min(opts.timeout ?? iaConfig.defaultTimeout ?? 60, iaConfig.maxTimeout ?? 300) * 1000; // convert to ms
+        const startTime = Date.now();
+        const nextContext = extendContext(opts.context, opts.targetBot);
+        // Resolve target bot's workspace
+        const targetWorkspace = getWorkspacePath(opts.targetBot);
+        const targetBotConfig = this.getTargetBotConfig(opts.targetBot);
+        // Resolve agent definition
+        const agentDef = resolveAgentDefinition(targetWorkspace, opts.agent, targetBotConfig?.agent);
+        // Build workspace awareness
+        const workspaceMap = getBotWorkspaceMap(opts.targetBot);
+        const workspacePrompt = buildWorkspacePrompt(workspaceMap);
+        const callerPrompt = buildCallerPrompt(opts.context);
+        // Build system message with inter-agent context
+        const systemParts = [callerPrompt, workspacePrompt];
+        if (agentDef) {
+            systemParts.push(`\n--- Agent Definition: ${agentDef.name} ---\n${agentDef.content}`);
+        }
+        // If the target has an ask_agent tool available, inject the chain context
+        if (nextContext.depth < (iaConfig.maxDepth ?? 3)) {
+            systemParts.push(`\nYou have the ask_agent tool available for calling other agents. Current call chain: ${nextContext.visited.join(' → ')}. Remaining depth: ${(iaConfig.maxDepth ?? 3) - nextContext.depth}.`);
+        }
+        const defaultConfigDir = process.env.HOME ? `${process.env.HOME}/.copilot` : undefined;
+        const skillDirectories = discoverSkillDirectories(targetWorkspace);
+        // Build ephemeral permission handler
+        const ephemeralPermissionHandler = this.buildEphemeralPermissionHandler(opts);
+        // Build custom tools for ephemeral session (ask_agent with propagated context)
+        // Pass target bot name so chained calls use B's identity (not A's channel)
+        const ephemeralTools = this.buildEphemeralTools(opts.targetBot, nextContext);
+        let session;
+        try {
+            session = await withWorkspaceEnv(targetWorkspace, () => this.bridge.createSession({
+                workingDirectory: targetWorkspace,
+                configDir: defaultConfigDir,
+                mcpServers: this.resolveMcpServers(targetWorkspace),
+                skillDirectories: skillDirectories.length > 0 ? skillDirectories : undefined,
+                onPermissionRequest: ephemeralPermissionHandler,
+                systemMessage: { content: systemParts.filter(Boolean).join('\n\n') },
+                tools: ephemeralTools.length > 0 ? ephemeralTools : undefined,
+            }));
+            // Send message and wait for idle
+            const response = await this.sendAndWaitForIdle(session, opts.message, timeout);
+            const durationMs = Date.now() - startTime;
+            recordAgentCall({
+                callerBot: opts.callerBot,
+                targetBot: opts.targetBot,
+                targetAgent: opts.agent,
+                messageSummary: opts.message.slice(0, 500),
+                responseSummary: response.slice(0, 500),
+                durationMs,
+                success: true,
+                chainId: opts.context.chainId,
+                depth: nextContext.depth,
+            });
+            log.info(`Ephemeral call ${opts.callerBot}→${opts.targetBot}: ${durationMs}ms, ${response.length} chars`);
+            return { success: true, response };
+        }
+        catch (err) {
+            const durationMs = Date.now() - startTime;
+            const errorMsg = err?.message ?? 'unknown error';
+            recordAgentCall({
+                callerBot: opts.callerBot,
+                targetBot: opts.targetBot,
+                targetAgent: opts.agent,
+                messageSummary: opts.message.slice(0, 500),
+                durationMs,
+                success: false,
+                error: errorMsg,
+                chainId: opts.context.chainId,
+                depth: nextContext.depth,
+            });
+            log.error(`Ephemeral call ${opts.callerBot}→${opts.targetBot} failed: ${errorMsg}`);
+            return { success: false, error: 'ephemeral_session_error', detail: errorMsg };
+        }
+        finally {
+            if (session) {
+                try {
+                    await this.bridge.destroySession(session.sessionId);
+                }
+                catch { /* best-effort */ }
+            }
+        }
+    }
+    /** Send a message to a session and wait for session.idle, collecting streamed response text. */
+    sendAndWaitForIdle(session, message, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            let settled = false;
+            const timer = setTimeout(() => {
+                if (!settled) {
+                    settled = true;
+                    unsub();
+                    reject(new Error(`Ephemeral session timed out after ${timeoutMs / 1000}s`));
+                }
+            }, timeoutMs);
+            const unsub = session.on((event) => {
+                if (settled)
+                    return;
+                if (event.type === 'assistant.message_delta') {
+                    const text = event.data?.deltaContent ?? event.data?.text ?? event.deltaContent ?? '';
+                    if (text)
+                        chunks.push(text);
+                }
+                if (event.type === 'assistant.message' && event.data?.content && chunks.length === 0) {
+                    // Full message event — only use as fallback when no deltas were received
+                    chunks.push(event.data.content);
+                }
+                if (event.type === 'session.idle') {
+                    settled = true;
+                    clearTimeout(timer);
+                    unsub();
+                    resolve(chunks.join(''));
+                }
+                if (event.type === 'session.error') {
+                    settled = true;
+                    clearTimeout(timer);
+                    unsub();
+                    reject(new Error(event.data?.message ?? 'Session error'));
+                }
+            });
+            session.send({ prompt: message }).catch((err) => {
+                if (!settled) {
+                    settled = true;
+                    clearTimeout(timer);
+                    unsub();
+                    reject(err);
+                }
+            });
+        });
+    }
+    /** Build a permission handler for ephemeral sessions with merged caller+target rules. */
+    buildEphemeralPermissionHandler(opts) {
+        return async (request, _invocation) => {
+            const reqKind = request.kind;
+            const reqCommand = typeof request.fullCommandText === 'string'
+                ? request.fullCommandText
+                : typeof request.command === 'string' ? request.command : undefined;
+            // 1. Hardcoded safety denies — always enforced
+            if (isHardDeny(reqKind, reqCommand)) {
+                return { kind: 'denied-by-rules' };
+            }
+            // 2. Caller's explicit denies — checked before auto-approve
+            if (opts.denyTools && opts.denyTools.length > 0) {
+                const toolName = request.toolName ?? request.tool_name ?? request.name ?? reqKind;
+                if (opts.denyTools.includes(toolName)) {
+                    return { kind: 'denied-by-rules' };
+                }
+            }
+            // 3. Auto-approve bridge custom tools
+            if (reqKind === 'custom-tool') {
+                const reqToolName = request.toolName;
+                if (BRIDGE_CUSTOM_TOOLS.includes(reqToolName)) {
+                    return { kind: 'approved' };
+                }
+            }
+            // 4. Caller's explicit grants (only if caller has them)
+            if (opts.grantTools && opts.grantTools.length > 0) {
+                const toolName = request.toolName ?? request.tool_name ?? request.name ?? reqKind;
+                if (opts.grantTools.includes(toolName)) {
+                    // Verify caller has this permission
+                    const callerResult = checkPermission(opts.callerChannelId, toolName, '*');
+                    if (callerResult === 'allow') {
+                        return { kind: 'approved' };
+                    }
+                }
+            }
+            // 5. Target bot's own stored permission rules
+            // Use a synthetic scope for the target bot
+            const targetScope = `bot:${opts.targetBot}`;
+            const toolName = request.toolName ?? request.tool_name ?? request.name ?? reqKind;
+            const storedResult = checkPermission(targetScope, toolName, '*');
+            if (storedResult === 'allow')
+                return { kind: 'approved' };
+            if (storedResult === 'deny')
+                return { kind: 'denied-by-rules' };
+            // 6. Caller channel's stored rules (merged — supplement target)
+            const callerResult = checkPermission(opts.callerChannelId, toolName, '*');
+            if (callerResult === 'allow')
+                return { kind: 'approved' };
+            // 7. Autopilot: approve remaining if enabled
+            if (opts.autopilot) {
+                return { kind: 'approved' };
+            }
+            // 8. No rule matched — deny with detail (no human to ask in ephemeral sessions)
+            log.warn(`Ephemeral permission denied (no rule): ${toolName} for ${opts.targetBot}`);
+            return { kind: 'denied-no-approval-rule-and-could-not-request-from-user' };
+        };
+    }
+    /** Build custom tools for an ephemeral inter-agent session. */
+    buildEphemeralTools(currentBotName, context) {
+        const tools = [];
+        const iaConfig = getInterAgentConfig();
+        // Only register ask_agent if there's remaining depth
+        if (iaConfig.enabled && context.depth < (iaConfig.maxDepth ?? 3)) {
+            tools.push(this.buildAskAgentToolDef(currentBotName, context, true));
+        }
+        return tools;
+    }
+    /** Get target bot config across all platforms. */
+    getTargetBotConfig(botName) {
+        const config = getConfig();
+        for (const platform of Object.values(config.platforms)) {
+            if (platform.bots?.[botName]) {
+                return platform.bots[botName];
+            }
+        }
+        return null;
+    }
+    /** Build the ask_agent tool definition (shared by normal and ephemeral sessions).
+     *  When callerBotDirect is true, channelIdOrBot is the bot name directly (for ephemeral sessions). */
+    buildAskAgentToolDef(channelIdOrBot, parentContext, callerBotDirect = false) {
+        const callerBot = callerBotDirect ? channelIdOrBot : getChannelBotName(channelIdOrBot);
+        const channelId = callerBotDirect ? undefined : channelIdOrBot;
+        return {
+            name: 'ask_agent',
+            description: 'Ask another agent a question. Creates a fresh session for the target agent with its own workspace, tools, and knowledge. Use this when you need information or capabilities from a different bot identity (e.g., asking Alice about home automation, asking a specialist about their domain). IMPORTANT: The user cannot see the inter-agent exchange. After receiving the response, communicate the relevant information back to the user.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    target: {
+                        type: 'string',
+                        description: 'The bot name to ask (e.g., "alice", "copilot"). Must be configured in the inter-agent allowlist.',
+                    },
+                    message: {
+                        type: 'string',
+                        description: 'The question or request to send to the target agent.',
+                    },
+                    agent: {
+                        type: 'string',
+                        description: 'Optional: specific agent persona to use (matches *.agent.md file in the target\'s workspace/agents/ directory).',
+                    },
+                    timeout: {
+                        type: 'number',
+                        description: 'Optional: timeout in seconds (default from config, capped at maxTimeout).',
+                    },
+                    autopilot: {
+                        type: 'boolean',
+                        description: 'Optional: auto-approve tool permissions in the target session (default: false). Enable for trusted queries that may require tool use.',
+                    },
+                    denyTools: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Optional: tool names to deny in the target session (e.g., ["bash"] for read-only queries).',
+                    },
+                    grantTools: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Optional: tool names to pre-approve in the target session. Only effective if you (the caller) also have those tools approved.',
+                    },
+                },
+                required: ['target', 'message'],
+            },
+            handler: async (args) => {
+                try {
+                    // Build or extend context
+                    const context = parentContext
+                        ? parentContext
+                        : createContext(callerBot, channelId);
+                    // Pre-flight: check if the call is allowed
+                    const blocked = canCall(callerBot, args.target, context);
+                    if (blocked) {
+                        return { content: JSON.stringify({ success: false, error: 'not_allowed', detail: blocked }) };
+                    }
+                    const result = await this.executeEphemeralCall({
+                        callerBot,
+                        targetBot: args.target,
+                        message: args.message,
+                        context,
+                        agent: args.agent,
+                        timeout: args.timeout,
+                        autopilot: args.autopilot,
+                        denyTools: args.denyTools,
+                        grantTools: args.grantTools,
+                        callerChannelId: channelId ?? `bot:${callerBot}`,
+                    });
+                    return { content: JSON.stringify(result) };
+                }
+                catch (err) {
+                    return { content: JSON.stringify({ success: false, error: 'tool_error', detail: err?.message ?? 'unknown error' }) };
+                }
+            },
+        };
+    }
+    /** Build custom tool definitions to pass to SDK session creation. */
+    buildCustomTools(channelId) {
+        const tools = [];
+        if (this.sendFileHandler) {
+            const handler = this.sendFileHandler;
+            const config = getChannelConfig(channelId);
+            const botName = getChannelBotName(channelId);
+            const workDir = this.resolveWorkingDirectory(channelId);
+            const allowPaths = getWorkspaceAllowPaths(botName, config.platform);
+            tools.push({
+                name: 'send_file',
+                description: 'Send a file or image from the workspace to the user in their chat channel. The file will appear as an inline image (for image types) or a downloadable attachment.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'Path to the file to send (absolute or relative to workspace)' },
+                        message: { type: 'string', description: 'Optional message to accompany the file' },
+                    },
+                    required: ['path'],
+                },
+                handler: async (args) => {
+                    try {
+                        // Resolve relative paths against workspace
+                        const resolved = path.isAbsolute(args.path) ? path.resolve(args.path) : path.resolve(workDir, args.path);
+                        // Resolve symlinks to prevent traversal via symlink targets
+                        let realPath;
+                        try {
+                            realPath = fs.realpathSync(resolved);
+                        }
+                        catch {
+                            return { content: 'File not found.' };
+                        }
+                        // Validate the real file path is within workspace or allowed paths
+                        const allowed = [workDir, ...allowPaths];
+                        const isAllowed = allowed.some(dir => realPath.startsWith(path.resolve(dir) + path.sep) || realPath === path.resolve(dir));
+                        if (!isAllowed) {
+                            log.warn(`send_file blocked: "${realPath}" is outside workspace for channel ${channelId.slice(0, 8)}...`);
+                            return { content: 'File path is outside the allowed workspace. Only files within your workspace can be sent.' };
+                        }
+                        await handler(channelId, realPath, args.message);
+                        return { content: `File sent: ${path.basename(realPath)}` };
+                    }
+                    catch (err) {
+                        log.error(`send_file failed for channel ${channelId.slice(0, 8)}...:`, err);
+                        return { content: `Failed to send file: ${err?.message ?? 'unknown error'}` };
+                    }
+                },
+            });
+        }
+        // Show file contents in chat (renamed from show_file — CLI doesn't support overridesBuiltInTool yet)
+        if (this.getAdapterForChannel) {
+            const adapterResolver = this.getAdapterForChannel;
+            const showWorkDir = this.resolveWorkingDirectory(channelId);
+            const showBotName = getChannelBotName(channelId);
+            const showConfig = getChannelConfig(channelId);
+            const showAllowPaths = getWorkspaceAllowPaths(showBotName, showConfig.platform);
+            tools.push({
+                name: 'show_file_in_chat',
+                description: 'Show file contents to the user in their chat channel as a formatted code block. Prefer this over the built-in show_file which only works in terminal. Use when the user asks to see a file, code snippet, or diff. Supports optional line range. For diffs, set diff: true to show pending git changes.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'Full absolute path to the file to show.' },
+                        view_range: {
+                            type: 'array', items: { type: 'integer' },
+                            description: 'Optional [start, end] line range. [start, -1] shows from start to end of file.',
+                        },
+                        diff: { type: 'boolean', description: 'When true, show pending git diff instead of file contents.' },
+                    },
+                    required: ['path'],
+                },
+                handler: async (args) => {
+                    try {
+                        const resolved = path.isAbsolute(args.path) ? path.resolve(args.path) : path.resolve(showWorkDir, args.path);
+                        let realPath;
+                        try {
+                            realPath = fs.realpathSync(resolved);
+                        }
+                        catch {
+                            return { content: 'File not found.' };
+                        }
+                        const allowed = [showWorkDir, ...showAllowPaths];
+                        const isAllowed = allowed.some(dir => realPath.startsWith(path.resolve(dir) + path.sep) || realPath === path.resolve(dir));
+                        if (!isAllowed) {
+                            log.warn(`show_file blocked: "${realPath}" is outside workspace for channel ${channelId.slice(0, 8)}...`);
+                            return { content: 'File path is outside the allowed workspace.' };
+                        }
+                        const adapter = adapterResolver(channelId);
+                        if (!adapter)
+                            return { content: 'No adapter available for this channel.' };
+                        const ext = path.extname(realPath).slice(1) || 'txt';
+                        const fileName = path.basename(realPath);
+                        let content;
+                        if (args.diff) {
+                            const { execFileSync } = await import('node:child_process');
+                            const dir = path.dirname(realPath);
+                            try {
+                                content = execFileSync('git', ['diff', '--', realPath], { cwd: dir, encoding: 'utf-8', timeout: 5000 });
+                                if (!content.trim())
+                                    content = '(no pending changes)';
+                            }
+                            catch {
+                                content = '(not a git repository or git diff failed)';
+                            }
+                            await adapter.sendMessage(channelId, `**${fileName}** (diff)\n\`\`\`\`diff\n${content}\n\`\`\`\``);
+                        }
+                        else {
+                            const fullContent = fs.readFileSync(realPath, 'utf-8');
+                            let lines = fullContent.split('\n');
+                            if (args.view_range && args.view_range.length === 2) {
+                                const [start, end] = args.view_range;
+                                const startIdx = Math.max(0, start - 1);
+                                const endIdx = end === -1 ? lines.length : Math.min(end, lines.length);
+                                lines = lines.slice(startIdx, endIdx);
+                            }
+                            content = lines.join('\n');
+                            const MAX_CHARS = 8000;
+                            let truncated = false;
+                            if (content.length > MAX_CHARS) {
+                                content = content.slice(0, MAX_CHARS);
+                                truncated = true;
+                            }
+                            // Use 4-backtick fence to avoid breaking if content contains ```
+                            const rangeLabel = args.view_range ? ` (lines ${args.view_range[0]}–${args.view_range[1] === -1 ? 'end' : args.view_range[1]})` : '';
+                            let msg = `**${fileName}**${rangeLabel}\n\`\`\`\`${ext}\n${content}\n\`\`\`\``;
+                            if (truncated)
+                                msg += '\n*(truncated — file too large for chat)*';
+                            await adapter.sendMessage(channelId, msg);
+                        }
+                        return { content: `Showed ${fileName} to user in chat.` };
+                    }
+                    catch (err) {
+                        log.error(`show_file failed for channel ${channelId.slice(0, 8)}...:`, err);
+                        return { content: `Failed to show file: ${err?.message ?? 'unknown error'}` };
+                    }
+                },
+            });
+        }
+        // Admin-only onboarding tools
+        const config = getChannelConfig(channelId);
+        const botName = getChannelBotName(channelId);
+        const isAdmin = isBotAdmin(config.platform, botName);
+        if (isAdmin && this.getAdapterForChannel) {
+            const adapterResolver = this.getAdapterForChannel;
+            // Tool: get_platform_info — returns available teams, bots, and defaults
+            tools.push({
+                name: 'get_platform_info',
+                description: 'Get information about the bridge platform: available teams, bot names, and defaults. Use this when onboarding a new project to present options to the user.',
+                parameters: { type: 'object', properties: {} },
+                handler: async () => {
+                    try {
+                        const adapter = adapterResolver(channelId);
+                        if (!adapter?.getTeams)
+                            return { content: 'Platform does not support team listing.' };
+                        const teams = await adapter.getTeams();
+                        const appConfig = getConfig();
+                        const platformConfig = appConfig.platforms[config.platform];
+                        const botNames = platformConfig.bots ? Object.keys(platformConfig.bots) : ['default'];
+                        return {
+                            content: JSON.stringify({
+                                teams: teams.map(t => ({ id: t.id, name: t.name, displayName: t.displayName })),
+                                bots: botNames,
+                                defaults: {
+                                    model: appConfig.defaults.model,
+                                    triggerMode: appConfig.defaults.triggerMode,
+                                    threadedReplies: appConfig.defaults.threadedReplies,
+                                },
+                            }, null, 2),
+                        };
+                    }
+                    catch (err) {
+                        return { content: `Error: ${err?.message ?? 'unknown'}` };
+                    }
+                },
+            });
+            // Tool: create_project — full onboarding orchestration
+            tools.push({
+                name: 'create_project',
+                description: 'Create a new project: set up a Mattermost channel, assign a bot, initialize the workspace, and optionally clone a git repo. The channel is immediately active after creation. Use get_platform_info first to get team IDs and available bots.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        project_name: { type: 'string', description: 'Human-readable project name (e.g., "Widget API"). Will be slugified for the channel name.' },
+                        bot_name: { type: 'string', description: 'Bot to assign (e.g., "copilot", "bob"). Must be a configured bot name.' },
+                        team_id: { type: 'string', description: 'Mattermost team ID (from get_platform_info).' },
+                        private: { type: 'boolean', description: 'Create a private channel. Ask the user: private or public?' },
+                        workspace_path: { type: 'string', description: 'Workspace directory path. Ask the user — default is ~/.copilot-bridge/workspaces/<project-slug>/.' },
+                        repo_url: { type: 'string', description: 'Git repository URL to clone into the workspace. Optional — skip for new projects.' },
+                        user_id: { type: 'string', description: 'Mattermost user ID of the requesting user, to add them to the channel.' },
+                        trigger_mode: { type: 'string', enum: ['all', 'mention'], description: 'How the bot responds. Ask the user: "all" (every message) or "mention" (only when @mentioned).' },
+                        threaded_replies: { type: 'boolean', description: 'Whether the bot replies in threads. Ask the user: yes or no.' },
+                    },
+                    required: ['project_name', 'bot_name', 'team_id', 'private', 'workspace_path', 'trigger_mode', 'threaded_replies'],
+                },
+                handler: async (args) => {
+                    try {
+                        const adapter = adapterResolver(channelId);
+                        if (!adapter)
+                            return { content: 'Error: No adapter available for this channel.' };
+                        const result = await onboardProject(adapter, {
+                            projectName: args.project_name,
+                            botName: args.bot_name,
+                            platform: config.platform,
+                            teamId: args.team_id,
+                            private: args.private,
+                            workspacePath: args.workspace_path,
+                            repoUrl: args.repo_url,
+                            userId: args.user_id ?? this.lastMessageUserIds.get(channelId),
+                            triggerMode: args.trigger_mode,
+                            threadedReplies: args.threaded_replies,
+                        });
+                        return {
+                            content: [
+                                `✅ Project "${args.project_name}" created:`,
+                                ...result.steps.map(s => `  - ${s}`),
+                                '',
+                                `Channel: #${result.channelName}`,
+                                `Workspace: ${result.workspacePath}`,
+                                result.cloned ? `Repo cloned: ${args.repo_url}` : '',
+                            ].filter(Boolean).join('\n'),
+                        };
+                    }
+                    catch (err) {
+                        log.error(`create_project failed:`, err);
+                        return { content: `Failed to create project: ${err?.message ?? 'unknown error'}` };
+                    }
+                },
+            });
+            // Tool: grant_path_access — add an extra allowed path for an agent
+            tools.push({
+                name: 'grant_path_access',
+                description: 'Grant an agent read/write access to an additional folder beyond its workspace. Updates the workspace_overrides table in SQLite.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        bot_name: { type: 'string', description: 'The bot/agent name (e.g., "inbox", "bob").' },
+                        path: { type: 'string', description: 'Absolute path to the folder to grant access to.' },
+                    },
+                    required: ['bot_name', 'path'],
+                },
+                handler: async (args) => {
+                    try {
+                        const existing = getWorkspaceOverride(args.bot_name);
+                        const workDir = existing?.workingDirectory ?? getWorkspacePath(args.bot_name);
+                        const currentPaths = existing?.allowPaths ?? [];
+                        const resolvedPath = path.resolve(args.path);
+                        // Block sensitive paths (bidirectional: parent-of or child-of blocked)
+                        const home = os.homedir();
+                        const blocked = [home, path.join(home, '.ssh'), path.join(home, '.aws'), path.join(home, '.gnupg'),
+                            path.join(home, '.copilot-bridge'), '/etc', '/var', '/usr', '/System', '/private'];
+                        if (resolvedPath === '/') {
+                            return { content: '❌ Refused: cannot grant access to filesystem root.' };
+                        }
+                        for (const b of blocked) {
+                            if (resolvedPath === b || b.startsWith(resolvedPath + path.sep) || resolvedPath.startsWith(b + path.sep)) {
+                                return { content: `❌ Refused: "${resolvedPath}" overlaps with sensitive directory "${b}". Grant a more specific, non-sensitive subdirectory instead.` };
+                            }
+                        }
+                        if (currentPaths.includes(resolvedPath)) {
+                            return { content: `"${args.bot_name}" already has access to ${resolvedPath}.` };
+                        }
+                        const newPaths = [...currentPaths, resolvedPath];
+                        setWorkspaceOverride(args.bot_name, workDir, newPaths);
+                        return {
+                            content: `✅ Granted "${args.bot_name}" access to ${resolvedPath}.\nCurrent allowed paths: ${JSON.stringify(newPaths)}\n\nTo apply: delete the agent's AGENTS.md and run /new in its channel (or restart the bridge).`,
+                        };
+                    }
+                    catch (err) {
+                        return { content: `Failed: ${err?.message ?? 'unknown error'}` };
+                    }
+                },
+            });
+            // Tool: revoke_path_access — remove an allowed path from an agent
+            tools.push({
+                name: 'revoke_path_access',
+                description: 'Remove an extra allowed folder from an agent. Does not affect its workspace directory.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        bot_name: { type: 'string', description: 'The bot/agent name.' },
+                        path: { type: 'string', description: 'Absolute path to revoke access from.' },
+                    },
+                    required: ['bot_name', 'path'],
+                },
+                handler: async (args) => {
+                    try {
+                        const existing = getWorkspaceOverride(args.bot_name);
+                        if (!existing)
+                            return { content: `No workspace override found for "${args.bot_name}".` };
+                        const resolvedPath = path.resolve(args.path);
+                        const newPaths = existing.allowPaths.filter(p => path.resolve(p) !== resolvedPath);
+                        setWorkspaceOverride(args.bot_name, existing.workingDirectory, newPaths);
+                        return {
+                            content: `✅ Revoked "${args.bot_name}" access to ${resolvedPath}.\nRemaining allowed paths: ${JSON.stringify(newPaths)}\n\nTo apply: delete the agent's AGENTS.md and run /new in its channel (or restart the bridge).`,
+                        };
+                    }
+                    catch (err) {
+                        return { content: `Failed: ${err?.message ?? 'unknown error'}` };
+                    }
+                },
+            });
+            // Tool: list_agent_access — show workspace info for all agents
+            tools.push({
+                name: 'list_agent_access',
+                description: 'List all agents and their workspace paths and extra allowed folders.',
+                parameters: { type: 'object', properties: {} },
+                handler: async () => {
+                    try {
+                        const overrides = listWorkspaceOverrides();
+                        const overrideMap = new Map(overrides.map(o => [o.botName, o]));
+                        // Enumerate all configured bots across platforms
+                        const config = getConfig();
+                        const botNames = new Set();
+                        for (const platform of Object.values(config.platforms)) {
+                            if (platform.bots) {
+                                for (const name of Object.keys(platform.bots))
+                                    botNames.add(name);
+                            }
+                        }
+                        // Include any bots that have overrides but aren't in config
+                        for (const o of overrides)
+                            botNames.add(o.botName);
+                        if (botNames.size === 0)
+                            return { content: 'No agents configured.' };
+                        const lines = [...botNames].sort().map(name => {
+                            const override = overrideMap.get(name);
+                            const workspace = override?.workingDirectory ?? getWorkspacePath(name);
+                            const extra = override?.allowPaths ?? [];
+                            return `**${name}**\n  Workspace: ${workspace}\n  Extra paths: ${extra.length > 0 ? extra.join(', ') : '(none)'}`;
+                        });
+                        return { content: lines.join('\n\n') };
+                    }
+                    catch (err) {
+                        return { content: `Failed: ${err?.message ?? 'unknown error'}` };
+                    }
+                },
+            });
+        }
+        // Inter-agent tool: ask_agent (only when enabled in config)
+        const iaConfig = getInterAgentConfig();
+        if (iaConfig.enabled) {
+            tools.push(this.buildAskAgentToolDef(channelId));
+        }
+        // Scheduler tool: create/list/cancel/pause/resume scheduled tasks
+        tools.push(this.buildScheduleToolDef(channelId));
+        if (tools.length > 0) {
+            log.info(`Built ${tools.length} custom tool(s) for channel ${channelId.slice(0, 8)}...`);
+        }
+        return tools;
+    }
+    /** Build the schedule tool definition for creating/managing scheduled tasks. */
+    buildScheduleToolDef(channelId) {
+        const botName = getChannelBotName(channelId);
+        return {
+            name: 'schedule',
+            description: 'Create, list, cancel, pause, or resume scheduled tasks. Tasks fire at the specified time and send a prompt to the LLM for processing. Supports cron expressions for recurring tasks and ISO datetimes for one-off tasks.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    action: {
+                        type: 'string',
+                        enum: ['create', 'list', 'cancel', 'pause', 'resume'],
+                        description: 'The action to perform.',
+                    },
+                    prompt: {
+                        type: 'string',
+                        description: 'The prompt to send when the job fires. Required for "create".',
+                    },
+                    cron: {
+                        type: 'string',
+                        description: 'Cron expression for recurring tasks (e.g., "0 9 * * 1-5" for weekdays at 9am). Use standard 5-field cron syntax.',
+                    },
+                    run_at: {
+                        type: 'string',
+                        description: 'ISO 8601 datetime for one-off tasks. IMPORTANT: current_datetime is UTC — use a Z suffix (e.g., "2026-03-09T22:31:00Z") or properly convert to local time before adding an offset. Do NOT take the UTC hour and attach a non-UTC offset. Mutually exclusive with cron.',
+                    },
+                    timezone: {
+                        type: 'string',
+                        description: 'IANA timezone for display and cron scheduling (e.g., "America/Los_Angeles"). Defaults to UTC.',
+                    },
+                    description: {
+                        type: 'string',
+                        description: 'Human-readable label for the task.',
+                    },
+                    id: {
+                        type: 'string',
+                        description: 'Task ID. Required for cancel/pause/resume.',
+                    },
+                },
+                required: ['action'],
+            },
+            handler: async (args) => {
+                try {
+                    switch (args.action) {
+                        case 'create': {
+                            if (!args.prompt)
+                                return { content: 'Error: prompt is required for create.' };
+                            if (!args.cron && !args.run_at)
+                                return { content: 'Error: either cron or run_at is required.' };
+                            const task = addJob({
+                                channelId,
+                                botName,
+                                prompt: args.prompt,
+                                cronExpr: args.cron,
+                                runAt: args.run_at,
+                                timezone: args.timezone,
+                                description: args.description,
+                                createdBy: this.lastMessageUserIds.get(channelId),
+                            });
+                            const type = task.cronExpr ? `recurring (${task.cronExpr})` : `one-off (${task.runAt})`;
+                            const tz = task.timezone ?? 'UTC';
+                            const nextRunLocal = task.nextRun ? formatInTimezone(task.nextRun, tz) : undefined;
+                            return { content: JSON.stringify({ success: true, id: task.id, type, nextRun: nextRunLocal, timezone: tz, description: task.description }) };
+                        }
+                        case 'list': {
+                            const tasks = listJobs(channelId);
+                            if (tasks.length === 0)
+                                return { content: 'No scheduled tasks for this channel.' };
+                            const summary = tasks.map(t => {
+                                const tz = t.timezone ?? 'UTC';
+                                return {
+                                    id: t.id,
+                                    description: t.description ?? t.prompt.slice(0, 60),
+                                    type: t.cronExpr ? 'recurring' : 'one-off',
+                                    schedule: t.cronExpr ?? t.runAt,
+                                    timezone: tz,
+                                    enabled: t.enabled,
+                                    lastRun: t.lastRun ? formatInTimezone(t.lastRun, tz) : undefined,
+                                    nextRun: t.nextRun ? formatInTimezone(t.nextRun, tz) : undefined,
+                                };
+                            });
+                            return { content: JSON.stringify(summary) };
+                        }
+                        case 'cancel': {
+                            if (!args.id)
+                                return { content: 'Error: id is required for cancel.' };
+                            const removed = removeJob(args.id, channelId);
+                            return { content: removed ? `Task ${args.id} cancelled and removed.` : `Task ${args.id} not found.` };
+                        }
+                        case 'pause': {
+                            if (!args.id)
+                                return { content: 'Error: id is required for pause.' };
+                            const paused = pauseJob(args.id, channelId);
+                            return { content: paused ? `Task ${args.id} paused.` : `Task ${args.id} not found.` };
+                        }
+                        case 'resume': {
+                            if (!args.id)
+                                return { content: 'Error: id is required for resume.' };
+                            const resumed = resumeJob(args.id, channelId);
+                            return { content: resumed ? `Task ${args.id} resumed.` : `Task ${args.id} not found or failed to resume.` };
+                        }
+                        default:
+                            return { content: `Unknown action: ${args.action}. Use create, list, cancel, pause, or resume.` };
+                    }
+                }
+                catch (err) {
+                    return { content: `Schedule error: ${err?.message ?? 'unknown error'}` };
+                }
+            },
+        };
+    }
+    attachSessionEvents(session, channelId) {
+        const unsub = session.on((event) => {
+            if (event.type === 'session.usage_info' && event.data) {
+                this.contextUsage.set(channelId, {
+                    currentTokens: event.data.currentTokens,
+                    tokenLimit: event.data.tokenLimit,
+                });
+            }
+            this.eventHandler?.(session.sessionId, channelId, event);
+        });
+        this.sessionUnsubscribes.set(session.sessionId, unsub);
+    }
+    handlePermissionRequest(channelId, request, invocation) {
+        const prefs = this.getEffectivePrefs(channelId);
+        // Hardcoded safety denies — checked before autopilot, cannot be overridden
+        const reqKind = request.kind;
+        const reqCommand = typeof request.fullCommandText === 'string' ? request.fullCommandText
+            : typeof request.command === 'string' ? request.command : undefined;
+        if (isHardDeny(reqKind, reqCommand)) {
+            return Promise.resolve({ kind: 'denied-by-rules' });
+        }
+        // Auto-approve bridge custom tools (they enforce their own workspace boundaries)
+        if (reqKind === 'custom-tool') {
+            const reqToolName = request.toolName;
+            if (BRIDGE_CUSTOM_TOOLS.includes(reqToolName)) {
+                return Promise.resolve({ kind: 'approved' });
+            }
+        }
+        // Autopilot mode: allow everything (after safety checks)
+        if (prefs.permissionMode === 'autopilot') {
+            return Promise.resolve({ kind: 'approved' });
+        }
+        // Check config-level permission rules first (CLI-compatible syntax)
+        const config = getChannelConfig(channelId);
+        const botName = getChannelBotName(channelId);
+        const resolvedDir = this.resolveWorkingDirectory(channelId);
+        const workspaceAllowPaths = getWorkspaceAllowPaths(botName, config.platform);
+        const configResult = evaluateConfigPermissions(request, resolvedDir, workspaceAllowPaths, isBotAdmin(config.platform, botName));
+        if (configResult === 'allow') {
+            return Promise.resolve({ kind: 'approved' });
+        }
+        if (configResult === 'deny') {
+            return Promise.resolve({ kind: 'denied-by-rules' });
+        }
+        // Check stored permission rules (SQLite, from /remember)
+        log.debug(`Permission request:`, JSON.stringify(request).slice(0, 500));
+        const kind = request.kind ?? 'unknown';
+        const serverName = request.serverName;
+        // Build a descriptive tool name from kind + available fields
+        const toolName = request.toolName ?? request.tool_name ?? request.name ?? kind;
+        const toolInput = request.input ?? request.arguments ?? request.parameters ?? request;
+        const commands = extractCommandPatterns(toolInput);
+        // For MCP tools, check server-level rules first (covers all tools on that server)
+        if (kind === 'mcp' && serverName) {
+            const serverResult = checkPermission(channelId, `mcp:${serverName}`, '*');
+            if (serverResult === 'allow') {
+                log.debug(`MCP "${serverName}" auto-approved by stored rule`);
+                return Promise.resolve({ kind: 'approved' });
+            }
+            if (serverResult === 'deny') {
+                log.debug(`MCP "${serverName}" denied by stored rule`);
+                return Promise.resolve({ kind: 'denied-by-rules' });
+            }
+        }
+        if (commands.length > 0) {
+            const results = commands.map(cmd => checkPermission(channelId, toolName, cmd));
+            if (results.every(r => r === 'allow')) {
+                const hasWrapper = commands.some(cmd => SHELL_WRAPPERS.has(cmd));
+                if (!hasWrapper) {
+                    return Promise.resolve({ kind: 'approved' });
+                }
+            }
+            if (results.some(r => r === 'deny')) {
+                return Promise.resolve({ kind: 'denied-by-rules' });
+            }
+        }
+        else {
+            const result = checkPermission(channelId, toolName, '*');
+            if (result === 'allow')
+                return Promise.resolve({ kind: 'approved' });
+            if (result === 'deny')
+                return Promise.resolve({ kind: 'denied-by-rules' });
+        }
+        // No rule matched — need to ask the user via chat
+        return new Promise((resolve) => {
+            const entry = {
+                sessionId: invocation.sessionId,
+                channelId,
+                toolName,
+                serverName,
+                toolInput: toolInput,
+                commands,
+                resolve,
+                createdAt: Date.now(),
+            };
+            let queue = this.pendingPermissions.get(channelId);
+            if (!queue) {
+                queue = [];
+                this.pendingPermissions.set(channelId, queue);
+            }
+            queue.push(entry);
+            // Only emit the event if this is the first (active) item in the queue
+            if (queue.length === 1) {
+                this.eventHandler?.(invocation.sessionId, channelId, {
+                    type: 'bridge.permission_request',
+                    data: {
+                        toolName,
+                        serverName,
+                        input: toolInput,
+                        commands,
+                    },
+                });
+            }
+        });
+    }
+    handleUserInputRequest(channelId, request, invocation) {
+        return new Promise((resolve) => {
+            const entry = {
+                sessionId: invocation.sessionId,
+                channelId,
+                question: request.question,
+                choices: request.choices,
+                allowFreeform: request.allowFreeform,
+                resolve,
+                createdAt: Date.now(),
+            };
+            let queue = this.pendingUserInput.get(channelId);
+            if (!queue) {
+                queue = [];
+                this.pendingUserInput.set(channelId, queue);
+            }
+            queue.push(entry);
+            // Only emit the event if this is the first (active) item in the queue
+            if (queue.length === 1) {
+                this.eventHandler?.(invocation.sessionId, channelId, {
+                    type: 'bridge.user_input_request',
+                    data: {
+                        question: request.question,
+                        choices: request.choices,
+                        allowFreeform: request.allowFreeform,
+                    },
+                });
+            }
+        });
+    }
+    async shutdown() {
+        // Resolve all pending permissions (deny them on shutdown)
+        for (const [, queue] of this.pendingPermissions) {
+            for (const pending of queue) {
+                pending.resolve({ kind: 'denied-interactively-by-user' });
+            }
+        }
+        this.pendingPermissions.clear();
+        // Resolve all pending user inputs (empty answer on shutdown)
+        for (const [, queue] of this.pendingUserInput) {
+            for (const pending of queue) {
+                pending.resolve({ answer: '', wasFreeform: false });
+            }
+        }
+        this.pendingUserInput.clear();
+        // Unsubscribe all session event listeners
+        for (const [, unsub] of this.sessionUnsubscribes) {
+            unsub();
+        }
+        this.sessionUnsubscribes.clear();
+        // Release all sessions (don't destroy — they persist in CLI)
+        for (const [channelId, sessionId] of this.channelSessions) {
+            this.bridge.releaseSession(sessionId);
+        }
+        this.channelSessions.clear();
+        this.sessionChannels.clear();
+    }
+}
+//# sourceMappingURL=session-manager.js.map