@mnemom/mnemom 0.17.2-next.4 → 0.17.2-next.6

package/dist/lib/slack-router.js

@@ -0,0 +1,185 @@
+/**
+ * lib/slack-router.ts — the per-operator Socket Mode router.
+ *
+ * ONE process per operator machine holds the app's Socket Mode connection
+ * (Slack hands each event to exactly one of an app's open connections, so a
+ * connection per session would silently drop messages). For every channel
+ * message it asks lib/slack-route.ts who is addressed and appends the message to
+ * each addressed session's inbox (lib/slack-state.ts); each session's listener
+ * delivers from there. The router never writes to a session, never runs a tool,
+ * and holds no state beyond an in-memory user-name cache.
+ */
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { slackCall } from "./slack.js";
+import { buildThreadIndex, routeMessage, stripAddressing, } from "./slack-route.js";
+import { appendInbox, liveSessions, readPosts, slackDir } from "./slack-state.js";
+const routerPidFile = () => join(slackDir(), "router.pid");
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === "EPERM";
+    }
+}
+/** The running router's pid, or null. */
+export function routerPid() {
+    try {
+        const pid = Number(readFileSync(routerPidFile(), "utf8").trim());
+        return Number.isInteger(pid) && pid > 0 && pidAlive(pid) ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Start the router detached if none is running. `argv` is how to re-invoke this
+ * CLI (node + script path). Returns the pid (existing or new).
+ */
+export function ensureRouter(argv = [process.execPath, process.argv[1] ?? "mnemom"]) {
+    const existing = routerPid();
+    if (existing)
+        return existing;
+    const child = spawn(argv[0], [...argv.slice(1), "agent", "slack", "router"], {
+        detached: true,
+        stdio: "ignore",
+        env: process.env,
+    });
+    child.unref();
+    return child.pid ?? 0;
+}
+/** Run the router until the process is killed. Reconnects on disconnect. */
+export async function runRouter(opts) {
+    const log = opts.log ?? ((l) => console.error(`[slack-router] ${l}`));
+    const fetchImpl = opts.fetchImpl ?? fetch;
+    const WS = globalThis.WebSocket;
+    if (!WS)
+        throw new Error("the Slack router needs Node 22+ (global WebSocket).");
+    const auth = await slackCall("auth.test", opts.botToken, {}, fetchImpl);
+    if (!auth.ok)
+        throw new Error(`Slack auth.test failed: ${auth.error}`);
+    const botUserId = String(auth.user_id);
+    const other = routerPid();
+    if (other && other !== process.pid)
+        throw new Error(`a router is already running (pid ${other}).`);
+    mkdirSync(slackDir(), { recursive: true, mode: 0o700 });
+    writeFileSync(routerPidFile(), String(process.pid), { mode: 0o600 });
+    const names = new Map();
+    const userName = async (id) => {
+        if (names.has(id))
+            return names.get(id);
+        try {
+            const r = await slackCall("users.info", opts.botToken, { user: id }, fetchImpl);
+            const u = r.user;
+            const n = u?.profile?.display_name || u?.profile?.real_name || u?.name;
+            if (n)
+                names.set(id, n);
+            return n;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    // app_mention and message.channels both fire for a mention — handle each ts once.
+    const seen = new Set();
+    const handle = async (ev) => {
+        const key = `${ev.channel}:${ev.ts}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        if (seen.size > 2000)
+            seen.delete(seen.values().next().value);
+        // Sender gate: Slack text becomes model input, so only allowlisted members
+        // may reach a session. An empty allowlist delivers nothing.
+        if (!ev.user || !opts.allow.includes(ev.user))
+            return;
+        const live = liveSessions();
+        const threads = buildThreadIndex(readPosts());
+        const targets = routeMessage(ev, { botUserId, liveSessions: live, threads });
+        if (!targets.length) {
+            if (ev.text?.includes(`<@${botUserId}>`) && !ev.bot_id) {
+                const hint = live.length
+                    ? `No live session matched. Address one as \`@<app> <session>: …\` — live now: ${live.map((s) => `\`${s}\``).join(", ")}.`
+                    : "No agent session is listening right now.";
+                await slackCall("chat.postMessage", opts.botToken, { channel: ev.channel, thread_ts: ev.thread_ts ?? ev.ts, text: hint }, fetchImpl).catch(() => undefined);
+            }
+            return;
+        }
+        const { channel, ts, user } = ev;
+        if (!channel || !ts || !user)
+            return; // routeMessage already requires all three
+        const inThread = ev.thread_ts && ev.thread_ts !== ev.ts ? threads.get(channel)?.get(ev.thread_ts) : undefined;
+        const user_name = await userName(user);
+        const text = stripAddressing(ev.text ?? "", botUserId, live);
+        for (const session of targets) {
+            const via = [];
+            if (inThread?.has(session))
+                via.push("thread");
+            if ((ev.text ?? "").includes(`<@${botUserId}>`))
+                via.push("mention");
+            if (!via.length)
+                via.push("handle");
+            appendInbox(session, {
+                channel: channel,
+                ts: ts,
+                thread_ts: ev.thread_ts,
+                user: user,
+                user_name,
+                text,
+                via,
+            });
+            log(`routed ${ev.channel}/${ev.ts} → ${session} (${via.join("+")})`);
+        }
+    };
+    for (;;) {
+        try {
+            const open = await slackCall("apps.connections.open", opts.appToken, {}, fetchImpl);
+            if (!open.ok)
+                throw new Error(`apps.connections.open: ${open.error}`);
+            await new Promise((resolve) => {
+                const ws = new WS(String(open.url));
+                ws.onmessage = (m) => {
+                    let env;
+                    try {
+                        env = JSON.parse(String(m.data));
+                    }
+                    catch {
+                        return;
+                    }
+                    if (env.envelope_id)
+                        ws.send(JSON.stringify({ envelope_id: env.envelope_id }));
+                    if (env.type === "disconnect") {
+                        log(`disconnect requested (${env.reason ?? "?"}); reconnecting`);
+                        ws.close();
+                        return;
+                    }
+                    const ev = env.payload?.event;
+                    if (env.type === "events_api" &&
+                        ev &&
+                        (ev.type === "message" || ev.type === "app_mention")) {
+                        handle(ev).catch((e) => log(`handle failed: ${e instanceof Error ? e.message : e}`));
+                    }
+                };
+                ws.onopen = () => log(`connected as <@${botUserId}>`);
+                ws.onclose = () => resolve();
+                ws.onerror = () => ws.close();
+            });
+        }
+        catch (e) {
+            log(`connection error: ${e instanceof Error ? e.message : e}`);
+        }
+        await new Promise((r) => setTimeout(r, 2000));
+    }
+}
+/** For `status`: whether a pid file points at a live router. */
+export function routerStatus() {
+    const pid = routerPid();
+    return {
+        running: pid !== null,
+        pid,
+        pidFile: existsSync(routerPidFile()) ? routerPidFile() : "",
+    };
+}

package/dist/lib/slack-state.d.ts

@@ -0,0 +1,36 @@
+/**
+ * lib/slack-state.ts — the local, per-operator state behind `mnemom agent slack`.
+ *
+ *   ~/.mnemom/slack/posts.jsonl          every post a session made (routes thread replies)
+ *   ~/.mnemom/slack/live/<session>.json  a session currently listening (pid)
+ *   ~/.mnemom/slack/inbox/<session>.jsonl messages the router routed to a session
+ *
+ * The router (one per operator machine) is the only writer of inboxes; each
+ * session's listener is the only reader of its own. No secret is stored here.
+ */
+import { type PostRecord } from "./slack-route.js";
+export declare function slackDir(): string;
+export declare function recordPost(p: PostRecord): void;
+export declare function readPosts(): PostRecord[];
+/** A message as delivered to a session. */
+export interface InboxMessage {
+    channel: string;
+    ts: string;
+    thread_ts?: string;
+    user: string;
+    user_name?: string;
+    text: string;
+    /** How it was addressed: thread | mention | handle. */
+    via: string[];
+}
+export declare function appendInbox(session: string, msg: InboxMessage): void;
+export declare function inboxPath(session: string): string;
+/** Messages appended after byte `offset`, and the new offset. */
+export declare function readInboxFrom(session: string, offset: number): {
+    messages: InboxMessage[];
+    offset: number;
+};
+export declare function registerLive(session: string, pid?: number): void;
+export declare function unregisterLive(session: string): void;
+/** Sessions with a running listener; stale entries (dead pid) are pruned. */
+export declare function liveSessions(): string[];

package/dist/lib/slack-state.js

@@ -0,0 +1,119 @@
+/**
+ * lib/slack-state.ts — the local, per-operator state behind `mnemom agent slack`.
+ *
+ *   ~/.mnemom/slack/posts.jsonl          every post a session made (routes thread replies)
+ *   ~/.mnemom/slack/live/<session>.json  a session currently listening (pid)
+ *   ~/.mnemom/slack/inbox/<session>.jsonl messages the router routed to a session
+ *
+ * The router (one per operator machine) is the only writer of inboxes; each
+ * session's listener is the only reader of its own. No secret is stored here.
+ */
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+import { MNEMOM_DIR } from "./config.js";
+import { normSession } from "./slack-route.js";
+export function slackDir() {
+    return join(MNEMOM_DIR, "slack");
+}
+const postsFile = () => join(slackDir(), "posts.jsonl");
+const liveDir = () => join(slackDir(), "live");
+const inboxDir = () => join(slackDir(), "inbox");
+/** Only the most recent posts matter for thread routing; cap what we read. */
+const MAX_POSTS = 5000;
+function ensure(dir) {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+}
+function readJsonl(path) {
+    if (!existsSync(path))
+        return [];
+    const out = [];
+    for (const line of readFileSync(path, "utf8").split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch {
+            // a torn line from a concurrent append is skipped, never fatal
+        }
+    }
+    return out;
+}
+export function recordPost(p) {
+    ensure(slackDir());
+    appendFileSync(postsFile(), JSON.stringify(p) + "\n", { mode: 0o600 });
+}
+export function readPosts() {
+    return readJsonl(postsFile()).slice(-MAX_POSTS);
+}
+const fileFor = (session) => `${normSession(session)}`;
+export function appendInbox(session, msg) {
+    ensure(inboxDir());
+    appendFileSync(join(inboxDir(), `${fileFor(session)}.jsonl`), JSON.stringify(msg) + "\n", {
+        mode: 0o600,
+    });
+}
+export function inboxPath(session) {
+    return join(inboxDir(), `${fileFor(session)}.jsonl`);
+}
+/** Messages appended after byte `offset`, and the new offset. */
+export function readInboxFrom(session, offset) {
+    const path = inboxPath(session);
+    if (!existsSync(path))
+        return { messages: [], offset: 0 };
+    const buf = readFileSync(path);
+    if (buf.length < offset)
+        offset = 0; // truncated/rotated
+    const chunk = buf.subarray(offset).toString("utf8");
+    const end = chunk.lastIndexOf("\n") + 1; // leave a partial trailing line for next read
+    const messages = [];
+    for (const line of chunk.slice(0, end).split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            messages.push(JSON.parse(line));
+        }
+        catch {
+            /* skip */
+        }
+    }
+    return { messages, offset: offset + Buffer.byteLength(chunk.slice(0, end)) };
+}
+export function registerLive(session, pid = process.pid) {
+    ensure(liveDir());
+    writeFileSync(join(liveDir(), `${fileFor(session)}.json`), JSON.stringify({ session, pid, since: new Date().toISOString() }), { mode: 0o600 });
+}
+export function unregisterLive(session) {
+    rmSync(join(liveDir(), `${fileFor(session)}.json`), { force: true });
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === "EPERM";
+    }
+}
+/** Sessions with a running listener; stale entries (dead pid) are pruned. */
+export function liveSessions() {
+    if (!existsSync(liveDir()))
+        return [];
+    const out = [];
+    for (const f of readdirSync(liveDir())) {
+        if (!f.endsWith(".json"))
+            continue;
+        const path = join(liveDir(), f);
+        try {
+            const rec = JSON.parse(readFileSync(path, "utf8"));
+            if (rec.session && typeof rec.pid === "number" && pidAlive(rec.pid))
+                out.push(rec.session);
+            else
+                rmSync(path, { force: true });
+        }
+        catch {
+            rmSync(path, { force: true });
+        }
+    }
+    return out;
+}

package/dist/lib/slack.d.ts

@@ -0,0 +1,69 @@
+/**
+ * lib/slack.ts — the Slack Web API seam behind `mnemom agent slack`.
+ *
+ * One shared Slack app (bot token, scopes `chat:write` + `chat:write.customize`)
+ * posts on behalf of every governed session; `chat:write.customize` lets each post
+ * carry the session's own display name (MNEMOM_AGENT_SESSION_NAME, set by the
+ * launcher in the child CLI's env) so a channel reads as N named agents, not one bot.
+ *
+ * Where the bot may post is governed in Slack itself: it can only post to channels
+ * it has been /invited to (`not_in_channel` otherwise).
+ *
+ * The token resolves env (MNEMOM_SLACK_BOT_TOKEN) > the launcher's secret store
+ * (~/.mnemom/launcher.json `slack_bot_token`). It is deliberately NEVER exported
+ * into the child CLI's environment, so it does not sit in the model's context.
+ */
+export declare const SLACK_TOKEN_ENV = "MNEMOM_SLACK_BOT_TOKEN";
+export declare const SLACK_TOKEN_STORE_KEY = "slack_bot_token";
+/** The app-level token (`xapp-…`, scope connections:write) the Socket Mode router needs. */
+export declare const SLACK_APP_TOKEN_ENV = "MNEMOM_SLACK_APP_TOKEN";
+export declare const SLACK_APP_TOKEN_STORE_KEY = "slack_app_token";
+export type FetchLike = (url: string, init: RequestInit) => Promise<Response>;
+export interface SlackResponse {
+    ok: boolean;
+    error?: string;
+    [k: string]: unknown;
+}
+/** env > store; "" when neither is set. `kind` selects the bot or the app-level token. */
+export declare function resolveSlackToken(env: NodeJS.ProcessEnv, store: Record<string, unknown>, kind?: "bot" | "app"): {
+    token: string;
+    source: "env" | "store" | null;
+};
+/** The session's display name from the launcher, or undefined outside a launched session. */
+export declare function sessionPosterName(env: NodeJS.ProcessEnv): string | undefined;
+/** A bot token is `xoxb-…`; reject anything else before it reaches the store. */
+export declare function looksLikeBotToken(token: string): boolean;
+/** An app-level token is `xapp-…`. */
+export declare function looksLikeAppToken(token: string): boolean;
+/**
+ * The Slack app manifest an operator pastes at api.slack.com/apps → "From a
+ * manifest". One app per operator: Socket Mode delivers each event to ONE of an
+ * app's open connections, so a single router per app is what makes routing lossless.
+ * The app-level token (connections:write) cannot be minted by a manifest — the
+ * operator generates it under Basic Information → App-Level Tokens.
+ */
+export declare function slackAppManifest(appName: string): Record<string, unknown>;
+/** The request body for `method` (pure; unit-tested). */
+export declare function encodeSlackBody(method: string, body: Record<string, unknown>): {
+    contentType: string;
+    payload: string;
+};
+/** POST one Web API method (bearer auth). Throws only on transport/HTTP failure. */
+export declare function slackCall(method: string, token: string, body: Record<string, unknown>, fetchImpl?: FetchLike): Promise<SlackResponse>;
+export interface PostInput {
+    token: string;
+    channel: string;
+    text: string;
+    username?: string;
+    iconEmoji?: string;
+    threadTs?: string;
+}
+/** The chat.postMessage body for a post — pure, so the wire shape is unit-testable. */
+export declare function buildPostBody(input: PostInput): Record<string, unknown>;
+/** Post a message; throws a human-readable error on a Slack `ok:false`. */
+export declare function postMessage(input: PostInput, fetchImpl?: FetchLike): Promise<{
+    channel: string;
+    ts: string;
+}>;
+/** Map the Slack error codes a poster actually hits to the fix. */
+export declare function explainSlackError(code: string | undefined, channel?: string): string;

package/dist/lib/slack.js

@@ -0,0 +1,178 @@
+/**
+ * lib/slack.ts — the Slack Web API seam behind `mnemom agent slack`.
+ *
+ * One shared Slack app (bot token, scopes `chat:write` + `chat:write.customize`)
+ * posts on behalf of every governed session; `chat:write.customize` lets each post
+ * carry the session's own display name (MNEMOM_AGENT_SESSION_NAME, set by the
+ * launcher in the child CLI's env) so a channel reads as N named agents, not one bot.
+ *
+ * Where the bot may post is governed in Slack itself: it can only post to channels
+ * it has been /invited to (`not_in_channel` otherwise).
+ *
+ * The token resolves env (MNEMOM_SLACK_BOT_TOKEN) > the launcher's secret store
+ * (~/.mnemom/launcher.json `slack_bot_token`). It is deliberately NEVER exported
+ * into the child CLI's environment, so it does not sit in the model's context.
+ */
+import { SESSION_NAME_ENV } from "./agent.js";
+export const SLACK_TOKEN_ENV = "MNEMOM_SLACK_BOT_TOKEN";
+export const SLACK_TOKEN_STORE_KEY = "slack_bot_token";
+/** The app-level token (`xapp-…`, scope connections:write) the Socket Mode router needs. */
+export const SLACK_APP_TOKEN_ENV = "MNEMOM_SLACK_APP_TOKEN";
+export const SLACK_APP_TOKEN_STORE_KEY = "slack_app_token";
+const SLACK_API = "https://slack.com/api";
+/** Slack truncates `username` beyond 80 chars; keep ours inside that. */
+const MAX_USERNAME = 80;
+/** env > store; "" when neither is set. `kind` selects the bot or the app-level token. */
+export function resolveSlackToken(env, store, kind = "bot") {
+    const envKey = kind === "bot" ? SLACK_TOKEN_ENV : SLACK_APP_TOKEN_ENV;
+    const storeKey = kind === "bot" ? SLACK_TOKEN_STORE_KEY : SLACK_APP_TOKEN_STORE_KEY;
+    const fromEnv = (env[envKey] ?? "").trim();
+    if (fromEnv)
+        return { token: fromEnv, source: "env" };
+    const stored = store[storeKey];
+    if (typeof stored === "string" && stored.trim())
+        return { token: stored.trim(), source: "store" };
+    return { token: "", source: null };
+}
+/** The session's display name from the launcher, or undefined outside a launched session. */
+export function sessionPosterName(env) {
+    const name = (env[SESSION_NAME_ENV] ?? "").replace(/[\r\n]+/g, " ").trim();
+    return name ? name.slice(0, MAX_USERNAME) : undefined;
+}
+/** A bot token is `xoxb-…`; reject anything else before it reaches the store. */
+export function looksLikeBotToken(token) {
+    return /^xoxb-[A-Za-z0-9-]+$/.test(token.trim());
+}
+/** An app-level token is `xapp-…`. */
+export function looksLikeAppToken(token) {
+    return /^xapp-[A-Za-z0-9-]+$/.test(token.trim());
+}
+/**
+ * The Slack app manifest an operator pastes at api.slack.com/apps → "From a
+ * manifest". One app per operator: Socket Mode delivers each event to ONE of an
+ * app's open connections, so a single router per app is what makes routing lossless.
+ * The app-level token (connections:write) cannot be minted by a manifest — the
+ * operator generates it under Basic Information → App-Level Tokens.
+ */
+export function slackAppManifest(appName) {
+    const name = appName.trim().slice(0, 35) || "mnemom-agents";
+    return {
+        display_information: {
+            name,
+            description: "Governed Mnemom agent sessions — each posts under its own session name.",
+            background_color: "#1d1c1d",
+        },
+        features: { bot_user: { display_name: name, always_online: true } },
+        oauth_config: {
+            scopes: {
+                bot: [
+                    "chat:write",
+                    "chat:write.customize",
+                    "app_mentions:read",
+                    "channels:history",
+                    "groups:history",
+                    "channels:read",
+                    "channels:join",
+                    "users:read",
+                ],
+            },
+        },
+        settings: {
+            event_subscriptions: { bot_events: ["app_mention", "message.channels", "message.groups"] },
+            interactivity: { is_enabled: false },
+            org_deploy_enabled: false,
+            socket_mode_enabled: true,
+            token_rotation_enabled: false,
+        },
+    };
+}
+/**
+ * Methods that accept a JSON body. Slack's read methods (conversations.info,
+ * users.info, …) REJECT a JSON body with `invalid_arguments`, so every other
+ * method is sent form-encoded (objects/arrays JSON-stringified per field).
+ */
+const JSON_METHODS = new Set(["chat.postMessage", "chat.update", "chat.postEphemeral"]);
+/** The request body for `method` (pure; unit-tested). */
+export function encodeSlackBody(method, body) {
+    if (JSON_METHODS.has(method)) {
+        return { contentType: "application/json; charset=utf-8", payload: JSON.stringify(body) };
+    }
+    const form = new URLSearchParams();
+    for (const [k, v] of Object.entries(body)) {
+        if (v === undefined || v === null)
+            continue;
+        form.set(k, typeof v === "object" ? JSON.stringify(v) : String(v));
+    }
+    return { contentType: "application/x-www-form-urlencoded", payload: form.toString() };
+}
+/** POST one Web API method (bearer auth). Throws only on transport/HTTP failure. */
+export async function slackCall(method, token, body, fetchImpl = fetch) {
+    const { contentType, payload } = encodeSlackBody(method, body);
+    const res = await fetchImpl(`${SLACK_API}/${method}`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${token}`, "Content-Type": contentType },
+        body: payload,
+    });
+    if (!res.ok)
+        throw new Error(`Slack ${method}: HTTP ${res.status}`);
+    return (await res.json());
+}
+/** The chat.postMessage body for a post — pure, so the wire shape is unit-testable. */
+export function buildPostBody(input) {
+    const body = {
+        channel: input.channel.trim(),
+        text: input.text,
+        unfurl_links: false,
+    };
+    if (input.username)
+        body.username = input.username;
+    if (input.iconEmoji)
+        body.icon_emoji = normalizeEmoji(input.iconEmoji);
+    if (input.threadTs)
+        body.thread_ts = input.threadTs;
+    return body;
+}
+function normalizeEmoji(raw) {
+    // Index scan, not /^:+|:+$/ — that pattern backtracks polynomially on long ':' runs.
+    let v = raw.trim();
+    let a = 0;
+    let b = v.length;
+    while (a < b && v[a] === ":")
+        a++;
+    while (b > a && v[b - 1] === ":")
+        b--;
+    v = v.slice(a, b);
+    return `:${v}:`;
+}
+/** Post a message; throws a human-readable error on a Slack `ok:false`. */
+export async function postMessage(input, fetchImpl = fetch) {
+    const res = await slackCall("chat.postMessage", input.token, buildPostBody(input), fetchImpl);
+    if (!res.ok)
+        throw new Error(explainSlackError(res.error, input.channel));
+    return { channel: String(res.channel ?? input.channel), ts: String(res.ts ?? "") };
+}
+/** Map the Slack error codes a poster actually hits to the fix. */
+export function explainSlackError(code, channel) {
+    const where = channel ? ` ${channel}` : "";
+    switch (code) {
+        case "not_in_channel":
+            return `Slack: the bot is not in${where} — invite it there first (/invite @<app> in the channel).`;
+        case "channel_not_found":
+            return `Slack: channel${where} not found (or private and the bot is not a member).`;
+        case "is_archived":
+            return `Slack: channel${where} is archived.`;
+        case "missing_scope":
+            return "Slack: the bot token is missing a scope — the app needs chat:write and chat:write.customize.";
+        case "invalid_auth":
+        case "not_authed":
+        case "token_revoked":
+        case "account_inactive":
+            return `Slack: the bot token was rejected (${code}) — re-run \`mnemom agent slack login\`.`;
+        case "msg_too_long":
+            return "Slack: message too long.";
+        case "ratelimited":
+            return "Slack: rate limited — try again shortly.";
+        default:
+            return `Slack: ${code ?? "unknown error"}`;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnemom/mnemom",
-  "version": "0.17.2-next.4",
+  "version": "0.17.2-next.6",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {