@vellumai/assistant 0.4.12 → 0.4.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.4.12",
+  "version": "0.4.13",
   "type": "module",
   "bin": {
     "vellum": "./src/index.ts"

package/src/__tests__/slack-skill.test.ts

@@ -0,0 +1,124 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { describe, expect, test } from 'bun:test';
+
+import type { SlackConversation } from '../messaging/providers/slack/types.js';
+
+const BUNDLED_SKILLS_DIR = join(import.meta.dir, '..', 'config', 'bundled-skills');
+
+describe('slack adapter isPrivate mapping', () => {
+  // Inline the mapping logic to test it independently of the adapter module
+  function mapIsPrivate(conv: Partial<SlackConversation>): boolean {
+    return conv.is_private ?? conv.is_group ?? false;
+  }
+
+  test('public channel is not private', () => {
+    expect(mapIsPrivate({ is_channel: true, is_private: false })).toBe(false);
+  });
+
+  test('private channel with is_private flag', () => {
+    expect(mapIsPrivate({ is_channel: true, is_private: true })).toBe(true);
+  });
+
+  test('private channel via is_group (legacy)', () => {
+    expect(mapIsPrivate({ is_group: true })).toBe(true);
+  });
+
+  test('is_private takes precedence over is_group', () => {
+    expect(mapIsPrivate({ is_private: false, is_group: true })).toBe(false);
+  });
+
+  test('DM defaults to not private when flags absent', () => {
+    expect(mapIsPrivate({ is_im: true })).toBe(false);
+  });
+
+  test('mpim (group DM) defaults to not private when is_private absent', () => {
+    expect(mapIsPrivate({ is_mpim: true })).toBe(false);
+  });
+
+  test('undefined flags default to false', () => {
+    expect(mapIsPrivate({})).toBe(false);
+  });
+});
+
+describe('slack skill TOOLS.json', () => {
+  const toolsPath = join(BUNDLED_SKILLS_DIR, 'slack', 'TOOLS.json');
+  const toolsJson = JSON.parse(readFileSync(toolsPath, 'utf-8'));
+
+  test('is valid JSON with correct version', () => {
+    expect(toolsJson.version).toBe(1);
+    expect(Array.isArray(toolsJson.tools)).toBe(true);
+  });
+
+  test('has expected tools', () => {
+    const names = toolsJson.tools.map((t: { name: string }) => t.name);
+    expect(names).toContain('slack_scan_digest');
+    expect(names).toContain('slack_channel_details');
+    expect(names).toContain('slack_configure_channels');
+    expect(names).toContain('slack_add_reaction');
+    expect(names).toContain('slack_delete_message');
+    expect(names).toContain('slack_leave_channel');
+  });
+
+  test('has 6 tools total', () => {
+    expect(toolsJson.tools.length).toBe(6);
+  });
+
+  test('all tools have required fields', () => {
+    for (const tool of toolsJson.tools) {
+      expect(tool.name).toBeDefined();
+      expect(tool.description).toBeDefined();
+      expect(tool.category).toBeDefined();
+      expect(tool.risk).toBeDefined();
+      expect(tool.input_schema).toBeDefined();
+      expect(tool.executor).toBeDefined();
+      expect(tool.execution_target).toBeDefined();
+    }
+  });
+
+  test('all executor files exist', () => {
+    const slackSkillDir = join(BUNDLED_SKILLS_DIR, 'slack');
+    for (const tool of toolsJson.tools) {
+      const executorPath = join(slackSkillDir, tool.executor);
+      expect(() => readFileSync(executorPath)).not.toThrow();
+    }
+  });
+});
+
+describe('messaging skill no longer has Slack tools', () => {
+  const messagingToolsPath = join(BUNDLED_SKILLS_DIR, 'messaging', 'TOOLS.json');
+  const messagingToolsJson = JSON.parse(readFileSync(messagingToolsPath, 'utf-8'));
+
+  test('slack_add_reaction not in messaging TOOLS.json', () => {
+    const names = messagingToolsJson.tools.map((t: { name: string }) => t.name);
+    expect(names).not.toContain('slack_add_reaction');
+  });
+
+  test('slack_delete_message not in messaging TOOLS.json', () => {
+    const names = messagingToolsJson.tools.map((t: { name: string }) => t.name);
+    expect(names).not.toContain('slack_delete_message');
+  });
+
+  test('slack_leave_channel not in messaging TOOLS.json', () => {
+    const names = messagingToolsJson.tools.map((t: { name: string }) => t.name);
+    expect(names).not.toContain('slack_leave_channel');
+  });
+});
+
+describe('slack skill SKILL.md', () => {
+  const skillMd = readFileSync(join(BUNDLED_SKILLS_DIR, 'slack', 'SKILL.md'), 'utf-8');
+
+  test('has correct frontmatter name', () => {
+    expect(skillMd).toContain('name: "Slack"');
+  });
+
+  test('is user-invocable', () => {
+    expect(skillMd).toContain('user-invocable: true');
+  });
+
+  test('mentions privacy rules', () => {
+    expect(skillMd).toContain('isPrivate');
+    expect(skillMd).toContain('MUST NEVER be shared');
+  });
+});

package/src/agent/loop.ts

@@ -41,7 +41,7 @@ export type AgentEvent =
 
 const DEFAULT_CONFIG: AgentLoopConfig = {
   maxTokens: 16000,
-  maxToolUseTurns: 0,
+  maxToolUseTurns: 40,
   minTurnIntervalMs: 150,
 };
 

package/src/config/bundled-skills/messaging/TOOLS.json

@@ -221,96 +221,6 @@
       "executor": "tools/messaging-mark-read.ts",
       "execution_target": "host"
     },
