@eliya-oss/agent-slack 0.1.10 → 0.1.11

package/.agents/cli-api.md

@@ -12,6 +12,7 @@ Non-goal for v0: agent-side summarization. The CLI returns clean context; agents
 
 - Noun-verb commands: `agent-slack conversation history`, `agent-slack thread get`, `agent-slack api call`.
 - JSON is always available with `--json`; non-TTY stdout defaults to JSON.
+- Output is token-efficient by default: read commands return slim normalized shapes, and JSON is serialized compactly (no indentation). `--pretty` restores indentation; `--full` returns raw Slack objects.
 - Data goes to stdout. Progress, warnings, and errors go to stderr.
 - Every command supports `--help --json`; every group supports `describe --json`.
 - Large reads support `--cursor`, `--limit`, `--all`, and `--format ndjson`.
@@ -22,9 +23,10 @@ Non-goal for v0: agent-side summarization. The CLI returns clean context; agents
 
 ```bash
 agent-slack [--profile NAME] [--team TEAM_ID] [--token user|bot|admin|app]
-    [--json] [--format json|ndjson|table] [--fields FIELD[,FIELD...]]
+    [--json] [--format json|ndjson|table] [--pretty] [--full]
+    [--fields FIELD[,FIELD...]]
     [--limit N] [--cursor CURSOR] [--all]
-    [--include users,reactions,files,permalinks,threads]
+    [--include users,threads,permalinks]
     [--no-cache] [--trace]
 ```
 
