@vellumai/assistant 0.12.1-staging.1 → 0.12.1

package/src/config/acp-defaults.test.ts

@@ -13,17 +13,15 @@ describe("DEFAULT_ACP_AGENT_PROFILES", () => {
     ]);
   });
 
-  test("claude profile uses the @agentclientprotocol adapter binary on opus", () => {
+  test("claude profile uses the @agentclientprotocol adapter binary", () => {
     expect(DEFAULT_ACP_AGENT_PROFILES.claude).toEqual({
       command: "claude-agent-acp",
       args: [],
       description: "Claude Code (via @agentclientprotocol/claude-agent-acp)",
-      model: "opus",
     });
   });
 
   test("codex profile uses the @agentclientprotocol adapter binary", () => {
-    // No model: Codex aliases are its own, so the adapter's default stands.
     expect(DEFAULT_ACP_AGENT_PROFILES.codex).toEqual({
       command: "codex-acp",
       args: [],
@@ -46,19 +44,11 @@ describe("DEFAULT_ACP_AGENT_PROFILES", () => {
 describe("DEFAULT_AGENT_NPM_PACKAGES", () => {
   test("is keyed by command name with the canonical npm package", () => {
     expect(DEFAULT_AGENT_NPM_PACKAGES).toEqual({
-      "claude-agent-acp": "@agentclientprotocol/claude-agent-acp@0.75.1",
-      "codex-acp": "@agentclientprotocol/codex-acp@1.10.0",
+      "claude-agent-acp": "@agentclientprotocol/claude-agent-acp",
+      "codex-acp": "@agentclientprotocol/codex-acp",
     });
   });
 
-  test("every package spec pins an exact version", () => {
-    // A bare name would let a clean install resolve whatever npm calls
-    // latest, which is what the repo's pinning rule exists to prevent.
-    for (const spec of Object.values(DEFAULT_AGENT_NPM_PACKAGES)) {
-      expect(spec).toMatch(/^@?[^@]+@\d+\.\d+\.\d+$/);
-    }
-  });
-
   test("every default profile's command has a matching npm package", () => {
     for (const profile of Object.values(DEFAULT_ACP_AGENT_PROFILES)) {
       expect(DEFAULT_AGENT_NPM_PACKAGES[profile.command]).toBeDefined();

package/src/config/acp-defaults.ts

@@ -1,11 +1,5 @@
 import type { AcpAgentConfig } from "./acp-schema.js";
 
-/**
- * A bundled profile always names its command; a user entry for the same id
- * may omit `command` and inherit this one.
- */
-export type AcpAgentProfile = AcpAgentConfig & { command: string };
-
 // Shared frozen empty args array — these defaults are read by every ACP spawn,
 // so a single accidental `args.push(...)` from one caller would corrupt every
 // subsequent read. Cast through `unknown` because `AcpAgentConfig.args` is
@@ -19,22 +13,17 @@ const FROZEN_EMPTY_ARGS = Object.freeze([] as string[]) as unknown as string[];
  * falls back to this map so common agents like `claude` and `codex` Just Work
  * without requiring per-user config.
  *
- * A profile's `model` is the model a session of that agent starts on when the
- * ask names none, and is the rung `acp.agents.<id>.model` fills: a user config
- * entry that names a model overrides it, one that omits it inherits it.
- *
- * Keyed by agent id. Deeply frozen: the outer object, each profile, and the
- * `args` arrays, so mutation throws in strict mode rather than silently
+ * Keyed by agent id. Deeply frozen — the outer object, each profile, and the
+ * `args` arrays — so mutation throws in strict mode rather than silently
  * corrupting the shared defaults.
  */
 export const DEFAULT_ACP_AGENT_PROFILES: Readonly<
-  Record<string, AcpAgentProfile>
+  Record<string, AcpAgentConfig>
 > = Object.freeze({
   claude: Object.freeze({
     command: "claude-agent-acp",
     args: FROZEN_EMPTY_ARGS,
     description: "Claude Code (via @agentclientprotocol/claude-agent-acp)",
-    model: "opus",
   }),
   codex: Object.freeze({
     command: "codex-acp",
@@ -44,21 +33,15 @@ export const DEFAULT_ACP_AGENT_PROFILES: Readonly<
 });
 
 /**
- * Single source of truth for adapter binary → npm package spec. Automatic
+ * Single source of truth for adapter binary → npm package name. Automatic
  * installation and the resolver's install hints use this map, so a new
  * adapter only needs one entry here.
  *
  * Keyed by command name (not agent id) so the mapping follows the binary
  * regardless of how a user's config aliases an agent.
- *
- * Values carry an exact version, so a clean install lands the adapter version
- * the daemon was tested against instead of whatever npm calls latest today.
- * An adapter already on PATH is left alone: installation runs only when
- * preflight found no binary at all, so this never moves a version the user
- * installed themselves.
  */
 export const DEFAULT_AGENT_NPM_PACKAGES: Readonly<Record<string, string>> =
   Object.freeze({
-    "claude-agent-acp": "@agentclientprotocol/claude-agent-acp@0.75.1",
-    "codex-acp": "@agentclientprotocol/codex-acp@1.10.0",
+    "claude-agent-acp": "@agentclientprotocol/claude-agent-acp",
+    "codex-acp": "@agentclientprotocol/codex-acp",
   });

package/src/config/acp-schema.ts

@@ -1,15 +1,8 @@
 import { z } from "zod";
 
-import { DEFAULT_ACP_AGENT_PROFILES } from "./acp-defaults.js";
-
-export const AcpAgentConfigSchema = z
+const AcpAgentConfigSchema = z
   .object({
-    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",
-      ),
+    command: z.string().describe("Command to spawn the ACP agent process"),
     args: z
       .array(z.string())
       .default([])
@@ -22,12 +15,6 @@ export 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");
 
@@ -43,21 +30,6 @@ 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,18 +23,6 @@ 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.
@@ -47,23 +35,21 @@ 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 the pinned version 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 it once 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 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.
+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.
 
 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). Install the pinned version below rather than `@latest`, so the adapter matches what the assistant was built against.
+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).
 
 ```bash
-bun add -g @agentclientprotocol/claude-agent-acp@0.75.1   # claude
-bun add -g @agentclientprotocol/codex-acp@1.10.0          # codex
+bun add -g @agentclientprotocol/claude-agent-acp   # claude
+bun add -g @agentclientprotocol/codex-acp          # codex
 ```
 
 ## Claude setup
@@ -98,14 +84,20 @@ 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 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.
+- 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.
 - 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
 
-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.
+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
+```
 
-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.
+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.
 
 ## 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 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.",
+      "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.",
       "category": "orchestration",
       "risk": "high",
       "input_schema": {
@@ -20,10 +20,6 @@
           "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, generated by app_refresh or assistant apps refresh
+    dist/              # Compiled output — auto-generated by app_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` and a single compile (`assistant apps refresh` or `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` + `app_refresh`. To start over: `app_delete(app_id)` first, then a fresh `app_create`.
 
-Apps are multi-file Preact + TSX projects; esbuild bundles when you compile. Structure:
+Apps are multi-file Preact + TSX projects; esbuild bundles automatically. 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. 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`).
+3. **`app_refresh`** ONCE at the end to compile.
 
-**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.
+**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.
 
 **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,14 +221,11 @@ app_create({                         app_create({
 
 ### 4 — Compile
 
-File edits do not compile on their own. After ALL file writes, compile once:
-
 ```
-assistant apps inspect <name>
-assistant apps refresh <name>
+app_refresh(app_id)
 ```
 
-`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.
+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.
 
 ### 5 — Show the preview card
 
@@ -247,7 +244,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 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.
+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.
 
 > ⚠️ **`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.
 
@@ -353,7 +350,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`; 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
+- [ ] **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
 - [ ] **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 compiling (`app_refresh` or `assistant apps refresh`)
+- Always create the route handler files via `file_write` before calling `app_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/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). 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).",
+      "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.",
       "category": "messaging",
       "risk": "high",
       "input_schema": {
@@ -133,11 +133,11 @@
         "properties": {
           "platform": {
             "type": "string",
-            "description": "Platform (e.g. \"gmail\", \"slack\", \"telegram\", \"discord\"). Auto-detected if only one is connected."
+            "description": "Platform (e.g. \"gmail\"). Auto-detected if only one is connected. Slack is not supported — use the Slack Web API directly."
           },
           "account": {
             "type": "string",
-            "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."
+            "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."
           },
           "conversation_id": {
             "type": "string",

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

@@ -1,6 +1,7 @@
 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,
@@ -15,10 +16,11 @@ import {
   toOutlookFileAttachments,
 } from "../../../../messaging/providers/outlook/client.js";
 import type { OutlookDraftMessage } from "../../../../messaging/providers/outlook/types.js";
-import {
-  isProactivelyAddressable,
-  sendChannelText,
-} from "../../../../runtime/channel-send.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 {
   isAbortLikeError,
   throwIfCancelled,
@@ -27,6 +29,7 @@ import type {
   ToolContext,
   ToolExecutionResult,
 } from "../../../../tools/types.js";
+import { getLogger } from "../../../../util/logger.js";
 import { guessMimeType } from "../../../../util/mime-type.js";
 import {
   err,
@@ -39,6 +42,8 @@ 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(
@@ -53,6 +58,123 @@ 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,
@@ -75,62 +197,9 @@ export async function run(
   throwIfCancelled(context);
 
   try {
-    // 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.`);
-    }
+    const provider = await resolveProvider(platform);
 
-    // Reject attachments on platforms that can't carry them.
+    // Reject attachments on platforms that can't carry them (e.g. Telegram, WhatsApp).
     if (
       attachmentPaths?.length &&
       !ATTACHMENT_CAPABLE_PLATFORMS.has(provider.id)
@@ -357,14 +426,7 @@ export async function run(
       );
     }
 
-    // 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.`,
-      );
-    }
+    // Non-email platforms
     const attachments = attachmentPaths?.length
       ? await readAttachments(attachmentPaths)
       : undefined;
@@ -380,6 +442,16 @@ 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 and system events
+- `role: "user"` - caller speech (prefixed with `[SPEAKER]` tags) 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/screen-annotation/SKILL.md

@@ -124,14 +124,7 @@ 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.
-
-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
+because a plausible amount of time has passed. 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.