-    {
-      "name": "slack_add_reaction",
-      "description": "Add an emoji reaction to a Slack message. Include a confidence score (0-1).",
-      "category": "messaging",
-      "risk": "medium",
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "channel": {
-            "type": "string",
-            "description": "Slack channel ID"
-          },
-          "timestamp": {
-            "type": "string",
-            "description": "Message timestamp (ts)"
-          },
-          "emoji": {
-            "type": "string",
-            "description": "Emoji name without colons (e.g. \"thumbsup\")"
-          },
-          "confidence": {
-            "type": "number",
-            "description": "Confidence score (0-1) for this action"
-          }
-        },
-        "required": [
-          "channel",
-          "timestamp",
-          "emoji",
-          "confidence"
-        ]
-      },
-      "executor": "tools/slack-add-reaction.ts",
-      "execution_target": "host"
-    },
-    {
-      "name": "slack_delete_message",
-      "description": "Delete a Slack message posted by the bot. Include a confidence score (0-1).",
-      "category": "messaging",
-      "risk": "high",
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "channel": {
-            "type": "string",
-            "description": "Slack channel ID"
-          },
-          "timestamp": {
-            "type": "string",
-            "description": "Message timestamp (ts) to delete"
-          },
-          "confidence": {
-            "type": "number",
-            "description": "Confidence score (0-1) for this action"
-          }
-        },
-        "required": [
-          "channel",
-          "timestamp",
-          "confidence"
-        ]
-      },
-      "executor": "tools/slack-delete-message.ts",
-      "execution_target": "host"
-    },
-    {
-      "name": "slack_leave_channel",
-      "description": "Leave a Slack channel. Include a confidence score (0-1).",
-      "category": "messaging",
-      "risk": "medium",
-      "input_schema": {
-        "type": "object",
-        "properties": {
-          "channel": {
-            "type": "string",
-            "description": "Slack channel ID to leave"
-          },
-          "confidence": {
-            "type": "number",
-            "description": "Confidence score (0-1) for this action"
-          }
-        },
-        "required": [
-          "channel",
-          "confidence"
-        ]
-      },
-      "executor": "tools/slack-leave-channel.ts",
-      "execution_target": "host"
-    },
     {
       "name": "messaging_analyze_activity",
       "description": "Analyze channel or conversation activity levels. Groups conversations as high/medium/low/dead activity.",
@@ -1011,6 +921,10 @@
           "max_senders": {
             "type": "number",
             "description": "Maximum senders to return (default 30)"
+          },
+          "page_token": {
+            "type": "string",
+            "description": "Resume token from a previous scan's next_page_token to continue scanning beyond the cap"
           }
         }
       },
@@ -1040,6 +954,10 @@
           "max_senders": {
             "type": "number",
             "description": "Maximum senders to return (default 30)"
+          },
+          "page_token": {
+            "type": "string",
+            "description": "Resume token from a previous scan's next_page_token to continue scanning beyond the cap"
           }
         }
       },
@@ -1098,6 +1016,10 @@
           "min_confidence": {
             "type": "number",
             "description": "Minimum confidence threshold 0-1 (default 0.5)"
+          },
+          "page_token": {
+            "type": "string",
+            "description": "Resume token from a previous scan's next_page_token to continue scanning beyond the cap"
           }
         }
       },

package/src/config/bundled-skills/messaging/tools/gmail-outreach-scan.ts

@@ -70,6 +70,7 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
   const maxSenders = (input.max_senders as number) ?? 30;
   const timeRange = (input.time_range as string) ?? '90d';
   const minConfidence = (input.min_confidence as number) ?? 0.5;
+  const inputPageToken = input.page_token as string | undefined;
 
   const query = `in:inbox -has:unsubscribe newer_than:${timeRange}`;
 
@@ -78,7 +79,8 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
     return withValidToken(provider.credentialService, async (token) => {
       // Paginate through listMessages to collect up to maxMessages IDs
       const allMessageIds: string[] = [];
-      let pageToken: string | undefined;
+      let pageToken: string | undefined = inputPageToken;
+      let truncated = false;
 
       while (allMessageIds.length < maxMessages) {
         const pageSize = Math.min(100, maxMessages - allMessageIds.length);
@@ -90,6 +92,10 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
         if (!pageToken) break;
       }
 
+      if (allMessageIds.length >= maxMessages && pageToken) {
+        truncated = true;
+      }
+
       if (allMessageIds.length === 0) {
         return ok(JSON.stringify({ senders: [], total_scanned: 0, outreach_detected: 0, message: 'No emails found matching the query.' }));
       }
@@ -215,6 +221,7 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
         senders,
         total_scanned: allMessageIds.length,
         outreach_detected: totalOutreachDetected,
+        ...(truncated ? { truncated: true, next_page_token: pageToken } : {}),
       }));
     });
   } catch (e) {

package/src/config/bundled-skills/messaging/tools/gmail-sender-digest.ts

@@ -38,13 +38,14 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
   const query = (input.query as string) ?? 'category:promotions newer_than:90d';
   const maxMessages = Math.min((input.max_messages as number) ?? 500, MAX_MESSAGES_CAP);
   const maxSenders = (input.max_senders as number) ?? 30;
+  const inputPageToken = input.page_token as string | undefined;
 
   try {
     const provider = getMessagingProvider('gmail');
     return withValidToken(provider.credentialService, async (token) => {
       // Paginate through listMessages to collect up to maxMessages IDs
       const allMessageIds: string[] = [];
-      let pageToken: string | undefined;
+      let pageToken: string | undefined = inputPageToken;
       let truncated = false;
 
       while (allMessageIds.length < maxMessages) {
@@ -171,7 +172,7 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
         senders: result,
         total_scanned: allMessageIds.length,
         query_used: query,
-        ...(truncated ? { truncated: true } : {}),
+        ...(truncated ? { truncated: true, next_page_token: pageToken } : {}),
         note: `message_count reflects emails found per sender within the ${allMessageIds.length} messages scanned. Use the message_ids array with gmail_batch_archive to archive exactly these messages.`,
       }));
     });

