@integrity-labs/agt-cli 0.20.6 → 0.20.8

package/mcp/slack-channel.js

@@ -14323,6 +14323,462 @@ async function isThreadKilled(opts) {
   }
 }
 
+// src/slack-progress.ts
+var MODE_EMOJI = {
+  thinking: "\u{1F4AD}",
+  working: "\u{1F6E0}\uFE0F",
+  waiting: "\u23F3"
+};
+var TERMINAL_EMOJI = {
+  completed: "\u2705",
+  failed: "\u274C"
+};
+function formatWallClock(ms) {
+  const d = new Date(ms);
+  const hh = String(d.getUTCHours()).padStart(2, "0");
+  const mm = String(d.getUTCMinutes()).padStart(2, "0");
+  const ss = String(d.getUTCSeconds()).padStart(2, "0");
+  return `${hh}:${mm}:${ss} UTC`;
+}
+function renderHeaderLine(state) {
+  if (state.terminal) {
+    return `${TERMINAL_EMOJI[state.terminal.kind]} *${state.terminal.kind === "completed" ? "Done" : "Failed"}* \u2014 ${state.initialLabel}`;
+  }
+  return `${MODE_EMOJI[state.mode]} *Working on:* ${state.initialLabel}`;
+}
+function renderStepLine(state) {
+  if (state.terminal) {
+    return state.terminal.message ? state.terminal.message : void 0;
+  }
+  const parts = [];
+  if (state.stepNumber) {
+    if (state.stepNumber.total != null) {
+      parts.push(`*Step ${state.stepNumber.current} of ${state.stepNumber.total}*`);
+    } else {
+      parts.push(`*Step ${state.stepNumber.current}*`);
+    }
+  }
+  if (state.stepLabel) parts.push(state.stepLabel);
+  return parts.length > 0 ? parts.join(": ") : void 0;
+}
+function renderProgressBlocks(state) {
+  const header = renderHeaderLine(state);
+  const step = renderStepLine(state);
+  const footer = state.terminal ? `_${state.terminal.kind === "completed" ? "completed" : "failed"}: ${formatWallClock(state.lastChangeAt)}_` : `_last update: ${formatWallClock(state.lastChangeAt)}_`;
+  const lines = [header];
+  if (step) lines.push(step);
+  if (state.detail) lines.push(`_${state.detail}_`);
+  lines.push(footer);
+  const fallbackText = state.terminal ? `${state.terminal.kind === "completed" ? "Done" : "Failed"} \u2014 ${state.initialLabel}` : `Working on: ${state.initialLabel}`;
+  return {
+    text: fallbackText,
+    blocks: [
+      {
+        type: "section",
+        text: { type: "mrkdwn", text: lines.join("\n") }
+      }
+    ]
+  };
+}
+var SLACK_POST_URL = "https://slack.com/api/chat.postMessage";
+var SLACK_UPDATE_URL = "https://slack.com/api/chat.update";
+var DEFAULT_TIMEOUT_MS = 5e3;
+var SlackApiError = class extends Error {
+  constructor(endpoint, slackError, status) {
+    super(`Slack ${endpoint} failed: ${slackError} (status=${status})`);
+    this.endpoint = endpoint;
+    this.slackError = slackError;
+    this.status = status;
+    this.name = "SlackApiError";
+  }
+};
+function createSlackProgressFlush(opts) {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  let anchorTs = null;
+  async function slackCall(endpoint, body) {
+    const url = endpoint === "chat.postMessage" ? SLACK_POST_URL : SLACK_UPDATE_URL;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    let response;
+    try {
+      response = await fetchImpl(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${opts.botToken}`
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    const parsed = await response.json().catch(() => ({ ok: false, error: "invalid_json" }));
+    if (!parsed.ok) {
+      throw new SlackApiError(endpoint, parsed.error ?? "unknown", response.status);
+    }
+    return parsed;
+  }
+  return async function flush(state) {
+    const payload = renderProgressBlocks(state);
+    if (anchorTs == null) {
+      const body = {
+        channel: opts.channel,
+        text: payload.text,
+        blocks: payload.blocks
+      };
+      if (opts.threadTs) body.thread_ts = opts.threadTs;
+      try {
+        const res = await slackCall("chat.postMessage", body);
+        if (!res.ts) {
+          throw new SlackApiError(
+            "chat.postMessage",
+            "missing ts in successful response",
+            200
+          );
+        }
+        anchorTs = res.ts;
+        opts.onAnchorPosted?.(res.ts);
+      } catch (err) {
+        throw err;
+      }
+      return;
+    }
+    try {
+      await slackCall("chat.update", {
+        channel: opts.channel,
+        ts: anchorTs,
+        text: payload.text,
+        blocks: payload.blocks
+      });
+    } catch (err) {
+      if (opts.onApiError && err instanceof SlackApiError) {
+        await opts.onApiError(err);
+        return;
+      }
+      throw err;
+    }
+  };
+}
+
+// src/progress-tools.ts
+import { randomUUID } from "crypto";
+
+// src/progress-handle.ts
+async function startProgressHandle(opts) {
+  const now = opts.now ?? (() => Date.now());
+  const setTimer = opts.setTimer ?? ((cb, ms) => setTimeout(cb, ms));
+  const clearTimer = opts.clearTimer ?? ((id) => clearTimeout(id));
+  const debounceMs = opts.debounceMs ?? 1e3;
+  const onPostTerminalUpdate = opts.onPostTerminalUpdate ?? defaultPostTerminalWarn;
+  const state = {
+    initialLabel: opts.initialLabel,
+    mode: opts.initialMode ?? "working",
+    lastChangeAt: now()
+  };
+  let lastFlushAt = 0;
+  let pendingTimer = null;
+  let inFlight = null;
+  let terminal = false;
+  async function doFlush() {
+    while (inFlight) await inFlight;
+    if (pendingTimer != null) {
+      clearTimer(pendingTimer);
+      pendingTimer = null;
+    }
+    lastFlushAt = now();
+    const promise = opts.flush(snapshotState());
+    inFlight = promise.then(
+      () => {
+        inFlight = null;
+      },
+      (err) => {
+        inFlight = null;
+        throw err;
+      }
+    );
+    await inFlight;
+  }
+  function snapshotState() {
+    return {
+      initialLabel: state.initialLabel,
+      mode: state.mode,
+      stepLabel: state.stepLabel,
+      stepNumber: state.stepNumber ? { ...state.stepNumber } : void 0,
+      detail: state.detail,
+      lastChangeAt: state.lastChangeAt,
+      terminal: state.terminal ? { ...state.terminal } : void 0
+    };
+  }
+  function applyUpdate(next) {
+    if (next.mode !== void 0) state.mode = next.mode;
+    if (next.stepLabel !== void 0) state.stepLabel = next.stepLabel;
+    if (next.stepNumber !== void 0) state.stepNumber = { ...next.stepNumber };
+    if (next.detail !== void 0) state.detail = next.detail;
+    state.lastChangeAt = now();
+  }
+  async function scheduleOrFlush() {
+    const elapsed = now() - lastFlushAt;
+    if (elapsed >= debounceMs) {
+      await doFlush();
+      return;
+    }
+    if (pendingTimer != null) return;
+    const remaining = debounceMs - elapsed;
+    pendingTimer = setTimer(() => {
+      pendingTimer = null;
+      void doFlush().catch(() => {
+      });
+    }, remaining);
+  }
+  lastFlushAt = now();
+  await opts.flush(snapshotState());
+  return {
+    snapshot: snapshotState,
+    async update(next) {
+      if (terminal) {
+        const peeked = snapshotState();
+        Object.assign(peeked, {
+          mode: next.mode ?? peeked.mode,
+          stepLabel: next.stepLabel ?? peeked.stepLabel,
+          stepNumber: next.stepNumber ?? peeked.stepNumber,
+          detail: next.detail ?? peeked.detail
+        });
+        try {
+          onPostTerminalUpdate(peeked);
+        } catch (err) {
+          console.warn(
+            "[progress-handle] onPostTerminalUpdate threw \u2014 swallowed to keep update() non-throwing:",
+            err
+          );
+        }
+        return;
+      }
+      applyUpdate(next);
+      await scheduleOrFlush();
+    },
+    async complete(summary) {
+      if (terminal) return;
+      terminal = true;
+      state.terminal = { kind: "completed", message: summary };
+      state.lastChangeAt = now();
+      await doFlush();
+    },
+    async fail(reason) {
+      if (terminal) return;
+      terminal = true;
+      state.terminal = { kind: "failed", message: reason };
+      state.lastChangeAt = now();
+      await doFlush();
+    },
+    isTerminal: () => terminal
+  };
+}
+function defaultPostTerminalWarn(state) {
+  console.warn(
+    `[progress-handle] update() called after terminal transition (${state.terminal?.kind}) \u2014 ignored.`
+  );
+}
+
+// src/progress-tools.ts
+var ProgressToolRegistry = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.toolNames = {
+      start: `${opts.prefix}_progress_start`,
+      update: `${opts.prefix}_progress_update`,
+      complete: `${opts.prefix}_progress_complete`,
+      fail: `${opts.prefix}_progress_fail`
+    };
+  }
+  handles = /* @__PURE__ */ new Map();
+  toolNames;
+  /** Tool definitions to splice into the MCP ListToolsRequest response. */
+  getDefinitions() {
+    const { surfaceDescription, startArgsSchema } = this.opts;
+    const debounceMs = this.opts.debounceMs ?? 1e3;
+    const debounceText = debounceMs === 1e3 ? "per second" : `every ${debounceMs}ms`;
+    return [
+      {
+        name: this.toolNames.start,
+        description: `Post a "still working" anchor to ${surfaceDescription} and return a progress_id. The anchor message updates in place as you call ${this.toolNames.update} \u2014 operators see one message that ticks forward instead of a flood of new ones. Always end with ${this.toolNames.complete} or ${this.toolNames.fail}; otherwise the anchor lingers as "working" until the stale-state sweep flips it. Opt-in \u2014 only call this for tasks that will take more than a few seconds.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            label: {
+              type: "string",
+              description: 'Short top-line label for the task (e.g. "diagnose vigil"). Stays constant for the lifetime of this progress anchor.'
+            },
+            initial_mode: {
+              type: "string",
+              enum: ["thinking", "working", "waiting"],
+              description: 'Initial mode emoji \u2014 defaults to "working".'
+            },
+            ...startArgsSchema.properties
+          },
+          required: ["label", ...startArgsSchema.required]
+        }
+      },
+      {
+        name: this.toolNames.update,
+        description: `Update the progress anchor in place. The state machine debounces calls to one ${surfaceDescription} API call ${debounceText}, so spamming this every step is safe \u2014 only the latest pending state will paint. Any subset of fields can be passed; omitted ones retain their previous value.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            progress_id: { type: "string", description: "The progress_id returned from start." },
+            step_label: { type: "string", description: 'Short label for the current step (e.g. "Querying CloudWatch logs").' },
+            step_current: { type: "number", description: "1-based step counter \u2014 current." },
+            step_total: { type: "number", description: "Total steps if known. Omit for open-ended progress." },
+            mode: { type: "string", enum: ["thinking", "working", "waiting"] },
+            detail: { type: "string", description: "Free-text detail line under the step label." }
+          },
+          required: ["progress_id"]
+        }
+      },
+      {
+        name: this.toolNames.complete,
+        description: `Mark the progress anchor as \u2705 completed. Flushes any pending debounced state before painting the terminal banner \u2014 the operator never sees a stale "Step N" beside the \u2705. After this, the handle is dead; further updates are no-ops.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            progress_id: { type: "string" },
+            summary: { type: "string", description: "Optional one-line summary of what was achieved." }
+          },
+          required: ["progress_id"]
+        }
+      },
+      {
+        name: this.toolNames.fail,
+        description: `Mark the progress anchor as \u274C failed. Always include a one-sentence reason \u2014 the operator can't tell *why* from emoji alone. Same flush-then-paint behaviour as complete.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            progress_id: { type: "string" },
+            reason: { type: "string", description: "One-sentence failure reason." }
+          },
+          required: ["progress_id", "reason"]
+        }
+      }
+    ];
+  }
+  /**
+   * Dispatch a CallToolRequest. Returns `undefined` if the tool name
+   * isn't one of ours (so the caller can keep walking its dispatch
+   * chain). Returns a tool result otherwise.
+   */
+  async handle(name, args) {
+    if (name === this.toolNames.start) return this.handleStart(args);
+    if (name === this.toolNames.update) return this.handleUpdate(args);
+    if (name === this.toolNames.complete) return this.handleComplete(args);
+    if (name === this.toolNames.fail) return this.handleFail(args);
+    return void 0;
+  }
+  /** Live count of in-flight handles. Exposed for tests + diagnostics. */
+  size() {
+    return this.handles.size;
+  }
+  async handleStart(args) {
+    const label = typeof args.label === "string" ? args.label : null;
+    if (!label) return errResult(`${this.toolNames.start}: 'label' must be a non-empty string`);
+    if ("initial_mode" in args && !isMode(args.initial_mode)) {
+      return errResult(
+        `${this.toolNames.start}: 'initial_mode' must be one of 'thinking', 'working', or 'waiting'`
+      );
+    }
+    for (const k of this.opts.startArgsSchema.required) {
+      if (typeof args[k] !== "string" || args[k].length === 0) {
+        return errResult(`${this.toolNames.start}: '${k}' must be a non-empty string`);
+      }
+    }
+    const initialMode = isMode(args.initial_mode) ? args.initial_mode : void 0;
+    const progressId = randomUUID();
+    try {
+      const flush = this.opts.createFlush(args);
+      const handle = await startProgressHandle({
+        initialLabel: label,
+        initialMode,
+        flush,
+        debounceMs: this.opts.debounceMs ?? 1e3
+      });
+      this.handles.set(progressId, handle);
+      return okResult(JSON.stringify({ progress_id: progressId }));
+    } catch (err) {
+      return errResult(`${this.toolNames.start} failed: ${err.message ?? String(err)}`);
+    }
+  }
+  async handleUpdate(args) {
+    const id = typeof args.progress_id === "string" ? args.progress_id : null;
+    if (!id) return errResult(`${this.toolNames.update}: 'progress_id' must be a string`);
+    const handle = this.handles.get(id);
+    if (!handle) return errResult(`${this.toolNames.update}: unknown progress_id (already terminated, or never started)`);
+    if ("mode" in args && !isMode(args.mode)) {
+      return errResult(
+        `${this.toolNames.update}: 'mode' must be one of 'thinking', 'working', or 'waiting'`
+      );
+    }
+    if (typeof args.step_total === "number" && typeof args.step_current !== "number") {
+      return errResult(
+        `${this.toolNames.update}: 'step_total' requires 'step_current'`
+      );
+    }
+    const next = {};
+    if (typeof args.step_label === "string") next.stepLabel = args.step_label;
+    if (typeof args.step_current === "number") {
+      next.stepNumber = {
+        current: args.step_current,
+        ...typeof args.step_total === "number" ? { total: args.step_total } : {}
+      };
+    }
+    if (isMode(args.mode)) next.mode = args.mode;
+    if (typeof args.detail === "string") next.detail = args.detail;
+    try {
+      await handle.update(next);
+      return okResult("ok");
+    } catch (err) {
+      return errResult(`${this.toolNames.update} failed: ${err.message ?? String(err)}`);
+    }
+  }
+  async handleComplete(args) {
+    const id = typeof args.progress_id === "string" ? args.progress_id : null;
+    if (!id) return errResult(`${this.toolNames.complete}: 'progress_id' must be a string`);
+    const handle = this.handles.get(id);
+    if (!handle) return errResult(`${this.toolNames.complete}: unknown progress_id`);
+    const summary = typeof args.summary === "string" ? args.summary : void 0;
+    try {
+      await handle.complete(summary);
+      this.handles.delete(id);
+      return okResult("ok");
+    } catch (err) {
+      return errResult(`${this.toolNames.complete} failed: ${err.message ?? String(err)}`);
+    }
+  }
+  async handleFail(args) {
+    const id = typeof args.progress_id === "string" ? args.progress_id : null;
+    if (!id) return errResult(`${this.toolNames.fail}: 'progress_id' must be a string`);
+    const reason = typeof args.reason === "string" ? args.reason : null;
+    if (!reason) return errResult(`${this.toolNames.fail}: 'reason' must be a non-empty string`);
+    const handle = this.handles.get(id);
+    if (!handle) return errResult(`${this.toolNames.fail}: unknown progress_id`);
+    try {
+      await handle.fail(reason);
+      this.handles.delete(id);
+      return okResult("ok");
+    } catch (err) {
+      return errResult(`${this.toolNames.fail} failed: ${err.message ?? String(err)}`);
+    }
+  }
+};
+function okResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function errResult(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+function isMode(value) {
+  return value === "thinking" || value === "working" || value === "waiting";
+}
+
 // ../../node_modules/.pnpm/@modelcontextprotocol+sdk@1.27.1_zod@3.25.76/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 import process2 from "process";
 
@@ -14436,7 +14892,7 @@ import {
 } from "fs";
 import { basename, join as join2, resolve as resolve2 } from "path";
 import { homedir as homedir2 } from "os";
-import { createHash, randomUUID } from "crypto";
+import { createHash, randomUUID as randomUUID2 } from "crypto";
 
 // src/slack-thread-store.ts
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -15754,7 +16210,7 @@ async function handleSlashCommandEnvelope(payload) {
           ...payload.thread_ts ? { thread_ts: payload.thread_ts } : {}
         }
       };
-      const tmpPath = `${flagPath}.${process.pid}.${randomUUID()}.tmp`;
+      const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
       writeFileSync2(tmpPath, JSON.stringify(flag) + "\n", "utf8");
       renameSync(tmpPath, flagPath);
       process.stderr.write(
@@ -15862,7 +16318,7 @@ async function handleRestartCommand(opts) {
         message_ts: opts.ts
       }
     };
-    const tmpPath = `${flagPath}.${process.pid}.${randomUUID()}.tmp`;
+    const tmpPath = `${flagPath}.${process.pid}.${randomUUID2()}.tmp`;
     writeFileSync2(tmpPath, JSON.stringify(flag) + "\n", "utf8");
     renameSync(tmpPath, flagPath);
     process.stderr.write(
@@ -16011,6 +16467,7 @@ var mcp = new Server(
       // 2048 chars, so anything appended late silently disappears.
       "CRITICAL: every response to a Slack <channel> tag MUST go through slack.reply. Text in your session WITHOUT a slack.reply call never reaches the user \u2014 the message dies inside the agent process.",
       'Messages from Slack arrive as <channel source="slack" user="<slack-id>" user_name="<display-name>" channel="..." thread_ts="...">. Pass channel + thread_ts from the tag to slack.reply; always include thread_ts on threaded replies.',
+      "Long task (3+ tool calls or >5s)? slack_progress_start (channel + thread_ts), slack_progress_update between steps, slack_progress_complete/_fail to close. One anchor edits in place; avoids thread spam. Not for one-shots.",
       selfIdentityInstruction,
       "Inbound attachments: <channel> `files` is a JSON-serialised array \u2014 JSON.parse it. If an entry has `path`, the image is already downloaded \u2014 Read it directly, do NOT call slack.download_attachment. Use that tool only for entries with `file_id` but NO `path` (PDF, docx, csv): pass file_id + channel verbatim, then Read the returned path. Single-image messages also get a top-level `image_path`. Don't surface internal file-handling errors that don't affect the answer.",
       "Address users by user_name, never by raw user ID. In multi-participant threads the CURRENT speaker is the one on the latest <channel> tag.",
@@ -16021,8 +16478,31 @@ var mcp = new Server(
     ].join(" ")
   }
 );
+var progressRegistry = new ProgressToolRegistry({
+  prefix: "slack",
+  surfaceDescription: "a Slack thread",
+  startArgsSchema: {
+    properties: {
+      channel: {
+        type: "string",
+        description: "Slack channel id (from the `channel` attribute on the inbound <channel> tag)."
+      },
+      thread_ts: {
+        type: "string",
+        description: "Thread `ts` so the anchor lands in the same thread as the request (from the `thread_ts` attribute on the inbound <channel> tag). Omit to post at channel-root."
+      }
+    },
+    required: ["channel"]
+  },
+  createFlush: (args) => createSlackProgressFlush({
+    botToken: BOT_TOKEN,
+    channel: args.channel,
+    threadTs: typeof args.thread_ts === "string" ? args.thread_ts : void 0
+  })
+});
 mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
   tools: [
+    ...progressRegistry.getDefinitions(),
     {
       name: "slack.reply",
       description: "Send a message back to a Slack channel or thread",
@@ -16221,6 +16701,8 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
 }));
 mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
   const { name, arguments: args } = req.params;
+  const progressResult = await progressRegistry.handle(name, args ?? {});
+  if (progressResult !== void 0) return progressResult;
   if (name === "slack.reply") {
     const { channel, text, thread_ts } = args;
     if (channel && thread_ts) {
@@ -16757,15 +17239,15 @@ async function handleSendStructured(args) {
   const { validateSlackBlocks: validateSlackBlocks2 } = runtime;
   const { channel, blocks, text, thread_ts, interactive } = args;
   if (typeof channel !== "string" || !channel) {
-    return errResult("channel is required");
+    return errResult2("channel is required");
   }
   if (typeof text !== "string" || !text) {
-    return errResult("text is required (used as fallback for push notifications and unfurls)");
+    return errResult2("text is required (used as fallback for push notifications and unfurls)");
   }
   noteThreadActivity(channel, thread_ts);
   const validation = validateSlackBlocks2(blocks);
   if (!validation.ok) {
-    return errResult(`Invalid blocks: ${validation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
+    return errResult2(`Invalid blocks: ${validation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
   }
   let effectiveBlocks = blocks;
   let ratingCallbackId = null;
@@ -16773,13 +17255,13 @@ async function handleSendStructured(args) {
   let ratingTokenised = [];
   if (interactive) {
     if (interactive.type !== "rate_run") {
-      return errResult(`Unsupported interactive.type '${interactive.type}'. Supported: rate_run.`);
+      return errResult2(`Unsupported interactive.type '${interactive.type}'. Supported: rate_run.`);
     }
     if (typeof interactive.run_id !== "string" || !interactive.run_id) {
-      return errResult("interactive.run_id is required when interactive is set");
+      return errResult2("interactive.run_id is required when interactive is set");
     }
     if (!interactiveHostAvailable()) {
-      return errResult(
+      return errResult2(
         "interactive=rate_run requires Block Kit plus host MCP wiring (AGT_HOST, AGT_API_KEY, AGT_AGENT_ID)."
       );
     }
@@ -16810,7 +17292,7 @@ async function handleSendStructured(args) {
     effectiveBlocks = [...blocks, ratingBlock];
     const finalValidation = runtime.validateSlackBlocks(effectiveBlocks);
     if (!finalValidation.ok) {
-      return errResult(
+      return errResult2(
         `Invalid blocks (after appending rating row): ${finalValidation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`
       );
     }
@@ -16831,7 +17313,7 @@ async function handleSendStructured(args) {
         kindData: { run_id: interactive.run_id, scale }
       });
     } catch (err) {
-      return errResult(`Failed to register rating row: ${err.message}`);
+      return errResult2(`Failed to register rating row: ${err.message}`);
     }
   }
   const result = await postSlackMessageWithTs({
@@ -16841,7 +17323,7 @@ async function handleSendStructured(args) {
     ...thread_ts ? { thread_ts } : {}
   });
   if (!result.ok || !result.ts) {
-    return errResult(`Slack chat.postMessage failed: ${result.error ?? "unknown"}`);
+    return errResult2(`Slack chat.postMessage failed: ${result.error ?? "unknown"}`);
   }
   if (ratingCallbackId) {
     try {
@@ -16896,17 +17378,17 @@ async function handleSendStructured(args) {
 }
 async function handleAskUser(args) {
   if (!askUserToolAvailable()) {
-    return errResult("slack.ask_user is disabled or the host MCP is missing AGT_HOST/AGT_API_KEY/AGT_AGENT_ID env wiring.");
+    return errResult2("slack.ask_user is disabled or the host MCP is missing AGT_HOST/AGT_API_KEY/AGT_AGENT_ID env wiring.");
   }
   const { randomUUID: rndUUID } = await import("crypto");
   const runtime = await Promise.resolve().then(() => (init_slack_block_kit_runtime(), slack_block_kit_runtime_exports));
   const { validateAskUserOptions: validateAskUserOptions2, buildAskUserBlocks: buildAskUserBlocks2 } = runtime;
   const { channel, question, options, timeout_seconds, thread_ts } = args;
-  if (typeof channel !== "string" || !channel) return errResult("channel is required");
-  if (typeof question !== "string" || !question) return errResult("question is required");
+  if (typeof channel !== "string" || !channel) return errResult2("channel is required");
+  if (typeof question !== "string" || !question) return errResult2("question is required");
   const optsValidation = validateAskUserOptions2(options);
   if (!optsValidation.ok) {
-    return errResult(`Invalid options: ${optsValidation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
+    return errResult2(`Invalid options: ${optsValidation.errors.map((e) => `${e.path}: ${e.message}`).join("; ")}`);
   }
   const requestedTimeout = typeof timeout_seconds === "number" ? timeout_seconds : 300;
   const timeoutSec = Math.max(10, Math.min(3600, requestedTimeout));
@@ -16939,7 +17421,7 @@ async function handleAskUser(args) {
       expiresAt
     });
   } catch (err) {
-    return errResult(`Failed to register pending interaction: ${err.message}`);
+    return errResult2(`Failed to register pending interaction: ${err.message}`);
   }
   const slackResult = await postSlackMessageWithTs({
     channel,
@@ -16949,7 +17431,7 @@ async function handleAskUser(args) {
     ...thread_ts ? { thread_ts } : {}
   });
   if (!slackResult.ok || !slackResult.ts) {
-    return errResult(`Slack chat.postMessage failed: ${slackResult.error ?? "unknown"}`);
+    return errResult2(`Slack chat.postMessage failed: ${slackResult.error ?? "unknown"}`);
   }
   try {
     await runtime.updatePendingInteractionMessageTs(cfg, callbackId, slackResult.ts);
@@ -16994,7 +17476,7 @@ async function handleAskUser(args) {
     ]
   };
 }
-function errResult(text) {
+function errResult2(text) {
   return { content: [{ type: "text", text }], isError: true };
 }
 var MAX_INBOUND_FILE_BYTES = 25 * 1024 * 1024;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@integrity-labs/agt-cli",
-  "version": "0.20.6",
+  "version": "0.20.8",
   "description": "Augmented Team CLI — agent provisioning and management",
   "type": "module",
   "engines": {