@vellumai/assistant 0.11.6 → 0.11.7-staging.2

package/src/daemon/handlers/config-discord-channel.ts

@@ -0,0 +1,301 @@
+/**
+ * Connect and disconnect the Discord bot: the assistant's own identity in a
+ * server, not a grant to act as the person who authorized it. The user-scoped
+ * `discord` OAuth provider is a different surface and is untouched here.
+ *
+ * Storing the credential IS the connection. The gateway's Discord client is
+ * credential-gated (`gateway/src/index.ts`, "Discord Gateway lifecycle"): the
+ * watcher's next tick starts it when the token appears and tears it down when
+ * it goes, so there is no webhook to register and no restart to arrange.
+ */
+
+import { CHANNEL_BOT_PROVIDER } from "@vellumai/service-contracts/channels";
+import { z } from "zod";
+
+import {
+  getConfig,
+  invalidateConfigCache,
+  loadRawConfig,
+  saveRawConfig,
+  setNestedValue,
+} from "../../config/loader.js";
+import { DISCORD_API_BASE_URL } from "../../messaging/providers/discord/api.js";
+import {
+  ensureManualTokenConnection,
+  removeManualTokenConnection,
+} from "../../oauth/manual-token-connection.js";
+import { credentialKey } from "../../security/credential-key.js";
+import {
+  deleteSecureKeyAsync,
+  getSecureKeyAsync,
+  setSecureKeyAsync,
+} from "../../security/secure-keys.js";
+import {
+  deleteCredentialMetadata,
+  upsertCredentialMetadata,
+} from "../../tools/credentials/metadata-store.js";
+import { ChannelConfigResultBaseSchema } from "./channel-config-result.js";
+import { log } from "./shared.js";
+
+/**
+ * From the shared vocabulary rather than a literal: `manual-token-providers`
+ * declares this bot's credential fields under the same constant, and a second
+ * spelling would be free to disagree with it.
+ */
+const DISCORD_PROVIDER = CHANNEL_BOT_PROVIDER.discord;
+
+/**
+ * The fields read back from Discord when a token validates. Parsed rather than
+ * cast: this runs at a network boundary and what it keeps is written into
+ * config, so a shape Discord did not send should fail here rather than persist
+ * as an undefined the reader silently tolerates.
+ */
+const DiscordBotIdentitySchema = z.object({
+  id: z.string().optional(),
+  username: z.string().optional(),
+});
+
+/**
+ * The application read, including its own install settings. The portal's
+ * Installation page writes Default Install Settings to
+ * `integration_types_config["0"].oauth2_install_params` (`0` is
+ * GUILD_INSTALL); top-level `install_params` is the older in-app
+ * authorization link, still served for apps that configured it.
+ */
+const DiscordInstallParamsSchema = z.object({
+  scopes: z.array(z.string()).optional(),
+});
+const DiscordApplicationSchema = z.object({
+  id: z.string().optional(),
+  install_params: DiscordInstallParamsSchema.optional(),
+  integration_types_config: z
+    .record(
+      z.string(),
+      z.object({
+        oauth2_install_params: DiscordInstallParamsSchema.optional(),
+      }),
+    )
+    .optional(),
+});
+
+/**
+ * The permission integer a parameterized invite link requests: View Channels,
+ * Send Messages, Send Messages in Threads, Embed Links, Attach Files, Read
+ * Message History, Add Reactions, Use External Emojis, Use Slash Commands.
+ * The setup skill's invite script derives the same integer from named bits;
+ * skills are import-isolated from this package, so the value is stated here
+ * and pinned equal by the connect test.
+ */
+const DISCORD_INVITE_PERMISSIONS = "277025770560";
+
+/**
+ * The install link for the application, total over every app state.
+ *
+ * An app whose own install settings grant the `bot` scope gets a link
+ * carrying only the client id, so the grant is whatever the owner configured
+ * and an edit on the portal's Installation page takes effect. Any other app,
+ * including the fresh one the wizard's create step just made, gets the
+ * parameterized link: a client-id-only link installs nothing without
+ * settings, and explicit scope and permission parameters are honored
+ * regardless of them.
+ */
+function buildDiscordInviteUrl(
+  app: z.infer<typeof DiscordApplicationSchema>,
+): string | undefined {
+  if (!app.id) {
+    return undefined;
+  }
+  const url = new URL("https://discord.com/oauth2/authorize");
+  url.searchParams.set("client_id", app.id);
+  const settingsScopes =
+    app.integration_types_config?.["0"]?.oauth2_install_params?.scopes ??
+    app.install_params?.scopes ??
+    [];
+  if (!settingsScopes.includes("bot")) {
+    url.searchParams.set("permissions", DISCORD_INVITE_PERMISSIONS);
+    url.searchParams.set("scope", "bot");
+  }
+  return url.toString();
+}
+
+export const DiscordChannelConfigResultSchema =
+  ChannelConfigResultBaseSchema.extend({
+    /** The bot's own account, read back from Discord when the token validates. */
+    botUserId: z.string().optional(),
+    botUsername: z.string().optional(),
+    /**
+     * The application the bot belongs to. Read from Discord rather than
+     * assumed equal to the bot user id: they coincide today, and anything
+     * built on that assumption breaks silently if it ever stops being true.
+     */
+    applicationId: z.string().optional(),
+    /**
+     * The install link for the bot's application, computed daemon-side from
+     * the application's own install settings so no client re-derives the
+     * grant rules. Absent until a token has validated.
+     */
+    inviteUrl: z.string().optional(),
+  });
+
+export type DiscordChannelConfigResult = z.infer<
+  typeof DiscordChannelConfigResultSchema
+>;
+
+/**
+ * A failed operation still reports the current state. For Discord "connected"
+ * and "has a token" are one question, since the gateway's client exists while
+ * the credential does.
+ */
+async function failure(error: string): Promise<DiscordChannelConfigResult> {
+  const hasToken = await hasStoredBotToken();
+  return { success: false, hasBotToken: hasToken, connected: hasToken, error };
+}
+
+async function hasStoredBotToken(): Promise<boolean> {
+  return Boolean(
+    await getSecureKeyAsync(credentialKey(DISCORD_PROVIDER, "bot_token")),
+  );
+}
+
+/** Current state, without touching anything. */
+export async function getDiscordChannelConfig(): Promise<DiscordChannelConfigResult> {
+  const { discord } = getConfig();
+  const hasToken = await hasStoredBotToken();
+  return {
+    success: true,
+    hasBotToken: hasToken,
+    connected: hasToken,
+    ...(discord.botUserId ? { botUserId: discord.botUserId } : {}),
+    ...(discord.botUsername ? { botUsername: discord.botUsername } : {}),
+    ...(discord.applicationId ? { applicationId: discord.applicationId } : {}),
+    ...(discord.inviteUrl ? { inviteUrl: discord.inviteUrl } : {}),
+  };
+}
+
+/**
+ * Validate a bot token with Discord and store it.
+ *
+ * Recording the bot's own account is what lets a connected panel name it
+ * rather than say "connected": the gateway learns that identity only at
+ * READY, which no caller here can wait for.
+ */
+export async function setDiscordChannelConfig(
+  botToken?: string,
+): Promise<DiscordChannelConfigResult> {
+  if (!botToken?.trim()) {
+    return failure("botToken is required");
+  }
+  const token = botToken.trim();
+
+  let botUserId: string | undefined;
+  let botUsername: string | undefined;
+  let applicationId: string | undefined;
+  let inviteUrl: string | undefined;
+  try {
+    // Not `callDiscordApi`: that resolves the stored credential, and this
+    // token is not stored yet. Validating first is what keeps an invalid one
+    // out of secure storage, where it would start a connection that cannot
+    // authenticate.
+    const headers = { Authorization: `Bot ${token}` };
+    const signal = () => AbortSignal.timeout(10_000);
+    // Both answer from the token alone, so they go together. The application
+    // read is optional and swallows its own failure: it enriches the result
+    // and must never be the reason a valid token is rejected.
+    const [res, appRes] = await Promise.all([
+      fetch(`${DISCORD_API_BASE_URL}/users/@me`, {
+        headers,
+        signal: signal(),
+      }),
+      fetch(`${DISCORD_API_BASE_URL}/oauth2/applications/@me`, {
+        headers,
+        signal: signal(),
+      }).catch(() => null),
+    ]);
+    if (!res.ok) {
+      throw new Error(`Discord returned ${res.status}`);
+    }
+    const me = DiscordBotIdentitySchema.parse(await res.json());
+    botUserId = me.id;
+    botUsername = me.username;
+
+    if (appRes?.ok) {
+      const app = DiscordApplicationSchema.safeParse(await appRes.json());
+      if (app.success) {
+        applicationId = app.data.id;
+        inviteUrl = buildDiscordInviteUrl(app.data);
+      }
+    }
+  } catch (err) {
+    // The body is not echoed: this path runs with a secret in hand, and the
+    // caller only needs to know the token was rejected.
+    log.warn({ err }, "Discord bot token validation failed");
+    return failure(
+      "Discord rejected this bot token. Check it was copied from the Bot tab of your application, and reset it there if it was shown before.",
+    );
+  }
+
+  const stored = await setSecureKeyAsync(
+    credentialKey(DISCORD_PROVIDER, "bot_token"),
+    token,
+  );
+  if (!stored) {
+    return failure("Failed to store the bot token in secure storage");
+  }
+  upsertCredentialMetadata(DISCORD_PROVIDER, "bot_token", {});
+
+  const raw = loadRawConfig();
+  setNestedValue(raw, "discord.botUserId", botUserId ?? "");
+  setNestedValue(raw, "discord.botUsername", botUsername ?? "");
+  setNestedValue(raw, "discord.applicationId", applicationId ?? "");
+  setNestedValue(raw, "discord.inviteUrl", inviteUrl ?? "");
+  saveRawConfig(raw);
+  invalidateConfigCache();
+
+  await ensureManualTokenConnection(
+    DISCORD_PROVIDER,
+    botUsername ? `@${botUsername}` : undefined,
+  );
+
+  log.info({ botUserId, botUsername }, "Discord bot token stored");
+  return {
+    success: true,
+    hasBotToken: true,
+    connected: true,
+    ...(botUserId ? { botUserId } : {}),
+    ...(botUsername ? { botUsername } : {}),
+    ...(applicationId ? { applicationId } : {}),
+    ...(inviteUrl ? { inviteUrl } : {}),
+  };
+}
+
+/**
+ * Clear the stored credential, which disconnects the bot.
+ *
+ * A legacy `discord.allowedChannelIds` entry, where one exists, is left
+ * alone on purpose: the gateway still enforces it as persisted operator
+ * intent, so reconnecting the same bot must not silently widen its room
+ * scope by clearing it here.
+ */
+export async function clearDiscordChannelConfig(): Promise<DiscordChannelConfigResult> {
+  const deleted = await deleteSecureKeyAsync(
+    credentialKey(DISCORD_PROVIDER, "bot_token"),
+  );
+  if (deleted === "error") {
+    // The token is still stored, so the gateway's client stays connected: a
+    // success here would report a disconnect that did not happen.
+    return failure("Failed to delete the bot token from secure storage");
+  }
+  deleteCredentialMetadata(DISCORD_PROVIDER, "bot_token");
+  await removeManualTokenConnection(DISCORD_PROVIDER);
+
+  const raw = loadRawConfig();
+  setNestedValue(raw, "discord.botUserId", "");
+  setNestedValue(raw, "discord.botUsername", "");
+  setNestedValue(raw, "discord.applicationId", "");
+  setNestedValue(raw, "discord.inviteUrl", "");
+  saveRawConfig(raw);
+  invalidateConfigCache();
+
+  log.info("Discord bot token cleared");
+  return { success: true, hasBotToken: false, connected: false };
+}

