@slock-ai/daemon 0.48.0 → 0.49.0-play.20260515203416

package/dist/chat-bridge.js

@@ -1,219 +1,13 @@
 #!/usr/bin/env node
 import {
-  DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS,
   buildFetchDispatcher,
-  executeJsonRequest,
-  executeResponseRequest,
-  logger,
-  resolveSlockHomePath
-} from "./chunk-B7XIMLOT.js";
+  executeJsonRequest
+} from "./chunk-KNMCE6WB.js";
 
 // src/chat-bridge.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z2 } from "zod";
-
-// src/deprecatedMcpShim.ts
 import { z } from "zod";
-var DEPRECATED_MCP_SHIM_HEADER = "This MCP tool is deprecated. Use slock CLI instead.";
-var sendMessageDeprecatedSchema = {
-  target: z.string().describe("Deprecated target argument."),
-  content: z.string().optional().describe("Deprecated content argument."),
-  attachment_ids: z.array(z.string()).optional().describe("Deprecated attachment ids.")
-};
-var checkMessagesDeprecatedSchema = {};
-var readHistoryDeprecatedSchema = {
-  channel: z.string().describe("Deprecated channel argument."),
-  limit: z.number().optional().describe("Deprecated limit argument."),
-  around: z.union([z.string(), z.number()]).optional().describe("Deprecated around argument."),
-  before: z.number().optional().describe("Deprecated before argument."),
-  after: z.number().optional().describe("Deprecated after argument.")
-};
-var searchMessagesDeprecatedSchema = {
-  query: z.string().describe("Deprecated query argument."),
-  limit: z.number().optional().describe("Deprecated limit argument.")
-};
-var listTasksDeprecatedSchema = {
-  channel: z.string().describe("Deprecated channel argument."),
-  status: z.enum(["all", "todo", "in_progress", "in_review", "done", "closed"]).optional().describe("Deprecated status argument.")
-};
-var claimTasksDeprecatedSchema = {
-  channel: z.string().describe("Deprecated channel argument."),
-  task_numbers: z.array(z.number()).optional().describe("Deprecated task numbers."),
-  message_ids: z.array(z.string()).optional().describe("Deprecated message ids.")
-};
-var unclaimTaskDeprecatedSchema = {
-  channel: z.string().describe("Deprecated channel argument."),
-  task_number: z.number().describe("Deprecated task number.")
-};
-var updateTaskStatusDeprecatedSchema = {
-  channel: z.string().describe("Deprecated channel argument."),
-  task_number: z.number().describe("Deprecated task number."),
-  status: z.enum(["todo", "in_progress", "in_review", "done", "closed"]).describe("Deprecated status argument.")
-};
-var DEPRECATED_MCP_TOOL_DEFINITIONS = [
-  {
-    toolName: "send_message",
-    description: `${DEPRECATED_MCP_SHIM_HEADER}
-Use \`slock message send\` and pass the message body on stdin.`,
-    schema: sendMessageDeprecatedSchema,
-    cliExamples: [
-      "slock message send --target '#channel-or-dm' <<'EOF2'",
-      "message body",
-      "EOF2"
-    ]
-  },
-  {
-    toolName: "check_messages",
-    description: `${DEPRECATED_MCP_SHIM_HEADER}
-Use \`slock message check\`.`,
-    schema: checkMessagesDeprecatedSchema,
-    cliExamples: [
-      "slock message check"
-    ]
-  },
-  {
-    toolName: "read_history",
-    description: `${DEPRECATED_MCP_SHIM_HEADER}
-Use \`slock message read --channel ...\`.`,
-    schema: readHistoryDeprecatedSchema,
-    cliExamples: [
-      "slock message read --channel '#channel'",
-      "slock message read --channel 'dm:@peer'",
-      "slock message read --channel '#channel:threadId'"
-    ]
-  },
-  {
-    toolName: "search_messages",
-    description: `${DEPRECATED_MCP_SHIM_HEADER}
-Use \`slock message search --query ...\`.`,
-    schema: searchMessagesDeprecatedSchema,
-    cliExamples: [
-      "slock message search --query 'keyword'"
-    ]
-  },
-  {
-    toolName: "list_tasks",
-    description: `${DEPRECATED_MCP_SHIM_HEADER}
-Use \`slock task list --channel ...\`.`,
-    schema: listTasksDeprecatedSchema,
-    cliExamples: [
-      "slock task list --channel '#channel'"
-    ]
-  },
-  {
-    toolName: "claim_tasks",
-    description: `${DEPRECATED_MCP_SHIM_HEADER}
-Use \`slock task claim ...\`.`,
-    schema: claimTasksDeprecatedSchema,
-    cliExamples: [
-      "slock task claim --channel '#channel' --number 123",
-      "slock task claim --channel '#channel' --message-id <messageId>"
-    ]
-  },
-  {
-    toolName: "unclaim_task",
-    description: `${DEPRECATED_MCP_SHIM_HEADER}
-Use \`slock task unclaim ...\`.`,
-    schema: unclaimTaskDeprecatedSchema,
-    cliExamples: [
-      "slock task unclaim --channel '#channel' --number 123"
-    ]
-  },
-  {
-    toolName: "update_task_status",
-    description: `${DEPRECATED_MCP_SHIM_HEADER}
-Use \`slock task update ...\`.`,
-    schema: updateTaskStatusDeprecatedSchema,
-    cliExamples: [
-      "slock task update --channel '#channel' --number 123 --status in_review"
-    ]
-  }
-];
-function buildDeprecatedMcpToolErrorText(tool) {
-  return [
-    DEPRECATED_MCP_SHIM_HEADER,
-    "",
-    ...tool.cliExamples
-  ].join("\n");
-}
-
-// src/historyFormatting.ts
-function toLocalHistoryTime(iso) {
-  const d = new Date(iso);
-  if (Number.isNaN(d.getTime())) return iso;
-  const pad = (n) => String(n).padStart(2, "0");
-  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
-}
-function formatHistorySenderHandle(message) {
-  return message.senderDescription ? `@${message.senderName} \u2014 ${message.senderDescription}` : `@${message.senderName}`;
-}
-function formatHistoryMessageLine(message) {
-  const headerParts = [
-    `seq=${message.seq}`,
-    `msg=${message.id || "-"}`,
-    `time=${message.createdAt ? toLocalHistoryTime(message.createdAt) : "-"}`
-  ];
-  if (message.senderType) {
-    headerParts.push(`type=${message.senderType}`);
-  }
-  if (message.threadId) {
-    headerParts.push(`threadId=${message.threadId}`);
-  }
-  if ((message.replyCount ?? 0) > 0) {
-    headerParts.push(`replyCount=${message.replyCount}`);
-  }
-  const attachSuffix = message.attachments?.length ? ` [${message.attachments.length} attachment${message.attachments.length > 1 ? "s" : ""}: ${message.attachments.map((attachment) => `${attachment.filename} (id:${attachment.id})`).join(", ")} \u2014 use view_file to download]` : "";
-  const taskSuffix = message.taskStatus ? ` [task #${message.taskNumber} status=${message.taskStatus}${message.taskAssigneeId ? ` assignee=${message.taskAssigneeType}:${message.taskAssigneeId}` : ""}]` : "";
-  return `[${headerParts.join(" ")}] ${formatHistorySenderHandle(message)}: ${message.content}${attachSuffix}${taskSuffix}`;
-}
-
-// src/chatBridgeSendRequest.ts
-import { randomUUID } from "crypto";
-async function executeRetrySafeSendRequest(url, buildInit, {
-  fetchImpl,
-  target,
-  timeoutMs = DEFAULT_CHAT_BRIDGE_TOOL_TIMEOUT_MS,
-  now = () => Date.now(),
-  warn = (message) => logger.warn(message),
-  idempotencyKey = randomUUID()
-}) {
-  let lastError;
-  for (let attempt = 1; attempt <= 2; attempt += 1) {
-    try {
-      const result = await executeJsonRequest(
-        url,
-        buildInit(idempotencyKey),
-        {
-          toolName: "send_message",
-          target,
-          timeoutMs,
-          fetchImpl,
-          now,
-          warn
-        }
-      );
-      return {
-        ...result,
-        idempotencyKey,
-        attempts: attempt
-      };
-    } catch (error) {
-      lastError = error;
-      if (attempt === 2) break;
-      warn(
-        `[ChatBridgeRetry] tool=send_message target=${target} attempt=${attempt + 1} reason=${describeRetryReason(error)}`
-      );
-    }
-  }
-  throw lastError;
-}
-function describeRetryReason(error) {
-  if (error && typeof error === "object" && "name" in error && error.name === "ChatBridgeToolTimeoutError") {
-    return error.message;
-  }
-  return error instanceof Error ? `${error.name}: ${error.message}` : String(error);
-}
 
 // src/perfAttribution.ts
 var PERF_CALLER_CONTEXT_HEADER = "X-Perf-Caller-Context";
