@slock-ai/daemon 0.40.1 → 0.41.0

package/dist/chat-bridge.js

@@ -2,12 +2,137 @@
 import {
   buildFetchDispatcher,
   logger
-} from "./chunk-E6OOH3IC.js";
+} from "./chunk-JG7ONJZ6.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"]).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"]).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) {
@@ -210,16 +335,26 @@ var args = process.argv.slice(2);
 var agentId = "";
 var serverUrl = "http://localhost:3001";
 var authToken = "";
+var runtime = "unknown";
+var launchId = "";
+var deprecatedShimMode = 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 (!agentId) {
   console.error("Missing --agent-id");
   process.exit(1);
 }
 var commonHeaders = buildChatBridgeCommonHeaders(authToken);
+var runtimeActionHeaders = {
+  ...commonHeaders,
+  ...launchId ? { "X-Agent-Launch-Id": launchId } : {}
+};
 function bridgeFetch(url, init = {}) {
   const dispatcher = buildFetchDispatcher(url, process.env);
   const requestInit = dispatcher ? { ...init, dispatcher } : init;
@@ -367,61 +502,102 @@ function formatSenderHandle(message) {
   const senderDescription = message.sender_description ?? message.senderDescription ?? null;
   return senderDescription ? `@${senderName} \u2014 ${senderDescription}` : `@${senderName}`;
 }
+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) {
+  for (const tool of DEPRECATED_MCP_TOOL_DEFINITIONS) {
+    registerDeprecatedTool(tool);
+  }
+}
+var RUNTIME_PROFILE_MIGRATION_DONE_TOOL_NAME = "runtime_profile_migration_done";
 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'.",
+  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.",
   {
-    target: z.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: z.string().describe("The message content"),
-    attachment_ids: z.array(z.string()).optional().describe("Optional attachment IDs from upload_file to include with the message")
+    migration_key: z2.string().describe("The migration key from the Runtime Profile migration hint")
   },
-  async ({ target, content, attachment_ids }) => {
+  async ({ migration_key }) => {
+    const key = migration_key.trim();
+    if (!key) {
+      return {
+        isError: true,
+        content: [{ type: "text", text: "Error: migration_key is required" }]
+      };
+    }
     try {
-      const { response: res, data } = await executeRetrySafeSendRequest(
-        `${serverUrl}/internal/agent/${agentId}/send`,
-        (idempotencyKey) => ({
+      const { response: res, data } = await executeJsonRequest(
+        `${serverUrl}/internal/agent/${agentId}/runtime-profile/migration-done`,
+        {
           method: "POST",
-          headers: commonHeaders,
-          body: JSON.stringify({ target, content, attachmentIds: attachment_ids, idempotencyKey })
-        }),
+          headers: runtimeActionHeaders,
+          body: JSON.stringify({ migrationKey: key })
+        },
         {
-          target,
+          toolName: RUNTIME_PROFILE_MIGRATION_DONE_TOOL_NAME,
           fetchImpl: bridgeFetch
         }
       );
       if (!res.ok) {
         return {
-          content: [
-            { type: "text", text: `Error: ${data.error}` }
-          ]
+          isError: true,
+          content: [{ type: "text", text: `Error: ${data.error || "Runtime Profile migration is not active"}` }]
         };
       }
-      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}`
-          }
-        ]
+        content: [{ type: "text", text: "Runtime Profile migration completed. Normal inbox delivery can resume." }]
       };
     } catch (err) {
       return {
@@ -431,844 +607,951 @@ ${formatMessages(unreadToShow)}`;
     }
   }
 );