@@ -109,7 +111,7 @@ agent-slack conversation list --types public_channel,private_channel,mpim,im [--
 agent-slack conversation get CHANNEL_ID
 agent-slack conversation members CHANNEL_ID [--all]
 agent-slack conversation history CHANNEL_ID [--oldest TS] [--latest TS] [--all]
-agent-slack conversation context CHANNEL_ID [--since 24h] [--include users,reactions,files,threads]
+agent-slack conversation context CHANNEL_ID [--since 24h] [--include users,threads,permalinks]
 ```
 
 `conversation context` returns normalized messages, hydrated users, thread refs, file refs, reactions, and permalinks in one deterministic payload for agents.
@@ -117,7 +119,7 @@ agent-slack conversation context CHANNEL_ID [--since 24h] [--include users,react
 ### Threads and messages
 
 ```bash
-agent-slack thread get --channel CHANNEL_ID --ts MESSAGE_TS [--include users,reactions,files,permalinks]
+agent-slack thread get --channel CHANNEL_ID --ts MESSAGE_TS [--include users,permalinks]
 agent-slack message get --channel CHANNEL_ID --ts MESSAGE_TS
 agent-slack message permalink --channel CHANNEL_ID --ts MESSAGE_TS
 ```
@@ -182,6 +184,38 @@ Rules:
 
 ## Output Contract
 
+### Serialization
+
+JSON is serialized compactly by default (no indentation) to minimize an agent's
+token cost. `--pretty` restores 2-space indentation for humans. Human TTY
+rendering is unchanged.
+
+### Normalization
+
+Read commands return slim normalized shapes by default, carrying the fields an
+agent needs to reason and dropping Slack boilerplate. `--full` bypasses
+normalization and returns the raw Slack objects.
+
+- **message**: `user` (or `bot_id`/`username`), `ts`, `text`, and, when present,
+  `thread_ts`, `reply_count`, `reactions` (`[{name, count}]`), `files`
+  (`[{id, name, mimetype, size}]`), `subtype`, `edited`. Drops `blocks`,
+  `client_msg_id`, `team`, and reaction user lists.
+- **user**: `id`, `name`, `real_name` (display name), and, when present,
+  `is_bot`, `deleted`, `title`. Drops all `image_*` URLs, `color`, `status_*`,
+  `tz`, and team fields.
+- **file**: `id`, `name`, `mimetype`, `size`, and `permalink` when present.
+  Drops thumbnails and private URLs.
+- **conversation**: `id`, `name`, `is_private`, `is_archived`, `topic`,
+  `purpose`, `num_members` when present.
+- `conversation context` dedupes thread roots already present in `messages` and
+  hydrates every unique author, including those who appear only in replies.
+
+### Scope warnings
+
+When a scope the active token lacks would make a result more complete or
+efficient (for example `users:read` for author hydration), the CLI adds a
+message to `warnings` instead of failing silently.
+
 Default JSON envelope:
 
 ```json
@@ -212,7 +246,7 @@ Structured error on stderr:
 {
   "ok": false,
   "error": {
-    "type": "rate_limited",
+    "type": "SlackRateLimited",
     "title": "Slack rate limit reached",
     "slack_error": "ratelimited",
     "retriable": true,
@@ -230,7 +264,7 @@ Exit codes:
 - `2`: usage or validation error
 - `3`: not found
 - `4`: auth or permission denied
-- `5`: conflict or invalid Slack state
+- `5`: unsafe method blocked
 - `6`: rate limited
 
 Rate-limit behavior:
@@ -264,13 +298,13 @@ Schema output includes:
 Read a thread:
 
 ```bash
-agent-slack thread get --channel C123 --ts 1710000000.000100 --include users,reactions,files,permalinks --json
+agent-slack thread get --channel C123 --ts 1710000000.000100 --include users,permalinks --json
 ```
 
 Prepare channel-summary input:
 
 ```bash
-agent-slack conversation context C123 --since 24h --include users,reactions,files,threads --format ndjson
+agent-slack conversation context C123 --since 24h --include users,threads,permalinks --json
 ```
 
 Search before reading:

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @eliya-oss/agent-slack
 
+## 0.1.11
+
+### Patch Changes
+
+- e01fe7d: Read commands now return slim, token-efficient output by default. Messages, users, files, and conversations are normalized to the fields that matter, and JSON is serialized compactly. On a real 30-day channel read this cut the payload by about 85% (6.4x smaller) with no loss of meaning.
+
+  - `--full` returns the raw Slack objects when you need them.
+  - `--pretty` restores indentation for humans.
+  - `conversation context` now hydrates authors that appear only in thread replies, and warns via `warnings` when `users:read` is missing instead of returning bare IDs.
+  - `thread get --include users,permalinks` now hydrates author names and per-message links (previously the flag was accepted but ignored).
+
+  Note: this changes the default output shape of read commands. Pass `--full` to get the previous raw Slack objects.
+
 ## 0.1.10
 
 ### Patch Changes

package/README.md

@@ -2,8 +2,8 @@
 
 # agent-slack
 
-Slack context for AI agents via the `agent-slack` CLI.
-Short alias: `aslk`.
+Read your Slack workspace from the command line: threads, channels, users, files, and search.
+Built so your AI agents can read Slack too. Short alias: `aslk`.
 
 <pre align="center">npm install -g @eliya-oss/agent-slack</pre>
 

package/dist/application/commands.js

@@ -2,8 +2,9 @@ import { flagBoolean, flagString, requireFlag, splitCsv } from "../cli/args.js";
 import { PRIMARY_COMMAND_NAME, describeAllCommands, describeCommandGroup, findCommandMetadata, renderCompletion, renderHumanHelp } from "../cli/metadata.js";
 import { ResourceNotFound, UnsupportedMethod, UsageError } from "../domain/errors.js";
 import { ProfileName, Scope } from "../domain/ids.js";
-import { pagingFrom, successEnvelope, toNdjson } from "../output/envelope.js";
+import { pagingFrom, serializeJson, successEnvelope, toNdjson } from "../output/envelope.js";
 import { renderHumanEnvelope } from "../output/human.js";
+import { normalizeResponse, slimFile, slimMessage, slimUser } from "../output/normalize.js";
 import { projectFields } from "../output/projection.js";
 import { getProfile, parseTokenType, requireYes, tokenFor } from "./auth.js";
 import { parseJsonPayload, requirePositional } from "./payload.js";
@@ -81,14 +82,7 @@ export const dispatch = async (parsed, services) => {
         return conversationCommand(parsed, services);
     }
     if (first === "thread" && second === "get") {
-        return methodCall(parsed, services, {
-            method: "conversations.replies",
-            payload: {
-                channel: requireFlag(parsed, "channel"),
-                ts: requireFlag(parsed, "ts"),
-                limit: numberFlag(parsed, "limit")
-            }
-        });
+        return threadGet(parsed, services);
     }
     if (first === "message") {
         if (second === "get") {
@@ -249,7 +243,7 @@ const apiCall = async (parsed, services) => {
         inline: flagString(parsed, "payload"),
         positional: parsed.positionals[3]
     });
-    return methodCall(parsed, services, { method, payload });
+    return methodCall(parsed, services, { method, payload }, { normalize: false });
 };
 const teamCommand = async (parsed, services) => {
     const second = parsed.positionals[1];
@@ -332,6 +326,7 @@ const conversationCommand = async (parsed, services) => {
     }
     throw new UsageError("Unknown conversation command", { command: parsed.positionals.join(" ") });
 };
+const hasScope = (profile, scope) => profile.scopes.includes(scope);
 const conversationContext = async (parsed, services) => {
     const channel = requirePositional(parsed.positionals, 2, "CHANNEL_ID");
     const profileName = flagString(parsed, "profile", "default") ?? "default";
@@ -354,26 +349,68 @@ const conversationContext = async (parsed, services) => {
         allowWrite: false,
         yes: false
     });
+    const full = flagBoolean(parsed, "full");
+    const shape = (message) => (full ? message : slimMessage(message));
     const messages = extractArray(history.response.messages);
+    const warnings = [];
     const context = {
         channel,
-        messages
+        messages: messages.map(shape)
     };
+    // Fetch threads first so authors who appear only in replies still get hydrated.
+    const threadReplies = {};
+    if (include.has("threads")) {
+        const threads = {};
+        for (const message of messages) {
+            const record = extractLooseRecord(message);
+            const ts = stringField(record, "thread_ts") ?? stringField(record, "ts");
+            const hasReplies = typeof record.reply_count === "number" && record.reply_count > 0;
+            if (ts !== undefined && hasReplies) {
+                const thread = await callSlack(services, {
+                    method: "conversations.replies",
+                    payload: { channel, ts },
+                    token,
+                    profile,
+                    all: false,
+                    allowWrite: false,
+                    yes: false
+                });
+                // Drop the root; it is already present in `messages`.
+                const replies = extractArray(thread.response.messages).filter((reply) => stringField(extractLooseRecord(reply), "ts") !== ts);
+                threadReplies[ts] = replies;
+                threads[ts] = replies.map(shape);
+            }
+        }
+        context.threads = threads;
+    }
     if (include.has("users")) {
-        const users = {};
-        for (const userId of uniqueStrings(messages.map((message) => stringField(extractLooseRecord(message), "user")))) {
-            const user = await callSlack(services, {
-                method: "users.info",
-                payload: { user: userId },
-                token,
-                profile,
-                all: false,
-                allowWrite: false,
-                yes: false
-            });
-            users[userId] = user.response.user ?? user.response;
+        if (hasScope(profile, "users:read")) {
+            const replyAuthors = Object.values(threadReplies)
+                .flat()
+                .map((reply) => stringField(extractLooseRecord(reply), "user"));
+            const authorIds = uniqueStrings([
+                ...messages.map((message) => stringField(extractLooseRecord(message), "user")),
+                ...replyAuthors
+            ]);
+            const users = {};
+            for (const userId of authorIds) {
+                const user = await callSlack(services, {
+                    method: "users.info",
+                    payload: { user: userId },
+                    token,
+                    profile,
+                    all: false,
+                    allowWrite: false,
+                    yes: false
+                });
+                const raw = user.response.user ?? user.response;
+                users[userId] = full ? raw : slimUser(raw);
+            }
+            context.users = users;
+        }
+        else {
+            warnings.push("users:read scope is missing, so message authors are returned as IDs only. Reconnect with users:read to hydrate names.");
         }
-        context.users = users;
     }
     if (include.has("permalinks")) {
         const permalinks = {};
@@ -394,33 +431,95 @@ const conversationContext = async (parsed, services) => {
         }
         context.permalinks = permalinks;
     }
-    if (include.has("threads")) {
-        const threads = {};
-        for (const message of messages) {
-            const record = extractLooseRecord(message);
-            const ts = stringField(record, "thread_ts") ?? stringField(record, "ts");
-            const hasReplies = typeof record.reply_count === "number" && record.reply_count > 0;
-            if (ts !== undefined && hasReplies) {
-                const thread = await callSlack(services, {
-                    method: "conversations.replies",
-                    payload: { channel, ts },
+    return {
+        method: "conversation.context",
+        profile,
+        response: history.response,
+        stdoutValue: context,
+        items: messages.map(shape),
+        ...(warnings.length > 0 ? { warnings } : {})
+    };
+};
+const threadGet = async (parsed, services) => {
+    const profileName = flagString(parsed, "profile", "default") ?? "default";
+    const tokenType = parseTokenType(flagString(parsed, "token"));
+    const profile = await getProfile(services, profileName);
+    const token = tokenFor(profile, tokenType);
+    const channel = requireFlag(parsed, "channel");
+    const ts = requireFlag(parsed, "ts");
+    const full = flagBoolean(parsed, "full");
+    const include = new Set(splitCsv(flagString(parsed, "include")));
+    const result = await callSlack(services, {
+        method: "conversations.replies",
+        payload: cleanObject({ channel, ts, limit: numberFlag(parsed, "limit") }),
+        token,
+        profile,
+        all: flagBoolean(parsed, "all"),
+        allowWrite: false,
+        yes: false
+    });
+    if (flagBoolean(parsed, "raw")) {
+        return {
+            method: "conversations.replies",
+            profile,
+            stdoutValue: result.response,
+            rawStdout: serializeJson(result.response, flagBoolean(parsed, "pretty")),
+            response: result.response,
+            items: result.items
+        };
+    }
+    const shape = (message) => (full ? message : slimMessage(message));
+    const rawMessages = extractArray(result.response.messages);
+    const warnings = [];
+    const data = { messages: rawMessages.map(shape) };
+    if (include.has("users")) {
+        if (hasScope(profile, "users:read")) {
+            const users = {};
+            for (const userId of uniqueStrings(rawMessages.map((message) => stringField(extractLooseRecord(message), "user")))) {
+                const user = await callSlack(services, {
+                    method: "users.info",
+                    payload: { user: userId },
                     token,
                     profile,
                     all: false,
                     allowWrite: false,
                     yes: false
                 });
-                threads[ts] = thread.response.messages ?? thread.response;
+                const raw = user.response.user ?? user.response;
+                users[userId] = full ? raw : slimUser(raw);
             }
+            data.users = users;
+        }
+        else {
+            warnings.push("users:read scope is missing, so message authors are returned as IDs only. Reconnect with users:read to hydrate names.");
         }
-        context.threads = threads;
+    }
+    if (include.has("permalinks")) {
+        const permalinks = {};
+        for (const messageTs of uniqueStrings(rawMessages.map((message) => stringField(extractLooseRecord(message), "ts")))) {
+            const permalink = await callSlack(services, {
+                method: "chat.getPermalink",
+                payload: { channel, message_ts: messageTs },
+                token,
+                profile,
+                all: false,
+                allowWrite: false,
+                yes: false
+            });
+            const value = stringField(permalink.response, "permalink");
+            if (value !== undefined) {
+                permalinks[messageTs] = value;
+            }
+        }
+        data.permalinks = permalinks;
     }
     return {
-        method: "conversation.context",
+        method: "conversations.replies",
         profile,
-        response: history.response,
-        stdoutValue: context,
-        items: messages
+        response: result.response,
+        stdoutValue: data,
+        items: rawMessages.map(shape),
+        ...(warnings.length > 0 ? { warnings } : {})
     };
 };
 const searchCommand = async (parsed, services) => {
@@ -486,10 +585,10 @@ const fileDownload = async (parsed, services) => {
         method: "file.download",
         profile,
         response: result.response,
-        stdoutValue: { file, download }
+        stdoutValue: { file: flagBoolean(parsed, "full") ? file : slimFile(file), download }
     };
 };
-const methodCall = async (parsed, services, input) => {
+const methodCall = async (parsed, services, input, options = {}) => {
     const profileName = flagString(parsed, "profile", "default") ?? "default";
     const tokenType = parseTokenType(flagString(parsed, "token"));
     const profile = await getProfile(services, profileName);
@@ -509,15 +608,16 @@ const methodCall = async (parsed, services, input) => {
             method: input.method,
             profile,
             stdoutValue: result.response,
-            rawStdout: `${JSON.stringify(result.response, null, 2)}\n`,
+            rawStdout: serializeJson(result.response, flagBoolean(parsed, "pretty")),
             response: result.response,
             items: result.items
         };
     }
+    const normalize = options.normalize !== false && !flagBoolean(parsed, "full");
     return {
         method: input.method,
         profile,
-        stdoutValue: result.response,
+        stdoutValue: normalize ? normalizeResponse(input.method, result.response) : result.response,
         response: result.response,
         items: result.items
     };
@@ -538,7 +638,7 @@ export const renderDispatchResult = (parsed, result, options = {}) => {
         ...(result.warnings === undefined ? {} : { warnings: result.warnings })
     });
     if (shouldRenderJson(parsed, options)) {
-        return `${JSON.stringify(envelope, null, 2)}\n`;
+        return serializeJson(envelope, flagBoolean(parsed, "pretty"));
     }
     return renderHumanEnvelope(envelope, {
         color: options.stdoutIsTty === true && options.env?.NO_COLOR === undefined && !flagBoolean(parsed, "no-color")

package/dist/application/execute.js

@@ -1,5 +1,5 @@
 import { flagBoolean, flagString, parseArgs } from "../cli/args.js";
-import { errorEnvelope } from "../output/envelope.js";
+import { errorEnvelope, serializeJson } from "../output/envelope.js";
 import { renderHumanErrorEnvelope } from "../output/human.js";
 import { dispatch, renderDispatchResult } from "./commands.js";
 export const executeCli = async (argv, services, options = {}) => {
@@ -15,8 +15,9 @@ export const executeCli = async (argv, services, options = {}) => {
     }
     catch (error) {
         const { envelope, exitCode } = errorEnvelope(error);
+        const pretty = parsed === null ? argv.includes("--pretty") : flagBoolean(parsed, "pretty");
         const stderr = shouldRenderJsonError(argv, parsed, options)
-            ? `${JSON.stringify(envelope, null, 2)}\n`
+            ? serializeJson(envelope, pretty)
             : renderHumanErrorEnvelope(envelope, {
                 color: shouldColorError(argv, parsed, options)
             });

package/dist/cli/args.js

@@ -6,6 +6,8 @@ const booleanFlags = new Set([
     "json",
     "no-color",
     "raw",
+    "pretty",
+    "full",
     "trace",
     "yes",
     "no-cache",

package/dist/output/envelope.js

@@ -58,5 +58,8 @@ const suggestionFor = (tag) => {
     }
 };
 export const stringifyJson = (value) => `${JSON.stringify(value, null, 2)}\n`;
+// Machine output is compact by default to minimize token cost; `--pretty`
+// restores indentation for humans. See ADR-002.
+export const serializeJson = (value, pretty) => pretty ? `${JSON.stringify(value, null, 2)}\n` : `${JSON.stringify(value)}\n`;
 export const toNdjson = (items) => items.map((item) => JSON.stringify(item)).join("\n") + (items.length > 0 ? "\n" : "");
 export const exitCodeOf = (error) => isSlkError(error) ? error.exitCode : 1;

package/dist/output/normalize.js

@@ -0,0 +1,154 @@
+// Slim, token-efficient shapes for Slack read output.
+//
+// Raw Slack objects carry far more than an agent needs to reason: users.info
+// returns ~7 avatar URLs plus color/status/tz/team; messages carry `blocks`
+// (a structured duplicate of `text`), `client_msg_id`, `team`, and verbose
+// reactions. These transforms keep the reasoning-relevant fields and drop the
+// rest. `--full` bypasses them and returns the raw objects. See ADR-002.
+const isRec = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const asArray = (value) => (Array.isArray(value) ? value : []);
+const str = (record, key) => typeof record[key] === "string" && record[key].length > 0 ? record[key] : undefined;
+export const slimFile = (input) => {
+    if (!isRec(input))
+        return input;
+    const out = { id: input.id, name: input.name };
+    if (typeof input.mimetype === "string")
+        out.mimetype = input.mimetype;
+    if (typeof input.size === "number")
+        out.size = input.size;
+    const permalink = str(input, "permalink");
+    if (permalink)
+        out.permalink = permalink;
+    return out;
+};
+export const slimMessage = (input) => {
+    if (!isRec(input))
+        return input;
+    const m = input;
+    const out = {};
+    if (typeof m.user === "string")
+        out.user = m.user;
+    else if (typeof m.bot_id === "string")
+        out.bot_id = m.bot_id;
+    const username = str(m, "username");
+    if (username)
+        out.username = username;
+    const subtype = str(m, "subtype");
+    if (subtype)
+        out.subtype = subtype;
+    if (typeof m.ts === "string")
+        out.ts = m.ts;
+    out.text = typeof m.text === "string" ? m.text : "";
+    if (typeof m.thread_ts === "string" && m.thread_ts !== m.ts)
+        out.thread_ts = m.thread_ts;
+    if (typeof m.reply_count === "number")
+        out.reply_count = m.reply_count;
+    const reactions = asArray(m.reactions)
+        .filter(isRec)
+        .map((r) => ({ name: r.name, count: r.count }));
+    if (reactions.length > 0)
+        out.reactions = reactions;
+    const files = asArray(m.files).map(slimFile);
+    if (files.length > 0)
+        out.files = files;
+    if (m.edited !== undefined && m.edited !== null)
+        out.edited = true;
+    return out;
+};
+export const slimUser = (input) => {
+    if (!isRec(input))
+        return input;
+    const u = input;
+    const profile = isRec(u.profile) ? u.profile : {};
+    const out = { id: u.id, name: u.name };
+    const real = str(profile, "display_name") ?? str(u, "real_name") ?? str(profile, "real_name");
+    if (real)
+        out.real_name = real;
+    if (u.is_bot === true)
+        out.is_bot = true;
+    if (u.deleted === true)
+        out.deleted = true;
+    const title = str(profile, "title");
+    if (title)
+        out.title = title;
+    return out;
+};
+export const slimConversation = (input) => {
+    if (!isRec(input))
+        return input;
+    const c = input;
+    const out = { id: c.id, name: c.name };
+    if (c.is_private === true)
+        out.is_private = true;
+    if (c.is_archived === true)
+        out.is_archived = true;
+    if (c.is_im === true)
+        out.is_im = true;
+    if (c.is_mpim === true)
+        out.is_mpim = true;
+    const topic = isRec(c.topic) ? str(c.topic, "value") : undefined;
+    if (topic)
+        out.topic = topic;
+    const purpose = isRec(c.purpose) ? str(c.purpose, "value") : undefined;
+    if (purpose)
+        out.purpose = purpose;
+    if (typeof c.num_members === "number")
+        out.num_members = c.num_members;
+    return out;
+};
+export const slimTeam = (input) => {
+    if (!isRec(input))
+        return input;
+    const t = input;
+    const out = { id: t.id, name: t.name };
+    const domain = str(t, "domain");
+    if (domain)
+        out.domain = domain;
+    const emailDomain = str(t, "email_domain");
+    if (emailDomain)
+        out.email_domain = emailDomain;
+    const enterpriseId = str(t, "enterprise_id");
+    if (enterpriseId)
+        out.enterprise_id = enterpriseId;
+    const enterpriseName = str(t, "enterprise_name");
+    if (enterpriseName)
+        out.enterprise_name = enterpriseName;
+    return out;
+};
+// Drop the always-present envelope noise from an unmapped response.
+const stripResponseEnvelope = (response) => {
+    const { ok, response_metadata, ...rest } = response;
+    void ok;
+    void response_metadata;
+    return rest;
+};
+// Normalize a raw Slack Web API response for a given method into slim `data`.
+export const normalizeResponse = (method, response) => {
+    if (!isRec(response))
+        return response;
+    const r = response;
+    switch (method) {
+        case "conversations.history":
+        case "conversations.replies":
+            return { messages: asArray(r.messages).map(slimMessage) };
+        case "conversations.info":
+            return { channel: slimConversation(r.channel) };
+        case "conversations.list":
+            return { channels: asArray(r.channels).map(slimConversation) };
+        case "users.info":
+        case "users.lookupByEmail":
+            return { user: slimUser(r.user) };
+        case "users.list":
+            return { users: asArray(r.members).map(slimUser) };
+        case "files.info":
+            return { file: slimFile(r.file) };
+        case "files.list":
+            return { files: asArray(r.files).map(slimFile) };
+        case "team.info":
+            return { team: slimTeam(r.team) };
+        case "reactions.get":
+            return isRec(r.message) ? { ...stripResponseEnvelope(r), message: slimMessage(r.message) } : stripResponseEnvelope(r);
+        default:
+            return stripResponseEnvelope(r);
+    }
+};

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@eliya-oss/agent-slack",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Slack context CLI for AI agents.",
   "type": "module",
-  "packageManager": "pnpm@11.9.0",
   "bin": {
     "agent-slack": "dist/main.js",
     "aslk": "dist/main.js"
@@ -17,22 +16,6 @@
     "LICENSE",
     ".agents/cli-api.md"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "check": "pnpm typecheck && pnpm test:coverage && pnpm build",
-    "changeset": "changeset",
-    "clean": "rm -rf dist coverage",
-    "dev": "tsx src/main.ts",
-    "prepack": "pnpm build",
-    "release:check": "pnpm check && npm pack --dry-run",
-    "agent-slack": "tsx src/main.ts",
-    "aslk": "tsx src/main.ts",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
-    "test:emulate": "vitest run tests/emulate",
-    "version-packages": "changeset version"
-  },
   "keywords": [
     "slack",
     "cli",
@@ -61,5 +44,24 @@
   },
   "engines": {
     "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "check": "pnpm typecheck && pnpm test:coverage && pnpm build",
+    "changeset": "changeset",
+    "clean": "rm -rf dist coverage",
+    "dev": "tsx src/main.ts",
+    "docs:build": "pnpm --filter docs build",
+    "docs:dev": "pnpm --filter docs dev",
+    "docs:types": "pnpm --filter docs types:check",
+    "release:check": "pnpm check && npm pack --dry-run",
+    "release:publish": "pnpm build && changeset publish",
+    "agent-slack": "tsx src/main.ts",
+    "aslk": "tsx src/main.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:emulate": "vitest run tests/emulate",
+    "version-packages": "changeset version"
   }
-}
+}