@slock-ai/cli 0.0.1

package/dist/index.js

@@ -0,0 +1,1921 @@
+#!/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;
+    let errorCode = 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}`;
+        errorCode = parsed?.errorCode ?? null;
+      }
+    } else if (!res.ok) {
+      error = `HTTP ${res.status}`;
+    }
+    return { ok: res.ok, status: res.status, data, error, errorCode };
+  }
+  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 formatRuntimeContext(ctx) {
+  if (!ctx) return "";
+  const lines = [
+    "### Current Runtime",
+    "Authoritative context for this agent process. Do not infer computer identity from hostname or cwd when this section is present."
+  ];
+  if (ctx.agentId) lines.push(`- Agent ID: ${ctx.agentId}`);
+  if (ctx.serverId) lines.push(`- Server ID: ${ctx.serverId}`);
+  if (ctx.machineName || ctx.machineId) {
+    const label = ctx.machineName && ctx.machineId ? `${ctx.machineName} (${ctx.machineId})` : ctx.machineName || ctx.machineId;
+    lines.push(`- Computer: ${label}`);
+  }
+  if (ctx.machineHostname) lines.push(`- Hostname: ${ctx.machineHostname}`);
+  if (ctx.machineOs) lines.push(`- OS: ${ctx.machineOs}`);
+  if (ctx.daemonVersion) lines.push(`- Daemon: v${ctx.daemonVersion}`);
+  if (ctx.workspacePath) lines.push(`- Workspace: ${ctx.workspacePath}`);
+  return lines.length > 2 ? `${lines.join("\n")}
+
+` : "";
+}
+function formatServerInfo(data) {
+  let text = "## Server\n\n";
+  const channels = data.channels ?? [];
+  const agents = data.agents ?? [];
+  const humans = data.humans ?? [];
+  text += formatRuntimeContext(data.runtimeContext);
+  text += "### Channels\n";
+  text += 'Visible public channels may appear even when `joined=false`. 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. To leave a channel you have joined, use `slock channel leave --target "#name"`. To stop following a thread, use `slock thread unfollow --target "#name:shortid"`.\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;
+}
+function formatChannelMembers(data) {
+  let text = "## Channel Members\n\n";
+  const ref = data.channel?.ref ?? "(unknown)";
+  const type = data.channel?.type ? ` (${data.channel.type})` : "";
+  const agents = data.agents ?? [];
+  const humans = data.humans ?? [];
+  text += `Channel: ${ref}${type}
+`;
+  text += "Members means join/post authority for this surface.\n\n";
+  text += "### Agents\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";
+  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/channel/members.ts
+function registerChannelMembersCommand(parent) {
+  parent.command("members").description("List agents and humans who are members of a channel, DM, or thread").argument("<target>", "Channel / DM / thread target, e.g. #proj-runtime, dm:@alice, #proj-runtime:abcd1234").action(async (target) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const client = new ApiClient(ctx);
+    const channel = String(target || "").trim();
+    if (!channel) fail("MEMBERS_FAILED", "target is required");
+    const encoded = encodeURIComponent(channel);
+    const res = await client.request(
+      "GET",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/channel-members?channel=${encoded}`
+    );
+    if (!res.ok) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "MEMBERS_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    process.stdout.write(formatChannelMembers(res.data));
+  });
+}
+
+// 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}`);
+    }
+    const data = res.data;
+    if (data?.runtimeContext) {
+      data.runtimeContext = {
+        ...data.runtimeContext,
+        workspacePath: data.runtimeContext.workspacePath ?? process.env.SLOCK_CURRENT_WORKSPACE_PATH ?? null
+      };
+    }
+    process.stdout.write(formatServerInfo(data));
+  });
+}
+
+// src/commands/channel/leave.ts
+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;
+}
+function formatLeaveChannelResult(target) {
+  return `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.`;
+}
+function formatAlreadyNotJoined(target) {
+  return `Already not joined in ${target}.`;
+}
+function registerChannelLeaveCommand(parent) {
+  parent.command("leave").description("Leave a regular channel you have joined").requiredOption("--target <target>", "Regular channel to leave, e.g. '#engineering'").action(async (opts) => {
+    const channelName = parseRegularChannelTarget(opts.target);
+    if (!channelName) {
+      fail("INVALID_TARGET", "Target must be a regular channel in the form '#channel-name'. DMs and thread targets are not supported.");
+    }
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const client = new ApiClient(ctx);
+    const infoRes = await client.request(
+      "GET",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/server`
+    );
+    if (!infoRes.ok) {
+      const code = infoRes.status >= 500 ? "SERVER_5XX" : "INFO_FAILED";
+      fail(code, infoRes.error ?? `HTTP ${infoRes.status}`);
+    }
+    const channel = (infoRes.data?.channels ?? []).find((candidate) => candidate.name === channelName);
+    if (!channel) {
+      fail("NOT_FOUND", `Channel not found: ${opts.target}`);
+    }
+    if (!channel.joined) {
+      process.stdout.write(formatAlreadyNotJoined(opts.target) + "\n");
+      return;
+    }
+    const leaveRes = await client.request(
+      "POST",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/channels/${encodeURIComponent(channel.id)}/leave`
+    );
+    if (!leaveRes.ok) {
+      const code = leaveRes.status >= 500 ? "SERVER_5XX" : "LEAVE_FAILED";
+      fail(code, leaveRes.error ?? `HTTP ${leaveRes.status}`);
+    }
+    process.stdout.write(formatLeaveChannelResult(opts.target) + "\n");
+  });
+}
+
+// src/commands/thread/unfollow.ts
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var SHORT_ID_RE = /^[0-9a-f]{8}$/i;
+function parseThreadTarget(target) {
+  const trimmed = target.trim();
+  if (UUID_RE.test(trimmed)) return trimmed;
+  if (trimmed.startsWith("#")) {
+    const rest = trimmed.slice(1);
+    const lastColon = rest.lastIndexOf(":");
+    if (lastColon > 0 && SHORT_ID_RE.test(rest.slice(lastColon + 1))) {
+      return trimmed;
+    }
+  }
+  if (trimmed.startsWith("dm:@") || trimmed.startsWith("DM:@")) {
+    const rest = trimmed.slice(4);
+    const lastColon = rest.lastIndexOf(":");
+    if (lastColon > 0 && SHORT_ID_RE.test(rest.slice(lastColon + 1))) {
+      return trimmed;
+    }
+  }
+  return null;
+}
+function formatUnfollowThreadResult(target) {
+  return `Unfollowed ${target}. You can still inspect the thread when its parent conversation is visible, but you will no longer receive ordinary thread delivery unless you follow it again or are mentioned.`;
+}
+function registerThreadUnfollowCommand(parent) {
+  parent.command("unfollow").description("Stop following a thread you no longer need ordinary delivery for").requiredOption("--target <target>", "Thread target, e.g. '#engineering:abcd1234' or 'dm:@alice:abcd1234'").action(async (opts) => {
+    const thread = parseThreadTarget(opts.target);
+    if (!thread) {
+      fail("INVALID_TARGET", "Thread must be a thread target like '#channel:abcd1234', 'dm:@peer:abcd1234', or a thread channel UUID.");
+    }
+    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(
+      "POST",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/threads/unfollow`,
+      { thread }
+    );
+    if (!res.ok) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "UNFOLLOW_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    process.stdout.write(formatUnfollowThreadResult(thread) + "\n");
+  });
+}
+
+// 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;
+var FILENAME_MIME_MAP = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json",
+  ".csv": "text/csv"
+};
+var MIME_TYPE_RE = /^[a-z0-9][a-z0-9!#$&^_.+-]*\/[a-z0-9][a-z0-9!#$&^_.+-]*$/i;
+var AttachmentUploadArgError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AttachmentUploadArgError";
+  }
+};
+function inferMimeTypeFromFilename(filename) {
+  const index = filename.lastIndexOf(".");
+  const ext = index >= 0 ? filename.slice(index).toLowerCase() : "";
+  return FILENAME_MIME_MAP[ext] || null;
+}
+function inferMimeTypeFromBuffer(buffer) {
+  if (buffer.length >= 8 && buffer.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    return "image/png";
+  }
+  if (buffer.length >= 3 && buffer.subarray(0, 3).equals(Buffer.from([255, 216, 255]))) {
+    return "image/jpeg";
+  }
+  if (buffer.length >= 6) {
+    const header = buffer.subarray(0, 6).toString("ascii");
+    if (header === "GIF87a" || header === "GIF89a") return "image/gif";
+  }
+  if (buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP") {
+    return "image/webp";
+  }
+  return null;
+}
+function normalizeExplicitMimeType(mimeType) {
+  const normalized = mimeType?.trim().toLowerCase();
+  if (!normalized) return null;
+  if (!MIME_TYPE_RE.test(normalized)) {
+    throw new AttachmentUploadArgError(
+      "INVALID_ARG",
+      `--mime-type must look like type/subtype, got: ${mimeType}`
+    );
+  }
+  return normalized;
+}
+function inferUploadMimeType(filename, buffer, explicitMimeType) {
+  const explicit = normalizeExplicitMimeType(explicitMimeType);
+  return explicit || inferMimeTypeFromBuffer(buffer) || inferMimeTypeFromFilename(filename) || "application/octet-stream";
+}
+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."
+  ).option("--mime-type <type>", "Explicit MIME type override, e.g. image/png").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);
+    let explicitMimeType;
+    try {
+      explicitMimeType = normalizeExplicitMimeType(opts.mimeType);
+    } catch (err) {
+      if (err instanceof AttachmentUploadArgError) fail(err.code, err.message);
+      throw err;
+    }
+    const uploadMimeType = inferUploadMimeType(filename, buffer, explicitMimeType);
+    const blob = new Blob([buffer], { type: uploadMimeType });
+    const form = new FormData();
+    form.append("file", blob, filename);
+    form.append("channelId", channelId);
+    if (explicitMimeType) {
+      form.append("mimeType", explicitMimeType);
+    }
+    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");
+  });
+}
+
+// ../shared/src/tracing/index.ts
+var DEFAULT_TRACE_FLAGS = "00";
+var TRACE_ID_HEX_LENGTH = 32;
+var SPAN_ID_HEX_LENGTH = 16;
+var TRACE_FLAGS_HEX_LENGTH = 2;
+var TRACE_ID_PATTERN = /^[0-9a-f]{32}$/;
+var SPAN_ID_PATTERN = /^[0-9a-f]{16}$/;
+var TRACE_FLAGS_PATTERN = /^[0-9a-f]{2}$/;
+function isTraceId(value) {
+  return TRACE_ID_PATTERN.test(value) && value !== "0".repeat(TRACE_ID_HEX_LENGTH);
+}
+function isSpanId(value) {
+  return SPAN_ID_PATTERN.test(value) && value !== "0".repeat(SPAN_ID_HEX_LENGTH);
+}
+function isTraceFlags(value) {
+  return TRACE_FLAGS_PATTERN.test(value);
+}
+function assertTraceContext(context) {
+  if (!isTraceId(context.traceId)) {
+    throw new Error(`Invalid traceId: expected ${TRACE_ID_HEX_LENGTH} lowercase hex chars`);
+  }
+  if (!isSpanId(context.spanId)) {
+    throw new Error(`Invalid spanId: expected ${SPAN_ID_HEX_LENGTH} lowercase hex chars`);
+  }
+  if (context.parentSpanId !== null && !isSpanId(context.parentSpanId)) {
+    throw new Error(`Invalid parentSpanId: expected null or ${SPAN_ID_HEX_LENGTH} lowercase hex chars`);
+  }
+  if (!isTraceFlags(context.traceFlags)) {
+    throw new Error(`Invalid traceFlags: expected ${TRACE_FLAGS_HEX_LENGTH} lowercase hex chars`);
+  }
+}
+function createTraceContext({
+  parent = null,
+  traceId,
+  spanId,
+  traceFlags,
+  traceIdGenerator = generateTraceId,
+  spanIdGenerator = generateSpanId
+} = {}) {
+  const context = {
+    traceId: traceId ?? parent?.traceId ?? traceIdGenerator(),
+    spanId: spanId ?? spanIdGenerator(),
+    parentSpanId: parent?.spanId ?? null,
+    traceFlags: traceFlags ?? parent?.traceFlags ?? DEFAULT_TRACE_FLAGS
+  };
+  assertTraceContext(context);
+  return context;
+}
+var NoopTracer = class {
+  startSpan(_name, options) {
+    return new NoopActiveSpan(createTraceContext({ parent: options.parent ?? null }));
+  }
+};
+var NoopActiveSpan = class {
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+  addEvent() {
+  }
+  end() {
+  }
+};
+var noopTracer = new NoopTracer();
+function generateTraceId() {
+  return randomNonZeroHex(TRACE_ID_HEX_LENGTH);
+}
+function generateSpanId() {
+  return randomNonZeroHex(SPAN_ID_HEX_LENGTH);
+}
+function randomNonZeroHex(length) {
+  let value = randomHex(length);
+  while (value === "0".repeat(length)) {
+    value = randomHex(length);
+  }
+  return value;
+}
+function randomHex(length) {
+  const bytes = new Uint8Array(length / 2);
+  globalThis.crypto.getRandomValues(bytes);
+  return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+// ../shared/src/testing/failpoints.ts
+var NoopFailpointRegistry = class {
+  get enabled() {
+    return false;
+  }
+  isEnabled() {
+    return false;
+  }
+  configure() {
+  }
+  clear() {
+  }
+  getTrace() {
+    return [];
+  }
+  hit(_key, _context, fallback) {
+    return fallback ? fallback() : void 0;
+  }
+};
+var noopFailpointRegistry = new NoopFailpointRegistry();
+
+// ../shared/src/serverPermissions.ts
+var EMPTY_SERVER_CAPABILITIES = Object.freeze({
+  manageServer: false,
+  manageChannels: false,
+  manageAgents: false,
+  manageMachines: false,
+  manageMembers: false,
+  changeMemberRoles: false,
+  manageBilling: false,
+  joinPublicChannels: false
+});
+var SERVER_CAPABILITY_MATRIX = {
+  owner: Object.freeze({
+    manageServer: true,
+    manageChannels: true,
+    manageAgents: true,
+    manageMachines: true,
+    manageMembers: true,
+    changeMemberRoles: true,
+    manageBilling: true,
+    joinPublicChannels: true
+  }),
+  admin: Object.freeze({
+    manageServer: true,
+    manageChannels: true,
+    manageAgents: true,
+    manageMachines: true,
+    manageMembers: true,
+    changeMemberRoles: true,
+    manageBilling: false,
+    joinPublicChannels: true
+  }),
+  member: Object.freeze({
+    manageServer: false,
+    manageChannels: false,
+    manageAgents: false,
+    manageMachines: false,
+    manageMembers: false,
+    changeMemberRoles: false,
+    manageBilling: false,
+    joinPublicChannels: true
+  })
+};
+
+// ../shared/src/index.ts
+var RUNTIMES = [
+  { id: "claude", displayName: "Claude Code", binary: "claude", supported: true },
+  { id: "codex", displayName: "Codex CLI", binary: "codex", supported: true },
+  { id: "kimi", displayName: "Kimi CLI", binary: "kimi", supported: true },
+  { id: "copilot", displayName: "Copilot CLI", binary: "copilot", supported: true },
+  { id: "cursor", displayName: "Cursor CLI", binary: "cursor-agent", supported: true },
+  { id: "gemini", displayName: "Gemini CLI", binary: "gemini", supported: true }
+];
+function getRuntimeDisplayName(id) {
+  return RUNTIMES.find((r) => r.id === id)?.displayName ?? id;
+}
+var PLAN_CONFIG = {
+  free: {
+    displayName: "Hobby",
+    limits: { maxMachines: 2, maxAgents: 5, maxChannels: 5, messageHistoryDays: 30, includedAgents: 5 },
+    comingSoon: false,
+    price: 0,
+    extraAgentPrice: 0
+  },
+  founder: {
+    displayName: "Founder",
+    limits: { maxMachines: -1, maxAgents: -1, maxChannels: -1, messageHistoryDays: -1, includedAgents: -1 },
+    comingSoon: false,
+    price: 0,
+    extraAgentPrice: 0
+  }
+};
+var DISPLAY_PLAN_CONFIG = {
+  free: PLAN_CONFIG.free,
+  pro: {
+    displayName: "Team",
+    limits: { maxMachines: 8, maxAgents: 40, maxChannels: 20, messageHistoryDays: -1, includedAgents: 40 },
+    comingSoon: true,
+    price: 20,
+    extraAgentPrice: 0
+  },
+  max: {
+    displayName: "Business",
+    limits: { maxMachines: 40, maxAgents: 200, maxChannels: -1, messageHistoryDays: -1, includedAgents: 200 },
+    comingSoon: true,
+    price: 200,
+    extraAgentPrice: 0
+  }
+};
+
+// src/commands/profile/_format.ts
+function formatCreatedAgents(createdAgents) {
+  if (createdAgents.length === 0) {
+    return ["- Created Agents: none"];
+  }
+  return [
+    `- Created Agents (${createdAgents.length}):`,
+    ...createdAgents.map((createdAgent) => `  - @${createdAgent.name} (${getRuntimeDisplayName(createdAgent.runtime)}, ${createdAgent.status})`)
+  ];
+}
+function formatHumanProfile(profile) {
+  const lines = [
+    "## Profile",
+    "",
+    "- Type: human",
+    `- Handle: @${profile.name}`,
+    `- Display Name: ${profile.displayName ?? "(none)"}`,
+    `- Description: ${profile.description ?? "(none)"}`,
+    `- Membership: ${profile.membershipStatus}`
+  ];
+  if (profile.role) lines.push(`- Role: ${profile.role}`);
+  if (profile.joinedAt) lines.push(`- Joined: ${profile.joinedAt}`);
+  if (profile.email) lines.push(`- Email: ${profile.email}`);
+  return [...lines, ...formatCreatedAgents(profile.createdAgents)].join("\n");
+}
+function formatCreator(profile) {
+  if (!profile.creator) return null;
+  return profile.creator.displayName ? `${profile.creator.displayName} (@${profile.creator.name})` : `@${profile.creator.name}`;
+}
+function formatAgentProfile(profile) {
+  const lines = [
+    "## Profile",
+    "",
+    "- Type: agent",
+    `- Handle: @${profile.name}`,
+    `- Display Name: ${profile.displayName ?? "(none)"}`,
+    `- Description: ${profile.description ?? "(none)"}`,
+    `- Status: ${profile.status}`,
+    `- Runtime: ${getRuntimeDisplayName(profile.runtime)}`,
+    `- Model: ${profile.model}`,
+    `- Reasoning: ${profile.reasoningEffort ?? "medium"}`
+  ];
+  if (profile.executionMode) lines.push(`- Execution: ${profile.executionMode}`);
+  if (profile.computerName || profile.computerId) {
+    const label = profile.computerName && profile.computerId ? `${profile.computerName} (${profile.computerId})` : profile.computerName ?? profile.computerId;
+    lines.push(`- Computer: ${label}`);
+  }
+  if (profile.computerHostname) lines.push(`- Hostname: ${profile.computerHostname}`);
+  if (profile.daemonVersion) lines.push(`- Daemon: v${profile.daemonVersion}`);
+  lines.push(`- Created: ${profile.createdAt}`);
+  if (profile.deletedAt) lines.push(`- Deleted At: ${profile.deletedAt}`);
+  const creator = formatCreator(profile);
+  if (creator) lines.push(`- Creator: ${creator}`);
+  return [...lines, ...formatCreatedAgents(profile.createdAgents)].join("\n");
+}
+function formatProfile(profile) {
+  return profile.kind === "human" ? formatHumanProfile(profile) : formatAgentProfile(profile);
+}
+
+// src/commands/profile/show.ts
+function normalizeTarget(target) {
+  if (target === void 0) return null;
+  const trimmed = target.trim();
+  if (!trimmed) {
+    fail("INVALID_ARG", "profile target must not be empty");
+  }
+  if (!trimmed.startsWith("@")) {
+    fail("INVALID_ARG", "profile target must start with @");
+  }
+  return trimmed;
+}
+function registerProfileShowCommand(parent) {
+  parent.command("show").description("Show a profile. Omit the target to show your own profile.").argument("[target]", "Handle like @alice; omit to show your own profile").option("--json", "Emit machine-readable JSON").action(async (target, opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const normalizedTarget = normalizeTarget(target);
+    const params = new URLSearchParams();
+    if (normalizedTarget) params.set("target", normalizedTarget);
+    const client = new ApiClient(ctx);
+    const pathname = params.size > 0 ? `/internal/agent/${encodeURIComponent(ctx.agentId)}/profile?${params.toString()}` : `/internal/agent/${encodeURIComponent(ctx.agentId)}/profile`;
+    const res = await client.request("GET", pathname);
+    if (!res.ok || !res.data) {
+      const code = res.status >= 500 ? "SERVER_5XX" : "PROFILE_SHOW_FAILED";
+      fail(code, res.error ?? `HTTP ${res.status}`);
+    }
+    if (opts.json) {
+      emit({ ok: true, data: res.data });
+      return;
+    }
+    process.stdout.write(`${formatProfile(res.data)}
+`);
+  });
+}
+
+// src/commands/profile/update.ts
+import { basename as basename2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+var MAX_PROFILE_AVATAR_BYTES = 2 * 1024 * 1024;
+var PROFILE_AVATAR_MIME_TYPES = /* @__PURE__ */ new Set([
+  "image/jpeg",
+  "image/png",
+  "image/gif",
+  "image/webp"
+]);
+var FILENAME_MIME_MAP2 = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+var MAX_PROFILE_DESCRIPTION_LENGTH = 3e3;
+var MAX_PROFILE_DISPLAY_NAME_LENGTH = 80;
+function inferImageMimeType(filename, buffer) {
+  const lowerFilename = filename.toLowerCase();
+  if (buffer.length >= 8 && buffer.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    return "image/png";
+  }
+  if (buffer.length >= 3 && buffer.subarray(0, 3).equals(Buffer.from([255, 216, 255]))) {
+    return "image/jpeg";
+  }
+  if (buffer.length >= 6) {
+    const header = buffer.subarray(0, 6).toString("ascii");
+    if (header === "GIF87a" || header === "GIF89a") return "image/gif";
+  }
+  if (buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP") {
+    return "image/webp";
+  }
+  const dot = lowerFilename.lastIndexOf(".");
+  return dot >= 0 ? FILENAME_MIME_MAP2[lowerFilename.slice(dot)] ?? null : null;
+}
+function readAvatarFile(avatarFile) {
+  if (!existsSync2(avatarFile)) {
+    fail("PROFILE_FILE_NOT_FOUND", `Avatar file does not exist: ${avatarFile}`);
+  }
+  const stat = statSync2(avatarFile);
+  if (!stat.isFile()) {
+    fail("PROFILE_FILE_NOT_FOUND", `Avatar file is not a regular file: ${avatarFile}`);
+  }
+  if (stat.size > MAX_PROFILE_AVATAR_BYTES) {
+    fail(
+      "PROFILE_AVATAR_TOO_LARGE",
+      `Avatar file is ${stat.size} bytes; max size is ${MAX_PROFILE_AVATAR_BYTES} bytes`
+    );
+  }
+  const buffer = readFileSync2(avatarFile);
+  const filename = basename2(avatarFile);
+  const mimeType = inferImageMimeType(filename, buffer);
+  if (!mimeType || !PROFILE_AVATAR_MIME_TYPES.has(mimeType)) {
+    fail(
+      "PROFILE_AVATAR_BAD_FORMAT",
+      "Avatar must be a JPEG, PNG, GIF, or WebP image"
+    );
+  }
+  return { filename, buffer, mimeType };
+}
+function registerProfileUpdateCommand(parent) {
+  parent.command("update").description("Update your own profile").option("--avatar-file <path>", "Path to a local image file to use as your avatar").option("--display-name <name>", "Set your display name (non-empty)").option("--description <text>", "Set your profile description (non-empty)").option("--json", "Emit machine-readable JSON").action(async (opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const hasAvatar = opts.avatarFile !== void 0;
+    const hasDisplayName = opts.displayName !== void 0;
+    const hasDescription = opts.description !== void 0;
+    if (!hasAvatar && !hasDisplayName && !hasDescription) {
+      fail("INVALID_ARG", "Provide at least one of --avatar-file, --display-name, or --description");
+    }
+    let trimmedDisplayName;
+    if (hasDisplayName) {
+      trimmedDisplayName = opts.displayName.trim();
+      if (trimmedDisplayName.length === 0) {
+        fail("INVALID_ARG", "--display-name must not be empty");
+      }
+      if (trimmedDisplayName.length > MAX_PROFILE_DISPLAY_NAME_LENGTH) {
+        fail("INVALID_ARG", `--display-name must be at most ${MAX_PROFILE_DISPLAY_NAME_LENGTH} characters`);
+      }
+    }
+    if (hasDescription) {
+      if (opts.description.length === 0) {
+        fail("INVALID_ARG", "--description must not be empty");
+      }
+      if (opts.description.length > MAX_PROFILE_DESCRIPTION_LENGTH) {
+        fail("INVALID_ARG", `--description must be at most ${MAX_PROFILE_DESCRIPTION_LENGTH} characters`);
+      }
+    }
+    const client = new ApiClient(ctx);
+    let latestProfile = null;
+    if (hasDisplayName || hasDescription) {
+      const body = {};
+      if (hasDisplayName) {
+        body.displayName = trimmedDisplayName;
+      }
+      if (hasDescription) {
+        body.description = opts.description;
+      }
+      const res = await client.request(
+        "POST",
+        `/internal/agent/${encodeURIComponent(ctx.agentId)}/profile`,
+        body
+      );
+      if (!res.ok || !res.data) {
+        const code = res.errorCode ?? (res.status >= 500 ? "SERVER_5XX" : "PROFILE_UPDATE_FAILED");
+        fail(code, res.error ?? `HTTP ${res.status}`);
+      }
+      latestProfile = res.data;
+    }
+    if (hasAvatar) {
+      const avatar = readAvatarFile(opts.avatarFile);
+      const form = new FormData();
+      const avatarBytes = Uint8Array.from(avatar.buffer);
+      form.append("avatar", new Blob([avatarBytes], { type: avatar.mimeType }), avatar.filename);
+      const res = await client.requestMultipart(
+        "POST",
+        `/internal/agent/${encodeURIComponent(ctx.agentId)}/profile/avatar`,
+        form
+      );
+      if (!res.ok || !res.data) {
+        const code = res.errorCode ?? (res.status >= 500 ? "SERVER_5XX" : "PROFILE_UPDATE_FAILED");
+        fail(code, res.error ?? `HTTP ${res.status}`);
+      }
+      latestProfile = res.data;
+    }
+    if (!latestProfile) {
+      fail("PROFILE_UPDATE_FAILED", "No profile returned from server");
+    }
+    if (opts.json) {
+      emit({ ok: true, data: latestProfile });
+      return;
+    }
+    process.stdout.write(`${formatProfile(latestProfile)}
+`);
+  });
+}
+
+// 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 buildScheduleBody(opts, now = () => Intl.DateTimeFormat().resolvedOptions().timeZone) {
+  if (!opts.delaySeconds && !opts.fireAt && !opts.repeat) {
+    return {
+      body: {},
+      error: { code: "INVALID_ARG", message: "Provide --delay-seconds, --fire-at, or --repeat" }
+    };
+  }
+  if (opts.delaySeconds && opts.fireAt) {
+    return {
+      body: {},
+      error: {
+        code: "INVALID_ARG",
+        message: "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) {
+      return {
+        body: {},
+        error: {
+          code: "INVALID_ARG",
+          message: `--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 = now();
+  }
+  if (opts.channel !== void 0) body.channel = opts.channel;
+  if (body.msgId == null) {
+    return {
+      body: {},
+      error: {
+        code: "INVALID_ARG",
+        message: "Reminder create requires an anchor msgId; resolve a message first and pass --msg-id"
+      }
+    };
+  }
+  return { body };
+}
+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)."
+  ).requiredOption(
+    "--msg-id <id>",
+    "Message id this reminder is anchored to. Required for agent-created reminders."
+  ).action(async (opts) => {
+    let ctx;
+    try {
+      ctx = loadAgentContext();
+    } catch (err) {
+      if (err instanceof AgentBootstrapError) fail(err.code, err.message);
+      throw err;
+    }
+    const built = buildScheduleBody(opts);
+    if (built.error) fail(built.error.code, built.error.message);
+    const client = new ApiClient(ctx);
+    const res = await client.request(
+      "POST",
+      `/internal/agent/${encodeURIComponent(ctx.agentId)}/reminders`,
+      built.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 channelCmd = program.command("channel").description("Channel membership operations");
+registerChannelMembersCommand(channelCmd);
+registerChannelLeaveCommand(channelCmd);
+var threadCmd = program.command("thread").description("Thread attention operations");
+registerThreadUnfollowCommand(threadCmd);
+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 profileCmd = program.command("profile").description("Profile operations");
+registerProfileShowCommand(profileCmd);
+registerProfileUpdateCommand(profileCmd);
+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;
+  }
+});