-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: 10MB.",
-  {
-    file_path: z.string().describe("Absolute path to the file on your local filesystem"),
-    channel: z.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)) {
+if (!deprecatedShimMode) {
+  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 {
-          isError: true,
-          content: [{ type: "text", text: `Error: File not found: ${file_path}` }]
+          content: [
+            {
+              type: "text",
+              text: `Message sent to ${target}. Message ID: ${data.messageId}${replyHint}${unreadSection}`
+            }
+          ]
         };
-      }
-      const stat = fs.statSync(file_path);
-      if (stat.size > 10 * 1024 * 1024) {
+      } catch (err) {
         return {
           isError: true,
-          content: [{ type: "text", text: `Error: File too large (${(stat.size / 1024 / 1024).toFixed(1)}MB). Max 10MB per file.` }]
+          content: [{ type: "text", text: `Error: ${err.message}` }]
         };
       }
-      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
+    }
+  );
+  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: 10MB.",
+    {
+      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 > 10 * 1024 * 1024) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: `Error: File too large (${(stat.size / 1024 / 1024).toFixed(1)}MB). Max 10MB per file.` }]
+          };
+        }
+        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}` }]
+          };
         }
-      );
-      if (!listRes.ok || !listData.channelId) {
         return {
-          isError: true,
-          content: [{ type: "text", text: `Error: ${listData.error || `Could not resolve channel: ${channel}`}` }]
+          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.`
+            }
+          ]
         };
-      }
-      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) {
+      } catch (err) {
         return {
           isError: true,
-          content: [{ type: "text", text: `Error: ${data.error}` }]
+          content: [{ type: "text", text: `Error: ${err.message}` }]
         };
       }
-      return {
-        content: [
+    }
+  );
+  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 os = await import("os");
+        const cacheDir = path.join(os.homedir(), ".slock", "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}`,
           {
-            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.`
+            headers: downloadHeaders,
+            redirect: "follow"
+          },
+          {
+            toolName: "view_file",
+            target: attachment_id,
+            fetchImpl: bridgeFetch
           }
-        ]
-      };
-    } 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: z.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 os = await import("os");
-      const cacheDir = path.join(os.homedir(), ".slock", "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);
+        );
+        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: `File already cached at: ${cachedPath}` }]
+          content: [{ type: "text", text: `Downloaded to: ${filePath}` }]
         };
-      }
-      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) {
+      } catch (err) {
         return {
           isError: true,
-          content: [{ type: "text", text: `Error: Failed to download attachment (${res.status})` }]
+          content: [{ type: "text", text: `Error: ${err.message}` }]
         };
       }
-      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
+  );
+  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}` }] };
         }
-      );
-      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) }] };
+        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}` }]
+        };
       }
-      return {
-        content: [{ type: "text", text: "No new messages." }]
-      };
-    } catch (err) {
-      return {
-        isError: true,
-        content: [{ type: "text", text: `Error: ${err.message}` }]
-      };
     }
-  }
-);
-function formatMessages(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");
-}
-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 += "### Channels\n";
-      text += 'Visible public channels may appear even when `joined=false`. Use `read_history(channel="#name")` to inspect them. When a channel is not joined, you cannot send messages there or receive ordinary channel delivery until a human adds you to the channel.\n';
-      if (channels.length > 0) {
-        for (const t of channels) {
-          const status = t.joined ? "joined" : "not joined";
-          text += t.description ? `  - #${t.name} [${status}] \u2014 ${t.description}
+  );
+  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 += "### Channels\n";
+        text += 'Visible public channels may appear even when `joined=false`. Use `read_history(channel="#name")` to inspect them. 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 status = t.joined ? "joined" : "not joined";
+            text += t.description ? `  - #${t.name} [${status}] \u2014 ${t.description}
 ` : `  - #${t.name} [${status}]
 `;
+          }
+        } else {
+          text += "  (none)\n";
         }
-      } 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}
+        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";
         }
-      } 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}
+        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";
         }
-      } else {
-        text += "  (none)\n";
-      }
-      return {
-        content: [{ type: "text", text }]
-      };
-    } 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: z.string().describe("Search query"),
-    channel: z.string().optional().describe("Optional target to scope the search, e.g. '#general', 'dm:@richard', '#general:abcd1234'"),
-    sender_id: z.string().optional().describe("Optional exact sender id filter."),
-    after: z.string().optional().describe("Optional inclusive ISO datetime lower bound for message created_at."),
-    before: z.string().optional().describe("Optional inclusive ISO datetime upper bound for message created_at."),
-    limit: z.number().default(10).describe("Max number of search results to return (default 10, max 20)")
-  },
-  async ({ query, channel, sender_id, after, before, limit }) => {
-    try {
-      const trimmed = query.trim();
-      if (!trimmed) {
         return {
-          content: [{ type: "text", text: "Search query cannot be empty." }]
+          content: [{ type: "text", text }]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error: ${err.message}` }]
         };
       }
-      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);
-      const { response: res, data } = await executeJsonRequest(
-        `${serverUrl}/internal/agent/${agentId}/search?${params}`,
-        { method: "GET", headers: commonHeaders },
-        {
-          toolName: "search_messages",
-          target: channel ?? null,
-          fetchImpl: bridgeFetch
+    }
+  );
+  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}`}` }]
+          };
         }
-      );
-      if (!res.ok) {
         return {
-          content: [{ type: "text", text: `Error: ${data.error}` }]
+          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.` }]
         };