package/src/daemon/handlers/config-ingress.ts

@@ -5,6 +5,7 @@ import {
   normalizePublicBaseUrl,
   parseRecordedAssistantId,
   parseTunnelRecord,
+  selectRestartTunnelRecord,
   type TunnelRecord,
 } from "@vellumai/service-contracts/ingress";
 
@@ -60,6 +61,14 @@ export function loadPairingTunnelRecord(): TunnelRecord | null {
   return parseTunnelRecord(readIngressSection()[INGRESS_PAIRING_TUNNEL_KEY]);
 }
 
+/**
+ * Read the tunnel a reader should offer to restart: the pairing-only record
+ * when one exists, else the last that ran.
+ */
+export function loadRestartTunnelRecord(): TunnelRecord | null {
+  return selectRestartTunnelRecord(readIngressSection());
+}
+
 /**
  * Read the assistant id the last tunnel fronted, or null when absent. The
  * daemon cannot derive it: it scopes itself as `self` internally.

package/src/daemon/handlers/config-slack-channel.ts

@@ -24,6 +24,7 @@ import {
   getCredentialMetadata,
   upsertCredentialMetadata,
 } from "../../tools/credentials/metadata-store.js";
+import { ChannelConfigResultBaseSchema } from "./channel-config-result.js";
 import { log as _log } from "./shared.js";
 
 // -- Result type --
@@ -31,21 +32,18 @@ import { log as _log } from "./shared.js";
 export const SlackThreadMode = z.enum(["mention_only", "mention_then_thread"]);
 export type SlackThreadMode = z.infer<typeof SlackThreadMode>;
 
-export const SlackChannelConfigResultSchema = z.object({
-  success: z.boolean(),
-  hasBotToken: z.boolean(),
-  hasAppToken: z.boolean(),
-  hasUserToken: z.boolean(),
-  connected: z.boolean(),
-  teamId: z.string().optional(),
-  teamName: z.string().optional(),
-  teamUrl: z.string().optional(),
-  botUserId: z.string().optional(),
-  botUsername: z.string().optional(),
-  threadMode: SlackThreadMode,
-  error: z.string().optional(),
-  warning: z.string().optional(),
-});
+export const SlackChannelConfigResultSchema =
+  ChannelConfigResultBaseSchema.extend({
+    hasAppToken: z.boolean(),
+    hasUserToken: z.boolean(),
+    teamId: z.string().optional(),
+    teamName: z.string().optional(),
+    teamUrl: z.string().optional(),
+    botUserId: z.string().optional(),
+    botUsername: z.string().optional(),
+    threadMode: SlackThreadMode,
+    warning: z.string().optional(),
+  });
 
 export type SlackChannelConfigResult = z.infer<
   typeof SlackChannelConfigResultSchema

package/src/daemon/handlers/config-telegram.ts

@@ -28,6 +28,7 @@ import {
   deleteCredentialMetadata,
   upsertCredentialMetadata,
 } from "../../tools/credentials/metadata-store.js";
+import { ChannelConfigResultBaseSchema } from "./channel-config-result.js";
 import { log } from "./shared.js";
 
 const TELEGRAM_BOT_TOKEN_IN_URL_PATTERN =
@@ -61,15 +62,11 @@ function summarizeTelegramError(err: unknown): string {
 
 // -- Transport-agnostic result type (omits the `type` discriminant) --
 
-export const TelegramConfigResultSchema = z.object({
-  success: z.boolean(),
-  hasBotToken: z.boolean(),
+export const TelegramConfigResultSchema = ChannelConfigResultBaseSchema.extend({
   botId: z.string().optional(),
   botUsername: z.string().optional(),
-  connected: z.boolean(),
   hasWebhookSecret: z.boolean(),
   lastError: z.string().optional(),
-  error: z.string().optional(),
   commandsRegistered: z.array(z.string()).optional(),
   warning: z.string().optional(),
 });

package/src/daemon/handlers/conversations.ts

@@ -43,8 +43,6 @@ export function handleConfirmationResponse(msg: ConfirmationResponse): void {
     if (conversation.hasPendingConfirmation(msg.requestId)) {
       touchConversation(conversationId);
       conversation.handleConfirmationResponse(msg.requestId, decision, {
-        selectedPattern: msg.selectedPattern,
-        selectedScope: msg.selectedScope,
         emissionContext: { source: "button" },
       });
       return;

package/src/daemon/handlers/skills.ts

@@ -67,6 +67,11 @@ import {
   deleteManagedSkill,
   validateManagedSkillId,
 } from "../../skills/managed-store.js";
+import {
+  filterSkillsByPlatform,
+  isSkillCompatibleWithPlatform,
+  skillPlatformUnavailableMessage,
+} from "../../skills/platform-compatibility.js";
 import type { SkillFileProvider } from "../../skills/skill-file-provider.js";
 import { createSkillsShProvider } from "../../skills/skillssh-files.js";
 import type { SkillAuditData } from "../../skills/skillssh-registry.js";
@@ -475,7 +480,7 @@ async function listSkillsWithCatalog(): Promise<SlimSkillResponse[]> {
 
   // All entries from the Vellum platform API are first-party.
   // Create SlimSkillResponses for catalog skills not already installed.
-  const available: SlimSkillResponse[] = catalogSkills
+  const available: SlimSkillResponse[] = filterSkillsByPlatform(catalogSkills)
     .filter((cs) => !installedIds.has(cs.id))
     .map((cs) => catalogSkillToSlim(cs));
 
@@ -1227,11 +1232,17 @@ export async function installSkill(spec: {
     // Bundled skills are already available — no install needed
     const catalog = loadSkillCatalog();
 
-    // Feature flag gate: reject install if the skill's flag is disabled
+    // Reject install if the skill is unsupported on this host or its flag is disabled
     const config = getConfig();
-    const flaggedSkill = catalog.find((s) => s.id === spec.slug);
-    if (flaggedSkill) {
-      const flagKey = skillFlagKey(flaggedSkill);
+    const catalogSkill = catalog.find((s) => s.id === spec.slug);
+    if (catalogSkill) {
+      if (!isSkillCompatibleWithPlatform(catalogSkill)) {
+        return {
+          success: false,
+          error: skillPlatformUnavailableMessage(spec.slug, catalogSkill),
+        };
+      }
+      const flagKey = skillFlagKey(catalogSkill);
       if (flagKey && !isAssistantFeatureFlagEnabled(flagKey, config)) {
         return {
           success: false,
@@ -1277,6 +1288,12 @@ export async function installSkill(spec: {
         const vellumCatalog = await getCatalog();
         const catalogEntry = vellumCatalog.find((s) => s.id === spec.slug);
         if (catalogEntry) {
+          if (!isSkillCompatibleWithPlatform(catalogEntry)) {
+            return {
+              success: false,
+              error: skillPlatformUnavailableMessage(spec.slug, catalogEntry),
+            };
+          }
           // Default `overwrite` to true at the handler boundary to preserve
           // pre-existing HTTP API behaviour. CLI callers always pass an
           // explicit boolean (`opts.overwrite ?? false`) so the CLI surface
@@ -1476,10 +1493,11 @@ export async function searchSkills(
     // hard-coded as catalog/available.
     const catalog = loadSkillCatalog();
     const config = getConfig();
-    const resolved = resolveSkillStates(catalog, config);
+    const compatibleCatalog = filterSkillsByPlatform(catalog);
+    const resolved = resolveSkillStates(compatibleCatalog, config);
     const resolvedById = new Map(resolved.map((r) => [r.summary.id, r]));
 
-    const catalogMatches = filterByQuery(catalog, query, [
+    const catalogMatches = filterByQuery(compatibleCatalog, query, [
       (s) => s.id,
       (s) => s.displayName,
       (s) => s.description,

package/src/daemon/lifecycle.ts

@@ -32,6 +32,7 @@ import { maybeEnqueueLexicalBackfillOnUpgrade } from "../persistence/job-handler
 import { clearLifecycleQuiesce } from "../persistence/lifecycle-quiesce.js";
 import { isPlatformClientConfigured } from "../platform/client.js";
 import { startConsentRefresh } from "../platform/consent-cache.js";
+import { syncAvatarToPlatform } from "../platform/sync-avatar.js";
 import { syncWorkspaceIdentityToPlatform } from "../platform/sync-identity.js";
 import { ensurePromptFiles } from "../prompts/system-prompt.js";
 import { runProviderConnectionsBackfill } from "../providers/inference/backfill.js";
@@ -695,9 +696,10 @@ export async function runDaemon(): Promise<void> {
 
   // Initialize providers before Qdrant so HTTP routes can begin accepting
   // requests while Qdrant initializes, then best-effort sync the workspace
-  // identity name to the platform record.
+  // identity name and avatar to the platform record.
   await initializeProviders(config);
   syncWorkspaceIdentityToPlatform();
+  syncAvatarToPlatform();
 
   // Start the idle/LRU/memory-pressure sweep over the in-memory conversation
   // pool.

package/src/daemon/message-types/messages.ts

@@ -33,8 +33,6 @@ export interface ConfirmationResponse {
   type: "confirmation_response";
   requestId: string;
   decision: "allow" | "deny";
-  selectedPattern?: string;
-  selectedScope?: string;
 }
 
 export interface SecretResponse {

package/src/daemon/tool-setup-types.ts

@@ -3,7 +3,7 @@
  * tool-setup ↔ doordash-steps and tool-setup ↔ tool-side-effects cycles.
  */
 
