@vellumai/assistant 0.11.3 → 0.11.4-dev.202608190019.b94dbf2

package/src/config/schemas/__tests__/live-voice.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test";
 
 import {
   LiveVoiceConfigSchema,
+  LiveVoiceFluxConfigSchema,
   LiveVoiceFrontModelConfigSchema,
   LiveVoiceVadConfigSchema,
   VALID_LIVE_VOICE_MODES,
@@ -21,11 +22,18 @@ const FRONT_MODEL_DEFAULTS = {
   endpointDecisionTimeoutMs: 1200,
   endpointExtensionMs: 1500,
   endpointMaxExtensions: 2,
-  ackFirstDeltaTimeoutMs: 2500,
-  ackGenerationTimeoutMs: 600,
   progress: PROGRESS_DEFAULTS,
 };
 
+// `eagerEotThreshold` is deliberately absent: it has no default, and leaving it
+// unset is what keeps Deepgram from emitting speculative turn events.
+const FLUX_DEFAULTS = {
+  turnEnd: { enabled: false },
+  model: "flux-general-en",
+  eotThreshold: 0.7,
+  eotTimeoutMs: 5_000,
+};
+
 describe("LiveVoiceVadConfigSchema", () => {
   test("empty object parses to defaults", () => {
     const parsed = LiveVoiceVadConfigSchema.parse({});
@@ -124,8 +132,15 @@ describe("LiveVoiceFrontModelConfigSchema", () => {
     expect(parsed.endpointMaxExtensions).toBe(0);
     // Unspecified fields still get defaults
     expect(parsed.endpointExtensionMs).toBe(1500);
-    expect(parsed.ackFirstDeltaTimeoutMs).toBe(2500);
-    expect(parsed.ackGenerationTimeoutMs).toBe(600);
+  });
+
+  test("strips retired generated-ack settings", () => {
+    const parsed = LiveVoiceFrontModelConfigSchema.parse({
+      ackFirstDeltaTimeoutMs: 2500,
+      ackGenerationTimeoutMs: 600,
+    });
+    expect(parsed).not.toHaveProperty("ackFirstDeltaTimeoutMs");
+    expect(parsed).not.toHaveProperty("ackGenerationTimeoutMs");
   });
 
   test("rejects non-positive endpointDecisionTimeoutMs", () => {
@@ -213,6 +228,87 @@ describe("LiveVoiceFrontModelConfigSchema", () => {
   });
 });
 
+describe("LiveVoiceFluxConfigSchema", () => {
+  test("empty object parses to defaults, with turn-end off", () => {
+    expect(LiveVoiceFluxConfigSchema.parse({})).toEqual(FLUX_DEFAULTS);
+  });
+
+  test("an unset eagerEotThreshold is absent, not zero", () => {
+    expect("eagerEotThreshold" in LiveVoiceFluxConfigSchema.parse({})).toBe(
+      false,
+    );
+  });
+
+  test("accepts overrides", () => {
+    const parsed = LiveVoiceFluxConfigSchema.parse({
+      turnEnd: { enabled: true },
+      model: "flux-general-multi",
+      eotThreshold: 0.85,
+      eagerEotThreshold: 0.45,
+      eotTimeoutMs: 12_000,
+    });
+    expect(parsed.turnEnd.enabled).toBe(true);
+    expect(parsed.model).toBe("flux-general-multi");
+    expect(parsed.eotThreshold).toBe(0.85);
+    expect(parsed.eagerEotThreshold).toBe(0.45);
+    expect(parsed.eotTimeoutMs).toBe(12_000);
+  });
+
+  test("partial overrides merge with defaults", () => {
+    const parsed = LiveVoiceFluxConfigSchema.parse({ eotThreshold: 0.6 });
+    expect(parsed.eotThreshold).toBe(0.6);
+    expect(parsed.turnEnd.enabled).toBe(false);
+    expect(parsed.model).toBe("flux-general-en");
+    expect(parsed.eotTimeoutMs).toBe(5_000);
+  });
+
+  test("rejects an eotThreshold outside 0.5..0.9", () => {
+    const above = LiveVoiceFluxConfigSchema.safeParse({ eotThreshold: 0.95 });
+    expect(above.success).toBe(false);
+    expect(above.error?.issues.map((i) => i.message)).toEqual([
+      "liveVoice.flux.eotThreshold must be <= 0.9",
+    ]);
+
+    const below = LiveVoiceFluxConfigSchema.safeParse({ eotThreshold: 0.4 });
+    expect(below.success).toBe(false);
+    expect(below.error?.issues.map((i) => i.message)).toEqual([
+      "liveVoice.flux.eotThreshold must be >= 0.5",
+    ]);
+  });
+
+  test("rejects an eagerEotThreshold outside 0.3..0.9", () => {
+    expect(
+      LiveVoiceFluxConfigSchema.safeParse({ eagerEotThreshold: 0.2 }).success,
+    ).toBe(false);
+    expect(
+      LiveVoiceFluxConfigSchema.safeParse({ eagerEotThreshold: 0.95 }).success,
+    ).toBe(false);
+  });
+
+  test("rejects an eotTimeoutMs outside 500..60000, and non-integers", () => {
+    expect(
+      LiveVoiceFluxConfigSchema.safeParse({ eotTimeoutMs: 499 }).success,
+    ).toBe(false);
+    expect(
+      LiveVoiceFluxConfigSchema.safeParse({ eotTimeoutMs: 60_001 }).success,
+    ).toBe(false);
+    expect(
+      LiveVoiceFluxConfigSchema.safeParse({ eotTimeoutMs: 1_500.5 }).success,
+    ).toBe(false);
+  });
+
+  test("rejects a non-boolean turnEnd.enabled", () => {
+    const result = LiveVoiceFluxConfigSchema.safeParse({
+      turnEnd: { enabled: "yes" },
+    });
+    expect(result.success).toBe(false);
+    const msgs = result.error?.issues.map((i) => i.message) ?? [];
+    expect(msgs.some((m) => m.includes("liveVoice.flux.turnEnd.enabled"))).toBe(
+      true,
+    );
+  });
+});
+
 describe("LiveVoiceConfigSchema", () => {
   test("empty object parses to defaults", () => {
     const parsed = LiveVoiceConfigSchema.parse({});
@@ -228,6 +324,9 @@ describe("LiveVoiceConfigSchema", () => {
         echoDrainSlackMs: 300,
       },
       frontModel: FRONT_MODEL_DEFAULTS,
+      // Off by default: Flux turn detection is opt-in, so the front-door hold
+      // verdict keeps committing turns until it is enabled.
+      flux: FLUX_DEFAULTS,
       maxSessionDurationSeconds: 1800,
       // Off by default: voice turns carry only their transcript, no audio
       // artifacts on the conversation messages (JARVIS-1283).
@@ -255,6 +354,7 @@ describe("LiveVoiceConfigSchema", () => {
       mode: "ptt",
       vad: { silenceThresholdMs: 900 },
       frontModel: { endpointDecisionTimeoutMs: 300 },
+      flux: { turnEnd: { enabled: true } },
       maxSessionDurationSeconds: 600,
     });
     expect(parsed.mode).toBe("ptt");
@@ -265,6 +365,9 @@ describe("LiveVoiceConfigSchema", () => {
     // Partial frontModel overrides merge with defaults
     expect(parsed.frontModel.endpointDecisionTimeoutMs).toBe(300);
     expect(parsed.frontModel.endpointExtensionMs).toBe(1500);
+    // Partial flux overrides merge with defaults
+    expect(parsed.flux.turnEnd.enabled).toBe(true);
+    expect(parsed.flux.eotThreshold).toBe(0.7);
     expect(parsed.maxSessionDurationSeconds).toBe(600);
   });
 

package/src/config/schemas/call-site-catalog.ts

@@ -289,11 +289,11 @@ const CATALOG_RECORD: CatalogRecord = {
       "Captions images via a vision-capable profile for text-only model fallback.",
     domain: "skills",
   },
-  voiceFrontDecision: {
-    id: "voiceFrontDecision",
-    displayName: "Voice Front Decision",
+  voiceProgressNarration: {
+    id: "voiceProgressNarration",
+    displayName: "Voice Progress Narration",
     description:
-      "Fast turn-taking and presence decisions during live voice (semantic endpointing, ack generation).",
+      "Phrases short spoken progress updates during long-running live voice turns.",
     domain: "agentLoop",
   },
   voiceFrontDoor: {

package/src/config/schemas/live-voice.ts

@@ -207,34 +207,64 @@ export const LiveVoiceFrontModelConfigSchema = z
       )
       .default(2)
       .describe("Cap on consecutive 'hold' extensions per utterance"),
-    ackFirstDeltaTimeoutMs: z
-      .number({
-        error: "liveVoice.frontModel.ackFirstDeltaTimeoutMs must be a number",
-      })
-      .int("liveVoice.frontModel.ackFirstDeltaTimeoutMs must be an integer")
-      .positive(
-        "liveVoice.frontModel.ackFirstDeltaTimeoutMs must be a positive integer",
-      )
-      .default(2500)
-      .describe(
-        "Keyword-delay budget (ms): a spoken ack fires if no first assistant delta has arrived by then",
-      ),
-    ackGenerationTimeoutMs: z
-      .number({
-        error: "liveVoice.frontModel.ackGenerationTimeoutMs must be a number",
-      })
-      .int("liveVoice.frontModel.ackGenerationTimeoutMs must be an integer")
-      .positive(
-        "liveVoice.frontModel.ackGenerationTimeoutMs must be a positive integer",
-      )
-      .default(600)
-      .describe("Budget (ms) for LLM-generated ack text"),
     progress: LiveVoiceProgressConfigSchema.default(
       LiveVoiceProgressConfigSchema.parse({}),
     ),
   })
   .describe(
-    "Front-model presence layer tuning for live voice sessions (semantic endpointing + spoken acks + progress narration)",
+    "Voice front-door endpointing and long-turn progress narration tuning",
+  );
+
+const LiveVoiceFluxTurnEndConfigSchema = z
+  .object({
+    enabled: z
+      .boolean({ error: "liveVoice.flux.turnEnd.enabled must be a boolean" })
+      .default(false)
+      .describe(
+        "Commit the live-voice turn on Flux's EndOfTurn instead of the front-door [0] hold verdict. Requires services.stt.provider to be deepgram-flux; ignored otherwise.",
+      ),
+  })
+  .describe(
+    "Which signal commits a live voice turn when Deepgram Flux is the STT provider",
+  );
+
+export const LiveVoiceFluxConfigSchema = z
+  .object({
+    turnEnd: LiveVoiceFluxTurnEndConfigSchema.default(
+      LiveVoiceFluxTurnEndConfigSchema.parse({}),
+    ),
+    model: z
+      .string({ error: "liveVoice.flux.model must be a string" })
+      .default("flux-general-en")
+      .describe("Deepgram Flux model requested when opening the STT stream"),
+    eotThreshold: z
+      .number({ error: "liveVoice.flux.eotThreshold must be a number" })
+      .min(0.5, "liveVoice.flux.eotThreshold must be >= 0.5")
+      .max(0.9, "liveVoice.flux.eotThreshold must be <= 0.9")
+      .default(0.7)
+      .describe(
+        "End-of-turn confidence Flux must reach before it emits EndOfTurn. Lower values commit sooner and cut speakers off more often; higher values wait longer and add end-of-turn latency.",
+      ),
+    eagerEotThreshold: z
+      .number({ error: "liveVoice.flux.eagerEotThreshold must be a number" })
+      .min(0.3, "liveVoice.flux.eagerEotThreshold must be >= 0.3")
+      .max(0.9, "liveVoice.flux.eagerEotThreshold must be <= 0.9")
+      .optional()
+      .describe(
+        "Confidence at which Flux starts speculating that the turn has ended. Leaving it unset disables Deepgram's EagerEndOfTurn / TurnResumed events; enabling it raises LLM calls 50-70% because speculative turns that resume are thrown away.",
+      ),
+    eotTimeoutMs: z
+      .number({ error: "liveVoice.flux.eotTimeoutMs must be a number" })
+      .int("liveVoice.flux.eotTimeoutMs must be an integer")
+      .min(500, "liveVoice.flux.eotTimeoutMs must be >= 500")
+      .max(60_000, "liveVoice.flux.eotTimeoutMs must be <= 60000")
+      .default(5_000)
+      .describe(
+        "Silence (ms) after which Flux force-ends the turn even though its end-of-turn confidence never reached eotThreshold",
+      ),
+  })
+  .describe(
+    "Deepgram Flux turn-detection tuning for live voice sessions (model-integrated end-of-turn)",
   );
 
 export const LiveVoiceConfigSchema = z
@@ -251,6 +281,9 @@ export const LiveVoiceConfigSchema = z
     frontModel: LiveVoiceFrontModelConfigSchema.default(
       LiveVoiceFrontModelConfigSchema.parse({}),
     ),
+    flux: LiveVoiceFluxConfigSchema.default(
+      LiveVoiceFluxConfigSchema.parse({}),
+    ),
     maxSessionDurationSeconds: z
       .number({
         error: "liveVoice.maxSessionDurationSeconds must be a number",
@@ -280,3 +313,4 @@ export type LiveVoiceFrontModelConfig = z.infer<
 export type LiveVoiceProgressConfig = z.infer<
   typeof LiveVoiceProgressConfigSchema
 >;
+export type LiveVoiceFluxConfig = z.infer<typeof LiveVoiceFluxConfigSchema>;

package/src/config/schemas/llm.ts

@@ -1,6 +1,9 @@
 import { z } from "zod";
 
-import { PROVIDERS_REQUIRING_BASE_URL_AND_MODELS } from "../../providers/inference/auth.js";
+import {
+  PROVIDERS_REQUIRING_BASE_URL_AND_MODELS,
+  ROUTING_IDENTITY_PROVIDERS,
+} from "../../providers/inference/auth.js";
 import { PROVIDER_CATALOG } from "../../providers/model-catalog.js";
 import { isCodexSubscriptionModel } from "../../providers/openai/codex-models.js";
 import {
@@ -25,32 +28,54 @@ import {
 // Provider enum
 // ---------------------------------------------------------------------------
 
-export const LLMProvider = z
-  .enum([
-    "anthropic",
-    "openai",
-    "gemini",
-    "ollama",
-    "fireworks",
-    "openrouter",
-    "vercel-ai-gateway",
-    "openai-compatible",
-    "minimax",
-    "atlascloud",
-    "together",
-    "litellm",
-    "baseten",
-    "poolside",
-    // Routing identities rather than adapters: "vellum" = the platform-managed
-    // route (upstream derived from the model at dispatch), "chatgpt" = the
-    // subscription route to OpenAI. Neither has a PROVIDER_CATALOG entry;
-    // dispatch substitutes the real upstream before any adapter lookup.
-    "vellum",
-    "chatgpt",
-  ])
-  .meta({ id: "LLMProvider" });
+/**
+ * The provider values the write surfaces accept today: adapter-backed
+ * catalog providers plus the two routing identities. The schema itself is
+ * an open string so a stored provider outside this list parses instead of
+ * stripping its profile; dispatch resolves such a label as a connection
+ * entry name and fails with an explainable resolution error when no row
+ * carries it. Write-time membership is enforced at the profiles route and
+ * the `commitConfigWrite` choke point (`unknownLlmProviderIssue`), which
+ * is where entry names unlock when the entries model enables them.
+ */
+export const KNOWN_LLM_PROVIDERS = [
+  "anthropic",
+  "openai",
+  "gemini",
+  "ollama",
+  "fireworks",
+  "openrouter",
+  "vercel-ai-gateway",
+  "openai-compatible",
+  "minimax",
+  "atlascloud",
+  "together",
+  "litellm",
+  "baseten",
+  "poolside",
+  // Routing identities rather than adapters: "vellum" = the platform-managed
+  // route (upstream derived from the model at dispatch), "chatgpt" = the
+  // subscription route to OpenAI. Neither has a PROVIDER_CATALOG entry;
+  // dispatch substitutes the real upstream before any adapter lookup.
+  "vellum",
+  "chatgpt",
+] as const;
+
+export const LLMProvider = z.string().min(1).meta({ id: "LLMProvider" });
 export type LLMProvider = z.infer<typeof LLMProvider>;
 
+/**
+ * Write-surface membership check for a provider value. Returns a message
+ * when the value is outside {@link KNOWN_LLM_PROVIDERS}, null when it is
+ * allowed. Pure and sync so the profiles route and the config-write choke
+ * point share one rule.
+ */
+export function unknownLlmProviderIssue(provider: string): string | null {
+  return (KNOWN_LLM_PROVIDERS as readonly string[]).includes(provider)
+    ? null
+    : `Invalid provider "${provider}". Valid providers: ${KNOWN_LLM_PROVIDERS.join(", ")}.`;
+}
+
 /**
  * Providers that can back `llm.defaultProvider`: the named columns of the
  * default-profile matrix plus every API-key catalog provider whose personal
@@ -70,10 +95,10 @@ export const DEFAULT_PROVIDER_CHOICES: readonly LLMProvider[] = [
         entry.defaultModel !== "",
     )
       .map((entry) => entry.id)
-      // A catalog provider absent from `LLMProvider` cannot be referenced by
-      // any profile, so it cannot back the defaults either.
+      // A catalog provider outside the known provider set cannot be
+      // referenced by any profile, so it cannot back the defaults either.
       .filter((id): id is LLMProvider =>
-        (LLMProvider.options as readonly string[]).includes(id),
+        (KNOWN_LLM_PROVIDERS as readonly string[]).includes(id),
       ),
   ]),
 ];
@@ -84,13 +109,15 @@ export function isDefaultProviderChoice(value: string): value is LLMProvider {
 
 /**
  * Default-provider choices whose profiles materialize from the shared BYOK
- * templates: every choice except the `vellum` routing identity, whose
- * defaults are pinned managed models.
+ * templates: every choice except the routing identities (`vellum`,
+ * `chatgpt`), whose defaults are pinned models on code-owned columns.
  */
 export function isByokDefaultProviderChoice(
   value: string,
 ): value is LLMProvider {
-  return value !== "vellum" && isDefaultProviderChoice(value);
+  return (
+    !ROUTING_IDENTITY_PROVIDERS.has(value) && isDefaultProviderChoice(value)
+  );
 }
 
 const DefaultProviderEnum = z.enum(
@@ -188,7 +215,7 @@ export const LLMCallSiteEnum = z.enum([
   "skillCategoryInference",
   "inference",
   "vision",
-  "voiceFrontDecision",
+  "voiceProgressNarration",
   "voiceFrontDoor",
   "trustRuleSuggestion",
   "homeGreeting",

package/src/config/schemas/mcp.ts

@@ -109,3 +109,26 @@ export const McpConfigSchema = z
 export type McpTransport = z.infer<typeof McpTransportSchema>;
 export type McpServerConfig = z.infer<typeof McpServerConfigSchema>;
 export type McpConfig = z.infer<typeof McpConfigSchema>;
+
+/**
+ * Who declared a server: the workspace `config.json`, which the user owns,
+ * or a plugin's `mcp.json`, which its author owns.
+ *
+ * Deliberately not a schema field. It is resolved from where the entry was
+ * read, never parsed from a file, so nothing on disk can claim to be
+ * workspace-owned. What it gates is credential access: only a workspace
+ * server resolves `mcp:<serverId>:*` from the credential store, because a
+ * plugin controls both its server key and its URL and would otherwise
+ * receive a workspace credential at an endpoint it chose.
+ */
+export type McpServerSource = "workspace" | "plugin";
+
+/** A server config with its origin resolved. */
+export interface ResolvedMcpServerConfig extends McpServerConfig {
+  readonly source: McpServerSource;
+}
+
+/** The MCP config the daemon runs: both origins, every server attributed. */
+export interface ResolvedMcpConfig extends Omit<McpConfig, "servers"> {
+  readonly servers: Record<string, ResolvedMcpServerConfig>;
+}

package/src/config/schemas/plugin-updates.ts

@@ -5,11 +5,15 @@ import { z } from "zod";
  *
  * The resource monitor process runs a periodic sweep (see
  * `monitoring/plugin-auto-update.ts`) that moves every installed, enabled
- * plugin to its source's current revision. The sweep is off by default:
+ * marketplace plugin to the catalog's current pin. The sweep is off by default:
  * `mode: "manual"` means nothing upgrades unless a human runs
  * `assistant plugins upgrade <name>` (or the equivalent route), which is the
  * behavior every workspace had before this block existed. Setting
  * `mode: "auto"` opts the workspace into the hourly sweep.
+ *
+ * Opting in never covers plugins installed straight from a GitHub URL. Those
+ * track a mutable ref rather than a reviewed pin, so the sweep leaves them to
+ * an explicit `assistant plugins upgrade`.
  */
 export const PluginUpdatesConfigSchema = z
   .object({
@@ -19,7 +23,7 @@ export const PluginUpdatesConfigSchema = z
       })
       .default("manual")
       .describe(
-        'How installed plugins move to newer revisions. "manual" (default) never upgrades on its own — upgrades happen only when a human asks for one. "auto" lets the resource monitor upgrade every installed, enabled plugin on the `checkIntervalMs` cadence.',
+        'How installed plugins move to newer revisions. "manual" (default) never upgrades on its own: upgrades happen only when a human asks for one. "auto" lets the resource monitor upgrade every installed, enabled marketplace plugin on the `checkIntervalMs` cadence. Plugins installed directly from a GitHub URL are never upgraded automatically, since they track a mutable ref instead of a reviewed pin.',
       ),
     strategy: z
       // Deliberately narrower than the full `PluginUpgradeStrategy` union: the

package/src/config/schemas/stt.ts

@@ -6,6 +6,7 @@ import { z } from "zod";
  */
 export const VALID_STT_PROVIDERS = [
   "deepgram",
+  "deepgram-flux",
   "google-gemini",
   "openai-whisper",
   "xai",

package/src/config/skills.ts

@@ -104,11 +104,18 @@ export interface SkillSummary {
   owner?: OwnerInfo;
   /** Parsed tool manifest metadata, if the skill has a valid TOOLS.json. */
   toolManifest?: SkillToolManifestMeta;
-  /** IDs of child skills that this skill includes (metadata-only, not auto-activated). */
+  /**
+   * IDs of child skills this skill composes. `skill_load` inlines each child's
+   * body and projects its tools when the parent loads (tools/skills/load.ts);
+   * they play no part in which skills get selected for a turn.
+   */
   includes?: string[];
   /** Feature flag ID declared in frontmatter. Only skills with this field are subject to feature flag gating. */
   featureFlag?: string;
-  /** Compact routing cues projected into <available_skills> XML to guide skill selection. */
+  /**
+   * Intent phrases rendered into the skill's capability card as "Use when: ..."
+   * (memory substrate/skill-content.ts), which is the text skill routing scores.
+   */
   activationHints?: string[];
   /** Conditions under which this skill should NOT be loaded. */
   avoidWhen?: string[];

package/src/context/outbound-sanitize.ts

@@ -102,6 +102,96 @@ export function compactAxTreeHistory(messages: Message[]): Message[] {
   });
 }
 
+/**
+ * Full-wrapper matcher for the `<channel_capabilities>` block. Both ends are
+ * required so a user message that merely opens with the tag (someone pasting
+ * prompt markup into chat) is never mistaken for an injected block, the same
+ * discipline `stripUserTextBlocksByPrefix` uses in `strip-injections.ts`.
+ */
+const CHANNEL_CAPABILITIES_OPEN = "<channel_capabilities>\n";
+const CHANNEL_CAPABILITIES_CLOSE = "\n</channel_capabilities>";
+
+/** Whether a text block is a complete `<channel_capabilities>…` block. */
+function isChannelCapabilitiesBlock(text: string): boolean {
+  return (
+    text.startsWith(CHANNEL_CAPABILITIES_OPEN) &&
+    text.endsWith(CHANNEL_CAPABILITIES_CLOSE)
+  );
+}
+
+/**
+ * Drop `<channel_capabilities>` blocks that repeat the last one still standing,
+ * so a conversation carries one copy per distinct set of capabilities instead
+ * of one per turn.
+ *
+ * Runtime injection prepends this block to the turn-starting user message and
+ * then freezes it into history: live, because injection splices into the
+ * conversation's own message array, and across restarts, because `loadFromDb`
+ * rehydrates it from message metadata. Nothing ever removes it, so an N-turn
+ * channel conversation ships N copies. Unlike `<turn_context>`, which at least
+ * carries a fresh timestamp, this block is a pure function of the channel
+ * (`buildChannelCapabilityBlock`): every copy after the first is byte-identical
+ * to the one above it and tells the model nothing it has not already read.
+ *
+ * ## Why "same as the last retained copy" and not "not the current turn"
+ *
+ * Prompt caching only pays off when the bytes a provider marked in turn N are
+ * still at the same position in turn N+1, an invariant this repo enforces end
+ * to end in `prompt-cache-cross-turn-stability.test.ts`. Any rule of the form
+ * "keep it on the current turn, collapse it above" necessarily re-renders one
+ * message every turn (the turn that just ended), which is a full cache miss on
+ * the whole message prefix, every turn, for every conversation.
+ *
+ * Comparing against the last RETAINED copy avoids that entirely: whether a
+ * given occurrence survives depends only on the messages above it, never on
+ * how many turns come later. A message's rendering is therefore fixed the
+ * moment it is written, and the prefix stays byte-stable as the conversation
+ * grows. Capabilities that genuinely change mid-conversation (the same
+ * conversation resumed from a different client) still differ from the retained
+ * copy, so the new block is kept and the model sees the change.
+ *
+ * The cost is placement: the surviving copy sits at the top of the conversation
+ * rather than next to the newest message. It is the same bytes either way.
+ *
+ * Idempotent, like every other transform in this module: re-running it over an
+ * already-deduplicated history retains exactly the same occurrences.
+ */
+export function dedupeChannelCapabilityBlocks(history: Message[]): Message[] {
+  let lastRetained: string | null = null;
+  let changed = false;
+
+  const next = history.map((message) => {
+    if (message.role !== "user") {
+      return message;
+    }
+
+    let messageChanged = false;
+    const content = message.content.filter((block) => {
+      if (block.type !== "text" || !isChannelCapabilitiesBlock(block.text)) {
+        return true;
+      }
+      if (block.text === lastRetained) {
+        messageChanged = true;
+        return false;
+      }
+      lastRetained = block.text;
+      return true;
+    });
+
+    // A user row is never only injections in practice, but guard anyway: an
+    // empty content array is not a message any provider will accept, and
+    // dropping the row would break tool_use/tool_result pairing and the
+    // row-to-history index mapping `summarizeUpToMessage` relies on.
+    if (!messageChanged || content.length === 0) {
+      return message;
+    }
+    changed = true;
+    return { ...message, content };
+  });
+
+  return changed ? next : history;
+}
+
 /**
  * Index of the last user message carrying `tool_result` blocks — the
  * "current turn" boundary {@link stripOldMediaBlocks} keeps intact while
@@ -194,6 +284,9 @@ function stripOldMediaBlocks(history: Message[]): Message[] {
  *   `web_search_tool_result` blocks to text summaries; Anthropic's opaque
  *   `encrypted_content` tokens expire / are route-scoped, and replaying a stale
  *   one is rejected with `Invalid encrypted_content in search_result block`.
+ * - {@link dedupeChannelCapabilityBlocks} keeps one `<channel_capabilities>`
+ *   block per distinct set of capabilities instead of the one-per-turn history
+ *   accumulates; every repeat is byte-identical to the copy above it.
  *
  * Transforms the outbound copy only — the durable history keeps the rich
  * originals and each send re-derives the sanitized projection (every transform
@@ -206,5 +299,7 @@ function stripOldMediaBlocks(history: Message[]): Message[] {
 export function preModelCallSanitize(history: Message[]): Message[] {
   const mediaStripped = stripOldMediaBlocks(history);
   const axCompacted = compactAxTreeHistory(mediaStripped);
-  return stripHistoricalWebSearchResults(axCompacted).messages;
+  const webSearchStripped =
+    stripHistoricalWebSearchResults(axCompacted).messages;
+  return dedupeChannelCapabilityBlocks(webSearchStripped);
 }

package/src/daemon/__tests__/conversation-surfaces-launch.test.ts

@@ -158,7 +158,7 @@ function makeContext(overrides?: Partial<Conversation>): HarnessContext {
 
   const base = asConversation({
     conversationId: "origin-conv-id",
-    sendToClient: (msg) => sent.push(msg),
+    emit: (msg) => sent.push(msg),
     pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
     lastSurfaceAction: new Map<
       string,