@vellumai/assistant 0.11.8 → 0.11.9-staging.2

package/src/providers/inference/auth.ts

@@ -144,12 +144,12 @@ export type ConnectionProvider = string;
 export const CHATGPT_SUBSCRIPTION_CONNECTION_NAME = "chatgpt-subscription";
 
 /**
- * Provider values that are routing identities rather than adapters: the
- * value names HOW a request routes (vellum = the platform-managed route,
- * chatgpt = the subscription route), and dispatch translates it to a real
- * upstream + connection row per-request (resolveRoutingIdentity). Identity
- * profiles carry no provider_connection; backfill and materialization must
- * not stamp one.
+ * Provider values that name a routing identity. Dispatch translates them
+ * to a connection row and an upstream factory id via
+ * `resolveRoutingIdentity`. `chatgpt` has no adapter factory (upstream is
+ * always openai). `vellum` is also a catalog factory id when the derived
+ * upstream is vellum. Identity profiles carry no provider_connection;
+ * backfill and materialization must not stamp one.
  */
 export const ROUTING_IDENTITY_PROVIDERS: ReadonlySet<string> = new Set([
   "vellum",

package/src/providers/media-resolve.ts

@@ -28,6 +28,7 @@ import {
   sniffImageMimeType,
 } from "../util/image-conversion.js";
 import { getLogger } from "../util/logger.js";
+import { keepFileAsWorkspaceRef } from "./content-block-size.js";
 import {
   attachmentIdFragment,
   type Base64MediaSource,
@@ -265,6 +266,16 @@ async function resolveImageBlock(
 }
 
 function resolveFileBlock(block: FileContent): ContentBlock {
+  // Video and over-cap text stay a workspace file. Do not load bytes or
+  // carry extracted_text into the provider prompt: serializers name the
+  // file and stop there.
+  if (keepFileAsWorkspaceRef(block.source)) {
+    if (block.extracted_text === undefined) {
+      return block;
+    }
+    const { extracted_text: _extracted, ...rest } = block;
+    return rest;
+  }
   if (block.source.type === "base64") {
     return block;
   }
@@ -356,6 +367,9 @@ function contentNeedsResolution(
         : base64ImageNeedsRewrite(block.source, options);
     }
     if (block.type === "file") {
+      if (keepFileAsWorkspaceRef(block.source)) {
+        return block.extracted_text !== undefined;
+      }
       return block.source.type === "workspace_ref";
     }
     if (block.type === "tool_result" && block.contentBlocks?.length) {

package/src/providers/model-catalog.ts

@@ -631,6 +631,22 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       linkLabel: "Open Google AI Studio",
     },
     models: [
+      {
+        id: "gemini-3.8-flash",
+        displayName: "Gemini 3.8 Flash",
+        contextWindowTokens: 1048576,
+        maxOutputTokens: 65536,
+        supportsThinking: true,
+        thinkingFloor: "low",
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 1.5,
+          outputPer1mTokens: 7.5,
+          cacheReadPer1mTokens: 0.15,
+        },
+      },
       {
         id: "gemini-3.7-flash",
         displayName: "Gemini 3.7 Flash",
@@ -928,23 +944,6 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.16,
         },
       },
-      {
-        id: "accounts/fireworks/models/glm-5p2",
-        displayName: "GLM 5.2",
-        // Fireworks serves GLM 5.2 with a 1,040K input window.
-        contextWindowTokens: 1040000,
-        maxOutputTokens: 131072,
-        supportsThinking: true,
-        supportsCaching: true,
-        supportsVision: false,
-        supportsToolUse: true,
-        maxEffort: "max",
-        pricing: {
-          inputPer1mTokens: 1.4,
-          outputPer1mTokens: 4.4,
-          cacheReadPer1mTokens: 0.26,
-        },
-      },
       {
         id: "accounts/fireworks/models/glm-5p3",
         displayName: "GLM 5.3",
@@ -984,6 +983,23 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.029,
         },
       },
+      {
+        id: "accounts/fireworks/models/glm-5p2",
+        displayName: "GLM 5.2",
+        // Fireworks serves GLM 5.2 with a 1,040K input window.
+        contextWindowTokens: 1040000,
+        maxOutputTokens: 131072,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: false,
+        supportsToolUse: true,
+        maxEffort: "max",
+        pricing: {
+          inputPer1mTokens: 1.4,
+          outputPer1mTokens: 4.4,
+          cacheReadPer1mTokens: 0.26,
+        },
+      },
       // Kimi K2.5 (accounts/fireworks/models/kimi-k2p5) is intentionally
       // absent: Fireworks serves it on-demand/dedicated only, so serverless
       // chat/completions calls 404 ("not found, inaccessible, and/or not
@@ -1006,28 +1022,25 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 0.06,
         },
       },
