@vellumai/assistant 0.7.1 → 0.7.3

package/src/skills/remote-skill-policy.ts

@@ -1,12 +1,6 @@
-export type RemoteSkillProvider = "clawhub" | "skillssh";
-
-export type SkillsShRisk =
-  | "safe"
-  | "low"
-  | "medium"
-  | "high"
-  | "critical"
-  | "unknown";
+type RemoteSkillProvider = "clawhub" | "skillssh";
+
+type SkillsShRisk = "safe" | "low" | "medium" | "high" | "critical" | "unknown";
 export type SkillsShRiskThreshold = Exclude<SkillsShRisk, "unknown">;
 
 export interface RemoteSkillPolicy {
@@ -26,12 +20,12 @@ export interface RemoteSkillPolicy {
   maxSkillsShRisk: SkillsShRiskThreshold;
 }
 
-export interface ClawhubModerationState {
+interface ClawhubModerationState {
   isSuspicious?: boolean;
   isMalwareBlocked?: boolean;
 }
 
-export interface SkillsShAuditState {
+interface SkillsShAuditState {
   risk?: SkillsShRisk | null;
 }
 
@@ -40,27 +34,27 @@ interface RemoteSkillCandidateBase {
   slug: string;
 }
 
-export interface ClawhubRemoteSkillCandidate extends RemoteSkillCandidateBase {
+interface ClawhubRemoteSkillCandidate extends RemoteSkillCandidateBase {
   provider: "clawhub";
   moderation?: ClawhubModerationState | null;
 }
 
-export interface SkillsShRemoteSkillCandidate extends RemoteSkillCandidateBase {
+interface SkillsShRemoteSkillCandidate extends RemoteSkillCandidateBase {
   provider: "skillssh";
   audit?: SkillsShAuditState | null;
 }
 
-export type RemoteSkillCandidate =
+type RemoteSkillCandidate =
   | ClawhubRemoteSkillCandidate
   | SkillsShRemoteSkillCandidate;
 
-export type RemoteSkillDenyReason =
+type RemoteSkillDenyReason =
   | "clawhub_suspicious"
   | "clawhub_malware_blocked"
   | "clawhub_moderation_missing"
   | "skillssh_risk_exceeds_threshold";
 
-export type RemoteSkillInstallDecision =
+type RemoteSkillInstallDecision =
   | { ok: true }
   | { ok: false; reason: RemoteSkillDenyReason };
 

package/src/skills/skill-file-provider.ts

@@ -1,5 +1,5 @@
 import type { SlimSkillResponse } from "../daemon/message-types/skills.js";
-import type { SkillFileEntry } from "./catalog-files.js";
+import type { SkillFileEntry } from "./skill-file-types.js";
 
 /**
  * A file provider can resolve file listings and single-file content for

package/src/skills/skill-file-types.ts

@@ -0,0 +1,13 @@
+/**
+ * Types extracted from catalog-files.ts to break the
+ * catalog-files ↔ skill-file-provider cycle.
+ */
+
+export interface SkillFileEntry {
+  path: string; // relative to skill directory root (e.g. "SKILL.md", "tools/foo.ts")
+  name: string; // basename
+  size: number;
+  mimeType: string;
+  isBinary: boolean;
+  content: string | null; // inline text if ≤ 2 MB and text MIME, else null
+}

package/src/skills/skillssh-audit-types.ts

@@ -0,0 +1,28 @@
+/**
+ * Audit types for SkillSSH partner security analysis.
+ *
+ * Extracted as a leaf module so daemon message types can reference
+ * PartnerAudit without pulling in the full skillssh-registry module
+ * (which transitively imports cli/program and the entire CLI graph).
+ */
+
+export type RiskLevel =
+  | "safe"
+  | "low"
+  | "medium"
+  | "high"
+  | "critical"
+  | "unknown";
+
+export interface PartnerAudit {
+  risk: RiskLevel;
+  alerts?: number;
+  score?: number;
+  analyzedAt: string;
+}
+
+/** Map from audit provider name (e.g. "ath", "socket", "snyk") to audit data */
+export type SkillAuditData = Record<string, PartnerAudit>;
+
+/** Map from skill slug to per-provider audit data */
+export type AuditResponse = Record<string, SkillAuditData>;

package/src/skills/skillssh-registry.ts

@@ -6,6 +6,14 @@ import { dirname, join, resolve, sep } from "node:path";
 import { getWorkspaceSkillsDir } from "../util/platform.js";
 import { upsertSkillsIndex } from "./catalog-install.js";
 import { computeSkillHash, writeInstallMeta } from "./install-meta.js";
+import type {
+  AuditResponse,
+  PartnerAudit,
+  RiskLevel,
+  SkillAuditData,
+} from "./skillssh-audit-types.js";
+
+export type { AuditResponse, PartnerAudit, RiskLevel, SkillAuditData };
 
 // ─── Types ───────────────────────────────────────────────────────────────────
 
@@ -17,27 +25,6 @@ export interface SkillsShSearchResult {
   source: string; // e.g. "vercel-labs/agent-skills"
 }
 
-export type RiskLevel =
-  | "safe"
-  | "low"
-  | "medium"
-  | "high"
-  | "critical"
-  | "unknown";
-
-export interface PartnerAudit {
-  risk: RiskLevel;
-  alerts?: number;
-  score?: number;
-  analyzedAt: string;
-}
-
-/** Map from audit provider name (e.g. "ath", "socket", "snyk") to audit data */
-export type SkillAuditData = Record<string, PartnerAudit>;
-
-/** Map from skill slug to per-provider audit data */
-export type AuditResponse = Record<string, SkillAuditData>;
-
 export interface ResolvedSkillSource {
   owner: string;
   repo: string;

package/src/subagent/index.ts

@@ -1,11 +1,5 @@
 export { mergeSkillIds } from "./manager.js";
-export type {
-  SubagentConfig,
-  SubagentRole,
-  SubagentRoleConfig,
-  SubagentState,
-  SubagentStatus,
-} from "./types.js";
+export type { SubagentRole } from "./types.js";
 export { SUBAGENT_ROLE_REGISTRY, TERMINAL_STATUSES } from "./types.js";
 
 import { SubagentManager } from "./manager.js";

package/src/subagent/manager.ts

@@ -11,10 +11,7 @@
 import { v4 as uuid } from "uuid";
 
 import { getConfig } from "../config/loader.js";
-import {
-  Conversation,
-  type ConversationMemoryPolicy,
-} from "../daemon/conversation.js";
+import { Conversation } from "../daemon/conversation.js";
 import { findConversation } from "../daemon/conversation-store.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
@@ -231,16 +228,6 @@ export class SubagentManager {
     const maxTokens = appConfig.llm.default.maxTokens;
     const workingDir = getSandboxWorkingDir();
 
-    const memoryPolicy: ConversationMemoryPolicy = isFork
-      ? {
-          scopeId: "default",
-          includeDefaultFallback: false,
-        }
-      : {
-          scopeId: `subagent:${subagentId}`,
-          includeDefaultFallback: true,
-        };
-
     // ── Initialise state ────────────────────────────────────────────
     const now = Date.now();
     // For forks, default sendResultToUser to false (silent) unless explicitly true.
@@ -289,7 +276,6 @@ export class SubagentManager {
       maxTokens,
       wrappedSendToClient,
       workingDir,
-      memoryPolicy,
       undefined, // sharedCesClient
       undefined, // speedOverride
       "5m", // cacheTtl — subagents run tight tool-use loops, 5m is always hot

package/src/tasks/task-runner.ts

@@ -67,7 +67,6 @@ export async function runTask(
 
   updateTaskRun(run.id, {
     conversationId: conversation.id,
-    memoryScopeId: `task:${task.id}`,
   });
 
   try {

package/src/tasks/task-store.ts

@@ -27,7 +27,6 @@ export interface TaskRun {
   finishedAt: number | null;
   error: string | null;
   principalId: string | null;
-  memoryScopeId: string | null;
   createdAt: number;
 }
 
@@ -109,7 +108,6 @@ export function createTaskRun(taskId: string): TaskRun {
     finishedAt: null,
     error: null,
     principalId: null,
-    memoryScopeId: null,
     createdAt: now,
   };
   db.insert(taskRuns).values(run).run();
@@ -125,7 +123,6 @@ export function updateTaskRun(
       | "conversationId"
       | "error"
       | "principalId"
-      | "memoryScopeId"
       | "startedAt"
       | "finishedAt"
     >

package/src/telemetry/types.ts

@@ -21,6 +21,8 @@ export interface LlmUsageTelemetryEvent extends TelemetryEventBase {
   llm_call_site: LLMCallSite | null;
   inference_profile: string | null;
   inference_profile_source: UsageAttributionProfileSource | null;
+  /** Computed estimated cost in USD for this LLM call. Null when pricing data is unavailable. */
+  cost: number | null;
 }
 
 /** Turn event — one per user message. */

package/src/telemetry/usage-telemetry-reporter.test.ts

@@ -389,6 +389,7 @@ describe("UsageTelemetryReporter", () => {
     expect(e.llm_call_site).toBe("compactionAgent");
     expect(e.inference_profile).toBe("quality-optimized");
     expect(e.inference_profile_source).toBe("conversation");
+    expect(e.cost).toBe(0.001);
     expect(e.recorded_at).toBe(1700000099000);
   });
 
@@ -419,6 +420,26 @@ describe("UsageTelemetryReporter", () => {
     });
   });
 
+  test("cost is null when estimatedCostUsd is null (unpriced event)", async () => {
+    const event = makeUsageEvent({
+      id: "evt-unpriced",
+      estimatedCostUsd: null,
+      pricingStatus: "unpriced",
+    });
+    mockQueryUnreportedUsageEvents.mockReturnValue([event]);
+    mockFetch.mockImplementation(() =>
+      Promise.resolve(new Response('{"accepted":1}', { status: 200 })),
+    );
+
+    const reporter = new UsageTelemetryReporter();
+    await reporter.flush();
+
+    const body = JSON.parse(
+      (mockFetch.mock.calls[0] as [string, RequestInit])[1].body as string,
+    );
+    expect(body.events[0].cost).toBeNull();
+  });
+
   test("organization_id and user_id included in payload when available", async () => {
     mockGetPlatformOrganizationId.mockReturnValue("org-123");
     mockGetPlatformUserId.mockReturnValue("user-456");

package/src/telemetry/usage-telemetry-reporter.ts

@@ -194,6 +194,7 @@ export class UsageTelemetryReporter {
             llm_call_site: e.callSite,
             inference_profile: e.inferenceProfile,
             inference_profile_source: e.inferenceProfileSource,
+            cost: e.estimatedCostUsd ?? null,
             recorded_at: e.createdAt,
           }),
         ),

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

@@ -0,0 +1,28 @@
+/**
+ * Shared helper for app-control skill wrapper scripts.
+ *
+ * Each wrapper calls forwardAppControlProxyTool() to delegate execution to
+ * the proxy resolver, which forwards the call to the connected client.
+ */
+
+import type { ToolContext, ToolExecutionResult } from "../types.js";
+
+/**
+ * Forward an app-control proxy tool call through the context's proxyToolResolver.
+ *
+ * Returns a clear error result if the resolver is missing (e.g. when the tool
+ * is invoked outside a session with a connected client).
+ */
+export function forwardAppControlProxyTool(
+  toolName: string,
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  if (!context.proxyToolResolver) {
+    return Promise.resolve({
+      content: `Cannot execute ${toolName}: no proxy resolver available. This tool requires a connected client.`,
+      isError: true,
+    });
+  }
+  return context.proxyToolResolver(toolName, input);
+}

package/src/tools/apps/executors.ts

@@ -42,7 +42,6 @@ export interface AppStoreWriter {
     icon?: string;
     schemaJson: string;
     htmlDefinition: string;
-    pages?: Record<string, string>;
     formatVersion?: number;
   }): AppDefinition;
   updateApp(
@@ -77,12 +76,16 @@ export interface AppCreateInput {
   name: string;
   description?: string;
   schema_json?: string;
-  html?: string;
-  pages?: Record<string, string>;
+  /**
+   * Retired single-file shortcut. Kept in the type so legacy or stale callers
+   * get a clear tool error instead of silently creating a v2 app with stale
+   * scaffold content.
+   */
+  html?: unknown;
+  /** Retired single-file multi-page shortcut. */
+  pages?: unknown;
   auto_open?: boolean;
   preview?: Record<string, unknown>;
-  /** When provided, controls multifile scaffold behavior. */
-  featureFlags?: { multifileEnabled: boolean };
 }
 
 export async function executeAppCreate(
@@ -93,22 +96,26 @@ export async function executeAppCreate(
   const name = input.name;
   const description = input.description;
   const schemaJson = input.schema_json ?? "{}";
-  // Default to a minimal scaffold only when html is truly omitted; reject
-  // invalid types (e.g. object/number) so malformed tool calls surface errors.
-  let htmlDefinition: string;
-  if (typeof input.html === "string") {
-    htmlDefinition = input.html;
-  } else if (input.html == null) {
-    htmlDefinition = "<!DOCTYPE html><html><head></head><body></body></html>";
-  } else {
+
+  if (Object.prototype.hasOwnProperty.call(input, "html")) {
     return {
       content: JSON.stringify({
-        error: `html must be a string, got ${typeof input.html}`,
+        error:
+          "app_create no longer accepts html. Create the app scaffold, write src/index.html and src/main.tsx with file_write, then call app_refresh.",
+      }),
+      isError: true,
+    };
+  }
+
+  if (Object.prototype.hasOwnProperty.call(input, "pages")) {
+    return {
+      content: JSON.stringify({
+        error:
+          "app_create no longer accepts pages. Build multi-file TSX apps under src/ and route inside the Preact app instead.",
       }),
       isError: true,
     };
   }
-  const pages = input.pages;
   const autoOpen = input.auto_open !== false; // default true
   const preview = input.preview;
 
@@ -121,49 +128,30 @@ export async function executeAppCreate(
       isError: true,
     };
   }
-  if (pages) {
-    for (const [filename, content] of Object.entries(pages)) {
-      if (typeof content !== "string") {
-        return {
-          content: JSON.stringify({
-            error: `pages["${filename}"] must be a string, got ${typeof content}`,
-          }),
-          isError: true,
-        };
-      }
-    }
-  }
 
   // Extract icon from preview if provided - only persist emoji-like values,
   // not URLs which would render as raw strings in UI and bundle manifests.
   const rawIcon = preview?.icon as string | undefined;
   const icon = rawIcon && !rawIcon.startsWith("http") ? rawIcon : undefined;
 
-  const multifileEnabled = input.featureFlags?.multifileEnabled === true;
-
   const app = store.createApp({
     name,
     description,
     icon,
     schemaJson,
-    htmlDefinition: multifileEnabled ? "" : htmlDefinition,
-    pages: multifileEnabled ? undefined : pages,
-    formatVersion: multifileEnabled ? 2 : undefined,
+    htmlDefinition: "",
+    formatVersion: 2,
   });
 
   // Scaffold multifile app with src/ files and compile to dist/
-  if (multifileEnabled) {
-    const htmlSafeName = name
-      .replace(/&/g, "&amp;")
-      .replace(/</g, "&lt;")
-      .replace(/>/g, "&gt;")
-      .replace(/"/g, "&quot;");
-    const jsxSafeName = name.replace(/[<>{}&"']/g, "");
-
-    const indexHtml =
-      typeof input.html === "string"
-        ? input.html
-        : `<!DOCTYPE html>
+  const htmlSafeName = name
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+  const jsxSafeName = name.replace(/[<>{}&"']/g, "");
+
+  const indexHtml = `<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="UTF-8">
@@ -175,7 +163,7 @@ export async function executeAppCreate(
 </body>
 </html>`;
 
-    const mainTsx = `import { render } from 'preact';
+  const mainTsx = `import { render } from 'preact';
 
 function App() {
   return <div>{"Hello, ${jsxSafeName}!"}</div>;
@@ -184,31 +172,30 @@ function App() {
 render(<App />, document.getElementById('app')!);
 `;
 
-    // Only write scaffold files when they don't already exist on disk.
-    // The LLM may have written custom source files via file_write before
-    // calling app_create, and overwriting them would destroy the real app
-    // content, leaving only the scaffold placeholder.
-    if (!store.appFileExists(app.id, "src/index.html")) {
-      store.writeAppFile(app.id, "src/index.html", indexHtml);
-    }
-    if (!store.appFileExists(app.id, "src/main.tsx")) {
-      store.writeAppFile(app.id, "src/main.tsx", mainTsx);
-    }
+  // Only write scaffold files when they don't already exist on disk.
+  // The LLM may have written custom source files via file_write before
+  // calling app_create, and overwriting them would destroy the real app
+  // content, leaving only the scaffold placeholder.
+  if (!store.appFileExists(app.id, "src/index.html")) {
+    store.writeAppFile(app.id, "src/index.html", indexHtml);
+  }
+  if (!store.appFileExists(app.id, "src/main.tsx")) {
+    store.writeAppFile(app.id, "src/main.tsx", mainTsx);
+  }
 
-    // Compile src/ → dist/
-    const appDir = getAppDirPath(app.id);
-    const compileResult = await compileApp(appDir);
-    if (!compileResult.ok) {
-      return {
-        content: JSON.stringify({
-          ...app,
-          compile_errors: compileResult.errors,
-          compile_warnings: compileResult.warnings,
-          compile_duration_ms: compileResult.durationMs,
-        }),
-        isError: false,
-      };
-    }
+  // Compile src/ → dist/
+  const appDir = getAppDirPath(app.id);
+  const compileResult = await compileApp(appDir);
+  if (!compileResult.ok) {
+    return {
+      content: JSON.stringify({
+        ...app,
+        compile_errors: compileResult.errors,
+        compile_warnings: compileResult.warnings,
+        compile_duration_ms: compileResult.durationMs,
+      }),
+      isError: false,
+    };
   }
 
   // Emit the inline preview card via the proxy without opening a workspace panel.

package/src/tools/background-tool-registry.ts

@@ -19,7 +19,7 @@ export interface BackgroundTool {
   command: string;
   startedAt: number;
   /** Kills the process (bash) or aborts the proxy (host_bash). */
-  cancel: () => void;
+  cancel: (reason?: string) => void;
 }
 
 /** Maximum number of concurrent background tools allowed. */
@@ -61,16 +61,30 @@ export function listBackgroundTools(conversationId?: string): BackgroundTool[] {
  * Cancels a background tool by ID: calls `tool.cancel()`, removes the entry,
  * and returns `true`. Returns `false` if the ID is not found.
  */
-export function cancelBackgroundTool(id: string): boolean {
+export function cancelBackgroundTool(id: string, reason?: string): boolean {
   const tool = registry.get(id);
   if (!tool) {
     return false;
   }
-  tool.cancel();
+  tool.cancel(reason);
   registry.delete(id);
   return true;
 }
 
+export function cancelBackgroundTools(
+  shouldCancel: (tool: BackgroundTool) => boolean,
+  reason?: string,
+): BackgroundTool[] {
+  const cancelled: BackgroundTool[] = [];
+  for (const tool of Array.from(registry.values())) {
+    if (!shouldCancel(tool)) continue;
+    tool.cancel(reason);
+    registry.delete(tool.id);
+    cancelled.push(tool);
+  }
+  return cancelled;
+}
+
 /**
  * Generates a short prefixed ID for a background tool.
  * Format: `bg-<8 hex chars>` (e.g. `bg-a1b2c3d4`).

package/src/tools/browser/__tests__/browser-status.test.ts

@@ -85,11 +85,13 @@ mock.module("../browser-manager.js", () => ({
 /** Mutable proxy returned by HostBrowserProxy.instance. */
 let mockSingletonProxy: {
   isAvailable: () => boolean;
+  hasExtensionClient: () => boolean;
   request: unknown;
 } | null = null;
 
 const unavailableFallback = {
   isAvailable: () => false,
+  hasExtensionClient: () => false,
   request: () => Promise.reject(new Error("no extension")),
 };
 
@@ -159,7 +161,7 @@ describe("executeBrowserStatus", () => {
   });
 
   test("reports extension as connected when probe fails on restricted chrome:// page", async () => {
-    mockSingletonProxy = { isAvailable: () => true, request: () => {} };
+    mockSingletonProxy = { isAvailable: () => true, hasExtensionClient: () => true, request: () => {} };
     probeOutcomes[BROWSER_STATUS_MODE.EXTENSION] = "fail";
     probeErrors[BROWSER_STATUS_MODE.EXTENSION] = new CdpError(
       "cdp_error",
@@ -181,7 +183,7 @@ describe("executeBrowserStatus", () => {
   // ── macOS host-browser proxy mode tests ─────────────────────────────
 
   test("reports extension as available when singleton proxy is connected", async () => {
-    mockSingletonProxy = { isAvailable: () => true, request: () => {} };
+    mockSingletonProxy = { isAvailable: () => true, hasExtensionClient: () => true, request: () => {} };
     const result = await executeBrowserStatus(
       {},
       makeContext({
@@ -199,22 +201,23 @@ describe("executeBrowserStatus", () => {
     expect(extension.details.transport).toBe("extension-ws");
   });
 
-  test("reports extension disconnected when singleton proxy is not available", async () => {
-    // mockSingletonProxy = null → falls back to unavailableFallback
-    const result = await executeBrowserStatus({}, makeContext());
-    expect(result.isError).toBe(false);
-    const payload = JSON.parse(result.content);
-    const extension = payload.modes.find(
-      (m: { mode: string }) => m.mode === BROWSER_STATUS_MODE.EXTENSION,
-    );
-    expect(extension).toBeDefined();
-    expect(extension.available).toBe(false);
-    expect(extension.summary).toContain("disconnected");
-    expect(extension.details.transport).toBe("extension-ws");
-  });
+  test("reports extension unavailable when no Chrome Extension is connected", async () => {
+      // mockSingletonProxy = null → falls back to unavailableFallback (hasExtensionClient = false)
+      const result = await executeBrowserStatus({}, makeContext());
+      expect(result.isError).toBe(false);
+      const payload = JSON.parse(result.content);
+      const extension = payload.modes.find(
+        (m: { mode: string }) => m.mode === BROWSER_STATUS_MODE.EXTENSION,
+      );
+      expect(extension).toBeDefined();
+      expect(extension.available).toBe(false);
+      expect(extension.summary).toContain("no Chrome Extension is connected");
+      expect(extension.verified).toBe("preflight");
+      expect(extension.details.transport).toBe("extension-ws");
+    });
 
   test("probe failure diagnostics include remediation actions", async () => {
-    mockSingletonProxy = { isAvailable: () => true, request: () => {} };
+    mockSingletonProxy = { isAvailable: () => true, hasExtensionClient: () => true, request: () => {} };
     probeOutcomes[BROWSER_STATUS_MODE.EXTENSION] = "fail";
     probeErrors[BROWSER_STATUS_MODE.EXTENSION] = new CdpError(
       "transport_error",
@@ -233,7 +236,7 @@ describe("executeBrowserStatus", () => {
   });
 
   test("recommendation order follows auto candidate precedence with available extension", async () => {
-    mockSingletonProxy = { isAvailable: () => true, request: () => {} };
+    mockSingletonProxy = { isAvailable: () => true, hasExtensionClient: () => true, request: () => {} };
     const result = await executeBrowserStatus({}, makeContext());
     expect(result.isError).toBe(false);
     const payload = JSON.parse(result.content);
@@ -252,7 +255,7 @@ describe("executeBrowserStatus", () => {
   });
 
   test("restricted chrome:// page probe includes transport details", async () => {
-    mockSingletonProxy = { isAvailable: () => true, request: () => {} };
+    mockSingletonProxy = { isAvailable: () => true, hasExtensionClient: () => true, request: () => {} };
     probeOutcomes[BROWSER_STATUS_MODE.EXTENSION] = "fail";
     probeErrors[BROWSER_STATUS_MODE.EXTENSION] = new CdpError(
       "cdp_error",

package/src/tools/browser/browser-execution.ts

@@ -2251,14 +2251,14 @@ async function checkExtensionModeStatus(
 ): Promise<BrowserStatusModeResult> {
   const proxy = HostBrowserProxy.instance;
 
-  if (!proxy.isAvailable()) {
+  if (!proxy.hasExtensionClient()) {
     return {
       mode: BROWSER_STATUS_MODE.EXTENSION,
       available: false,
       verified: "preflight",
       autoCandidate,
       summary:
-        "Extension mode is unavailable: the extension transport is currently disconnected.",
+        "Extension mode is unavailable: no Chrome Extension is connected.",
       userActions: extensionSetupActions(),
       tradeoffs: modeTradeoffs(BROWSER_STATUS_MODE.EXTENSION),
       details: { transport: "extension-ws" },