@vellumai/assistant 0.11.3 → 0.11.4-staging.2

package/src/documents/document-store.ts

@@ -798,12 +798,125 @@ export function replaceInDocument(
   }
 }
 
+// ---------------------------------------------------------------------------
+// Append idempotency
+// ---------------------------------------------------------------------------
+
+/** A blank-line-delimited block of markdown, located in its source string. */
+interface MarkdownBlock {
+  /** Whitespace-trimmed block text, the unit duplicate detection compares. */
+  text: string;
+  /** Offset of the block's first character in the source string. */
+  start: number;
+}
+
+/**
+ * Split markdown into blank-line-delimited blocks, dropping empty ones but
+ * keeping each surviving block's offset so a suffix of the source can be
+ * recovered verbatim.
+ */
+function splitIntoBlocks(content: string): MarkdownBlock[] {
+  const blocks: MarkdownBlock[] = [];
+  const separator = /\n[^\S\n]*\n/g;
+  let cursor = 0;
+  let match: RegExpExecArray | null;
+  const push = (start: number, end: number): void => {
+    const text = content.slice(start, end).trim();
+    if (text.length > 0) {
+      blocks.push({ text, start });
+    }
+  };
+  while ((match = separator.exec(content)) !== null) {
+    push(cursor, match.index);
+    cursor = match.index + match[0].length;
+  }
+  push(cursor, content.length);
+  return blocks;
+}
+
+/**
+ * An append has to repeat at least this many characters of the document's tail
+ * before the repetition is treated as an accident.
+ *
+ * The floor is what keeps legitimate repetition intact. A document can honestly
+ * repeat a heading, a refrain, a table row, or a bare "TODO" back to back, and
+ * those are all short. Only a substantial restatement (an opening paragraph
+ * passed to both `document_create` and the first append) clears the bar.
+ */
+const MIN_DUPLICATE_APPEND_CHARS = 40;
+
+/**
+ * Drop a leading run of blocks from `markdown` that exactly repeats the tail of
+ * `existing`, so an append that restates content already committed does not
+ * write it a second time.
+ *
+ * The guard is deliberately narrow: the repeated run must be an exact,
+ * block-aligned match, it must sit at the very start of the append and the very
+ * end of the document, and it must be at least
+ * {@link MIN_DUPLICATE_APPEND_CHARS} long. Anything else, including the same
+ * text reappearing further down the append, is passed through untouched.
+ */
+function stripDuplicateLeadingBlocks(
+  existing: string,
+  markdown: string,
+): string {
+  const existingBlocks = splitIntoBlocks(existing);
+  const incomingBlocks = splitIntoBlocks(markdown);
+  const maxOverlap = Math.min(existingBlocks.length, incomingBlocks.length);
+
+  let overlap = 0;
+  for (let candidate = maxOverlap; candidate >= 1; candidate--) {
+    const offset = existingBlocks.length - candidate;
+    let matches = true;
+    for (let i = 0; i < candidate; i++) {
+      if (existingBlocks[offset + i].text !== incomingBlocks[i].text) {
+        matches = false;
+        break;
+      }
+    }
+    if (matches) {
+      overlap = candidate;
+      break;
+    }
+  }
+  if (overlap === 0) {
+    return markdown;
+  }
+
+  const duplicatedChars = incomingBlocks
+    .slice(0, overlap)
+    .reduce((total, block) => total + block.text.length, 0);
+  if (duplicatedChars < MIN_DUPLICATE_APPEND_CHARS) {
+    return markdown;
+  }
+
+  if (overlap === incomingBlocks.length) {
+    return "";
+  }
+  return markdown
+    .slice(incomingBlocks[overlap].start)
+    .replace(/^(?:[^\S\n]*\n)+/, "");
+}
+
+/** Outcome of a successful {@link updateDocumentContent} call. */
+export interface DocumentContentUpdated {
+  success: true;
+  /**
+   * The markdown that actually landed. Equals the submitted markdown except
+   * when an append's leading blocks duplicated the document's tail, in which
+   * case it is the remainder. Clients render this so their view matches the row.
+   */
+  appliedMarkdown: string;
+  /** True when a duplicated leading run was dropped from an append. */
+  duplicateLeadingContentSkipped: boolean;
+}
+
 /** Update persisted document content (append or replace). */
 export function updateDocumentContent(
   surfaceId: string,
   markdown: string,
   mode: string,
-): { success: true } | { success: false; error: string } {
+): DocumentContentUpdated | { success: false; error: string } {
   try {
     const existing = rawGet<{ content: string }>(
       "documents:updateDocumentContent:get",
@@ -814,9 +927,19 @@ export function updateDocumentContent(
       log.info({ surfaceId }, "No persisted document to update");
       return { success: false, error: "Document not found" };
     }
-    const sep = mode === "append" && existing.content.length > 0 ? "\n\n" : "";
-    const newContent =
-      mode === "append" ? existing.content + sep + markdown : markdown;
+    const appending = mode === "append";
+    const appliedMarkdown = appending
+      ? stripDuplicateLeadingBlocks(existing.content, markdown)
+      : markdown;
+    const duplicateLeadingContentSkipped =
+      appending && appliedMarkdown !== markdown;
+    const sep =
+      appending && existing.content.length > 0 && appliedMarkdown.length > 0
+        ? "\n\n"
+        : "";
+    const newContent = appending
+      ? existing.content + sep + appliedMarkdown
+      : appliedMarkdown;
     writeThroughToWorkspaceFile(surfaceId, newContent);
     const wordCount = countWords(newContent);
     rawRun(
@@ -827,8 +950,18 @@ export function updateDocumentContent(
       Date.now(),
       surfaceId,
     );
+    if (duplicateLeadingContentSkipped) {
+      log.info(
+        { surfaceId, skippedChars: markdown.length - appliedMarkdown.length },
+        "Skipped append content duplicating the document tail",
+      );
+    }
     log.info({ surfaceId, mode }, "Updated document content");
-    return { success: true };
+    return {
+      success: true,
+      appliedMarkdown,
+      duplicateLeadingContentSkipped,
+    };
   } catch (error) {
     log.error({ err: error, surfaceId }, "Document content update error");
     return {

package/src/hooks/hook-loader.ts

@@ -39,9 +39,9 @@
  * registry, so the next read re-resolves fresh.
  *
  * Plugin *discovery* (which plugin directories exist, in what order) lives in
- * `../plugins/mtime-cache.ts`; the orchestrator there passes the discovered
- * directories into {@link collectUserHookEntries}. Keeping discovery out of
- * this module lets it sit below the plugin cache with no import cycle.
+ * `../plugins/mtime-cache.ts`; hook lookup in `./registry.ts` passes the
+ * discovered names into {@link collectUserHookEntries}. Keeping discovery out
+ * of this module lets it sit below the plugin cache with no import cycle.
  */
 
 import {

package/src/hooks/registry.ts

@@ -6,20 +6,22 @@
  * hook-chain ordering.
  *
  * User-land hooks (from the filesystem) are owned by
- * {@link ./hook-loader.ts} and surfaced through `getUserHooksFor` in
- * `plugins/mtime-cache.ts`. This module owns only the in-process hooks that
- * default plugins register at boot.
+ * {@link ./hook-loader.ts} and surfaced through {@link getUserHooksFor}.
+ * This module owns the in-process hooks that default plugins register at
+ * boot, plus the user-land lookup that walks discovered plugin names from
+ * the plugin cache.
  *
  * {@link getHooksFor} combines both sources: in-process hooks from this
  * registry (filtered by `isPluginDisabled` at read time) and user-land hooks
  * from the plugin cache. The read-time filtering is what makes `assistant
- * plugins disable default-*` take effect immediately in a running assistant
- * — the hooks stay registered but are filtered out on the next turn.
+ * plugins disable default-*` take effect immediately in a running assistant:
+ * the hooks stay registered but are filtered out on the next turn.
  */
 
 import { isPluginDisabled } from "../plugins/disabled-state.js";
-import { getUserHookEntriesFor } from "../plugins/mtime-cache.js";
+import { getDiscoveredUserPluginNames } from "../plugins/mtime-cache.js";
 import type { HookEntry, HookFunction } from "../plugins/types.js";
+import { collectUserHookEntries } from "./hook-loader.js";
 
 // ─── Internal state ──────────────────────────────────────────────────────────
 
@@ -75,6 +77,48 @@ export function unregisterPluginHooks(pluginName: string): void {
 
 // ─── Queries ─────────────────────────────────────────────────────────────────
 
+/**
+ * Get all hooks for a given event name from user plugins and standalone
+ * workspace hooks, from the hook loader's in-memory cache. Plugin hooks run
+ * in install-date order, the workspace hook runs last.
+ *
+ * This is a pure cache read: it never scans disk, activates a plugin, or
+ * runs `init`. Activation happens only at boot (`populateCacheAtBoot`)
+ * and through the imperative install/uninstall poke
+ * (`reconcilePluginSourcesNow`), both main-daemon paths, so a
+ * sidecar process that dispatches hooks (a worker running conversation
+ * turns) can never bring a plugin up in its own process.
+ *
+ * `effectiveEnabledPlugins` carries the per-chat plugin scope: when non-null,
+ * user plugins outside the set are skipped (standalone workspace hooks always
+ * run). `null`/omitted means no per-chat restriction.
+ */
+export async function getUserHookEntriesFor<TCtx = unknown>(
+  hookName: string,
+  effectiveEnabledPlugins?: Set<string> | null,
+): Promise<HookEntry<TCtx>[]> {
+  return collectUserHookEntries<TCtx>(
+    hookName,
+    getDiscoveredUserPluginNames(),
+    effectiveEnabledPlugins,
+  );
+}
+
+/**
+ * {@link getUserHookEntriesFor} without owner attribution. Returns just the
+ * hook functions in the same order.
+ */
+export async function getUserHooksFor<TCtx = unknown>(
+  hookName: string,
+  effectiveEnabledPlugins?: Set<string> | null,
+): Promise<HookFunction<TCtx>[]> {
+  const entries = await getUserHookEntriesFor<TCtx>(
+    hookName,
+    effectiveEnabledPlugins,
+  );
+  return entries.map((e) => e.fn);
+}
+
 /**
  * Collect every registered hook for the given name, in registration order.
  * Plugins that don't declare a hook for `name` are skipped. Used by the

package/src/inbound/__tests__/oauth-callback-url.test.ts

@@ -0,0 +1,83 @@
+/**
+ * Tests for the shared OAuth callback URL resolver.
+ *
+ * The property that matters is stability: every caller and every attempt
+ * must get the same redirect URI. Dynamic client registration and Client
+ * ID Metadata Documents both pin `redirect_uris` when the client is
+ * registered, and the authorization server matches the value exactly on
+ * each authorization request, so a URI that varies per attempt makes both
+ * mechanisms unusable.
+ */
+
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+const resolveCallbackUrl = mock(
+  async () => "https://ingress.example/webhooks/oauth/callback",
+);
+
+mock.module("../platform-callback-registration.js", () => ({
+  resolveCallbackUrl,
+}));
+
+mock.module("../public-ingress-urls.js", () => ({
+  getOAuthCallbackUrl: () => "https://direct.example/webhooks/oauth/callback",
+}));
+
+mock.module("../../config/loader.js", () => ({
+  loadConfig: () => ({}),
+}));
+
+const { OAUTH_CALLBACK_PATH, resolveOauthCallbackUrl } =
+  await import("../oauth-callback-url.js");
+
+afterEach(() => {
+  resolveCallbackUrl.mockClear();
+});
+
+describe("resolveOauthCallbackUrl", () => {
+  test("returns whatever the shared resolver decides", async () => {
+    await expect(resolveOauthCallbackUrl()).resolves.toEqual(
+      "https://ingress.example/webhooks/oauth/callback",
+    );
+  });
+
+  test("registers the shared callback path, not a per-caller one", async () => {
+    await resolveOauthCallbackUrl();
+    const [, callbackPath] = resolveCallbackUrl.mock.calls[0] as unknown[];
+    expect(callbackPath).toEqual(OAUTH_CALLBACK_PATH);
+    expect(OAUTH_CALLBACK_PATH).toEqual("webhooks/oauth/callback");
+  });
+
+  test("every call resolves to the same URL, path, and registration type", async () => {
+    // The URI a client registers and the URI it later authorizes with are
+    // the same string, which is what an exact-match redirect_uri check
+    // needs. Nothing about the caller can vary it: the function takes no
+    // arguments.
+    const first = await resolveOauthCallbackUrl();
+    const second = await resolveOauthCallbackUrl();
+    expect(first).toEqual(second);
+
+    const [, pathA, typeA] = resolveCallbackUrl.mock.calls[0] as unknown[];
+    const [, pathB, typeB] = resolveCallbackUrl.mock.calls[1] as unknown[];
+    expect(pathA).toEqual(pathB);
+    expect(typeA).toEqual(typeB);
+  });
+
+  test("registers one route type so the platform holds a single admin row", async () => {
+    await resolveOauthCallbackUrl();
+    const [, , type] = resolveCallbackUrl.mock.calls[0] as unknown[];
+    expect(type).toEqual("oauth");
+  });
+
+  test("propagates the resolver's failure rather than inventing a URL", async () => {
+    // No ingress and no platform connection means there is no URL that
+    // would work. Returning a plausible one produces an authorization
+    // request whose callback silently never arrives.
+    resolveCallbackUrl.mockImplementationOnce(async () => {
+      throw new Error("No public base URL configured.");
+    });
+    await expect(resolveOauthCallbackUrl()).rejects.toThrow(
+      /No public base URL/,
+    );
+  });
+});

package/src/inbound/oauth-callback-url.ts

@@ -0,0 +1,61 @@
+/**
+ * Public URL resolution for the assistant's shared OAuth callback route.
+ *
+ * Every browser-based OAuth flow in the daemon redirects back to one path,
+ * `webhooks/oauth/callback`, which the gateway serves and forwards to
+ * `POST /v1/internal/oauth/callback`. The runtime matches the arriving
+ * `state` against `security/oauth-callback-registry.ts` and resolves the
+ * waiting flow, so one route multiplexes every concurrent handshake and no
+ * caller needs a listener of its own.
+ *
+ * Which base URL is correct depends on how the assistant is reachable: a
+ * platform pod and a platform-connected assistant are served through a
+ * managed callback route, a self-hosted deployment through its configured
+ * public ingress. `resolveCallbackUrl` owns that decision, and this is the
+ * OAuth-shaped entry point to it, mirroring `plugin-api/webhook-url.ts`
+ * for plugin ingress.
+ */
+
+import { loadConfig } from "../config/loader.js";
+import { resolveCallbackUrl } from "./platform-callback-registration.js";
+import { getOAuthCallbackUrl } from "./public-ingress-urls.js";
+
+/**
+ * Path the gateway serves the shared OAuth callback on.
+ *
+ * Fixed rather than caller-supplied. Every flow is demultiplexed by OAuth
+ * `state`, so a per-caller path would buy nothing and would need its own
+ * gateway route and its own platform registration.
+ */
+export const OAUTH_CALLBACK_PATH = "webhooks/oauth/callback";
+
+/**
+ * Registration type recorded with the platform.
+ *
+ * The platform keys a callback route by `(path, type)`, and there is one
+ * OAuth route, so one type describes it. Registering the same path under
+ * several types would produce duplicate admin rows pointing at the same
+ * URL.
+ */
+const OAUTH_REGISTRATION_TYPE = "oauth";
+
+/**
+ * Resolve the redirect URI an authorization server should send the user
+ * back to.
+ *
+ * Takes no arguments on purpose: every caller shares one route, so there
+ * is nothing to vary. That is what makes the URI stable across callers and
+ * across attempts, which is what an exact-match `redirect_uri` check needs.
+ *
+ * @throws when no public ingress is configured and the assistant is not
+ *   connected to the platform. There is no URL that would work in that
+ *   case, and returning a plausible one produces an authorization request
+ *   whose callback silently never arrives.
+ */
+export async function resolveOauthCallbackUrl(): Promise<string> {
+  return resolveCallbackUrl(
+    () => getOAuthCallbackUrl(loadConfig()),
+    OAUTH_CALLBACK_PATH,
+    OAUTH_REGISTRATION_TYPE,
+  );
+}

package/src/live-voice/__tests__/live-voice-agent-turn.test.ts

@@ -1,16 +1,13 @@
 import { describe, expect, mock, test } from "bun:test";
 
-import { sanitizeForTts } from "../../calls/tts-text-sanitizer.js";
 import type {
   VoiceTurnCallbacks,
   VoiceTurnOptions,
 } from "../../calls/voice-session-bridge.js";
-import type { LiveVoiceFrontModelConfig } from "../../config/schemas/live-voice.js";
 import type {
   StreamingTranscriber,
   SttStreamServerEvent,
 } from "../../stt/types.js";
-import type { VoiceFrontDecider } from "../front-decision.js";
 import {
   LiveVoiceSession,
   type LiveVoiceTtsStreamer,
@@ -96,8 +93,6 @@ function createSessionHarness(
     createTurnId?: () => string;
     emitMetrics?: boolean;
     streamTtsAudio?: LiveVoiceTtsStreamer;
-    frontModelConfig?: Partial<LiveVoiceFrontModelConfig>;
-    frontDecider?: VoiceFrontDecider;
   } = {},
 ) {
   const transcriber =
@@ -119,10 +114,6 @@ function createSessionHarness(
     ...(options.streamTtsAudio
       ? { streamTtsAudio: options.streamTtsAudio }
       : {}),
-    ...(options.frontModelConfig
-      ? { frontModelConfig: options.frontModelConfig }
-      : {}),
-    ...(options.frontDecider ? { frontDecider: options.frontDecider } : {}),
   });
 
   return { frames, session, startVoiceTurn, transcriber };
@@ -468,7 +459,7 @@ describe("LiveVoiceSession assistant turn", () => {
     });
   });
 
-  test("records tool_use_start on the active turn and publishes what it is doing", async () => {
+  test("publishes tool activity while the turn is running", async () => {
     let callbacks: VoiceTurnCallbacks | undefined;
     const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
       callbacks = options.callbacks;
@@ -488,12 +479,6 @@ describe("LiveVoiceSession assistant turn", () => {
     callbacks?.tool_use_start?.("some_tool");
     await waitForFrameCount(frames, 4);
 
-    const activeTurn = (
-      session as unknown as {
-        activeAssistantTurn: { toolUseStarted: boolean } | null;
-      }
-    ).activeAssistantTurn;
-    expect(activeTurn?.toolUseStarted).toBe(true);
     // One activity frame, so a silent stretch of tool work is visible on the
     // surfaces that show the session. An unrecognized tool still gets a line.
     expect(frames.at(-1)).toMatchObject({
@@ -560,90 +545,6 @@ describe("LiveVoiceSession assistant turn", () => {
   });
 });
 
-describe("LiveVoiceSession tool-use spoken ack", () => {
-  const ACK_TIMEOUT_MS = 40;
-  // Every ack is front-model-phrased; the generated text passes through the
-  // same TTS sanitizer as regular segments. The stub varies its phrasing by
-  // trigger so the two ack kinds stay distinguishable in assertions.
-  const TOOL_ACK = "Let me look that up.";
-  const FIRST_DELTA_ACK = "Sure — one moment.";
-  const EXPECTED_TOOL_ACK = sanitizeForTts(TOOL_ACK).trim();
-  const EXPECTED_FIRST_DELTA_ACK = sanitizeForTts(FIRST_DELTA_ACK).trim();
-
-  const ackDecider: VoiceFrontDecider = {
-    generateAckText: async (input) =>
-      input.toolName ? TOOL_ACK : FIRST_DELTA_ACK,
-    generateProgressText: async () => null,
-  };
-
-  function createAckHarness() {
-    const { startVoiceTurn, getCallbacks } = createCapturingTurnStarter();
-    const { streamTtsAudio, ttsTexts } = createRecordingTtsStreamer();
-    const harness = createSessionHarness({
-      startVoiceTurn,
-      streamTtsAudio,
-      frontModelConfig: { ackFirstDeltaTimeoutMs: ACK_TIMEOUT_MS },
-      frontDecider: ackDecider,
-    });
-    return { ...harness, getCallbacks, ttsTexts };
-  }
-
-  test("tool_use_start before any delta speaks an immediate tool ack and cancels the timer", async () => {
-    const { frames, session, getCallbacks, ttsTexts } = createAckHarness();
-
-    await startReleasedTurn(session, getCallbacks);
-    getCallbacks()?.tool_use_start?.("web_search");
-    await waitFor(() => ttsTexts.length === 1);
-    expect(ttsTexts).toEqual([EXPECTED_TOOL_ACK]);
-
-    // The pending first-delta timer was cancelled: letting its budget elapse
-    // speaks no second ack.
-    await new Promise((resolve) => setTimeout(resolve, ACK_TIMEOUT_MS + 40));
-    expect(ttsTexts).toEqual([EXPECTED_TOOL_ACK]);
-
-    // The ack is audio-only — no caption frame carries it.
-    expect(frames.some((frame) => frame.type === "assistant_text_delta")).toBe(
-      false,
-    );
-
-    emitTextDelta(getCallbacks, "Hello there.");
-    emitMessageComplete(getCallbacks);
-    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
-    expect(ttsTexts).toEqual([EXPECTED_TOOL_ACK, "Hello there."]);
-  });
-
-  test("tool_use_start after the first delta speaks no ack", async () => {
-    const { frames, session, getCallbacks, ttsTexts } = createAckHarness();
-
-    await startReleasedTurn(session, getCallbacks);
-    emitTextDelta(getCallbacks, "Hello there.");
-    getCallbacks()?.tool_use_start?.("web_search");
-    emitMessageComplete(getCallbacks);
-    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
-    await new Promise((resolve) => setTimeout(resolve, ACK_TIMEOUT_MS + 40));
-
-    expect(ttsTexts).toEqual(["Hello there."]);
-  });
-
-  test("tool_use_start after a first-delta ack already spoke adds no second ack", async () => {
-    const { frames, session, getCallbacks, ttsTexts } = createAckHarness();
-
-    await startReleasedTurn(session, getCallbacks);
-    // Let the slow-first-delta timer speak the turn's one ack first.
-    await waitFor(() => ttsTexts.length === 1);
-    expect(ttsTexts).toEqual([EXPECTED_FIRST_DELTA_ACK]);
-
-    getCallbacks()?.tool_use_start?.("web_search");
-    await flushAsyncCallbacks();
-    expect(ttsTexts).toEqual([EXPECTED_FIRST_DELTA_ACK]);
-
-    emitTextDelta(getCallbacks, "Hello there.");
-    emitMessageComplete(getCallbacks);
-    await waitFor(() => frames.some((frame) => frame.type === "tts_done"));
-    expect(ttsTexts).toEqual([EXPECTED_FIRST_DELTA_ACK, "Hello there."]);
-  });
-});
-
 describe("LiveVoiceSession room reveal", () => {
   function createMarkerHarness() {
     const { startVoiceTurn, getCallbacks } = createCapturingTurnStarter();
@@ -651,9 +552,6 @@ describe("LiveVoiceSession room reveal", () => {
     const harness = createSessionHarness({
       startVoiceTurn,
       streamTtsAudio,
-      // Deltas are emitted immediately in these runs; a long ack budget keeps
-      // filler phrases out of the recorded TTS text.
-      frontModelConfig: { ackFirstDeltaTimeoutMs: 10_000 },
     });
     return { ...harness, getCallbacks, ttsTexts };
   }
@@ -689,7 +587,6 @@ describe("LiveVoiceSession room reveal", () => {
     const harness = createSessionHarness({
       startVoiceTurn,
       streamTtsAudio,
-      frontModelConfig: { ackFirstDeltaTimeoutMs: 10_000 },
     });
     return {
       ...harness,

package/src/live-voice/__tests__/live-voice-events.test.ts

@@ -4,7 +4,6 @@ import type {
   VoiceTurnCallbacks,
   VoiceTurnOptions,
 } from "../../calls/voice-session-bridge.js";
-import { VOICE_NO_SETUP_FLOWS_RULE } from "../../calls/voice-session-bridge.js";
 import type {
   StreamingTranscriber,
   SttStreamServerEvent,
@@ -254,14 +253,14 @@ describe("LiveVoiceSession archive and metrics events", () => {
       userMessageInterface: "macos",
       assistantMessageInterface: "macos",
       // Pins the full production control prompt for the FRONT-DOOR leg (the
-      // first leg of every routed turn): the speech-first rule (which now
-      // permits a surface, since the room reveals one by itself) and the
-      // shared no-setup-flows rule (no OAuth/browser flows mid-call). The [-1]
-      // room-minimize teaching is deliberately absent — only the escalated
-      // leg learns it (see live-voice-triage-escalate.test.ts).
+      // first leg of every routed turn): the speech-first rule, and nothing
+      // else. This leg is toolless, so both the screen-reveal and setup-flow
+      // teachings are deliberately absent. It has nothing to show and no
+      // connection to run, and its capability digest already routes anything
+      // needing a tool to the escalated leg (see
+      // live-voice-triage-escalate.test.ts).
       voiceControlPrompt:
-        "You are speaking in a local live voice session. Keep replies brief and conversational. Speech is the main channel: say the answer, and do not narrate a surface instead of answering. You can also put something on screen when it genuinely helps (a form, a list to pick from, a progress card for long work); the call overlay minimizes by itself once you finish speaking, so the user sees it without doing anything. Never tell the user you cannot show them something. Reply in the language the caller is speaking; if they switch languages, switch with them. " +
-        VOICE_NO_SETUP_FLOWS_RULE,
+        "You are speaking in a local live voice session. Keep replies brief and conversational. Speech is the main channel: say the answer, and do not narrate a surface instead of answering. You can also put something on screen when it genuinely helps (a form, a list to pick from, a progress card for long work); the call overlay minimizes by itself once you finish speaking, so the user sees it without doing anything. Never tell the user you cannot show them something. Reply in the language the caller is speaking; if they switch languages, switch with them. ",
     });
     callbacks?.assistant_text_delta?.(makeTextDelta("Hello there."));
     callbacks?.message_complete?.(makeMessageComplete());