package/src/config/bundled-skills/messaging/tools/messaging-sender-digest.ts

@@ -6,6 +6,7 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
   const query = (input.query as string) ?? 'category:promotions newer_than:90d';
   const maxMessages = input.max_messages as number | undefined;
   const maxSenders = input.max_senders as number | undefined;
+  const pageToken = input.page_token as string | undefined;
 
   try {
     const provider = resolveProvider(platform);
@@ -15,13 +16,14 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
     }
 
     return withProviderToken(provider, async (token) => {
-      const result = await provider.senderDigest!(token, query, { maxMessages, maxSenders });
+      const result = await provider.senderDigest!(token, query, { maxMessages, maxSenders, pageToken });
 
       if (result.senders.length === 0) {
         return ok(JSON.stringify({
           senders: [],
           total_scanned: result.totalScanned,
           query_used: result.queryUsed,
+          ...(result.truncated ? { truncated: true, next_page_token: result.nextPageToken } : {}),
           message: 'No emails found matching the query. Try broadening the search (e.g. remove category filter or extend date range).',
         }));
       }
@@ -43,7 +45,7 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
         senders,
         total_scanned: result.totalScanned,
         query_used: result.queryUsed,
-        ...(result.truncated ? { truncated: true } : {}),
+        ...(result.truncated ? { truncated: true, next_page_token: result.nextPageToken } : {}),
         note: `message_count reflects emails found per sender within the ${result.totalScanned} messages scanned. Use the message_ids array with the archive tool to archive exactly these messages.`,
       }));
     });

package/src/config/bundled-skills/skills-catalog/SKILL.md