-      }
-      if (!data.results || data.results.length === 0) {
+      } catch (err) {
         return {
-          content: [{ type: "text", text: "No search results." }]
+          isError: true,
+          content: [{ type: "text", text: `Error: ${err.message}` }]
         };
       }
-      const formatted = data.results.map((result, index) => {
-        const target = formatSearchTarget(result);
-        const threadInfo = result.channelType === "thread" ? `
+    }
+  );
+  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."),
+      limit: z2.number().default(10).describe("Max number of search results to return (default 10, max 20)")
+    },
+    async ({ query, channel, sender_id, after, before, 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);
+        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)
+          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: z.string().describe("The target to read history from \u2014 e.g. '#general', 'dm:@richard', '#general:abcd1234', 'dm:@richard:abcd1234'"),
-    limit: z.number().default(50).describe("Max number of messages to return (default 50, max 100)"),
-    around: z.union([z.string(), z.number()]).optional().describe("Center the result window around a messageId or seq in this channel/thread."),
-    before: z.number().optional().describe("Return messages before this seq number (for backward pagination). Omit for latest messages."),
-    after: z.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) {
+      } catch (err) {
         return {
-          content: [
-            { type: "text", text: "No messages in this channel." }
-          ]
+          isError: true,
+          content: [{ type: "text", text: `Error: ${err.message}` }]
         };
       }
-      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 = `
+    }
+  );
+  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) {
+        } 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 = `
+          } 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 += `
+        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: z.string().describe("The channel whose task board to view \u2014 e.g. '#engineering', '#proj-slock'"),
-    status: z.enum(["all", "todo", "in_progress", "in_review", "done"]).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}` }]
+          content: [
+            {
+              type: "text",
+              text: `${header}
+
+${formatted}${footer}`
+            }
+          ]
         };
-      }
-      if (!data.tasks || data.tasks.length === 0) {
+      } catch (err) {
         return {
-          content: [{ type: "text", text: `No${status !== "all" ? ` ${status}` : ""} tasks in ${channel}.` }]
+          isError: true,
+          content: [{ type: "text", text: `Error: ${err.message}` }]
         };
       }
-      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: [
+    }
+  );
+  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"]).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 },
           {
-            type: "text",
-            text: `## Task Board for ${channel} (${data.tasks.length} tasks)
-
-${formatted}`
+            toolName: "list_tasks",
+            target: channel,
+            fetchImpl: bridgeFetch
           }
-        ]
-      };
-    } 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: z.string().describe("The channel to create tasks in \u2014 e.g. '#engineering'"),
-    tasks: z.array(
-      z.object({
-        title: z.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}` }]
+          };
         }
-      );
-      if (!res.ok) {
+        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: ${data.error}` }]
+          content: [{ type: "text", text: `Error: ${err.message}` }]
         };
       }
-      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: [
+    }
+  );
+  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`,
           {
-            type: "text",
-            text: `Created ${data.tasks.length} task(s) in ${channel}:
+            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}` }]
-      };
+            }
+          ]
+        };
+      } 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:
+  );
+  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: z.string().describe("The channel \u2014 e.g. '#engineering'"),
-    task_numbers: z.array(z.number()).optional().describe("Task numbers to claim (from list_tasks output, e.g. [1, 3])"),
-    message_ids: z.array(z.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)) {
+    {
+      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"}`;
+        });
+        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: "Error: provide at least one of task_numbers or message_ids" }]
+          content: [
+            {
+              type: "text",
+              text: `Claim results (${summary}):
+${lines.join("\n")}${threadHint}`
+            }
+          ]
         };
