@vellumai/assistant 0.12.0 → 0.12.1-dev.202609141913.5e16607

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/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",

package/src/config/bundled-skills/messaging/tools/messaging-send.ts

@@ -1,7 +1,6 @@
 import { readFile } from "node:fs/promises";
 import { basename } from "node:path";
 
-import { isChannelId } from "../../../../channels/types.js";
 import type { OutboundAttachment } from "../../../../messaging/provider-types.js";
 import {
   createDraft,
@@ -16,11 +15,10 @@ import {
   toOutlookFileAttachments,
 } from "../../../../messaging/providers/outlook/client.js";
 import type { OutlookDraftMessage } from "../../../../messaging/providers/outlook/types.js";
-import { resolveProactiveHomeConversation } from "../../../../notifications/conversation-pairing.js";
-import { recordDeliveredChannelPost } from "../../../../notifications/delivered-post-record.js";
-import { getConversation } from "../../../../persistence/conversation-crud.js";
-import { syncMessageToDisk } from "../../../../persistence/conversation-disk-view.js";
-import { normalizeExternalThreadId } from "../../../../persistence/external-conversation-store.js";
+import {
+  isProactivelyAddressable,
+  sendChannelText,
+} from "../../../../runtime/channel-send.js";
 import {
   isAbortLikeError,
   throwIfCancelled,
@@ -29,7 +27,6 @@ import type {
   ToolContext,
   ToolExecutionResult,
 } from "../../../../tools/types.js";
-import { getLogger } from "../../../../util/logger.js";
 import { guessMimeType } from "../../../../util/mime-type.js";
 import {
   err,
@@ -42,8 +39,6 @@ import {
   resolveProvider,
 } from "./shared.js";
 
-const log = getLogger("messaging-send");
-
 /** Read attachment files from disk into in-memory parts for outbound sending. */
 async function readAttachments(paths: string[]): Promise<OutboundAttachment[]> {
   return Promise.all(
@@ -58,123 +53,6 @@ async function readAttachments(paths: string[]): Promise<OutboundAttachment[]> {
 /** Email providers that accept file attachments on outbound sends. */
 const ATTACHMENT_CAPABLE_PLATFORMS = new Set(["gmail", "outlook"]);
 
-/**
- * Record a message the provider just accepted where the chat's proactive
- * posts live, so the chat's own conversation and `recall` can see what was
- * sent from elsewhere (a scheduled run, another conversation).
- *
- * Only channel providers have such a home; an email send is tool-mediated
- * and has no chat conversation. The row is written after the provider
- * returned the message id, never before, and carries that id on its
- * envelope and in `channel_outbound_posts` like every other post the daemon
- * makes.
- *
- * A send into the sending turn's own chat writes no row: its tool call and
- * result already sit in that conversation's history, and a second assistant
- * row beside the tool pair would break history repair. Whether the send is
- * "its own" is decided by the delivered target against the turn, not by the
- * home: the turn arrived on a channel, in a chat, in a thread (the turn-local
- * snapshot on the tool context), and a post the provider delivered to exactly
- * that place is a same-conversation send even when the chat's home resolves
- * elsewhere. The delivered thread is the one the provider reports, not the
- * one requested: a provider that ignores the request lands the post in the
- * thread-less chat, and the record must say so; a post into a thread is
- * recorded in the thread's own conversation, where its replies arrive. The home
- * comparison stays as the second test, for a sender that arrived through no
- * channel but is the home. The post is then in the outbound index only
- * through no path, which is the same class as a raw API send and is deferred
- * with it.
- *
- * Failures here never fail the send: the message is already out.
- */
-async function recordSentChannelPost(params: {
-  providerId: string;
-  externalChatId: string;
-  /** The thread the provider delivered into, as it reported it. */
-  deliveredThreadId: string | undefined;
-  text: string;
-  providerMessageId: string;
-  sender: ToolContext;
-}): Promise<void> {
-  const { providerId, externalChatId, sender } = params;
-  if (!isChannelId(providerId) || !params.providerMessageId) {
-    return;
-  }
-  try {
-    if (
-      isSendIntoOwnChat(
-        sender,
-        providerId,
-        externalChatId,
-        params.deliveredThreadId,
-      )
-    ) {
-      return;
-    }
-    const home = await resolveProactiveHomeConversation({
-      sourceChannel: providerId,
-      externalChatId,
-      threadId: params.deliveredThreadId,
-      source: "notification",
-      conversationType: "background",
-      title: `Messages to ${externalChatId}`,
-    });
-    if (home.conversationId === sender.conversationId) {
-      return;
-    }
-    const recorded = await recordDeliveredChannelPost({
-      conversationId: home.conversationId,
-      channel: providerId,
-      externalChatId,
-      ...(params.deliveredThreadId
-        ? { threadId: params.deliveredThreadId }
-        : {}),
-      text: params.text,
-      providerMessageId: params.providerMessageId,
-      crossPostedFrom: sender.conversationId,
-    });
-    const homeConversation = getConversation(home.conversationId);
-    if (homeConversation) {
-      syncMessageToDisk(
-        home.conversationId,
-        recorded.messageId,
-        homeConversation.createdAt,
-      );
-    }
-  } catch (e) {
-    log.warn(
-      { err: e, provider: providerId, externalChatId },
-      "Failed to record the sent message in the chat's conversation",
-    );
-  }
-}
-
-/**
- * True when the delivered chat and thread are the ones the sending turn
- * arrived in. Reads the turn-local snapshot the tool context carries
- * (`executionChannel`, `requesterChatId`, `sourceThreadId`), never the live
- * binding, which a concurrent inbound can rewrite while this call runs.
- * Thread ids compare in the binding store's normalized form, so an absent
- * thread on both sides matches and a thread-less delivery never matches a
- * turn that arrived in a thread.
- */
-function isSendIntoOwnChat(
-  sender: ToolContext,
-  channel: string,
-  externalChatId: string,
-  deliveredThreadId: string | undefined,
-): boolean {
-  if (!sender.executionChannel || !sender.requesterChatId) {
-    return false;
-  }
-  return (
-    sender.executionChannel === channel &&
-    sender.requesterChatId === externalChatId &&
-    normalizeExternalThreadId(sender.sourceThreadId) ===
-      normalizeExternalThreadId(deliveredThreadId)
-  );
-}
-
 export async function run(
   input: Record<string, unknown>,
   context: ToolContext,
@@ -197,9 +75,62 @@ export async function run(
   throwIfCancelled(context);
 
   try {
-    const provider = await resolveProvider(platform);
+    // A channel whose transport can be addressed from a named chat is sent
+    // through the transport, which is the one send implementation for that
+    // channel, records what it sent, and reaches channels with no messaging
+    // provider at all. A platform named outright is checked first; one
+    // auto-detected from the connected providers is checked the same way.
+    const namedChannel =
+      platform && isProactivelyAddressable(platform) ? platform : undefined;
+    const provider = namedChannel ? undefined : await resolveProvider(platform);
+    const channel =
+      namedChannel ??
+      (provider && isProactivelyAddressable(provider.id)
+        ? provider.id
+        : undefined);
+
+    if (channel) {
+      if (attachmentPaths?.length) {
+        return err("Attachments are only supported on Gmail and Outlook.");
+      }
+      // A channel's transport sends as the channel's one bot identity, so an
+      // account cannot select where the send goes out from. Refusing is
+      // safer than silently sending from the default account.
+      if (input.account) {
+        return err(
+          `account does not apply to ${channel}: a channel send goes out as the channel's own bot.`,
+        );
+      }
+      // Recheck: provider resolution above is an await, and this posts to
+      // the channel.
+      throwIfCancelled(context);
+      const sent = await sendChannelText({
+        channel,
+        target: {
+          kind: "chat",
+          chatId: conversationId,
+          ...(threadId ? { threadId } : {}),
+        },
+        text,
+        renderRichly: true,
+        assistantId: context.assistantId,
+        sender: {
+          conversationId: context.conversationId,
+          executionChannel: context.executionChannel,
+          requesterChatId: context.requesterChatId,
+          sourceThreadId: context.sourceThreadId,
+        },
+      });
+      const threadSuffix = sent.threadId
+        ? `, "thread_id": "${sent.threadId}"`
+        : "";
+      return ok(`Message sent (ID: ${sent.lastMessageId}${threadSuffix}).`);
+    }
+    if (!provider) {
+      throw new Error(`Messaging provider "${platform}" not found.`);
+    }
 
-    // Reject attachments on platforms that can't carry them (e.g. Telegram, WhatsApp).
+    // Reject attachments on platforms that can't carry them.
     if (
       attachmentPaths?.length &&
       !ATTACHMENT_CAPABLE_PLATFORMS.has(provider.id)
@@ -426,7 +357,14 @@ export async function run(
       );
     }
 
-    // Non-email platforms
+    // A provider with a send of its own and no direct transport (a plugin's,
+    // for instance). Its send is tool-mediated and has no chat conversation
+    // to record in.
+    if (!provider.sendMessage) {
+      return err(
+        `${provider.displayName} cannot send from here: it has no send of its own and no channel transport to address.`,
+      );
+    }
     const attachments = attachmentPaths?.length
       ? await readAttachments(attachmentPaths)
       : undefined;
@@ -442,16 +380,6 @@ export async function run(
     const threadSuffix = result.threadId
       ? `, "thread_id": "${result.threadId}"`
       : "";
-
-    await recordSentChannelPost({
-      providerId: provider.id,
-      externalChatId: conversationId,
-      deliveredThreadId: result.threadId,
-      text,
-      providerMessageId: result.id,
-      sender: context,
-    });
-
     return ok(`Message sent (ID: ${result.id}${threadSuffix}).`);
   } catch (e) {
     // A cancelled turn is not a send failure: let it reach the executor's

package/src/config/bundled-skills/phone-calls/references/TRANSCRIPTS.md

@@ -23,7 +23,7 @@ sqlite3 "$VELLUM_WORKSPACE_DIR/data/db/assistant.db" \
 
 This returns all messages in chronological order with:
 
-- `role: "user"` - caller speech (prefixed with `[SPEAKER]` tags) and system events
+- `role: "user"` - caller speech and system events
 - `role: "assistant"` - assistant responses, including `text` content and any `tool_use`/`tool_result` blocks
 
 ## Quick one-liner for the most recent call

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

@@ -209,7 +209,6 @@ When you mention a schedule or a conversation it owns in Vellum chat, write a ma
 
 Use these paths only in Vellum chat. Do not use them in Slack, Telegram, Discord, email, or notifications. Those surfaces cannot navigate `/assistant/...` routes.
 
-
 ### Anchored & Ambiguous Relative Time
 
 Phrases like "at the 45 minute mark", "at the top of the hour", "at noon", or "20 minutes in" are **clock-position or anchored relative time** expressions. Do NOT treat them as offsets from now.
@@ -256,13 +255,13 @@ Write the delivery step into the `message` when you create the schedule — not
 
 A schedule whose message has no delivery step is not finished. Before calling `schedule_create` in `execute` mode, read your own message back and check that it says where the output goes.
 
-There is a safety net, and it is not a substitute for the above. When an execute-mode run finishes with user-facing output and delivered nothing — no `assistant notifications send`, no `messaging_send`, no Slack `chat.postMessage` — the assistant sends a notification carrying the run's final reply, so a schedule can no longer run and leave no trace. It fires on the raw reply — whatever the run happened to end on, at whatever length. An authored delivery step gets a title and body you chose, sent at the moment you chose. Rely on the net and you get the machine's guess instead.
+There is a safety net, and it is not a substitute for the above. When an execute-mode run finishes with user-facing output and nothing delivered it, the assistant sends a notification carrying the run's final reply, so a schedule can no longer run and leave no trace. `messaging_send` counts as a delivery only when the call reported success, and `assistant notifications send` once the notification pipeline has taken it: a send the channel refused, or one that never reported at all, leaves the run eligible for the net, so the failure reaches you instead of vanishing into a conversation nobody has open. A Slack `chat.postMessage` never counts, because Slack refuses a call with a successful HTTP status and `ok: false` in the body, so the command succeeding proves nothing; a run that posts Block Kit that way also gets the net's notification. It fires on the raw reply, whatever the run happened to end on, at whatever length. An authored delivery step gets a title and body you chose, sent at the moment you chose. Rely on the net and you get the machine's guess instead.
 
 Choose the right delivery tool based on the content:
 
-- **Rich content** (digests, summaries, reports): For Gmail, use `messaging_send` with the target platform and conversation ID. For Slack, call `chat.postMessage` through `assistant oauth request`, with the provider the **slack** skill says to pass for posting on this workspace (`slack_channel` when the bot is set up; where only the `slack` integration exists, the skill says to tell the user before posting as them), never through `curl` or a revealed token. This preserves the full content and posts directly.
+- **Rich content** (digests, summaries, reports): Use `messaging_send` with the target platform and conversation ID. It reaches Gmail or Outlook as a draft, and posts to a Slack, Telegram, or Discord chat through that channel's own transport, where the post is recorded and can be found again afterwards. Reach for `chat.postMessage` through `assistant oauth request` only for a Block Kit shape `messaging_send` cannot carry, with the provider the **slack** skill says to pass for posting on this workspace (`slack_channel` when the bot is set up; where only the `slack` integration exists, the skill says to tell the user before posting as them), never through `curl` or a revealed token. Either way the full content posts directly.
 - **Short alerts** (status updates, completion notices): Use `assistant notifications send` via `bash` to let the notification router pick the best channel. Note: the router's decision engine rewrites content into short alerts, so it is not suitable for rich content.
 
 Example schedule message for a Slack digest:
 
-> "Scan my Slack channels for the last 24 hours using `assistant oauth request` for every Slack Web API call, with the provider the slack skill names for this workspace, then post the summary with `chat.postMessage` through the same command to the channel the user named."
+> "Scan my Slack channels for the last 24 hours using `assistant oauth request` for every Slack Web API read, with the provider the slack skill names for this workspace, then post the summary to the channel the user named with `messaging_send`, passing `platform: \"slack\"` and that channel's ID."

package/src/config/bundled-skills/screen-annotation/SKILL.md

@@ -124,7 +124,14 @@ their ear. Silence is the cue that it is their turn.
 
 **Advance on evidence, not on time.** Move to the next step when a fresh
 picture shows this one done, or when they tell you it is. Do not move on
-because a plausible amount of time has passed. If the next picture shows the
+because a plausible amount of time has passed.
+
+The most direct telling is automatic. When the user clicks the control an
+arrow is pointing at, a message arrives as their turn saying they clicked it,
+by name, and that mark comes down on its own. Treat it as the step done: say
+what comes next and point at it. Nothing arrives for a click anywhere else,
+and nothing arrives for a ring, so for those the picture and their words are
+still the evidence. If the next picture shows the
 step not done, or done to the wrong thing, point at the same place again with
 a shorter caption and say what you saw. Pointing at the next step while the
 previous one is still open is how someone ends up two steps behind a mark.

package/src/config/bundled-skills/screen-annotation/tools/screen-annotation.test.ts

@@ -53,7 +53,10 @@ describe("screen_point_at", () => {
     );
 
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("connected desktop client");
+    expect(result.content).toContain(
+      "The Vellum desktop app is needed to view or control your screen",
+    );
+    expect(result.content).toContain("https://www.vellum.ai/downloads");
   });
 
   /** Drawing on the user's screen is a side effect a stopped turn must not have. */

package/src/config/bundled-skills/skill-management/TOOLS.json

@@ -3,7 +3,7 @@
   "tools": [
     {
       "name": "scaffold_managed_skill",
-      "description": "Create or update a managed skill in {workspaceDir}/skills. The skill becomes available for skill_load when a valid top-level SKILL.md is written under the skill directory. Never persist a skill without explicit user consent. Before persisting, test the snippet: write to a temp file with bash and run with `bun run /tmp/vellum-eval/snippet.ts`. Iterate up to 3 attempts, then ask the user. Clean up temp files after. Do not use file_write for temp files outside the working directory. After a skill is written, the next turn may run in a recreated conversation due to file-watcher eviction - continue normally.",
+      "description": "Create or update a managed skill in {workspaceDir}/skills. The skill becomes available for skill_load when a valid top-level SKILL.md is written under the skill directory. Never persist a skill without explicit user consent. Before persisting, test the snippet: write to a temp file with bash and run with `bun run /tmp/vellum-eval/snippet.ts`. Iterate up to 3 attempts, then ask the user. Clean up temp files after. Do not use file_write for temp files outside the working directory.",
       "category": "skills",
       "risk": "high",
       "input_schema": {
@@ -92,7 +92,7 @@
     },
     {
       "name": "delete_managed_skill",
-      "description": "Delete a managed skill directory from {workspaceDir}/skills. Never delete a skill without explicit user confirmation. After deletion, the next turn may run in a recreated conversation due to file-watcher eviction - continue normally.",
+      "description": "Delete a managed skill directory from {workspaceDir}/skills. Never delete a skill without explicit user confirmation.",
       "category": "skills",
       "risk": "high",
       "input_schema": {