@pome-sh/cli 0.20.0 → 0.21.0

package/dist/src-GGRWNJTK.js

@@ -0,0 +1,2869 @@
+export { SLACK_CHECKS } from './chunk-IY6G5NWT.js';
+import './chunk-NY55QTVQ.js';
+import { defineTwin, queryTokenResolver, formTokenResolver, UnknownToolError, openTwinDatabase, createApp } from './chunk-LZIPGCQJ.js';
+import './chunk-VBATFCWR.js';
+import './chunk-SG6ZTIMT.js';
+import { z, ZodError } from 'zod';
+
+// ../packages/twin-slack/dist/src/db.js
+var MIGRATION_SQL = `
+CREATE TABLE IF NOT EXISTS workspaces (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  domain TEXT NOT NULL,
+  url TEXT NOT NULL,
+  enterprise_id TEXT,
+  created_at TEXT NOT NULL,
+  entity_counter INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS users (
+  id TEXT PRIMARY KEY,
+  team_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  real_name TEXT NOT NULL DEFAULT '',
+  display_name TEXT NOT NULL DEFAULT '',
+  email TEXT,
+  is_bot INTEGER NOT NULL DEFAULT 0,
+  is_admin INTEGER NOT NULL DEFAULT 0,
+  deleted INTEGER NOT NULL DEFAULT 0,
+  tz TEXT NOT NULL DEFAULT 'America/Los_Angeles',
+  profile_json TEXT NOT NULL DEFAULT '{}',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  FOREIGN KEY (team_id) REFERENCES workspaces(id) ON DELETE CASCADE
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS users_email_idx
+  ON users(team_id, email) WHERE email IS NOT NULL;
+
+CREATE TABLE IF NOT EXISTS channels (
+  id TEXT PRIMARY KEY,
+  team_id TEXT NOT NULL,
+  name TEXT NOT NULL DEFAULT '',
+  is_channel INTEGER NOT NULL DEFAULT 1,
+  is_group INTEGER NOT NULL DEFAULT 0,
+  is_im INTEGER NOT NULL DEFAULT 0,
+  is_mpim INTEGER NOT NULL DEFAULT 0,
+  is_private INTEGER NOT NULL DEFAULT 0,
+  is_archived INTEGER NOT NULL DEFAULT 0,
+  topic TEXT NOT NULL DEFAULT '',
+  purpose TEXT NOT NULL DEFAULT '',
+  creator TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  ts_counter INTEGER NOT NULL DEFAULT 0,
+  dm_signature TEXT,
+  FOREIGN KEY (team_id) REFERENCES workspaces(id) ON DELETE CASCADE
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS channels_name_idx
+  ON channels(team_id, name) WHERE name <> '';
+
+-- Deterministic DM / MPIM dedup: dm_signature is the sorted member-id list
+-- joined with a pipe character. NULL on public channels and private groups.
+CREATE UNIQUE INDEX IF NOT EXISTS channels_dm_signature_idx
+  ON channels(team_id, dm_signature) WHERE dm_signature IS NOT NULL;
+
+CREATE TABLE IF NOT EXISTS channel_members (
+  channel_id TEXT NOT NULL,
+  user_id TEXT NOT NULL,
+  joined_at TEXT NOT NULL,
+  last_read TEXT NOT NULL DEFAULT '0000000000.000000',
+  PRIMARY KEY (channel_id, user_id),
+  FOREIGN KEY (channel_id) REFERENCES channels(id) ON DELETE CASCADE,
+  FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS messages (
+  channel_id TEXT NOT NULL,
+  ts TEXT NOT NULL,
+  user_id TEXT NOT NULL,
+  text TEXT NOT NULL,
+  subtype TEXT,
+  thread_ts TEXT,
+  reply_count INTEGER NOT NULL DEFAULT 0,
+  reply_users_count INTEGER NOT NULL DEFAULT 0,
+  latest_reply TEXT,
+  edited_user_id TEXT,
+  edited_ts TEXT,
+  blocks_json TEXT NOT NULL DEFAULT '[]',
+  attachments_json TEXT NOT NULL DEFAULT '[]',
+  bot_id TEXT,
+  app_id TEXT,
+  username TEXT,
+  icon_url TEXT,
+  icon_emoji TEXT,
+  PRIMARY KEY (channel_id, ts),
+  FOREIGN KEY (channel_id) REFERENCES channels(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS messages_history_idx ON messages(channel_id, ts DESC);
+CREATE INDEX IF NOT EXISTS messages_thread_idx ON messages(channel_id, thread_ts, ts);
+
+CREATE TABLE IF NOT EXISTS reactions (
+  channel_id TEXT NOT NULL,
+  message_ts TEXT NOT NULL,
+  name TEXT NOT NULL,
+  user_id TEXT NOT NULL,
+  added_at TEXT NOT NULL,
+  PRIMARY KEY (channel_id, message_ts, name, user_id),
+  FOREIGN KEY (channel_id, message_ts) REFERENCES messages(channel_id, ts) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS reactions_by_msg_idx ON reactions(channel_id, message_ts);
+
+CREATE TABLE IF NOT EXISTS pins (
+  channel_id TEXT NOT NULL,
+  message_ts TEXT NOT NULL,
+  pinned_by TEXT NOT NULL,
+  pinned_at TEXT NOT NULL,
+  PRIMARY KEY (channel_id, message_ts),
+  FOREIGN KEY (channel_id, message_ts) REFERENCES messages(channel_id, ts) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS files (
+  id TEXT PRIMARY KEY,
+  team_id TEXT NOT NULL,
+  user_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  title TEXT NOT NULL DEFAULT '',
+  mimetype TEXT NOT NULL DEFAULT 'text/plain',
+  filetype TEXT NOT NULL DEFAULT 'text',
+  size INTEGER NOT NULL DEFAULT 0,
+  url_private TEXT NOT NULL DEFAULT '',
+  channels_json TEXT NOT NULL DEFAULT '[]',
+  deleted INTEGER NOT NULL DEFAULT 0,
+  content TEXT,
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (team_id) REFERENCES workspaces(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS bookmarks (
+  id TEXT PRIMARY KEY,
+  channel_id TEXT NOT NULL,
+  title TEXT NOT NULL,
+  link TEXT NOT NULL,
+  emoji TEXT,
+  type TEXT NOT NULL DEFAULT 'link',
+  created_by TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  FOREIGN KEY (channel_id) REFERENCES channels(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS scheduled_messages (
+  id TEXT PRIMARY KEY,
+  channel_id TEXT NOT NULL,
+  user_id TEXT NOT NULL,
+  text TEXT NOT NULL,
+  thread_ts TEXT,
+  post_at INTEGER NOT NULL,
+  date_created INTEGER NOT NULL,
+  blocks_json TEXT NOT NULL DEFAULT '[]',
+  FOREIGN KEY (channel_id) REFERENCES channels(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS canvases (
+  id TEXT PRIMARY KEY,
+  team_id TEXT NOT NULL,
+  title TEXT NOT NULL DEFAULT '',
+  markdown TEXT NOT NULL DEFAULT '',
+  channel_id TEXT,
+  created_by TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  FOREIGN KEY (team_id) REFERENCES workspaces(id) ON DELETE CASCADE,
+  FOREIGN KEY (channel_id) REFERENCES channels(id) ON DELETE SET NULL
+);
+
+CREATE TABLE IF NOT EXISTS emoji (
+  team_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  value TEXT NOT NULL,
+  PRIMARY KEY (team_id, name),
+  FOREIGN KEY (team_id) REFERENCES workspaces(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS messages_text_idx ON messages(text);
+`;
+var RESET_SQL = `
+DELETE FROM emoji;
+DELETE FROM canvases;
+DELETE FROM scheduled_messages;
+DELETE FROM bookmarks;
+DELETE FROM files;
+DELETE FROM pins;
+DELETE FROM reactions;
+DELETE FROM messages;
+DELETE FROM channel_members;
+DELETE FROM channels;
+DELETE FROM users;
+DELETE FROM workspaces;
+`;
+function openSlackTwinDatabase(path = process.env.SLACK_CLONE_DB ?? ":memory:") {
+  return openTwinDatabase(path, { migrate });
+}
+function migrate(db) {
+  db.exec(MIGRATION_SQL);
+  ensureColumn(db, "workspaces", "entity_counter", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn(db, "workspaces", "ts_counter", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn(db, "channels", "ts_counter", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn(db, "channels", "dm_signature", "TEXT");
+  db.exec(`UPDATE workspaces SET ts_counter = COALESCE(
+       (SELECT MAX(ts_counter) FROM channels WHERE team_id = workspaces.id),
+       ts_counter
+     ) WHERE ts_counter = 0`);
+  ensureColumn(db, "messages", "bot_id", "TEXT");
+  ensureColumn(db, "messages", "app_id", "TEXT");
+  ensureColumn(db, "messages", "username", "TEXT");
+  ensureColumn(db, "messages", "icon_url", "TEXT");
+  ensureColumn(db, "messages", "icon_emoji", "TEXT");
+}
+function resetDatabase(db) {
+  db.exec(RESET_SQL);
+}
+function ensureColumn(db, table, column, definition) {
+  const columns = db.prepare(`PRAGMA table_info(${table})`).all();
+  if (!columns.some((row) => row.name === column)) {
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+  }
+}
+
+// ../packages/twin-slack/dist/src/errors.js
+var TwinError = class extends Error {
+  status;
+  code;
+  extra;
+  constructor(message, status, code, extra) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.extra = extra;
+  }
+};
+function slackError(code, status = 400, extra) {
+  throw new TwinError(code, status, code, extra);
+}
+function notFound(code = "not_found") {
+  throw new TwinError(code, 404, code);
+}
+function isSqliteConstraintError(err) {
+  if (!err || typeof err !== "object")
+    return false;
+  const code = err.code ?? "";
+  return code.startsWith("SQLITE_CONSTRAINT");
+}
+function twinErrorFromSqliteConstraint(method, err) {
+  if (!isSqliteConstraintError(err))
+    return null;
+  const message = err instanceof Error ? err.message : String(err);
+  if (message.includes("channels_name_idx")) {
+    return new TwinError("name_taken", 409, "name_taken");
+  }
+  if (method.startsWith("reactions.") || message.includes("reactions")) {
+    return new TwinError("already_reacted", 400, "already_reacted");
+  }
+  if (method.startsWith("pins.") || message.includes("pins")) {
+    return new TwinError("already_pinned", 400, "already_pinned");
+  }
+  return new TwinError("internal_error", 500, "internal_error", { warning: message });
+}
+
+// ../packages/twin-slack/dist/src/util.js
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function nowUnix() {
+  return Math.floor(Date.now() / 1e3);
+}
+async function parseFormOrJson(c) {
+  const contentType = (c.req.header("content-type") ?? "").toLowerCase();
+  if (contentType.includes("application/json")) {
+    try {
+      const body = await c.req.json();
+      if (body && typeof body === "object" && !Array.isArray(body)) {
+        return body;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  if (contentType.includes("application/x-www-form-urlencoded") || contentType.includes("multipart/form-data")) {
+    try {
+      const body = await c.req.parseBody();
+      return coerceFormValues(body);
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+function coerceFormValues(raw) {
+  const out = {};
+  for (const [key, value] of Object.entries(raw)) {
+    out[key] = value;
+  }
+  return out;
+}
+function asString(value, fallback = "") {
+  if (typeof value === "string")
+    return value;
+  if (value === void 0 || value === null)
+    return fallback;
+  return String(value);
+}
+function asOptionalString(value) {
+  if (typeof value !== "string")
+    return void 0;
+  if (value.length === 0)
+    return void 0;
+  return value;
+}
+function asNumber(value, fallback) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string" && value.length > 0) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed))
+      return parsed;
+  }
+  return fallback;
+}
+function asBool(value, fallback = false) {
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "string") {
+    const v = value.toLowerCase().trim();
+    if (v === "1" || v === "true" || v === "yes")
+      return true;
+    if (v === "0" || v === "false" || v === "no")
+      return false;
+  }
+  if (typeof value === "number")
+    return value !== 0;
+  return fallback;
+}
+function cursorEncode(payload) {
+  return Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+}
+function cursorDecode(cursor) {
+  if (!cursor)
+    return null;
+  try {
+    const decoded = Buffer.from(cursor, "base64url").toString("utf8");
+    const parsed = JSON.parse(decoded);
+    if (parsed && typeof parsed === "object" && Number.isInteger(parsed.offset) && parsed.offset >= 0) {
+      return { offset: parsed.offset };
+    }
+  } catch {
+  }
+  return null;
+}
+var DETERMINISTIC_TS_BASE_SECONDS = 1735689600;
+function tsBaseSeconds() {
+  if (process.env.SLACK_DETERMINISTIC_TS === "1")
+    return DETERMINISTIC_TS_BASE_SECONDS;
+  return Math.floor(Date.now() / 1e3);
+}
+function padTsCounter(counter) {
+  return String(counter).padStart(6, "0");
+}
+
+// ../packages/twin-slack/dist/src/domain/canvases.js
+var NOOP = () => {
+};
+function canvasesCreate(host, args, onDelta = NOOP) {
+  const content = coerceDocumentContent(args.document_content);
+  if (args.document_content !== void 0 && !content) {
+    slackError("canvas_creation_failed", 400, { detail: "invalid document_content" });
+  }
+  if (content && content.type !== "markdown") {
+    slackError("canvas_creation_failed", 400, { detail: `unsupported content type: ${content.type}` });
+  }
+  if (args.channel_id) {
+    assertChannelAccess(host, args.channel_id);
+  }
+  const id = host.allocId("F");
+  const now = nowIso();
+  const title = args.title ?? "";
+  const markdown = content?.markdown ?? "";
+  const out = host.db.transaction(() => {
+    host.db.prepare(`INSERT INTO canvases (id, team_id, title, markdown, channel_id, created_by, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, host.workspaceId, title, markdown, args.channel_id ?? null, host.actor.id, now, now);
+    const after = host.db.prepare(`SELECT * FROM canvases WHERE id = ?`).get(id);
+    onDelta({ before: null, after });
+    return { canvas_id: id };
+  })();
+  return out;
+}
+function canvasesEdit(host, args, onDelta = NOOP) {
+  if (!args.canvas_id)
+    slackError("invalid_arguments", 400);
+  const before = host.db.prepare(`SELECT * FROM canvases WHERE id = ?`).get(args.canvas_id);
+  if (!before)
+    slackError("canvas_not_found", 404);
+  assertCanvasAccess(host, before);
+  const changes = coerceChanges(args.changes);
+  if (!changes || changes.length === 0)
+    slackError("invalid_arguments", 400);
+  const change = changes[0];
+  const next = applyChange(before, change);
+  const now = nowIso();
+  const out = host.db.transaction(() => {
+    host.db.prepare(`UPDATE canvases SET title = ?, markdown = ?, updated_at = ? WHERE id = ?`).run(next.title, next.markdown, now, before.id);
+    const after = host.db.prepare(`SELECT * FROM canvases WHERE id = ?`).get(before.id);
+    onDelta({ before, after });
+    return {};
+  })();
+  return out;
+}
+function canvasesDelete(host, args, onDelta = NOOP) {
+  if (!args.canvas_id)
+    slackError("invalid_arguments", 400);
+  const before = host.db.prepare(`SELECT * FROM canvases WHERE id = ?`).get(args.canvas_id);
+  if (!before)
+    slackError("canvas_not_found", 404);
+  assertCanvasAccess(host, before);
+  const out = host.db.transaction(() => {
+    host.db.prepare(`DELETE FROM canvases WHERE id = ?`).run(before.id);
+    onDelta({ before, after: null });
+    return {};
+  })();
+  return out;
+}
+function assertChannelAccess(host, channelRef) {
+  const channel = host.requireChannel ? host.requireChannel(channelRef) : host.db.prepare(`SELECT * FROM channels WHERE id = ?`).get(channelRef);
+  if (!channel)
+    slackError("channel_not_found", 404);
+  const member = host.db.prepare(`SELECT 1 FROM channel_members WHERE channel_id = ? AND user_id = ?`).get(channel.id, host.actor.id);
+  if (!member)
+    slackError("not_in_channel", 400);
+}
+function assertCanvasAccess(host, canvas) {
+  if (canvas.channel_id) {
+    assertChannelAccess(host, canvas.channel_id);
+    return;
+  }
+  if (canvas.created_by !== host.actor.id)
+    slackError("restricted_action", 403);
+}
+function applyChange(row, change) {
+  const op = change.operation;
+  if (op === "rename") {
+    const title = change.title_content?.markdown;
+    if (title === void 0)
+      slackError("invalid_arguments", 400);
+    return { title, markdown: row.markdown };
+  }
+  const doc = change.document_content;
+  if (op === "insert_at_start") {
+    if (!doc)
+      slackError("invalid_arguments", 400);
+    const markdown = doc.markdown + (row.markdown ? `
+${row.markdown}` : "");
+    return { title: row.title, markdown };
+  }
+  if (op === "insert_at_end" || op === "insert_after" || op === "insert_before") {
+    if (!doc)
+      slackError("invalid_arguments", 400);
+    if ((op === "insert_after" || op === "insert_before") && !change.section_id) {
+      slackError("invalid_arguments", 400);
+    }
+    const markdown = row.markdown ? `${row.markdown}
+${doc.markdown}` : doc.markdown;
+    return { title: row.title, markdown };
+  }
+  if (op === "replace") {
+    if (!doc)
+      slackError("invalid_arguments", 400);
+    return { title: row.title, markdown: doc.markdown };
+  }
+  if (op === "delete") {
+    if (!change.section_id)
+      slackError("invalid_arguments", 400);
+    return { title: row.title, markdown: row.markdown };
+  }
+  slackError("canvas_editing_failed", 400, { detail: `unsupported operation: ${op}` });
+}
+function coerceDocumentContent(raw) {
+  if (raw === void 0 || raw === null)
+    return void 0;
+  let value = raw;
+  if (typeof raw === "string") {
+    try {
+      value = JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return void 0;
+  const obj = value;
+  if (typeof obj.markdown !== "string")
+    return void 0;
+  return {
+    type: typeof obj.type === "string" ? obj.type : "markdown",
+    markdown: obj.markdown
+  };
+}
+function coerceChanges(raw) {
+  let value = raw;
+  if (typeof raw === "string") {
+    try {
+      value = JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  if (!Array.isArray(value))
+    return void 0;
+  const out = [];
+  for (const item of value) {
+    if (typeof item !== "object" || item === null || Array.isArray(item))
+      return void 0;
+    const obj = item;
+    if (typeof obj.operation !== "string")
+      return void 0;
+    out.push({
+      operation: obj.operation,
+      document_content: coerceDocumentContent(obj.document_content),
+      title_content: coerceDocumentContent(obj.title_content),
+      section_id: typeof obj.section_id === "string" ? obj.section_id : void 0
+    });
+  }
+  return out;
+}
+
+// ../packages/twin-slack/dist/src/serializers.js
+var SLACK_TWIN_HOST = "https://pome-twin.slack.com";
+var SLACK_TWIN_FILE_HOST = "https://pome-twin-files.slack.com";
+function slackOk(payload) {
+  return { ok: true, ...payload };
+}
+function slackError2(code, extra = {}) {
+  return { ok: false, error: code, ...extra };
+}
+function serializeWorkspace(row) {
+  return {
+    id: row.id,
+    name: row.name,
+    domain: row.domain,
+    email_domain: row.domain.includes(".") ? row.domain : `${row.domain}.slack.com`,
+    icon: {
+      image_default: true,
+      image_34: `${SLACK_TWIN_HOST}/team_default_v2_0034.png`,
+      image_44: `${SLACK_TWIN_HOST}/team_default_v2_0044.png`,
+      image_68: `${SLACK_TWIN_HOST}/team_default_v2_0068.png`,
+      image_88: `${SLACK_TWIN_HOST}/team_default_v2_0088.png`,
+      image_102: `${SLACK_TWIN_HOST}/team_default_v2_0102.png`,
+      image_132: `${SLACK_TWIN_HOST}/team_default_v2_0132.png`,
+      image_230: `${SLACK_TWIN_HOST}/team_default_v2_0230.png`
+    },
+    enterprise_id: row.enterprise_id ?? void 0,
+    url: row.url
+  };
+}
+function serializeUserProfile(row, opts = {}) {
+  const profile = safeJson(row.profile_json);
+  const base = {
+    avatar_hash: "g000000000",
+    status_text: profile.status_text ?? "",
+    status_emoji: profile.status_emoji ?? "",
+    status_expiration: profile.status_expiration ?? 0,
+    real_name: row.real_name,
+    display_name: row.display_name || row.real_name || row.name,
+    real_name_normalized: row.real_name,
+    display_name_normalized: row.display_name || row.real_name || row.name,
+    image_24: `${SLACK_TWIN_HOST}/avatars/${row.id}_24.png`,
+    image_32: `${SLACK_TWIN_HOST}/avatars/${row.id}_32.png`,
+    image_48: `${SLACK_TWIN_HOST}/avatars/${row.id}_48.png`,
+    image_72: `${SLACK_TWIN_HOST}/avatars/${row.id}_72.png`,
+    image_192: `${SLACK_TWIN_HOST}/avatars/${row.id}_192.png`,
+    image_512: `${SLACK_TWIN_HOST}/avatars/${row.id}_512.png`
+  };
+  const out = {
+    ...base,
+    ...profile
+  };
+  if (opts.omitEmail) {
+    delete out.email;
+  } else if (row.email != null && out.email === void 0) {
+    out.email = row.email;
+  }
+  if (opts.omitTeam) {
+    delete out.team;
+  } else if (out.team === void 0) {
+    out.team = row.team_id;
+  }
+  return out;
+}
+function serializeUser(row, opts = {}) {
+  return {
+    id: row.id,
+    team_id: row.team_id,
+    name: row.name,
+    deleted: Boolean(row.deleted),
+    color: "9f69e7",
+    real_name: row.real_name,
+    tz: row.tz,
+    tz_label: row.tz.replace(/_/g, " "),
+    tz_offset: 0,
+    // The embedded profile carries `team` (both users.list and users.info) but
+    // OMITS `email` on users.list — real Slack only returns the email on the
+    // single-user reads (users.info / lookupByEmail), not in the list envelope
+    // (FDRS-473 Kind B). `omitProfileEmail` is set by the users.list caller.
+    // serializeUserProfile returns Record<string, unknown> (its own `...profile`
+    // spread is an open record); cast to the upstream Profile shape so the parent
+    // `satisfies` stays exact without re-anchoring the nested record here.
+    profile: serializeUserProfile(row, { omitEmail: opts.omitProfileEmail }),
+    is_admin: Boolean(row.is_admin),
+    is_owner: Boolean(row.is_admin),
+    is_primary_owner: row.id === "U_PRIMARY",
+    is_restricted: false,
+    is_ultra_restricted: false,
+    is_bot: Boolean(row.is_bot),
+    is_app_user: false,
+    updated: tsToUnix(row.updated_at),
+    is_email_confirmed: Boolean(row.email),
+    who_can_share_contact_card: "EVERYONE",
+    ...opts.include_locale ? { locale: "en-US" } : {}
+  };
+}
+function serializeChannel(row, opts = {}) {
+  const created = tsToUnix(row.created_at);
+  const isIm = Boolean(row.is_im);
+  const isMpim = Boolean(row.is_mpim);
+  const isPrivate = Boolean(row.is_private || row.is_group);
+  const out = {
+    id: row.id,
+    name: row.name,
+    name_normalized: row.name,
+    is_channel: Boolean(row.is_channel) && !isIm && !isMpim,
+    is_group: Boolean(row.is_group) || isPrivate && !isIm && !isMpim,
+    is_im: isIm,
+    is_mpim: isMpim,
+    is_private: isPrivate,
+    is_archived: Boolean(row.is_archived),
+    is_general: row.name === "general",
+    is_shared: false,
+    is_org_shared: false,
+    is_pending_ext_shared: false,
+    pending_shared: [],
+    context_team_id: row.team_id,
+    creator: row.creator,
+    created,
+    unlinked: 0,
+    topic: {
+      value: row.topic,
+      creator: row.creator,
+      last_set: created
+    },
+    purpose: {
+      value: row.purpose,
+      creator: row.creator,
+      last_set: created
+    }
+  };
+  out.parent_conversation = null;
+  if (opts.num_members !== void 0)
+    out.num_members = opts.num_members;
+  if (opts.is_member !== void 0)
+    out.is_member = opts.is_member;
+  if (opts.last_read !== void 0)
+    out.last_read = opts.last_read;
+  if (opts.include_members)
+    out.members = opts.include_members;
+  return out;
+}
+function serializeMessage(row, opts = {}) {
+  const botId = row.bot_id ?? (row.user_id.startsWith("B") ? row.user_id : null);
+  const blocks = safeJsonArray(row.blocks_json);
+  const attachments = safeJsonArray(row.attachments_json);
+  const out = {
+    type: "message",
+    user: row.user_id,
+    text: row.text,
+    ts: row.ts,
+    ...row.subtype ? { subtype: row.subtype } : {},
+    ...row.thread_ts ? {
+      thread_ts: row.thread_ts,
+      // parent_user_id is the THREAD PARENT's author, not this row's author.
+      ...opts.parent_user_id ? { parent_user_id: opts.parent_user_id } : {}
+    } : {},
+    ...row.reply_count > 0 ? {
+      reply_count: row.reply_count,
+      reply_users_count: row.reply_users_count,
+      // row.latest_reply is `string | null`; upstream is `string | undefined`.
+      // Cast to the upstream field type — runtime value is unchanged.
+      latest_reply: row.latest_reply,
+      subscribed: false
+    } : {},
+    ...row.edited_user_id && row.edited_ts ? { edited: { user: row.edited_user_id, ts: row.edited_ts } } : {},
+    // safeJsonArray returns unknown[]; cast to the upstream field types so the
+    // anchor stays exact (mirrors twin-github `as Upstream["field"]`).
+    ...blocks.length > 0 ? { blocks } : {},
+    ...attachments.length > 0 ? { attachments } : {},
+    ...opts.reactions && opts.reactions.length > 0 ? { reactions: groupReactions(opts.reactions) } : {},
+    ...opts.include_team ? { team: opts.include_team } : {},
+    ...botId ? {
+      bot_id: botId,
+      ...row.app_id ? { app_id: row.app_id } : {},
+      bot_profile: {
+        id: botId,
+        deleted: false,
+        name: row.username ?? botId,
+        updated: tsToUnix(row.ts),
+        app_id: row.app_id ?? "A_POME",
+        icons: row.icon_url ? { image_36: row.icon_url, image_48: row.icon_url, image_72: row.icon_url } : {
+          image_36: `${SLACK_TWIN_HOST}/avatars/${botId}_36.png`,
+          image_48: `${SLACK_TWIN_HOST}/avatars/${botId}_48.png`,
+          image_72: `${SLACK_TWIN_HOST}/avatars/${botId}_72.png`
+        },
+        team_id: opts.include_team ?? ""
+      }
+    } : {},
+    ...row.username ? { username: row.username } : {}
+  };
+  if (opts.permalink)
+    out.permalink = opts.permalink;
+  if (row.icon_emoji)
+    out.icons = { ...out.icons ?? {}, emoji: row.icon_emoji };
+  if (row.icon_url)
+    out.icons = { ...out.icons ?? {}, image_64: row.icon_url };
+  return out;
+}
+function groupReactions(rows) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const existing = grouped.get(row.name);
+    if (existing) {
+      existing.count += 1;
+      existing.users.push(row.user_id);
+    } else {
+      grouped.set(row.name, {
+        name: row.name,
+        count: 1,
+        users: [row.user_id]
+      });
+    }
+  }
+  return [...grouped.values()];
+}
+function serializeFile(row) {
+  return {
+    id: row.id,
+    created: tsToUnix(row.created_at),
+    timestamp: tsToUnix(row.created_at),
+    name: row.name,
+    title: row.title,
+    mimetype: row.mimetype,
+    filetype: row.filetype,
+    pretty_type: prettyFiletype(row.filetype),
+    user: row.user_id,
+    user_team: row.team_id,
+    editable: row.filetype === "text" || row.filetype === "markdown",
+    size: row.size,
+    mode: "hosted",
+    is_external: false,
+    external_type: "",
+    is_public: false,
+    public_url_shared: false,
+    display_as_bot: false,
+    username: "",
+    url_private: row.url_private || `${SLACK_TWIN_FILE_HOST}/files-pri/${row.team_id}-${row.id}/${row.name}`,
+    url_private_download: `${SLACK_TWIN_FILE_HOST}/files-pri/${row.team_id}-${row.id}/download/${row.name}`,
+    permalink: `${SLACK_TWIN_HOST}/files/${row.user_id}/${row.id}/${row.name}`,
+    permalink_public: `${SLACK_TWIN_FILE_HOST}/${row.team_id}-${row.id}-public/${row.name}`,
+    // safeJsonArray returns unknown[]; upstream File.channels is string[]. Cast
+    // to the upstream field type (mirrors twin-github `as Upstream["field"]`).
+    channels: safeJsonArray(row.channels_json),
+    groups: [],
+    ims: [],
+    comments_count: 0
+  };
+}
+function serializeBookmark(row) {
+  return {
+    id: row.id,
+    channel_id: row.channel_id,
+    title: row.title,
+    link: row.link,
+    emoji: row.emoji ?? "",
+    icon_url: "",
+    type: row.type,
+    entity_id: "",
+    date_created: tsToUnix(row.created_at),
+    date_updated: tsToUnix(row.created_at),
+    rank: "",
+    last_updated_by_user_id: row.created_by,
+    last_updated_by_team_id: "",
+    shortcut_id: "",
+    app_id: "",
+    app_action_id: ""
+  };
+}
+function serializePin(pin, message) {
+  return {
+    type: "message",
+    created: tsToUnix(pin.pinned_at),
+    created_by: pin.pinned_by,
+    channel: pin.channel_id,
+    message
+  };
+}
+function safeJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function safeJsonArray(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed))
+      return parsed;
+    return [];
+  } catch {
+    return [];
+  }
+}
+function tsToUnix(iso) {
+  const ms = Date.parse(iso);
+  if (Number.isNaN(ms))
+    return 0;
+  return Math.floor(ms / 1e3);
+}
+function prettyFiletype(filetype) {
+  const mapping = {
+    text: "Plain Text",
+    markdown: "Markdown",
+    pdf: "PDF",
+    gif: "GIF",
+    png: "PNG",
+    jpg: "JPEG",
+    jpeg: "JPEG",
+    binary: "Binary"
+  };
+  return mapping[filetype] ?? filetype.toUpperCase();
+}
+
+// ../packages/twin-slack/dist/src/domain/emoji.js
+function emojiList(host) {
+  const rows = host.db.prepare(`SELECT name, value FROM emoji WHERE team_id = ? ORDER BY name`).all(host.workspaceId);
+  const emoji = {};
+  for (const row of rows) {
+    emoji[row.name] = row.value;
+  }
+  return { emoji };
+}
+function emojiImageUrl(name) {
+  return `${SLACK_TWIN_HOST}/emoji/${encodeURIComponent(name)}/1.png`;
+}
+function seedEmojiRows(db, teamId, entries) {
+  const insert = db.prepare(`INSERT OR REPLACE INTO emoji (team_id, name, value) VALUES (?, ?, ?)`);
+  for (const entry of entries) {
+    const value = entry.alias !== void 0 && entry.alias.length > 0 ? `alias:${entry.alias}` : entry.url && entry.url.length > 0 ? entry.url : emojiImageUrl(entry.name);
+    insert.run(teamId, entry.name, value);
+  }
+}
+
+// ../packages/twin-slack/dist/src/domain/topic.js
+var NOOP2 = () => {
+};
+var MAX_TOPIC_PURPOSE = 250;
+function conversationsSetTopic(host, args, onDelta = NOOP2) {
+  return setChannelText(host, args.channel, "topic", args.topic, onDelta);
+}
+function conversationsSetPurpose(host, args, onDelta = NOOP2) {
+  return setChannelText(host, args.channel, "purpose", args.purpose, onDelta);
+}
+function setChannelText(host, channelRef, field, value, onDelta) {
+  if (value === void 0 || value === null) {
+    slackError("invalid_arguments", 400, {
+      response_metadata: { messages: [`[ERROR] missing required field: ${field}`] }
+    });
+  }
+  if (value.length > MAX_TOPIC_PURPOSE)
+    slackError("too_long", 400);
+  const channel = host.requireChannel(channelRef);
+  if (channel.is_im || channel.is_mpim)
+    slackError("method_not_supported_for_channel_type", 400);
+  if (channel.is_archived)
+    slackError("is_archived", 400);
+  const member = host.db.prepare(`SELECT 1 FROM channel_members WHERE channel_id = ? AND user_id = ?`).get(channel.id, host.actor.id);
+  if (!member)
+    slackError("not_in_channel", 400);
+  const before = channel;
+  const out = host.db.transaction(() => {
+    host.db.prepare(`UPDATE channels SET ${field} = ? WHERE id = ?`).run(value, channel.id);
+    const after = host.db.prepare(`SELECT * FROM channels WHERE id = ?`).get(channel.id);
+    onDelta({ before, after });
+    return { channel: serializeChannel(after) };
+  })();
+  return out;
+}
+var seedSchema = z.object({
+  team: z.object({
+    id: z.string().regex(/^T[A-Z0-9_]+$/).optional(),
+    name: z.string().default("Pome Twin Workspace"),
+    domain: z.string().default("pome-twin")
+  }).prefault({}),
+  users: z.array(z.object({
+    id: z.string().regex(/^[UB][A-Z0-9_]+$/).optional(),
+    name: z.string().min(1),
+    real_name: z.string().default(""),
+    email: z.string().email().optional(),
+    is_bot: z.boolean().default(false),
+    is_admin: z.boolean().default(false),
+    tz: z.string().default("America/Los_Angeles"),
+    profile: z.record(z.string(), z.unknown()).default({})
+  })).default([]),
+  channels: z.array(z.object({
+    id: z.string().regex(/^[CGDM][A-Z0-9_]+$/).optional(),
+    name: z.string().regex(/^[a-z0-9_-]{1,80}$/),
+    is_private: z.boolean().default(false),
+    topic: z.string().default(""),
+    purpose: z.string().default(""),
+    creator: z.string().optional(),
+    members: z.array(z.string()).default([]),
+    messages: z.array(z.object({
+      ts: z.string().optional(),
+      user: z.string(),
+      text: z.string(),
+      thread_ts: z.string().optional(),
+      reactions: z.array(z.object({ name: z.string(), user: z.string() })).default([])
+    })).default([])
+  })).default([]),
+  emoji: z.array(z.object({
+    name: z.string().regex(/^[a-z0-9_+-]{1,100}$/),
+    url: z.string().url().optional(),
+    alias: z.string().regex(/^[a-z0-9_+-]{1,100}$/).optional()
+  })).default([])
+});
+function parseSeed(input) {
+  return seedSchema.parse(input);
+}
+function loadSeedFromEnv(env = process.env) {
+  const raw = env.POME_SEED_JSON;
+  if (raw === void 0 || raw === "") {
+    return defaultSeedState();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`POME_SEED_JSON is not valid JSON: ${err.message}`);
+  }
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    const obj = parsed;
+    if (obj.slack && typeof obj.slack === "object" && obj.slack !== null) {
+      const slack = obj.slack;
+      if ("seed" in slack) {
+        return parseSeed(slack.seed);
+      }
+    }
+  }
+  return parseSeed(parsed);
+}
+function defaultSeedState() {
+  return {
+    team: {
+      id: "T_POME",
+      name: "Pome Twin Workspace",
+      domain: "pome-twin"
+    },
+    users: [
+      {
+        id: "U_PRIMARY",
+        name: "pome-agent",
+        real_name: "Pome Agent",
+        email: "pome-agent@pome-twin.slack.com",
+        is_bot: false,
+        is_admin: true
+      },
+      {
+        id: "U_ALICE",
+        name: "alice",
+        real_name: "Alice",
+        email: "alice@pome-twin.slack.com"
+      },
+      {
+        id: "U_BOB",
+        name: "bob",
+        real_name: "Bob",
+        email: "bob@pome-twin.slack.com"
+      }
+    ],
+    channels: [
+      {
+        id: "C_GENERAL",
+        name: "general",
+        is_private: false,
+        topic: "Company-wide announcements and chatter.",
+        purpose: "This channel is for company-wide communication.",
+        creator: "U_PRIMARY",
+        members: ["U_PRIMARY", "U_ALICE", "U_BOB"],
+        messages: [
+          { user: "U_ALICE", text: "morning team" },
+          { user: "U_BOB", text: "morning :wave:" }
+        ]
+      },
+      {
+        id: "C_RANDOM",
+        name: "random",
+        is_private: false,
+        topic: "Non-work chatter and water cooler talk.",
+        purpose: "A place for non-work-related flimflam.",
+        creator: "U_PRIMARY",
+        members: [],
+        messages: []
+      }
+    ],
+    emoji: [
+      { name: "shipit", alias: "squirrel" },
+      { name: "squirrel" },
+      { name: "bowtie" }
+    ]
+  };
+}
+
+// ../packages/twin-slack/dist/src/domain/bookmarks.js
+function bookmarksAdd(domain, args, actor, onDelta = NOOP3) {
+  const channel = domain.requireChannel(args.channel_id);
+  if (!args.title)
+    slackError("invalid_arguments", 400);
+  if (!args.link && (!args.type || args.type === "link"))
+    slackError("invalid_arguments", 400);
+  const acting = domain.resolveActorUser(actor);
+  const id = domain.allocId(domain.requireWorkspace().id, "Bk");
+  const out = domain.db.transaction(() => {
+    domain.db.prepare(`INSERT INTO bookmarks (id, channel_id, title, link, emoji, type, created_by, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, channel.id, args.title, args.link ?? "", args.emoji ?? null, args.type ?? "link", acting.id, nowIso());
+    const after = domain.db.prepare(`SELECT * FROM bookmarks WHERE id = ?`).get(id);
+    onDelta({ before: null, after });
+    return { bookmark: serializeBookmark(after) };
+  })();
+  return out;
+}
+function bookmarksRemove(domain, args, actor, onDelta = NOOP3) {
+  const channel = domain.requireChannel(args.channel_id);
+  const before = domain.db.prepare(`SELECT * FROM bookmarks WHERE id = ? AND channel_id = ?`).get(args.bookmark_id, channel.id);
+  if (!before)
+    slackError("no_bookmark_found", 404);
+  const out = domain.db.transaction(() => {
+    domain.db.prepare(`DELETE FROM bookmarks WHERE id = ?`).run(before.id);
+    onDelta({ before, after: null });
+    return {};
+  })();
+  return out;
+}
+function bookmarksList(domain, args) {
+  const channel = domain.requireChannel(args.channel_id);
+  const rows = domain.db.prepare(`SELECT * FROM bookmarks WHERE channel_id = ? ORDER BY created_at`).all(channel.id);
+  return { bookmarks: rows.map((row) => serializeBookmark(row)) };
+}
+
+// ../packages/twin-slack/dist/src/domain/helpers.js
+function clampLimit(value, max, fallback) {
+  if (!Number.isFinite(value) || value === void 0)
+    return fallback;
+  return Math.min(max, Math.max(1, Math.floor(value)));
+}
+function safeParseJson(raw) {
+  if (!raw)
+    return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function sanitizeJsonString(raw, fallback) {
+  try {
+    const parsed = JSON.parse(raw);
+    return JSON.stringify(parsed);
+  } catch {
+    return fallback;
+  }
+}
+function normalizeReactionName(raw) {
+  return raw.trim().replace(/^:|:$/g, "");
+}
+function filetypeMimetype(filetype) {
+  const mapping = {
+    text: "text/plain",
+    markdown: "text/markdown",
+    json: "application/json",
+    pdf: "application/pdf",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif"
+  };
+  return mapping[filetype] ?? "application/octet-stream";
+}
+
+// ../packages/twin-slack/dist/src/domain/chat.js
+function chatPostMessage(domain, args, actor, onDelta = NOOP3) {
+  const channel = domain.requireChannel(args.channel);
+  if (channel.is_archived)
+    slackError("is_archived", 400);
+  if (!args.text && !args.blocks && !args.attachments)
+    slackError("no_text", 400);
+  if (args.thread_ts) {
+    const parent = domain.db.prepare(`SELECT * FROM messages WHERE channel_id = ? AND ts = ?`).get(channel.id, args.thread_ts);
+    if (!parent)
+      slackError("thread_not_found", 404);
+  }
+  const author = domain.resolveActorUser(actor);
+  if (channel.is_private || channel.is_im || channel.is_mpim) {
+    const member = domain.db.prepare(`SELECT 1 FROM channel_members WHERE channel_id = ? AND user_id = ?`).get(channel.id, author.id);
+    if (!member)
+      slackError("not_in_channel", 400);
+  }
+  const ts = domain.allocMessageTs(channel.id);
+  const blocks = args.blocks ? sanitizeJsonString(args.blocks, "[]") : "[]";
+  const attachments = args.attachments ? sanitizeJsonString(args.attachments, "[]") : "[]";
+  const subtype = author.is_bot ? "bot_message" : null;
+  const botId = author.is_bot ? author.id : null;
+  const appId = author.is_bot ? "A_POME" : null;
+  const username = typeof args.username === "string" && args.username.length > 0 ? args.username : null;
+  const iconUrl = typeof args.icon_url === "string" && args.icon_url.length > 0 ? args.icon_url : null;
+  const iconEmoji = typeof args.icon_emoji === "string" && args.icon_emoji.length > 0 ? args.icon_emoji : null;
+  const out = domain.db.transaction(() => {
+    domain.db.prepare(`INSERT INTO messages (channel_id, ts, user_id, text, subtype, thread_ts, blocks_json, attachments_json,
+                               bot_id, app_id, username, icon_url, icon_emoji)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(channel.id, ts, author.id, args.text ?? "", subtype, args.thread_ts ?? null, blocks, attachments, botId, appId, username, iconUrl, iconEmoji);
+    if (args.thread_ts) {
+      domain.db.prepare(`UPDATE messages SET reply_count = reply_count + 1, latest_reply = ?,
+            reply_users_count = (
+              SELECT COUNT(DISTINCT user_id) FROM messages WHERE channel_id = ? AND thread_ts = ?
+            )
+           WHERE channel_id = ? AND ts = ?`).run(ts, channel.id, args.thread_ts, channel.id, args.thread_ts);
+    }
+    const row = domain.requireMessageRow(channel.id, ts);
+    onDelta({ before: null, after: row });
+    const workspaceId = domain.requireWorkspace().id;
+    return { channel: channel.id, ts, message: serializeMessage(row, { include_team: workspaceId }) };
+  })();
+  return out;
+}
+function chatUpdate(domain, args, actor, onDelta = NOOP3) {
+  const channel = domain.requireChannel(args.channel);
+  if (channel.is_archived)
+    slackError("is_archived", 400);
+  const acting = domain.resolveActorUser(actor);
+  const before = domain.db.prepare(`SELECT * FROM messages WHERE channel_id = ? AND ts = ?`).get(channel.id, args.ts);
+  if (!before)
+    slackError("message_not_found", 404);
+  if (before.user_id !== acting.id)
+    slackError("cant_update_message", 403);
+  const out = domain.db.transaction(() => {
+    const updatedTs = domain.allocMessageTs(channel.id);
+    const newText = args.text ?? before.text;
+    const newBlocks = args.blocks ? sanitizeJsonString(args.blocks, before.blocks_json) : before.blocks_json;
+    const newAttachments = args.attachments ? sanitizeJsonString(args.attachments, before.attachments_json) : before.attachments_json;
+    domain.db.prepare(`UPDATE messages SET text = ?, blocks_json = ?, attachments_json = ?, edited_user_id = ?, edited_ts = ? WHERE channel_id = ? AND ts = ?`).run(newText, newBlocks, newAttachments, acting.id, updatedTs, channel.id, args.ts);
+    const after = domain.requireMessageRow(channel.id, args.ts);
+    onDelta({ before, after });
+    return { channel: channel.id, ts: args.ts, text: after.text, message: serializeMessage(after) };
+  })();
+  return out;
+}
+function chatDelete(domain, args, actor, onDelta = NOOP3) {
+  const channel = domain.requireChannel(args.channel);
+  const acting = domain.resolveActorUser(actor);
+  const before = domain.db.prepare(`SELECT * FROM messages WHERE channel_id = ? AND ts = ?`).get(channel.id, args.ts);
+  if (!before)
+    slackError("message_not_found", 404);
+  if (before.user_id !== acting.id)
+    slackError("cant_delete_message", 403);
+  const out = domain.db.transaction(() => {
+    domain.db.prepare(`DELETE FROM messages WHERE channel_id = ? AND ts = ?`).run(channel.id, args.ts);
+    if (before.thread_ts) {
+      domain.db.prepare(`UPDATE messages SET reply_count = MAX(reply_count - 1, 0),
+            reply_users_count = (
+              SELECT COUNT(DISTINCT user_id) FROM messages WHERE channel_id = ? AND thread_ts = ?
+            ),
+            latest_reply = (
+              SELECT ts FROM messages WHERE channel_id = ? AND thread_ts = ? ORDER BY ts DESC LIMIT 1
+            )
+           WHERE channel_id = ? AND ts = ?`).run(channel.id, before.thread_ts, channel.id, before.thread_ts, channel.id, before.thread_ts);
+    }
+    onDelta({ before, after: null });
+    return { channel: channel.id, ts: args.ts };
+  })();
+  return out;
+}
+function chatScheduleMessage(domain, args, actor, onDelta = NOOP3) {
+  const channel = domain.requireChannel(args.channel);
+  if (channel.is_archived)
+    slackError("is_archived", 400);
+  if (!args.text)
+    slackError("no_text", 400);
+  if (!args.post_at || args.post_at <= nowUnix())
+    slackError("time_in_past", 400);
+  const acting = domain.resolveActorUser(actor);
+  const id = domain.allocId(domain.requireWorkspace().id, "Q");
+  const now = nowUnix();
+  const out = domain.db.transaction(() => {
+    domain.db.prepare(`INSERT INTO scheduled_messages (id, channel_id, user_id, text, thread_ts, post_at, date_created, blocks_json)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, channel.id, acting.id, args.text, args.thread_ts ?? null, args.post_at, now, args.blocks ? sanitizeJsonString(args.blocks, "[]") : "[]");
+    const row = domain.requireScheduledMessage(id);
+    onDelta({ before: null, after: row });
+    return {
+      channel: channel.id,
+      scheduled_message_id: id,
+      post_at: args.post_at,
+      message: { text: args.text, type: "delayed_message" }
+    };
+  })();
+  return out;
+}
+function chatDeleteScheduledMessage(domain, args, actor, onDelta = NOOP3) {
+  const channel = domain.requireChannel(args.channel);
+  const row = domain.db.prepare(`SELECT * FROM scheduled_messages WHERE id = ? AND channel_id = ?`).get(args.scheduled_message_id, channel.id);
+  if (!row)
+    slackError("scheduled_message_not_found", 404);
+  const out = domain.db.transaction(() => {
+    domain.db.prepare(`DELETE FROM scheduled_messages WHERE id = ?`).run(row.id);
+    onDelta({ before: row, after: null });
+    return {};
+  })();
+  return out;
+}
+
+// ../packages/twin-slack/dist/src/domain/conversations.js
+function conversationsList(domain, args) {
+  const requested = (args.types ?? "public_channel").split(",").map((t) => t.trim()).filter(Boolean);
+  const typeFilters = [];
+  if (requested.includes("public_channel"))
+    typeFilters.push(`(is_private = 0 AND is_im = 0 AND is_mpim = 0)`);
+  if (requested.includes("private_channel"))
+    typeFilters.push(`(is_private = 1 AND is_im = 0 AND is_mpim = 0)`);
+  if (requested.includes("mpim"))
+    typeFilters.push(`is_mpim = 1`);
+  if (requested.includes("im"))
+    typeFilters.push(`is_im = 1`);
+  const where = [];
+  if (typeFilters.length > 0)
+    where.push(`(${typeFilters.join(" OR ")})`);
+  if (args.exclude_archived)
+    where.push(`is_archived = 0`);
+  const offset = cursorDecode(args.cursor ?? null)?.offset ?? 0;
+  const limit = clampLimit(args.limit, 1e3, 100);
+  const stmt = `SELECT * FROM channels${where.length ? ` WHERE ${where.join(" AND ")}` : ""} ORDER BY created_at, id LIMIT ? OFFSET ?`;
+  const rows = domain.db.prepare(stmt).all(limit + 1, offset);
+  const hasMore = rows.length > limit;
+  const slice = rows.slice(0, limit);
+  const channels = slice.map((row) => {
+    const numMembers = domain.db.prepare(`SELECT COUNT(*) AS c FROM channel_members WHERE channel_id = ?`).get(row.id).c;
+    return serializeChannel(row, { num_members: numMembers });
+  });
+  return {
+    channels,
+    response_metadata: {
+      next_cursor: hasMore ? cursorEncode({ offset: offset + slice.length }) : ""
+    }
+  };
+}
+function conversationsInfo(domain, args, actor = {}) {
+  const channel = domain.requireChannel(args.channel);
+  domain.assertChannelMemberForActor(channel, actor);
+  const numMembers = domain.db.prepare(`SELECT COUNT(*) AS c FROM channel_members WHERE channel_id = ?`).get(channel.id).c;
+  return { channel: serializeChannel(channel, { num_members: numMembers }) };
+}
+function conversationsCreate(domain, args, actor, onDelta = NOOP3) {
+  if (!args.name)
+    slackError("invalid_name_required", 400);
+  if (args.name.length > 80)
+    slackError("invalid_name_maxlength", 400);
+  if (/[A-Z]/.test(args.name) || /[^a-z0-9_-]/.test(args.name)) {
+    slackError("invalid_name_specials", 400);
+  }
+  if (/^[-_]/.test(args.name) || /^\d+$/.test(args.name)) {
+    slackError("invalid_name_punctuation", 400);
+  }
+  const workspace = domain.requireWorkspace();
+  const creator = domain.resolveActorUser(actor).id;
+  const channelId = domain.allocId(workspace.id, args.is_private ? "G" : "C");
+  const now = nowIso();
+  const out = domain.db.transaction(() => {
+    const existing = domain.db.prepare(`SELECT id FROM channels WHERE team_id = ? AND name = ?`).get(workspace.id, args.name);
+    if (existing)
+      slackError("name_taken", 409);
+    domain.db.prepare(`INSERT INTO channels (id, team_id, name, is_channel, is_group, is_im, is_mpim, is_private, is_archived, topic, purpose, creator, created_at, ts_counter)
+         VALUES (?, ?, ?, ?, ?, 0, 0, ?, 0, '', '', ?, ?, 0)`).run(channelId, workspace.id, args.name, args.is_private ? 0 : 1, args.is_private ? 1 : 0, args.is_private ? 1 : 0, creator, now);
+    domain.db.prepare(`INSERT OR IGNORE INTO channel_members (channel_id, user_id, joined_at) VALUES (?, ?, ?)`).run(channelId, creator, now);
+    const row = domain.requireChannelRow(channelId);
+    onDelta({ before: null, after: row });
+    return serializeChannel(row, { num_members: 1, is_member: true });
+  })();
+  return { channel: out };
+}
+function conversationsArchive(domain, args, actor, onDelta = NOOP3) {
+  const channel = domain.requireChannel(args.channel);
+  if (channel.is_archived)
+    slackError("already_archived", 400);
+  if (channel.name === "general")
+    slackError("cant_archive_general", 400);
+  const acting = domain.resolveActorUser(actor);
+  if (!acting.is_admin)
+    domain.assertChannelMember(channel, acting.id);
+  const out = domain.db.transaction(() => {
+    const before = domain.requireChannelRow(channel.id);
+    domain.db.prepare(`UPDATE channels SET is_archived = 1 WHERE id = ?`).run(channel.id);
+    const after = domain.requireChannelRow(channel.id);
+    onDelta({ before, after });
+    return { ok: true };
+  })();
+  return out;
+}
+function conversationsInvite(domain, args, actor, onDelta = NOOP3) {
+  const channel = domain.requireChannel(args.channel);
+  if (channel.is_archived)
+    slackError("is_archived", 400);
+  const acting = domain.resolveActorUser(actor);
+  if (!acting.is_admin)
+    domain.assertChannelMember(channel, acting.id);
+  const userIds = (args.users ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+  if (userIds.length === 0)
+    slackError("no_user", 400);
+  const now = nowIso();
+  const out = domain.db.transaction(() => {
+    const beforeMembers = domain.channelMemberIds(channel.id);
+    for (const userRef of userIds) {
+      const user = domain.resolveUser(userRef);
+      if (!user)
+        slackError("user_not_found", 404);
+      const exists = domain.db.prepare(`SELECT 1 FROM channel_members WHERE channel_id = ? AND user_id = ?`).get(channel.id, user.id);
+      if (exists)
+        slackError("already_in_channel", 400);
+      domain.db.prepare(`INSERT INTO channel_members (channel_id, user_id, joined_at) VALUES (?, ?, ?)`).run(channel.id, user.id, now);
+    }
+    const afterMembers = domain.channelMemberIds(channel.id);
+    onDelta({
+      before: { channel_id: channel.id, members: beforeMembers },
+      after: { channel_id: channel.id, members: afterMembers }
+    });
+    return { channel: serializeChannel(channel, { num_members: afterMembers.length }) };
+  })();
+  return out;
+}
+function conversationsJoin(domain, args, actor, onDelta = NOOP3) {
+  const channel = domain.requireChannel(args.channel);
+  if (channel.is_archived)
+    slackError("is_archived", 400);
+  if (channel.is_private)
+    slackError("channel_not_found", 404);
+  const userId = domain.resolveActorUser(actor).id;
+  const now = nowIso();
+  const out = domain.db.transaction(() => {
+    const existing = domain.db.prepare(`SELECT * FROM channel_members WHERE channel_id = ? AND user_id = ?`).get(channel.id, userId);
+    if (existing) {
+      return { channel: serializeChannel(channel, { is_member: true }), already_in_channel: true, warning: "already_in_channel" };
+    }
+    domain.db.prepare(`INSERT INTO channel_members (channel_id, user_id, joined_at) VALUES (?, ?, ?)`).run(channel.id, userId, now);
+    const after = domain.db.prepare(`SELECT * FROM channel_members WHERE channel_id = ? AND user_id = ?`).get(channel.id, userId);
+    onDelta({ before: null, after });
+    return { channel: serializeChannel(channel, { is_member: true }) };
+  })();
+  return out;
+}
+function conversationsLeave(domain, args, actor, onDelta = NOOP3) {
+  const channel = domain.requireChannel(args.channel);
+  if (channel.name === "general")
+    slackError("cant_leave_general", 400);
+  const userId = domain.resolveActorUser(actor).id;
+  const out = domain.db.transaction(() => {
+    const existing = domain.db.prepare(`SELECT * FROM channel_members WHERE channel_id = ? AND user_id = ?`).get(channel.id, userId);
+    if (!existing)
+      slackError("not_in_channel", 400);
+    domain.db.prepare(`DELETE FROM channel_members WHERE channel_id = ? AND user_id = ?`).run(channel.id, userId);
+    onDelta({ before: existing, after: null });
+    return { not_in_channel: false };
+  })();
+  return out;
+}
+function conversationsKick(domain, args, actor, onDelta = NOOP3) {
+  const channel = domain.requireChannel(args.channel);
+  if (channel.name === "general")
+    slackError("cant_kick_from_general", 400);
+  const acting = domain.resolveActorUser(actor);
+  const target = domain.resolveUser(args.user);
+  if (!target)
+    slackError("user_not_found", 404);
+  if (target.id === acting.id)
+    slackError("cant_kick_self", 400);
+  const out = domain.db.transaction(() => {
+    const existing = domain.db.prepare(`SELECT * FROM channel_members WHERE channel_id = ? AND user_id = ?`).get(channel.id, target.id);
+    if (!existing)
+      slackError("not_in_channel", 400);
+    domain.db.prepare(`DELETE FROM channel_members WHERE channel_id = ? AND user_id = ?`).run(channel.id, target.id);
+    onDelta({ before: existing, after: null });
+    return {};
+  })();
+  return out;
+}
+function conversationsMembers(domain, args, actor = {}) {
+  const channel = domain.requireChannel(args.channel);
+  domain.assertChannelMemberForActor(channel, actor);
+  const offset = cursorDecode(args.cursor ?? null)?.offset ?? 0;
+  const limit = clampLimit(args.limit, 1e3, 100);
+  const rows = domain.db.prepare(`SELECT user_id FROM channel_members WHERE channel_id = ? ORDER BY joined_at, user_id LIMIT ? OFFSET ?`).all(channel.id, limit + 1, offset);
+  const hasMore = rows.length > limit;
+  const slice = rows.slice(0, limit);
+  return {
+    members: slice.map((row) => row.user_id),
+    response_metadata: {
+      next_cursor: hasMore ? cursorEncode({ offset: offset + slice.length }) : ""
+    }
+  };
+}
+function conversationsHistory(domain, args, actor = {}) {
+  const channel = domain.requireChannel(args.channel);
+  domain.assertChannelMemberForActor(channel, actor);
+  const offset = cursorDecode(args.cursor ?? null)?.offset ?? 0;
+  const limit = clampLimit(args.limit, 1e3, 100);
+  const params = [channel.id];
+  const where = [`channel_id = ?`, `(thread_ts IS NULL OR ts = thread_ts)`];
+  if (args.oldest) {
+    where.push(args.inclusive ? `ts >= ?` : `ts > ?`);
+    params.push(args.oldest);
+  }
+  if (args.latest) {
+    where.push(args.inclusive ? `ts <= ?` : `ts < ?`);
+    params.push(args.latest);
+  }
+  const sql = `SELECT * FROM messages WHERE ${where.join(" AND ")} ORDER BY ts DESC LIMIT ? OFFSET ?`;
+  params.push(limit + 1, offset);
+  const rows = domain.db.prepare(sql).all(...params);
+  const hasMore = rows.length > limit;
+  const slice = rows.slice(0, limit);
+  const workspaceId = domain.requireWorkspace().id;
+  return {
+    messages: slice.map((row) => serializeMessage(row, { reactions: domain.reactionsFor(row.channel_id, row.ts), include_team: workspaceId })),
+    has_more: hasMore,
+    pin_count: domain.db.prepare(`SELECT COUNT(*) AS c FROM pins WHERE channel_id = ?`).get(channel.id).c,
+    channel_actions_ts: null,
+    channel_actions_count: 0,
+    // Real Slack OMITS `response_metadata` on conversations.history when there is
+    // no next page (it only carries the pagination cursor when hasMore); it does
+    // NOT return an empty-cursor envelope here the way conversations.list does
+    // (FDRS-473 Kind B — conditional pagination matched per endpoint).
+    ...hasMore ? { response_metadata: { next_cursor: cursorEncode({ offset: offset + slice.length }) } } : {}
+  };
+}
+function conversationsReplies(domain, args, actor = {}) {
+  if (!args.ts)
+    slackError("invalid_arguments", 400);
+  const channel = domain.requireChannel(args.channel);
+  domain.assertChannelMemberForActor(channel, actor);
+  const parent = domain.db.prepare(`SELECT * FROM messages WHERE channel_id = ? AND ts = ?`).get(channel.id, args.ts);
+  if (!parent)
+    slackError("thread_not_found", 404);
+  const offset = cursorDecode(args.cursor ?? null)?.offset ?? 0;
+  const limit = clampLimit(args.limit, 1e3, 100);
+  const rows = domain.db.prepare(`SELECT * FROM messages
+       WHERE channel_id = ? AND (ts = ? OR thread_ts = ?)
+       ORDER BY ts ASC LIMIT ? OFFSET ?`).all(channel.id, args.ts, args.ts, limit + 1, offset);
+  const hasMore = rows.length > limit;
+  const slice = rows.slice(0, limit);
+  const workspaceId = domain.requireWorkspace().id;
+  const parentAuthor = parent.user_id;
+  const parentTs = parent.ts;
+  return {
+    messages: slice.map((row) => {
+      const isParent = row.ts === parentTs && !row.thread_ts;
+      const serialized = serializeMessage(row, {
+        reactions: domain.reactionsFor(row.channel_id, row.ts),
+        include_team: workspaceId,
+        parent_user_id: row.thread_ts ? parentAuthor : void 0
+      });
+      if (isParent) {
+        serialized.thread_ts = parentTs;
+        serialized.subscribed = false;
+        serialized.is_locked = false;
+      }
+      return serialized;
+    }),
+    has_more: hasMore,
+    // Real Slack OMITS `response_metadata` on conversations.replies when there is
+    // no next page (cursor present only when hasMore) — FDRS-473 Kind B.
+    ...hasMore ? { response_metadata: { next_cursor: cursorEncode({ offset: offset + slice.length }) } } : {}
+  };
+}
+function conversationsOpen(domain, args, actor, onDelta = NOOP3) {
+  const workspace = domain.requireWorkspace();
+  const acting = domain.resolveActorUser(actor);
+  if (args.channel) {
+    const existing = domain.requireChannel(args.channel);
+    onDelta({ before: existing, after: existing });
+    return { no_op: true, already_open: true, channel: serializeChannel(existing, { is_member: true }) };
+  }
+  if (!args.users)
+    slackError("users_list_not_supplied", 400);
+  const targetIds = args.users.split(",").map((s) => s.trim()).filter(Boolean).map((u) => {
+    const found = domain.resolveUser(u);
+    if (!found)
+      slackError("user_not_found", 404);
+    return found.id;
+  });
+  const allIds = [.../* @__PURE__ */ new Set([acting.id, ...targetIds])].sort();
+  const isMpim = allIds.length > 2;
+  const lookupName = isMpim ? `mpdm-${allIds.join("--")}` : "";
+  const dmSignature = allIds.join("|");
+  const out = domain.db.transaction(() => {
+    const existingChannel = domain.findDirectChannelBySignature(workspace.id, dmSignature);
+    if (existingChannel) {
+      onDelta({ before: existingChannel, after: existingChannel });
+      return { no_op: true, already_open: true, channel: serializeChannel(existingChannel, { is_member: true }) };
+    }
+    const channelId = domain.allocId(workspace.id, isMpim ? "M" : "D");
+    const now = nowIso();
+    domain.db.prepare(`INSERT INTO channels (id, team_id, name, is_channel, is_group, is_im, is_mpim, is_private, is_archived, topic, purpose, creator, created_at, ts_counter, dm_signature)
+         VALUES (?, ?, ?, 0, 0, ?, ?, 1, 0, '', '', ?, ?, 0, ?)`).run(channelId, workspace.id, lookupName, isMpim ? 0 : 1, isMpim ? 1 : 0, acting.id, now, dmSignature);
+    for (const id of allIds) {
+      domain.db.prepare(`INSERT OR IGNORE INTO channel_members (channel_id, user_id, joined_at) VALUES (?, ?, ?)`).run(channelId, id, now);
+    }
+    const created = domain.requireChannelRow(channelId);
+    onDelta({ before: null, after: created });
+    return { channel: serializeChannel(created, { is_member: true, num_members: allIds.length }) };
+  })();
+  return out;
+}
+
+// ../packages/twin-slack/dist/src/domain/files.js
+function filesUpload(domain, args, actor, onDelta = NOOP3) {
+  const workspace = domain.requireWorkspace();
+  const acting = domain.resolveActorUser(actor);
+  const channelsRaw = args.channels ?? args.channel ?? "";
+  const channelIds = channelsRaw.split(",").map((s) => s.trim()).filter(Boolean).map((ref) => domain.requireChannel(ref).id);
+  const id = domain.allocId(workspace.id, "F");
+  const name = args.filename ?? `untitled-${id}.txt`;
+  const title = args.title ?? name;
+  const filetype = args.filetype ?? "text";
+  const content = args.content ?? null;
+  const size = content ? Buffer.byteLength(content, "utf8") : 0;
+  const out = domain.db.transaction(() => {
+    domain.db.prepare(`INSERT INTO files (id, team_id, user_id, name, title, mimetype, filetype, size, url_private, channels_json, deleted, content, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, '', ?, 0, ?, ?)`).run(id, workspace.id, acting.id, name, title, filetypeMimetype(filetype), filetype, size, JSON.stringify(channelIds), content, nowIso());
+    const after = domain.db.prepare(`SELECT * FROM files WHERE id = ?`).get(id);
+    if (args.initial_comment && channelIds.length > 0) {
+      const ts = domain.allocMessageTs(channelIds[0]);
+      domain.db.prepare(`INSERT INTO messages (channel_id, ts, user_id, text, subtype, thread_ts, blocks_json, attachments_json)
+           VALUES (?, ?, ?, ?, ?, ?, '[]', ?)`).run(channelIds[0], ts, acting.id, args.initial_comment, "file_share", args.thread_ts ?? null, JSON.stringify([{ id: 1, file_id: id, title }]));
+    }
+    onDelta({ before: null, after });
+    return { file: serializeFile(after) };
+  })();
+  return out;
+}
+function filesInfo(domain, args) {
+  const file = domain.db.prepare(`SELECT * FROM files WHERE id = ?`).get(args.file);
+  if (!file)
+    slackError("file_not_found", 404);
+  return {
+    file: serializeFile(file),
+    comments: [],
+    response_metadata: { next_cursor: "" }
+  };
+}
+function filesList(domain, args) {
+  const count = clampLimit(args.count, 1e3, 100);
+  const page = Math.max(1, Math.floor(args.page ?? 1));
+  const offset = (page - 1) * count;
+  const params = [];
+  const where = [`deleted = 0`];
+  if (args.user) {
+    const user = domain.resolveUser(args.user);
+    if (!user)
+      slackError("user_not_found", 404);
+    where.push(`user_id = ?`);
+    params.push(user.id);
+  }
+  let sql = `SELECT * FROM files WHERE ${where.join(" AND ")} ORDER BY created_at DESC LIMIT ? OFFSET ?`;
+  params.push(count, offset);
+  let rows = domain.db.prepare(sql).all(...params);
+  if (args.channel) {
+    const channelId = domain.requireChannel(args.channel).id;
+    rows = rows.filter((row) => JSON.parse(row.channels_json).includes(channelId));
+  }
+  const total = domain.db.prepare(`SELECT COUNT(*) AS c FROM files WHERE deleted = 0`).get().c;
+  return {
+    files: rows.map((row) => serializeFile(row)),
+    paging: {
+      count,
+      total,
+      page,
+      pages: total === 0 ? 0 : Math.ceil(total / count)
+    }
+    // files.list paginates via `paging` (page/pages), not a cursor. Real Slack
+    // does NOT return a `response_metadata.next_cursor` envelope on files.list,
+    // so the twin omits it rather than emitting an empty-cursor stub that diffs
+    // as a twin-only field (FDRS-473 Kind B).
+  };
+}
+function filesDelete(domain, args, actor, onDelta = NOOP3) {
+  const before = domain.db.prepare(`SELECT * FROM files WHERE id = ?`).get(args.file);
+  if (!before)
+    slackError("file_not_found", 404);
+  const out = domain.db.transaction(() => {
+    domain.db.prepare(`UPDATE files SET deleted = 1 WHERE id = ?`).run(args.file);
+    const after = domain.db.prepare(`SELECT * FROM files WHERE id = ?`).get(args.file);
+    onDelta({ before, after });
+    return {};
+  })();
+  return out;
+}
+
+// ../packages/twin-slack/dist/src/domain/pins.js
+function pinsAdd(domain, args, actor, onDelta = NOOP3) {
+  const channel = domain.requireChannel(args.channel);
+  const message = domain.db.prepare(`SELECT * FROM messages WHERE channel_id = ? AND ts = ?`).get(channel.id, args.timestamp);
+  if (!message)
+    slackError("message_not_found", 404);
+  const acting = domain.resolveActorUser(actor);
+  const out = domain.db.transaction(() => {
+    const existing = domain.db.prepare(`SELECT * FROM pins WHERE channel_id = ? AND message_ts = ?`).get(channel.id, args.timestamp);
+    if (existing)
+      slackError("already_pinned", 400);
+    domain.db.prepare(`INSERT INTO pins (channel_id, message_ts, pinned_by, pinned_at) VALUES (?, ?, ?, ?)`).run(channel.id, args.timestamp, acting.id, nowIso());
+    const after = domain.db.prepare(`SELECT * FROM pins WHERE channel_id = ? AND message_ts = ?`).get(channel.id, args.timestamp);
+    onDelta({ before: null, after });
+    return {};
+  })();
+  return out;
+}
+function pinsRemove(domain, args, actor, onDelta = NOOP3) {
+  const channel = domain.requireChannel(args.channel);
+  const before = domain.db.prepare(`SELECT * FROM pins WHERE channel_id = ? AND message_ts = ?`).get(channel.id, args.timestamp);
+  if (!before)
+    slackError("no_pin", 404);
+  const out = domain.db.transaction(() => {
+    domain.db.prepare(`DELETE FROM pins WHERE channel_id = ? AND message_ts = ?`).run(channel.id, args.timestamp);
+    onDelta({ before, after: null });
+    return {};
+  })();
+  return out;
+}
+function pinsList(domain, args, actor = {}) {
+  const channel = domain.requireChannel(args.channel);
+  domain.assertChannelMemberForActor(channel, actor);
+  const pins = domain.db.prepare(`SELECT * FROM pins WHERE channel_id = ? ORDER BY pinned_at`).all(channel.id);
+  const items = pins.map((pin) => {
+    const message = domain.db.prepare(`SELECT * FROM messages WHERE channel_id = ? AND ts = ?`).get(pin.channel_id, pin.message_ts);
+    const serializedMessage = message ? serializeMessage(message, { reactions: domain.reactionsFor(pin.channel_id, pin.message_ts) }) : { ts: pin.message_ts };
+    return serializePin(pin, serializedMessage);
+  });
+  return { items };
+}
+
+// ../packages/twin-slack/dist/src/domain/reactions.js
+function reactionsAdd(domain, args, actor, onDelta = NOOP3) {
+  if (!args.name)
+    slackError("no_reaction", 400);
+  const channel = domain.requireChannel(args.channel);
+  const message = domain.db.prepare(`SELECT * FROM messages WHERE channel_id = ? AND ts = ?`).get(channel.id, args.timestamp);
+  if (!message)
+    slackError("message_not_found", 404);
+  const acting = domain.resolveActorUser(actor);
+  const reaction = normalizeReactionName(args.name);
+  const out = domain.db.transaction(() => {
+    const existing = domain.db.prepare(`SELECT * FROM reactions WHERE channel_id = ? AND message_ts = ? AND name = ? AND user_id = ?`).get(channel.id, args.timestamp, reaction, acting.id);
+    if (existing)
+      slackError("already_reacted", 400);
+    const now = nowIso();
+    domain.db.prepare(`INSERT INTO reactions (channel_id, message_ts, name, user_id, added_at) VALUES (?, ?, ?, ?, ?)`).run(channel.id, args.timestamp, reaction, acting.id, now);
+    const after = domain.db.prepare(`SELECT * FROM reactions WHERE channel_id = ? AND message_ts = ? AND name = ? AND user_id = ?`).get(channel.id, args.timestamp, reaction, acting.id);
+    onDelta({ before: null, after });
+    return {};
+  })();
+  return out;
+}
+function reactionsRemove(domain, args, actor, onDelta = NOOP3) {
+  if (!args.name)
+    slackError("no_reaction", 400);
+  const channel = domain.requireChannel(args.channel);
+  const acting = domain.resolveActorUser(actor);
+  const reaction = normalizeReactionName(args.name);
+  const before = domain.db.prepare(`SELECT * FROM reactions WHERE channel_id = ? AND message_ts = ? AND name = ? AND user_id = ?`).get(channel.id, args.timestamp, reaction, acting.id);
+  if (!before)
+    slackError("no_reaction", 404);
+  const out = domain.db.transaction(() => {
+    domain.db.prepare(`DELETE FROM reactions WHERE channel_id = ? AND message_ts = ? AND name = ? AND user_id = ?`).run(channel.id, args.timestamp, reaction, acting.id);
+    onDelta({ before, after: null });
+    return {};
+  })();
+  return out;
+}
+function reactionsGet(domain, args, actor = {}) {
+  const channel = domain.requireChannel(args.channel);
+  domain.assertChannelMemberForActor(channel, actor);
+  const message = domain.db.prepare(`SELECT * FROM messages WHERE channel_id = ? AND ts = ?`).get(channel.id, args.timestamp);
+  if (!message)
+    slackError("message_not_found", 404);
+  const reactions = domain.reactionsFor(channel.id, args.timestamp);
+  return {
+    type: "message",
+    channel: channel.id,
+    message: { ...serializeMessage(message, { reactions }) }
+  };
+}
+
+// ../packages/twin-slack/dist/src/domain/search.js
+function searchMessages(domain, args, actor = {}) {
+  if (!args.query || args.query.trim() === "")
+    slackError("no_query", 400);
+  const acting = domain.resolveActorUser(actor);
+  const count = clampLimit(args.count, 100, 20);
+  const page = Math.max(1, Math.floor(args.page ?? 1));
+  const offset = (page - 1) * count;
+  const sortDir = (args.sort_dir ?? "desc").toLowerCase() === "asc" ? "ASC" : "DESC";
+  const like = `%${args.query.replace(/[%_]/g, (m) => `\\${m}`)}%`;
+  const visibilityClause = `(
+    channel_id IN (SELECT id FROM channels WHERE is_private = 0 AND is_im = 0 AND is_mpim = 0)
+    OR channel_id IN (SELECT channel_id FROM channel_members WHERE user_id = ?)
+  )`;
+  const total = domain.db.prepare(`SELECT COUNT(*) AS c FROM messages WHERE text LIKE ? ESCAPE '\\' AND ${visibilityClause}`).get(like, acting.id).c;
+  const rows = domain.db.prepare(`SELECT * FROM messages
+       WHERE text LIKE ? ESCAPE '\\' AND ${visibilityClause}
+       ORDER BY ts ${sortDir}
+       LIMIT ? OFFSET ?`).all(like, acting.id, count, offset);
+  const matches = rows.map((row) => {
+    const channel = domain.db.prepare(`SELECT * FROM channels WHERE id = ?`).get(row.channel_id);
+    return {
+      iid: `${row.channel_id}-${row.ts}`,
+      type: "message",
+      user: row.user_id,
+      username: domain.userNameOf(row.user_id),
+      ts: row.ts,
+      text: row.text,
+      permalink: `${SLACK_TWIN_HOST}/archives/${row.channel_id}/p${row.ts.replace(".", "")}`,
+      team: domain.requireWorkspace().id,
+      channel: channel ? { id: channel.id, name: channel.name, is_private: Boolean(channel.is_private) } : { id: row.channel_id, name: "", is_private: false }
+    };
+  });
+  return {
+    query: args.query,
+    messages: {
+      total,
+      pagination: {
+        page,
+        page_count: total === 0 ? 0 : Math.ceil(total / count),
+        per_page: count,
+        total_count: total,
+        first: offset + 1,
+        last: offset + matches.length
+      },
+      paging: {
+        count,
+        total,
+        page,
+        pages: total === 0 ? 0 : Math.ceil(total / count)
+      },
+      matches
+    }
+  };
+}
+
+// ../packages/twin-slack/dist/src/domain/team.js
+function authTest(domain, actor) {
+  const workspace = domain.requireWorkspace();
+  const userRow = domain.resolveActorUser(actor);
+  return {
+    url: `${SLACK_TWIN_HOST}/`,
+    team: workspace.name,
+    user: userRow.name,
+    team_id: workspace.id,
+    user_id: userRow.id,
+    bot_id: userRow.is_bot ? userRow.id : null,
+    is_enterprise_install: false
+  };
+}
+function teamInfo(domain, args) {
+  return { team: serializeWorkspace(domain.requireWorkspace()) };
+}
+
+// ../packages/twin-slack/dist/src/domain/users.js
+function usersList(domain, args) {
+  const workspace = domain.requireWorkspace();
+  const offset = cursorDecode(args.cursor ?? null)?.offset ?? 0;
+  const limit = clampLimit(args.limit, 1e3, 100);
+  const rows = domain.db.prepare(`SELECT * FROM users WHERE team_id = ? ORDER BY id LIMIT ? OFFSET ?`).all(workspace.id, limit + 1, offset);
+  const hasMore = rows.length > limit;
+  const slice = rows.slice(0, limit);
+  return {
+    // users.list embeds each user's profile WITHOUT `email` — real Slack only
+    // returns the email on the single-user reads (FDRS-473 Kind B).
+    members: slice.map((row) => serializeUser(row, { include_locale: args.include_locale, omitProfileEmail: true })),
+    cache_ts: nowUnix(),
+    response_metadata: {
+      next_cursor: hasMore ? cursorEncode({ offset: offset + slice.length }) : ""
+    }
+  };
+}
+function usersInfo(domain, args) {
+  const user = domain.resolveUser(args.user);
+  if (!user)
+    slackError("user_not_found", 404);
+  return { user: serializeUser(user, { include_locale: args.include_locale }) };
+}
+function usersLookupByEmail(domain, args) {
+  if (!args.email)
+    slackError("users_not_found", 400);
+  const workspace = domain.requireWorkspace();
+  const user = domain.db.prepare(`SELECT * FROM users WHERE team_id = ? AND email = ?`).get(workspace.id, args.email);
+  if (!user)
+    slackError("users_not_found", 404);
+  return { user: serializeUser(user) };
+}
+function usersProfileGet(domain, args, actor) {
+  const target = args.user ? domain.resolveUser(args.user) : domain.resolveActorUser(actor);
+  if (!target)
+    slackError("user_not_found", 404);
+  return { profile: serializeUserProfile(target, { omitTeam: true }) };
+}
+function usersProfileSet(domain, args, actor, onDelta = NOOP3) {
+  const target = args.user ? domain.resolveUser(args.user) : domain.resolveActorUser(actor);
+  if (!target)
+    slackError("user_not_found", 404);
+  const acting = domain.resolveActorUser(actor);
+  if (target.id !== acting.id && !acting.is_admin)
+    slackError("cant_set_profile_for_other_user", 403);
+  const out = domain.db.transaction(() => {
+    const before = domain.db.prepare(`SELECT * FROM users WHERE id = ?`).get(target.id);
+    let profile = safeParseJson(before.profile_json);
+    if (args.profile) {
+      const incoming = safeParseJson(args.profile);
+      profile = { ...profile, ...incoming };
+    } else if (args.name) {
+      profile = { ...profile, [args.name]: args.value ?? "" };
+    }
+    domain.db.prepare(`UPDATE users SET profile_json = ?, real_name = COALESCE((SELECT json_extract(?, '$.real_name')), real_name), updated_at = ? WHERE id = ?`).run(JSON.stringify(profile), JSON.stringify(profile), nowIso(), target.id);
+    const after = domain.db.prepare(`SELECT * FROM users WHERE id = ?`).get(target.id);
+    onDelta({ before, after });
+    return { profile: serializeUserProfile(after, { omitTeam: true }) };
+  })();
+  return out;
+}
+
+// ../packages/twin-slack/dist/src/domain/slack-domain.js
+var NOOP3 = () => {
+};
+var DEFAULT_BOT_USER = "U_PRIMARY";
+var DEFAULT_TEAM_ID = "T_POME";
+var SlackDomain = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  // ───────────────────────────────────────────────────────────────────────────
+  // Lifecycle
+  // ───────────────────────────────────────────────────────────────────────────
+  seed(state) {
+    resetDatabase(this.db);
+    const team = state.team ?? {};
+    const teamId = team.id ?? DEFAULT_TEAM_ID;
+    const teamName = team.name ?? "Pome Twin Workspace";
+    const teamDomain = team.domain ?? "pome-twin";
+    const now = nowIso();
+    this.db.transaction(() => {
+      this.db.prepare(`INSERT INTO workspaces (id, name, domain, url, enterprise_id, created_at, entity_counter)
+           VALUES (?, ?, ?, ?, NULL, ?, 0)`).run(teamId, teamName, teamDomain, `${SLACK_TWIN_HOST}/`, now);
+      const userIdByHandle = /* @__PURE__ */ new Map();
+      const seedUsers = state.users ?? [];
+      for (const u of seedUsers) {
+        const id = u.id ?? this.allocId(teamId, u.is_bot ? "B" : "U");
+        const handle = u.name;
+        userIdByHandle.set(handle, id);
+        userIdByHandle.set(id, id);
+        this.db.prepare(`INSERT INTO users (id, team_id, name, real_name, display_name, email, is_bot, is_admin, deleted, tz, profile_json, created_at, updated_at)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, ?, ?, ?, ?)`).run(id, teamId, handle, u.real_name ?? "", "", u.email ?? null, u.is_bot ? 1 : 0, u.is_admin ? 1 : 0, u.tz ?? "America/Los_Angeles", JSON.stringify(u.profile ?? {}), now, now);
+      }
+      if (!userIdByHandle.has("pome-agent") && !userIdByHandle.has(DEFAULT_BOT_USER)) {
+        const id = DEFAULT_BOT_USER;
+        userIdByHandle.set("pome-agent", id);
+        userIdByHandle.set(id, id);
+        this.db.prepare(`INSERT INTO users (id, team_id, name, real_name, display_name, email, is_bot, is_admin, deleted, tz, profile_json, created_at, updated_at)
+             VALUES (?, ?, 'pome-agent', 'Pome Agent', '', 'pome-agent@pome-twin.slack.com', 0, 1, 0, 'America/Los_Angeles', '{}', ?, ?)`).run(id, teamId, now, now);
+      }
+      const seedChannels = state.channels ?? [];
+      for (const ch of seedChannels) {
+        const channelId = ch.id ?? this.allocId(teamId, ch.is_private ? "G" : "C");
+        const creator = this.resolveSeedUserId(ch.creator, userIdByHandle) ?? DEFAULT_BOT_USER;
+        this.db.prepare(`INSERT INTO channels (id, team_id, name, is_channel, is_group, is_im, is_mpim, is_private, is_archived, topic, purpose, creator, created_at, ts_counter)
+             VALUES (?, ?, ?, ?, ?, 0, 0, ?, 0, ?, ?, ?, ?, 0)`).run(channelId, teamId, ch.name, ch.is_private ? 0 : 1, ch.is_private ? 1 : 0, ch.is_private ? 1 : 0, ch.topic ?? "", ch.purpose ?? "", creator, now);
+        for (const member of ch.members ?? []) {
+          const memberId = this.resolveSeedUserId(member, userIdByHandle);
+          if (!memberId)
+            continue;
+          this.db.prepare(`INSERT OR IGNORE INTO channel_members (channel_id, user_id, joined_at) VALUES (?, ?, ?)`).run(channelId, memberId, now);
+        }
+        const seededTsByOriginalTs = /* @__PURE__ */ new Map();
+        for (const m of ch.messages ?? []) {
+          const ts = m.ts ?? this.allocMessageTs(channelId);
+          if (m.ts)
+            seededTsByOriginalTs.set(m.ts, ts);
+          const userId = this.resolveSeedUserId(m.user, userIdByHandle) ?? DEFAULT_BOT_USER;
+          const threadTs = m.thread_ts ? seededTsByOriginalTs.get(m.thread_ts) ?? m.thread_ts : null;
+          this.db.prepare(`INSERT INTO messages (channel_id, ts, user_id, text, subtype, thread_ts, reply_count, reply_users_count, latest_reply, edited_user_id, edited_ts, blocks_json, attachments_json)
+               VALUES (?, ?, ?, ?, NULL, ?, 0, 0, NULL, NULL, NULL, '[]', '[]')`).run(channelId, ts, userId, m.text, threadTs);
+          if (threadTs) {
+            this.db.prepare(`UPDATE messages SET reply_count = reply_count + 1, latest_reply = ?,
+                  reply_users_count = (
+                    SELECT COUNT(DISTINCT user_id) FROM messages WHERE channel_id = ? AND thread_ts = ?
+                  )
+                 WHERE channel_id = ? AND ts = ?`).run(ts, channelId, threadTs, channelId, threadTs);
+          }
+          for (const r of m.reactions ?? []) {
+            const reactorId = this.resolveSeedUserId(r.user, userIdByHandle);
+            if (!reactorId)
+              continue;
+            this.db.prepare(`INSERT OR IGNORE INTO reactions (channel_id, message_ts, name, user_id, added_at) VALUES (?, ?, ?, ?, ?)`).run(channelId, ts, r.name, reactorId, now);
+          }
+        }
+      }
+      const seedEmoji = state.emoji ?? [];
+      if (seedEmoji.length > 0) {
+        seedEmojiRows(this.db, teamId, seedEmoji);
+      }
+    })();
+  }
+  resetToDefault(seedFn, onDelta = NOOP3) {
+    const beforeSummary = this.summarizeState();
+    this.seed(seedFn());
+    const afterSummary = this.summarizeState();
+    onDelta({ before: beforeSummary, after: afterSummary });
+    return { ok: true };
+  }
+  applySeed(input, onDelta = NOOP3) {
+    const beforeSummary = this.summarizeState();
+    const next = parseSeed(input);
+    this.seed(next);
+    const afterSummary = this.summarizeState();
+    onDelta({ before: beforeSummary, after: afterSummary });
+    return { ok: true };
+  }
+  exportState() {
+    const workspace = this.firstWorkspace();
+    if (!workspace)
+      return { workspace: null };
+    return {
+      workspace: {
+        id: workspace.id,
+        name: workspace.name,
+        domain: workspace.domain
+      },
+      users: this.db.prepare(`SELECT * FROM users WHERE team_id = ? ORDER BY id`).all(workspace.id),
+      channels: this.allChannels().map((channel) => ({
+        ...channel,
+        members: this.db.prepare(`SELECT user_id FROM channel_members WHERE channel_id = ? ORDER BY user_id`).all(channel.id).map((row) => row.user_id),
+        messages: this.db.prepare(`SELECT * FROM messages WHERE channel_id = ? ORDER BY ts`).all(channel.id)
+      })),
+      reactions: this.db.prepare(`SELECT * FROM reactions ORDER BY channel_id, message_ts, name, user_id`).all(),
+      pins: this.db.prepare(`SELECT * FROM pins ORDER BY channel_id, message_ts`).all(),
+      files: this.db.prepare(`SELECT * FROM files ORDER BY id`).all(),
+      bookmarks: this.db.prepare(`SELECT * FROM bookmarks ORDER BY id`).all(),
+      scheduled_messages: this.db.prepare(`SELECT * FROM scheduled_messages ORDER BY id`).all(),
+      canvases: this.db.prepare(`SELECT * FROM canvases ORDER BY id`).all(),
+      emoji: this.db.prepare(`SELECT * FROM emoji ORDER BY team_id, name`).all()
+    };
+  }
+  summarizeState() {
+    const get = (sql) => this.db.prepare(sql).get().c;
+    return {
+      users: get(`SELECT COUNT(*) AS c FROM users`),
+      channels: get(`SELECT COUNT(*) AS c FROM channels`),
+      messages: get(`SELECT COUNT(*) AS c FROM messages`),
+      reactions: get(`SELECT COUNT(*) AS c FROM reactions`),
+      pins: get(`SELECT COUNT(*) AS c FROM pins`),
+      files: get(`SELECT COUNT(*) AS c FROM files`),
+      bookmarks: get(`SELECT COUNT(*) AS c FROM bookmarks`),
+      scheduled_messages: get(`SELECT COUNT(*) AS c FROM scheduled_messages`),
+      canvases: get(`SELECT COUNT(*) AS c FROM canvases`),
+      emoji: get(`SELECT COUNT(*) AS c FROM emoji`)
+    };
+  }
+  authTest(actor) {
+    return authTest(this, actor);
+  }
+  conversationsList(args) {
+    return conversationsList(this, args);
+  }
+  conversationsInfo(args, actor = {}) {
+    return conversationsInfo(this, args, actor);
+  }
+  conversationsCreate(args, actor, onDelta = NOOP3) {
+    return conversationsCreate(this, args, actor, onDelta);
+  }
+  conversationsArchive(args, actor, onDelta = NOOP3) {
+    return conversationsArchive(this, args, actor, onDelta);
+  }
+  conversationsInvite(args, actor, onDelta = NOOP3) {
+    return conversationsInvite(this, args, actor, onDelta);
+  }
+  conversationsJoin(args, actor, onDelta = NOOP3) {
+    return conversationsJoin(this, args, actor, onDelta);
+  }
+  conversationsLeave(args, actor, onDelta = NOOP3) {
+    return conversationsLeave(this, args, actor, onDelta);
+  }
+  conversationsKick(args, actor, onDelta = NOOP3) {
+    return conversationsKick(this, args, actor, onDelta);
+  }
+  conversationsMembers(args, actor = {}) {
+    return conversationsMembers(this, args, actor);
+  }
+  conversationsHistory(args, actor = {}) {
+    return conversationsHistory(this, args, actor);
+  }
+  conversationsReplies(args, actor = {}) {
+    return conversationsReplies(this, args, actor);
+  }
+  conversationsOpen(args, actor, onDelta = NOOP3) {
+    return conversationsOpen(this, args, actor, onDelta);
+  }
+  chatPostMessage(args, actor, onDelta = NOOP3) {
+    return chatPostMessage(this, args, actor, onDelta);
+  }
+  chatUpdate(args, actor, onDelta = NOOP3) {
+    return chatUpdate(this, args, actor, onDelta);
+  }
+  chatDelete(args, actor, onDelta = NOOP3) {
+    return chatDelete(this, args, actor, onDelta);
+  }
+  chatScheduleMessage(args, actor, onDelta = NOOP3) {
+    return chatScheduleMessage(this, args, actor, onDelta);
+  }
+  chatDeleteScheduledMessage(args, actor, onDelta = NOOP3) {
+    return chatDeleteScheduledMessage(this, args, actor, onDelta);
+  }
+  reactionsAdd(args, actor, onDelta = NOOP3) {
+    return reactionsAdd(this, args, actor, onDelta);
+  }
+  reactionsRemove(args, actor, onDelta = NOOP3) {
+    return reactionsRemove(this, args, actor, onDelta);
+  }
+  reactionsGet(args, actor = {}) {
+    return reactionsGet(this, args, actor);
+  }
+  usersList(args) {
+    return usersList(this, args);
+  }
+  usersInfo(args) {
+    return usersInfo(this, args);
+  }
+  usersLookupByEmail(args) {
+    return usersLookupByEmail(this, args);
+  }
+  usersProfileGet(args, actor) {
+    return usersProfileGet(this, args, actor);
+  }
+  usersProfileSet(args, actor, onDelta = NOOP3) {
+    return usersProfileSet(this, args, actor, onDelta);
+  }
+  pinsAdd(args, actor, onDelta = NOOP3) {
+    return pinsAdd(this, args, actor, onDelta);
+  }
+  pinsRemove(args, actor, onDelta = NOOP3) {
+    return pinsRemove(this, args, actor, onDelta);
+  }
+  pinsList(args, actor = {}) {
+    return pinsList(this, args, actor);
+  }
+  searchMessages(args, actor = {}) {
+    return searchMessages(this, args, actor);
+  }
+  filesUpload(args, actor, onDelta = NOOP3) {
+    return filesUpload(this, args, actor, onDelta);
+  }
+  filesInfo(args) {
+    return filesInfo(this, args);
+  }
+  filesList(args) {
+    return filesList(this, args);
+  }
+  filesDelete(args, actor, onDelta = NOOP3) {
+    return filesDelete(this, args, actor, onDelta);
+  }
+  bookmarksAdd(args, actor, onDelta = NOOP3) {
+    return bookmarksAdd(this, args, actor, onDelta);
+  }
+  bookmarksRemove(args, actor, onDelta = NOOP3) {
+    return bookmarksRemove(this, args, actor, onDelta);
+  }
+  bookmarksList(args) {
+    return bookmarksList(this, args);
+  }
+  teamInfo(args) {
+    return teamInfo(this);
+  }
+  // ───────────────────────────────────────────────────────────────────────────
+  // Conversations topic / purpose (Wave 3)
+  // ───────────────────────────────────────────────────────────────────────────
+  conversationsSetTopic(args, actor, onDelta = NOOP3) {
+    return conversationsSetTopic({
+      db: this.db,
+      requireChannel: (ref) => this.requireChannel(ref),
+      actor: this.resolveActorUser(actor)
+    }, args, onDelta);
+  }
+  conversationsSetPurpose(args, actor, onDelta = NOOP3) {
+    return conversationsSetPurpose({
+      db: this.db,
+      requireChannel: (ref) => this.requireChannel(ref),
+      actor: this.resolveActorUser(actor)
+    }, args, onDelta);
+  }
+  // ───────────────────────────────────────────────────────────────────────────
+  // Canvases (Wave 3)
+  // ───────────────────────────────────────────────────────────────────────────
+  canvasesCreate(args, actor, onDelta = NOOP3) {
+    const workspace = this.requireWorkspace();
+    return canvasesCreate({
+      db: this.db,
+      workspaceId: workspace.id,
+      actor: this.resolveActorUser(actor),
+      allocId: (prefix) => this.allocId(workspace.id, prefix),
+      requireChannel: (ref) => this.requireChannel(ref)
+    }, args, onDelta);
+  }
+  canvasesEdit(args, actor, onDelta = NOOP3) {
+    const workspace = this.requireWorkspace();
+    return canvasesEdit({
+      db: this.db,
+      workspaceId: workspace.id,
+      actor: this.resolveActorUser(actor),
+      allocId: (prefix) => this.allocId(workspace.id, prefix),
+      requireChannel: (ref) => this.requireChannel(ref)
+    }, args, onDelta);
+  }
+  canvasesDelete(args, actor, onDelta = NOOP3) {
+    const workspace = this.requireWorkspace();
+    return canvasesDelete({
+      db: this.db,
+      workspaceId: workspace.id,
+      actor: this.resolveActorUser(actor),
+      allocId: (prefix) => this.allocId(workspace.id, prefix),
+      requireChannel: (ref) => this.requireChannel(ref)
+    }, args, onDelta);
+  }
+  // ───────────────────────────────────────────────────────────────────────────
+  // Emoji (Wave 3)
+  // ───────────────────────────────────────────────────────────────────────────
+  emojiList(_args = {}) {
+    return emojiList({ db: this.db, workspaceId: this.requireWorkspace().id });
+  }
+  // ----- shared helpers (used by domain/* modules) -----
+  // ───────────────────────────────────────────────────────────────────────────
+  // Private helpers
+  // ───────────────────────────────────────────────────────────────────────────
+  firstWorkspace() {
+    return this.db.prepare(`SELECT * FROM workspaces LIMIT 1`).get();
+  }
+  requireWorkspace() {
+    const w = this.firstWorkspace();
+    if (!w)
+      slackError("team_not_found", 404);
+    return w;
+  }
+  allChannels() {
+    return this.db.prepare(`SELECT * FROM channels ORDER BY rowid`).all();
+  }
+  allocId(workspaceId, prefix) {
+    const row = this.db.prepare(`UPDATE workspaces SET entity_counter = entity_counter + 1 WHERE id = ? RETURNING entity_counter`).get(workspaceId);
+    if (!row)
+      throw new Error(`workspace ${workspaceId} not found for id allocation`);
+    return `${prefix}${String(row.entity_counter).padStart(6, "0")}`;
+  }
+  allocMessageTs(channelId) {
+    const channel = this.db.prepare(`SELECT team_id FROM channels WHERE id = ?`).get(channelId);
+    if (!channel)
+      throw new Error(`channel ${channelId} not found for ts allocation`);
+    const row = this.db.prepare(`UPDATE workspaces SET ts_counter = ts_counter + 1 WHERE id = ? RETURNING ts_counter`).get(channel.team_id);
+    if (!row)
+      throw new Error(`workspace ${channel.team_id} not found for ts allocation`);
+    return `${tsBaseSeconds()}.${padTsCounter(row.ts_counter)}`;
+  }
+  resolveSeedUserId(ref, map) {
+    if (!ref)
+      return void 0;
+    return map.get(ref) ?? ref;
+  }
+  resolveUser(ref) {
+    if (!ref)
+      return void 0;
+    const byId = this.db.prepare(`SELECT * FROM users WHERE id = ?`).get(ref);
+    if (byId)
+      return byId;
+    const workspace = this.firstWorkspace();
+    if (!workspace)
+      return void 0;
+    const byName = this.db.prepare(`SELECT * FROM users WHERE team_id = ? AND name = ?`).get(workspace.id, ref);
+    if (byName)
+      return byName;
+    if (ref.includes("@")) {
+      const byEmail = this.db.prepare(`SELECT * FROM users WHERE team_id = ? AND email = ?`).get(workspace.id, ref);
+      if (byEmail)
+        return byEmail;
+    }
+    return void 0;
+  }
+  resolveActorUser(actor) {
+    if (actor.login) {
+      const user = this.resolveUser(actor.login);
+      if (!user)
+        slackError("user_not_found", 404);
+      return user;
+    }
+    const defaultUser = this.resolveUser("pome-agent");
+    if (defaultUser)
+      return defaultUser;
+    const fallback = this.db.prepare(`SELECT * FROM users WHERE id = ?`).get(DEFAULT_BOT_USER);
+    if (fallback)
+      return fallback;
+    slackError("user_not_found", 404);
+  }
+  channelRequiresMembership(channel) {
+    return Boolean(channel.is_private) || Boolean(channel.is_im) || Boolean(channel.is_mpim);
+  }
+  assertChannelMember(channel, userId) {
+    if (!this.channelRequiresMembership(channel))
+      return;
+    const member = this.db.prepare(`SELECT 1 FROM channel_members WHERE channel_id = ? AND user_id = ?`).get(channel.id, userId);
+    if (!member)
+      slackError("not_in_channel", 400);
+  }
+  assertChannelMemberForActor(channel, actor) {
+    this.assertChannelMember(channel, this.resolveActorUser(actor).id);
+  }
+  requireChannel(ref) {
+    const byId = this.db.prepare(`SELECT * FROM channels WHERE id = ?`).get(ref);
+    if (byId)
+      return byId;
+    const workspace = this.firstWorkspace();
+    if (workspace) {
+      const cleaned = ref.startsWith("#") ? ref.slice(1) : ref;
+      const byName = this.db.prepare(`SELECT * FROM channels WHERE team_id = ? AND name = ?`).get(workspace.id, cleaned);
+      if (byName)
+        return byName;
+    }
+    notFound("channel_not_found");
+  }
+  requireChannelRow(id) {
+    const row = this.db.prepare(`SELECT * FROM channels WHERE id = ?`).get(id);
+    if (!row)
+      slackError("channel_not_found", 404);
+    return row;
+  }
+  requireMessageRow(channelId, ts) {
+    const row = this.db.prepare(`SELECT * FROM messages WHERE channel_id = ? AND ts = ?`).get(channelId, ts);
+    if (!row)
+      slackError("message_not_found", 404);
+    return row;
+  }
+  requireScheduledMessage(id) {
+    const row = this.db.prepare(`SELECT * FROM scheduled_messages WHERE id = ?`).get(id);
+    if (!row)
+      slackError("scheduled_message_not_found", 404);
+    return row;
+  }
+  channelMemberIds(channelId) {
+    return this.db.prepare(`SELECT user_id FROM channel_members WHERE channel_id = ? ORDER BY joined_at, user_id`).all(channelId).map((r) => r.user_id);
+  }
+  reactionsFor(channelId, ts) {
+    return this.db.prepare(`SELECT * FROM reactions WHERE channel_id = ? AND message_ts = ? ORDER BY added_at, name, user_id`).all(channelId, ts);
+  }
+  findDirectChannelBySignature(teamId, dmSignature) {
+    const row = this.db.prepare(`SELECT * FROM channels WHERE team_id = ? AND dm_signature = ?`).get(teamId, dmSignature);
+    return row;
+  }
+  userNameOf(id) {
+    const row = this.db.prepare(`SELECT name FROM users WHERE id = ?`).get(id);
+    return row?.name ?? id;
+  }
+};
+
+// ../packages/twin-slack/dist/src/routes.js
+async function readArgs(c) {
+  const method = c.req.method.toUpperCase();
+  if (method === "GET" || method === "HEAD") {
+    return { ...c.req.query() };
+  }
+  const body = await parseFormOrJson(c);
+  return { ...c.req.query(), ...body };
+}
+function actorFrom(c) {
+  const session = c.get("session");
+  return { login: typeof session?.login === "string" ? session.login : void 0 };
+}
+var optNum = (value, fallback) => value === void 0 ? void 0 : asNumber(value, fallback);
+function registerSlackRoutes(app, { domain, recorder }) {
+  const read = (path, call) => {
+    const handler = recorder.handle({ mutation: false }, async (c) => ({
+      status: 200,
+      body: slackOk(call(await readArgs(c), actorFrom(c)))
+    }));
+    app.get(path, handler);
+    app.post(path, handler);
+  };
+  const write = (path, call, mutated = () => true) => {
+    app.post(path, recorder.handle({ mutation: true }, async (c) => {
+      let delta = null;
+      const result = call(await readArgs(c), actorFrom(c), (d) => {
+        delta = d;
+      });
+      return { status: 200, body: slackOk(result), delta, mutation: mutated(result) };
+    }));
+  };
+  read("/auth.test", (_args, actor) => domain.authTest(actor));
+  read("/conversations.list", (args) => domain.conversationsList({
+    types: asOptionalString(args.types),
+    exclude_archived: asBool(args.exclude_archived, false),
+    limit: optNum(args.limit, 100),
+    cursor: asOptionalString(args.cursor),
+    team_id: asOptionalString(args.team_id)
+  }));
+  read("/conversations.info", (args, actor) => {
+    const channel = asOptionalString(args.channel);
+    if (!channel)
+      throw new TwinError("channel_not_found", 400, "channel_not_found");
+    return domain.conversationsInfo({ channel, include_num_members: asBool(args.include_num_members, false) }, actor);
+  });
+  write("/conversations.create", (args, actor, delta) => domain.conversationsCreate({
+    name: asString(args.name),
+    is_private: asBool(args.is_private, false),
+    team_id: asOptionalString(args.team_id)
+  }, actor, delta));
+  write("/conversations.archive", (args, actor, delta) => domain.conversationsArchive({ channel: asString(args.channel) }, actor, delta));
+  write("/conversations.invite", (args, actor, delta) => domain.conversationsInvite({ channel: asString(args.channel), users: asString(args.users) }, actor, delta));
+  write("/conversations.join", (args, actor, delta) => domain.conversationsJoin({ channel: asString(args.channel) }, actor, delta));
+  write("/conversations.leave", (args, actor, delta) => domain.conversationsLeave({ channel: asString(args.channel) }, actor, delta));
+  write("/conversations.kick", (args, actor, delta) => domain.conversationsKick({ channel: asString(args.channel), user: asString(args.user) }, actor, delta));
+  read("/conversations.members", (args, actor) => domain.conversationsMembers({
+    channel: asString(args.channel),
+    limit: optNum(args.limit, 100),
+    cursor: asOptionalString(args.cursor)
+  }, actor));
+  read("/conversations.history", (args, actor) => domain.conversationsHistory({
+    channel: asString(args.channel),
+    cursor: asOptionalString(args.cursor),
+    inclusive: asBool(args.inclusive, false),
+    latest: asOptionalString(args.latest),
+    limit: optNum(args.limit, 100),
+    oldest: asOptionalString(args.oldest)
+  }, actor));
+  read("/conversations.replies", (args, actor) => domain.conversationsReplies({
+    channel: asString(args.channel),
+    ts: asString(args.ts),
+    cursor: asOptionalString(args.cursor),
+    inclusive: asBool(args.inclusive, false),
+    latest: asOptionalString(args.latest),
+    limit: optNum(args.limit, 100),
+    oldest: asOptionalString(args.oldest)
+  }, actor));
+  write("/conversations.open", (args, actor, delta) => domain.conversationsOpen({
+    users: asOptionalString(args.users),
+    channel: asOptionalString(args.channel),
+    return_im: asBool(args.return_im, false)
+  }, actor, delta), (result) => !result.already_open);
+  write("/conversations.setTopic", (args, actor, delta) => domain.conversationsSetTopic({ channel: asString(args.channel), topic: asString(args.topic) }, actor, delta));
+  write("/conversations.setPurpose", (args, actor, delta) => domain.conversationsSetPurpose({ channel: asString(args.channel), purpose: asString(args.purpose) }, actor, delta));
+  write("/chat.postMessage", (args, actor, delta) => domain.chatPostMessage({
+    channel: asString(args.channel),
+    text: asOptionalString(args.text),
+    blocks: asOptionalString(args.blocks),
+    attachments: asOptionalString(args.attachments),
+    thread_ts: asOptionalString(args.thread_ts),
+    reply_broadcast: asBool(args.reply_broadcast, false),
+    icon_emoji: asOptionalString(args.icon_emoji),
+    icon_url: asOptionalString(args.icon_url),
+    username: asOptionalString(args.username),
+    as_user: asBool(args.as_user, false)
+  }, actor, delta));
+  write("/chat.update", (args, actor, delta) => domain.chatUpdate({
+    channel: asString(args.channel),
+    ts: asString(args.ts),
+    text: asOptionalString(args.text),
+    blocks: asOptionalString(args.blocks),
+    attachments: asOptionalString(args.attachments)
+  }, actor, delta));
+  write("/chat.delete", (args, actor, delta) => domain.chatDelete({ channel: asString(args.channel), ts: asString(args.ts) }, actor, delta));
+  write("/chat.scheduleMessage", (args, actor, delta) => domain.chatScheduleMessage({
+    channel: asString(args.channel),
+    text: asString(args.text),
+    post_at: asNumber(args.post_at, 0),
+    thread_ts: asOptionalString(args.thread_ts),
+    blocks: asOptionalString(args.blocks)
+  }, actor, delta));
+  write("/chat.deleteScheduledMessage", (args, actor, delta) => domain.chatDeleteScheduledMessage({ channel: asString(args.channel), scheduled_message_id: asString(args.scheduled_message_id) }, actor, delta));
+  write("/reactions.add", (args, actor, delta) => domain.reactionsAdd({ channel: asString(args.channel), timestamp: asString(args.timestamp), name: asString(args.name) }, actor, delta));
+  write("/reactions.remove", (args, actor, delta) => domain.reactionsRemove({ channel: asString(args.channel), timestamp: asString(args.timestamp), name: asString(args.name) }, actor, delta));
+  read("/reactions.get", (args, actor) => domain.reactionsGet({
+    channel: asString(args.channel),
+    timestamp: asString(args.timestamp),
+    full: asBool(args.full, false)
+  }, actor));
+  read("/users.list", (args) => domain.usersList({
+    cursor: asOptionalString(args.cursor),
+    limit: optNum(args.limit, 100),
+    include_locale: asBool(args.include_locale, false),
+    team_id: asOptionalString(args.team_id)
+  }));
+  read("/users.info", (args) => domain.usersInfo({ user: asString(args.user), include_locale: asBool(args.include_locale, false) }));
+  read("/users.lookupByEmail", (args) => domain.usersLookupByEmail({ email: asString(args.email) }));
+  read("/users.profile.get", (args, actor) => domain.usersProfileGet({ user: asOptionalString(args.user), include_labels: asBool(args.include_labels, false) }, actor));
+  write("/users.profile.set", (args, actor, delta) => domain.usersProfileSet({
+    user: asOptionalString(args.user),
+    profile: asOptionalString(args.profile),
+    name: asOptionalString(args.name),
+    value: asOptionalString(args.value)
+  }, actor, delta));
+  write("/pins.add", (args, actor, delta) => domain.pinsAdd({ channel: asString(args.channel), timestamp: asString(args.timestamp) }, actor, delta));
+  write("/pins.remove", (args, actor, delta) => domain.pinsRemove({ channel: asString(args.channel), timestamp: asString(args.timestamp) }, actor, delta));
+  read("/pins.list", (args, actor) => domain.pinsList({ channel: asString(args.channel) }, actor));
+  read("/search.messages", (args, actor) => domain.searchMessages({
+    query: asString(args.query),
+    count: optNum(args.count, 20),
+    page: optNum(args.page, 1),
+    sort: asOptionalString(args.sort),
+    sort_dir: asOptionalString(args.sort_dir),
+    highlight: asBool(args.highlight, false)
+  }, actor));
+  write("/files.upload", (args, actor, delta) => domain.filesUpload({
+    channels: asOptionalString(args.channels),
+    channel: asOptionalString(args.channel),
+    filename: asOptionalString(args.filename),
+    title: asOptionalString(args.title),
+    filetype: asOptionalString(args.filetype),
+    content: asOptionalString(args.content),
+    initial_comment: asOptionalString(args.initial_comment),
+    thread_ts: asOptionalString(args.thread_ts)
+  }, actor, delta));
+  read("/files.info", (args) => domain.filesInfo({ file: asString(args.file) }));
+  read("/files.list", (args) => domain.filesList({
+    channel: asOptionalString(args.channel),
+    user: asOptionalString(args.user),
+    count: optNum(args.count, 100),
+    page: optNum(args.page, 1),
+    types: asOptionalString(args.types)
+  }));
+  write("/files.delete", (args, actor, delta) => domain.filesDelete({ file: asString(args.file) }, actor, delta));
+  write("/bookmarks.add", (args, actor, delta) => domain.bookmarksAdd({
+    channel_id: asString(args.channel_id),
+    title: asString(args.title),
+    type: asOptionalString(args.type),
+    link: asOptionalString(args.link),
+    emoji: asOptionalString(args.emoji),
+    entity_id: asOptionalString(args.entity_id)
+  }, actor, delta));
+  write("/bookmarks.remove", (args, actor, delta) => domain.bookmarksRemove({ channel_id: asString(args.channel_id), bookmark_id: asString(args.bookmark_id) }, actor, delta));
+  read("/bookmarks.list", (args) => domain.bookmarksList({ channel_id: asString(args.channel_id) }));
+  read("/team.info", (args) => domain.teamInfo({ team: asOptionalString(args.team) }));
+  write("/canvases.create", (args, actor, delta) => domain.canvasesCreate({
+    title: asOptionalString(args.title),
+    document_content: args.document_content,
+    channel_id: asOptionalString(args.channel_id)
+  }, actor, delta));
+  write("/canvases.edit", (args, actor, delta) => domain.canvasesEdit({ canvas_id: asString(args.canvas_id), changes: args.changes }, actor, delta));
+  write("/canvases.delete", (args, actor, delta) => domain.canvasesDelete({ canvas_id: asString(args.canvas_id) }, actor, delta));
+  read("/emoji.list", (args) => domain.emojiList(args));
+}
+var toolDefinitions = [
+  {
+    name: "slack_post_message",
+    description: "Post a new message to a Slack channel",
+    readOnly: false,
+    schema: z.strictObject({
+      channel_id: z.string(),
+      text: z.string()
+    }).strict()
+  },
+  {
+    name: "slack_reply_to_thread",
+    description: "Reply to a specific message thread in Slack",
+    readOnly: false,
+    schema: z.strictObject({
+      channel_id: z.string(),
+      thread_ts: z.string(),
+      text: z.string()
+    }).strict()
+  },
+  {
+    name: "slack_add_reaction",
+    description: "Add a reaction emoji to a message",
+    readOnly: false,
+    schema: z.strictObject({
+      channel_id: z.string(),
+      timestamp: z.string(),
+      reaction: z.string()
+    }).strict()
+  },
+  {
+    name: "slack_get_channel_history",
+    description: "Get recent messages from a channel",
+    readOnly: true,
+    schema: z.strictObject({
+      channel_id: z.string(),
+      limit: z.number().optional()
+    }).strict()
+  },
+  {
+    name: "slack_get_thread_replies",
+    description: "Get all replies in a message thread",
+    readOnly: true,
+    schema: z.strictObject({
+      channel_id: z.string(),
+      thread_ts: z.string()
+    }).strict()
+  },
+  {
+    name: "slack_list_channels",
+    description: "List public or pre-defined channels in the workspace with pagination",
+    readOnly: true,
+    schema: z.strictObject({
+      limit: z.number().optional(),
+      cursor: z.string().optional()
+    }).strict()
+  },
+  {
+    name: "slack_get_users",
+    description: "Get a list of all users in the workspace with their basic profile information",
+    readOnly: true,
+    schema: z.strictObject({
+      cursor: z.string().optional(),
+      limit: z.number().optional()
+    }).strict()
+  },
+  {
+    name: "slack_get_user_profile",
+    description: "Get detailed profile information for a specific user",
+    readOnly: true,
+    schema: z.strictObject({
+      user_id: z.string()
+    }).strict()
+  },
+  {
+    name: "slack_search_messages",
+    description: "Search messages in the workspace by text query",
+    readOnly: true,
+    schema: z.strictObject({
+      query: z.string(),
+      count: z.number().optional(),
+      page: z.number().optional()
+    }).strict()
+  },
+  {
+    name: "slack_get_reactions",
+    description: "Get all reactions on a specific message",
+    readOnly: true,
+    schema: z.strictObject({
+      channel_id: z.string(),
+      timestamp: z.string()
+    }).strict()
+  },
+  {
+    name: "slack_list_channel_members",
+    description: "List the member user IDs of a channel with pagination",
+    readOnly: true,
+    schema: z.strictObject({
+      channel_id: z.string(),
+      limit: z.number().optional(),
+      cursor: z.string().optional()
+    }).strict()
+  }
+];
+var MUTATING_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "slack_post_message",
+  "slack_reply_to_thread",
+  "slack_add_reaction"
+]);
+function isMutatingTool(name) {
+  return MUTATING_TOOL_NAMES.has(name);
+}
+function toJsonSchema(schema) {
+  const json = z.toJSONSchema(schema, { target: "draft-7" });
+  return {
+    type: "object",
+    properties: json.properties ?? {},
+    required: json.required ?? [],
+    additionalProperties: false
+  };
+}
+function listTools() {
+  return toolDefinitions.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    input_schema: toJsonSchema(tool.schema),
+    ...tool.readOnly ? { annotations: { readOnlyHint: true } } : {}
+  }));
+}
+function listToolsForMcp() {
+  return toolDefinitions.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    inputSchema: toJsonSchema(tool.schema),
+    ...tool.readOnly ? { annotations: { readOnlyHint: true } } : {}
+  }));
+}
+function executeTool(domain, name, args, onDelta, actor = {}) {
+  const def = toolDefinitions.find((t) => t.name === name);
+  if (!def)
+    throw new Error(`Unknown tool: ${name}`);
+  const parsed = def.schema.parse(args);
+  const delta = (d) => onDelta?.(d);
+  switch (name) {
+    case "slack_post_message": {
+      const p = parsed;
+      return domain.chatPostMessage({ channel: p.channel_id, text: p.text }, actor, delta);
+    }
+    case "slack_reply_to_thread": {
+      const p = parsed;
+      return domain.chatPostMessage({ channel: p.channel_id, thread_ts: p.thread_ts, text: p.text }, actor, delta);
+    }
+    case "slack_add_reaction": {
+      const p = parsed;
+      return domain.reactionsAdd({ channel: p.channel_id, timestamp: p.timestamp, name: p.reaction }, actor, delta);
+    }
+    case "slack_get_channel_history": {
+      const p = parsed;
+      return domain.conversationsHistory({ channel: p.channel_id, limit: p.limit }, actor);
+    }
+    case "slack_get_thread_replies": {
+      const p = parsed;
+      return domain.conversationsReplies({ channel: p.channel_id, ts: p.thread_ts }, actor);
+    }
+    case "slack_list_channels": {
+      const p = parsed;
+      return domain.conversationsList({ limit: p.limit, cursor: p.cursor });
+    }
+    case "slack_get_users": {
+      const p = parsed;
+      return domain.usersList({ cursor: p.cursor, limit: p.limit });
+    }
+    case "slack_get_user_profile": {
+      const p = parsed;
+      return domain.usersProfileGet({ user: p.user_id }, actor);
+    }
+    case "slack_search_messages": {
+      const p = parsed;
+      return domain.searchMessages({ query: p.query, count: p.count, page: p.page }, actor);
+    }
+    case "slack_get_reactions": {
+      const p = parsed;
+      return domain.reactionsGet({ channel: p.channel_id, timestamp: p.timestamp }, actor);
+    }
+    case "slack_list_channel_members": {
+      const p = parsed;
+      return domain.conversationsMembers({ channel: p.channel_id, limit: p.limit, cursor: p.cursor }, actor);
+    }
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+
+// ../packages/twin-slack/dist/src/unsupported-envelope.js
+var SUPPORTED_SURFACES = [
+  "auth.test",
+  "conversations.list",
+  "conversations.info",
+  "conversations.create",
+  "conversations.archive",
+  "conversations.invite",
+  "conversations.join",
+  "conversations.leave",
+  "conversations.kick",
+  "conversations.members",
+  "conversations.history",
+  "conversations.replies",
+  "conversations.open",
+  "conversations.setTopic",
+  "conversations.setPurpose",
+  "chat.postMessage",
+  "chat.update",
+  "chat.delete",
+  "chat.scheduleMessage",
+  "chat.deleteScheduledMessage",
+  "reactions.add",
+  "reactions.remove",
+  "reactions.get",
+  "users.list",
+  "users.info",
+  "users.lookupByEmail",
+  "users.profile.get",
+  "users.profile.set",
+  "pins.add",
+  "pins.remove",
+  "pins.list",
+  "search.messages",
+  "files.upload",
+  "files.info",
+  "files.list",
+  "files.delete",
+  "bookmarks.add",
+  "bookmarks.remove",
+  "bookmarks.list",
+  "team.info",
+  "canvases.create",
+  "canvases.edit",
+  "canvases.delete",
+  "emoji.list"
+];
+var unsupportedEnvelope = {
+  status: 501,
+  body: {
+    ok: false,
+    error: "unsupported_endpoint",
+    _twin: {
+      fidelity: "unsupported",
+      supported_surfaces: SUPPORTED_SURFACES
+    }
+  }
+};
+
+// ../packages/twin-slack/dist/src/twin.js
+var tolerantSeedSchema = z.preprocess((value) => value && typeof value === "object" && !Array.isArray(value) ? value : {}, z.record(z.string(), z.unknown()));
+function actorFromSession(session) {
+  return { login: typeof session?.login === "string" ? session.login : void 0 };
+}
+function wrapSlackOk(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const obj = value;
+    if ("ok" in obj)
+      return obj;
+    return { ok: true, ...obj };
+  }
+  return { ok: true, result: value };
+}
+function zodIssues(err) {
+  if (err instanceof ZodError)
+    return err.issues;
+  if (err instanceof Error && err.name === "ZodError" && Array.isArray(err.issues)) {
+    return err.issues;
+  }
+  return void 0;
+}
+function slackErrorEnvelope(err) {
+  if (err instanceof UnknownToolError)
+    return { status: 404, body: slackError2("unknown_tool") };
+  if (err instanceof TwinError) {
+    return { status: 200, body: { ok: false, error: err.code, ...err.extra ?? {} } };
+  }
+  const issues = zodIssues(err);
+  if (issues) {
+    return {
+      status: 200,
+      body: {
+        ok: false,
+        error: "invalid_arguments",
+        response_metadata: {
+          messages: issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`)
+        }
+      }
+    };
+  }
+  const mapped = twinErrorFromSqliteConstraint("", err);
+  if (mapped)
+    return { status: 200, body: { ok: false, error: mapped.code, ...mapped.extra ?? {} } };
+  return {
+    status: 500,
+    body: { ok: false, error: "internal_error", warning: err instanceof Error ? err.message : "internal_error" }
+  };
+}
+var toolListing = new Map(listTools().map((tool) => [tool.name, tool]));
+var slackTwinDefinition = defineTwin({
+  id: "slack",
+  version: process.env.POME_TWIN_VERSION ?? "0.1.0",
+  implementation: "slack_clone",
+  packageName: "@pome-sh/twin-slack",
+  fidelity: { default: "semantic" },
+  seed: tolerantSeedSchema,
+  domain: ({ db, seed }) => {
+    const domain = new SlackDomain(db ?? openSlackTwinDatabase(":memory:"));
+    if (seed !== void 0)
+      domain.seed(seed);
+    return domain;
+  },
+  routes: registerSlackRoutes,
+  // Frozen slack body parsing (F-683 review pin): form-or-JSON on every
+  // engine-owned surface — official Slack SDKs default to
+  // application/x-www-form-urlencoded — and malformed JSON collapses to {}.
+  bodyReader: (c) => parseFormOrJson(c),
+  // Frozen legacy /mcp/call surface: {name}/{params} alias keys; a body
+  // naming no tool answers 400 {ok:false, error:"invalid_arguments"}.
+  legacyMcp: {
+    aliases: true,
+    missingTool: () => ({ status: 400, body: slackError2("invalid_arguments") })
+  },
+  // Frozen /_pome/health shape: exactly {ok, twin} — no extras.
+  pomeHealth: () => ({}),
+  state: ({ domain }) => domain.exportState(),
+  admin: {
+    reset: ({ domain }) => {
+      domain.resetToDefault(defaultSeedState);
+      return { ok: true };
+    },
+    seed: ({ domain, seed }) => {
+      domain.applySeed(seed.seed ?? seed);
+      return { ok: true };
+    },
+    // Frozen pre-port admin surface: EVERY thrown error (zod seed rejection
+    // included) answers 500 {ok:false, error:"internal_error", warning} —
+    // the session envelope's 200 {ok:false} projection never applied here.
+    // Probed on the 3cd86eb baseline (form body "seed=whatever" → 500).
+    errorEnvelope: (err) => ({
+      status: 500,
+      body: {
+        ok: false,
+        error: "internal_error",
+        warning: err instanceof Error ? err.message : "internal_error"
+      }
+    }),
+    // Frozen slack admin-gate 403 body.
+    forbidden: () => ({ status: 403, body: slackError2("restricted_action") })
+  },
+  tools: toolDefinitions.map((def) => {
+    const listed = toolListing.get(def.name);
+    return {
+      name: def.name,
+      description: def.description,
+      schema: def.schema,
+      mutation: isMutatingTool(def.name),
+      inputSchema: listed?.input_schema,
+      ..."annotations" in (listed ?? {}) ? { annotations: listed.annotations } : {},
+      handler: (domain, args, ctx) => wrapSlackOk(executeTool(domain, def.name, args, ctx.reportDelta, actorFromSession(ctx.session)))
+    };
+  }),
+  // Frozen healthz shape: {ok, twin, implementation, tools, runtime} — no
+  // version/fidelity extras (slack never carried them).
+  healthz: () => ({}),
+  unsupported: () => unsupportedEnvelope,
+  errorEnvelope: slackErrorEnvelope,
+  auth: {
+    // F-712 pins: Bearer header + ?token= + form-body token; raw bearer
+    // rejected (allowRawBearer default false); sid mismatch → 401
+    // invalid_auth; expired vs invalid classified by the engine and
+    // rendered through the envelope hook.
+    providerToken: { provider: "slack", prefixes: ["xoxb-pome-", "xoxp-pome-"] },
+    providerSession: () => ({ login: "pome-agent" }),
+    tokenResolvers: [queryTokenResolver("token"), formTokenResolver("token")],
+    unauthorized: (kind) => ({
+      status: 401,
+      body: slackError2(kind === "no_token" ? "not_authed" : kind === "expired" ? "token_expired" : "invalid_auth")
+    }),
+    sidMismatch: () => ({ status: 401, body: slackError2("invalid_auth") }),
+    sessionExtras: (claims) => typeof claims.login === "string" && claims.login.length > 0 ? { login: claims.login } : {}
+  }
+});
+function createSlackTwinApp(opts = {}) {
+  return createApp(slackTwinDefinition, {
+    db: opts.db ?? openSlackTwinDatabase(":memory:"),
+    recorder: opts.recorder,
+    runId: opts.runId ?? "spawn",
+    seed: opts.seed
+  });
+}
+
+export { MUTATING_TOOL_NAMES, SlackDomain, createSlackTwinApp, defaultSeedState, executeTool, isMutatingTool, listTools, listToolsForMcp, loadSeedFromEnv, migrate, openSlackTwinDatabase, parseSeed, resetDatabase, seedSchema, slackTwinDefinition, toolDefinitions };