+      // MiniMax M2.7 (accounts/fireworks/models/minimax-m2p7) is
+      // intentionally absent: Fireworks has no serverless deployment for
+      // it (the model page claims serverless support, but the serving API
+      // returns 404).
       {
-        id: "accounts/fireworks/models/minimax-m2p7",
-        displayName: "MiniMax M2.7",
-        contextWindowTokens: 196608,
-        maxOutputTokens: 25000,
-        supportsThinking: false,
-        supportsCaching: false,
-        supportsVision: false,
-        supportsToolUse: true,
-        pricing: { inputPer1mTokens: 0.3, outputPer1mTokens: 1.2 },
-      },
-      {
-        id: "accounts/fireworks/models/deepseek-v4-pro",
+        id: "accounts/fireworks/models/deepseek-v4-pro-0813",
         displayName: "DeepSeek V4 Pro",
         contextWindowTokens: 1040000,
         maxOutputTokens: 131072,
         supportsThinking: true,
-        supportsCaching: false,
+        supportsCaching: true,
         supportsVision: false,
         supportsToolUse: true,
         maxEffort: "max",
-        pricing: { inputPer1mTokens: 1.74, outputPer1mTokens: 3.48 },
+        pricing: {
+          inputPer1mTokens: 1.32,
+          outputPer1mTokens: 3.96,
+          cacheReadPer1mTokens: 0.044,
+        },
       },
       {
         id: "accounts/fireworks/models/deepseek-v4-flash-0731",
@@ -1834,7 +1847,7 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       // Z.ai
       {
         id: "z-ai/glm-5.3",
-        displayName: "GLM-5.3",
+        displayName: "GLM 5.3",
         contextWindowTokens: 1048576,
         maxOutputTokens: 131072,
         supportsThinking: true,
@@ -1849,7 +1862,7 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       },
       {
         id: "z-ai/glm-5.3-flash",
-        displayName: "GLM-5.3 Flash",
+        displayName: "GLM 5.3 Flash",
         contextWindowTokens: 1310720,
         maxOutputTokens: 131072,
         supportsThinking: true,
@@ -1864,7 +1877,7 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
       },
       {
         id: "z-ai/glm-5.2",
-        displayName: "GLM-5.2",
+        displayName: "GLM 5.2",
         contextWindowTokens: 1048576,
         maxOutputTokens: 131072,
         supportsThinking: true,

package/src/providers/openai/chat-completions-provider.ts

@@ -7,7 +7,8 @@ import { getLogger } from "../../util/logger.js";
 import { isChatTemplateFailureError } from "../../util/provider-error-patterns.js";
 import { extractRetryAfterMs } from "../../util/retry.js";
 import { partialTagSuffix as sharedPartialTagSuffix } from "../../util/think-tag-stream.js";
-import { escapeXmlAttr } from "../../util/xml.js";
+import { clampProviderString } from "../content-block-size.js";
+import { fileBlockToProviderText } from "../file-block-text.js";
 import {
   base64Source,
   mediaSourceByteLength,
@@ -691,9 +692,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
   private requestHeaders: Record<string, string>;
   private parseThinkTags: boolean;
   private assistantReasoningField:
-    | "reasoning"
-    | "reasoning_content"
-    | undefined;
+    "reasoning" | "reasoning_content" | undefined;
   private coerceObjectArgsToJsonString: boolean;
   private omitToolChoiceWhenReasoning: boolean;
 
@@ -741,15 +740,12 @@ export class OpenAIChatCompletionsProvider implements Provider {
     const modelOverride = configObj?.model as string | undefined;
     const effort = configObj?.effort as string | undefined;
     const logitBias = configObj?.logit_bias as
-      | Record<string, number>
-      | undefined;
+      Record<string, number> | undefined;
     const topP = configObj?.top_p as number | undefined;
     const usageAttributionHeaders = configObj?.usageAttributionHeaders as
-      | Record<string, string>
-      | undefined;
+      Record<string, string> | undefined;
     const perRequestHeaders = configObj?.requestHeaders as
-      | Record<string, string>
-      | undefined;
+      Record<string, string> | undefined;
 
     // Per-tool keys whose object schemas were rewritten to JSON strings for the
     // wire, to be decoded back on the response. Empty unless
@@ -1580,14 +1576,14 @@ export class OpenAIChatCompletionsProvider implements Provider {
   ): OpenAI.Chat.Completions.ChatCompletionUserMessageParam {
     // If only a single text block, use plain string (simpler, fewer tokens)
     if (blocks.length === 1 && blocks[0].type === "text") {
-      return { role: "user", content: blocks[0].text };
+      return { role: "user", content: clampProviderString(blocks[0].text) };
     }
 
     const parts: OpenAI.Chat.Completions.ChatCompletionContentPart[] = [];
     for (const block of blocks) {
       switch (block.type) {
         case "text":
-          parts.push({ type: "text", text: block.text });
+          parts.push({ type: "text", text: clampProviderString(block.text) });
           break;
         case "image":
           if (!OPENAI_SUPPORTED_IMAGE_TYPES.has(block.source.media_type)) {
@@ -1622,7 +1618,7 @@ export class OpenAIChatCompletionsProvider implements Provider {
           } else {
             parts.push({
               type: "text",
-              text: this.fileBlockToText(block),
+              text: fileBlockToProviderText(block),
             });
           }
           break;
@@ -1641,16 +1637,4 @@ export class OpenAIChatCompletionsProvider implements Provider {
 
     return { role: "user", content: parts };
   }
-
-  private fileBlockToText(
-    block: Extract<ContentBlock, { type: "file" }>,
-  ): string {
-    const header = `<attached_file name="${escapeXmlAttr(
-      block.source.filename ?? "",
-    )}" type="${escapeXmlAttr(block.source.media_type)}" />`;
-    if (block.extracted_text && block.extracted_text.trim().length > 0) {
-      return `${header}\n${block.extracted_text}`;
-    }
-    return `${header}\nNo extracted text available.`;
-  }
 }

package/src/providers/openai/responses-provider.ts

@@ -5,7 +5,8 @@ import { isAbortReason } from "../../util/abort-reasons.js";
 import { ProviderError, type ProviderErrorReason } from "../../util/errors.js";
 import { getLogger } from "../../util/logger.js";
 import { extractRetryAfterMs } from "../../util/retry.js";
-import { escapeXmlAttr } from "../../util/xml.js";
+import { clampProviderString } from "../content-block-size.js";
+import { fileBlockToProviderText } from "../file-block-text.js";
 import { base64Source, resolveMediaReferences } from "../media-resolve.js";
 import { PROMPT_CACHE_BREAKPOINT_MODEL_IDS } from "../model-catalog.js";
 import { recordProviderRequestDiagnostics } from "../request-diagnostics.js";
@@ -229,8 +230,7 @@ export class OpenAIResponsesProvider implements Provider {
     const effort = configObj?.effort as string | undefined;
     const verbosity = configObj?.verbosity as string | undefined;
     const usageAttributionHeaders = configObj?.usageAttributionHeaders as
-      | Record<string, string>
-      | undefined;
+      Record<string, string> | undefined;
     const disableCache = configObj?.disableCache === true;
     const disableTurnStartCache = configObj?.disableTurnStartCache === true;
     const promptCacheKey =
@@ -1003,7 +1003,9 @@ export class OpenAIResponsesProvider implements Provider {
       return {
         type: "message",
         role: "user",
-        content: [{ type: "input_text", text: blocks[0].text }],
+        content: [
+          { type: "input_text", text: clampProviderString(blocks[0].text) },
+        ],
       };
     }
 
@@ -1011,7 +1013,10 @@ export class OpenAIResponsesProvider implements Provider {
     for (const block of blocks) {
       switch (block.type) {
         case "text":
-          parts.push({ type: "input_text", text: block.text });
+          parts.push({
+            type: "input_text",
+            text: clampProviderString(block.text),
+          });
           break;
         case "image":
           if (!OPENAI_SUPPORTED_IMAGE_TYPES.has(block.source.media_type)) {
@@ -1030,7 +1035,7 @@ export class OpenAIResponsesProvider implements Provider {
         case "file":
           parts.push({
             type: "input_text",
-            text: this.fileBlockToText(block),
+            text: fileBlockToProviderText(block),
           });
           break;
         case "server_tool_use":
@@ -1051,16 +1056,4 @@ export class OpenAIResponsesProvider implements Provider {
       content: parts,
     };
   }
-
-  private fileBlockToText(
-    block: Extract<ContentBlock, { type: "file" }>,
-  ): string {
-    const header = `<attached_file name="${escapeXmlAttr(
-      block.source.filename ?? "",
-    )}" type="${escapeXmlAttr(block.source.media_type)}" />`;
-    if (block.extracted_text && block.extracted_text.trim().length > 0) {
-      return `${header}\n${block.extracted_text}`;
-    }
-    return `${header}\nNo extracted text available.`;
-  }
 }

package/src/providers/registry.ts

@@ -313,16 +313,19 @@ export async function resolveProviderFromConnection(
   // For every other connection this is `undefined` and the effective provider
   // is the connection's own — no behavior change.
   const effectiveProvider = opts.providerOverride ?? connection.provider;
-  // Routing identities must be translated to a real upstream before this
-  // point (resolveRoutingIdentity in connection-resolution) — an identity
-  // reaching adapter construction would silently yield no adapter and the
-  // retry wire-normalization keys off real adapter provider names.
-  if (ROUTING_IDENTITY_PROVIDERS.has(effectiveProvider)) {
+  const model = opts.model ?? resolveModel(config, effectiveProvider);
+  // Routing identities must already be translated to a factory id
+  // (`resolveRoutingIdentity`). `chatgpt` has no factory and must not
+  // reach adapter construction. `vellum` is a catalog factory, so it is
+  // a valid effectiveProvider after that translation.
+  if (
+    ROUTING_IDENTITY_PROVIDERS.has(effectiveProvider) &&
+    !PROVIDER_CATALOG.some((entry) => entry.id === effectiveProvider)
+  ) {
     throw new Error(
-      `resolveProviderFromConnection received unresolved routing identity "${effectiveProvider}" — translate to a real upstream before adapter construction`,
+      `resolveProviderFromConnection received unresolved routing identity "${effectiveProvider}": translate to a real upstream before adapter construction`,
     );
   }
-  const model = opts.model ?? resolveModel(config, effectiveProvider);
   const cacheKey = getConnectionProviderCacheKey(
     connection,
     model,

package/src/providers/routing-identity.ts

@@ -39,7 +39,8 @@ export class ConnectionResolutionError extends ConfigError {
       | "model_incompatible"
       | "missing_credential"
       | "platform_unauthenticated"
-      | "unroutable_managed_model",
+      | "unroutable_managed_model"
+      | "adapter_unavailable",
     message: string,
     options?: { cause?: unknown; model?: string; profileName?: string },
   ) {

package/src/providers/types.ts

@@ -429,10 +429,7 @@ export interface SendMessageConfig {
   /**
    * When true, the TURN-STARTING user message carries content that will not
    * recur byte-identically on the next turn, so a long-TTL breakpoint placed
-   * on it could never be read back across turns. The agent loop is the only
-   * producer: it sets the flag from the history it is about to send, when the
-   * turn-starting message carries a memory-v3 `<memory_spotlight>` block (the
-   * one injected block strip-and-replaced from every user message each turn).
+   * on it could never be read back across turns.
    *
    * The flag describes the turn, not the request, so it holds for every
    * request the turn makes, including tool-loop iterations, whose trailing

package/src/providers/vellum-model-routing.ts

@@ -37,8 +37,9 @@ export const MANAGED_ROUTABLE_PROVIDERS: ReadonlySet<string> = new Set(
  * connection. Unlike the per-provider `*-managed` connections, this one does
  * not name an upstream provider on its DB row — the upstream is determined
  * per-request from the resolving profile. The same id is the catalog owner
- * of Vellum-hosted GPU models. Dispatch still substitutes a concrete
- * upstream (including `vellum` for those GPU models) before adapter lookup.
+ * of Vellum-hosted GPU models. Dispatch translates the identity to a
+ * factory id (including `vellum` when that is the catalog owner) before
+ * adapter lookup.
  */
 export const VELLUM_MANAGED_PROVIDER = "vellum";
 

package/src/runtime/AGENTS.md

@@ -20,8 +20,18 @@ Channel inbound turns (Slack/Telegram/etc. — `processChannelMessageInBackgroun
 
 **Invariant:** do NOT "fix" this by routing channel turns through `conversation.enqueueMessage` — the drain has no channel-callback delivery, so the reply would run but never reach the channel. A channel turn that still hits `CONVERSATION_BUSY_MESSAGE` (a non-channel turn raced in after admission) is re-scheduled for the channel-retry sweep via `deferRetryUntilIdle` — never `recordProcessingFailure` (which `classifyError` treats as fatal → dead-letter → silent drop, JARVIS-1346). The sweep is itself busy-aware: it `deferRetryUntilIdle`s a retry whose conversation is mid-turn. Busy deferral must **not** burn the retry budget: `deferRetryUntilIdle` pushes `retryAfter` forward but never increments `processingAttempts` and never dead-letters, so a conversation that stays busy across many sweeps re-defers indefinitely rather than dropping the reply at `RETRY_MAX_ATTEMPTS` (~10 min). Crash durability: while the in-memory admission waits, the inbound row sits `pending`; a crash mid-wait is recovered at startup by `recoverOrphanedChannelEvents` (`monitoring/recovery/`), which promotes boot-fenced orphan `pending` rows onto the sweep's `failed` retry path.
 
+**A growing reply is channel-generic, and what it leaves behind is not.** `channel-reply-session.ts` owns the shared half: consuming the turn's event stream once, accumulating text across LLM calls, coalescing, tracking the plan from `ui_show`/`ui_update`, and deciding open/append/stop. Everything platform-shaped belongs to the transport. A channel declares it can carry a growing reply by implementing `streamReply` at all; whether THIS conversation can is answered by the transport's own reply to `start` (Slack refuses a turn with no thread, Telegram a chat that is not private), which arrives as an ordinary not-ok and falls back to sending the finished reply. A channel that caps how much one operation may carry declares that as `maxStreamTextChars`; the session does the splitting, because it is what tracks how much the channel has actually taken and that mark may only advance once per confirmed operation. A transport that split a wide delta into several calls of its own would leave the session unable to tell a partial delivery from a whole one, and a failure part-way through would re-send the part that already landed.
+
+The load-bearing distinction is `streamPersists`. Slack finalizes its streamed message in place, so the stream IS the reply and durable delivery must not send it again. Telegram's draft is a 30-second preview that evaporates, so the reply is still owed and goes out the ordinary path. Two things follow, and both are easy to get wrong: a preview reports `fallback` at finish even though it really streamed, and a preview's stream id is never handed to `onStreamOpen`, because the crash-recovery breadcrumb exists to reconcile against a message the reader can still see. Recording a preview's id would point recovery at a message that never existed and lose the reply instead of posting it. Omitting `streamPersists` is the safe default: at worst the reply repeats, never disappears.
+
+**Delivery has its own crash window, and its own recovery.** A turn is marked `processing_status = 'processed'` as soon as it persists, while its reply delivery finalizes afterwards in memory, so a crash in between strands the row `processed` + `delivery_status = 'pending'`. Neither existing path recovers that: the sweep selects `delivery_status = 'failed'`, and the orphan step above selects `processing_status = 'pending'`. `recoverStrandedDeliveryEvents` (`monitoring/recovery/`) closes it, promoting boot-fenced rows whose stored payload names both a `replyCallbackUrl` and a `replyMessageId` onto the delivery-retry arm. That payload requirement is load-bearing, not a cheap filter: it keeps the step off the intercept-settled rows (reactions, edits, admission denials) which legitimately end `processed` + `pending` with no reply owed. The corollary for new code: any path that finishes a channel turn WITHOUT delivering must settle its own `deliveryStatus` rather than leaving it `pending`, or this step will re-post a reply that was never owed. The deduplicated-ingress skip in `background-dispatch.ts` calls `markDeliveryDelivered` for exactly that reason.
+
 **Faithful replay:** the sweep reconstructs a turn from the stored raw payload, so it must produce the SAME turn the live ingress path would have run — not an impoverished one. Two invariants, each learned from a live-path hardening change that originally skipped the sweep: (1) **content fencing** — non-guardian content is wrapped in `<external_content>` via the shared `prepareChannelInboundContent` (`routes/inbound-stages/inbound-content-prep.ts`), used by BOTH `inbound-message-handler.ts` and the sweep; replaying raw, unwrapped text would drop the untrusted-content boundary the model relies on (regression window: #30785 wrapped only the live path). (2) **idempotency key + slackMeta** — the live turn captures its `slackInbound` onto the stored payload (`storeInboundSlackMetadata`) and the sweep replays that EXACT object (`parseStoredSlackInbound`), so `deriveIngressIdempotencyKey` yields a byte-identical `client_message_id` (a replay of an already-persisted turn dedups the agent loop) and full slackMeta survives the replay. Dedup is not enough on its own: on a dedup hit the sweep gates `finalizeEventDelivery` on `isDeduplicatedDeliveryOwnedBySibling` — skipping delivery when a sibling event already owns it, so it never double-posts — and, when the deduped turn crashed before writing any reply, completes it with a fresh run rather than delivering nothing. A `buildReplaySlackInbound` fallback reconstructs the key-bearing fields for payloads stored before the capture existed (regression window: #38378 added the key to the live path only, though the sweep IS the "Slack retry" path it targeted). Any future hardening applied at channel ingress must be mirrored in the sweep, or a retried/recovered turn silently loses it.
 
+**Reaction wake turns are the deliberate exception to the sweep's processing lane.** A reaction an admitted actor ADDS to the assistant's own post dispatches a discretion turn through `processChannelMessageInBackground` (`inbound-stages/reaction-intercept.ts`, `buildReactionWakeTurn`): the turn's persisted user row carries the reaction envelope through the ordinary ingress carriers (`channelInbound` for every channel whose lane accepts it, the transitional `slackReactionRowMeta` for Slack), so the row reads as a reaction everywhere, and its content is the same line the reload renderer produces. The reply's destination is resolved from the target row's own thread rather than the reaction event's callback, which names the reacted message as its thread.
+
+These turns are at-most-once BY DESIGN: the sweep's processing lane rebuilds a turn from its stored payload as a plain message, which would corrupt a reaction into a fabricated user message. So the event is marked processed up front, and the payload it stores is delivery-only (callback, chat, assistant id): enough for the delivery lane to re-post a reply whose first delivery failed, and carrying no content or channel, so no processing replay can fabricate a turn from it. A post-admission busy loss degrades through the dispatch's `onTurnLostToBusy` hook to the passive transcript row instead of the sweep. Do not "fix" a lost reaction turn by widening that payload into a replayable one - teach the sweep to rebuild reaction turns first.
+
 ### SSE backpressure shedding must be observable
 
 SSE handlers built on `ReadableStream` shed slow subscribers when `controller.desiredSize <= 0` to keep daemon memory bounded. Every shed site must emit a log line + Sentry capture so the daemon-side shed can be time-correlated with the client-side idle watchdog (otherwise stalls are invisible from both sides). See [WHATWG Streams — Backpressure](https://streams.spec.whatwg.org/#pipe-chains) and [Node `monitorEventLoopDelay`](https://nodejs.org/api/perf_hooks.html#perf_hooksmonitoreventloopdelayoptions).
@@ -160,7 +170,7 @@ All CDP-backed browser tools (`browser_navigate`, `browser_snapshot`, `browser_s
 
 ### Interactive requests on channels (approvals, questions)
 
-**The guardian-request pipeline is the canonical rail for anything interactive on a channel** — cards with buttons, request-code replies, emoji reactions, typed answers. The end-to-end map (promotion → gateway `guardian_requests` row → notification broadcaster → per-channel adapters → reply router → decision primitive → per-kind resolver) lives in [docs/guardian-request-flow.md](../../docs/guardian-request-flow.md). New interactive features extend that pipeline's seams; do NOT add per-feature watchers, callback schemes, or inbound intercepts.
+**The guardian-request pipeline is the canonical rail for anything interactive on a channel**: cards with buttons, request-code replies, typed answers. The end-to-end map (promotion → gateway `guardian_requests` row → notification broadcaster → per-channel adapters → reply router → decision primitive → per-kind resolver) lives in [docs/guardian-request-flow.md](../../docs/guardian-request-flow.md). New interactive features extend that pipeline's seams; do NOT add per-feature watchers, callback schemes, or inbound intercepts.
 
 Identifiers and plumbing notes:
 
@@ -204,22 +214,37 @@ the gateway's Channel Identity Vocabulary, which covers the wire side.
   channel, including one this repo has no code for, which is why a new
   channel belongs here rather than in a sixth key of its own.
 
-  Every channel except Slack writes it: a reaction row carries the whole
-  shape (`inbound-stages/reaction-intercept.ts`), an edit or a delete
-  stamps `editedAt` / `deletedAt` onto whatever the row already said about
-  itself through `mergeProviderMessageMetadata`
-  (`inbound-stages/edit-intercept.ts`, `inbound-message-handler.ts`), and an
-  outbound assistant reply is stamped with a partial envelope at reserve time
-  (`buildAssistantChannelMetadata`) whose `messageId` (and, for a reply
+  Every row the daemon authors writes it on every channel, Slack included:
+  an outbound assistant reply is stamped with a partial envelope at reserve
+  time (`buildAssistantChannelMetadata`) whose `messageId` (and, for a reply
   split into several posts, `additionalMessageIds`) the post-send
   reconciliation in `channel-reply-delivery.ts` back-fills from the
-  transport's delivery results, which is what lets a later reaction on the
-  assistant's own post resolve back to its row. Slack
-  keeps writing `slackMeta`, and `readProviderMetadata` maps that envelope
-  onto this shape on read, so the channel-agnostic readers in
-  `persistence/delivery-crud.ts` (thread evidence, and finding the
-  conversation that holds a given provider message id) serve both without a
-  per-channel branch.
+  transport's delivery results, the assistant's own reaction rows write it
+  (`daemon/reaction-record.ts`), and bot-authored Slack backfill rows write
+  it. Every channel except Slack writes it for inbound rows too: a reaction
+  row carries the whole shape (`inbound-stages/reaction-intercept.ts`), and
+  an edit or a delete stamps `editedAt` / `deletedAt` onto whatever the row
+  already said about itself through `mergeProviderMessageMetadata`
+  (`inbound-stages/edit-intercept.ts`, `inbound-message-handler.ts`). The same reconciliation writes each id into
+  the `channel_outbound_posts` index (the outbound counterpart of
+  `channel_inbound_events`' provider-id resolution), which is what lets a
+  later reaction or delete naming the assistant's own post resolve back to
+  its row exactly; the envelope stays the row's self-description, and the
+  capped envelope scan in `findMessageByProviderMessageId` survives only as
+  the transitional fallback for rows reconciled before the table. A reply
+  still pending for the retry sweep that was reserved with Slack's own
+  pre-send envelope converges onto this envelope when that reconciliation
+  stamps it (`providerMetadataOfPreSendSlackEnvelope`, transitional in the
+  same way). Inbound Slack rows still write `slackMeta` (transitional: the
+  end state is this
+  envelope on every Slack row, with `slackMeta` as the read-compat arm for
+  historical rows). The two envelopes map onto each other on read, in both
+  directions: `readProviderMetadata` serves a `slackMeta` row as this shape
+  to the channel-agnostic readers in `persistence/delivery-crud.ts`, and
+  `readSlackMetadataFromMessageMetadata` serves a neutral row as Slack's
+  view (`slackViewOfProviderMetadata`, Slack's own fields riding the
+  schema's passthrough) to the Slack renderers and backfill readers, so no
+  reader on either side carries a per-envelope branch.
 
 ### Channel verification: gateway-owned
 

package/src/runtime/approval-message-composer.ts

@@ -40,11 +40,6 @@ export function composeApprovalMessage(
   return getFallbackMessage(context);
 }
 
-/** @internal Exported for use by the daemon-injected generator implementation. */
-export function escapeRegExp(input: string): string {
-  return input.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
 /** @internal Exported for use by the daemon-injected generator implementation. */
 export function includesRequiredKeywords(
   text: string,
@@ -54,7 +49,7 @@ export function includesRequiredKeywords(
     return true;
   }
   return requiredKeywords.every((keyword) => {
-    const re = new RegExp(`\\b${escapeRegExp(keyword)}\\b`, "i");
+    const re = new RegExp(`\\b${RegExp.escape(keyword)}\\b`, "i");
     return re.test(text);
   });
 }

package/src/runtime/assistant-event-hub.ts

@@ -338,9 +338,7 @@ export class AssistantEventHub {
    *   it receive the event; untargeted events go to all
    * - if `targetInterfaceId` is set, only client subscribers whose
    *   `interfaceId` matches receive the event; process subscribers and
-   *   non-matching clients are skipped. Used to narrow legacy
-   *   broadcasts (e.g. `conversation_list_invalidated`) to a specific
-   *   client surface during a migration window.
+   *   non-matching clients are skipped.
    *
    * Fanout is isolated: a throwing or rejecting subscriber does not abort
    * delivery to remaining subscribers.
@@ -744,13 +742,7 @@ export function broadcastMessage(
   const targetClientId = options?.targetClientId;
   const targetInterfaceId = options?.targetInterfaceId;
 
-  // `conversation_list_invalidated` is a list-level system event — publish
-  // it unscoped so every subscriber refreshes its sidebar.
-  const scopedConversationId =
-    msg.type === "conversation_list_invalidated"
-      ? undefined
-      : resolvedConversationId;
-  const event = buildAssistantEvent(msg, scopedConversationId);
+  const event = buildAssistantEvent(msg, resolvedConversationId);
   const targetCapability = capabilityForMessageType(msg.type);
   // Self-echo suppression: a `sync_changed` carrying an `originClientId`
   // means a specific client just mutated the resource. The hub must not
@@ -780,35 +772,6 @@ export function broadcastMessage(
   stampAndBuffer(event, { targeting: publishOptions });
   _hubChain = _hubChain
     .then(() => assistantEventHub.publish(event, publishOptions))
-    .then(() => {
-      // When a conversation title changes, also publish a
-      // `conversation_list_invalidated` so the macOS sidebar refreshes
-      // its row ordering for the renamed conversation. Web consumes the
-      // paired `sync_changed` with `conversation:<id>:metadata` tag
-      // emitted by `publishConversationTitleChanged` and patches the
-      // single row in place, so the broadcast is scoped to macOS only.
-      //
-      // TODO(electron-cutover): remove this emission once macOS migrates
-      // to the Electron client and consumes `sync_changed` directly. At
-      // that point `conversation_list_invalidated` has no remaining
-      // consumers and the message type can be retired.
-      if (msg.type === "conversation_title_updated") {
-        return assistantEventHub
-          .publish(
-            buildAssistantEvent({
-              type: "conversation_list_invalidated",
-              reason: "renamed",
-            }),
-            { targetInterfaceId: "macos" },
-          )
-          .catch((err: unknown) => {
-            log.warn(
-              { err },
-              "Failed to publish conversation_list_invalidated after title update",
-            );
-          });
-      }
-    })
     .catch((err: unknown) => {
       log.warn({ err }, "assistant-events hub subscriber threw during publish");
     });

package/src/runtime/channel-approval-types.ts

@@ -166,11 +166,7 @@ export interface ChannelApprovalPrompt {
  * joins (every channel's buttons ride the same `apr:` callback), and no
  * consumer reads a channel off this field.
  */
-export type ApprovalDecisionSource =
-  | "button"
-  | "reaction"
-  | "vellum_surface"
-  | "plain_text";
+export type ApprovalDecisionSource = "button" | "vellum_surface" | "plain_text";
 
 /** The structured result of a user's approval decision. */
 export interface ApprovalDecisionResult {