@vellumai/assistant 0.12.1 → 0.12.2-staging.2

package/src/config/acp-schema.ts

@@ -1,8 +1,15 @@
 import { z } from "zod";
 
-const AcpAgentConfigSchema = z
+import { DEFAULT_ACP_AGENT_PROFILES } from "./acp-defaults.js";
+
+export const AcpAgentConfigSchema = z
   .object({
-    command: z.string().describe("Command to spawn the ACP agent process"),
+    command: z
+      .string()
+      .optional()
+      .describe(
+        "Command to spawn the ACP agent process. Required unless the id has a bundled profile, whose command is inherited when this is unset",
+      ),
     args: z
       .array(z.string())
       .default([])
@@ -15,6 +22,12 @@ const AcpAgentConfigSchema = z
       .record(z.string(), z.string())
       .optional()
       .describe("Environment variables set for the agent process"),
+    model: z
+      .string()
+      .optional()
+      .describe(
+        "Model sessions of this agent start on when the ask names none (an adapter-reported alias such as 'opus' or 'sonnet' for Claude, not an Assistant catalog id). Overrides the bundled profile's value; unset inherits it.",
+      ),
   })
   .describe("Configuration for an individual ACP agent");
 
@@ -30,6 +43,21 @@ export const AcpConfigSchema = z
       ),
     agents: z
       .record(z.string(), AcpAgentConfigSchema)
+      .superRefine((agents, ctx) => {
+        for (const [id, agent] of Object.entries(agents)) {
+          if (
+            agent.command !== undefined ||
+            Object.hasOwn(DEFAULT_ACP_AGENT_PROFILES, id)
+          ) {
+            continue;
+          }
+          ctx.addIssue({
+            code: "custom",
+            path: [id, "command"],
+            message: `acp.agents.${id} needs a command: only the bundled ids (${Object.keys(DEFAULT_ACP_AGENT_PROFILES).join(", ")}) inherit one`,
+          });
+        }
+      })
       .default({})
       .describe("Map of agent names to their configurations"),
   })

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

@@ -23,6 +23,18 @@ Use `acp_spawn` to delegate a coding task to an external agent. The agent runs a
 
 Users can refer to agents by natural names: "claude code", "codex cli", and "openai codex" all resolve to the canonical `claude` and `codex` ids (unless the user's config defines an agent literally keyed by that name, which always wins).
 
+## Choosing a model
+
+Claude runs on Opus unless the user names a model; every other agent starts on its own default.
+
+When the user does name one, pass it as `model` on `acp_spawn`. Model names are the agent's own vocabulary, not Assistant model ids: an alias such as `default`, `sonnet`, `opus`, `haiku`, `fable`, or `opusplan` for Claude, or a full model id. Pass what the user said and let the agent resolve it.
+
+The spawn result reports `requestedModel` and `effectiveModel`. Treat `effectiveModel` as authoritative for the top-level ACP session. Never infer that model from the task text or from a nested subagent. When `requestedModel` is non-null and differs from `effectiveModel`, state which model the session is actually running on and relay `modelWarning` when present.
+
+If the agent refuses the model, or advertises no model selector, the spawn result says so: relay it in one sentence and carry on, because the session is live on the agent's own model.
+
+A session runs on the model it started on, so a different model means a new `acp_spawn`. A standing default per agent lives in the config at `acp.agents.<id>.model`.
+
 ## When the user names Claude Code or Codex
 
 If they name Claude Code or Codex without asking you to run it here (for example they say that tool will do the work), offer once, in one short sentence, that you can connect and run it in this conversation. Then continue with whatever they were doing.
@@ -35,21 +47,23 @@ If they name Claude Code or Codex without asking you to run it here (for example
 
 ACP is always available - default profiles for `claude` and `codex` ship out-of-box, so no config edit is needed to start. First-time setup is just making the adapter binary available, then spawning:
 
-1. Install the adapter binary if it's missing. This happens automatically: when `acp_spawn` finds the agent's binary missing from PATH, the assistant installs it once via a sandboxed bun global install and proceeds in the same call (see "Automatic adapter availability" below).
+1. Install the adapter binary if it's missing. This happens automatically: when `acp_spawn` finds the agent's binary missing from PATH, the assistant installs the pinned version via a sandboxed bun global install and proceeds in the same call (see "Automatic adapter availability" below).
 
 2. Call `acp_spawn`. Do NOT run `vellum sleep && vellum wake` - that kills the conversation.
 
 ## Automatic adapter availability
 
-When `acp_spawn` finds the agent's binary missing from PATH, the assistant installs it once via a sandboxed bun global install and then runs the real installed binary. The install runs in a fresh empty temporary directory (never the task's project directory), with known secrets stripped from the installer environment and the registry pinned to the public npm registry, so a malicious project directory cannot hijack package resolution or capture a token. After this one-time install, the adapter is a normal trusted binary on PATH and every later spawn (and resume) uses it directly.
+When an agent's binary is missing from PATH, the assistant installs the adapter version it was built against via a sandboxed bun global install and then runs the real installed binary. The install runs in a fresh empty temporary directory (never the task's project directory), with known secrets stripped from the installer environment and the registry pinned to the public npm registry, so a malicious project directory cannot hijack package resolution or capture a token.
+
+An adapter already on PATH is left alone, whoever installed it: the install runs only when preflight found no binary at all.
 
 Only the allowlisted out-of-box packages are ever installed this way (`@agentclientprotocol/claude-agent-acp`, `@agentclientprotocol/codex-acp`); user-configured agents with custom commands are never installed automatically.
 
