@vellumai/assistant 0.12.1-dev.202609141913.5e16607 → 0.12.1-staging.2

package/src/runtime/services/__tests__/conversation-serializer.test.ts

@@ -159,31 +159,3 @@ describe("serializeConversationSummary · enabledPlugins", () => {
     expect("enabledPlugins" in summary).toBe(false);
   });
 });
-
-describe("serializeConversationSummary · title keys", () => {
-  test("resolves a stored title key for the locale", () => {
-    const summary = serializeConversationSummary({
-      conversation: makeConversationRow({
-        title: "conversation.title.generating",
-      }),
-      displayMeta: { displayOrder: null, isPinned: false, groupId: null },
-      parentCache: new Map(),
-      isProcessing: false,
-      locale: "es",
-    });
-    expect(summary.title).toBe("Generando título...");
-    expect("titleState" in summary).toBe(false);
-  });
-
-  test("passes a stored display string through", () => {
-    const summary = serialize(
-      makeConversationRow({ title: "Untitled Conversation" }),
-    );
-    expect(summary.title).toBe("Untitled Conversation");
-  });
-
-  test("passes a custom title through", () => {
-    const summary = serialize(makeConversationRow({ title: "Weekly planning" }));
-    expect(summary.title).toBe("Weekly planning");
-  });
-});

package/src/runtime/services/conversation-serializer.ts

@@ -8,10 +8,6 @@
 
 import { parseChannelId } from "../../channels/types.js";
 import { normalizeConversationType } from "../../daemon/message-types/shared.js";