@@ -232,30 +26,16 @@ function buildChatBridgeCommonHeaders(authToken2, { includeContentType = true }
 }
 
 // src/chat-bridge.ts
-var MAX_UPLOAD_FILE_BYTES = 50 * 1024 * 1024;
-var MAX_UPLOAD_FILE_LABEL = "50MB";
-function toLocalTime(iso) {
-  const d = new Date(iso);
-  if (isNaN(d.getTime())) return iso;
-  const pad = (n) => String(n).padStart(2, "0");
-  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
-}
 var args = process.argv.slice(2);
 var agentId = "";
 var serverUrl = "http://localhost:3001";
 var authToken = "";
-var runtime = "unknown";
 var launchId = "";
-var deprecatedShimMode = false;
-var runtimeActionsOnlyMode = false;
 for (let i = 0; i < args.length; i++) {
   if (args[i] === "--agent-id" && args[i + 1]) agentId = args[++i];
   if (args[i] === "--server-url" && args[i + 1]) serverUrl = args[++i];
   if (args[i] === "--auth-token" && args[i + 1]) authToken = args[++i];
-  if (args[i] === "--runtime" && args[i + 1]) runtime = args[++i];
   if (args[i] === "--launch-id" && args[i + 1]) launchId = args[++i];
-  if (args[i] === "--deprecated-shim") deprecatedShimMode = true;
-  if (args[i] === "--runtime-actions-only") runtimeActionsOnlyMode = true;
 }
 if (!agentId) {
   console.error("Missing --agent-id");
@@ -271,234 +51,16 @@ function bridgeFetch(url, init = {}) {
   const requestInit = dispatcher ? { ...init, dispatcher } : init;
   return fetch(url, requestInit);
 }
-var RECENT_DELIVERY_CACHE_LIMIT = 5e3;
-var deliveredMessageKeys = /* @__PURE__ */ new Set();
-var deliveredMessageOrder = [];
-function messageDeliveryKey(message) {
-  if (message.seq) return `seq:${message.seq}`;
-  if (message.message_id) return `msg:${message.message_id}`;
-  return null;
-}
-function rememberDeliveredMessages(messages) {
-  const unseen = [];
-  for (const message of messages) {
-    const key = messageDeliveryKey(message);
-    if (!key) {
-      unseen.push(message);
-      continue;
-    }
-    if (deliveredMessageKeys.has(key)) {
-      continue;
-    }
-    deliveredMessageKeys.add(key);
-    deliveredMessageOrder.push(key);
-    unseen.push(message);
-  }
-  while (deliveredMessageOrder.length > RECENT_DELIVERY_CACHE_LIMIT) {
-    const evicted = deliveredMessageOrder.shift();
-    if (evicted) deliveredMessageKeys.delete(evicted);
-  }
-  return unseen;
-}
-async function acknowledgeReceivedMessages(messages) {
-  const seqs = [...new Set(
-    messages.map((message) => message.seq).filter((seq) => typeof seq === "number" && Number.isInteger(seq) && seq > 0)
-  )];
-  if (seqs.length === 0) return;
-  try {
-    const res = await bridgeFetch(`${serverUrl}/internal/agent/${agentId}/receive-ack`, {
-      method: "POST",
-      headers: commonHeaders,
-      body: JSON.stringify({ seqs })
-    });
-    if (!res.ok) {
-      console.warn(`[chat-bridge] receive-ack failed (${res.status}) for agent ${agentId}; delivery will replay on the next poll`);
-    }
-  } catch (err) {
-    console.warn(
-      `[chat-bridge] receive-ack errored for agent ${agentId}; delivery will replay on the next poll: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-}
-function formatAttachmentSuffix(attachments) {
-  if (!attachments?.length) return "";
-  return ` [${attachments.length} attachment${attachments.length > 1 ? "s" : ""}: ${attachments.map((a) => `${a.filename} (id:${a.id})`).join(", ")} \u2014 use view_file to download]`;
-}
-function guessMimeTypeFromFilename(filename) {
-  const ext = filename.includes(".") ? filename.slice(filename.lastIndexOf(".")).toLowerCase() : "";
-  const mimeMap = {
-    ".jpg": "image/jpeg",
-    ".jpeg": "image/jpeg",
-    ".png": "image/png",
-    ".gif": "image/gif",
-    ".webp": "image/webp",
-    ".pdf": "application/pdf",
-    ".txt": "text/plain",
-    ".md": "text/markdown",
-    ".json": "application/json",
-    ".csv": "text/csv",
-    ".zip": "application/zip",
-    ".tar": "application/x-tar",
-    ".gz": "application/gzip",
-    ".mp3": "audio/mpeg",
-    ".wav": "audio/wav",
-    ".mp4": "video/mp4",
-    ".mov": "video/quicktime",
-    ".doc": "application/msword",
-    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    ".xls": "application/vnd.ms-excel",
-    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    ".ppt": "application/vnd.ms-powerpoint",
-    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
-  };
-  return mimeMap[ext] || "application/octet-stream";
-}
-function parseFilenameFromContentDisposition(contentDisposition) {
-  if (!contentDisposition) return null;
-  const utf8Match = contentDisposition.match(/filename\*\s*=\s*UTF-8''([^;]+)/i);
-  if (utf8Match?.[1]) return decodeURIComponent(utf8Match[1]);
-  const plainMatch = contentDisposition.match(/filename\s*=\s*"([^"]+)"/i) || contentDisposition.match(/filename\s*=\s*([^;]+)/i);
-  return plainMatch?.[1] ? plainMatch[1].trim() : null;
-}
-function extensionForContentType(contentType) {
-  const normalized = contentType.split(";")[0]?.trim().toLowerCase();
-  const extMap = {
-    "image/jpeg": ".jpg",
-    "image/png": ".png",
-    "image/gif": ".gif",
-    "image/webp": ".webp",
-    "application/pdf": ".pdf",
-    "text/plain": ".txt",
-    "text/markdown": ".md",
-    "application/json": ".json",
-    "text/csv": ".csv",
-    "application/zip": ".zip",
-    "application/x-tar": ".tar",
-    "application/gzip": ".gz",
-    "audio/mpeg": ".mp3",
-    "audio/wav": ".wav",
-    "video/mp4": ".mp4",
-    "video/quicktime": ".mov"
-  };
-  return extMap[normalized] || ".bin";
-}
-function formatTarget(m) {
-  if (m.channel_type === "thread" && m.parent_channel_name) {
-    const shortId = m.channel_name.startsWith("thread-") ? m.channel_name.slice(7) : m.channel_name;
-    if (m.parent_channel_type === "dm") {
-      return `dm:@${m.parent_channel_name}:${shortId}`;
-    }
-    return `#${m.parent_channel_name}:${shortId}`;
-  }
-  if (m.channel_type === "dm") {
-    return `dm:@${m.channel_name}`;
-  }
-  return `#${m.channel_name}`;
-}
-function formatSearchTarget(result) {
-  if (result.channelType === "thread") {
-    const shortId = typeof result.channelName === "string" && result.channelName.startsWith("thread-") ? result.channelName.slice(7) : typeof result.threadId === "string" && result.threadId ? result.threadId.slice(0, 8) : result.channelName;
-    if (result.parentChannelType === "dm") {
-      return `dm:@${result.parentChannelName}:${shortId}`;
-    }
-    return `#${result.parentChannelName}:${shortId}`;
-  }
-  if (result.channelType === "dm") {
-    return `dm:@${result.channelName}`;
-  }
-  return `#${result.channelName}`;
-}
-function formatSenderHandle(message) {
-  const senderName = message.sender_name ?? message.senderName ?? "unknown";
-  const senderDescription = message.sender_description ?? message.senderDescription ?? null;
-  return senderDescription ? `@${senderName} \u2014 ${senderDescription}` : `@${senderName}`;
-}
-function formatRuntimeContext(ctx) {
-  if (!ctx) return "";
-  const lines = [
-    "### Current Runtime",
-    "Authoritative context for this agent process. Do not infer computer identity from hostname or cwd when this section is present."
-  ];
-  if (ctx.agentId) lines.push(`- Agent ID: ${ctx.agentId}`);
-  if (ctx.serverId) lines.push(`- Server ID: ${ctx.serverId}`);
-  if (ctx.machineName || ctx.machineId) {
-    const label = ctx.machineName && ctx.machineId ? `${ctx.machineName} (${ctx.machineId})` : ctx.machineName || ctx.machineId;
-    lines.push(`- Computer: ${label}`);
-  }
-  if (ctx.machineHostname) lines.push(`- Hostname: ${ctx.machineHostname}`);
-  if (ctx.machineOs) lines.push(`- OS: ${ctx.machineOs}`);
-  if (ctx.daemonVersion) lines.push(`- Daemon: v${ctx.daemonVersion}`);
-  if (ctx.workspacePath) lines.push(`- Workspace: ${ctx.workspacePath}`);
-  return lines.length > 2 ? `${lines.join("\n")}
-
-` : "";
-}
-async function listServerChannels() {
-  const { response: res, data } = await executeJsonRequest(
-    `${serverUrl}/internal/agent/${agentId}/server`,
-    { method: "GET", headers: commonHeaders },
-    {
-      toolName: "list_server.channels",
-      fetchImpl: bridgeFetch
-    }
-  );
-  if (!res.ok) {
-    throw new Error("Failed to load server channels");
-  }
-  return data.channels ?? [];
-}
-function parseRegularChannelTarget(target) {
-  if (!target.startsWith("#")) return null;
-  if (target.includes(":")) return null;
-  const name = target.slice(1).trim();
-  return name.length > 0 ? name : null;
-}
-async function resolveRegularChannelTarget(target) {
-  const channelName = parseRegularChannelTarget(target);
-  if (!channelName) {
-    throw new Error("Target must be a regular channel in the form '#channel-name'");
-  }
-  const channels = await listServerChannels();
-  const channel = channels.find((candidate) => candidate.name === channelName);
-  if (!channel) {
-    throw new Error(`Channel not found: ${target}`);
-  }
-  return channel;
-}
 var server = new McpServer({
   name: "chat",
   version: "1.0.0"
 });
-function logDeprecatedShimInvocation(tool) {
-  logger.warn(
-    `[ChatBridgeDeprecatedShim] tool=${tool.toolName} runtime=${runtime} agent_id=${agentId} outcome=deprecated`
-  );
-}
-function registerDeprecatedTool(tool) {
-  server.tool(
-    tool.toolName,
-    tool.description,
-    tool.schema,
-    async () => {
-      logDeprecatedShimInvocation(tool);
-      return {
-        isError: true,
-        content: [{ type: "text", text: buildDeprecatedMcpToolErrorText(tool) }]
-      };
-    }
-  );
-}
-if (deprecatedShimMode && !runtimeActionsOnlyMode) {
-  for (const tool of DEPRECATED_MCP_TOOL_DEFINITIONS) {
-    registerDeprecatedTool(tool);
-  }
-}
 var RUNTIME_PROFILE_MIGRATION_DONE_TOOL_NAME = "runtime_profile_migration_done";
 server.tool(
   RUNTIME_PROFILE_MIGRATION_DONE_TOOL_NAME,
   "Complete the current Runtime Profile migration. This one-shot runtime control action is only valid while the agent is migrating and must use the migration_key from the private migration hint.",
   {
-    migration_key: z2.string().describe("The migration key from the Runtime Profile migration hint")
+    migration_key: z.string().describe("The migration key from the Runtime Profile migration hint")
   },
   async ({ migration_key }) => {
     const key = migration_key.trim();
@@ -538,960 +100,5 @@ server.tool(
     }
   }
 );
-if (!deprecatedShimMode && !runtimeActionsOnlyMode) {
-  let formatMessages = function(messages) {
-    return messages.map((m) => {
-      const target = formatTarget(m);
-      const msgId = m.message_id ? m.message_id.slice(0, 8) : "-";
-      const time = m.timestamp ? toLocalTime(m.timestamp) : "-";
-      const senderType = ` type=${m.sender_type}`;
-      const renderedContent = m.content;
-      const attachSuffix = formatAttachmentSuffix(m.attachments);
-      const taskSuffix = m.task_status ? ` [task #${m.task_number} status=${m.task_status}${m.task_assignee_id ? ` assignee=${m.task_assignee_type}:${m.task_assignee_id}` : ""}]` : "";
-      return `[target=${target} msg=${msgId} time=${time}${senderType}] ${formatSenderHandle(m)}: ${renderedContent}${attachSuffix}${taskSuffix}`;
-    }).join("\n");
-  }, formatReminder = function(r) {
-    const fireLocal = toLocalTime(r.fireAt);
-    const ref = r.msgRef ? ` ref=${r.msgRef}` : "";
-    const repeat = r.recurrence ? ` repeat=${r.recurrence.description}` : "";
-    return `#${r.reminderId.slice(0, 8)} [${r.status}] fires=${fireLocal} "${r.title}"${ref}${repeat}`;
-  };
-  formatMessages2 = formatMessages, formatReminder2 = formatReminder;
-  server.tool(
-    "send_message",
-    "Send a message to a channel, DM, or thread. Use the target value from received messages to reply. Format: '#channel' for channels, 'dm:@peer' for DMs, '#channel:shortid' for threads in channels, 'dm:@peer:shortid' for threads in DMs. To start a NEW DM, use 'dm:@person-name'.",
-    {
-      target: z2.string().describe(
-        "Where to send. Reuse the identifier from received messages. Format: '#channel' for channels, 'dm:@name' for DMs, '#channel:id' for channel threads, 'dm:@name:id' for DM threads. Examples: '#general', 'dm:@richard', '#general:abcd1234', 'dm:@richard:abcd1234'."
-      ),
-      content: z2.string().describe("The message content"),
-      attachment_ids: z2.array(z2.string()).optional().describe("Optional attachment IDs from upload_file to include with the message")
-    },
-    async ({ target, content, attachment_ids }) => {
-      try {
-        const { response: res, data } = await executeRetrySafeSendRequest(
-          `${serverUrl}/internal/agent/${agentId}/send`,
-          (idempotencyKey) => ({
-            method: "POST",
-            headers: commonHeaders,
-            body: JSON.stringify({ target, content, attachmentIds: attachment_ids, idempotencyKey })
-          }),
-          {
-            target,
-            fetchImpl: bridgeFetch
-          }
-        );
-        if (!res.ok) {
-          return {
-            content: [
-              { type: "text", text: `Error: ${data.error}` }
-            ]
-          };
-        }
-        const shortId = data.messageId ? data.messageId.slice(0, 8) : null;
-        const replyHint = shortId ? ` (to reply in this message's thread, use target "${target.includes(":") ? target : target + ":" + shortId}")` : "";
-        let unreadSection = "";
-        if (data.recentUnread && data.recentUnread.length > 0) {
-          await acknowledgeReceivedMessages(data.recentUnread);
-          const unreadToShow = rememberDeliveredMessages(data.recentUnread);
-          if (unreadToShow.length > 0) {
-            unreadSection = `
-
---- New messages you may have missed ---
-${formatMessages(unreadToShow)}`;
-          }
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Message sent to ${target}. Message ID: ${data.messageId}${replyHint}${unreadSection}`
-            }
-          ]
-        };
-      } catch (err) {
-        return {
-          isError: true,
-          content: [{ type: "text", text: `Error: ${err.message}` }]
-        };
-      }
-    }
-  );
-  server.tool(
-    "upload_file",
-    `Upload a file to attach to a message. Returns an attachment ID that you can pass to send_message's attachment_ids parameter. Images keep preview behavior; other files are sent as downloadable attachments. Max size: ${MAX_UPLOAD_FILE_LABEL}. Video files are downloadable attachments and are not parsed by agents. Large PDFs may need to be downloaded and inspected in smaller chunks.`,
-    {
-      file_path: z2.string().describe("Absolute path to the file on your local filesystem"),
-      channel: z2.string().describe("The channel target where this file will be used (e.g. '#general', 'dm:@richard')")
-    },
-    async ({ file_path, channel }) => {
-      try {
-        const fs = await import("fs");
-        const path = await import("path");
-        if (!fs.existsSync(file_path)) {
-          return {
-            isError: true,
-            content: [{ type: "text", text: `Error: File not found: ${file_path}` }]
-          };
-        }
-        const stat = fs.statSync(file_path);
-        if (stat.size > MAX_UPLOAD_FILE_BYTES) {
-          return {
-            isError: true,
-            content: [{ type: "text", text: `Error: File too large (${(stat.size / 1024 / 1024).toFixed(1)}MB). Max ${MAX_UPLOAD_FILE_LABEL} per file.` }]
-          };
-        }
-        if (stat.size === 0) {
-          return {
-            isError: true,
-            content: [{ type: "text", text: "Error: File is empty; refusing to upload a 0-byte attachment." }]
-          };
-        }
-        const { response: listRes, data: listData } = await executeJsonRequest(
-          `${serverUrl}/internal/agent/${agentId}/resolve-channel`,
-          {
-            method: "POST",
-            headers: commonHeaders,
-            body: JSON.stringify({ target: channel })
-          },
-          {
-            toolName: "upload_file.resolve_channel",
-            target: channel,
-            fetchImpl: bridgeFetch
-          }
-        );
-        if (!listRes.ok || !listData.channelId) {
-          return {
-            isError: true,
-            content: [{ type: "text", text: `Error: ${listData.error || `Could not resolve channel: ${channel}`}` }]
-          };
-        }
-        const channelId = listData.channelId;
-        const fileBuffer = fs.readFileSync(file_path);
-        const filename = path.basename(file_path);
-        const mimeType = guessMimeTypeFromFilename(filename);
-        const blob = new Blob([fileBuffer], { type: mimeType });
-        const formData = new FormData();
-        formData.append("file", blob, filename);
-        formData.append("channelId", channelId);
-        const uploadHeaders = buildChatBridgeCommonHeaders(authToken, { includeContentType: false });
-        const { response: res, data } = await executeJsonRequest(
-          `${serverUrl}/internal/agent/${agentId}/upload`,
-          {
-            method: "POST",
-            headers: uploadHeaders,
-            body: formData
-          },
-          {
-            toolName: "upload_file",
-            target: channel,
-            fetchImpl: bridgeFetch
-          }
-        );
-        if (!res.ok) {
-          return {
-            isError: true,
-            content: [{ type: "text", text: `Error: ${data.error}` }]
-          };
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: `File uploaded: ${data.filename} (${(data.sizeBytes / 1024).toFixed(1)}KB)
-Attachment ID: ${data.id}
-
-Use this ID in send_message's attachment_ids parameter to include it in a message.`
-            }
-          ]
-        };
-      } catch (err) {
-        return {
-          isError: true,
-          content: [{ type: "text", text: `Error: ${err.message}` }]
-        };
-      }
-    }
-  );
-  server.tool(
-    "view_file",
-    "Download an attached file by its attachment ID and save it locally so you can inspect it. Returns the local file path.",
-    {
-      attachment_id: z2.string().describe("The attachment UUID (from the 'id:...' shown in the message)")
-    },
-    async ({ attachment_id }) => {
-      try {
-        const fs = await import("fs");
-        const path = await import("path");
-        const cacheDir = resolveSlockHomePath("attachments");
-        fs.mkdirSync(cacheDir, { recursive: true });
-        const existing = fs.readdirSync(cacheDir).find((f) => f.startsWith(attachment_id));
-        if (existing) {
-          const cachedPath = path.join(cacheDir, existing);
-          return {
-            content: [{ type: "text", text: `File already cached at: ${cachedPath}` }]
-          };
-        }
-        const downloadHeaders = buildChatBridgeCommonHeaders(authToken, { includeContentType: false });
-        const { response: res } = await executeResponseRequest(
-          `${serverUrl}/api/attachments/${attachment_id}`,
-          {
-            headers: downloadHeaders,
-            redirect: "follow"
-          },
-          {
-            toolName: "view_file",
-            target: attachment_id,
-            fetchImpl: bridgeFetch
-          }
-        );
-        if (!res.ok) {
-          return {
-            isError: true,
-            content: [{ type: "text", text: `Error: Failed to download attachment (${res.status})` }]
-          };
-        }
-        const contentType = res.headers.get("content-type") || "application/octet-stream";
-        const filename = parseFilenameFromContentDisposition(res.headers.get("content-disposition"));
-        const ext = filename ? path.extname(filename) || extensionForContentType(contentType) : extensionForContentType(contentType);
-        const filePath = path.join(cacheDir, `${attachment_id}${ext}`);
-        const buffer = Buffer.from(await res.arrayBuffer());
-        fs.writeFileSync(filePath, buffer);
-        return {
-          content: [{ type: "text", text: `Downloaded to: ${filePath}` }]
-        };
-      } catch (err) {
-        return {
-          isError: true,
-          content: [{ type: "text", text: `Error: ${err.message}` }]
-        };
-      }
-    }
-  );
-  server.tool(
-    "check_messages",
-    "Check for new messages without waiting. Returns immediately with any pending messages, or 'No new messages' if none. Use this freely during work \u2014 at natural breakpoints, after notifications, or whenever you want to see if anything new came in.",
-    {},
-    async () => {
-      try {
-        const { response: res, data } = await executeJsonRequest(
-          `${serverUrl}/internal/agent/${agentId}/receive`,
-          { method: "GET", headers: commonHeaders },
-          {
-            toolName: "check_messages",
-            timeoutMs: 1e4,
-            fetchImpl: bridgeFetch
-          }
-        );
-        if (!res.ok) {
-          return { isError: true, content: [{ type: "text", text: `Error: ${data.error || res.statusText}` }] };
-        }
-        const messages = data.messages ?? [];
-        if (messages.length > 0) {
-          await acknowledgeReceivedMessages(messages);
-          const messagesToShow = rememberDeliveredMessages(messages);
-          if (messagesToShow.length > 0) {
-            return { content: [{ type: "text", text: formatMessages(messagesToShow) }] };
-          }
-        }
-        return {
-          content: [{ type: "text", text: "No new messages." }]
-        };
-      } catch (err) {
-        return {
-          isError: true,
-          content: [{ type: "text", text: `Error: ${err.message}` }]
-        };
-      }
-    }
-  );
-  server.tool(
-    "list_server",
-    "List all channels in this server, including which ones you have joined, plus all agents and humans. Use this to discover who and where you can message.",
-    {},
-    async () => {
-      try {
-        const { response: res, data } = await executeJsonRequest(
-          `${serverUrl}/internal/agent/${agentId}/server`,
-          { method: "GET", headers: commonHeaders },
-          {
-            toolName: "list_server",
-            fetchImpl: bridgeFetch
-          }
-        );
-        let text = "## Server\n\n";
-        const channels = data.channels ?? [];
-        const agents = data.agents ?? [];
-        const humans = data.humans ?? [];
-        text += formatRuntimeContext(data.runtimeContext);
-        text += "### Channels\n";
-        text += 'Visible public channels may appear even when `joined=false`. Private channels are shown only when you are a member; do not disclose private-channel names, membership, or content outside that channel. Use `read_history(channel="#name")` to inspect visible channels. When a channel is not joined, you cannot send messages there or receive ordinary channel delivery until a human adds you to the channel. To leave a regular channel you have joined, use `leave_channel(target="#name")`.\n';
-        if (channels.length > 0) {
-          for (const t of channels) {
-            const visibility = t.type === "private" ? "private" : "public";
-            const status = `${visibility}, ${t.joined ? "joined" : "not joined"}`;
-            text += t.description ? `  - #${t.name} [${status}] \u2014 ${t.description}
-` : `  - #${t.name} [${status}]
-`;
-          }
-        } else {
-          text += "  (none)\n";
-        }
-        text += "\n### Agents\n";
-        text += "Other AI agents in this server.\n";
-        if (agents.length > 0) {
-          for (const a of agents) {
-            text += a.description ? `  - @${a.name} (${a.status}) \u2014 ${a.description}
-` : `  - @${a.name} (${a.status})
-`;
-          }
-        } else {
-          text += "  (none)\n";
-        }
-        text += "\n### Humans\n";
-        text += 'To start a new DM: send_message(target="dm:@name"). To reply in an existing DM: reuse the target from received messages.\n';
-        if (humans.length > 0) {
-          for (const u of humans) {
-            text += u.description ? `  - @${u.name} \u2014 ${u.description}
-` : `  - @${u.name}
-`;
-          }
-        } else {
-          text += "  (none)\n";
-        }
-        return {
-          content: [{ type: "text", text }]
-        };
-      } catch (err) {
-        return {
-          isError: true,
-          content: [{ type: "text", text: `Error: ${err.message}` }]
-        };
-      }
-    }
-  );
-  server.tool(
-    "leave_channel",
-    "Leave a regular channel you have joined. This only affects your own agent membership; it does not require admin privileges. After leaving, you can still inspect visible public channel history, but you will stop receiving ordinary channel delivery and cannot send until a human adds you again.",
-    {
-      target: z2.string().describe("Regular channel to leave, in the form '#channel-name'. DMs and thread targets are not supported.")
-    },
-    async ({ target }) => {
-      try {
-        const channel = await resolveRegularChannelTarget(target);
-        if (!channel.joined) {
-          return {
-            content: [{ type: "text", text: `Already not joined in ${target}.` }]
-          };
-        }
-        const { response: res, data } = await executeJsonRequest(
-          `${serverUrl}/internal/agent/${agentId}/channels/${channel.id}/leave`,
-          {
-            method: "POST",
-            headers: commonHeaders
-          },
-          {
-            toolName: "leave_channel",
-            target,
-            fetchImpl: bridgeFetch
-          }
-        );
-        if (!res.ok) {
-          return {
-            isError: true,
-            content: [{ type: "text", text: `Error: ${data.error || `Failed to leave ${target}`}` }]
-          };
-        }
-        return {
-          content: [{ type: "text", text: `Left ${target}. You can still inspect visible public channel history there, but you can no longer send or receive ordinary channel delivery until a human adds you again.` }]
-        };
-      } catch (err) {
-        return {
-          isError: true,
-          content: [{ type: "text", text: `Error: ${err.message}` }]
-        };
-      }
-    }
-  );
-  server.tool(
-    "search_messages",
-    "Search messages visible to the agent. Use this to find relevant conversations, then inspect a hit with read_history(channel=..., around=messageId).",
-    {
-      query: z2.string().describe("Search query"),
-      channel: z2.string().optional().describe("Optional target to scope the search, e.g. '#general', 'dm:@richard', '#general:abcd1234'"),
-      sender_id: z2.string().optional().describe("Optional exact sender id filter."),
-      after: z2.string().optional().describe("Optional inclusive ISO datetime lower bound for message created_at."),
-      before: z2.string().optional().describe("Optional inclusive ISO datetime upper bound for message created_at."),
-      sort: z2.enum(["relevance", "recent"]).optional().describe("Optional result sort. Use 'relevance' for best match first or 'recent' for newest first."),
-      limit: z2.number().default(10).describe("Max number of search results to return (default 10, max 20)")
-    },
-    async ({ query, channel, sender_id, after, before, sort, limit }) => {
-      try {
-        const trimmed = query.trim();
-        if (!trimmed) {
-          return {
-            content: [{ type: "text", text: "Search query cannot be empty." }]
-          };
-        }
-        const params = new URLSearchParams();
-        params.set("q", trimmed);
-        params.set("limit", String(Math.min(limit, 20)));
-        if (channel) params.set("channel", channel);
-        if (sender_id) params.set("senderId", sender_id);
-        if (after) params.set("after", after);
-        if (before) params.set("before", before);
-        if (sort) params.set("sort", sort);
-        const { response: res, data } = await executeJsonRequest(
-          `${serverUrl}/internal/agent/${agentId}/search?${params}`,
-          { method: "GET", headers: commonHeaders },
-          {
-            toolName: "search_messages",
-            target: channel ?? null,
-            fetchImpl: bridgeFetch
-          }
-        );
-        if (!res.ok) {
-          return {
-            content: [{ type: "text", text: `Error: ${data.error}` }]
-          };
-        }
-        if (!data.results || data.results.length === 0) {
-          return {
-            content: [{ type: "text", text: "No search results." }]
-          };
-        }
-        const formatted = data.results.map((result, index) => {
-          const target = formatSearchTarget(result);
-          const threadInfo = result.channelType === "thread" ? `
-thread: ${result.parentChannelName} -> ${target}` : "";
-          return [
-            `[${index + 1}] msg=${result.id} seq=${result.seq} time=${toLocalTime(result.createdAt)}`,
-            `target: ${target}${threadInfo}`,
-            `sender: @${result.senderName} (${result.senderType})`,
-            `content: ${result.content}`,
-            `match: ${result.snippet}`,
-            `next: read_history(channel="${target}", around="${result.id}", limit=20)`
-          ].join("\n");
-        }).join("\n\n");
-        return {
-          content: [{
-            type: "text",
-            text: `## Search Results for "${trimmed}" (${data.results.length} results)
-
-${formatted}`
-          }]
-        };
-      } catch (err) {
-        return {
-          isError: true,
-          content: [{ type: "text", text: `Error: ${err.message}` }]
-        };
-      }
-    }
-  );
-  server.tool(
-    "read_history",
-    "Read message history for a channel, DM, or thread. Use the same target format: '#channel', 'dm:@name', '#channel:id' for threads, 'dm:@name:id' for DM threads. Supports pagination via 'before' / 'after', and context jumps via 'around' (messageId or seq).",
-    {
-      channel: z2.string().describe("The target to read history from \u2014 e.g. '#general', 'dm:@richard', '#general:abcd1234', 'dm:@richard:abcd1234'"),
-      limit: z2.number().default(50).describe("Max number of messages to return (default 50, max 100)"),
-      around: z2.union([z2.string(), z2.number()]).optional().describe("Center the result window around a messageId or seq in this channel/thread."),
-      before: z2.number().optional().describe("Return messages before this seq number (for backward pagination). Omit for latest messages."),
-      after: z2.number().optional().describe("Return messages after this seq number (for catching up on unread). Returns oldest-first.")
-    },
-    async ({ channel, limit, around, before, after }) => {
-      try {
-        const params = new URLSearchParams();
-        params.set("channel", channel);
-        params.set("limit", String(Math.min(limit, 100)));
-        if (around !== void 0) params.set("around", String(around));
-        if (before) params.set("before", String(before));
-        if (after) params.set("after", String(after));
-        const { response: res, data } = await executeJsonRequest(
-          `${serverUrl}/internal/agent/${agentId}/history?${params}`,
-          { method: "GET", headers: commonHeaders },
-          {
-            toolName: "read_history",
-            target: channel,
-            fetchImpl: bridgeFetch
-          }
-        );
-        if (!res.ok) {
-          return {
-            content: [
-              { type: "text", text: `Error: ${data.error}` }
-            ]
-          };
-        }
-        if (!data.messages || data.messages.length === 0) {
-          return {
-            content: [
-              { type: "text", text: "No messages in this channel." }
-            ]
-          };
-        }
-        const formatted = data.messages.map((m) => formatHistoryMessageLine({
-          ...m,
-          senderName: m.senderName ?? m.sender_name ?? "unknown",
-          senderDescription: m.senderDescription ?? m.sender_description ?? null
-        })).join("\n");
-        let footer = "";
-        if (data.historyLimited) {
-          footer = `
-
---- ${data.historyLimitMessage || "Message history is limited on this plan."} ---`;
-        } else if (around && data.messages.length > 0 && (data.has_older || data.has_newer)) {
-          const minSeq = data.messages[0].seq;
-          const maxSeq = data.messages[data.messages.length - 1].seq;
-          footer = `
-
---- Context window shown. Use before=${minSeq} to load older messages or after=${maxSeq} to load newer messages. ---`;
-        } else if (data.has_more && data.messages.length > 0) {
-          if (after) {
-            const maxSeq = data.messages[data.messages.length - 1].seq;
-            footer = `
-
---- ${data.messages.length} messages shown. Use after=${maxSeq} to load more recent messages. ---`;
-          } else {
-            const minSeq = data.messages[0].seq;
-            footer = `
-
---- ${data.messages.length} messages shown. Use before=${minSeq} to load older messages. ---`;
-          }
-        }
-        let header = `## Message History for ${channel}${around ? ` around ${around}` : ""} (${data.messages.length} messages)`;
-        if ((data.last_read_seq ?? 0) > 0 && !after && !before && !around) {
-          header += `
-Your last read position: seq ${data.last_read_seq}. Use read_history(channel="${channel}", after=${data.last_read_seq}) to see only unread messages.`;
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: `${header}
-
-${formatted}${footer}`
-            }
-          ]
-        };
-      } catch (err) {
-        return {
-          isError: true,
-          content: [{ type: "text", text: `Error: ${err.message}` }]
-        };
-      }
-    }
-  );
-  server.tool(
-    "list_tasks",
-    "List all tasks in a channel. Returns each task's number, title, status, assignee, and message ID. Use this to see what work exists before claiming. Tasks marked as legacy are from an older system and cannot be claimed or modified.",
-    {
-      channel: z2.string().describe("The channel whose task board to view \u2014 e.g. '#engineering', '#proj-slock'"),
-      status: z2.enum(["all", "todo", "in_progress", "in_review", "done", "closed"]).default("all").describe("Filter by status (default: all)")
-    },
-    async ({ channel, status }) => {
-      try {
-        const params = new URLSearchParams();
-        params.set("channel", channel);
-        if (status !== "all") params.set("status", status);
-        const { response: res, data } = await executeJsonRequest(
-          `${serverUrl}/internal/agent/${agentId}/tasks?${params}`,
-          { method: "GET", headers: commonHeaders },
-          {
-            toolName: "list_tasks",
-            target: channel,
-            fetchImpl: bridgeFetch
-          }
-        );
-        if (!res.ok) {
-          return {
-            isError: true,
-            content: [{ type: "text", text: `Error: ${data.error}` }]
-          };
-        }
-        if (!data.tasks || data.tasks.length === 0) {
-          return {
-            content: [{ type: "text", text: `No${status !== "all" ? ` ${status}` : ""} tasks in ${channel}.` }]
-          };
-        }
-        const formatted = data.tasks.map((t) => {
-          const assignee = t.claimedByName ? ` \u2192 @${t.claimedByName}` : "";
-          const creator = t.createdByName ? ` (by @${t.createdByName})` : "";
-          const msgId = t.messageId ? ` msg=${t.messageId.slice(0, 8)}` : "";
-          const legacy = t.isLegacy ? " [LEGACY \u2014 read-only]" : "";
-          return `#${t.taskNumber} [${t.status}] ${t.title}${assignee}${creator}${msgId}${legacy}`;
-        }).join("\n");
-        return {
-          content: [
-            {
-              type: "text",
-              text: `## Task Board for ${channel} (${data.tasks.length} tasks)
-
-${formatted}`
-            }
-          ]
-        };
-      } catch (err) {
-        return {
-          isError: true,
-          content: [{ type: "text", text: `Error: ${err.message}` }]
-        };
-      }
-    }
-  );
-  server.tool(
-    "create_tasks",
-    "Create one or more new task-messages in a top-level channel or DM. This is a convenience helper for creating a brand-new message and publishing it as a task-message in the chat flow. Thread messages cannot become tasks. It does not claim the task for you; if you want to own it, still call claim_tasks afterward. It is not a separate task board outside the chat flow. Typical uses are breaking down a larger task into parallel subtasks or batch-creating new work for others to claim. Do not use this to convert an existing message \u2014 use claim_tasks with message_ids instead. If the work already exists as a task, either claim that task or leave it alone; do not create a second task/message for the same work.",
-    {
-      channel: z2.string().describe("The channel to create tasks in \u2014 e.g. '#engineering'"),
-      tasks: z2.array(
-        z2.object({
-          title: z2.string().describe("Task title")
-        })
-      ).describe("Array of tasks to create")
-    },
-    async ({ channel, tasks }) => {
-      try {
-        const { response: res, data } = await executeJsonRequest(
-          `${serverUrl}/internal/agent/${agentId}/tasks`,
-          {
-            method: "POST",
-            headers: commonHeaders,
-            body: JSON.stringify({ channel, tasks })
-          },
-          {
-            toolName: "create_tasks",
-            target: channel,
-            fetchImpl: bridgeFetch
-          }
-        );
-        if (!res.ok) {
-          return {
-            isError: true,
-            content: [{ type: "text", text: `Error: ${data.error}` }]
-          };
-        }
-        const created = data.tasks.map((t) => `#${t.taskNumber} msg=${t.messageId.slice(0, 8)} "${t.title}"`).join("\n");
-        const threadHints = data.tasks.map((t) => `#${t.taskNumber} \u2192 send_message to "${channel}:${t.messageId.slice(0, 8)}"`).join("\n");
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Created ${data.tasks.length} task(s) in ${channel}:
-${created}
-
-To follow up in each task's thread:
-${threadHints}`
-            }
-          ]
-        };
-      } catch (err) {
-        return {
-          isError: true,
-          content: [{ type: "text", text: `Error: ${err.message}` }]
-        };
-      }
-    }
-  );
-  server.tool(
-    "claim_tasks",
-    `Claim tasks so you are assigned to work on them. Two modes:
-1. By task number: claim existing tasks shown in list_tasks. Use task_numbers=[1, 3].
-2. By message ID: convert a regular top-level message into a task and claim it. Use message_ids=["a1b2c3d4"]. The message ID is the 8-character msg= value from received messages or read_history.
-
-Thread messages and system messages (e.g. task-claim / task-status announcements) cannot be claimed or converted into tasks \u2014 if a system message describes an action you should take, just do it; otherwise ignore it. If a task is in "todo" status, claiming auto-advances it to "in_progress". If another agent already claimed it, the claim fails \u2014 do not work on that task, move on. Always claim before starting any work to prevent duplicate effort.`,
-    {
-      channel: z2.string().describe("The channel \u2014 e.g. '#engineering'"),
-      task_numbers: z2.array(z2.number()).optional().describe("Task numbers to claim (from list_tasks output, e.g. [1, 3])"),
-      message_ids: z2.array(z2.string()).optional().describe("Message IDs or short ID prefixes (the 8-char msg= value, e.g. ['a1b2c3d4']). Converts a regular top-level message to a task and claims it. Thread messages are not allowed.")
-    },
-    async ({ channel, task_numbers, message_ids }) => {
-      try {
-        if ((!task_numbers || task_numbers.length === 0) && (!message_ids || message_ids.length === 0)) {
-          return {
-            content: [{ type: "text", text: "Error: provide at least one of task_numbers or message_ids" }]
-          };
-        }
-        const body = { channel };
-        if (task_numbers && task_numbers.length > 0) body.task_numbers = task_numbers;
-        if (message_ids && message_ids.length > 0) body.message_ids = message_ids;
-        const { response: res, data } = await executeJsonRequest(
-          `${serverUrl}/internal/agent/${agentId}/tasks/claim`,
-          {
-            method: "POST",
-            headers: commonHeaders,
-            body: JSON.stringify(body)
-          },
-          {
-            toolName: "claim_tasks",
-            target: channel,
-            fetchImpl: bridgeFetch
-          }
-        );
-        if (!res.ok) {
-          return {
-            isError: true,
-            content: [{ type: "text", text: `Error: ${data.error}` }]
-          };
-        }
-        const lines = data.results.map((r) => {
-          const label = r.taskNumber ? `#${r.taskNumber}` : `msg:${r.messageId}`;
-          if (r.success) {
-            const msgShort = r.messageId ? r.messageId.slice(0, 8) : "";
-            return `${label} (msg:${msgShort}): claimed`;
-          }
-          return `${label}: FAILED \u2014 ${r.reason || "already claimed"}. Do not reply.`;
-        });
-        const succeeded = data.results.filter((r) => r.success).length;
-        const failed = data.results.length - succeeded;
-        let summary = `${succeeded} claimed`;
-        if (failed > 0) summary += `, ${failed} failed`;
-        const claimedMsgs = data.results.filter((r) => r.success && r.messageId).map((r) => `#${r.taskNumber} \u2192 send_message to "${channel}:${r.messageId.slice(0, 8)}"`).join("\n");
-        const threadHint = claimedMsgs ? `
-
-Follow up in each task's thread:
-${claimedMsgs}` : "";
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Claim results (${summary}):
-${lines.join("\n")}${threadHint}`
-            }
-          ]
-        };
-      } catch (err) {
-        return {
-          isError: true,
-          content: [{ type: "text", text: `Error: ${err.message}` }]
-        };
-      }
-    }
-  );
-  server.tool(
-    "unclaim_task",
-    "Release your claim on a task so someone else can pick it up. Only use this if you can no longer work on the task \u2014 not as a way to mark it done. Use update_task_status to change status instead.",
-    {
-      channel: z2.string().describe("The channel \u2014 e.g. '#engineering'"),
-      task_number: z2.number().describe("The task number to unclaim (e.g. 3)")
-    },
-    async ({ channel, task_number }) => {
-      try {
-        const { response: res, data } = await executeJsonRequest(
-          `${serverUrl}/internal/agent/${agentId}/tasks/unclaim`,
-          {
-            method: "POST",
-            headers: commonHeaders,
-            body: JSON.stringify({ channel, task_number })
-          },
-          {
-            toolName: "unclaim_task",
-            target: channel,
-            fetchImpl: bridgeFetch
-          }
-        );
-        if (!res.ok) {
-          return {
-            isError: true,
-            content: [{ type: "text", text: `Error: ${data.error}` }]
-          };
-        }
-        return {
-          content: [
-            { type: "text", text: `#${task_number} unclaimed \u2014 now open.` }
-          ]
-        };
-      } catch (err) {
-        return {
-          isError: true,
-          content: [{ type: "text", text: `Error: ${err.message}` }]
-        };
-      }
-    }
-  );
-  server.tool(
-    "update_task_status",
-    "Update a task's progress status. You must be the task's assignee to update it. Use in_review when your work is ready for human validation. Only set done for trivial tasks or after explicit approval. Use closed to mark a task as won't-do (cancelled / abandoned / out-of-scope) \u2014 distinct from done. Valid transitions: todo\u2192{in_progress,closed}, in_progress\u2192{in_review,done,closed}, in_review\u2192{done,in_progress,closed}, done\u2192{todo,in_progress,in_review,closed}, closed\u2192todo (reopen).",
-    {
-      channel: z2.string().describe("The channel \u2014 e.g. '#engineering'"),
-      task_number: z2.number().describe("The task number to update (e.g. 3)"),
-      status: z2.enum(["todo", "in_progress", "in_review", "done", "closed"]).describe("The new status")
-    },
-    async ({ channel, task_number, status }) => {
-      try {
-        const { response: res, data } = await executeJsonRequest(
-          `${serverUrl}/internal/agent/${agentId}/tasks/update-status`,
-          {
-            method: "POST",
-            headers: commonHeaders,
-            body: JSON.stringify({ channel, task_number, status })
-          },
-          {
-            toolName: "update_task_status",
-            target: channel,
-            fetchImpl: bridgeFetch
-          }
-        );
-        if (!res.ok) {
-          return {
-            isError: true,
-            content: [{ type: "text", text: `Error: ${data.error}` }]
-          };
-        }
-        return {
-          content: [
-            { type: "text", text: `#${task_number} moved to ${status}.` }
-          ]
-        };
-      } catch (err) {
-        return {
-          isError: true,
-          content: [{ type: "text", text: `Error: ${err.message}` }]
-        };
-      }
-    }
-  );
-  server.tool(
-    "schedule_reminder",
-    "Schedule a reminder that will fire at a future time and wake you up with a DM. Use this when you need to follow up on something after a delay, at a specific time, or on a schedule. The reminder persists across daemon restarts. For one-shot reminders, provide delay_seconds (preferred) OR fire_at. For recurring reminders, provide repeat; you may also combine repeat with delay_seconds or fire_at to pin the first fire.",
-    {
-      title: z2.string().describe("Short description of what the reminder is about. This is what you'll see when it fires."),
-      delay_seconds: z2.number().int().positive().optional().describe("Preferred for relative times. Fires this many seconds from now (server-computed, timezone-safe). Use this for any 'in N seconds/minutes/hours' request."),
-      fire_at: z2.string().optional().describe("ISO-8601 UTC timestamp, e.g. '2026-04-21T09:00:00Z'. Use only for absolute calendar times ('tomorrow 9am UTC'). Your local clock is NOT trusted as UTC \u2014 if you mean a relative delay, use delay_seconds instead."),
-      repeat: z2.string().optional().describe("Recurrence rule. Supported forms: 'every:15m' | 'every:2h' | 'every:1d' (fixed interval) | 'daily@09:00' (in your local tz, snapshotted at creation) | 'weekly:mon,fri@09:00' (specific weekdays). The reminder auto-reschedules after each fire until you cancel it."),
-      channel: z2.string().optional().describe("Optional explicit channel to post a receipt system message in (format: '#channel', 'dm:@name', or thread ref). Use this only if you want the receipt somewhere other than the anchor message's channel."),
-      msg_id: z2.string().describe("Required anchor message id (from a received message). Resolve it explicitly and pass it in; if you cannot resolve one, do not create the reminder.")
-    },
-    async ({ title, delay_seconds, fire_at, repeat, channel, msg_id }) => {
-      try {
-        const body = { title, msgId: msg_id };
-        if (delay_seconds !== void 0) body.delaySeconds = delay_seconds;
-        if (fire_at !== void 0) body.fireAt = fire_at;
-        if (repeat !== void 0) {
-          body.repeat = repeat;
-          body.tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
-        }
-        if (channel !== void 0) body.channel = channel;
-        const { response: res, data } = await executeJsonRequest(
-          `${serverUrl}/internal/agent/${agentId}/reminders`,
-          {
-            method: "POST",
-            headers: commonHeaders,
-            body: JSON.stringify(body)
-          },
-          {
-            toolName: "schedule_reminder",
-            fetchImpl: bridgeFetch
-          }
-        );
-        if (!res.ok || !data.reminder) {
-          return { isError: true, content: [{ type: "text", text: `Error: ${data.error || res.statusText}` }] };
-        }
-        const lines = [`Reminder scheduled: ${formatReminder(data.reminder)}`];
-        if (data.warning) lines.push(`Warning: ${data.warning}`);
-        return { content: [{ type: "text", text: lines.join("\n") }] };
-      } catch (err) {
-        return {
-          isError: true,
-          content: [{ type: "text", text: `Error: ${err.message}` }]
-        };
-      }
-    }
-  );
-  server.tool(
-    "list_reminders",
-    "List your own reminders. Defaults to scheduled (pending) ones; pass status to include fired or canceled.",
-    {
-      status: z2.string().optional().describe("Comma-separated statuses to include (scheduled,fired,canceled). Defaults to 'scheduled'.")
-    },
-    async ({ status }) => {
-      try {
-        const qs = new URLSearchParams();
-        qs.set("status", status && status.trim().length > 0 ? status.trim() : "scheduled");
-        const { response: res, data } = await executeJsonRequest(
-          `${serverUrl}/internal/agent/${agentId}/reminders?${qs.toString()}`,
-          { method: "GET", headers: commonHeaders },
-          {
-            toolName: "list_reminders",
-            fetchImpl: bridgeFetch
-          }
-        );
-        if (!res.ok) {
-          return { isError: true, content: [{ type: "text", text: `Error: ${data.error || res.statusText}` }] };
-        }
-        const list = data.reminders ?? [];
-        if (list.length === 0) {
-          return { content: [{ type: "text", text: "No reminders." }] };
-        }
-        return {
-          content: [
-            { type: "text", text: list.map(formatReminder).join("\n") }
-          ]
-        };
-      } catch (err) {
-        return {
-          isError: true,
-          content: [{ type: "text", text: `Error: ${err.message}` }]
-        };
-      }
-    }
-  );
-  server.tool(
-    "cancel_reminder",
-    "Cancel one of your own scheduled reminders by id. Only reminders in 'scheduled' status can be canceled.",
-    {
-      reminder_id: z2.string().describe("The reminder id (full uuid, or the short 8-char prefix shown by schedule_reminder / list_reminders).")
-    },
-    async ({ reminder_id }) => {
-      try {
-        let fullId = reminder_id;
-        if (reminder_id.length < 32) {
-          const { response: listRes, data: listData } = await executeJsonRequest(
-            `${serverUrl}/internal/agent/${agentId}/reminders?status=scheduled`,
-            { method: "GET", headers: commonHeaders },
-            {
-              toolName: "cancel_reminder.resolve",
-              fetchImpl: bridgeFetch
-            }
-          );
-          if (!listRes.ok) {
-            return { isError: true, content: [{ type: "text", text: `Error: ${listData.error || listRes.statusText}` }] };
-          }
-          const matches = (listData.reminders ?? []).filter((r) => r.reminderId.startsWith(reminder_id));
-          if (matches.length === 0) {
-            return { isError: true, content: [{ type: "text", text: `No scheduled reminder matches id prefix '${reminder_id}'.` }] };
-          }
-          if (matches.length > 1) {
-            return { isError: true, content: [{ type: "text", text: `Ambiguous id prefix '${reminder_id}' matches ${matches.length} reminders; pass a longer id.` }] };
-          }
-          fullId = matches[0].reminderId;
-        }
-        const { response: res, data } = await executeJsonRequest(
-          `${serverUrl}/internal/agent/${agentId}/reminders/${fullId}`,
-          { method: "DELETE", headers: commonHeaders },
-          {
-            toolName: "cancel_reminder",
-            fetchImpl: bridgeFetch
-          }
-        );
-        if (!res.ok || !data.reminder) {
-          return { isError: true, content: [{ type: "text", text: `Error: ${data.error || res.statusText}` }] };
-        }
-        return {
-          content: [
-            { type: "text", text: `Reminder canceled: ${formatReminder(data.reminder)}` }
-          ]
-        };
-      } catch (err) {
-        return {
-          isError: true,
-          content: [{ type: "text", text: `Error: ${err.message}` }]
-        };
-      }
-    }
-  );
-}
-var formatMessages2;
-var formatReminder2;
 var transport = new StdioServerTransport();
 await server.connect(transport);