pome-sh 0.6.6

package/dist/src/twin-slack/domain.js

@@ -0,0 +1,1293 @@
+import { resetDatabase } from "./db.js";
+import { slackError, notFound } from "./errors.js";
+import { parseSeed } from "./seed.js";
+import { SLACK_TWIN_HOST, serializeBookmark, serializeChannel, serializeFile, serializeMessage, serializePin, serializeUser, serializeUserProfile, serializeWorkspace, } from "./serializers.js";
+import { cursorDecode, cursorEncode, nowIso, nowUnix, padTsCounter, tsBaseSeconds } from "./util.js";
+const NOOP = () => { };
+const DEFAULT_BOT_USER = "U_PRIMARY";
+const DEFAULT_TEAM_ID = "T_POME";
+export class SlackDomain {
+    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);
+            // Pre-create users from seed.
+            const userIdByHandle = 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);
+            }
+            // Ensure the pome-agent user always exists.
+            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);
+            }
+            // Channels + members + messages.
+            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);
+                }
+                // Seeded messages preserve thread relationships.
+                const seededTsByOriginalTs = 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);
+                    }
+                }
+            }
+        })();
+    }
+    resetToDefault(seedFn, onDelta = NOOP) {
+        const beforeSummary = this.summarizeState();
+        this.seed(seedFn());
+        const afterSummary = this.summarizeState();
+        onDelta({ before: beforeSummary, after: afterSummary });
+        return { ok: true };
+    }
+    applySeed(input, onDelta = NOOP) {
+        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(),
+        };
+    }
+    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`),
+        };
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Auth
+    // ───────────────────────────────────────────────────────────────────────────
+    authTest(actor) {
+        const workspace = this.requireWorkspace();
+        const userRow = this.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,
+        };
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Conversations
+    // ───────────────────────────────────────────────────────────────────────────
+    conversationsList(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, 1000, 100);
+        const stmt = `SELECT * FROM channels${where.length ? ` WHERE ${where.join(" AND ")}` : ""} ORDER BY created_at, id LIMIT ? OFFSET ?`;
+        const rows = this.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 = this.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 }) : "",
+            },
+        };
+    }
+    conversationsInfo(args, actor = {}) {
+        const channel = this.requireChannel(args.channel);
+        this.assertChannelMemberForActor(channel, actor);
+        const numMembers = this.db.prepare(`SELECT COUNT(*) AS c FROM channel_members WHERE channel_id = ?`).get(channel.id).c;
+        return { channel: serializeChannel(channel, { num_members: numMembers }) };
+    }
+    conversationsCreate(args, actor, onDelta = NOOP) {
+        // Slack distinguishes invalid_name_required (missing), invalid_name_maxlength
+        // (>80), invalid_name_specials (any letter outside [a-z0-9_-]), and
+        // invalid_name_punctuation (leading/trailing dash, leading underscore,
+        // pure digits). Match per https://docs.slack.dev/reference/methods/conversations.create
+        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 = this.requireWorkspace();
+        const creator = this.resolveActorUser(actor).id;
+        const channelId = this.allocId(workspace.id, args.is_private ? "G" : "C");
+        const now = nowIso();
+        const out = this.db.transaction(() => {
+            const existing = this.db
+                .prepare(`SELECT id FROM channels WHERE team_id = ? AND name = ?`)
+                .get(workspace.id, args.name);
+            if (existing)
+                slackError("name_taken", 409);
+            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, workspace.id, args.name, args.is_private ? 0 : 1, args.is_private ? 1 : 0, args.is_private ? 1 : 0, creator, now);
+            this.db
+                .prepare(`INSERT OR IGNORE INTO channel_members (channel_id, user_id, joined_at) VALUES (?, ?, ?)`)
+                .run(channelId, creator, now);
+            const row = this.requireChannelRow(channelId);
+            onDelta({ before: null, after: row });
+            return serializeChannel(row, { num_members: 1, is_member: true });
+        })();
+        return { channel: out };
+    }
+    conversationsArchive(args, actor, onDelta = NOOP) {
+        const channel = this.requireChannel(args.channel);
+        if (channel.is_archived)
+            slackError("already_archived", 400);
+        if (channel.name === "general")
+            slackError("cant_archive_general", 400);
+        const acting = this.resolveActorUser(actor);
+        if (!acting.is_admin)
+            this.assertChannelMember(channel, acting.id);
+        const out = this.db.transaction(() => {
+            const before = this.requireChannelRow(channel.id);
+            this.db.prepare(`UPDATE channels SET is_archived = 1 WHERE id = ?`).run(channel.id);
+            const after = this.requireChannelRow(channel.id);
+            onDelta({ before, after });
+            return { ok: true };
+        })();
+        return out;
+    }
+    conversationsInvite(args, actor, onDelta = NOOP) {
+        const channel = this.requireChannel(args.channel);
+        if (channel.is_archived)
+            slackError("is_archived", 400);
+        const acting = this.resolveActorUser(actor);
+        if (!acting.is_admin)
+            this.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 = this.db.transaction(() => {
+            const beforeMembers = this.channelMemberIds(channel.id);
+            for (const userRef of userIds) {
+                const user = this.resolveUser(userRef);
+                if (!user)
+                    slackError("user_not_found", 404);
+                const exists = this.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);
+                this.db
+                    .prepare(`INSERT INTO channel_members (channel_id, user_id, joined_at) VALUES (?, ?, ?)`)
+                    .run(channel.id, user.id, now);
+            }
+            const afterMembers = this.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;
+    }
+    conversationsJoin(args, actor, onDelta = NOOP) {
+        const channel = this.requireChannel(args.channel);
+        if (channel.is_archived)
+            slackError("is_archived", 400);
+        if (channel.is_private)
+            slackError("channel_not_found", 404);
+        const userId = this.resolveActorUser(actor).id;
+        const now = nowIso();
+        const out = this.db.transaction(() => {
+            const existing = this.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" };
+            }
+            this.db
+                .prepare(`INSERT INTO channel_members (channel_id, user_id, joined_at) VALUES (?, ?, ?)`)
+                .run(channel.id, userId, now);
+            const after = this.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;
+    }
+    conversationsLeave(args, actor, onDelta = NOOP) {
+        const channel = this.requireChannel(args.channel);
+        if (channel.name === "general")
+            slackError("cant_leave_general", 400);
+        const userId = this.resolveActorUser(actor).id;
+        const out = this.db.transaction(() => {
+            const existing = this.db
+                .prepare(`SELECT * FROM channel_members WHERE channel_id = ? AND user_id = ?`)
+                .get(channel.id, userId);
+            if (!existing)
+                slackError("not_in_channel", 400);
+            this.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;
+    }
+    conversationsKick(args, actor, onDelta = NOOP) {
+        const channel = this.requireChannel(args.channel);
+        if (channel.name === "general")
+            slackError("cant_kick_from_general", 400);
+        const acting = this.resolveActorUser(actor);
+        const target = this.resolveUser(args.user);
+        if (!target)
+            slackError("user_not_found", 404);
+        if (target.id === acting.id)
+            slackError("cant_kick_self", 400);
+        const out = this.db.transaction(() => {
+            const existing = this.db
+                .prepare(`SELECT * FROM channel_members WHERE channel_id = ? AND user_id = ?`)
+                .get(channel.id, target.id);
+            if (!existing)
+                slackError("not_in_channel", 400);
+            this.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;
+    }
+    conversationsMembers(args, actor = {}) {
+        const channel = this.requireChannel(args.channel);
+        this.assertChannelMemberForActor(channel, actor);
+        const offset = cursorDecode(args.cursor ?? null)?.offset ?? 0;
+        const limit = clampLimit(args.limit, 1000, 100);
+        const rows = this.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 }) : "",
+            },
+        };
+    }
+    conversationsHistory(args, actor = {}) {
+        const channel = this.requireChannel(args.channel);
+        this.assertChannelMemberForActor(channel, actor);
+        const offset = cursorDecode(args.cursor ?? null)?.offset ?? 0;
+        const limit = clampLimit(args.limit, 1000, 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 = this.db.prepare(sql).all(...params);
+        const hasMore = rows.length > limit;
+        const slice = rows.slice(0, limit);
+        const workspaceId = this.requireWorkspace().id;
+        return {
+            messages: slice.map((row) => serializeMessage(row, { reactions: this.reactionsFor(row.channel_id, row.ts), include_team: workspaceId })),
+            has_more: hasMore,
+            pin_count: this.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 }) } }
+                : {}),
+        };
+    }
+    conversationsReplies(args, actor = {}) {
+        if (!args.ts)
+            slackError("invalid_arguments", 400);
+        const channel = this.requireChannel(args.channel);
+        this.assertChannelMemberForActor(channel, actor);
+        const parent = this.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, 1000, 100);
+        const rows = this.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 = this.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: this.reactionsFor(row.channel_id, row.ts),
+                    include_team: workspaceId,
+                    parent_user_id: row.thread_ts ? parentAuthor : undefined,
+                });
+                if (isParent) {
+                    // Real Slack conversations.replies decorates the thread parent
+                    // with thread_ts === ts (even though the stored row has no
+                    // thread_ts), plus subscribed/is_locked. Every thread-walking
+                    // SDK consumer relies on this invariant.
+                    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 }) } }
+                : {}),
+        };
+    }
+    conversationsOpen(args, actor, onDelta = NOOP) {
+        const workspace = this.requireWorkspace();
+        const acting = this.resolveActorUser(actor);
+        if (args.channel) {
+            // Re-open existing DM/MPIM.
+            const existing = this.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 = this.resolveUser(u);
+            if (!found)
+                slackError("user_not_found", 404);
+            return found.id;
+        });
+        const allIds = [...new Set([acting.id, ...targetIds])].sort();
+        const isMpim = allIds.length > 2;
+        const lookupName = isMpim ? `mpdm-${allIds.join("--")}` : "";
+        const dmSignature = allIds.join("|");
+        const out = this.db.transaction(() => {
+            const existingChannel = this.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 = this.allocId(workspace.id, isMpim ? "M" : "D");
+            const now = nowIso();
+            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, 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) {
+                this.db
+                    .prepare(`INSERT OR IGNORE INTO channel_members (channel_id, user_id, joined_at) VALUES (?, ?, ?)`)
+                    .run(channelId, id, now);
+            }
+            const created = this.requireChannelRow(channelId);
+            onDelta({ before: null, after: created });
+            return { channel: serializeChannel(created, { is_member: true, num_members: allIds.length }) };
+        })();
+        return out;
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Chat
+    // ───────────────────────────────────────────────────────────────────────────
+    chatPostMessage(args, actor, onDelta = NOOP) {
+        const channel = this.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 = this.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 = this.resolveActorUser(actor);
+        if (channel.is_private || channel.is_im || channel.is_mpim) {
+            const member = this.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 = this.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;
+        // For bot authors: bot_id = the bot user's id; app_id = synthetic A_POME so
+        // SDK consumers see a non-null app_id consistent with real Slack.
+        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 = this.db.transaction(() => {
+            this.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) {
+                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, channel.id, args.thread_ts, channel.id, args.thread_ts);
+            }
+            const row = this.requireMessageRow(channel.id, ts);
+            onDelta({ before: null, after: row });
+            const workspaceId = this.requireWorkspace().id;
+            return { channel: channel.id, ts, message: serializeMessage(row, { include_team: workspaceId }) };
+        })();
+        return out;
+    }
+    chatUpdate(args, actor, onDelta = NOOP) {
+        const channel = this.requireChannel(args.channel);
+        if (channel.is_archived)
+            slackError("is_archived", 400);
+        const acting = this.resolveActorUser(actor);
+        const before = this.db
+            .prepare(`SELECT * FROM messages WHERE channel_id = ? AND ts = ?`)
+            .get(channel.id, args.ts);
+        if (!before)
+            slackError("message_not_found", 404);
+        // Real Slack has no admin override at the API layer — only the message's
+        // author may update their own message. Single-tenant sandbox semantics:
+        // the JWT's `login` claim identifies the acting user.
+        if (before.user_id !== acting.id)
+            slackError("cant_update_message", 403);
+        const out = this.db.transaction(() => {
+            const updatedTs = this.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;
+            this.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 = this.requireMessageRow(channel.id, args.ts);
+            onDelta({ before, after });
+            return { channel: channel.id, ts: args.ts, text: after.text, message: serializeMessage(after) };
+        })();
+        return out;
+    }
+    chatDelete(args, actor, onDelta = NOOP) {
+        const channel = this.requireChannel(args.channel);
+        const acting = this.resolveActorUser(actor);
+        const before = this.db
+            .prepare(`SELECT * FROM messages WHERE channel_id = ? AND ts = ?`)
+            .get(channel.id, args.ts);
+        if (!before)
+            slackError("message_not_found", 404);
+        // Real Slack has no admin override on chat.delete — only the author may delete.
+        if (before.user_id !== acting.id)
+            slackError("cant_delete_message", 403);
+        const out = this.db.transaction(() => {
+            this.db.prepare(`DELETE FROM messages WHERE channel_id = ? AND ts = ?`).run(channel.id, args.ts);
+            // Decrement thread parent if this was a reply.
+            if (before.thread_ts) {
+                this.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;
+    }
+    chatScheduleMessage(args, actor, onDelta = NOOP) {
+        const channel = this.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 = this.resolveActorUser(actor);
+        const id = this.allocId(this.requireWorkspace().id, "Q");
+        const now = nowUnix();
+        const out = this.db.transaction(() => {
+            this.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 = this.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;
+    }
+    chatDeleteScheduledMessage(args, actor, onDelta = NOOP) {
+        void actor;
+        const channel = this.requireChannel(args.channel);
+        const row = this.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 = this.db.transaction(() => {
+            this.db.prepare(`DELETE FROM scheduled_messages WHERE id = ?`).run(row.id);
+            onDelta({ before: row, after: null });
+            return {};
+        })();
+        return out;
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Reactions
+    // ───────────────────────────────────────────────────────────────────────────
+    reactionsAdd(args, actor, onDelta = NOOP) {
+        if (!args.name)
+            slackError("no_reaction", 400);
+        const channel = this.requireChannel(args.channel);
+        const message = this.db
+            .prepare(`SELECT * FROM messages WHERE channel_id = ? AND ts = ?`)
+            .get(channel.id, args.timestamp);
+        if (!message)
+            slackError("message_not_found", 404);
+        const acting = this.resolveActorUser(actor);
+        const reaction = normalizeReactionName(args.name);
+        const out = this.db.transaction(() => {
+            const existing = this.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();
+            this.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 = this.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;
+    }
+    reactionsRemove(args, actor, onDelta = NOOP) {
+        if (!args.name)
+            slackError("no_reaction", 400);
+        const channel = this.requireChannel(args.channel);
+        const acting = this.resolveActorUser(actor);
+        const reaction = normalizeReactionName(args.name);
+        const before = this.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 = this.db.transaction(() => {
+            this.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;
+    }
+    reactionsGet(args, actor = {}) {
+        const channel = this.requireChannel(args.channel);
+        this.assertChannelMemberForActor(channel, actor);
+        const message = this.db
+            .prepare(`SELECT * FROM messages WHERE channel_id = ? AND ts = ?`)
+            .get(channel.id, args.timestamp);
+        if (!message)
+            slackError("message_not_found", 404);
+        const reactions = this.reactionsFor(channel.id, args.timestamp);
+        return {
+            type: "message",
+            channel: channel.id,
+            message: { ...serializeMessage(message, { reactions }) },
+        };
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Users
+    // ───────────────────────────────────────────────────────────────────────────
+    usersList(args) {
+        const workspace = this.requireWorkspace();
+        const offset = cursorDecode(args.cursor ?? null)?.offset ?? 0;
+        const limit = clampLimit(args.limit, 1000, 100);
+        const rows = this.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 }) : "",
+            },
+        };
+    }
+    usersInfo(args) {
+        const user = this.resolveUser(args.user);
+        if (!user)
+            slackError("user_not_found", 404);
+        return { user: serializeUser(user, { include_locale: args.include_locale }) };
+    }
+    usersLookupByEmail(args) {
+        if (!args.email)
+            slackError("users_not_found", 400);
+        const workspace = this.requireWorkspace();
+        const user = this.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) };
+    }
+    usersProfileGet(args, actor) {
+        const target = args.user ? this.resolveUser(args.user) : this.resolveActorUser(actor);
+        if (!target)
+            slackError("user_not_found", 404);
+        // users.profile.get returns the bare profile WITHOUT `team` — real Slack omits
+        // it on this endpoint (it carries it in the embedded user.profile elsewhere)
+        // (FDRS-473 Kind B).
+        return { profile: serializeUserProfile(target, { omitTeam: true }) };
+    }
+    usersProfileSet(args, actor, onDelta = NOOP) {
+        const target = args.user ? this.resolveUser(args.user) : this.resolveActorUser(actor);
+        if (!target)
+            slackError("user_not_found", 404);
+        const acting = this.resolveActorUser(actor);
+        if (target.id !== acting.id && !acting.is_admin)
+            slackError("cant_set_profile_for_other_user", 403);
+        const out = this.db.transaction(() => {
+            const before = this.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 ?? "" };
+            }
+            this.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 = this.db.prepare(`SELECT * FROM users WHERE id = ?`).get(target.id);
+            onDelta({ before, after });
+            // users.profile.set echoes the bare profile, same shape as users.profile.get
+            // (no `team`) — FDRS-473 Kind B.
+            return { profile: serializeUserProfile(after, { omitTeam: true }) };
+        })();
+        return out;
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Pins
+    // ───────────────────────────────────────────────────────────────────────────
+    pinsAdd(args, actor, onDelta = NOOP) {
+        const channel = this.requireChannel(args.channel);
+        const message = this.db
+            .prepare(`SELECT * FROM messages WHERE channel_id = ? AND ts = ?`)
+            .get(channel.id, args.timestamp);
+        if (!message)
+            slackError("message_not_found", 404);
+        const acting = this.resolveActorUser(actor);
+        const out = this.db.transaction(() => {
+            const existing = this.db
+                .prepare(`SELECT * FROM pins WHERE channel_id = ? AND message_ts = ?`)
+                .get(channel.id, args.timestamp);
+            if (existing)
+                slackError("already_pinned", 400);
+            this.db
+                .prepare(`INSERT INTO pins (channel_id, message_ts, pinned_by, pinned_at) VALUES (?, ?, ?, ?)`)
+                .run(channel.id, args.timestamp, acting.id, nowIso());
+            const after = this.db
+                .prepare(`SELECT * FROM pins WHERE channel_id = ? AND message_ts = ?`)
+                .get(channel.id, args.timestamp);
+            onDelta({ before: null, after });
+            return {};
+        })();
+        return out;
+    }
+    pinsRemove(args, actor, onDelta = NOOP) {
+        void actor;
+        const channel = this.requireChannel(args.channel);
+        const before = this.db
+            .prepare(`SELECT * FROM pins WHERE channel_id = ? AND message_ts = ?`)
+            .get(channel.id, args.timestamp);
+        if (!before)
+            slackError("no_pin", 404);
+        const out = this.db.transaction(() => {
+            this.db.prepare(`DELETE FROM pins WHERE channel_id = ? AND message_ts = ?`).run(channel.id, args.timestamp);
+            onDelta({ before, after: null });
+            return {};
+        })();
+        return out;
+    }
+    pinsList(args, actor = {}) {
+        const channel = this.requireChannel(args.channel);
+        this.assertChannelMemberForActor(channel, actor);
+        const pins = this.db
+            .prepare(`SELECT * FROM pins WHERE channel_id = ? ORDER BY pinned_at`)
+            .all(channel.id);
+        const items = pins.map((pin) => {
+            const message = this.db
+                .prepare(`SELECT * FROM messages WHERE channel_id = ? AND ts = ?`)
+                .get(pin.channel_id, pin.message_ts);
+            const serializedMessage = message ? serializeMessage(message, { reactions: this.reactionsFor(pin.channel_id, pin.message_ts) }) : { ts: pin.message_ts };
+            return serializePin(pin, serializedMessage);
+        });
+        return { items };
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Search
+    // ───────────────────────────────────────────────────────────────────────────
+    searchMessages(args, actor = {}) {
+        if (!args.query || args.query.trim() === "")
+            slackError("no_query", 400);
+        const acting = this.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";
+        // Simple LIKE-based search. Slack's actual full-text engine is more
+        // sophisticated; for twin scenarios this is enough to match seeded
+        // and posted messages on substring.
+        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 = this.db
+            .prepare(`SELECT COUNT(*) AS c FROM messages WHERE text LIKE ? ESCAPE '\\' AND ${visibilityClause}`)
+            .get(like, acting.id).c;
+        const rows = this.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 = this.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: this.userNameOf(row.user_id),
+                ts: row.ts,
+                text: row.text,
+                permalink: `${SLACK_TWIN_HOST}/archives/${row.channel_id}/p${row.ts.replace(".", "")}`,
+                team: this.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,
+            },
+        };
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Files
+    // ───────────────────────────────────────────────────────────────────────────
+    filesUpload(args, actor, onDelta = NOOP) {
+        const workspace = this.requireWorkspace();
+        const acting = this.resolveActorUser(actor);
+        const channelsRaw = args.channels ?? args.channel ?? "";
+        const channelIds = channelsRaw
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean)
+            .map((ref) => this.requireChannel(ref).id);
+        const id = this.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 = this.db.transaction(() => {
+            this.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 = this.db.prepare(`SELECT * FROM files WHERE id = ?`).get(id);
+            // Optionally post initial_comment as a message in the first channel.
+            if (args.initial_comment && channelIds.length > 0) {
+                const ts = this.allocMessageTs(channelIds[0]);
+                this.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;
+    }
+    filesInfo(args) {
+        const file = this.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: "" },
+        };
+    }
+    filesList(args) {
+        const count = clampLimit(args.count, 1000, 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 = this.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 = this.db.prepare(sql).all(...params);
+        if (args.channel) {
+            const channelId = this.requireChannel(args.channel).id;
+            rows = rows.filter((row) => JSON.parse(row.channels_json).includes(channelId));
+        }
+        const total = this.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).
+        };
+    }
+    filesDelete(args, actor, onDelta = NOOP) {
+        void actor;
+        const before = this.db.prepare(`SELECT * FROM files WHERE id = ?`).get(args.file);
+        if (!before)
+            slackError("file_not_found", 404);
+        const out = this.db.transaction(() => {
+            this.db.prepare(`UPDATE files SET deleted = 1 WHERE id = ?`).run(args.file);
+            const after = this.db.prepare(`SELECT * FROM files WHERE id = ?`).get(args.file);
+            onDelta({ before, after });
+            return {};
+        })();
+        return out;
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Bookmarks
+    // ───────────────────────────────────────────────────────────────────────────
+    bookmarksAdd(args, actor, onDelta = NOOP) {
+        const channel = this.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 = this.resolveActorUser(actor);
+        const id = this.allocId(this.requireWorkspace().id, "Bk");
+        const out = this.db.transaction(() => {
+            this.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 = this.db.prepare(`SELECT * FROM bookmarks WHERE id = ?`).get(id);
+            onDelta({ before: null, after });
+            return { bookmark: serializeBookmark(after) };
+        })();
+        return out;
+    }
+    bookmarksRemove(args, actor, onDelta = NOOP) {
+        void actor;
+        const channel = this.requireChannel(args.channel_id);
+        const before = this.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 = this.db.transaction(() => {
+            this.db.prepare(`DELETE FROM bookmarks WHERE id = ?`).run(before.id);
+            onDelta({ before, after: null });
+            return {};
+        })();
+        return out;
+    }
+    bookmarksList(args) {
+        const channel = this.requireChannel(args.channel_id);
+        const rows = this.db
+            .prepare(`SELECT * FROM bookmarks WHERE channel_id = ? ORDER BY created_at`)
+            .all(channel.id);
+        return { bookmarks: rows.map((row) => serializeBookmark(row)) };
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Team
+    // ───────────────────────────────────────────────────────────────────────────
+    teamInfo(args) {
+        void args;
+        return { team: serializeWorkspace(this.requireWorkspace()) };
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // 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 created_at, id`).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) {
+        // Real Slack ts is workspace-globally-unique. Increment the workspace
+        // counter (not the channel counter) so two channels' first messages
+        // get distinct ts values. The channels.ts_counter column is kept for
+        // back-compat but no longer drives allocation.
+        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 undefined;
+        return map.get(ref) ?? ref;
+    }
+    resolveUser(ref) {
+        if (!ref)
+            return undefined;
+        const byId = this.db.prepare(`SELECT * FROM users WHERE id = ?`).get(ref);
+        if (byId)
+            return byId;
+        const workspace = this.firstWorkspace();
+        if (!workspace)
+            return undefined;
+        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 undefined;
+    }
+    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;
+    }
+}
+function clampLimit(value, max, fallback) {
+    if (!Number.isFinite(value) || value === undefined)
+        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";
+}