daemora 1.0.0

package/src/agents/SubAgentManager.js

@@ -0,0 +1,369 @@
+import { runAgentLoop } from "../core/AgentLoop.js";
+import { buildSystemPrompt } from "../systemPrompt.js";
+import { toolFunctions } from "../tools/index.js";
+import { agentProfiles, defaultSubAgentTools } from "../config/agentProfiles.js";
+import eventBus from "../core/EventBus.js";
+import { v4 as uuidv4 } from "uuid";
+import tenantContext from "../tenants/TenantContext.js";
+import { resolveModelForProfile } from "../models/ModelRouter.js";
+
+/**
+ * Sub-Agent Manager — spawns, tracks, kills, and steers sub-agents.
+ *
+ * Each sub-agent entry stores:
+ *   - taskDescription, startedAt, parentTaskId
+ *   - abortController  → hard-kills the agent (aborts mid-API-call too)
+ *   - steerQueue       → shared array; push here to inject a steering message
+ *                        into the running agent's next loop iteration
+ *
+ * Kill propagation:
+ *   When the Supervisor kills a parent task, it emits "supervisor:kill".
+ *   We listen to that event and abort all child agents of the killed task.
+ *
+ * Context sharing:
+ *   Pass parentContext (string) to give the sub-agent summary info from
+ *   the parent before it starts.
+ */
+
+const MAX_CONCURRENT_SUB_AGENTS = 7;
+
+/** Map<agentId, { taskDescription, startedAt, parentTaskId, abortController, steerQueue }> */
+const activeSubAgents = new Map();
+
+// ── Kill propagation: when Supervisor kills a parent, kill all its children ──
+eventBus.on("supervisor:kill", ({ taskId }) => {
+  for (const [agentId, info] of activeSubAgents.entries()) {
+    const isChild = info.parentTaskId === taskId;
+    const isSelf  = `subagent-${agentId}` === taskId;
+    if (isChild || isSelf) {
+      console.log(`[SubAgentManager] Killing sub-agent ${agentId} (parent ${taskId} killed)`);
+      info.abortController.abort();
+      activeSubAgents.delete(agentId);
+      eventBus.emitEvent("agent:killed", { agentId, reason: `parent task killed (${taskId})` });
+    }
+  }
+});
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Spawn a sub-agent to handle a specific task.
+ *
+ * @param {string} taskDescription  What the sub-agent should do
+ * @param {object} options
+ * @param {string}   [options.model]               Model override
+ * @param {string}   [options.profile]             Role preset: "researcher"|"coder"|"writer"|"analyst"
+ * @param {string[]} [options.extraTools]          Additional tools on top of profile or default
+ * @param {string[]} [options.tools]               Explicit tool list (overrides profile)
+ * @param {object}   [options.toolOverride]        Exact tool functions (specialist agents, bypasses all)
+ * @param {object}   [options.systemPromptOverride] Replace system prompt entirely (specialist agents)
+ * @param {number}   [options.maxCost]             Cost budget
+ * @param {number}   [options.timeout]             Timeout in ms
+ * @param {number}   [options.depth]               Recursion depth (managed internally)
+ * @param {string}   [options.parentTaskId]        Parent task ID for kill propagation
+ * @param {string}   [options.parentContext]       Summary/context from parent agent
+ * @param {string}   [options.approvalMode]        Inherited approval mode
+ * @param {object}   [options.channelMeta]         Inherited channel meta for approvals
+ * @returns {Promise<string>} Sub-agent's final response
+ */
+export async function spawnSubAgent(taskDescription, options = {}) {
+  const {
+    model                = null,
+    profile              = null,        // role preset: researcher | coder | writer | analyst
+    extraTools           = null,        // additional tools on top of profile or default
+    tools: allowedTools  = null,        // explicit list — overrides profile
+    toolOverride         = null,        // exact tool functions — specialist agents only (e.g. MCP)
+    systemPromptOverride = null,        // replace system prompt — specialist agents only
+    maxCost              = 0.10,
+    timeout              = 120_000,
+    depth                = 0,
+    parentTaskId         = null,
+    parentContext        = null,
+    approvalMode         = "auto",
+    channelMeta          = null,
+  } = options;
+
+  const maxDepth = 3;
+  if (depth >= maxDepth) {
+    return `Cannot spawn sub-agent: maximum depth (${maxDepth}) reached. Complete this task directly.`;
+  }
+
+  if (activeSubAgents.size >= MAX_CONCURRENT_SUB_AGENTS) {
+    return `Cannot spawn sub-agent: maximum concurrent agents (${MAX_CONCURRENT_SUB_AGENTS}) reached. Wait for others to finish.`;
+  }
+
+  const agentId = uuidv4().slice(0, 8);
+  const taskId  = `subagent-${agentId}`;
+
+  console.log(`[SubAgent:${agentId}] Spawning (depth=${depth}, parent=${parentTaskId?.slice(0, 8) ?? "root"}): "${taskDescription.slice(0, 80)}"`);
+
+  // ── Model resolution — priority: explicit > profile routing > parent > global default ───────
+  const store = tenantContext.getStore();
+  const resolvedModel = model
+    || resolveModelForProfile(profile, store?.resolvedConfig || {}, null)
+    || store?.resolvedModel
+    || config.defaultModel;
+
+  const apiKeys = store?.apiKeys || {};
+
+  // ── Tool set ──────────────────────────────────────────────────────────────
+  // Resolution order (highest priority first):
+  //   1. toolOverride  — exact functions, specialist agents only (e.g. MCP agents)
+  //   2. allowedTools  — explicit name list from caller
+  //   3. profile       — role preset ("researcher", "coder", etc.) + optional extraTools
+  //   4. default       — defaultSubAgentTools (27 tools, excludes blast-radius tools)
+  let agentTools;
+  if (toolOverride) {
+    // Specialist agents (MCP, etc.) — bypass all filtering entirely
+    agentTools = { ...toolOverride };
+  } else {
+    let toolNames;
+
+    if (allowedTools) {
+      // Caller provided explicit list — use as-is
+      toolNames = [...allowedTools];
+    } else if (profile) {
+      // Named role preset
+      const preset = agentProfiles[profile];
+      if (!preset) {
+        console.warn(`[SubAgent:${agentId}] Unknown profile "${profile}", using default`);
+        toolNames = [...defaultSubAgentTools];
+      } else {
+        toolNames = [...preset];
+      }
+    } else {
+      // No profile specified — use sensible default (not all 33 tools)
+      toolNames = [...defaultSubAgentTools];
+    }
+
+    // Apply extraTools on top of whatever was resolved above
+    if (extraTools) {
+      for (const t of extraTools) {
+        if (!toolNames.includes(t)) toolNames.push(t);
+      }
+    }
+
+    agentTools = {};
+    for (const name of toolNames) {
+      if (toolFunctions[name]) agentTools[name] = toolFunctions[name];
+    }
+
+    // Inject depth-aware spawnAgent and parallelAgents at next depth level.
+    // These are NOT in any profile — they're always injected dynamically so
+    // depth propagation is always correct regardless of profile used.
+    if (depth + 1 < maxDepth) {
+      agentTools.spawnAgent = (desc, opts) => {
+        const parsedOpts = typeof opts === "string" ? JSON.parse(opts) : (opts || {});
+        return spawnSubAgent(desc, {
+          ...parsedOpts,
+          depth: depth + 1,
+          parentTaskId: taskId,
+          channelMeta,
+          approvalMode,
+          model: parsedOpts.model || resolvedModel,  // inherit parent model if not explicitly set
+        });
+      };
+
+      // Wrap parallelAgents to correctly propagate depth.
+      // Without this, parallel agents spawned by sub-agents would get depth=0
+      // (the default), allowing infinite nesting and defeating the depth limit.
+      agentTools.parallelAgents = (tasksJson, sharedOptionsJson) => {
+        const tasks = typeof tasksJson === "string" ? JSON.parse(tasksJson) : (tasksJson || []);
+        const sharedOpts = typeof sharedOptionsJson === "string"
+          ? JSON.parse(sharedOptionsJson)
+          : (sharedOptionsJson || {});
+        const tasksWithDepth = tasks.map((t) => ({
+          ...t,
+          options: {
+            ...(t.options || {}),
+            depth:       depth + 1,
+            parentTaskId: t.options?.parentTaskId || taskId,
+            channelMeta:  t.options?.channelMeta  || channelMeta,
+            approvalMode: t.options?.approvalMode  || approvalMode,
+          },
+        }));
+        return spawnParallelAgents(tasksWithDepth, sharedOpts);
+      };
+    }
+  }
+
+  // ── Coordination primitives ───────────────────────────────────────────────
+  const abortController = new AbortController();
+  const steerQueue      = [];   // Shared mutable array — push here to steer the agent
+
+  activeSubAgents.set(agentId, {
+    taskDescription,
+    startedAt: Date.now(),
+    parentTaskId,
+    abortController,
+    steerQueue,
+  });
+
+  eventBus.emitEvent("agent:spawned", {
+    agentId,
+    taskId,
+    parentTaskId,
+    depth,
+    taskDescription: taskDescription.slice(0, 100),
+  });
+
+  // ── Build initial messages (optionally include parent context) ────────────
+  const initialMessages = [];
+
+  if (parentContext) {
+    // Give the sub-agent a quick summary of what the parent knows
+    initialMessages.push({
+      role: "user",
+      content: `[Context from parent agent]:\n${parentContext}\n\n[Your task]:\n${taskDescription}`,
+    });
+  } else {
+    initialMessages.push({ role: "user", content: taskDescription });
+  }
+
+  // ── Run with timeout and abort signal ─────────────────────────────────────
+  const startedAt = activeSubAgents.get(agentId).startedAt;
+
+  try {
+    const result = await Promise.race([
+      runAgentLoop({
+        messages:     initialMessages,
+        systemPrompt: systemPromptOverride || await buildSystemPrompt(taskDescription),
+        tools:        agentTools,
+        modelId:      resolvedModel,
+        taskId,
+        approvalMode,
+        channelMeta,
+        signal:       abortController.signal,   // hard kill support
+        steerQueue,                              // steering support
+        apiKeys,                                 // per-tenant API key overlay
+      }),
+      new Promise((_, reject) =>
+        setTimeout(() => {
+          abortController.abort();
+          reject(new Error(`Sub-agent timed out after ${timeout / 1000}s`));
+        }, timeout)
+      ),
+    ]);
+
+    console.log(`[SubAgent:${agentId}] Completed in ${Date.now() - startedAt}ms`);
+    eventBus.emitEvent("agent:finished", { agentId, taskId, parentTaskId, cost: result.cost });
+    return result.text;
+
+  } catch (error) {
+    const killed = abortController.signal.aborted;
+    console.log(`[SubAgent:${agentId}] ${killed ? "Killed" : "Failed"}: ${error.message}`);
+    eventBus.emitEvent("agent:finished", { agentId, taskId, parentTaskId, error: error.message, killed });
+    return killed
+      ? `Sub-agent was stopped by the supervisor.`
+      : `Sub-agent error: ${error.message}`;
+  } finally {
+    activeSubAgents.delete(agentId);
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Spawn multiple sub-agents in parallel and collect results.
+ *
+ * @param {Array<{description, options}>} tasks
+ * @param {object} sharedOptions
+ * @param {string}  [sharedOptions.sharedContext]  Spec/contract passed to ALL agents as parentContext.
+ *                                                  Use this to share HTML structure with CSS/JS agents,
+ *                                                  API schema with frontend/backend agents, etc.
+ * @param {string}  [sharedOptions.parentTaskId]   For kill propagation
+ * @param {string}  [sharedOptions.approvalMode]
+ * @param {object}  [sharedOptions.channelMeta]
+ */
+export async function spawnParallelAgents(tasks, sharedOptions = {}) {
+  const { sharedContext = null, parentTaskId = null, approvalMode = "auto", channelMeta = null } = sharedOptions;
+
+  const results = await Promise.allSettled(
+    tasks.map((t) => {
+      const opts = t.options || {};
+      // Merge sharedContext: if task already has parentContext, prepend the shared spec
+      const mergedContext = sharedContext
+        ? (opts.parentContext
+            ? `[Shared spec for all agents]:\n${sharedContext}\n\n[Additional context]:\n${opts.parentContext}`
+            : sharedContext)
+        : opts.parentContext || null;
+
+      return spawnSubAgent(t.description, {
+        ...opts,
+        parentContext: mergedContext,
+        parentTaskId:  opts.parentTaskId || parentTaskId,
+        approvalMode:  opts.approvalMode  || approvalMode,
+        channelMeta:   opts.channelMeta   || channelMeta,
+      });
+    })
+  );
+
+  return results.map((r, i) => ({
+    task:   tasks[i].description.slice(0, 80),
+    status: r.status,
+    result: r.status === "fulfilled" ? r.value : (r.reason?.message || "Failed"),
+  }));
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Management API
+// ─────────────────────────────────────────────────────────────────────────────
+
+export function getActiveSubAgentCount() {
+  return activeSubAgents.size;
+}
+
+export function listActiveAgents() {
+  return [...activeSubAgents.entries()].map(([id, info]) => ({
+    id,
+    taskId:      `subagent-${id}`,
+    parentTaskId: info.parentTaskId,
+    task:         info.taskDescription.slice(0, 120),
+    startedAt:    new Date(info.startedAt).toISOString(),
+    elapsedMs:    Date.now() - info.startedAt,
+    steerable:    true,
+  }));
+}
+
+/**
+ * Hard-kill a sub-agent by agent ID — with cascade kill to all descendants.
+ * Aborts mid-API-call via AbortController — breaks out immediately.
+ * Recursively kills all child and grandchild agents before killing the target.
+ */
+export function killAgent(agentId) {
+  const agent = activeSubAgents.get(agentId);
+  if (!agent) {
+    return `No active agent found: ${agentId}. Use manageAgents("list") to see active agents.`;
+  }
+
+  // Cascade: kill all direct children first (recursive, so grandchildren are handled too)
+  const taskId = `subagent-${agentId}`;
+  const childIds = [...activeSubAgents.entries()]
+    .filter(([, info]) => info.parentTaskId === taskId)
+    .map(([id]) => id);
+
+  for (const childId of childIds) {
+    killAgent(childId); // recursive cascade
+  }
+
+  // Now kill this agent
+  agent.abortController.abort();
+  activeSubAgents.delete(agentId);
+  eventBus.emitEvent("agent:killed", { agentId, reason: "manual kill (cascade)" });
+  console.log(`[SubAgentManager] Hard-killed agent ${agentId}${childIds.length ? ` + ${childIds.length} child(ren)` : ""}`);
+  return `Agent ${agentId} killed${childIds.length ? ` (cascade: ${childIds.length} child agent(s) also stopped)` : ""}.`;
+}
+
+/**
+ * Inject a steering instruction into a running sub-agent.
+ * Picked up at the next loop iteration in AgentLoop (drains steerQueue).
+ */
+export function steerAgent(agentId, message) {
+  const agent = activeSubAgents.get(agentId);
+  if (!agent) {
+    return `No active agent found: ${agentId}.`;
+  }
+  agent.steerQueue.push(message);
+  console.log(`[SubAgentManager] Steered agent ${agentId}: "${message.slice(0, 60)}"`);
+  return `Steering message sent to agent ${agentId}. It will be injected on the next loop iteration.`;
+}

package/src/agents/Supervisor.js

@@ -0,0 +1,192 @@
+import eventBus from "../core/EventBus.js";
+import { config } from "../config/default.js";
+
+/**
+ * Supervisor Agent — monitors all agent activity for safety.
+ *
+ * Listens to EventBus events and detects:
+ * - Infinite loops (same tool called too many times)
+ * - Cost overruns (task exceeding budget)
+ * - Dangerous patterns (blocked commands, secret exposure)
+ * - Runaway agents (too many tool calls per minute)
+ *
+ * Actions: log warning, pause agent, kill agent, alert user.
+ */
+class Supervisor {
+  constructor() {
+    this.toolCallCounts = new Map(); // taskId → count
+    this.toolCallTimestamps = new Map(); // taskId → [timestamps]
+    this.warnings = [];
+    this.killedTasks = new Set(); // taskIds that have been killed
+    this.maxToolCallsPerMinute = 30;
+    this.maxToolCallsPerTask = 100;
+    this.running = false;
+  }
+
+  /** Check if a task has been killed by the supervisor. Called by AgentLoop each iteration. */
+  isKilled(taskId) {
+    return taskId ? this.killedTasks.has(taskId) : false;
+  }
+
+  /** Kill a task — AgentLoop will detect this and stop. */
+  killTask(taskId, reason) {
+    if (!taskId || this.killedTasks.has(taskId)) return;
+    this.killedTasks.add(taskId);
+    console.log(`[Supervisor] KILLING task ${taskId?.slice(0, 8)}: ${reason}`);
+    eventBus.emitEvent("supervisor:kill", { taskId, reason });
+    eventBus.emitEvent("audit:event", { event: "supervisor_kill", taskId, reason });
+  }
+
+  /** Remove task from killed set after it ends (cleanup). */
+  cleanupKill(taskId) {
+    this.killedTasks.delete(taskId);
+  }
+
+  /**
+   * Start monitoring.
+   */
+  start() {
+    if (this.running) return;
+    this.running = true;
+
+    // Monitor tool calls
+    eventBus.on("tool:before", (data) => this.onToolBefore(data));
+    eventBus.on("tool:after", (data) => this.onToolAfter(data));
+    eventBus.on("model:called", (data) => this.onModelCalled(data));
+    eventBus.on("agent:spawned", (data) => this.onAgentSpawned(data));
+
+    console.log(`[Supervisor] Started monitoring`);
+  }
+
+  /**
+   * Stop monitoring.
+   */
+  stop() {
+    this.running = false;
+    eventBus.removeAllListeners("tool:before");
+    eventBus.removeAllListeners("tool:after");
+    eventBus.removeAllListeners("model:called");
+    eventBus.removeAllListeners("agent:spawned");
+    console.log(`[Supervisor] Stopped`);
+  }
+
+  /**
+   * Check before a tool is executed.
+   */
+  onToolBefore(data) {
+    const { taskId, tool_name, params } = data;
+
+    // Track call count
+    const count = (this.toolCallCounts.get(taskId) || 0) + 1;
+    this.toolCallCounts.set(taskId, count);
+
+    // Track call rate
+    const now = Date.now();
+    const timestamps = this.toolCallTimestamps.get(taskId) || [];
+    timestamps.push(now);
+    // Keep only last minute
+    const oneMinuteAgo = now - 60000;
+    const recentTimestamps = timestamps.filter((t) => t > oneMinuteAgo);
+    this.toolCallTimestamps.set(taskId, recentTimestamps);
+
+    // Check: too many calls per minute — warn first, kill at 2x
+    if (recentTimestamps.length > this.maxToolCallsPerMinute * 2) {
+      this.killTask(taskId, `Runaway agent: ${recentTimestamps.length} tool calls in last minute (hard limit: ${this.maxToolCallsPerMinute * 2})`);
+    } else if (recentTimestamps.length > this.maxToolCallsPerMinute) {
+      this.warn(taskId, `Rate limit: ${recentTimestamps.length} tool calls in last minute (max: ${this.maxToolCallsPerMinute})`);
+    }
+
+    // Check: too many total calls — warn first, kill at 1.5x
+    if (count > Math.floor(this.maxToolCallsPerTask * 1.5)) {
+      this.killTask(taskId, `Runaway agent: ${count} total tool calls (hard limit: ${Math.floor(this.maxToolCallsPerTask * 1.5)})`);
+    } else if (count > this.maxToolCallsPerTask) {
+      this.warn(taskId, `Total tool calls (${count}) exceeded max (${this.maxToolCallsPerTask})`);
+    }
+
+    // Check: dangerous tool patterns
+    if (tool_name === "executeCommand" && params) {
+      const cmd = Array.isArray(params) ? params[0] : params;
+      if (typeof cmd === "string") {
+        if (/rm\s+-rf\s+\//.test(cmd)) {
+          this.alert(taskId, `BLOCKED: Destructive command detected: ${cmd.slice(0, 50)}`);
+        }
+        if (/sudo/.test(cmd)) {
+          this.warn(taskId, `Sudo command detected: ${cmd.slice(0, 50)}`);
+        }
+      }
+    }
+  }
+
+  /**
+   * Check after a tool is executed.
+   */
+  onToolAfter(data) {
+    // Could add output scanning for secrets here
+  }
+
+  /**
+   * Monitor model cost.
+   */
+  onModelCalled(data) {
+    // Cost tracking happens in CostTracker via EventBus
+  }
+
+  /**
+   * Monitor sub-agent spawning.
+   */
+  onAgentSpawned(data) {
+    const { agentId, depth, parentTaskId } = data;
+    if (depth > 1) {
+      this.warn(parentTaskId, `Deep sub-agent spawning: depth=${depth}, agentId=${agentId}`);
+    }
+  }
+
+  /**
+   * Issue a warning.
+   */
+  warn(taskId, message) {
+    const warning = {
+      level: "warning",
+      taskId,
+      message,
+      timestamp: new Date().toISOString(),
+    };
+    this.warnings.push(warning);
+    console.log(`[Supervisor] WARNING (task ${taskId?.slice(0, 8)}): ${message}`);
+    eventBus.emitEvent("supervisor:warning", warning);
+  }
+
+  /**
+   * Issue a critical alert.
+   */
+  alert(taskId, message) {
+    const alert = {
+      level: "critical",
+      taskId,
+      message,
+      timestamp: new Date().toISOString(),
+    };
+    this.warnings.push(alert);
+    console.log(`[Supervisor] ALERT (task ${taskId?.slice(0, 8)}): ${message}`);
+    eventBus.emitEvent("supervisor:alert", alert);
+  }
+
+  /**
+   * Get recent warnings.
+   */
+  getWarnings(limit = 50) {
+    return this.warnings.slice(-limit);
+  }
+
+  /**
+   * Clean up tracking for a completed task.
+   */
+  cleanupTask(taskId) {
+    this.toolCallCounts.delete(taskId);
+    this.toolCallTimestamps.delete(taskId);
+  }
+}
+
+// Singleton
+const supervisor = new Supervisor();
+export default supervisor;

package/src/channels/BaseChannel.js

@@ -0,0 +1,104 @@
+/**
+ * Base channel interface.
+ * All input channels (Telegram, WhatsApp, Email, Discord, Slack, LINE, Signal) extend this.
+ *
+ * A channel:
+ * 1. Receives raw input from its platform
+ * 2. Normalizes it into a Task (via taskQueue.enqueue)
+ * 3. Routes the agent's reply back to the originating platform
+ *
+ * Built-in capabilities (all channels get these for free):
+ * - Allowlist gating  — set config.allowlist = [id, id, ...] to restrict who can send tasks.
+ *                       Empty / omitted = open to all (backward compatible).
+ * - Per-channel model — set config.model = "openai:gpt-4.1" to override the default model
+ *                       for all tasks coming from this channel.
+ * - Status reactions  — sendReaction(channelMeta, emoji) is a no-op by default.
+ *                       Channels that support native reactions override this.
+ */
+export class BaseChannel {
+  constructor(name, config) {
+    this.name = name;
+    this.config = config || {};
+    this.running = false;
+  }
+
+  /**
+   * Start listening for incoming messages.
+   */
+  async start() {
+    throw new Error(`${this.name}: start() not implemented`);
+  }
+
+  /**
+   * Stop listening.
+   */
+  async stop() {
+    throw new Error(`${this.name}: stop() not implemented`);
+  }
+
+  /**
+   * Send a reply back to the user on this channel.
+   * @param {object} channelMeta - Channel-specific metadata (chat_id, phone, email, etc.)
+   * @param {string} text - The response text
+   */
+  async sendReply(channelMeta, text) {
+    throw new Error(`${this.name}: sendReply() not implemented`);
+  }
+
+  /**
+   * Send a native reaction/emoji on the triggering message (optional feature).
+   * Channels that support reactions (Telegram, Discord, Slack) override this.
+   * Others silently ignore it.
+   *
+   * @param {object} channelMeta - Channel-specific metadata
+   * @param {string} emoji       - Emoji to react with (e.g. "✅", "❌", "⏳")
+   */
+  async sendReaction(channelMeta, emoji) {
+    // Default no-op — channels that support reactions override this
+  }
+
+  /**
+   * Check whether a user is allowed to send tasks on this channel.
+   *
+   * If config.allowlist is empty or not set → everyone is allowed (open channel).
+   * If config.allowlist has entries → only those IDs/usernames are allowed.
+   *
+   * @param {string|number} userId - Platform-specific user identifier
+   * @returns {boolean}
+   */
+  isAllowed(userId) {
+    const allowlist = this.config?.allowlist;
+    if (!allowlist || !Array.isArray(allowlist) || allowlist.length === 0) return true;
+    return allowlist.map(String).includes(String(userId));
+  }
+
+  /**
+   * Get the model override for this channel (if configured).
+   * Returns null if no override — TaskRunner will use the global default.
+   * @returns {string|null}
+   */
+  getModel() {
+    return this.config?.model || null;
+  }
+
+  /**
+   * Map a platform user identifier to a session ID.
+   * Ensures continuity across messages from the same user.
+   * @param {string} userId - Platform-specific user identifier
+   * @returns {string} Session ID
+   */
+  getSessionId(userId) {
+    return `${this.name}-${userId}`;
+  }
+
+  /**
+   * Returns true if this task was silently absorbed into a concurrent agent session.
+   * When true, the channel should NOT send a reply — the response was already included
+   * in the original task's reply (like Claude Code's follow-up injection behaviour).
+   * @param {object} completedTask
+   * @returns {boolean}
+   */
+  isTaskMerged(completedTask) {
+    return completedTask?.merged === true;
+  }
+}