-      }
-      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) {
+      } catch (err) {
         return {
           isError: true,
-          content: [{ type: "text", text: `Error: ${data.error}` }]
+          content: [{ type: "text", text: `Error: ${err.message}` }]
         };
       }
-      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"}`;
-      });
-      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: [
+    }
+  );
+  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`,
           {
-            type: "text",
-            text: `Claim results (${summary}):
-${lines.join("\n")}${threadHint}`
+            method: "POST",
+            headers: commonHeaders,
+            body: JSON.stringify({ channel, task_number })
+          },
+          {
+            toolName: "unclaim_task",
+            target: channel,
+            fetchImpl: bridgeFetch
           }
-        ]
-      };
-    } 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: z.string().describe("The channel \u2014 e.g. '#engineering'"),
-    task_number: z.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}` }]
+          };
         }
-      );
-      if (!res.ok) {
+        return {
+          content: [
+            { type: "text", text: `#${task_number} unclaimed \u2014 now open.` }
+          ]
+        };
+      } catch (err) {
         return {
           isError: true,
-          content: [{ type: "text", text: `Error: ${data.error}` }]
+          content: [{ type: "text", text: `Error: ${err.message}` }]
         };
       }
-      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. Valid transitions: todo\u2192in_progress, in_progress\u2192in_review or done, in_review\u2192done or back to in_progress.",
-  {
-    channel: z.string().describe("The channel \u2014 e.g. '#engineering'"),
-    task_number: z.number().describe("The task number to update (e.g. 3)"),
-    status: z.enum(["todo", "in_progress", "in_review", "done"]).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
+  );
+  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. Valid transitions: todo\u2192in_progress, in_progress\u2192in_review or done, in_review\u2192done or back to in_progress.",
+    {
+      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"]).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}` }]
+          };
         }
-      );
-      if (!res.ok) {
+        return {
+          content: [
+            { type: "text", text: `#${task_number} moved to ${status}.` }
+          ]
+        };
+      } catch (err) {
         return {
           isError: true,
-          content: [{ type: "text", text: `Error: ${data.error}` }]
+          content: [{ type: "text", text: `Error: ${err.message}` }]
         };
       }
-      return {
-        content: [
-          { type: "text", text: `#${task_number} moved to ${status}.` }
-        ]
-      };
-    } catch (err) {
-      return {
-        isError: true,
-        content: [{ type: "text", text: `Error: ${err.message}` }]
-      };
     }
-  }
-);
-function formatReminder(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}`;
-}
-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: z.string().describe("Short description of what the reminder is about. This is what you'll see when it fires."),
-    delay_seconds: z.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: z.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: z.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: z.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: z.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
+  );
+  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 (!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: z.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 (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}` }] };
         }
-      );
-      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." }] };
+        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}` }]
+        };
       }
-      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: z.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`,
+  );
+  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: "cancel_reminder.resolve",
+            toolName: "list_reminders",
             fetchImpl: bridgeFetch
           }
         );
-        if (!listRes.ok) {
-          return { isError: true, content: [{ type: "text", text: `Error: ${listData.error || listRes.statusText}` }] };
+        if (!res.ok) {
+          return { isError: true, content: [{ type: "text", text: `Error: ${data.error || res.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}'.` }] };
+        const list = data.reminders ?? [];
+        if (list.length === 0) {
+          return { content: [{ type: "text", text: "No reminders." }] };
         }
-        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;
+        return {
+          content: [
+            { type: "text", text: list.map(formatReminder).join("\n") }
+          ]
+        };
+      } catch (err) {
+        return {
+          isError: true,
+          content: [{ type: "text", text: `Error: ${err.message}` }]
+        };
       }
-      const { response: res, data } = await executeJsonRequest(
-        `${serverUrl}/internal/agent/${agentId}/reminders/${fullId}`,
-        { method: "DELETE", headers: commonHeaders },
-        {
-          toolName: "cancel_reminder",
-          fetchImpl: bridgeFetch
+    }
+  );
+  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;
         }
-      );
-      if (!res.ok || !data.reminder) {
-        return { isError: true, content: [{ type: "text", text: `Error: ${data.error || res.statusText}` }] };
+        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}` }]
+        };
       }
-      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);