-Manual installation is fallback guidance for unusual setups: bun unavailable, restricted global installs, or an auto-install failure (the failure reason is surfaced in the tool result).
+Manual installation is fallback guidance for unusual setups: bun unavailable, restricted global installs, or an auto-install failure (the failure reason is surfaced in the tool result). Install the pinned version below rather than `@latest`, so the adapter matches what the assistant was built against.
 
 ```bash
-bun add -g @agentclientprotocol/claude-agent-acp   # claude
-bun add -g @agentclientprotocol/codex-acp          # codex
+bun add -g @agentclientprotocol/claude-agent-acp@0.75.1   # claude
+bun add -g @agentclientprotocol/codex-acp@1.10.0          # codex
 ```
 
 ## Claude setup
@@ -84,20 +98,14 @@ Do NOT put API keys (or any secret) in the workspace config file - secrets never
 
 - Two agents are supported out-of-box: `claude` (via the `claude-agent-acp` adapter) and `codex` (via the `codex-acp` adapter).
 - NEVER use `claude`, `claude -p`, `claude --acp`, or the bare `codex` CLI as the ACP `command`. Claude and Codex only speak the protocol through their dedicated `*-acp` adapters.
-- Default profiles for both ship out-of-box. Users only need an `agents.<id>` entry in config if they want to override the defaults (e.g. point to a custom binary path or pass extra args/env). An `acp.agents.<id>` entry replaces the bundled default entirely (no field merge), so any override must spell out the full `command` and `args`, not just the field being changed.
+- Default profiles for both ship out-of-box. Users only need an `agents.<id>` entry in config if they want to override the defaults (e.g. point to a custom binary path or pass extra args/env). An entry that still runs the bundled adapter, whether it omits `command` or names the same binary by name or full path, inherits the `command`, `description` and `model` it leaves out, so a single-field change such as `acp.agents.claude.model` is all it takes. An entry that points the id at a different binary stands on its own, so it must spell out everything it needs, `command` included.
 - NEVER change an existing ACP config to use a different command. If the config already has `claude-agent-acp` or `codex-acp`, leave it alone.
 
 ## Updating an adapter
 
-Adapters are installed automatically when missing. To update an installed adapter, ask the user first and use its owning package manager. For bun installations:
-
-```bash
-bun add -g @agentclientprotocol/claude-agent-acp@latest
-# or
-bun add -g @agentclientprotocol/codex-acp@latest
-```
+Adapter upgrades ship with Assistant releases: the pinned version is what a missing adapter is installed at. An adapter already on PATH is never replaced, so a user who upgrades one themselves keeps that version.
 
-Codex uses the adapter's bundled dependency by default, within the version range declared by the adapter. If `CODEX_PATH` selects a separate CLI, update that installation separately. Verify the required model with a fresh `acp_spawn` call after updating.
+Codex uses the adapter's bundled dependency by default, within the version range declared by the adapter. If `CODEX_PATH` selects a separate CLI, update that installation separately.
 
 ## When to use acp_steer vs acp_spawn
 

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