-import {
-  resolveConversationTitle,
-  type SupportedLocale,
-} from "../../i18n/index.js";
 import { buildChannelBindingMetadata } from "../../messaging/channel-binding-metadata.js";
 import {
   type AttentionState,
@@ -82,7 +78,6 @@ interface ForkLineage {
 function buildForkLineage(
   conversation: ConversationRow,
   parentCache: Map<string, ConversationRow | null>,
-  locale?: SupportedLocale,
 ): ForkLineage {
   const parentConversationId = conversation.forkParentConversationId;
   const parentMessageId = conversation.forkParentMessageId;
@@ -106,7 +101,7 @@ function buildForkLineage(
     forkParent: {
       conversationId: parentConversationId,
       messageId: parentMessageId,
-      title: resolveConversationTitle(parentConversation.title, locale),
+      title: parentConversation.title ?? "Untitled",
     },
   };
 }
@@ -183,11 +178,6 @@ export function serializeConversationSummary(params: {
    * with no daemon-store coupling.
    */
   isProcessing: boolean;
-  /**
-   * Locale used to resolve stored title keys. Omitted locale is English
-   * inside {@link resolveConversationTitle}.
-   */
-  locale?: SupportedLocale;
 }) {
   const {
     conversation,
@@ -196,15 +186,14 @@ export function serializeConversationSummary(params: {
     displayMeta,
     parentCache,
     isProcessing,
-    locale,
   } = params;
   const originChannel = parseChannelId(conversation.originChannel);
   const assistantAttention = buildAssistantAttention(attentionState);
-  const forkLineage = buildForkLineage(conversation, parentCache, locale);
+  const forkLineage = buildForkLineage(conversation, parentCache);
 
   return {
     id: conversation.id,
-    title: resolveConversationTitle(conversation.title, locale),
+    title: conversation.title ?? "Untitled",
     createdAt: conversation.createdAt,
     updatedAt: conversation.updatedAt,
     lastMessageAt: conversation.lastMessageAt,
@@ -264,7 +253,6 @@ export function serializeConversationSummary(params: {
  */
 export function buildConversationDetailResponse(
   conversationId: string,
-  locale?: SupportedLocale,
 ): { conversation: ReturnType<typeof serializeConversationSummary> } | null {
   const conversation = getConversation(conversationId);
   if (!conversation || conversation.conversationType === "private") {
@@ -286,7 +274,6 @@ export function buildConversationDetailResponse(
       // Checks in-memory flag first (hot path), falls back to the
       // persisted `processing_started_at` column for cold conversations.
       isProcessing: isConversationProcessing(conversation.id),
-      locale,
     }),
   };
 }

package/src/runtime/sync/resource-sync-events.ts

@@ -4,7 +4,6 @@ import {
   conversationMetadataSyncTag,
   SYNC_TAGS,
 } from "../../daemon/message-types/sync.js";
-import { resolveConversationTitle } from "../../i18n/index.js";
 import { syncAvatarToPlatform } from "../../platform/sync-avatar.js";
 import { getAvatarImagePath } from "../../util/platform.js";
 import { broadcastMessage } from "../assistant-event-hub.js";
@@ -258,7 +257,7 @@ export function publishConversationTitleChanged(
     {
       type: "conversation_title_updated",
       conversationId,
-      title: resolveConversationTitle(title),
+      title,
     },
     conversationId,
   );

package/src/schedule/worker.ts

@@ -195,7 +195,7 @@ async function main(): Promise<void> {
   //
   // Bounded by MCP_STARTUP_GRACE_MS: unreachable servers must not hold the
   // schedules that do not use them. The connect runs on past the deadline.
-  const mcpStartup = startConfiguredMcpServers();
+  const mcpStartup = startConfiguredMcpServers(getConfig().mcp);
   await Promise.race([
     mcpStartup,
     // Unref'd so a connect that beats the deadline leaves nothing pending.

package/src/security/ces-rpc-record-backend.ts

@@ -11,11 +11,6 @@ import { getLogger } from "../util/logger.js";
 const log = getLogger("ces-rpc-record-backend");
 
 export interface CredentialRecordBackend {
-  /**
-   * Transport id. `"ces-rpc"` is the attached CES socket backend; live
-   * catalog listing fails over to CES HTTP when that transport is down.
-   */
-  readonly name?: string;
   isAvailable(): boolean;
   get(account: string): Promise<CredentialRecord | undefined>;
   set(account: string, record: CredentialRecord): Promise<boolean>;
@@ -34,8 +29,6 @@ export interface CredentialRecordBackend {
 }
 
 export class CesRpcRecordBackend implements CredentialRecordBackend {
-  readonly name = "ces-rpc";
-
   constructor(private readonly client: CesClient) {}
 
   isAvailable(): boolean {

package/src/subagent/consult-context.ts

@@ -33,6 +33,7 @@
 import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 
+import type { SkillSummary } from "../config/skills.js";
 import type { TrustContext } from "../daemon/trust-context-types.js";
 import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 import { truncate as truncateText } from "../util/truncate.js";
@@ -55,6 +56,15 @@ export interface AdvisorContextSources {
    * from the catalog section, mirroring the `skill_load` gate.
    */
   enabledPluginSet?: ReadonlySet<string> | null;
+  /**
+   * Pre-resolved skill catalog, typically the parent conversation's warm
+   * `skillProjectionCache.catalog`. Passing it keeps the synchronous on-disk
+   * catalog scan out of the consult path (and matches the catalog view the
+   * parent turn's tool projection used). When absent, the section falls back
+   * to a fresh `loadSkillCatalog()` scan, the same call every agent turn's
+   * projection already makes.
+   */
+  skillCatalog?: readonly SkillSummary[];
 }
 
 /** Cap a block so the assembled context never balloons the consult prompt. */
@@ -104,6 +114,7 @@ async function buildToolsSection(
  */
 async function buildSkillsSection(
   enabledPluginSet: ReadonlySet<string> | null | undefined,
+  preResolvedCatalog: readonly SkillSummary[] | undefined,
 ): Promise<string | null> {
   try {
     const [
@@ -119,17 +130,19 @@ async function buildSkillsSection(
     ]);
     const config = getConfig();
     const pluginScope = enabledPluginSet ?? null;
-    const catalog = loadSkillCatalog().filter((skill) => {
-      if (
-        pluginScope !== null &&
-        skill.owner?.kind === "plugin" &&
-        !pluginScope.has(skill.owner.id)
-      ) {
-        return false;
-      }
-      const flagKey = skillFlagKey(skill);
-      return !flagKey || isAssistantFeatureFlagEnabled(flagKey, config);
-    });
+    const catalog = (preResolvedCatalog ?? loadSkillCatalog()).filter(
+      (skill) => {
+        if (
+          pluginScope !== null &&
+          skill.owner?.kind === "plugin" &&
+          !pluginScope.has(skill.owner.id)
+        ) {
+          return false;
+        }
+        const flagKey = skillFlagKey(skill);
+        return !flagKey || isAssistantFeatureFlagEnabled(flagKey, config);
+      },
+    );
     if (catalog.length === 0) {
       return null;
     }
@@ -371,7 +384,7 @@ export async function buildAdvisorContext(
   const sections = await Promise.all(
     [
       buildToolsSection(sources.allowedToolNames),
-      buildSkillsSection(sources.enabledPluginSet),
+      buildSkillsSection(sources.enabledPluginSet, sources.skillCatalog),
       buildWorkspaceSection(sources),
     ].map((section) => withSectionTimeout(section, sectionTimeoutMs)),
   );

package/src/tools/acp/list-agents.test.ts

@@ -90,9 +90,7 @@ describe("executeAcpListAgents", () => {
     const codex = parsed.agents.find((a: { id: string }) => a.id === "codex");
     expect(codex.available).toBe(false);
     expect(codex.unavailableReason).toBe("'codex-acp' is not on PATH");
-    expect(codex.setupHint).toBe(
-      "bun add -g @agentclientprotocol/codex-acp@1.10.0",
-    );
+    expect(codex.setupHint).toBe("bun add -g @agentclientprotocol/codex-acp");
 
     const claude = parsed.agents.find((a: { id: string }) => a.id === "claude");
     expect(claude.available).toBe(true);

package/src/tools/acp/spawn.test.ts

@@ -124,22 +124,11 @@ const spawnMock = mock(
     _cwd: string,
     _parentConversationId: string,
     _sendToVellum: (msg: unknown) => void,
-    _options?: { parentToolUseId?: string; model?: string },
-  ): Promise<{
-    acpSessionId: string;
-    protocolSessionId: string;
-    requestedModel?: string;
-    effectiveModel?: string;
-    modelWarning?: string;
-  }> => {
-    const requestedModel = _options?.model?.trim() || undefined;
-    return {
-      acpSessionId: "acp-session-test",
-      protocolSessionId: "proto-session-test",
-      requestedModel,
-      effectiveModel: "opus",
-    };
-  },
+    _parentToolUseId?: string,
+  ) => ({
+    acpSessionId: "acp-session-test",
+    protocolSessionId: "proto-session-test",
+  }),
 );
 
 // Spread the real module's exports so transitive importers that pull other
@@ -212,8 +201,6 @@ describe("executeAcpSpawn - happy path", () => {
     const payload = JSON.parse(result.content);
     expect(payload.acpSessionId).toBe("acp-session-test");
     expect(payload.status).toBe("running");
-    expect(payload.requestedModel).toBeNull();
-    expect(payload.effectiveModel).toBe("opus");
     // The real adapter binary is spawned (no `bun x` wrapper).
     const agentConfigArg = spawnMock.mock.calls[0][1] as { command: string };
     expect(agentConfigArg.command).toBe("claude-agent-acp");
@@ -227,10 +214,8 @@ describe("executeAcpSpawn - happy path", () => {
 
     expect(result.isError).toBe(false);
     expect(spawnMock).toHaveBeenCalledTimes(1);
-    // The options bag is the 7th positional arg to spawn().
-    expect(spawnMock.mock.calls[0][6]).toEqual({
-      parentToolUseId: "toolu_abc123",
-    });
+    // parentToolUseId is the 7th positional arg to spawn().
+    expect(spawnMock.mock.calls[0][6]).toBe("toolu_abc123");
   });
 
   test("default-profile fallback when user config is empty", async () => {
@@ -287,7 +272,7 @@ describe("executeAcpSpawn — input validation", () => {
     expect(result.isError).toBe(true);
     expect(result.content).toContain("claude-agent-acp is not on PATH");
     expect(result.content).toContain(
-      "bun add -g @agentclientprotocol/claude-agent-acp@0.75.1",
+      "bun add -g @agentclientprotocol/claude-agent-acp",
     );
     expect(execFileMock).not.toHaveBeenCalled();
     expect(spawnMock).not.toHaveBeenCalled();
@@ -324,7 +309,7 @@ describe("executeAcpSpawn: sandboxed bun auto-install on missing binary", () =>
     expect(spawnMock).toHaveBeenCalledTimes(1);
     const payload = JSON.parse(result.content);
     expect(payload.message).toContain(
-      "Installed @agentclientprotocol/claude-agent-acp@0.75.1 automatically.",
+      "Installed @agentclientprotocol/claude-agent-acp automatically.",
     );
     // The real binary was spawned with cwd = the project dir and token
     // injected (trusted-binary config, no resolution at spawn).
@@ -345,7 +330,7 @@ describe("executeAcpSpawn: sandboxed bun auto-install on missing binary", () =>
     expect(args).toEqual([
       "add",
       "--global",
-      "@agentclientprotocol/claude-agent-acp@0.75.1",
+      "@agentclientprotocol/claude-agent-acp",
     ]);
   });
 
@@ -434,7 +419,7 @@ describe("executeAcpSpawn: sandboxed bun auto-install on missing binary", () =>
     expect(result.isError).toBe(true);
     expect(result.content).toContain("claude-agent-acp is not on PATH");
     expect(result.content).toContain(
-      "bun add -g @agentclientprotocol/claude-agent-acp@0.75.1",
+      "bun add -g @agentclientprotocol/claude-agent-acp",
     );
     expect(result.content).toContain("auto-install failed");
     expect(result.content).toContain("EACCES");
@@ -473,126 +458,6 @@ describe("executeAcpSpawn — per-agent resume hint", () => {
   });
 });
 
-describe("executeAcpSpawn - model selection", () => {
-  test("threads the requested model into manager.spawn's options", async () => {
-    const result = await executeAcpSpawn(
-      { agent: "claude", task: "do something", model: "opus" },
-      { ...makeContext(), toolUseId: "toolu_model" },
-    );
-
-    expect(result.isError).toBe(false);
-    expect(spawnMock.mock.calls[0][6]).toEqual({
-      parentToolUseId: "toolu_model",
-      model: "opus",
-    });
-    const payload = JSON.parse(result.content);
-    expect(payload.requestedModel).toBe("opus");
-    expect(payload.effectiveModel).toBe("opus");
-    expect(payload.message).toContain(
-      'The top-level ACP session reports "opus" as its effective model.',
-    );
-  });
-
-  test("reports the manager-normalized requested model", async () => {
-    const result = await executeAcpSpawn(
-      { agent: "claude", task: "do something", model: "  opus  " },
-      makeContext(),
-    );
-
-    expect(spawnMock.mock.calls[0][6]).toEqual({
-      parentToolUseId: undefined,
-      model: "  opus  ",
-    });
-    expect(JSON.parse(result.content).requestedModel).toBe("opus");
-  });
-
-  test("a null model is treated as omitted", async () => {
-    const result = await executeAcpSpawn(
-      { agent: "claude", task: "do something", model: null },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(false);
-    const options = spawnMock.mock.calls[0][6] as { model?: string };
-    expect(options.model).toBeUndefined();
-  });
-
-  test("a modelWarning from the spawn is relayed in the result message", async () => {
-    spawnMock.mockImplementationOnce(async () => ({
-      acpSessionId: "acp-session-test",
-      protocolSessionId: "proto-session-test",
-      requestedModel: "nope",
-      effectiveModel: "opus",
-      modelWarning: "Unknown model: nope",
-    }));
-
-    const result = await executeAcpSpawn(
-      { agent: "claude", task: "do something", model: "nope" },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(false);
-    const payload = JSON.parse(result.content);
-    expect(payload.message).toContain(
-      "The requested model was not applied: Unknown model: nope",
-    );
-    expect(payload.requestedModel).toBe("nope");
-    expect(payload.effectiveModel).toBe("opus");
-  });
-
-  test("the note relays a no-selector warning without calling it a refusal", async () => {
-    spawnMock.mockImplementationOnce(async () => ({
-      acpSessionId: "acp-session-test",
-      protocolSessionId: "proto-session-test",
-      requestedModel: "opus",
-      modelWarning:
-        'Agent "claude" does not support model selection, so the session is running on the agent\'s own model.',
-    }));
-
-    const result = await executeAcpSpawn(
-      { agent: "claude", task: "do something", model: "opus" },
-      makeContext(),
-    );
-
-    const payload = JSON.parse(result.content);
-    expect(payload.message).toContain("does not support model selection");
-    expect(payload.message).not.toContain("refused");
-  });
-
-  test("no model note when the spawn reports no warning", async () => {
-    const result = await executeAcpSpawn(
-      { agent: "claude", task: "do something", model: "opus" },
-      makeContext(),
-    );
-
-    expect(result.isError).toBe(false);
-    const payload = JSON.parse(result.content);
-    expect(payload.message).not.toContain(
-      "The requested model was not applied",
-    );
-  });
-
-  test("reports when the adapter does not identify the effective model", async () => {
-    spawnMock.mockImplementationOnce(async () => ({
-      acpSessionId: "acp-session-test",
-      protocolSessionId: "proto-session-test",
-      requestedModel: "sonnet",
-    }));
-
-    const result = await executeAcpSpawn(
-      { agent: "claude", task: "do something", model: "sonnet" },
-      makeContext(),
-    );
-
-    const payload = JSON.parse(result.content);
-    expect(payload.requestedModel).toBe("sonnet");
-    expect(payload.effectiveModel).toBeNull();
-    expect(payload.message).toContain(
-      "The top-level ACP session did not report an effective model.",
-    );
-  });
-});
-
 // ---------------------------------------------------------------------------
 // executeAcpSpawn — CLAUDE_CODE_OAUTH_TOKEN env injection + preflight
 //

package/src/tools/acp/spawn.ts

@@ -37,7 +37,6 @@ export const acpSpawnInputSchema = z.looseObject({
   agent: nullAsOmitted(z.string()),
   task: nullAsOmitted(z.string()),
   cwd: nullAsOmitted(z.string()),
-  model: nullAsOmitted(z.string()),
 });
 
 /**
@@ -67,7 +66,6 @@ export async function executeAcpSpawn(
   }
   const agent = parsedInput.data.agent || "claude";
   const task = parsedInput.data.task;
-  const model = parsedInput.data.model;
 
   if (!task) {
     return { content: '"task" is required.', isError: true };
@@ -126,20 +124,14 @@ export async function executeAcpSpawn(
     // Recheck: the auto-install and the agent-env preparation above are both
     // awaits, and this is the point a long-lived subprocess starts.
     throwIfCancelled(context);
-    const {
-      acpSessionId,
-      protocolSessionId,
-      requestedModel,
-      effectiveModel,
-      modelWarning,
-    } = await manager.spawn(
+    const { acpSessionId, protocolSessionId } = await manager.spawn(
       agent,
       agentConfig,
       task,
       cwd,
       context.conversationId,
       sendToClient,
-      { parentToolUseId: context.toolUseId, model },
+      context.toolUseId,
       // The manager rechecks after its own protocol handshake and session
       // creation, so a turn stopped in that window tears the child process
       // down instead of handing it the task.
@@ -158,26 +150,16 @@ export async function executeAcpSpawn(
     const installNote = autoInstalledPackage
       ? ` Installed ${autoInstalledPackage} automatically.`
       : "";
-    // Relayed verbatim: the warning already distinguishes an adapter with no
-    // selector from one that refused the value.
-    const modelNote = modelWarning
-      ? ` The requested model was not applied: ${modelWarning}`
-      : "";
-    const effectiveModelNote = effectiveModel
-      ? ` The top-level ACP session reports "${effectiveModel}" as its effective model.`
-      : " The top-level ACP session did not report an effective model.";
     const payload = JSON.stringify({
       acpSessionId,
       protocolSessionId,
       agent,
       cwd,
-      requestedModel: requestedModel ?? null,
-      effectiveModel: effectiveModel ?? null,
       status: "running",
       message:
         `ACP agent "${agent}" spawned (session: ${protocolSessionId}). ` +
         `Results stream back via SSE. You will be notified when it completes.` +
-        `${installNote}${modelNote}${effectiveModelNote}${resumeHint}`,
+        `${installNote}${resumeHint}`,
     });
 
     return { content: payload, isError: false };

package/src/tools/acp/status.ts

@@ -1,7 +1,6 @@
 import { z } from "zod";
 
 import { getAcpSessionManager } from "../../acp/index.js";
-import type { AcpSessionState } from "../../acp/types.js";
 import {
   invalidToolInputResult,
   nullAsOmitted,
@@ -17,40 +16,6 @@ export const acpStatusInputSchema = z.looseObject({
   acp_session_id: nullAsOmitted(z.string()),
 });
 
-/**
- * The session fields worth spending LLM context on. An allowlist rather than
- * an omission: `availableModels` is a picker for the human surfaces (HTTP and
- * SSE) that says nothing the agent can act on, and a field added to
- * `AcpSessionState` for those surfaces should not reach this one by default.
- * `model` stays: which model a session is running on is answerable.
- */
-function projectSession(state: AcpSessionState) {
-  return {
-    id: state.id,
-    agentId: state.agentId,
-    acpSessionId: state.acpSessionId,
-    parentConversationId: state.parentConversationId,
-    status: state.status,
-    startedAt: state.startedAt,
-    completedAt: state.completedAt,
-    error: state.error,
-    stopReason: state.stopReason,
-    task: state.task,
-    parentToolUseId: state.parentToolUseId,
-    authErrorCode: state.authErrorCode,
-    authErrorCredential: state.authErrorCredential,
-    latestUsage: state.latestUsage,
-    model: state.model,
-  };
-}
-
-/** Projects either shape `getStatus` answers with. */
-function projectStatus(status: AcpSessionState | AcpSessionState[]): unknown {
-  return Array.isArray(status)
-    ? status.map(projectSession)
-    : projectSession(status);
-}
-
 export async function executeAcpStatus(
   input: Record<string, unknown>,
   _context: ToolContext,
@@ -64,8 +29,9 @@ export async function executeAcpStatus(
 
   try {
     if (acpSessionId) {
+      const state = manager.getStatus(acpSessionId);
       return {
-        content: JSON.stringify(projectStatus(manager.getStatus(acpSessionId))),
+        content: JSON.stringify(state),
         isError: false,
       };
     }
@@ -76,10 +42,7 @@ export async function executeAcpStatus(
       return { content: "No ACP sessions found.", isError: false };
     }
 
-    return {
-      content: JSON.stringify(projectStatus(allStates)),
-      isError: false,
-    };
+    return { content: JSON.stringify(allStates), isError: false };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return { content: msg, isError: true };

package/src/tools/app-control/skill-proxy-bridge.ts

@@ -5,7 +5,6 @@
  * the proxy resolver, which forwards the call to the connected client.
  */
 
-import { formatDesktopAppRequired } from "../capability-offer.js";
 import { throwIfCancelled } from "../shared/abort.js";
 import type { ToolContext, ToolExecutionResult } from "../types.js";
 
@@ -33,7 +32,7 @@ export function forwardAppControlProxyTool(
   }
   if (!context.proxyToolResolver) {
     return Promise.resolve({
-      content: formatDesktopAppRequired("apps"),
+      content: `Cannot execute ${toolName}: no proxy resolver available. This tool requires a connected client.`,
       isError: true,
     });
   }

package/src/tools/capability-offer.test.ts

@@ -4,26 +4,11 @@ import {
   appendLoggedInBrowserOffer,
   CHROME_WEB_STORE_INSTALL_URL,
   DESKTOP_APP_DOWNLOAD_URL,
-  formatDesktopAppRequired,
   formatLoggedInBrowserOffer,
   isPhoneSurface,
   shouldOfferLoggedInBrowser,
 } from "./capability-offer.js";
 
-describe("formatDesktopAppRequired", () => {
-  test("offers a direct desktop-app download and retry step", () => {
-    const message = formatDesktopAppRequired("shell");
-
-    expect(message).toContain(
-      "The Vellum desktop app is needed to run commands on your computer",
-    );
-    expect(message).toContain(DESKTOP_APP_DOWNLOAD_URL);
-    expect(message).toContain("Open it, then retry.");
-    expect(message).not.toContain("client");
-    expect(message).not.toContain("daemon");
-  });
-});
-
 describe("isPhoneSurface", () => {
   test("is true for iOS transport and mobile client OS", () => {
     expect(isPhoneSurface({ transportInterface: "ios" })).toBe(true);
@@ -64,9 +49,7 @@ describe("shouldOfferLoggedInBrowser", () => {
     expect(shouldOfferLoggedInBrowser('Invalid browser_mode "bogus"')).toBe(
       false,
     );
-    expect(shouldOfferLoggedInBrowser("url must use http or https")).toBe(
-      false,
-    );
+    expect(shouldOfferLoggedInBrowser("url must use http or https")).toBe(false);
   });
 });
 
@@ -88,7 +71,6 @@ describe("formatLoggedInBrowserOffer", () => {
     });
     expect(offer).toContain("no in-app browser");
     expect(offer).toContain("Do not describe a browser panel");
-    expect(offer).toContain("Mac or Windows PC");
     expect(offer).toContain(DESKTOP_APP_DOWNLOAD_URL);
     expect(offer).toContain(CHROME_WEB_STORE_INSTALL_URL);
   });
@@ -96,9 +78,7 @@ describe("formatLoggedInBrowserOffer", () => {
 
 describe("appendLoggedInBrowserOffer", () => {
   test("appends the offer once", () => {
-    const once = appendLoggedInBrowserOffer(
-      "Error: Navigation failed: timeout",
-    );
+    const once = appendLoggedInBrowserOffer("Error: Navigation failed: timeout");
     expect(once).toContain("Error: Navigation failed: timeout");
     expect(once).toContain(DESKTOP_APP_DOWNLOAD_URL);
     const twice = appendLoggedInBrowserOffer(once);