-import type { InterfaceId } from "../channels/types.js";
+import type { ClientOs, InterfaceId } from "../channels/types.js";
 
 /**
  * How a subagent/wake tool allowlist is enforced.
@@ -51,8 +51,8 @@ export interface SubagentToolStats {
  * transport interface, no channel capabilities), which drops client-gated
  * tools (`host_*`, `ui_*`, `ask_question`, `request_system_permission`) from
  * the wire definitions and breaks the cache prefix anyway. When this pin is
- * set on the conversation, `isToolActiveForContext` reads `hasNoClient` and
- * `transportInterface` exclusively from the pin and treats channel
+ * set on the conversation, `isToolActiveForContext` reads `hasNoClient`,
+ * `transportInterface`, and `clientOs` exclusively from the pin and treats channel
  * capabilities as unset — an absent optional field pins the value to
  * `undefined`; there is no fall-through to the live conversation state.
  * (Interactive-interface turns never set channel capabilities, so unset IS
@@ -70,6 +70,8 @@ export interface WakeToolContextPin {
   hasNoClient: boolean;
   /** The interface the source's live turns ran on (e.g. `"macos"`). */
   transportInterface?: InterfaceId;
+  /** The client OS the source's live turns reported. */
+  clientOs?: ClientOs;
   /**
    * Origin tag stamped onto `ToolContext.requestOrigin` for the duration of
    * the wake (e.g. `"memory_retrospective"`). Wakes bypass `runAgentLoopImpl`,

package/src/daemon/trust-context-types.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  sameTrustIdentity,
+  type TrustContext,
+} from "./trust-context-types.js";
+
+function contactTrust(
+  overrides: Partial<TrustContext> = {},
+): TrustContext {
+  return {
+    trustClass: "trusted_contact",
+    sourceChannel: "slack",
+    requesterExternalUserId: "U12345678",
+    requesterContactId: "contact-abc",
+    ...overrides,
+  };
+}
+
+describe("sameTrustIdentity", () => {
+  test("two identical contact contexts compare equal", () => {
+    expect(sameTrustIdentity(contactTrust(), contactTrust())).toBe(true);
+  });
+
+  test("a different contact id is a different actor", () => {
+    expect(
+      sameTrustIdentity(
+        contactTrust({ requesterContactId: "contact-abc" }),
+        contactTrust({ requesterContactId: "contact-xyz" }),
+      ),
+    ).toBe(false);
+  });
+});

package/src/heartbeat/__tests__/heartbeat-service.test.ts

@@ -75,7 +75,6 @@ mock.module("../../util/platform.js", () => ({
   getSandboxWorkingDir: () => join(workspaceDir ?? fallbackDir, "sandbox/work"),
   getSoundsDir: () => join(workspaceDir ?? fallbackDir, "sounds"),
   getAvatarDir: () => join(workspaceDir ?? fallbackDir, "avatar"),
-  AVATAR_IMAGE_FILENAME: "avatar-image.png",
   getAvatarImagePath: () =>
     join(workspaceDir ?? fallbackDir, "avatar/avatar-image.png"),
 

package/src/live-voice/__tests__/live-voice-flux-turn-end.test.ts

@@ -277,6 +277,13 @@ const FLUX_ON = {
   eotTimeoutMs: 500,
 } as const satisfies Partial<LiveVoiceFluxConfig>;
 
+// Turn-end is on by schema default, so a session that must run the local
+// silence boundary has to say so. Naming it keeps those tests about the
+// boundary they exercise rather than about a default they no longer own.
+const FLUX_OFF = {
+  turnEnd: { enabled: false },
+} as const satisfies Partial<LiveVoiceFluxConfig>;
+
 describe("LiveVoiceSession Flux end-of-turn", () => {
   test("commits the turn on turn-end without an endpoint-decision leg", async () => {
     const { frames, session, transcribers, turnCalls } = createHarness({
@@ -331,6 +338,7 @@ describe("LiveVoiceSession Flux end-of-turn", () => {
 
   test("ignores turn-end when the flag is off and keeps the hold path", async () => {
     const { frames, session, transcribers, turnCalls } = createHarness({
+      fluxConfig: FLUX_OFF,
       startVoiceTurn: autoCompletingTurn(),
     });
 
@@ -420,8 +428,9 @@ describe("LiveVoiceSession Flux end-of-turn", () => {
 
   test("records the commit latency on the front-door path too, with no hold", async () => {
     const { frames, session, transcribers, turnCalls } = createHarness({
-      // No flux config: the latch is down and the local silence boundary owns
+      // Turn-end off: the latch is down and the local silence boundary owns
       // the commit, which is arm A of the measurement run.
+      fluxConfig: FLUX_OFF,
       silenceThresholdMs: 40,
       emitMetrics: true,
       startVoiceTurn: autoCompletingTurn(),
@@ -823,7 +832,10 @@ describe("LiveVoiceSession Flux end-of-turn", () => {
 describe("LiveVoiceSession Flux end-of-turn during the STT dial", () => {
   beforeEach(() => {
     setConfig("services", {
-      stt: { provider: "deepgram-flux", providers: {} },
+      stt: {
+        provider: "deepgram",
+        providers: { deepgram: { model: "flux" } },
+      },
     });
   });
 
@@ -912,11 +924,53 @@ describe("LiveVoiceSession Flux end-of-turn during the STT dial", () => {
     await session.close("client_end");
   });
 
+  test("seeds the latch from the live-voice role, not the global provider", async () => {
+    // The configuration roles exist for: live voice on flux while the global
+    // stays on a family that owns no turn boundary. Seeding from the global
+    // leaves the latch false, and the opening utterance closes its silence
+    // boundary on the caller's side before the dial can correct it.
+    setConfig("services", {
+      stt: {
+        provider: "deepgram",
+        providers: { deepgram: {} },
+        roles: { liveVoice: { provider: "deepgram", model: "flux" } },
+      },
+    });
+    const gate = createDialGate();
+    const { frames, session, transcribers, turnCalls } = createHarness({
+      fluxConfig: FLUX_ON,
+      silenceThresholdMs: 40,
+      resolveGate: gate.promise,
+      startVoiceTurn: autoCompletingTurn(),
+    });
+
+    await session.start();
+    await session.handleBinaryAudio(LOUD_CHUNK);
+    await sleep(PAST_SILENCE_BOUNDARY_MS);
+
+    // Deferred under the seeded latch: Flux owns this boundary.
+    expect(countFrames(frames, "utterance_end")).toBe(0);
+    expect(turnCalls).toHaveLength(0);
+
+    gate.open();
+    await waitFor(() => transcribers.length > 0);
+    transcribers[0]?.endOfTurn("what is the weather");
+
+    await waitFor(
+      () => turnCalls.length === 1,
+      "The opening utterance never committed on the Flux end-of-turn",
+    );
+    expect(turnCalls[0]?.content).toBe("what is the weather");
+    expect(countFrames(frames, "utterance_end")).toBe(1);
+
+    await session.close("client_end");
+  });
+
   test("never seeds the latch when the flag is off", async () => {
     const gate = createDialGate();
     const { frames, session, transcribers, turnCalls } = createHarness({
-      // No fluxConfig: `turnEnd.enabled` keeps its schema default of false
-      // while config still names deepgram-flux as the provider.
+      // Turn-end explicitly off while config still selects the flux family.
+      fluxConfig: FLUX_OFF,
       silenceThresholdMs: 40,
       resolveGate: gate.promise,
       startVoiceTurn: autoCompletingTurn(),