@integrity-labs/agt-cli 0.11.0 → 0.12.2

package/dist/{claude-scheduler-7PVWQHWU.js → claude-scheduler-CLSMSF5W.js}

@@ -7,7 +7,7 @@ import {
   markTaskFired,
   saveSchedulerState,
   syncTasksToScheduler
-} from "./chunk-QU7FBXH3.js";
+} from "./chunk-M6FSTVGG.js";
 export {
   computeNextFire,
   findTaskByTemplate,
@@ -18,4 +18,4 @@ export {
   saveSchedulerState,
   syncTasksToScheduler
 };
-//# sourceMappingURL=claude-scheduler-7PVWQHWU.js.map
+//# sourceMappingURL=claude-scheduler-CLSMSF5W.js.map

package/dist/lib/manager-worker.js

@@ -1,16 +1,22 @@
 import {
   api,
+  appendDmFooter,
   exchangeApiKey,
   extractFrontmatter,
   getApiKey,
   getFramework,
   getHostId,
+  getIntegration,
+  isParseError,
+  isResolveError,
+  parseDeliveryTarget,
   provision,
   provisionIsolationHook,
   provisionStopHook,
   requireHost,
-  resolveChannels
-} from "../chunk-WTMVQND4.js";
+  resolveChannels,
+  resolveDmTarget
+} from "../chunk-S5VHDDAJ.js";
 import {
   findTaskByTemplate,
   getProjectDir,
@@ -18,7 +24,7 @@ import {
   loadSchedulerState,
   markTaskFired,
   syncTasksToScheduler
-} from "../chunk-QU7FBXH3.js";
+} from "../chunk-M6FSTVGG.js";
 import {
   getProjectDir as getProjectDir2,
   injectMessage,
@@ -814,6 +820,91 @@ function resolveBrewPath(execFileSync) {
   if (existsSync(fallback)) return fallback;
   return null;
 }
+var toolkitCliEnsured = /* @__PURE__ */ new Set();
+var toolkitCliRetryAfter = /* @__PURE__ */ new Map();
+var TOOLKIT_INSTALL_RETRY_MS = 5 * 6e4;
+async function ensureToolkitCli(toolkitSlug) {
+  if (toolkitCliEnsured.has(toolkitSlug)) return;
+  const retryAfter = toolkitCliRetryAfter.get(toolkitSlug) ?? 0;
+  if (retryAfter > Date.now()) return;
+  const integration = getIntegration(toolkitSlug);
+  if (!integration?.cli_tool) {
+    toolkitCliEnsured.add(toolkitSlug);
+    return;
+  }
+  const { binary, installer, package: pkg, script } = integration.cli_tool;
+  const resolvedInstaller = installer ?? "manual";
+  const { execFileSync, execSync } = await import("child_process");
+  try {
+    execFileSync("which", [binary], { timeout: 5e3, stdio: "pipe" });
+    toolkitCliEnsured.add(toolkitSlug);
+    toolkitCliRetryAfter.delete(toolkitSlug);
+    return;
+  } catch {
+  }
+  if (resolvedInstaller === "manual") {
+    log(`[toolkit-install] ${toolkitSlug}: binary '${binary}' missing, installer=manual \u2014 operator must install`);
+    toolkitCliEnsured.add(toolkitSlug);
+    return;
+  }
+  let brewBinDir = null;
+  try {
+    if (resolvedInstaller === "npm") {
+      if (!pkg) {
+        log(`[toolkit-install] ${toolkitSlug}: installer=npm but no package declared`);
+        toolkitCliEnsured.add(toolkitSlug);
+        return;
+      }
+      log(`[toolkit-install] ${toolkitSlug}: installing via npm (${pkg})\u2026`);
+      execFileSync("npm", ["install", "-g", pkg], { timeout: 18e4, stdio: "pipe" });
+    } else if (resolvedInstaller === "brew") {
+      if (!pkg) {
+        log(`[toolkit-install] ${toolkitSlug}: installer=brew but no package declared`);
+        toolkitCliEnsured.add(toolkitSlug);
+        return;
+      }
+      const brewPath = resolveBrewPath(execFileSync);
+      if (!brewPath) {
+        log(`[toolkit-install] ${toolkitSlug}: installer=brew but Homebrew not available \u2014 install manually: brew install ${pkg}`);
+        toolkitCliEnsured.add(toolkitSlug);
+        return;
+      }
+      brewBinDir = dirname(brewPath);
+      const isRoot = typeof process.getuid === "function" && process.getuid() === 0;
+      log(`[toolkit-install] ${toolkitSlug}: installing via brew (${pkg})\u2026`);
+      if (isRoot) {
+        execFileSync("sudo", ["-u", "ec2-user", "-H", brewPath, "install", pkg], { timeout: 18e4, stdio: "pipe" });
+      } else {
+        execFileSync(brewPath, ["install", pkg], { timeout: 18e4, stdio: "pipe" });
+      }
+    } else if (resolvedInstaller === "script") {
+      if (!script) {
+        log(`[toolkit-install] ${toolkitSlug}: installer=script but no script declared`);
+        toolkitCliEnsured.add(toolkitSlug);
+        return;
+      }
+      log(`[toolkit-install] ${toolkitSlug}: running declared install script\u2026`);
+      execSync(script, { timeout: 18e4, stdio: "pipe" });
+    }
+  } catch (err) {
+    const msg = err.message.slice(0, 200);
+    log(`[toolkit-install] ${toolkitSlug}: installer=${resolvedInstaller} failed \u2014 ${msg} (retrying in ${TOOLKIT_INSTALL_RETRY_MS / 6e4}m)`);
+    toolkitCliRetryAfter.set(toolkitSlug, Date.now() + TOOLKIT_INSTALL_RETRY_MS);
+    return;
+  }
+  if (brewBinDir && !process.env.PATH?.split(":").includes(brewBinDir)) {
+    process.env.PATH = `${brewBinDir}:${process.env.PATH ?? ""}`;
+  }
+  try {
+    execFileSync("which", [binary], { timeout: 5e3, stdio: "pipe" });
+    log(`[toolkit-install] ${toolkitSlug}: installed \u2014 ${binary} now on PATH`);
+    toolkitCliEnsured.add(toolkitSlug);
+    toolkitCliRetryAfter.delete(toolkitSlug);
+  } catch {
+    log(`[toolkit-install] ${toolkitSlug}: installer=${resolvedInstaller} completed but ${binary} still not on PATH (retrying in ${TOOLKIT_INSTALL_RETRY_MS / 6e4}m)`);
+    toolkitCliRetryAfter.set(toolkitSlug, Date.now() + TOOLKIT_INSTALL_RETRY_MS);
+  }
+}
 async function ensureFrameworkBinary(frameworkId) {
   if (frameworkId !== "claude-code") return;
   if (frameworkBinaryChecked.has(frameworkId)) return;
@@ -1459,7 +1550,7 @@ async function pollCycle() {
         const adapter = resolveAgentFramework(prev.codeName);
         await stopGatewayIfRunning(prev.codeName, adapter);
         freePort(prev.codeName);
-        const agentDir = join2(config.configDir, prev.codeName, "provision");
+        const agentDir = join2(adapter.getAgentDir(prev.codeName), "provision");
         await cleanupAgentFiles(prev.codeName, agentDir);
         clearAgentCaches(prev.agentId, prev.codeName);
       }
@@ -1527,8 +1618,8 @@ async function processAgent(agent, agentStates) {
     agentFrameworkCache.set(agent.code_name, agent.framework);
   }
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const agentDir = join2(config.configDir, agent.code_name, "provision");
   const adapter = resolveAgentFramework(agent.code_name);
+  let agentDir = join2(adapter.getAgentDir(agent.code_name), "provision");
   if (agent.status === "draft" || agent.status === "paused") {
     log(`Agent '${agent.code_name}' is ${agent.status}, skipping provisioning`);
     await stopGatewayIfRunning(agent.code_name, adapter);
@@ -1652,6 +1743,8 @@ async function processAgent(agent, agentStates) {
   const frameworkId = refreshData.agent.framework ?? "openclaw";
   agentFrameworkCache.set(agent.code_name, frameworkId);
   const frameworkAdapter = getFramework(frameworkId);
+  agentDir = join2(frameworkAdapter.getAgentDir(agent.code_name), "provision");
+  cacheAgentDeliveryMetadata(agent.code_name, refreshData);
   if (frameworkAdapter.seedProfileConfig) {
     frameworkAdapter.seedProfileConfig(agent.code_name);
   }
@@ -1896,7 +1989,7 @@ async function processAgent(agent, agentStates) {
   const agentSessionMode = refreshData.agent.session_mode;
   if (agentSessionMode === "persistent" && (agentFrameworkCache.get(agent.code_name) ?? "openclaw") === "claude-code") {
     try {
-      const agentProvisionDir = join2(homedir2(), ".augmented", agent.code_name, "claudecode", "provision");
+      const agentProvisionDir = agentDir;
       const projectDir = join2(homedir2(), ".augmented", agent.code_name, "project");
       mkdirSync(agentProvisionDir, { recursive: true });
       mkdirSync(projectDir, { recursive: true });
@@ -2025,8 +2118,7 @@ async function processAgent(agent, agentStates) {
               try {
                 const { readFileSync: readFileSync2 } = await import("fs");
                 const { join: join3 } = await import("path");
-                const { homedir: homedir3 } = await import("os");
-                const mcpPath = join3(homedir3(), ".augmented", "agents", agent.code_name, "provision", ".mcp.json");
+                const mcpPath = join3(frameworkAdapter.getAgentDir(agent.code_name), "provision", ".mcp.json");
                 const mcpConfig = JSON.parse(readFileSync2(mcpPath, "utf-8"));
                 if (mcpConfig.mcpServers) {
                   const managedPrefixes = [
@@ -2228,6 +2320,16 @@ async function processAgent(agent, agentStates) {
           }
         }
       }
+      const agentFwForToolkits = agentFrameworkCache.get(agent.code_name) ?? "openclaw";
+      if (agentFwForToolkits === "claude-code" && refreshData.plugin_toolkits?.length) {
+        const toolkitUnion = /* @__PURE__ */ new Set();
+        for (const { toolkits } of refreshData.plugin_toolkits) {
+          for (const t of toolkits) toolkitUnion.add(t);
+        }
+        for (const toolkitSlug of toolkitUnion) {
+          await ensureToolkitCli(toolkitSlug);
+        }
+      }
       const agentFw2 = agentFrameworkCache.get(agent.code_name) ?? "openclaw";
       if (agentFw2 === "claude-code" && installedPluginSkills.length > 0 && isSessionHealthy(agent.code_name)) {
         const names = installedPluginSkills.join(", ");
@@ -2754,7 +2856,8 @@ async function executeAndProcessClaudeTask(codeName, agentId, task, prompt) {
     await processClaudeTaskResult(codeName, agentId, task.templateId, output, {
       mode: task.deliveryMode,
       channel: task.deliveryChannel,
-      to: task.deliveryTo
+      to: task.deliveryTo,
+      taskId: task.taskId
     });
     const updated = markTaskFired(codeName, task.taskId, "ok");
     claudeSchedulerStates.set(codeName, updated);
@@ -2814,8 +2917,14 @@ async function processClaudeTaskResult(codeName, agentId, templateId, output, de
         log(`[claude-scheduler] Kanban updates posted for '${codeName}' (${kanbanUpdates.length} updates)`);
       }
     }
-    if (delivery?.mode === "announce" && delivery.channel && delivery.to && output) {
-      await sendTaskNotification(codeName, delivery.channel, delivery.to, output.slice(0, 4e3));
+    if (delivery?.mode === "announce" && delivery.to && output) {
+      await deliverScheduledTaskOutput(
+        codeName,
+        agentId,
+        delivery.to,
+        output.slice(0, 4e3),
+        delivery.taskId
+      );
     }
   } catch (err) {
     log(`[claude-scheduler] Failed to post result for '${codeName}': ${err.message}`);
@@ -3281,7 +3390,7 @@ async function processDirectChatMessage(agent, msg) {
   try {
     let reply;
     if (fw === "claude-code") {
-      const { getProjectDir: ccProjectDir } = await import("../claude-scheduler-7PVWQHWU.js");
+      const { getProjectDir: ccProjectDir } = await import("../claude-scheduler-CLSMSF5W.js");
       const projDir = ccProjectDir(agent.codeName);
       const mcpConfigPath = join2(projDir, ".mcp.json");
       const serverNames = [];
@@ -3944,41 +4053,249 @@ ${a.detail}`;
 
 ${blocks.join("\n\n")}`);
 }
+async function deliverScheduledTaskOutput(agentCodeName, agentId, rawTarget, body, taskId) {
+  if (typeof rawTarget === "string") {
+    if (rawTarget.startsWith("channel:")) {
+      const result = await sendTaskNotification(agentCodeName, "slack", rawTarget, body);
+      await reportDeliveryStatus(agentId, taskId, {
+        status: result.ok ? "ok" : "failed",
+        medium: "slack",
+        error_code: result.ok ? null : result.error_code ?? "SLACK_SEND_FAILED"
+      });
+      return;
+    }
+    if (rawTarget.startsWith("chat:")) {
+      const result = await sendTaskNotification(agentCodeName, "telegram", rawTarget, body);
+      await reportDeliveryStatus(agentId, taskId, {
+        status: result.ok ? "ok" : "failed",
+        medium: "telegram",
+        error_code: result.ok ? null : result.error_code ?? "TELEGRAM_SEND_FAILED"
+      });
+      return;
+    }
+    log(`[delivery] Unrecognised legacy delivery_to string for '${agentCodeName}': ${rawTarget.slice(0, 60)}`);
+    await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: "LEGACY_DELIVERY_TO_UNRECOGNISED" });
+    return;
+  }
+  const parsed = parseDeliveryTarget(rawTarget);
+  if (isParseError(parsed)) {
+    log(`[delivery] Malformed delivery_to for '${agentCodeName}': ${parsed.code} \u2014 ${parsed.detail}`);
+    await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: parsed.code });
+    return;
+  }
+  if (parsed.kind === "channel") {
+    if (parsed.provider === "slack") {
+      const sent = await sendSlackChannelMessage(agentCodeName, parsed.channel_id ?? "", body);
+      await reportDeliveryStatus(agentId, taskId, {
+        status: sent ? "ok" : "failed",
+        medium: "slack",
+        error_code: sent ? null : "SLACK_SEND_FAILED"
+      });
+      return;
+    }
+    const toStr = `chat:${parsed.chat_id ?? ""}`;
+    const result = await sendTaskNotification(agentCodeName, "telegram", toStr, body);
+    await reportDeliveryStatus(agentId, taskId, {
+      status: result.ok ? "ok" : "failed",
+      medium: "telegram",
+      error_code: result.ok ? null : result.error_code ?? "TELEGRAM_SEND_FAILED"
+    });
+    return;
+  }
+  const agentRow = agentInfoForDelivery.get(agentCodeName);
+  if (!agentRow) {
+    log(`[delivery] No agent metadata cached for '${agentCodeName}' \u2014 dropping DM`);
+    await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: "AGENT_METADATA_UNAVAILABLE" });
+    return;
+  }
+  const resolved = resolveDmTarget(parsed, agentRow.resolverAgent, agentRow.peopleByPersonId);
+  if (isResolveError(resolved)) {
+    log(`[delivery] Cannot resolve DM target for '${agentCodeName}': ${resolved.code} \u2014 ${resolved.detail}`);
+    await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: resolved.code });
+    return;
+  }
+  const footeredBody = appendDmFooter(
+    body,
+    agentRow.ownerTeamName,
+    agentRow.agentDisplayName
+  );
+  if (resolved.kind === "dm" && resolved.medium === "slack") {
+    const tokens = agentChannelTokens.get(agentCodeName);
+    const botToken = tokens?.slack;
+    if (!botToken) {
+      await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: "SLACK_MISSING_SCOPE", medium: "slack" });
+      log(`[delivery] No Slack bot token for '${agentCodeName}' \u2014 DM dropped`);
+      return;
+    }
+    try {
+      const controller = new AbortController();
+      const timeoutHandle = setTimeout(() => controller.abort(), 5e3);
+      let openJson;
+      try {
+        const openResp = await fetch("https://slack.com/api/conversations.open", {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${botToken}`,
+            "Content-Type": "application/json; charset=utf-8"
+          },
+          body: JSON.stringify({ users: resolved.slack_user_id }),
+          signal: controller.signal
+        });
+        openJson = await openResp.json();
+      } finally {
+        clearTimeout(timeoutHandle);
+      }
+      if (!openJson.ok || !openJson.channel?.id) {
+        const errCode = openJson.error === "missing_scope" ? "SLACK_MISSING_SCOPE" : `SLACK_OPEN_FAILED:${openJson.error ?? "unknown"}`;
+        log(`[delivery] conversations.open failed for '${agentCodeName}': ${openJson.error}`);
+        await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: errCode, medium: "slack" });
+        return;
+      }
+      const sent = await sendSlackChannelMessage(agentCodeName, openJson.channel.id, footeredBody);
+      await reportDeliveryStatus(agentId, taskId, {
+        status: sent ? "ok" : "failed",
+        medium: "slack",
+        error_code: sent ? null : "SLACK_SEND_FAILED"
+      });
+    } catch (err) {
+      const isAbort = err.name === "AbortError";
+      const errCode = isAbort ? "SLACK_OPEN_TIMEOUT" : "SLACK_EXCEPTION";
+      log(`[delivery] Slack DM ${isAbort ? "timeout" : "failure"} for '${agentCodeName}': ${err.message}`);
+      await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: errCode, medium: "slack" });
+    }
+    return;
+  }
+  if (resolved.kind === "dm" && resolved.medium === "telegram") {
+    const tokens = agentChannelTokens.get(agentCodeName);
+    const botToken = tokens?.telegram;
+    if (!botToken) {
+      log(`[delivery] No Telegram bot token for '${agentCodeName}' \u2014 DM dropped`);
+      await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: "TELEGRAM_NO_TOKEN", medium: "telegram" });
+      return;
+    }
+    try {
+      const result = await telegramApiCall(botToken, "sendMessage", {
+        chat_id: resolved.telegram_chat_id,
+        text: footeredBody
+      });
+      if (!result.ok) {
+        log(`[delivery] Telegram DM failed for '${agentCodeName}': ${result.description}`);
+        await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: `TELEGRAM_SEND_FAILED:${result.description ?? "unknown"}`, medium: "telegram" });
+        return;
+      }
+      await reportDeliveryStatus(agentId, taskId, { status: "ok", medium: "telegram" });
+    } catch (err) {
+      log(`[delivery] Telegram DM exception for '${agentCodeName}': ${err.message}`);
+      await reportDeliveryStatus(agentId, taskId, { status: "failed", error_code: "TELEGRAM_EXCEPTION", medium: "telegram" });
+    }
+  }
+}
+var agentInfoForDelivery = /* @__PURE__ */ new Map();
+function cacheAgentDeliveryMetadata(codeName, refreshData) {
+  const agentRow = refreshData["agent"] ?? {};
+  const displayName = agentRow["display_name"] ?? codeName;
+  const ownerTeamName = agentRow["owner_team_name"] ?? null;
+  const framework = agentRow["framework"] ?? "openclaw";
+  const reportsToPersonId = agentRow["reports_to"] ?? null;
+  const reportsToType = agentRow["reports_to_type"] ?? null;
+  const channelConfigs = refreshData["channel_configs"] ?? {};
+  const dmCapable = [];
+  const slackBotToken = channelConfigs["slack"]?.config?.["bot_token"];
+  if (typeof slackBotToken === "string" && slackBotToken.length > 0) {
+    dmCapable.push("slack");
+  }
+  const telegramBotToken = channelConfigs["telegram"]?.config?.["bot_token"];
+  if (typeof telegramBotToken === "string" && telegramBotToken.length > 0) {
+    dmCapable.push("telegram");
+  }
+  const resolverAgent = {
+    agent_id: agentRow["agent_id"] ?? "",
+    framework,
+    dm_capable_mediums: dmCapable,
+    reports_to_person_id: reportsToType === "person" ? reportsToPersonId : null,
+    reports_to_type: reportsToType
+  };
+  const peopleByPersonId = /* @__PURE__ */ new Map();
+  if (reportsToPersonId && reportsToType === "person") {
+    peopleByPersonId.set(reportsToPersonId, {
+      person_id: reportsToPersonId,
+      display_name: agentRow["reports_to_name"] ?? "Reports-To",
+      slack_user_id: agentRow["reports_to_slack_user_id"] ?? null,
+      telegram_chat_id: agentRow["reports_to_telegram_chat_id"] ?? null
+    });
+  }
+  const people = refreshData["people"] ?? [];
+  for (const p of people) {
+    const personId = p["person_id"];
+    if (!personId) continue;
+    const contactPrefs = p["contact_preferences"] ?? {};
+    peopleByPersonId.set(personId, {
+      person_id: personId,
+      display_name: p["display_name"] ?? "person",
+      slack_user_id: contactPrefs["slack_user_id"] ?? null,
+      telegram_chat_id: contactPrefs["telegram_chat_id"] ?? null
+    });
+  }
+  agentInfoForDelivery.set(codeName, {
+    agentDisplayName: displayName,
+    ownerTeamName,
+    resolverAgent,
+    peopleByPersonId
+  });
+}
+async function reportDeliveryStatus(agentId, taskId, payload) {
+  if (!taskId) return;
+  try {
+    await api.post("/host/schedules/delivery-status", {
+      agent_id: agentId,
+      task_id: taskId,
+      status: payload.status,
+      medium: payload.medium ?? null,
+      error_code: payload.error_code ?? null
+    });
+  } catch (err) {
+    log(`[delivery] Failed to report delivery status for ${agentId}/${taskId}: ${err.message}`);
+  }
+}
 async function sendTaskNotification(agentCodeName, channel, to, text) {
   const tokens = agentChannelTokens.get(agentCodeName);
   if (channel === "slack") {
     const botToken = tokens?.slack;
     const channelId = to.replace(/^channel:/, "");
-    if (botToken) {
-      const sent = await sendSlackChannelMessage(agentCodeName, channelId, text);
-      if (sent) return;
+    if (!botToken) {
+      log(`No Slack bot token for '${agentCodeName}' \u2014 targeted notification dropped`);
+      return { ok: false, error_code: "SLACK_NO_TOKEN" };
     }
-    log(`No Slack bot token for '${agentCodeName}' \u2014 targeted notification dropped`);
-  } else if (channel === "telegram") {
+    const sent = await sendSlackChannelMessage(agentCodeName, channelId, text);
+    return sent ? { ok: true } : { ok: false, error_code: "SLACK_SEND_FAILED" };
+  }
+  if (channel === "telegram") {
     const botToken = tokens?.telegram;
     const chatId = to.replace(/^chat:/, "");
     if (!botToken) {
       log(`No Telegram bot token for '${agentCodeName}' \u2014 notification dropped`);
-      return;
+      return { ok: false, error_code: "TELEGRAM_NO_TOKEN" };
     }
     const allowedChats = tokens?.telegramAllowedChats;
     if (allowedChats && allowedChats.length > 0 && !allowedChats.includes(chatId)) {
       log(`Telegram chat ${chatId} not in allowed_chat_ids for '${agentCodeName}'`);
-      return;
+      return { ok: false, error_code: "TELEGRAM_CHAT_NOT_ALLOWED" };
     }
     try {
       const result = await telegramApiCall(botToken, "sendMessage", { chat_id: chatId, text });
       if (!result.ok) {
         log(`Telegram sendMessage failed for '${agentCodeName}': ${result.description}`);
-      } else {
-        log(`Telegram notification sent for '${agentCodeName}' to chat ${chatId}`);
+        return { ok: false, error_code: `TELEGRAM_SEND_FAILED:${result.description ?? "unknown"}` };
       }
+      log(`Telegram notification sent for '${agentCodeName}' to chat ${chatId}`);
+      return { ok: true };
     } catch (err) {
       log(`Telegram API error for '${agentCodeName}': ${err.message}`);
+      return { ok: false, error_code: "TELEGRAM_EXCEPTION" };
     }
-  } else {
-    log(`Unknown notify_channel '${channel}' for '${agentCodeName}'`);
   }
+  log(`Unknown notify_channel '${channel}' for '${agentCodeName}'`);
+  return { ok: false, error_code: `UNKNOWN_CHANNEL:${channel}` };
 }
 function generateArtifacts(agent, refreshData, adapter) {
   if (!refreshData.charter || !refreshData.tools) {