@@ -3,7 +3,7 @@
   "tools": [
     {
       "name": "acp_spawn",
-      "description": "Spawn an external coding agent (e.g. Claude Code, Codex) via ACP to work on a task. Default profiles ship for `claude` (`claude-agent-acp`) and `codex` (`codex-acp`); the assistant resolves the agent id to the right binary. The agent runs as a subprocess and streams results back. Use this when you want to delegate a coding task to an external agent that has its own tools, file editing, and terminal access. If a default agent's binary is missing, the assistant installs it once via a sandboxed bun global install and proceeds in the same call; if that fails (e.g. bun unavailable), an actionable install hint is returned - do NOT alter `agents.<id>.command` to swap binaries.",
+      "description": "Spawn an external coding agent (e.g. Claude Code, Codex) via ACP to work on a task. Default profiles ship for `claude` (`claude-agent-acp`) and `codex` (`codex-acp`); the assistant resolves the agent id to the right binary. The result reports `requestedModel` and the adapter-reported `effectiveModel`; treat `effectiveModel` as authoritative for the top-level ACP session. The agent runs as a subprocess and streams results back. Use this when you want to delegate a coding task to an external agent that has its own tools, file editing, and terminal access. If a default agent's binary is missing, the assistant installs it once via a sandboxed bun global install and proceeds in the same call; if that fails (e.g. bun unavailable), an actionable install hint is returned - do NOT alter `agents.<id>.command` to swap binaries.",
       "category": "orchestration",
       "risk": "high",
       "input_schema": {
@@ -20,6 +20,10 @@
           "cwd": {
             "type": "string",
             "description": "Working directory for the agent. This determines where the agent runs and where its session is stored. Set this to the project/repo root the user wants the agent to work in. Defaults to current conversation's working directory."
+          },
+          "model": {
+            "type": "string",
+            "description": "Model the agent should run on, passed ONLY when the user named one (e.g. 'opus' for Claude). Left off, a Claude session runs on Opus and every other agent on its own default. If the agent refuses the value, or advertises no model selector, the result says so and the session runs on its own model."
           }
         },
         "required": ["task"]

package/src/config/bundled-skills/app-builder/SKILL.md

@@ -60,7 +60,7 @@ Apps live under `/workspace/data/apps/`:
   <slug>.json          # App metadata
   <slug>/
     src/               # Source files (TSX) — what you write
-    dist/              # Compiled output — auto-generated by app_refresh
+    dist/              # Compiled output, generated by app_refresh or assistant apps refresh
     records/           # Data records (one JSON file per record)
   <slug>.preview       # Preview image (auto-generated)
 ```
@@ -156,9 +156,9 @@ Calculators, single-page tools, landing pages, and slide decks skip this — pas
 
 ### 3 — Create the app (scaffold, then expand)
 
-⚠️ **`app_create` is ONE-SHOT per build.** Call it exactly once. After it returns an `app_id`, all further changes go through `file_write` / `file_edit` + `app_refresh`. To start over: `app_delete(app_id)` first, then a fresh `app_create`.
+⚠️ **`app_create` is ONE-SHOT per build.** Call it exactly once. After it returns an `app_id`, all further changes go through `file_write` / `file_edit` and a single compile (`assistant apps refresh` or `app_refresh`). To start over: `app_delete(app_id)` first, then a fresh `app_create`.
 
-Apps are multi-file Preact + TSX projects; esbuild bundles automatically. Structure:
+Apps are multi-file Preact + TSX projects; esbuild bundles when you compile. Structure:
 
 ```
 src/
@@ -179,9 +179,9 @@ render(<App />, document.getElementById("app")!);
 
 1. **`app_create`** with a **4-file scaffold**: `src/index.html`, `src/main.tsx`, a **placeholder** `src/components/App.tsx` (`<div>Loading...</div>`), and an **empty** `src/styles.css`. The placeholders make the first compile clean — a 2-file scaffold leaves broken imports.
 2. **`file_write`** each real file, one per tool call, overwriting the placeholders and adding components.
-3. **`app_refresh`** ONCE at the end to compile.
+3. Compile ONCE at the end. File edits do not compile on their own. Use `assistant apps inspect <name>` to see whether source drifted, then `assistant apps refresh <name>` (or `app_refresh`).
 
-**Actually write the files.** Source code in reasoning/thinking is invisible to the app sandbox and is not a file write. Put every real file body in an `app_create.source_files`, `file_write`, `file_edit`, or `app_update.source_files` tool call, then verify the files exist before `app_refresh` when there is any doubt.
+**Actually write the files.** Source code in reasoning/thinking is invisible to the app sandbox and is not a file write. Put every real file body in an `app_create.source_files`, `file_write`, `file_edit`, or `app_update.source_files` tool call, then verify the files exist before compiling when there is any doubt.
 
 **Allowed packages** (esbuild-resolved, no CDN): `date-fns`, `chart.js`, `lodash-es`, `zod`, `clsx`. For icons, write inline `<svg>` markup directly — no icon package is bundled.
 
@@ -221,11 +221,14 @@ app_create({                         app_create({
 
 ### 4 — Compile
 
+File edits do not compile on their own. After ALL file writes, compile once:
+
 ```
-app_refresh(app_id)
+assistant apps inspect <name>
+assistant apps refresh <name>
 ```
 
-Call it ONCE, after ALL file writes — batching is required. If it fails, the response has error details; fix with `file_edit`, then `app_refresh` again.
+`assistant apps inspect` reports whether source changed since the last compile. `assistant apps refresh` compiles and refreshes open surfaces. `app_refresh(app_id)` also compiles. If compile fails, the response has error details; fix with `file_edit`, then compile again.
 
 ### 5 — Show the preview card
 
@@ -244,7 +247,7 @@ Editing an existing app means reusing its `app_id` — never `app_create`. Resol
 - **`app_update`** — rename or change description/schema, and/or rewrite files via `source_files`, in one call. It recompiles for you, so no separate `app_refresh` is needed. Use this instead of editing `<slug>.json` by hand.
 - **Full rebrand** — still iteration, edit the existing files.
 
-Then `app_refresh(app_id)` ONCE (unless you used `app_update`, which already recompiled). If the change is substantial, `app_open(app_id, open_mode: "preview")` for a fresh card; for small tweaks the existing card stays valid.
+Then compile ONCE (`assistant apps refresh <name>` or `app_refresh(app_id)`) unless you used `app_update`, which already recompiled. If the change is substantial, `app_open(app_id, open_mode: "preview")` for a fresh card; for small tweaks the existing card stays valid.
 
 > ⚠️ **`skill_load("app-builder")` is required before every `app_*` call** (including the first `app_create`). The skill can auto-unload between turns; without the reload, `app_refresh` / `app_open` error with "not currently active." It's idempotent — call it every time.
 
@@ -350,7 +353,7 @@ Slide decks are a different domain — skip app patterns (contextual headers, se
 ## SKILL COMPLETE WHEN
 
 - [ ] Request was scoped: personal build (sandbox) or complex/shippable (handed off to a project folder + coding agent)
-- [ ] **Sandbox path:** `app_create` returned an `app_id`; all files written via `file_write`; `app_refresh` ran ONCE clean; `app_open(open_mode: "preview")` rendered the card; user told what was built (3-6 bullets); iterations reflected live
+- [ ] **Sandbox path:** `app_create` returned an `app_id`; all files written via `file_write`; compile ran ONCE clean (`assistant apps refresh` or `app_refresh`); `app_open(open_mode: "preview")` rendered the card; user told what was built (3-6 bullets); iterations reflected live
 - [ ] **Handoff path:** project folder established; coding agent spawned via `acp_spawn({ task, cwd })`; user told work continues in the folder
 
 ---

package/src/config/bundled-skills/app-builder/references/CUSTOM_ROUTES.md

@@ -143,7 +143,7 @@ Older routes were written with a second `context` argument (`context.assistantEv
 
 ## Key rules
 
-- Always create the route handler files via `file_write` before calling `app_refresh`
+- Always create the route handler files via `file_write` before compiling (`app_refresh` or `assistant apps refresh`)
 - Export an optional `description` string for CLI discoverability (`assistant routes list`)
 - Handlers have full Node.js API access — `fs`, `path`, `crypto`, etc.
 - Handlers get a 30-second timeout per request

package/src/config/bundled-skills/computer-use/SKILL.md

@@ -23,6 +23,34 @@ The skill is internally preactivated for conversations with a connected desktop
 Tools in this skill are proxy tools. Execution is forwarded to a connected
 desktop client and is never handled locally by the assistant.
 
+## Observations
+
+Every computer-use step returns the accessibility tree. Every action also
+returns a screenshot taken after it ran (one at the end of a
+`computer_use_sequence`), so check it to see what your action did. An
+observation comes with a screenshot on a desktop's first look, when it is
+window-scoped, or when you pass `include_screenshot: true`. Ask for one whenever
+the tree is not enough to act on: a canvas, a game, a custom-drawn view, few or
+unlabeled controls, or a layout question.
+
+The tree is walked to a limited depth to keep steps fast, and says when it was
+cut off. If the element you need is not in it, call `computer_use_observe` with
+`full_tree: true`.
+
+## Typing is not sending
+
+Pressing enter in a chat, email or form usually sends or submits it, and that
+cannot be taken back. Send only when the user asked you to send, post or
+submit. When they asked you to type, write or draft something, type it and stop
+before pressing enter; tell them it is ready to send.
+
+## Batching known steps (macOS)
+
+When you already know the next few actions and none depends on seeing the
+result of the one before, send them as one `computer_use_sequence` call, for
+example opening a new window, typing a URL and pressing enter. Act one step at
+a time whenever the next action depends on what the screen shows.
+
 ## Window-scoped observation (macOS)
 
 `computer_use_observe` accepts optional `capture_window_id`, a native macOS
@@ -33,8 +61,7 @@ including secondary windows, even when another app covers the selected window.
 A missing window must not be replaced with a desktop capture.
 
 This is a **single observation**, not a session-wide privacy boundary: normal
-click/type/scroll and other action tools still return their normal desktop
-observations. Do not promise app-only capture for a whole control session.
+click/type/scroll and other action tools still observe the whole desktop. Do not promise app-only capture for a whole control session.
 The desktop must explicitly advertise `host_cu_window_capture` support on its
 connection; the daemon rejects older or unsupported clients before requesting
 any capture. Other desktop platforms reject this option.

package/src/config/bundled-skills/computer-use/TOOLS.json

@@ -15,6 +15,14 @@
             "maximum": 4294967295,
             "description": "macOS only: capture this native CGWindowID instead of the desktop, including only its accessibility tree. Obtain a current native window ID first; do not guess or use a browser tab ID. Applies to this observation only, not subsequent actions. Requires a desktop helper with window-capture support. Screenshot coordinates are window-relative; use accessibility element IDs for later actions, not desktop scaling."
           },
+          "include_screenshot": {
+            "type": "boolean",
+            "description": "Force a screenshot with this observation. The accessibility tree is returned every step and actions always return a screenshot of their result; ask for pixels on an observation whenever the tree is not enough to act on, such as a canvas, a game, a custom-drawn view, a window with few or unlabeled controls, or a question about layout."
+          },
+          "full_tree": {
+            "type": "boolean",
+            "description": "Walk the accessibility tree to full depth. Observations list the tree to a limited depth and say when it was cut off; pass this when the element you need is not in the tree."
+          },
           "target_client_id": {
             "type": "string",
             "description": "ID of the specific client to target. Required when multiple clients support host_cu; omit when only one is connected. Obtain IDs from `assistant clients list --capability host_cu`."
@@ -286,6 +294,97 @@
       "execution_target": "host",
       "supported_client_os": ["macos"]
     },
+    {
+      "name": "computer_use_sequence",
+      "description": "Run several computer-use actions you already know, in order, in one step, for example open an app, press cmd+n, type a URL and press enter. Use it when no action depends on seeing the result of the one before; otherwise act one step at a time. Element IDs refer to the latest observation, so use them only for actions that act before the screen changes. Stops at the first action that is refused or fails and reports which one. Returns one observation after the last action.",
+      "category": "computer-use",
+      "risk": "medium",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "actions": {
+            "type": "array",
+            "minItems": 1,
+            "maxItems": 10,
+            "description": "The actions to run, in order",
+            "items": {
+              "type": "object",
+              "properties": {
+                "action": {
+                  "type": "string",
+                  "enum": [
+                    "key",
+                    "type_text",
+                    "type",
+                    "click",
+                    "double_click",
+                    "right_click",
+                    "scroll",
+                    "wait",
+                    "open_app"
+                  ],
+                  "description": "The action to run"
+                },
+                "key": {
+                  "type": "string",
+                  "description": "key: key or shortcut to press (e.g. enter, tab, cmd+n)"
+                },
+                "text": {
+                  "type": "string",
+                  "description": "type_text (or type): the text to type"
+                },
+                "element_id": {
+                  "type": "integer",
+                  "description": "click, double_click, right_click, scroll: the [ID] of the element from the latest accessibility tree (preferred)"
+                },
+                "x": {
+                  "type": "integer",
+                  "description": "click, double_click, right_click, scroll: X coordinate on screen (fallback when no element_id)"
+                },
+                "y": {
+                  "type": "integer",
+                  "description": "click, double_click, right_click, scroll: Y coordinate on screen (fallback when no element_id)"
+                },
+                "direction": {
+                  "type": "string",
+                  "enum": ["up", "down", "left", "right"],
+                  "description": "scroll: scroll direction"
+                },
+                "amount": {
+                  "type": "integer",
+                  "description": "scroll: scroll amount (1-10)"
+                },
+                "duration_ms": {
+                  "type": "integer",
+                  "description": "wait: milliseconds to wait"
+                },
+                "app_name": {
+                  "type": "string",
+                  "description": "open_app: the name of the application to open (e.g. \"Google Chrome\")"
+                },
+                "reasoning": {
+                  "type": "string",
+                  "description": "Optional: why this action"
+                }
+              },
+              "required": ["action"]
+            }
+          },
+          "reasoning": {
+            "type": "string",
+            "description": "Optional: what these actions do together. Reasoning on each action works too"
+          },
+          "target_client_id": {
+            "type": "string",
+            "description": "ID of the specific client to target. Required when multiple clients support host_cu; omit when only one is connected. Obtain IDs from `assistant clients list --capability host_cu`."
+          }
+        },
+        "required": ["actions"]
+      },
+      "executor": "tools/computer-use-sequence.ts",
+      "execution_target": "host",
+      "supported_client_os": ["macos"]
+    },
     {
       "name": "computer_use_done",
       "description": "Signal that the computer use task is complete. Provide a summary of what was accomplished. This ends the computer use session.",

package/src/config/bundled-skills/computer-use/tools/computer-use-sequence.ts

@@ -0,0 +1,12 @@
+import { forwardComputerUseProxyTool } from "../../../../tools/computer-use/skill-proxy-bridge.js";
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+
+export async function run(
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  return forwardComputerUseProxyTool("computer_use_sequence", input, context);
+}

package/src/config/bundled-skills/media-processing/services/preprocess.ts

@@ -26,6 +26,7 @@ import {
   FFMPEG_PREPROCESS_TIMEOUT_MS,
   spawnWithTimeout,
 } from "../../../../util/spawn.js";
+import { safeStringSlice } from "../../../../util/unicode.js";
 import { transcribeSegmentAudio } from "./audio-transcribe.js";
 
 // ---------------------------------------------------------------------------
@@ -691,7 +692,7 @@ export async function preprocessForAsset(
     const msg = (err as Error).message;
     updateProcessingStage(stage.id, {
       status: "failed",
-      lastError: msg.slice(0, 500),
+      lastError: safeStringSlice(msg, 0, 500),
     });
     throw err;
   }

package/src/config/bundled-skills/media-processing/services/processing-pipeline.ts

@@ -21,6 +21,7 @@ import {
   updateProcessingStage,
 } from "../../../../persistence/media-store.js";
 import { computeRetryDelay, sleep } from "../../../../util/retry.js";
+import { safeStringSlice } from "../../../../util/unicode.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -224,7 +225,7 @@ export async function runPipeline(
         onProgress?.(`Completed stage: ${stageName}`);
         break;
       } catch (err) {
-        const errorMsg = (err as Error).message.slice(0, 500);
+        const errorMsg = safeStringSlice((err as Error).message, 0, 500);
         onProgress?.(
           `Stage ${stageName} failed (attempt ${attempt + 1}/${maxRetries + 1}): ${errorMsg}`,
         );

package/src/config/bundled-skills/media-processing/tools/generate-clip.ts

@@ -26,6 +26,7 @@ import {
   FFPROBE_TIMEOUT_MS,
   spawnWithTimeout,
 } from "../../../../util/spawn.js";
+import { safeStringSlice } from "../../../../util/unicode.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -268,7 +269,7 @@ export async function run(
       );
       if (reencodeResult.exitCode !== 0) {
         return {
-          content: `ffmpeg clip extraction failed (both stream copy and re-encode): ${reencodeResult.stderr.slice(0, 500)}`,
+          content: `ffmpeg clip extraction failed (both stream copy and re-encode): ${safeStringSlice(reencodeResult.stderr, 0, 500)}`,
           isError: true,
         };
       }

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

@@ -14,7 +14,7 @@ metadata:
 
 You are a unified messaging assistant with access to multiple platforms (Gmail, Outlook, Telegram, and more). Use the messaging tools to help users read, search, organize, draft, and send messages across all connected platforms.
 
-**Slack is not handled by this skill.** Slack messaging (send, read, search) is handled by the **slack** skill, which uses the Slack Web API directly via CLI. Do not use messaging tools with `platform: "slack"`.
+**On a channel, `messaging_send` posts through the channel's own transport.** Slack, Telegram, Discord, and WhatsApp all go out that way: threaded where you name a `thread_id`, rendered the way a reply is, and recorded in the chat's conversation once the channel acknowledges the post. Reading and searching Slack are not part of this skill; load the **slack** skill, which uses the Slack Web API for those.
 
 ## External Identity
 
@@ -34,7 +34,7 @@ When a platform is connected (auth test succeeds), always use the messaging API
 
 On Gmail and Outlook, `messaging_send` creates a real mailbox draft for review. It does not send. Recipients are optional on Outlook: if the user has not named a To address, still create the draft (use a non-email `conversation_id` such as `drafts`) and tell them only after the tool returns a draft ID. If draft creation fails or is interrupted, say so and offer the email copy in chat. Do not claim a draft exists until the tool succeeds.
 
-**Exception: Slack.** Slack messaging should use the Slack Web API directly via CLI, not messaging tools. See the **slack** skill for details.
+**On a channel, the send goes out as the assistant's own bot**, so `account` does not apply and is refused. It carries text only: attachments stay on Gmail and Outlook. The post is recorded in the chat's conversation, which is what lets `recall` find it later.
 
 ## Connection Setup
 
@@ -64,7 +64,7 @@ When the user asks to "connect my email", "set up email", "manage my email", or
 
 ### Slack
 
-Slack is **not** handled by this skill. For Slack setup, load the **slack-app-setup** skill directly. For Slack messaging, use the **slack** skill which accesses the Slack Web API via CLI.
+For Slack setup, load the **slack-app-setup** skill directly. `messaging_send` posts to a Slack chat through the channel's transport. Reading, searching, reactions, and file upload live in the **slack** skill, which uses the Slack Web API.
 
 ### Telegram
 

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

@@ -125,7 +125,7 @@
     },
     {
       "name": "messaging_send",
-      "description": "Send a message, reply to a thread, or create a draft. On Gmail and Outlook, always creates a real mailbox draft for review (recipients optional on Outlook). Supports replies (via thread_id), attachments (via attachment_paths, Gmail and Outlook), and all messaging platforms.",
+      "description": "Send a message, reply to a thread, or create a draft. On Gmail and Outlook, always creates a real mailbox draft for review (recipients optional on Outlook). On a channel (Slack, Telegram, Discord, WhatsApp) the message goes out as the channel's own bot, threaded when thread_id names a thread. Supports replies (via thread_id) and attachments (via attachment_paths, Gmail and Outlook).",
       "category": "messaging",
       "risk": "high",
       "input_schema": {
@@ -133,11 +133,11 @@
         "properties": {
           "platform": {
             "type": "string",
-            "description": "Platform (e.g. \"gmail\"). Auto-detected if only one is connected. Slack is not supported — use the Slack Web API directly."
+            "description": "Platform (e.g. \"gmail\", \"slack\", \"telegram\", \"discord\"). Auto-detected if only one is connected."
           },
           "account": {
             "type": "string",
-            "description": "Email address of the account to use. Required when multiple accounts are connected for the same platform. If omitted, uses the most recently connected account."
+            "description": "Email address of the account to use. Required when multiple accounts are connected for the same email platform. If omitted, uses the most recently connected account. Does not apply to a channel: a channel send goes out as the channel's own bot."
           },
           "conversation_id": {
             "type": "string",