@slock-ai/daemon 0.38.1 → 0.39.1-alpha.0

package/dist/cli/index.js

@@ -0,0 +1,1181 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/output.ts
+var CliExit = class extends Error {
+  constructor(exitCode) {
+    super(`CliExit(${exitCode})`);
+    this.exitCode = exitCode;
+    this.name = "CliExit";
+  }
+};
+function emit(payload) {
+  process.stdout.write(JSON.stringify(payload) + "\n");
+}
+function fail(code, message, exitCode = 1) {
+  process.stderr.write(JSON.stringify({ ok: false, code, message }) + "\n");
+  throw new CliExit(exitCode);
+}
+
+// src/auth/env.ts
+import fs from "fs";
+var AgentBootstrapError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AgentBootstrapError";
+  }
+};
+function readTokenFromFile(filePath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, "utf-8");
+  } catch (err) {
+    throw new AgentBootstrapError(
+      "TOKEN_FILE_UNREADABLE",
+      `SLOCK_AGENT_TOKEN_FILE=${filePath} could not be read: ${err.message}`
+    );
+  }
+  const token = raw.trim();
+  if (!token) {
+    throw new AgentBootstrapError(
+      "TOKEN_FILE_EMPTY",
+      `SLOCK_AGENT_TOKEN_FILE=${filePath} is empty`
+    );
+  }
+  return token;
+}
+function loadAgentContext(env = process.env) {
+  const agentId = env.SLOCK_AGENT_ID;
+  const serverUrl = env.SLOCK_SERVER_URL;
+  const serverId = env.SLOCK_SERVER_ID ?? null;
+  if (!agentId) throw new AgentBootstrapError("MISSING_AGENT_ID", "SLOCK_AGENT_ID is required");
+  if (!serverUrl) throw new AgentBootstrapError("MISSING_SERVER_URL", "SLOCK_SERVER_URL is required");
+  const tokenFile = env.SLOCK_AGENT_TOKEN_FILE;
+  if (tokenFile) {
+    return { agentId, serverUrl, serverId, token: readTokenFromFile(tokenFile), tokenSource: "token-file" };
+  }
+  const tokenLiteral = env.SLOCK_AGENT_TOKEN;
+  if (tokenLiteral) {
+    return { agentId, serverUrl, serverId, token: tokenLiteral, tokenSource: "env" };
+  }
+  throw new AgentBootstrapError(
+    "MISSING_TOKEN",
+    "Neither SLOCK_AGENT_TOKEN_FILE nor SLOCK_AGENT_TOKEN is set. The daemon should inject one of these when spawning the agent process."
+  );
+}
+
+// src/commands/auth/whoami.ts
+function registerWhoamiCommand(parent) {
+  parent.command("whoami").description("Print the agent context resolved from env (token value redacted)").action(() => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    emit({
+      ok: true,
+      data: {
+        agentId: ctx.agentId,
+        serverUrl: ctx.serverUrl,
+        serverId: ctx.serverId,
+        tokenSource: ctx.tokenSource
+      }
+    });
+  });
+}
+
+// src/proxy.ts
+import { ProxyAgent } from "undici";
+var fetchDispatcherCache = /* @__PURE__ */ new Map();
+function getDefaultPort(protocol) {
+  switch (protocol) {
+    case "https:":
+      return "443";
+    case "http:":
+      return "80";
+    default:
+      return "";
+  }
+}
+function hostMatchesNoProxyEntry(hostname, ruleHost) {
+  if (!ruleHost) return false;
+  const normalizedRule = ruleHost.replace(/^\*\./, ".").replace(/^\./, "").toLowerCase();
+  const normalizedHost = hostname.toLowerCase();
+  return normalizedHost === normalizedRule || normalizedHost.endsWith(`.${normalizedRule}`);
+}
+function getProxyUrlForTarget(targetUrl, env) {
+  const protocol = new URL(targetUrl).protocol;
+  switch (protocol) {
+    case "https:":
+      return env.HTTPS_PROXY || env.https_proxy || env.ALL_PROXY || env.all_proxy;
+    case "http:":
+      return env.HTTP_PROXY || env.http_proxy || env.ALL_PROXY || env.all_proxy;
+    default:
+      return env.ALL_PROXY || env.all_proxy;
+  }
+}
+function shouldBypassProxy(targetUrl, env) {
+  const rawNoProxy = env.NO_PROXY || env.no_proxy;
+  if (!rawNoProxy) return false;
+  const url = new URL(targetUrl);
+  const hostname = url.hostname.toLowerCase();
+  const port = url.port || getDefaultPort(url.protocol);
+  return rawNoProxy.split(",").map((entry) => entry.trim()).filter(Boolean).some((entry) => {
+    if (entry === "*") return true;
+    const [ruleHost, rulePort] = entry.split(":", 2);
+    if (rulePort && rulePort !== port) return false;
+    return hostMatchesNoProxyEntry(hostname, ruleHost);
+  });
+}
+function buildFetchDispatcher(targetUrl, env = process.env) {
+  const proxyUrl = getProxyUrlForTarget(targetUrl, env);
+  if (!proxyUrl) return void 0;
+  if (shouldBypassProxy(targetUrl, env)) return void 0;
+  const cached = fetchDispatcherCache.get(proxyUrl);
+  if (cached) return cached;
+  const dispatcher = new ProxyAgent(proxyUrl);
+  fetchDispatcherCache.set(proxyUrl, dispatcher);
+  return dispatcher;
+}
+
+// src/client.ts
+var ApiClient = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  buildAuthHeaders() {
+    const headers = {
+      "Authorization": `Bearer ${this.ctx.token}`,
+      "X-Agent-Id": this.ctx.agentId
+    };
+    if (this.ctx.serverId) headers["X-Server-Id"] = this.ctx.serverId;
+    return headers;
+  }
+  async parseJsonResponse(res) {
+    let data = null;
+    let error = null;
+    const contentType = res.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      const parsed = await res.json().catch(() => null);
+      if (res.ok) {
+        data = parsed;
+      } else {
+        error = parsed?.error ?? `HTTP ${res.status}`;
+      }
+    } else if (!res.ok) {
+      error = `HTTP ${res.status}`;
+    }
+    return { ok: res.ok, status: res.status, data, error };
+  }
+  async request(method, pathname, body) {
+    const url = new URL(pathname, this.ctx.serverUrl).toString();
+    const headers = this.buildAuthHeaders();
+    headers["Content-Type"] = "application/json";
+    const dispatcher = buildFetchDispatcher(url);
+    const init = {
+      method,
+      headers,
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    };
+    if (dispatcher) init.dispatcher = dispatcher;
+    const res = await fetch(url, init);
+    return this.parseJsonResponse(res);
+  }
+  // Multipart upload. Caller builds the FormData (file part + any text fields).
+  // Content-Type intentionally omitted so fetch sets the correct multipart
+  // boundary itself.
+  async requestMultipart(method, pathname, form) {
+    const url = new URL(pathname, this.ctx.serverUrl).toString();
+    const dispatcher = buildFetchDispatcher(url);
+    const init = {
+      method,
+      headers: this.buildAuthHeaders(),
+      body: form
+    };
+    if (dispatcher) init.dispatcher = dispatcher;
+    const res = await fetch(url, init);
+    return this.parseJsonResponse(res);
+  }
+  // Returns the raw Response so the caller can stream / save the body.
+  // For non-JSON downloads (binary attachments). Caller is responsible for
+  // consuming the body. On non-2xx, attempts to surface a JSON error.
+  async requestRaw(method, pathname) {
+    const url = new URL(pathname, this.ctx.serverUrl).toString();
+    const dispatcher = buildFetchDispatcher(url);
+    const init = {
+      method,
+      headers: this.buildAuthHeaders(),
+      redirect: "follow"
+    };
+    if (dispatcher) init.dispatcher = dispatcher;
+    const res = await fetch(url, init);
+    let error = null;
+    if (!res.ok) {
+      const contentType = res.headers.get("content-type") ?? "";
+      if (contentType.includes("application/json")) {
+        const parsed = await res.json().catch(() => null);
+        error = parsed?.error ?? `HTTP ${res.status}`;
+      } else {
+        error = `HTTP ${res.status}`;
+      }
+    }
+    return { ok: res.ok, status: res.status, response: res, error };
+  }
+};
+
+// src/commands/server/_format.ts
+function formatServerInfo(data) {
+  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 `slock message read --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}
+` : `  - #${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: slock message send --target "dm:@name" <<'EOF' followed by the message body and EOF. To reply in an existing DM: reuse the target from received messages.
+`;
+  if (humans.length > 0) {
+    for (const u of humans) {
+      text += u.description ? `  - @${u.name} \u2014 ${u.description}
+` : `  - @${u.name}
+`;
+    }
+  } else {
+    text += "  (none)\n";
+  }
+  return text;
+}
+
+// src/commands/server/info.ts
+function registerServerInfoCommand(parent) {
+  parent.command("info").description("List channels, agents, and humans on the current server").action(async () => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const client = new ApiClient(ctx);
+    const res = await client.request(
+      "GET",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/server`
+    );
+    if (!res.ok) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "INFO_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    process.stdout.write(formatServerInfo(res.data));
+  });
+}
+
+// src/commands/message/_format.ts
+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())}`;
+}
+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 formatSenderHandle(m) {
+  const name = m.sender_name ?? "unknown";
+  const desc = m.sender_description ?? null;
+  return desc ? `@${name} \u2014 ${desc}` : `@${name}`;
+}
+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 slock attachment view to download]`;
+}
+function formatMessageLine(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 content = 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)}: ${content}${attachSuffix}${taskSuffix}`;
+}
+function formatMessages(messages) {
+  if (messages.length === 0) return "No new messages.";
+  return messages.map(formatMessageLine).join("\n");
+}
+function formatHistoryMessageLine(m) {
+  const senderName = m.senderName ?? m.sender_name ?? "unknown";
+  const senderDescription = m.senderDescription ?? m.sender_description ?? null;
+  const headerParts = [
+    `seq=${m.seq}`,
+    `msg=${m.id || "-"}`,
+    `time=${m.createdAt ? toLocalTime(m.createdAt) : "-"}`
+  ];
+  if (m.senderType) headerParts.push(`type=${m.senderType}`);
+  if (m.threadId) headerParts.push(`threadId=${m.threadId}`);
+  if ((m.replyCount ?? 0) > 0) headerParts.push(`replyCount=${m.replyCount}`);
+  const attachSuffix = formatAttachmentSuffix(m.attachments);
+  const taskSuffix = m.taskStatus ? ` [task #${m.taskNumber} status=${m.taskStatus}${m.taskAssigneeId ? ` assignee=${m.taskAssigneeType}:${m.taskAssigneeId}` : ""}]` : "";
+  const handle = senderDescription ? `@${senderName} \u2014 ${senderDescription}` : `@${senderName}`;
+  return `[${headerParts.join(" ")}] ${handle}: ${m.content}${attachSuffix}${taskSuffix}`;
+}
+function formatHistory(channel, data, opts) {
+  if (!data.messages || data.messages.length === 0) return "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 (opts?.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 (opts?.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}${opts?.around ? ` around ${opts.around}` : ""} (${data.messages.length} messages)`;
+  if ((data.last_read_seq ?? 0) > 0 && !opts?.after && !opts?.before && !opts?.around) {
+    header += `
+Your last read position: seq ${data.last_read_seq}. Use slock message read --channel "${channel}" --after ${data.last_read_seq} to see only unread messages.`;
+  }
+  return `${header}
+
+${formatted}${footer}`;
+}
+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 formatSearchResults(query, data) {
+  if (!data.results || data.results.length === 0) return "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=${result.createdAt ? toLocalTime(result.createdAt) : "-"}`,
+      `target: ${target}${threadInfo}`,
+      `sender: @${result.senderName} (${result.senderType})`,
+      `content: ${result.content}`,
+      `match: ${result.snippet}`,
+      `next: slock message read --channel "${target}" --around "${result.id}" --limit 20`
+    ].join("\n");
+  }).join("\n\n");
+  return `## Search Results for "${query}" (${data.results.length} results)
+
+${formatted}`;
+}
+
+// src/commands/message/send.ts
+var SendContentError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "SendContentError";
+  }
+};
+async function readStream(stream) {
+  let content = "";
+  stream.setEncoding("utf8");
+  for await (const chunk of stream) {
+    content += String(chunk);
+  }
+  return content;
+}
+function missingContentMessage() {
+  return [
+    "No message content received on stdin.",
+    "Use a heredoc or pipe content into slock message send:",
+    `  slock message send --target "#channel" <<'EOF'`,
+    "  message body",
+    "  EOF"
+  ].join("\n");
+}
+async function resolveSendContent(input = process.stdin) {
+  if (input.isTTY) {
+    throw new SendContentError("MISSING_CONTENT", missingContentMessage());
+  }
+  const content = await readStream(input);
+  if (content.trim().length === 0) {
+    throw new SendContentError("MISSING_CONTENT", missingContentMessage());
+  }
+  return content;
+}
+function rejectArgContent(positionalContent, opts) {
+  if (positionalContent.length > 0) {
+    throw new SendContentError(
+      "POSITIONAL_CONTENT_UNSUPPORTED",
+      [
+        "Message content must be provided on stdin, not as positional arguments.",
+        "Use:",
+        `  slock message send --target "#channel" <<'EOF'`,
+        "  message body",
+        "  EOF"
+      ].join("\n")
+    );
+  }
+  if (opts.content !== void 0) {
+    throw new SendContentError(
+      "CONTENT_FLAG_UNSUPPORTED",
+      [
+        "--content is no longer supported. Pipe message content to stdin.",
+        "Use:",
+        `  printf 'hello' | slock message send --target "#channel"`
+      ].join("\n")
+    );
+  }
+}
+function registerSendCommand(parent) {
+  parent.command("send").description("Send a message to a channel, DM, or thread").argument("[content...]", "Unsupported positional message content. Pipe content to stdin instead.").requiredOption("--target <target>", "Target: '#channel', 'dm:@peer', '#channel:threadId', 'dm:@peer:threadId'").option("--content <content>", "Unsupported. Pipe message content to stdin instead.").option(
+    "--attachment-id <id>",
+    "Attachment id to link (repeatable). Get one from `slock attachment upload`.",
+    (value, prev = []) => prev.concat(value)
+  ).action(async (positionalContent, opts) => {
+    try {
+      rejectArgContent(positionalContent, opts);
+    } catch (err) {
+      if (err instanceof SendContentError) fail(err.code, err.message);
+      throw err;
+    }
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const client = new ApiClient(ctx);
+    let content;
+    try {
+      content = await resolveSendContent();
+    } catch (err) {
+      if (err instanceof SendContentError) fail(err.code, err.message);
+      throw err;
+    }
+    const body = { target: opts.target, content };
+    if (opts.attachmentId && opts.attachmentId.length > 0) {
+      body.attachmentIds = opts.attachmentId;
+    }
+    const res = await client.request(
+      "POST",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/send`,
+      body
+    );
+    if (!res.ok) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "SEND_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    const data = res.data;
+    const shortId = data.messageId ? data.messageId.slice(0, 8) : null;
+    const replyHint = shortId ? ` (to reply in this message's thread, use target "${opts.target.includes(":") ? opts.target : opts.target + ":" + shortId}")` : "";
+    let unreadSection = "";
+    if (data.recentUnread && data.recentUnread.length > 0) {
+      unreadSection = `
+
+--- New messages you may have missed ---
+${formatMessages(data.recentUnread)}`;
+    }
+    process.stdout.write(`Message sent to ${opts.target}. Message ID: ${data.messageId}${replyHint}${unreadSection}
+`);
+  });
+}
+
+// src/commands/message/_inbox.ts
+async function drainInbox(ctx, opts) {
+  const client = new ApiClient(ctx);
+  const agentPath = `/internal/agent/${encodeURIComponent(ctx.agentId)}`;
+  const failCode = opts.block ? "WAIT_FAILED" : "CHECK_FAILED";
+  const query = [];
+  if (opts.block) query.push("block=true");
+  if (opts.block && opts.timeoutMs !== void 0) query.push(`timeout=${opts.timeoutMs}`);
+  const path = query.length > 0 ? `${agentPath}/receive?${query.join("&")}` : `${agentPath}/receive`;
+  const res = await client.request("GET", path);
+  if (!res.ok) {
+    const code = res.status >= 500 ? "SERVER_5XX" : failCode;
+    fail(code, res.error ?? `HTTP ${res.status}`);
+  }
+  const messages = res.data?.messages ?? [];
+  const seqs = messages.map((m) => m.seq).filter((s) => Number.isInteger(s) && s > 0);
+  if (seqs.length === 0) return { messages };
+  const ack = await client.request("POST", `${agentPath}/receive-ack`, { seqs });
+  if (ack.ok) return { messages };
+  const ackCode = ack.status >= 500 ? "SERVER_5XX" : "ACK_FAILED";
+  const ackMessage = ack.error ?? `HTTP ${ack.status}`;
+  return { messages, ackFailure: { code: ackCode, message: ackMessage } };
+}
+
+// src/commands/message/check.ts
+function registerCheckCommand(parent) {
+  parent.command("check").description("Drain the agent inbox (non-blocking). Acks delivered seqs before returning.").action(async () => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const result = await drainInbox(ctx, { block: false });
+    process.stdout.write(formatMessages(result.messages) + "\n");
+  });
+}
+
+// src/commands/message/read.ts
+function parsePositiveInt(name, raw) {
+  if (raw === void 0) return void 0;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) {
+    fail("INVALID_ARG", `--${name} must be a positive integer; got ${raw}`);
+  }
+  return n;
+}
+function registerReadCommand(parent) {
+  parent.command("read").description("Read message history for a channel, DM, or thread").requiredOption("--channel <target>", "Target: '#channel', 'dm:@peer', '#channel:threadId', 'dm:@peer:threadId'").option("--before <seq>", "Return messages strictly before this seq (paginate backwards)").option("--after <seq>", "Return messages strictly after this seq (paginate forwards)").option("--around <idOrSeq>", "Center the window on this messageId or seq").option("--limit <n>", "Max messages to return (server default applies if omitted)").action(async (opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const before = parsePositiveInt("before", opts.before);
+    const after = parsePositiveInt("after", opts.after);
+    const limit = parsePositiveInt("limit", opts.limit);
+    const params = new URLSearchParams();
+    params.set("channel", opts.channel);
+    if (before !== void 0) params.set("before", String(before));
+    if (after !== void 0) params.set("after", String(after));
+    if (opts.around !== void 0) params.set("around", opts.around);
+    if (limit !== void 0) params.set("limit", String(limit));
+    const client = new ApiClient(ctx);
+    const res = await client.request(
+      "GET",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/history?${params.toString()}`
+    );
+    if (!res.ok) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "READ_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    process.stdout.write(formatHistory(opts.channel, res.data, { around: opts.around, after, before }) + "\n");
+  });
+}
+
+// src/commands/message/search.ts
+function registerSearchCommand(parent) {
+  parent.command("search").description("Search messages across channels the agent can see").requiredOption("--query <q>", "Search query string").option("--channel <target>", "Restrict to a single channel/DM/thread").option("--sender <id>", "Restrict to messages by this sender id").option("--before <iso>", "Only messages before this ISO datetime").option("--after <iso>", "Only messages after this ISO datetime").option("--limit <n>", "Max results (server default applies if omitted)").action(async (opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    let limit;
+    if (opts.limit !== void 0) {
+      const n = Number(opts.limit);
+      if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) {
+        fail("INVALID_ARG", `--limit must be a positive integer; got ${opts.limit}`);
+      }
+      limit = n;
+    }
+    const params = new URLSearchParams();
+    params.set("q", opts.query);
+    if (opts.channel) params.set("channel", opts.channel);
+    if (opts.sender) params.set("senderId", opts.sender);
+    if (opts.before) params.set("before", opts.before);
+    if (opts.after) params.set("after", opts.after);
+    if (limit !== void 0) params.set("limit", String(limit));
+    const client = new ApiClient(ctx);
+    const res = await client.request(
+      "GET",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/search?${params.toString()}`
+    );
+    if (!res.ok) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "SEARCH_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    process.stdout.write(formatSearchResults(opts.query, res.data) + "\n");
+  });
+}
+
+// src/commands/attachment/upload.ts
+import { existsSync, statSync, readFileSync } from "fs";
+import { basename } from "path";
+var MAX_BYTES = 10 * 1024 * 1024;
+function registerAttachmentUploadCommand(parent) {
+  parent.command("upload").description("Upload a local file as an attachment (max 10MB)").requiredOption("--path <filepath>", "Absolute path to the local file to upload").option(
+    "--channel <target>",
+    "Target where the attachment will be used: '#channel', 'dm:@peer', or thread variants. Required by the v0 server until channel-less uploads land."
+  ).action(async (opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    if (!existsSync(opts.path)) {
+      fail("INVALID_ARG", `--path does not exist: ${opts.path}`);
+    }
+    const stat = statSync(opts.path);
+    if (!stat.isFile()) {
+      fail("INVALID_ARG", `--path is not a regular file: ${opts.path}`);
+    }
+    if (stat.size > MAX_BYTES) {
+      fail(
+        "INVALID_ARG",
+        `--path is ${stat.size} bytes; max upload size is ${MAX_BYTES} bytes (10MB)`
+      );
+    }
+    if (!opts.channel) {
+      fail(
+        "MISSING_CHANNEL",
+        "v0 server requires a channel to attach the upload to. Pass --channel '#name', 'dm:@peer', or a thread target."
+      );
+    }
+    const client = new ApiClient(ctx);
+    const agentPath = `/internal/agent/${encodeURIComponent(ctx.agentId)}`;
+    const resolved = await client.request(
+      "POST",
+      `${agentPath}/resolve-channel`,
+      { target: opts.channel }
+    );
+    if (!resolved.ok || !resolved.data?.channelId) {
+      const code = resolved.status >= 500 ? "SERVER_5XX" : "RESOLVE_FAILED";
+      fail(code, resolved.error ?? `Could not resolve channel: ${opts.channel}`);
+    }
+    const channelId = resolved.data.channelId;
+    const buffer = readFileSync(opts.path);
+    const filename = basename(opts.path);
+    const blob = new Blob([buffer]);
+    const form = new FormData();
+    form.append("file", blob, filename);
+    form.append("channelId", channelId);
+    const res = await client.requestMultipart(
+      "POST",
+      `${agentPath}/upload`,
+      form
+    );
+    if (!res.ok) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "UPLOAD_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    const d = res.data;
+    process.stdout.write(`File uploaded: ${d.filename} (${(d.sizeBytes / 1024).toFixed(1)}KB)
+Attachment ID: ${d.id}
+
+Use this ID with slock message send --attachment-id ${d.id} to include it in a message.
+`);
+  });
+}
+
+// src/commands/attachment/view.ts
+import { writeFileSync } from "fs";
+function registerAttachmentViewCommand(parent) {
+  parent.command("view").description("Download an attachment by id and save it to a local path").requiredOption("--id <attachmentId>", "Attachment UUID").requiredOption("--output <path>", "Local path to write the file to").action(async (opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const client = new ApiClient(ctx);
+    const res = await client.requestRaw(
+      "GET",
+      `/api/attachments/${encodeURIComponent(opts.id)}`
+    );
+    if (!res.ok) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "VIEW_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    const buffer = Buffer.from(await res.response.arrayBuffer());
+    writeFileSync(opts.output, buffer);
+    process.stdout.write(`Downloaded to: ${opts.output}
+`);
+  });
+}
+
+// src/commands/task/_format.ts
+function formatTaskList(channel, data, statusFilter) {
+  if (!data.tasks || data.tasks.length === 0) {
+    return `No${statusFilter && statusFilter !== "all" ? ` ${statusFilter}` : ""} 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 `## Task Board for ${channel} (${data.tasks.length} tasks)
+
+${formatted}`;
+}
+function formatTasksCreated(channel, data) {
+  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 slock message send --target "${channel}:${t.messageId.slice(0, 8)}"`).join("\n");
+  return `Created ${data.tasks.length} task(s) in ${channel}:
+${created}
+
+To follow up in each task's thread:
+${threadHints}`;
+}
+function formatClaimResults(channel, data) {
+  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 slock message send --target "${channel}:${r.messageId.slice(0, 8)}"`).join("\n");
+  const threadHint = claimedMsgs ? `
+
+Follow up in each task's thread:
+${claimedMsgs}` : "";
+  return `Claim results (${summary}):
+${lines.join("\n")}${threadHint}`;
+}
+function formatTaskUnclaimed(taskNumber) {
+  return `#${taskNumber} unclaimed \u2014 now open.`;
+}
+function formatTaskStatusUpdated(taskNumber, status) {
+  return `#${taskNumber} moved to ${status}.`;
+}
+
+// src/commands/task/list.ts
+var VALID_STATUSES = /* @__PURE__ */ new Set(["all", "todo", "in_progress", "in_review", "done"]);
+function registerTaskListCommand(parent) {
+  parent.command("list").description("List tasks in a channel").requiredOption("--channel <target>", "Channel target: '#channel'").option("--status <s>", "Filter: all|todo|in_progress|in_review|done (default: server-side)").action(async (opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    if (opts.status && !VALID_STATUSES.has(opts.status)) {
+      fail("INVALID_ARG", `--status must be one of ${Array.from(VALID_STATUSES).join("|")}; got ${opts.status}`);
+    }
+    const params = new URLSearchParams();
+    params.set("channel", opts.channel);
+    if (opts.status) params.set("status", opts.status);
+    const client = new ApiClient(ctx);
+    const res = await client.request(
+      "GET",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/tasks?${params.toString()}`
+    );
+    if (!res.ok) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "LIST_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    process.stdout.write(formatTaskList(opts.channel, res.data, opts.status) + "\n");
+  });
+}
+
+// src/commands/task/create.ts
+function registerTaskCreateCommand(parent) {
+  parent.command("create").description("Create one or more tasks in a channel").requiredOption("--channel <target>", "Channel target: '#channel'").requiredOption(
+    "--title <title>",
+    "Task title (repeatable for batch create)",
+    (value, prev = []) => prev.concat(value)
+  ).action(async (opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const titles = opts.title ?? [];
+    if (titles.length === 0) fail("INVALID_ARG", "--title is required (at least one)");
+    const client = new ApiClient(ctx);
+    const res = await client.request(
+      "POST",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/tasks`,
+      { channel: opts.channel, tasks: titles.map((title) => ({ title })) }
+    );
+    if (!res.ok) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "CREATE_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    process.stdout.write(formatTasksCreated(opts.channel, res.data) + "\n");
+  });
+}
+
+// src/commands/task/claim.ts
+function registerTaskClaimCommand(parent) {
+  parent.command("claim").description("Claim one or more tasks (by task number or message id)").requiredOption("--channel <target>", "Channel target: '#channel'").option(
+    "--number <n>",
+    "Task number to claim (repeatable)",
+    (value, prev = []) => prev.concat(value)
+  ).option(
+    "--message-id <id>",
+    "Message id (full or short) to claim (repeatable)",
+    (value, prev = []) => prev.concat(value)
+  ).action(async (opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const numbers = (opts.number ?? []).map((raw) => {
+      const n = Number(raw);
+      if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) {
+        fail("INVALID_ARG", `--number must be a positive integer; got ${raw}`);
+      }
+      return n;
+    });
+    const messageIds = opts.messageId ?? [];
+    if (numbers.length === 0 && messageIds.length === 0) {
+      fail("INVALID_ARG", "Provide at least one --number or --message-id");
+    }
+    const body = { channel: opts.channel };
+    if (numbers.length > 0) body.task_numbers = numbers;
+    if (messageIds.length > 0) body.message_ids = messageIds;
+    const client = new ApiClient(ctx);
+    const res = await client.request(
+      "POST",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/tasks/claim`,
+      body
+    );
+    if (!res.ok) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "CLAIM_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    process.stdout.write(formatClaimResults(opts.channel, res.data) + "\n");
+  });
+}
+
+// src/commands/task/unclaim.ts
+function registerTaskUnclaimCommand(parent) {
+  parent.command("unclaim").description("Release a previously-claimed task").requiredOption("--channel <target>", "Channel target: '#channel'").requiredOption("--number <n>", "Task number to unclaim").action(async (opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const n = Number(opts.number);
+    if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) {
+      fail("INVALID_ARG", `--number must be a positive integer; got ${opts.number}`);
+    }
+    const client = new ApiClient(ctx);
+    const res = await client.request(
+      "POST",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/tasks/unclaim`,
+      { channel: opts.channel, task_number: n }
+    );
+    if (!res.ok) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "UNCLAIM_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    process.stdout.write(formatTaskUnclaimed(n) + "\n");
+  });
+}
+
+// src/commands/task/update.ts
+var STATUSES = ["todo", "in_progress", "in_review", "done"];
+function registerTaskUpdateCommand(parent) {
+  parent.command("update").description("Update task status").requiredOption("--channel <target>", "Channel target: '#channel'").requiredOption("--number <n>", "Task number to update").requiredOption(
+    "--status <status>",
+    `New status. One of: ${STATUSES.join(", ")}`
+  ).action(async (opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const n = Number(opts.number);
+    if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) {
+      fail("INVALID_ARG", `--number must be a positive integer; got ${opts.number}`);
+    }
+    if (!STATUSES.includes(opts.status)) {
+      fail(
+        "INVALID_ARG",
+        `--status must be one of: ${STATUSES.join(", ")}; got ${opts.status}`
+      );
+    }
+    const client = new ApiClient(ctx);
+    const res = await client.request(
+      "POST",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/tasks/update-status`,
+      { channel: opts.channel, task_number: n, status: opts.status }
+    );
+    if (!res.ok) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "UPDATE_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    process.stdout.write(formatTaskStatusUpdated(n, opts.status) + "\n");
+  });
+}
+
+// src/commands/reminder/_format.ts
+function toLocalTime2(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())}`;
+}
+function formatReminder(r) {
+  const fireLocal = toLocalTime2(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}`;
+}
+function formatReminderScheduled(r, warning) {
+  const lines = [`Reminder scheduled: ${formatReminder(r)}`];
+  if (warning) lines.push(`Warning: ${warning}`);
+  return lines.join("\n");
+}
+function formatReminderList(reminders) {
+  if (reminders.length === 0) return "No reminders.";
+  return reminders.map(formatReminder).join("\n");
+}
+function formatReminderCanceled(r) {
+  return `Reminder canceled: ${formatReminder(r)}`;
+}
+
+// src/commands/reminder/schedule.ts
+function registerReminderScheduleCommand(parent) {
+  parent.command("schedule").description("Schedule a reminder that fires at a future time").requiredOption("--title <t>", "Short description of what the reminder is about").option(
+    "--delay-seconds <n>",
+    "Preferred for relative times. Fires this many seconds from now (server-computed, timezone-safe)"
+  ).option(
+    "--fire-at <iso>",
+    "ISO-8601 UTC timestamp, e.g. 2026-04-21T09:00:00Z. Use only for absolute calendar times"
+  ).option(
+    "--repeat <rule>",
+    "Recurrence rule: every:15m | every:2h | every:1d | daily@09:00 | weekly:mon,fri@09:00"
+  ).option(
+    "--channel <ref>",
+    "Optional channel to post a receipt message in (e.g. #general, dm:@alice). Without this, receipt is only posted when --msg-id is given."
+  ).option("--msg-id <id>", "Optional message id this reminder is anchored to").action(async (opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    if (!opts.delaySeconds && !opts.fireAt && !opts.repeat) {
+      fail("INVALID_ARG", "Provide --delay-seconds, --fire-at, or --repeat");
+    }
+    if (opts.delaySeconds && opts.fireAt) {
+      fail("INVALID_ARG", "Pass either --delay-seconds or --fire-at, not both");
+    }
+    const body = { title: opts.title, msgId: opts.msgId ?? null };
+    if (opts.delaySeconds !== void 0) {
+      const n = Number(opts.delaySeconds);
+      if (!Number.isFinite(n) || !Number.isInteger(n) || n <= 0) {
+        fail("INVALID_ARG", `--delay-seconds must be a positive integer; got ${opts.delaySeconds}`);
+      }
+      body.delaySeconds = n;
+    }
+    if (opts.fireAt !== void 0) body.fireAt = opts.fireAt;
+    if (opts.repeat !== void 0) {
+      body.repeat = opts.repeat;
+      body.tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    }
+    if (opts.channel !== void 0) body.channel = opts.channel;
+    const client = new ApiClient(ctx);
+    const res = await client.request(
+      "POST",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/reminders`,
+      body
+    );
+    if (!res.ok || !res.data?.reminder) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "SCHEDULE_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    process.stdout.write(formatReminderScheduled(res.data.reminder, res.data.warning ?? null) + "\n");
+  });
+}
+
+// src/commands/reminder/list.ts
+var VALID_STATUSES2 = /* @__PURE__ */ new Set(["scheduled", "fired", "canceled"]);
+function registerReminderListCommand(parent) {
+  parent.command("list").description("List your own reminders (defaults to scheduled)").option(
+    "--status <s>",
+    "Comma-separated statuses (scheduled,fired,canceled). Default: scheduled"
+  ).action(async (opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const statusRaw = opts.status && opts.status.trim().length > 0 ? opts.status.trim() : "scheduled";
+    for (const s of statusRaw.split(",").map((x) => x.trim()).filter(Boolean)) {
+      if (!VALID_STATUSES2.has(s)) {
+        fail("INVALID_ARG", `--status entries must be one of ${Array.from(VALID_STATUSES2).join("|")}; got ${s}`);
+      }
+    }
+    const params = new URLSearchParams();
+    params.set("status", statusRaw);
+    const client = new ApiClient(ctx);
+    const res = await client.request(
+      "GET",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/reminders?${params.toString()}`
+    );
+    if (!res.ok) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "LIST_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    process.stdout.write(formatReminderList(res.data?.reminders ?? []) + "\n");
+  });
+}
+
+// src/commands/reminder/cancel.ts
+function registerReminderCancelCommand(parent) {
+  parent.command("cancel").description("Cancel a scheduled reminder by id (full uuid or 8-char prefix)").requiredOption("--id <id>", "Reminder id (full uuid or short prefix)").action(async (opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    if (!opts.id || opts.id.trim().length === 0) {
+      fail("INVALID_ARG", "--id is required");
+    }
+    const client = new ApiClient(ctx);
+    let fullId = opts.id;
+    if (opts.id.length < 32) {
+      const listRes = await client.request(
+        "GET",
+        `/internal/agent/${encodeURIComponent(ctx.agentId)}/reminders?status=scheduled`
+      );
+      if (!listRes.ok) {
+        const code = listRes.status >= 500 ? "SERVER_5XX" : "CANCEL_FAILED";
+        fail(code, listRes.error ?? `HTTP ${listRes.status}`);
+      }
+      const matches = (listRes.data?.reminders ?? []).filter((r) => r.reminderId.startsWith(opts.id));
+      if (matches.length === 0) {
+        fail("NOT_FOUND", `No scheduled reminder matches id prefix '${opts.id}'.`);
+      }
+      if (matches.length > 1) {
+        fail("AMBIGUOUS", `Ambiguous id prefix '${opts.id}' matches ${matches.length} reminders; pass a longer id.`);
+      }
+      fullId = matches[0].reminderId;
+    }
+    const res = await client.request(
+      "DELETE",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/reminders/${encodeURIComponent(fullId)}`
+    );
+    if (!res.ok || !res.data?.reminder) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "CANCEL_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    process.stdout.write(formatReminderCanceled(res.data.reminder) + "\n");
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("slock").description(
+  "Agent-facing execution interface for Slock. Invoked by daemon-spawned agent processes \u2014 not a user-facing CLI product."
+).version("0.0.1");
+var authCmd = program.command("auth").description("Auth introspection");
+registerWhoamiCommand(authCmd);
+var serverCmd = program.command("server").description("Server / workspace introspection");
+registerServerInfoCommand(serverCmd);
+var messageCmd = program.command("message").description("Message operations");
+registerSendCommand(messageCmd);
+registerCheckCommand(messageCmd);
+registerReadCommand(messageCmd);
+registerSearchCommand(messageCmd);
+var attachmentCmd = program.command("attachment").description("Attachment operations");
+registerAttachmentUploadCommand(attachmentCmd);
+registerAttachmentViewCommand(attachmentCmd);
+var taskCmd = program.command("task").description("Task board operations");
+registerTaskListCommand(taskCmd);
+registerTaskCreateCommand(taskCmd);
+registerTaskClaimCommand(taskCmd);
+registerTaskUnclaimCommand(taskCmd);
+registerTaskUpdateCommand(taskCmd);
+var reminderCmd = program.command("reminder").description("Reminder operations");
+registerReminderScheduleCommand(reminderCmd);
+registerReminderListCommand(reminderCmd);
+registerReminderCancelCommand(reminderCmd);
+program.parseAsync().catch((err) => {
+  if (err instanceof CliExit) {
+    process.exitCode = err.exitCode;
+  } else {
+    process.stderr.write(`Unexpected error: ${err?.message ?? err}
+`);
+    process.exitCode = 1;
+  }
+});