@@ -23,7 +23,7 @@ Community skills are published on [Clawhub](https://clawhub.com) and can be sear
 
 ### Searching for community skills
 
-Use the `skill_load` tool to search the catalog, or check the system prompt's available skills list. The IPC `skills_search` message searches both bundled and community skills.
+Use the `skill_load` tool to search the catalog, or check the system prompt's available skills list. The IPC `skills_search` message searches community skills on Clawhub. Bundled skills are already listed in the system prompt.
 
 ### Installing a community skill
 

package/src/config/bundled-skills/slack/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: "Slack"
+description: "Scan channels, summarize threads, and manage Slack with privacy guardrails"
+user-invocable: true
+metadata: {"vellum": {"emoji": "💬"}}
+---
+
+You are a Slack assistant that helps users stay on top of their Slack workspace. Use the slack tools for channel scanning, thread summarization, and Slack-specific operations.
+
+## Channel Scanning
+
+When the user says "scan my Slack", "what's happening on Slack", or similar:
+
+1. Call `slack_scan_digest` immediately. If preferred channels are configured, scan those; otherwise scan top active channels.
+2. Present results progressively: overview first (channel names, message counts, top threads), then offer to drill into specific threads.
+3. For threads the user wants to explore, use `messaging_read` with `thread_id` to fetch full content, then summarize with attribution (who said what, decisions made, open questions).
+
+## Thread Summarization
+
+When summarizing threads surfaced by the digest:
+
+- Include attribution: who said what, what decisions were made, what questions remain open
+- Note the thread's channel and whether it's private
+- Keep summaries concise but complete
+
+## Context Sharing (Privacy Rules)
+
+**This is critical.** Channel privacy must be respected at all times:
+
+- Content from `isPrivate: true` channels MUST NEVER be shared to other channels, DMs, or external destinations
+- Before sharing any content, always check the source channel's `isPrivate` flag in the digest data
+- If the user asks to share private channel content, explain that the content is from a private channel and cannot be shared externally, then offer alternatives (e.g., summarize the topic without quoting, ask the user to share manually)
+- Public channel content can be shared with attribution ("From #channel: ...")
+- Always confirm with the user before sending content to any destination
+
+## Channel Preferences
+
+Use `slack_configure_channels` to save and load preferred channels for scanning.
+
+- After a first scan, suggest configuring defaults: "Want me to remember these channels for future scans?"
+- Saved preferences are used automatically by `slack_scan_digest` when no specific channels are requested
+
+## Watcher Integration
+
+For real-time monitoring (not just on-demand scanning), the user can set up a Slack watcher using the watcher skill with the same channel IDs. Mention this if the user wants ongoing monitoring.
+
+## Connection
+
+Before using any Slack tool, verify that Slack is connected. If not connected, guide the user through the Slack setup flow described in the messaging skill.

package/src/config/bundled-skills/slack/TOOLS.json

@@ -0,0 +1,167 @@
+{
+  "version": 1,
+  "tools": [
+    {
+      "name": "slack_scan_digest",
+      "description": "Scan multiple Slack channels and return a digest of recent activity including top threads, participants, and privacy status.",
+      "category": "slack",
+      "risk": "low",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "channel_ids": {
+            "type": "array",
+            "items": { "type": "string" },
+            "description": "Specific channel IDs to scan. If omitted, scans preferred or top active channels."
+          },
+          "hours_back": {
+            "type": "number",
+            "description": "How many hours of history to scan (default 24)"
+          },
+          "include_threads": {
+            "type": "boolean",
+            "description": "Whether to fetch thread replies for top threads (default true)"
+          },
+          "max_channels": {
+            "type": "number",
+            "description": "Maximum number of channels to scan (default 20)"
+          }
+        }
+      },
+      "executor": "tools/slack-scan-digest.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "slack_channel_details",
+      "description": "Get detailed information about a single Slack channel including name, topic, purpose, privacy status, and member count.",
+      "category": "slack",
+      "risk": "low",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "channel_id": {
+            "type": "string",
+            "description": "The Slack channel ID to get details for"
+          }
+        },
+        "required": ["channel_id"]
+      },
+      "executor": "tools/slack-channel-details.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "slack_configure_channels",
+      "description": "Manage preferred Slack channels for scanning. List, add, remove, or set the preferred channel list.",
+      "category": "slack",
+      "risk": "low",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "action": {
+            "type": "string",
+            "enum": ["list", "add", "remove", "set"],
+            "description": "Action to perform on the preferred channels list"
+          },
+          "channel_ids": {
+            "type": "array",
+            "items": { "type": "string" },
+            "description": "Channel IDs to add, remove, or set (not needed for 'list')"
+          }
+        },
+        "required": ["action"]
+      },
+      "executor": "tools/slack-configure-channels.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "slack_add_reaction",
+      "description": "Add an emoji reaction to a Slack message. Include a confidence score (0-1).",
+      "category": "slack",
+      "risk": "medium",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "channel": {
+            "type": "string",
+            "description": "Slack channel ID"
+          },
+          "timestamp": {
+            "type": "string",
+            "description": "Message timestamp (ts)"
+          },
+          "emoji": {
+            "type": "string",
+            "description": "Emoji name without colons (e.g. \"thumbsup\")"
+          },
+          "confidence": {
+            "type": "number",
+            "description": "Confidence score (0-1) for this action"
+          }
+        },
+        "required": [
+          "channel",
+          "timestamp",
+          "emoji",
+          "confidence"
+        ]
+      },
+      "executor": "tools/slack-add-reaction.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "slack_delete_message",
+      "description": "Delete a Slack message posted by the bot. Include a confidence score (0-1).",
+      "category": "slack",
+      "risk": "high",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "channel": {
+            "type": "string",
+            "description": "Slack channel ID"
+          },
+          "timestamp": {
+            "type": "string",
+            "description": "Message timestamp (ts) to delete"
+          },
+          "confidence": {
+            "type": "number",
+            "description": "Confidence score (0-1) for this action"
+          }
+        },
+        "required": [
+          "channel",
+          "timestamp",
+          "confidence"
+        ]
+      },
+      "executor": "tools/slack-delete-message.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "slack_leave_channel",
+      "description": "Leave a Slack channel. Include a confidence score (0-1).",
+      "category": "slack",
+      "risk": "medium",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "channel": {
+            "type": "string",
+            "description": "Slack channel ID to leave"
+          },
+          "confidence": {
+            "type": "number",
+            "description": "Confidence score (0-1) for this action"
+          }
+        },
+        "required": [
+          "channel",
+          "confidence"
+        ]
+      },
+      "executor": "tools/slack-leave-channel.ts",
+      "execution_target": "host"
+    }
+  ]
+}

package/src/config/bundled-skills/slack/tools/shared.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared utilities for slack skill tools.
+ */
+
+import { getMessagingProvider } from '../../../../messaging/registry.js';
+import { withValidToken } from '../../../../security/token-manager.js';
+import type { ToolExecutionResult } from '../../../../tools/types.js';
+
+export function ok(content: string): ToolExecutionResult {
+  return { content, isError: false };
+}
+
+export function err(message: string): ToolExecutionResult {
+  return { content: message, isError: true };
+}
+
+/**
+ * Execute a callback with a valid Slack OAuth token.
+ */
+export async function withSlackToken<T>(fn: (token: string) => Promise<T>): Promise<T> {
+  const provider = getMessagingProvider('slack');
+  return withValidToken(provider.credentialService, fn);
+}

package/src/config/bundled-skills/{messaging → slack}/tools/slack-add-reaction.ts

@@ -1,8 +1,6 @@
 import { addReaction } from '../../../../messaging/providers/slack/client.js';
-import { getMessagingProvider } from '../../../../messaging/registry.js';
-import { withValidToken } from '../../../../security/token-manager.js';
 import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-import { err,ok } from './shared.js';
+import { err, ok, withSlackToken } from './shared.js';
 
 export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
   const channel = input.channel as string;
