volute 0.7.0 → 0.8.1

package/dist/{chunk-62X577Y7.js → chunk-W6TMWYU3.js}

@@ -1,23 +1,23 @@
 #!/usr/bin/env node
 import {
   loadMergedEnv
-} from "./chunk-H7AMDUIA.js";
+} from "./chunk-QF22MYDJ.js";
 import {
   applyIsolation
-} from "./chunk-W76KWE23.js";
+} from "./chunk-IQXBMFZG.js";
 import {
   agentDir,
   findAgent,
   findVariant,
   setAgentRunning,
   setVariantRunning,
-  validateBranchName,
+  stateDir,
   voluteHome
-} from "./chunk-UWHWAPGO.js";
+} from "./chunk-DP2DX4WV.js";
 
 // src/lib/agent-manager.ts
 import { execFile, spawn } from "child_process";
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, unlinkSync as unlinkSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
 import { resolve } from "path";
 import { promisify } from "util";
 
@@ -59,14 +59,21 @@ function clearJsonMap(path, map) {
 }
 
 // src/lib/rotating-log.ts
-import { createWriteStream, existsSync as existsSync2, renameSync, statSync } from "fs";
+import {
+  createWriteStream,
+  existsSync as existsSync2,
+  renameSync,
+  rmSync,
+  statSync
+} from "fs";
 import { Writable } from "stream";
 var MAX_SIZE = 10 * 1024 * 1024;
 var RotatingLog = class extends Writable {
-  constructor(path, maxSize = MAX_SIZE) {
+  constructor(path, maxSize = MAX_SIZE, maxFiles = 5) {
     super();
     this.path = path;
     this.maxSize = maxSize;
+    this.maxFiles = maxFiles;
     this.on("error", () => {
     });
     try {
@@ -82,6 +89,13 @@ var RotatingLog = class extends Writable {
     this.size += chunk.length;
     if (this.size > this.maxSize) {
       try {
+        const oldest = `${this.path}.${this.maxFiles}`;
+        if (existsSync2(oldest)) rmSync(oldest);
+        for (let i = this.maxFiles - 1; i >= 1; i--) {
+          const from = `${this.path}.${i}`;
+          const to = `${this.path}.${i + 1}`;
+          if (existsSync2(from)) renameSync(from, to);
+        }
         renameSync(this.path, `${this.path}.1`);
         const oldStream = this.stream;
         this.stream = createWriteStream(this.path);
@@ -99,6 +113,9 @@ var RotatingLog = class extends Writable {
 
 // src/lib/agent-manager.ts
 var execFileAsync = promisify(execFile);
+function agentPidPath(name) {
+  return resolve(stateDir(name), "agent.pid");
+}
 var MAX_RESTART_ATTEMPTS = 5;
 var BASE_RESTART_DELAY = 3e3;
 var MAX_RESTART_DELAY = 6e4;
@@ -107,6 +124,7 @@ var AgentManager = class {
   stopping = /* @__PURE__ */ new Set();
   shuttingDown = false;
   restartAttempts = /* @__PURE__ */ new Map();
+  pendingContext = /* @__PURE__ */ new Map();
   resolveTarget(name) {
     const [baseName, variantName] = name.split("@", 2);
     const entry = findAgent(baseName);
@@ -127,6 +145,34 @@ var AgentManager = class {
     const target = this.resolveTarget(name);
     const { dir, isVariant, baseName, variantName } = target;
     const port = target.port;
+    const pidFile = agentPidPath(name);
+    try {
+      if (existsSync3(pidFile)) {
+        const stalePid = parseInt(readFileSync2(pidFile, "utf-8").trim(), 10);
+        if (stalePid > 0) {
+          try {
+            process.kill(stalePid, 0);
+            const { stdout } = await execFileAsync("ps", ["-p", String(stalePid), "-o", "args="]);
+            if (stdout.includes("server.ts")) {
+              console.error(`[daemon] killing stale agent process ${stalePid} for ${name}`);
+              process.kill(-stalePid, "SIGTERM");
+              await new Promise((r) => setTimeout(r, 500));
+            } else {
+              console.error(
+                `[daemon] stale PID ${stalePid} for ${name} is not an agent process, skipping`
+              );
+            }
+          } catch (err) {
+            if (err.code !== "ESRCH") {
+              console.error(`[daemon] failed to check/kill stale process for ${name}:`, err);
+            }
+          }
+        }
+        rmSync2(pidFile, { force: true });
+      }
+    } catch (err) {
+      console.error(`[daemon] failed to read PID file for ${name}:`, err);
+    }
     try {
       const res = await fetch(`http://127.0.0.1:${port}/health`);
       if (res.ok) {
@@ -136,13 +182,18 @@ var AgentManager = class {
       }
     } catch {
     }
-    const voluteDir = resolve(dir, ".volute");
-    const logsDir = resolve(voluteDir, "logs");
+    const logsDir = resolve(stateDir(name), "logs");
     mkdirSync(logsDir, { recursive: true });
     const logStream = new RotatingLog(resolve(logsDir, "agent.log"));
-    const agentEnv = loadMergedEnv(dir);
-    const { VOLUTE_DAEMON_TOKEN: _, ...parentEnv } = process.env;
-    const env = { ...parentEnv, ...agentEnv, VOLUTE_AGENT: name };
+    const agentEnv = loadMergedEnv(name);
+    const env = {
+      ...process.env,
+      ...agentEnv,
+      VOLUTE_AGENT: name,
+      VOLUTE_STATE_DIR: stateDir(name),
+      VOLUTE_AGENT_DIR: dir,
+      VOLUTE_AGENT_PORT: String(port)
+    };
     const tsxBin = resolve(dir, "node_modules", ".bin", "tsx");
     const spawnOpts = {
       cwd: dir,
@@ -185,82 +236,83 @@ var AgentManager = class {
       }
       throw err;
     }
+    if (child.pid) {
+      try {
+        writeFileSync2(pidFile, String(child.pid));
+      } catch (err) {
+        console.error(`[daemon] failed to write PID file for ${name}:`, err);
+      }
+    }
     if (this.restartAttempts.delete(name)) this.saveCrashAttempts();
-    this.setupCrashRecovery(name, child, dir, isVariant);
+    this.setupCrashRecovery(name, child);
     if (isVariant) {
       setVariantRunning(baseName, variantName, true);
     } else {
       setAgentRunning(name, true);
     }
     console.error(`[daemon] started agent ${name} on port ${port}`);
+    await this.deliverPendingContext(name);
+  }
+  setPendingContext(name, context) {
+    this.pendingContext.set(name, context);
+  }
+  async deliverPendingContext(name) {
+    const context = this.pendingContext.get(name);
+    if (!context) return;
+    const tracked = this.agents.get(name);
+    if (!tracked) return;
+    this.pendingContext.delete(name);
+    const parts = [];
+    if (context.type === "merge" || context.type === "merged") {
+      parts.push(`[system] Variant "${context.name}" has been merged and you have been restarted.`);
+    } else {
+      parts.push("[system] You have been restarted.");
+    }
+    if (context.summary) parts.push(`Changes: ${context.summary}`);
+    if (context.justification) parts.push(`Why: ${context.justification}`);
+    if (context.memory) parts.push(`Context: ${context.memory}`);
+    try {
+      await fetch(`http://127.0.0.1:${tracked.port}/message`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          content: [{ type: "text", text: parts.join("\n") }],
+          channel: "system"
+        })
+      });
+    } catch (err) {
+      console.error(`[daemon] failed to deliver pending context to ${name}:`, err);
+    }
   }
-  setupCrashRecovery(name, child, dir, isVariant) {
+  setupCrashRecovery(name, child) {
     child.on("exit", async (code) => {
       this.agents.delete(name);
       if (this.shuttingDown || this.stopping.has(name)) return;
       console.error(`[daemon] agent ${name} exited with code ${code}`);
-      const wasRestart = isVariant ? false : await this.handleRestart(name, dir);
-      if (wasRestart) {
-        console.error(`[daemon] restarting ${name} immediately after merge`);
-        if (this.restartAttempts.delete(name)) this.saveCrashAttempts();
-        this.startAgent(name).catch((err) => {
-          console.error(`[daemon] failed to restart ${name} after merge:`, err);
-        });
-      } else {
-        const attempts = this.restartAttempts.get(name) ?? 0;
-        if (attempts >= MAX_RESTART_ATTEMPTS) {
-          console.error(`[daemon] ${name} crashed ${attempts} times \u2014 giving up on restart`);
-          const [base, variant] = name.split("@", 2);
-          if (variant) {
-            setVariantRunning(base, variant, false);
-          } else {
-            setAgentRunning(name, false);
-          }
-          return;
+      const attempts = this.restartAttempts.get(name) ?? 0;
+      if (attempts >= MAX_RESTART_ATTEMPTS) {
+        console.error(`[daemon] ${name} crashed ${attempts} times \u2014 giving up on restart`);
+        const [base, variant] = name.split("@", 2);
+        if (variant) {
+          setVariantRunning(base, variant, false);
+        } else {
+          setAgentRunning(name, false);
         }
-        const delay = Math.min(BASE_RESTART_DELAY * 2 ** attempts, MAX_RESTART_DELAY);
-        this.restartAttempts.set(name, attempts + 1);
-        this.saveCrashAttempts();
-        console.error(
-          `[daemon] crash recovery for ${name} \u2014 attempt ${attempts + 1}/${MAX_RESTART_ATTEMPTS}, restarting in ${delay}ms`
-        );
-        setTimeout(() => {
-          if (this.shuttingDown) return;
-          this.startAgent(name).catch((err) => {
-            console.error(`[daemon] failed to restart ${name}:`, err);
-          });
-        }, delay);
+        return;
       }
-    });
-  }
-  async handleRestart(name, dir) {
-    const restartPath = resolve(dir, ".volute", "restart.json");
-    if (!existsSync3(restartPath)) return false;
-    try {
-      const signal = JSON.parse(readFileSync2(restartPath, "utf-8"));
-      unlinkSync2(restartPath);
-      if (signal.action === "merge" && signal.name) {
-        const err = validateBranchName(signal.name);
-        if (err) {
-          console.error(`[daemon] invalid variant name in restart.json for ${name}: ${err}`);
-          return false;
-        }
-        console.error(`[daemon] merging variant for ${name}: ${signal.name}`);
-        const mergeArgs = ["merge", name, signal.name];
-        if (signal.summary) mergeArgs.push("--summary", signal.summary);
-        if (signal.justification) mergeArgs.push("--justification", signal.justification);
-        if (signal.memory) mergeArgs.push("--memory", signal.memory);
-        const { VOLUTE_DAEMON_TOKEN: _t, ...mergeEnv } = process.env;
-        await execFileAsync("volute", mergeArgs, {
-          cwd: dir,
-          env: { ...mergeEnv, VOLUTE_SUPERVISOR: "1" }
+      const delay = Math.min(BASE_RESTART_DELAY * 2 ** attempts, MAX_RESTART_DELAY);
+      this.restartAttempts.set(name, attempts + 1);
+      this.saveCrashAttempts();
+      console.error(
+        `[daemon] crash recovery for ${name} \u2014 attempt ${attempts + 1}/${MAX_RESTART_ATTEMPTS}, restarting in ${delay}ms`
+      );
+      setTimeout(() => {
+        if (this.shuttingDown) return;
+        this.startAgent(name).catch((err) => {
+          console.error(`[daemon] failed to restart ${name}:`, err);
         });
-      }
-      return true;
-    } catch (e) {
-      console.error(`[daemon] failed to handle restart for ${name}:`, e);
-      return false;
-    }
+      }, delay);
+    });
   }
   async stopAgent(name) {
     const tracked = this.agents.get(name);
@@ -285,6 +337,7 @@ var AgentManager = class {
     });
     this.stopping.delete(name);
     if (this.restartAttempts.delete(name)) this.saveCrashAttempts();
+    rmSync2(agentPidPath(name), { force: true });
     if (!this.shuttingDown) {
       const [baseName, variantName] = name.split("@", 2);
       if (variantName) {

package/dist/{chunk-EG45HBSJ.js → chunk-XSJ27WEM.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-D424ZQGI.js";
 import {
   voluteHome
-} from "./chunk-UWHWAPGO.js";
+} from "./chunk-DP2DX4WV.js";
 
 // src/commands/up.ts
 import { spawn } from "child_process";

package/dist/cli.js

@@ -9,49 +9,52 @@ if (!process.env.VOLUTE_HOME) {
 var command = process.argv[2];
 var args = process.argv.slice(3);
 if (command === "--version" || command === "-v") {
-  const { default: pkg } = await import("./package-T2WAVJOU.js");
+  const { default: pkg } = await import("./package-RJSONENE.js");
   console.log(pkg.version);
   process.exit(0);
 }
 switch (command) {
   case "agent":
-    await import("./agent-7JF7MT73.js").then((m) => m.run(args));
+    await import("./agent-YORVRB6I.js").then((m) => m.run(args));
     break;
-  case "message":
-    await import("./message-SCOQDR3P.js").then((m) => m.run(args));
+  case "send":
+    await import("./send-BNC2S5BY.js").then((m) => m.run(args));
+    break;
+  case "history":
+    await import("./history-PXJVYLVY.js").then((m) => m.run(args));
     break;
   case "variant":
-    await import("./variant-4Z6W3PP6.js").then((m) => m.run(args));
+    await import("./variant-RKXPN5DH.js").then((m) => m.run(args));
     break;
   case "connector":
-    await import("./connector-Y7JPNROO.js").then((m) => m.run(args));
+    await import("./connector-ZP6MEFF4.js").then((m) => m.run(args));
     break;
   case "channel":
-    await import("./channel-SMCNOIVQ.js").then((m) => m.run(args));
+    await import("./channel-RDGHBFSI.js").then((m) => m.run(args));
     break;
   case "schedule":
-    await import("./schedule-S6QVC5ON.js").then((m) => m.run(args));
+    await import("./schedule-HCUCBNQI.js").then((m) => m.run(args));
     break;
   case "env":
-    await import("./env-7GLUJCWS.js").then((m) => m.run(args));
+    await import("./env-KMNYGVZ2.js").then((m) => m.run(args));
     break;
   case "up":
-    await import("./up-RWZF6MLT.js").then((m) => m.run(args));
+    await import("./up-V6EAA7OZ.js").then((m) => m.run(args));
     break;
   case "down":
-    await import("./down-AZVH5TCD.js").then((m) => m.run(args));
+    await import("./down-O4EWZTVA.js").then((m) => m.run(args));
     break;
   case "restart":
-    await import("./daemon-restart-4HVEKYFY.js").then((m) => m.run(args));
+    await import("./daemon-restart-CPBLMMRI.js").then((m) => m.run(args));
     break;
   case "setup":
-    await import("./setup-F4TCWVSP.js").then((m) => m.run(args));
+    await import("./setup-32KH5KLN.js").then((m) => m.run(args));
     break;
   case "service":
-    await import("./service-HZNIDNJF.js").then((m) => m.run(args));
+    await import("./service-XCADRKIS.js").then((m) => m.run(args));
     break;
   case "update":
-    await import("./update-F7QWV2LB.js").then((m) => m.run(args));
+    await import("./update-EUCZ7XGG.js").then((m) => m.run(args));
     break;
   case "--help":
   case "-h":
@@ -70,8 +73,8 @@ Commands:
   volute agent upgrade <name>             Upgrade agent to latest template
   volute agent import <path>              Import an OpenClaw workspace
 
-  volute message send <name> "<msg>"      Send a message to an agent
-  volute message history [--agent <name>] View message history
+  volute send <target> "<msg>"             Send a message (agent DM, channel, etc.)
+  volute history [--agent <name>]          View message history
 
   volute variant create <name>            Create a variant (worktree + server)
   volute variant list                     List variants for an agent
@@ -82,7 +85,6 @@ Commands:
   volute connector disconnect <type>      Disable a connector for an agent
 
   volute channel read <uri>               Read recent messages from a channel
-  volute channel send <uri> "<msg>"       Send a message to a channel
   volute channel list [<platform>]        List conversations on a platform
   volute channel users <platform>         List users on a platform
   volute channel create <platform> ...    Create a conversation on a platform
@@ -109,7 +111,7 @@ Options:
   --version, -v                           Show version number
   --help, -h                              Show this help message
 
-Agent-scoped commands (variant, connector, schedule, channel, message history)
+Agent-scoped commands (send, history, variant, connector, schedule, channel)
 use --agent <name> or VOLUTE_AGENT env var to identify the agent.`);
     break;
   default:
@@ -118,7 +120,7 @@ Run 'volute --help' for usage.`);
     process.exit(1);
 }
 if (command !== "update") {
-  import("./update-check-B4J6IEQ4.js").then((m) => m.checkForUpdate()).then((result) => {
+  import("./update-check-SM4244SU.js").then((m) => m.checkForUpdate()).then((result) => {
     if (result.updateAvailable) {
       console.error(`
   Update available: ${result.current} \u2192 ${result.latest}`);

package/dist/{connector-Y7JPNROO.js → connector-ZP6MEFF4.js}

@@ -6,16 +6,16 @@ import {
   agentEnvPath,
   readEnv,
   writeEnv
-} from "./chunk-H7AMDUIA.js";
+} from "./chunk-QF22MYDJ.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
 import {
   daemonFetch
-} from "./chunk-JR4UXCTO.js";
+} from "./chunk-23L3MKEV.js";
 import {
   agentDir
-} from "./chunk-UWHWAPGO.js";
+} from "./chunk-DP2DX4WV.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/connector.ts

package/dist/connectors/discord.js

@@ -1,27 +1,18 @@
 #!/usr/bin/env node
 import {
   buildChannelSlug,
-  fireAndForget,
-  handleAgentMessage,
   loadEnv,
   loadFollowedChannels,
   reportTyping,
+  sendToAgent,
   slugify,
-  splitMessage,
   writeChannelEntry
-} from "../chunk-BX7KI4S3.js";
+} from "../chunk-N6MLQ26B.js";
+import "../chunk-DP2DX4WV.js";
 import "../chunk-K3NQKI34.js";
 
 // src/connectors/discord.ts
-import {
-  AttachmentBuilder,
-  ChannelType,
-  Client,
-  Events,
-  GatewayIntentBits,
-  Partials
-} from "discord.js";
-var DISCORD_MAX_LENGTH = 2e3;
+import { ChannelType, Client, Events, GatewayIntentBits, Partials } from "discord.js";
 var TYPING_INTERVAL_MS = 8e3;
 var env = loadEnv();
 var token = process.env.DISCORD_TOKEN;
@@ -102,14 +93,16 @@ client.on(Events.MessageCreate, async (message) => {
     channelName: channelName ?? message.channelId,
     serverName: message.guild?.name
   });
-  if (env.agentDir) {
-    writeChannelEntry(env.agentDir, channelKey, {
+  try {
+    writeChannelEntry(env.agentName, channelKey, {
       platformId: message.channelId,
       platform: "discord",
       name: channelName ? `#${channelName}` : void 0,
       server: message.guild?.name,
       type: isDM ? "dm" : "channel"
     });
+  } catch (err) {
+    console.error(`[discord] failed to write channel entry for ${channelKey}:`, err);
   }
   const participantCount = isDM ? 2 : message.guild?.memberCount;
   const payload = {
@@ -124,7 +117,11 @@ client.on(Events.MessageCreate, async (message) => {
   };
   reportTyping(env, channelKey, senderName, false);
   if (isFollowedChannel && !isMentioned) {
-    await fireAndForget(env, payload);
+    const result = await sendToAgent(env, payload);
+    if (!result.ok)
+      message.reply(result.error ?? "Failed to process message").catch((err) => {
+        console.warn(`[discord] failed to send error reply: ${err}`);
+      });
     return;
   }
   await handleDiscordMessage(message, payload);
@@ -146,50 +143,12 @@ async function handleDiscordMessage(message, payload) {
   channel.sendTyping().catch((err) => {
     console.warn(`[discord] sendTyping failed: ${err}`);
   });
-  let replied = false;
   try {
-    await handleAgentMessage(env, payload, {
-      onFlush: async (text, images) => {
-        if (!text && images.length === 0) return;
-        const chunks = text ? splitMessage(text, DISCORD_MAX_LENGTH) : [];
-        const imageFiles = images.map((img, i) => {
-          const ext = img.media_type.split("/")[1] || "png";
-          return new AttachmentBuilder(Buffer.from(img.data, "base64"), {
-            name: `image-${i}.${ext}`
-          });
-        });
-        if (chunks.length === 0 && imageFiles.length > 0) {
-          const sendFn = replied ? channel.send.bind(channel) : message.reply.bind(message);
-          await sendFn({ content: "\u200B", files: imageFiles }).catch((err) => {
-            console.error(`Failed to send message: ${err}`);
-          });
-          replied = true;
-          return;
-        }
-        for (let i = 0; i < chunks.length; i++) {
-          const isLast = i === chunks.length - 1;
-          const opts = {
-            content: chunks[i]
-          };
-          if (isLast && imageFiles.length > 0) opts.files = imageFiles;
-          try {
-            if (!replied) {
-              await message.reply(opts);
-              replied = true;
-            } else {
-              await channel.send(opts);
-            }
-          } catch (err) {
-            console.error(`Failed to send message: ${err}`);
-          }
-        }
-      },
-      onError: async (msg) => {
-        await message.reply(msg).catch((err) => {
-          console.error(`[discord] failed to send error reply: ${err}`);
-        });
-      }
-    });
+    const result = await sendToAgent(env, payload);
+    if (!result.ok)
+      message.reply(result.error ?? "Failed to process message").catch((err) => {
+        console.warn(`[discord] failed to send error reply: ${err}`);
+      });
   } finally {
     clearInterval(typingInterval);
   }

package/dist/connectors/slack.js

@@ -1,19 +1,17 @@
 #!/usr/bin/env node
 import {
   buildChannelSlug,
-  fireAndForget,
-  handleAgentMessage,
   loadEnv,
   loadFollowedChannels,
   onShutdown,
-  splitMessage,
+  sendToAgent,
   writeChannelEntry
-} from "../chunk-BX7KI4S3.js";
+} from "../chunk-N6MLQ26B.js";
+import "../chunk-DP2DX4WV.js";
 import "../chunk-K3NQKI34.js";
 
 // src/connectors/slack.ts
 import { App } from "@slack/bolt";
-var SLACK_MAX_LENGTH = 4e3;
 var env = loadEnv();
 var botToken = process.env.SLACK_BOT_TOKEN;
 var appToken = process.env.SLACK_APP_TOKEN;
@@ -30,7 +28,7 @@ var app = new App({
 });
 var botUserId;
 var serverName;
-app.message(async ({ message, say }) => {
+app.message(async ({ message }) => {
   if (message.subtype) return;
   if (!("user" in message) || !("text" in message)) return;
   if ("bot_id" in message && message.bot_id) return;
@@ -98,14 +96,16 @@ app.message(async ({ message, say }) => {
     channelName: channelName ?? message.channel,
     serverName
   });
-  if (env.agentDir) {
-    writeChannelEntry(env.agentDir, channelKey, {
+  try {
+    writeChannelEntry(env.agentName, channelKey, {
       platformId: message.channel,
       platform: "slack",
       name: channelName ? `#${channelName}` : void 0,
       server: serverName,
       type: isDM ? "dm" : "channel"
     });
+  } catch (err) {
+    console.error(`[slack] failed to write channel entry for ${channelKey}:`, err);
   }
   const participantCount = message.channel_type === "im" ? 2 : numMembers;
   const payload = {
@@ -119,38 +119,21 @@ app.message(async ({ message, say }) => {
     ...participantCount ? { participantCount } : {}
   };
   if (isFollowedChannel && !isMentioned) {
-    await fireAndForget(env, payload);
+    const result2 = await sendToAgent(env, payload);
+    if (!result2.ok)
+      app.client.chat.postMessage({
+        channel: message.channel,
+        text: result2.error ?? "Failed to process message"
+      }).catch((err) => {
+        console.warn(`[slack] failed to send error reply: ${err}`);
+      });
     return;
   }
-  await handleAgentMessage(env, payload, {
-    onFlush: async (text2, images) => {
-      for (const img of images) {
-        const ext = img.media_type.split("/")[1] || "png";
-        try {
-          await app.client.filesUploadV2({
-            channel_id: message.channel,
-            file: Buffer.from(img.data, "base64"),
-            filename: `image.${ext}`
-          });
-        } catch (err) {
-          console.error(`Failed to upload image: ${err}`);
-        }
-      }
-      if (!text2) return;
-      const chunks = splitMessage(text2, SLACK_MAX_LENGTH);
-      for (const chunk of chunks) {
-        try {
-          await say(chunk);
-        } catch (err) {
-          console.error(`Failed to send message: ${err}`);
-        }
-      }
-    },
-    onError: async (msg) => {
-      await say(msg).catch(() => {
-      });
-    }
-  });
+  const result = await sendToAgent(env, payload);
+  if (!result.ok)
+    app.client.chat.postMessage({ channel: message.channel, text: result.error ?? "Failed to process message" }).catch((err) => {
+      console.warn(`[slack] failed to send error reply: ${err}`);
+    });
 });
 async function start() {
   await app.start();