@@ -14,8 +12,7 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
   }
 
   try {
-    const provider = getMessagingProvider('slack');
-    return withValidToken(provider.credentialService, async (token) => {
+    return withSlackToken(async (token) => {
       await addReaction(token, channel, timestamp, emoji);
       return ok(`Added :${emoji}: reaction.`);
     });

package/src/config/bundled-skills/slack/tools/slack-channel-details.ts

@@ -0,0 +1,33 @@
+import * as slack from '../../../../messaging/providers/slack/client.js';
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { err, ok, withSlackToken } from './shared.js';
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const channelId = input.channel_id as string;
+
+  if (!channelId) {
+    return err('channel_id is required.');
+  }
+
+  try {
+    return withSlackToken(async (token) => {
+      const resp = await slack.conversationInfo(token, channelId);
+      const conv = resp.channel;
+
+      const result = {
+        channelId: conv.id,
+        name: conv.name ?? conv.id,
+        topic: conv.topic?.value || null,
+        purpose: conv.purpose?.value || null,
+        isPrivate: conv.is_private ?? conv.is_group ?? false,
+        isArchived: conv.is_archived ?? false,
+        memberCount: conv.num_members ?? null,
+        latestActivityTs: conv.latest?.ts ?? null,
+      };
+
+      return ok(JSON.stringify(result, null, 2));
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/slack/tools/slack-configure-channels.ts

@@ -0,0 +1,75 @@
+import { getConfig, saveConfig } from '../../../../config/loader.js';
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { err, ok } from './shared.js';
+
+function getPreferredChannels(): string[] {
+  const config = getConfig();
+  const channels = config.skills?.entries?.slack?.config?.preferredChannels;
+  return Array.isArray(channels) ? channels as string[] : [];
+}
+
+function setPreferredChannels(channels: string[]): void {
+  const config = getConfig();
+  if (!config.skills) config.skills = {} as typeof config.skills;
+  if (!config.skills.entries) config.skills.entries = {};
+  if (!config.skills.entries.slack) config.skills.entries.slack = { enabled: true };
+  if (!config.skills.entries.slack.config) config.skills.entries.slack.config = {};
+  config.skills.entries.slack.config.preferredChannels = channels;
+  saveConfig(config);
+}
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const action = input.action as string;
+  const channelIds = input.channel_ids as string[] | undefined;
+
+  if (!action) {
+    return err('action is required (list, add, remove, or set).');
+  }
+
+  try {
+    switch (action) {
+      case 'list': {
+        const channels = getPreferredChannels();
+        if (channels.length === 0) {
+          return ok('No preferred channels configured. Use action "set" or "add" to configure channels.');
+        }
+        return ok(JSON.stringify({ preferredChannels: channels }, null, 2));
+      }
+
+      case 'add': {
+        if (!channelIds?.length) {
+          return err('channel_ids required for "add" action.');
+        }
+        const current = getPreferredChannels();
+        const merged = [...new Set([...current, ...channelIds])];
+        setPreferredChannels(merged);
+        return ok(JSON.stringify({ preferredChannels: merged, added: channelIds.filter((id) => !current.includes(id)) }, null, 2));
+      }
+
+      case 'remove': {
+        if (!channelIds?.length) {
+          return err('channel_ids required for "remove" action.');
+        }
+        const current = getPreferredChannels();
+        const removeSet = new Set(channelIds);
+        const remaining = current.filter((id) => !removeSet.has(id));
+        setPreferredChannels(remaining);
+        return ok(JSON.stringify({ preferredChannels: remaining, removed: channelIds.filter((id) => current.includes(id)) }, null, 2));
+      }
+
+      case 'set': {
+        if (!channelIds) {
+          return err('channel_ids required for "set" action.');
+        }
+        const unique = [...new Set(channelIds)];
+        setPreferredChannels(unique);
+        return ok(JSON.stringify({ preferredChannels: unique }, null, 2));
+      }
+
+      default:
+        return err(`Unknown action "${action}". Use list, add, remove, or set.`);
+    }
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-skills/{messaging → slack}/tools/slack-delete-message.ts

@@ -1,8 +1,6 @@
 import { deleteMessage } from '../../../../messaging/providers/slack/client.js';
-import { getMessagingProvider } from '../../../../messaging/registry.js';
-import { withValidToken } from '../../../../security/token-manager.js';
 import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-import { err, ok } from './shared.js';
+import { err, ok, withSlackToken } from './shared.js';
 
 export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
   const channel = input.channel as string;
@@ -13,8 +11,7 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
   }
 
   try {
-    const provider = getMessagingProvider('slack');
-    return withValidToken(provider.credentialService, async (token) => {
+    return withSlackToken(async (token) => {
       await deleteMessage(token, channel, timestamp);
       return ok(`Message deleted.`);
     });

package/src/config/bundled-skills/{messaging → slack}/tools/slack-leave-channel.ts

@@ -1,8 +1,6 @@
 import { leaveConversation } from '../../../../messaging/providers/slack/client.js';
-import { getMessagingProvider } from '../../../../messaging/registry.js';
-import { withValidToken } from '../../../../security/token-manager.js';
 import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
-import { err,ok } from './shared.js';
+import { err, ok, withSlackToken } from './shared.js';
 
 export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
   const channel = input.channel as string;
@@ -12,8 +10,7 @@ export async function run(input: Record<string, unknown>, _context: ToolContext)
   }
 
   try {
-    const provider = getMessagingProvider('slack');
-    return withValidToken(provider.credentialService, async (token) => {
+    return withSlackToken(async (token) => {
       await leaveConversation(token, channel);
       return ok('Left channel.');
     });

package/src/config/bundled-skills/slack/tools/slack-scan-digest.ts

@@ -0,0 +1,193 @@
+import * as slack from '../../../../messaging/providers/slack/client.js';
+import type { SlackConversation } from '../../../../messaging/providers/slack/types.js';
+import { getConfig } from '../../../../config/loader.js';
+import type { ToolContext, ToolExecutionResult } from '../../../../tools/types.js';
+import { err, ok, withSlackToken } from './shared.js';
+
+interface ThreadSummary {
+  threadTs: string;
+  previewText: string;
+  replyCount: number;
+  participants: string[];
+}
+
+interface ChannelDigest {
+  channelId: string;
+  channelName: string;
+  isPrivate: boolean;
+  messageCount: number;
+  topThreads: ThreadSummary[];
+  keyParticipants: string[];
+  error?: string;
+}
+
+const userNameCache = new Map<string, string>();
+
+async function resolveUserName(token: string, userId: string): Promise<string> {
+  if (!userId) return 'unknown';
+  const cached = userNameCache.get(userId);
+  if (cached) return cached;
+
+  try {
+    const resp = await slack.userInfo(token, userId);
+    const name = resp.user.profile?.display_name
+      || resp.user.profile?.real_name
+      || resp.user.real_name
+      || resp.user.name;
+    userNameCache.set(userId, name);
+    return name;
+  } catch {
+    return userId;
+  }
+}
+
+async function scanChannel(
+  token: string,
+  conv: SlackConversation,
+  oldestTs: string,
+  includeThreads: boolean,
+): Promise<ChannelDigest> {
+  const channelId = conv.id;
+  const channelName = conv.name ?? channelId;
+  const isPrivate = conv.is_private ?? conv.is_group ?? false;
+
+  try {
+    const history = await slack.conversationHistory(token, channelId, 100, undefined, oldestTs);
+    const messages = history.messages;
+
+    const participantIds = new Set<string>();
+    for (const msg of messages) {
+      if (msg.user) participantIds.add(msg.user);
+    }
+
+    const keyParticipants: string[] = [];
+    for (const uid of participantIds) {
+      keyParticipants.push(await resolveUserName(token, uid));
+    }
+
+    const threadMessages = messages
+      .filter((m) => (m.reply_count ?? 0) > 0)
+      .sort((a, b) => (b.reply_count ?? 0) - (a.reply_count ?? 0))
+      .slice(0, 3);
+
+    const topThreads: ThreadSummary[] = [];
+    for (const msg of threadMessages) {
+      let participants: string[] = [];
+
+      if (includeThreads) {
+        try {
+          const replies = await slack.conversationReplies(token, channelId, msg.ts, 10);
+          const threadParticipantIds = new Set<string>();
+          for (const reply of replies.messages) {
+            if (reply.user) threadParticipantIds.add(reply.user);
+          }
+          for (const uid of threadParticipantIds) {
+            participants.push(await resolveUserName(token, uid));
+          }
+        } catch {
+          participants = [await resolveUserName(token, msg.user ?? '')];
+        }
+      }
+
+      topThreads.push({
+        threadTs: msg.ts,
+        previewText: truncate(msg.text, 150),
+        replyCount: msg.reply_count ?? 0,
+        participants,
+      });
+    }
+
+    return {
+      channelId,
+      channelName,
+      isPrivate,
+      messageCount: messages.length,
+      topThreads,
+      keyParticipants,
+    };
+  } catch (e) {
+    return {
+      channelId,
+      channelName,
+      isPrivate,
+      messageCount: 0,
+      topThreads: [],
+      keyParticipants: [],
+      error: e instanceof Error ? e.message : String(e),
+    };
+  }
+}
+
+function truncate(text: string, maxLen: number): string {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen - 3) + '...';
+}
+
+export async function run(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
+  const channelIds = input.channel_ids as string[] | undefined;
+  const hoursBack = (input.hours_back as number) ?? 24;
+  const includeThreads = (input.include_threads as boolean) ?? true;
+  const maxChannels = (input.max_channels as number) ?? 20;
+
+  try {
+    return withSlackToken(async (token) => {
+      const oldestTs = String((Date.now() - hoursBack * 60 * 60 * 1000) / 1000);
+
+      let channelsToScan: SlackConversation[];
+
+      if (channelIds?.length) {
+        const results = await Promise.allSettled(
+          channelIds.map((id) => slack.conversationInfo(token, id)),
+        );
+        channelsToScan = results
+          .filter((r): r is PromiseFulfilledResult<Awaited<ReturnType<typeof slack.conversationInfo>>> => r.status === 'fulfilled')
+          .map((r) => r.value.channel);
+      } else {
+        const config = getConfig();
+        const preferredIds = config.skills?.entries?.slack?.config?.preferredChannels as string[] | undefined;
+
+        if (preferredIds?.length) {
+          const results = await Promise.allSettled(
+            preferredIds.map((id) => slack.conversationInfo(token, id)),
+          );
+          channelsToScan = results
+            .filter((r): r is PromiseFulfilledResult<Awaited<ReturnType<typeof slack.conversationInfo>>> => r.status === 'fulfilled')
+            .map((r) => r.value.channel);
+        } else {
+          const resp = await slack.listConversations(token, 'public_channel,private_channel', true, 200);
+          channelsToScan = resp.channels
+            .filter((c) => c.is_member)
+            .sort((a, b) => {
+              const aTs = a.latest?.ts ? parseFloat(a.latest.ts) : 0;
+              const bTs = b.latest?.ts ? parseFloat(b.latest.ts) : 0;
+              return bTs - aTs;
+            })
+            .slice(0, maxChannels);
+        }
+      }
+
+      const scanResults = await Promise.allSettled(
+        channelsToScan.map((conv) => scanChannel(token, conv, oldestTs, includeThreads)),
+      );
+
+      const digests: ChannelDigest[] = scanResults
+        .filter((r): r is PromiseFulfilledResult<ChannelDigest> => r.status === 'fulfilled')
+        .map((r) => r.value)
+        .filter((d) => d.messageCount > 0 || d.error);
+
+      const skippedCount = scanResults.filter((r) => r.status === 'rejected').length;
+
+      const result = {
+        scannedChannels: digests.length,
+        totalChannelsAttempted: channelsToScan.length,
+        skippedDueToErrors: skippedCount,
+        hoursBack,
+        channels: digests,
+      };
+
+      return ok(JSON.stringify(result, null, 2));
+    });
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+}

package/src/config/bundled-tool-registry.ts

@@ -122,8 +122,6 @@ import * as sequenceList from "./bundled-skills/messaging/tools/sequence-list.js
 import * as sequencePause from "./bundled-skills/messaging/tools/sequence-pause.js";
 import * as sequenceResume from "./bundled-skills/messaging/tools/sequence-resume.js";
 import * as sequenceUpdate from "./bundled-skills/messaging/tools/sequence-update.js";
-import * as slackAddReaction from "./bundled-skills/messaging/tools/slack-add-reaction.js";
-import * as slackLeaveChannel from "./bundled-skills/messaging/tools/slack-leave-channel.js";
 // ── notifications ───────────────────────────────────────────────────────────
 import * as sendNotification from "./bundled-skills/notifications/tools/send-notification.js";
 // ── phone-calls ─────────────────────────────────────────────────────────────
@@ -144,6 +142,13 @@ import * as scheduleCreate from "./bundled-skills/schedule/tools/schedule-create
 import * as scheduleDelete from "./bundled-skills/schedule/tools/schedule-delete.js";
 import * as scheduleList from "./bundled-skills/schedule/tools/schedule-list.js";
 import * as scheduleUpdate from "./bundled-skills/schedule/tools/schedule-update.js";
+// ── slack ────────────────────────────────────────────────────────────────────
+import * as slackAddReaction from "./bundled-skills/slack/tools/slack-add-reaction.js";
+import * as slackChannelDetails from "./bundled-skills/slack/tools/slack-channel-details.js";
+import * as slackConfigureChannels from "./bundled-skills/slack/tools/slack-configure-channels.js";
+import * as slackDeleteMessage from "./bundled-skills/slack/tools/slack-delete-message.js";
+import * as slackLeaveChannel from "./bundled-skills/slack/tools/slack-leave-channel.js";
+import * as slackScanDigest from "./bundled-skills/slack/tools/slack-scan-digest.js";
 import * as subagentAbort from "./bundled-skills/subagent/tools/subagent-abort.js";
 import * as subagentMessage from "./bundled-skills/subagent/tools/subagent-message.js";
 import * as subagentRead from "./bundled-skills/subagent/tools/subagent-read.js";
@@ -271,8 +276,6 @@ export const bundledToolRegistry = new Map<string, SkillToolScript>([
   ["messaging:tools/messaging-send.ts", messagingSend],
   ["messaging:tools/messaging-reply.ts", messagingReply],
   ["messaging:tools/messaging-mark-read.ts", messagingMarkRead],
-  ["messaging:tools/slack-add-reaction.ts", slackAddReaction],
-  ["messaging:tools/slack-leave-channel.ts", slackLeaveChannel],
   ["messaging:tools/messaging-analyze-activity.ts", messagingAnalyzeActivity],
   ["messaging:tools/messaging-analyze-style.ts", messagingAnalyzeStyle],
   ["messaging:tools/messaging-draft.ts", messagingDraft],
@@ -333,6 +336,14 @@ export const bundledToolRegistry = new Map<string, SkillToolScript>([
   ["schedule:tools/schedule-update.ts", scheduleUpdate],
   ["schedule:tools/schedule-delete.ts", scheduleDelete],
 
+  // slack
+  ["slack:tools/slack-scan-digest.ts", slackScanDigest],
+  ["slack:tools/slack-channel-details.ts", slackChannelDetails],
+  ["slack:tools/slack-configure-channels.ts", slackConfigureChannels],
+  ["slack:tools/slack-add-reaction.ts", slackAddReaction],
+  ["slack:tools/slack-delete-message.ts", slackDeleteMessage],
+  ["slack:tools/slack-leave-channel.ts", slackLeaveChannel],
+
   // subagent
   ["subagent:tools/subagent-spawn.ts", subagentSpawn],
   ["subagent:tools/subagent-status.ts", subagentStatus],

package/src/config/schema.ts

@@ -205,7 +205,7 @@ export const AssistantConfigSchema = z.object({
     .number({ error: 'maxToolUseTurns must be a number' })
     .int('maxToolUseTurns must be an integer')
     .nonnegative('maxToolUseTurns must be a non-negative integer')
-    .default(0),
+    .default(40),
   thinking: ThinkingConfigSchema.default(ThinkingConfigSchema.parse({})),
   contextWindow: ContextWindowConfigSchema.default(ContextWindowConfigSchema.parse({})),
   memory: MemoryConfigSchema.default(MemoryConfigSchema.parse({})),

package/src/daemon/session-agent-loop-handlers.ts

@@ -185,12 +185,13 @@ export function handleThinkingDelta(
   if (!state.firstThinkingDeltaEmitted) {
     state.firstThinkingDeltaEmitted = true;
     const lastToolName = state.lastCompletedToolName;
-    // Only emit activity state when we have a tool name to report.
-    // When lastCompletedToolName is undefined (e.g. right after
-    // confirmation_resolved), emitting without statusText would clear
-    // the client's current status (e.g. "Resuming after approval").
-    // The phase is already 'thinking' from either message_dequeued or
-    // confirmation_resolved, so skipping here is safe.
+    // Only emit an activity state when a tool just completed, so we can
+    // show "Processing <tool> results". When no tool has completed yet
+    // (e.g. right after confirmation_resolved), skip the emission entirely
+    // so the client preserves its current status text (e.g. "Resuming
+    // after approval"). Even omitting statusText from the message would
+    // cause the client to clear it, since the client overwrites
+    // assistantStatusText for every assistant_activity_state event.
     if (lastToolName) {
       const statusText = `Processing ${friendlyToolName(lastToolName)} results`;
       deps.ctx.emitActivityState('thinking', 'thinking_delta', 'assistant_turn', deps.reqId, statusText);

package/src/messaging/provider-types.ts

@@ -10,6 +10,7 @@ export interface Conversation {
   memberCount?: number;
   topic?: string;
   isArchived?: boolean;
+  isPrivate?: boolean;
   metadata?: Record<string, unknown>;
 }
 
@@ -101,6 +102,8 @@ export interface SenderDigestResult {
   queryUsed: string;
   /** True when pagination was stopped because the scan cap was reached but more messages exist. */
   truncated?: boolean;
+  /** Resume token for sequential scanning — present when truncated is true. */
+  nextPageToken?: string;
 }
 
 export interface ArchiveResult {

package/src/messaging/provider.ts

@@ -41,7 +41,7 @@ export interface MessagingProvider {
   markRead?(token: string, conversationId: string, messageId?: string): Promise<void>;
 
   /** Scan messages and group by sender for bulk cleanup (e.g. newsletter decluttering). */
-  senderDigest?(token: string, query: string, options?: { maxMessages?: number; maxSenders?: number }): Promise<SenderDigestResult>;
+  senderDigest?(token: string, query: string, options?: { maxMessages?: number; maxSenders?: number; pageToken?: string }): Promise<SenderDigestResult>;
   /** Archive messages matching a search query. */
   archiveByQuery?(token: string, query: string): Promise<ArchiveResult>;
 

package/src/messaging/providers/gmail/adapter.ts

@@ -195,13 +195,13 @@ export const gmailMessagingProvider: MessagingProvider = {
     await gmail.modifyMessage(token, messageId, { removeLabelIds: ['UNREAD'] });
   },
 
-  async senderDigest(token: string, query: string, options?: { maxMessages?: number; maxSenders?: number }): Promise<SenderDigestResult> {
+  async senderDigest(token: string, query: string, options?: { maxMessages?: number; maxSenders?: number; pageToken?: string }): Promise<SenderDigestResult> {
     const maxMessages = Math.min(options?.maxMessages ?? 2000, 2000);
     const maxSenders = options?.maxSenders ?? 30;
     const maxIdsPerSender = 2000;
 
     const allMessageIds: string[] = [];
-    let pageToken: string | undefined;
+    let pageToken: string | undefined = options?.pageToken;
     let truncated = false;
 
     while (allMessageIds.length < maxMessages) {
@@ -289,7 +289,7 @@ export const gmailMessagingProvider: MessagingProvider = {
       hasMore: s.hasMore,
     }));
 
-    return { senders, totalScanned: allMessageIds.length, queryUsed: query, ...(truncated ? { truncated } : {}) };
+    return { senders, totalScanned: allMessageIds.length, queryUsed: query, ...(truncated ? { truncated, nextPageToken: pageToken } : {}) };
   },
 
   async archiveByQuery(token: string, query: string): Promise<ArchiveResult> {

package/src/messaging/providers/slack/adapter.ts

@@ -60,6 +60,7 @@ function mapConversation(conv: SlackConversation): Conversation {
     memberCount: conv.num_members,
     topic: conv.topic?.value || undefined,
     isArchived: conv.is_archived,
+    isPrivate: conv.is_private ?? conv.is_group ?? false,
     metadata: conv.is_im ? { dmUserId: conv.user } : undefined,
   };
 }

package/src/messaging/providers/slack/client.ts

@@ -10,6 +10,7 @@ import type {
   SlackAuthTestResponse,
   SlackChatDeleteResponse,
   SlackConversationHistoryResponse,
+  SlackConversationInfoResponse,
   SlackConversationLeaveResponse,
   SlackConversationMarkResponse,
   SlackConversationRepliesResponse,
@@ -95,6 +96,13 @@ export async function listConversations(
   });
 }
 
+export async function conversationInfo(
+  token: string,
+  channel: string,
+): Promise<SlackConversationInfoResponse> {
+  return request<SlackConversationInfoResponse>(token, 'conversations.info', { channel });
+}
+
 export async function conversationHistory(
   token: string,
   channel: string,

package/src/messaging/providers/slack/types.ts

@@ -20,6 +20,7 @@ export interface SlackConversation {
   is_group?: boolean;
   is_im?: boolean;
   is_mpim?: boolean;
+  is_private?: boolean;
   is_archived?: boolean;
   is_member?: boolean;
   topic?: { value: string };
@@ -108,6 +109,10 @@ export interface SlackSearchMatch {
   thread_ts?: string;
 }
 
+export interface SlackConversationInfoResponse extends SlackApiResponse {
+  channel: SlackConversation;
+}
+
 export interface SlackConversationsOpenResponse extends SlackApiResponse {
   channel: { id: string };
 }