@vellumai/assistant 0.6.4 → 0.6.6

package/src/__tests__/anthropic-provider.test.ts

@@ -10,6 +10,15 @@ let lastStreamParams: Record<string, unknown> | null = null;
 let _lastStreamOptions: Record<string, unknown> | null = null;
 let lastConstructorArgs: Record<string, unknown> | null = null;
 
+type ScriptedStreamEvent =
+  | { kind: "text"; text: string }
+  | { kind: "blockStart"; blockType?: "text" }
+  | { kind: "blockStop" };
+
+// When set, the mock fires these scripted stream events in order instead of
+// the default single "Hello" text event. Tests reset this in beforeEach.
+let scriptedStream: ScriptedStreamEvent[] | null = null;
+
 const fakeResponse = {
   content: [{ type: "text", text: "Hello" }],
   model: "claude-sonnet-4-6",
@@ -50,8 +59,25 @@ mock.module("@anthropic-ai/sdk", () => ({
           return this;
         },
         async finalMessage() {
-          // Fire text events
-          for (const cb of handlers["text"] ?? []) cb("Hello");
+          if (scriptedStream) {
+            for (const event of scriptedStream) {
+              if (event.kind === "text") {
+                for (const cb of handlers["text"] ?? []) cb(event.text);
+              } else if (event.kind === "blockStart") {
+                for (const cb of handlers["streamEvent"] ?? [])
+                  cb({
+                    type: "content_block_start",
+                    content_block: { type: event.blockType ?? "text" },
+                  });
+              } else if (event.kind === "blockStop") {
+                for (const cb of handlers["streamEvent"] ?? [])
+                  cb({ type: "content_block_stop" });
+              }
+            }
+          } else {
+            // Default: a single "Hello" text event (preserves existing tests).
+            for (const cb of handlers["text"] ?? []) cb("Hello");
+          }
           return fakeResponse;
         },
       };
@@ -77,6 +103,7 @@ mock.module("@anthropic-ai/sdk", () => ({
 import { SYSTEM_PROMPT_CACHE_BOUNDARY } from "../prompts/system-prompt.js";
 import {
   AnthropicProvider,
+  isPlaceholderSentinelText,
   PLACEHOLDER_BLOCKS_OMITTED,
   PLACEHOLDER_EMPTY_TURN,
 } from "../providers/anthropic/client.js";
@@ -144,6 +171,7 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     lastStreamParams = null;
     _lastStreamOptions = null;
     lastConstructorArgs = null;
+    scriptedStream = null;
     provider = new AnthropicProvider("sk-ant-test", "claude-sonnet-4-6");
   });
 
@@ -1254,6 +1282,147 @@ describe("AnthropicProvider — Cache-Control Characterization", () => {
     }
   });
 
+  test("streams normal text through without delay when text is not a sentinel prefix", async () => {
+    scriptedStream = [
+      { kind: "blockStart" },
+      { kind: "text", text: "Hello world" },
+      { kind: "blockStop" },
+    ];
+    const emitted: string[] = [];
+    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+      onEvent: (event) => {
+        if (event.type === "text_delta") emitted.push(event.text);
+      },
+    });
+    expect(emitted).toEqual(["Hello world"]);
+  });
+
+  test("suppresses placeholder sentinel streamed as a single chunk", async () => {
+    // Model echoes a sentinel in one chunk; buffer should hold it and
+    // drop it on content_block_stop since it matches exactly.
+    scriptedStream = [
+      { kind: "blockStart" },
+      { kind: "text", text: PLACEHOLDER_EMPTY_TURN },
+      { kind: "blockStop" },
+    ];
+    const emitted: string[] = [];
+    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+      onEvent: (event) => {
+        if (event.type === "text_delta") emitted.push(event.text);
+      },
+    });
+    expect(emitted).toEqual([]);
+  });
+
+  test("suppresses bare-variant sentinel streamed as a single chunk", async () => {
+    scriptedStream = [
+      { kind: "blockStart" },
+      { kind: "text", text: "__PLACEHOLDER__[empty assistant turn]" },
+      { kind: "blockStop" },
+    ];
+    const emitted: string[] = [];
+    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+      onEvent: (event) => {
+        if (event.type === "text_delta") emitted.push(event.text);
+      },
+    });
+    expect(emitted).toEqual([]);
+  });
+
+  test("suppresses placeholder sentinel streamed across multiple chunks", async () => {
+    scriptedStream = [
+      { kind: "blockStart" },
+      { kind: "text", text: "\x00__PLACE" },
+      { kind: "text", text: "HOLDER__[empty" },
+      { kind: "text", text: " assistant turn]" },
+      { kind: "blockStop" },
+    ];
+    const emitted: string[] = [];
+    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+      onEvent: (event) => {
+        if (event.type === "text_delta") emitted.push(event.text);
+      },
+    });
+    expect(emitted).toEqual([]);
+  });
+
+  test("flushes buffered prefix when the continuation diverges from all sentinels", async () => {
+    // "__PLACEHOLDER__" is a prefix of the sentinels, so it stays buffered.
+    // Once the next chunk diverges (bracket instead of the expected opening),
+    // the buffer must flush.
+    scriptedStream = [
+      { kind: "blockStart" },
+      { kind: "text", text: "__PLACEHOLDER__" },
+      { kind: "text", text: " is bold in markdown" },
+      { kind: "blockStop" },
+    ];
+    const emitted: string[] = [];
+    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+      onEvent: (event) => {
+        if (event.type === "text_delta") emitted.push(event.text);
+      },
+    });
+    expect(emitted.join("")).toBe("__PLACEHOLDER__ is bold in markdown");
+  });
+
+  test("flushes non-sentinel residual buffer at content_block_stop", async () => {
+    // If the stream ends mid-prefix, the residual must be flushed (the
+    // accumulated text isn't a complete sentinel, so it's real content).
+    scriptedStream = [
+      { kind: "blockStart" },
+      { kind: "text", text: "__PLACEHOLDER__" },
+      { kind: "blockStop" },
+    ];
+    const emitted: string[] = [];
+    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+      onEvent: (event) => {
+        if (event.type === "text_delta") emitted.push(event.text);
+      },
+    });
+    expect(emitted).toEqual(["__PLACEHOLDER__"]);
+  });
+
+  test("resets buffer across content blocks so a sentinel in one block doesn't poison the next", async () => {
+    scriptedStream = [
+      { kind: "blockStart" },
+      { kind: "text", text: PLACEHOLDER_EMPTY_TURN },
+      { kind: "blockStop" },
+      { kind: "blockStart" },
+      { kind: "text", text: "Fresh block content" },
+      { kind: "blockStop" },
+    ];
+    const emitted: string[] = [];
+    await provider.sendMessage([userMsg("Hi")], undefined, undefined, {
+      onEvent: (event) => {
+        if (event.type === "text_delta") emitted.push(event.text);
+      },
+    });
+    expect(emitted).toEqual(["Fresh block content"]);
+  });
+
+  test("isPlaceholderSentinelText matches sentinel with and without the null-byte prefix", () => {
+    // The runtime filter must be lenient enough to catch sentinel text that
+    // lost its `\x00` prefix in transit (e.g. a model echoing it back from
+    // input history without reproducing the control character). Migration 222
+    // handles the same two variants.
+    expect(isPlaceholderSentinelText(PLACEHOLDER_EMPTY_TURN)).toBe(true);
+    expect(isPlaceholderSentinelText(PLACEHOLDER_BLOCKS_OMITTED)).toBe(true);
+    expect(
+      isPlaceholderSentinelText("__PLACEHOLDER__[empty assistant turn]"),
+    ).toBe(true);
+    expect(
+      isPlaceholderSentinelText("__PLACEHOLDER__[internal blocks omitted]"),
+    ).toBe(true);
+    // Nearby strings must NOT match — guard against over-broad matching.
+    expect(isPlaceholderSentinelText("")).toBe(false);
+    expect(isPlaceholderSentinelText("__PLACEHOLDER__")).toBe(false);
+    expect(
+      isPlaceholderSentinelText(
+        "prefix __PLACEHOLDER__[empty assistant turn]",
+      ),
+    ).toBe(false);
+  });
+
   // -----------------------------------------------------------------------
   // Workspace context injection + cache control
   // -----------------------------------------------------------------------

package/src/__tests__/app-compiler.test.ts

@@ -355,6 +355,63 @@ console.log("styled");`,
     const r2 = await compileApp(appDir2);
     expect(r2.ok).toBe(true);
   }, 30_000);
+
+  test("concurrent callers during an in-flight compile coalesce to at most one follow-up", async () => {
+    const appDir = await scaffold("concurrent-dedup", {
+      "main.tsx": `console.log("hello");`,
+      "index.html": MINIMAL_HTML,
+    });
+
+    // Kick off three concurrent compiles. Serialisation guarantees the
+    // first runs to completion alone; callers 2 and 3 coalesce into a
+    // single follow-up compile that begins after the first settles.
+    const [r1, r2, r3] = await Promise.all([
+      compileApp(appDir),
+      compileApp(appDir),
+      compileApp(appDir),
+    ]);
+
+    expect(r1.ok).toBe(true);
+    expect(r2.ok).toBe(true);
+    expect(r3.ok).toBe(true);
+
+    // Callers 2 and 3 share the coalesced follow-up promise.
+    expect(r2).toBe(r3);
+    // Caller 1 ran a distinct compile from the coalesced follow-up.
+    expect(r1).not.toBe(r2);
+
+    // Final dist/ output must be intact regardless of how many compiles
+    // ran: main.js non-empty and index.html has the injected script tag.
+    const js = await readFile(join(appDir, "dist", "main.js"), "utf-8");
+    expect(js.length).toBeGreaterThan(0);
+    const html = await readFile(join(appDir, "dist", "index.html"), "utf-8");
+    expect(html).toContain('src="main.js"');
+  });
+
+  test("source edit during an in-flight compile is picked up by the follow-up", async () => {
+    const appDir = await scaffold("mid-build-edit", {
+      "main.tsx": `console.log("original");`,
+      "index.html": MINIMAL_HTML,
+    });
+
+    // Start the first compile but do not await it yet.
+    const first = compileApp(appDir);
+
+    // Mutate the source while the first compile is still running, then
+    // request another compile. The follow-up must read the updated source
+    // rather than silently reusing the first compile's (now stale) output.
+    await writeFile(join(appDir, "src", "main.tsx"), `console.log("updated");`);
+    const second = compileApp(appDir);
+
+    const [r1, r2] = await Promise.all([first, second]);
+    expect(r1.ok).toBe(true);
+    expect(r2.ok).toBe(true);
+    expect(r1).not.toBe(r2);
+
+    const js = await readFile(join(appDir, "dist", "main.js"), "utf-8");
+    expect(js).toContain("updated");
+    expect(js).not.toContain("original");
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/approval-cascade.test.ts

@@ -57,15 +57,33 @@ mock.module("../providers/registry.js", () => ({
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
-    provider: "mock-provider",
-    maxTokens: 4096,
-    thinking: false,
-    contextWindow: {
-      maxInputTokens: 100000,
-      thresholdTokens: 80000,
-      preserveRecentMessages: 6,
-      summaryModel: "mock-model",
-      maxSummaryTokens: 512,
+    llm: {
+      default: {
+        provider: "mock-provider",
+        model: "mock-model",
+        maxTokens: 4096,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: false, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 100000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
+      },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
     timeouts: { permissionTimeoutSec: 300 },
@@ -187,12 +205,20 @@ mock.module("../agent/loop.js", () => ({
     getToolTokenBudget() {
       return 0;
     }
+    getResolvedTools() {
+      return [];
+    }
+    getActiveModel() {
+      return undefined;
+    }
     async run(
       _messages: Message[],
       _onEvent: (event: AgentEvent) => void,
       _signal?: AbortSignal,
       _requestId?: string,
-      _onCheckpoint?: (checkpoint: CheckpointInfo) => CheckpointDecision,
+      _onCheckpoint?: (
+        checkpoint: CheckpointInfo,
+      ) => CheckpointDecision | Promise<CheckpointDecision>,
     ): Promise<Message[]> {
       return [];
     }

package/src/__tests__/approval-routes-http.test.ts

@@ -27,11 +27,39 @@ mock.module("../config/loader.js", () => ({
     rateLimit: { maxRequestsPerMinute: 0 },
     secretDetection: { enabled: false },
     contextWindow: { maxInputTokens: 200000 },
+    llm: {
+      default: {
+        provider: "anthropic",
+        model: "claude-opus-4-7",
+        maxTokens: 64000,
+        effort: "max" as const,
+        speed: "standard" as const,
+        temperature: null,
+        thinking: { enabled: true, streamThinking: true },
+        contextWindow: {
+          enabled: true,
+          maxInputTokens: 200000,
+          targetBudgetRatio: 0.3,
+          compactThreshold: 0.8,
+          summaryBudgetRatio: 0.05,
+          overflowRecovery: {
+            enabled: true,
+            safetyMarginRatio: 0.05,
+            maxAttempts: 3,
+            interactiveLatestTurnCompression: "summarize",
+            nonInteractiveLatestTurnCompression: "truncate",
+          },
+        },
+      },
+      profiles: {},
+      callSites: {},
+      pricingOverrides: [],
+    },
     services: {
       inference: {
         mode: "your-own",
         provider: "anthropic",
-        model: "claude-opus-4-6",
+        model: "claude-opus-4-7",
       },
       "image-generation": {
         mode: "your-own",
@@ -55,16 +83,35 @@ mock.module("../config/env.js", () => ({
   setIngressPublicBaseUrl: () => {},
 }));
 
-// Mock the trust store so addRule doesn't touch disk or require full config
+// Mock the trust store so addRule doesn't touch disk or require full config.
+// Track calls to addRule so tests can verify canonicalization.
+const addRuleCalls: Array<{
+  tool: string;
+  pattern: string;
+  scope: string;
+  decision: string;
+  priority?: number;
+  options?: { executionTarget?: string };
+}> = [];
 mock.module("../permissions/trust-store.js", () => ({
-  addRule: () => ({
-    id: "test-rule",
-    tool: "test",
-    pattern: "*",
-    scope: "everywhere",
-    decision: "allow",
-    priority: 100,
-  }),
+  addRule: (
+    tool: string,
+    pattern: string,
+    scope: string,
+    decision: string,
+    priority?: number,
+    options?: { executionTarget?: string },
+  ) => {
+    addRuleCalls.push({ tool, pattern, scope, decision, priority, options });
+    return {
+      id: "test-rule",
+      tool,
+      pattern,
+      scope,
+      decision,
+      priority: priority ?? 100,
+    };
+  },
   getRules: () => [],
 }));
 
@@ -231,6 +278,7 @@ describe("standalone approval endpoints — HTTP layer", () => {
     db.run("DELETE FROM conversations");
     db.run("DELETE FROM conversation_keys");
     pendingInteractions.clear();
+    addRuleCalls.length = 0;
     eventHub = new AssistantEventHub();
   });
 
@@ -917,6 +965,82 @@ describe("standalone approval endpoints — HTTP layer", () => {
 
       await stopServer();
     });
+
+    test("trust rule creation works without allowHighRisk for scoped tool families", async () => {
+      const session = makeIdleSession();
+      await startServer(() => session);
+
+      pendingInteractions.register("req-bash-hr", {
+        conversation: session,
+        conversationId: "conv-1",
+        kind: "confirmation",
+        confirmationDetails: {
+          toolName: "bash",
+          input: { command: "rm -rf /tmp/test" },
+          riskLevel: "high",
+          allowlistOptions: [
+            { label: "Allow rm", description: "test", pattern: "rm**" },
+          ],
+          scopeOptions: [{ label: "Everywhere", scope: "everywhere" }],
+        },
+      });
+
+      const res = await fetch(url("trust-rules"), {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
+        body: JSON.stringify({
+          requestId: "req-bash-hr",
+          pattern: "rm**",
+          scope: "everywhere",
+          decision: "allow",
+        }),
+      });
+
+      expect(res.status).toBe(200);
+      expect(addRuleCalls).toHaveLength(1);
+      expect(addRuleCalls[0].decision).toBe("allow");
+
+      await stopServer();
+    });
+
+    test("accepts scope 'everywhere' for non-scoped tools (backward compat)", async () => {
+      const session = makeIdleSession();
+      await startServer(() => session);
+
+      pendingInteractions.register("req-nonscoped", {
+        conversation: session,
+        conversationId: "conv-1",
+        kind: "confirmation",
+        confirmationDetails: {
+          toolName: "web_fetch",
+          input: { url: "https://example.com" },
+          riskLevel: "medium",
+          allowlistOptions: [
+            {
+              label: "Allow fetch",
+              description: "test",
+              pattern: "https://example.com/**",
+            },
+          ],
+          scopeOptions: [],
+        },
+      });
+
+      const res = await fetch(url("trust-rules"), {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
+        body: JSON.stringify({
+          requestId: "req-nonscoped",
+          pattern: "https://example.com/**",
+          scope: "everywhere",
+          decision: "allow",
+        }),
+      });
+
+      expect(res.status).toBe(200);
+
+      await stopServer();
+    });
   });
 
   // ── Hub publisher integration ────────────────────────────────────────

package/src/__tests__/assistant-attachments.test.ts

@@ -284,6 +284,50 @@ describe("cleanAssistantContent", () => {
     expect(result.warnings).toHaveLength(0);
     expect(result.cleanedContent).toHaveLength(1);
   });
+
+  test("drops Anthropic placeholder sentinel text blocks", () => {
+    const content = [
+      { type: "text", text: "\x00__PLACEHOLDER__[empty assistant turn]" },
+      { type: "text", text: "\x00__PLACEHOLDER__[internal blocks omitted]" },
+      { type: "text", text: "real text" },
+      { type: "tool_use", id: "t1", name: "read", input: {} },
+    ];
+    const result = cleanAssistantContent(content);
+
+    expect(result.cleanedContent).toHaveLength(2);
+    expect((result.cleanedContent[0] as { text: string }).text).toBe(
+      "real text",
+    );
+    expect((result.cleanedContent[1] as { type: string }).type).toBe(
+      "tool_use",
+    );
+  });
+
+  test("returns empty array when all text blocks are placeholder sentinels", () => {
+    const content = [
+      { type: "text", text: "\x00__PLACEHOLDER__[empty assistant turn]" },
+    ];
+    const result = cleanAssistantContent(content);
+
+    expect(result.cleanedContent).toHaveLength(0);
+  });
+
+  test("drops placeholder sentinels even when the null-byte prefix is missing", () => {
+    // Models sometimes echo the sentinel from input history without reproducing
+    // the \x00 control character. The filter must catch both variants so
+    // stripped-prefix echoes don't leak into persisted messages.
+    const content = [
+      { type: "text", text: "__PLACEHOLDER__[empty assistant turn]" },
+      { type: "text", text: "__PLACEHOLDER__[internal blocks omitted]" },
+      { type: "text", text: "real text" },
+    ];
+    const result = cleanAssistantContent(content);
+
+    expect(result.cleanedContent).toHaveLength(1);
+    expect((result.cleanedContent[0] as { text: string }).text).toBe(
+      "real text",
+    );
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/assistant-feature-flags-integration.test.ts

@@ -98,3 +98,32 @@ describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
     ).toBe(true);
   });
 });
+
+// ---------------------------------------------------------------------------
+// compaction-v2 flag (opt-in): ensures registry-declared defaultEnabled=false
+// is honored and that an explicit override can flip it on. Guards the rollout
+// gate for the boundary-message-based compaction pipeline introduced in
+// later PRs.
+// ---------------------------------------------------------------------------
+
+describe("compaction-v2 flag", () => {
+  test("defaults to false (disabled) when no override is set", () => {
+    const config = {} as any;
+
+    expect(isAssistantFeatureFlagEnabled("compaction-v2", config)).toBe(false);
+  });
+
+  test("returns true when explicitly overridden to true", () => {
+    _setOverridesForTesting({ "compaction-v2": true });
+    const config = {} as any;
+
+    expect(isAssistantFeatureFlagEnabled("compaction-v2", config)).toBe(true);
+  });
+
+  test("returns false when explicitly overridden to false", () => {
+    _setOverridesForTesting({ "compaction-v2": false });
+    const config = {} as any;
+
+    expect(isAssistantFeatureFlagEnabled("compaction-v2", config)).toBe(false);
+  });
+});

package/src/__tests__/auto-analysis-end-to-end.test.ts

@@ -50,6 +50,7 @@ mock.module("../memory/qdrant-client.js", () => ({
     deletePoints: async () => {},
   }),
   initQdrantClient: () => {},
+  resolveQdrantUrl: () => "http://127.0.0.1:6333",
 }));
 
 // ── Test config ────────────────────────────────────────────────────

package/src/__tests__/avatar-generator.test.ts

@@ -96,8 +96,10 @@ describe("generateAndSaveAvatar", () => {
     expect(result.content).toContain("No image data returned");
   });
 
-  test("generic error returns mapped message", async () => {
-    mockRouterError = new Error("Network timeout");
+  test("router-mapped error message is surfaced verbatim", async () => {
+    // avatar-router now maps provider errors before throwing, so the
+    // generator just surfaces error.message directly.
+    mockRouterError = new Error("Image generation failed: Network timeout");
 
     const result = await executeAvatar("a cat");
 

package/src/__tests__/browser-fill-credential.test.ts

@@ -347,7 +347,7 @@ describe("executeBrowserFillCredential", () => {
     );
     expect(result.isError).toBe(true);
     expect(result.content).toContain('element_id "e99" not found');
-    expect(result.content).toContain("browser_snapshot");
+    expect(result.content).toContain("snapshot");
     // Element resolution fails before any CDP session is opened.
     expect(sendCalls).toHaveLength(0);
     expect(detachCalls).toBe(0);

package/src/__tests__/browser-identifier-parity-guard.test.ts

@@ -0,0 +1,53 @@
+/**
+ * Parity guard for browser operation and CLI subcommand identifiers.
+ *
+ * Verifies that the canonical operation list and CLI subcommand
+ * metadata remain in sync:
+ *
+ *   1. Shared operation list     (BROWSER_OPERATIONS from browser/types.ts)
+ *   2. CLI subcommand metadata   (BROWSER_OPERATION_META from browser/operations.ts)
+ *
+ * Drift between these causes silent mismatches between the CLI and
+ * operation dispatch. This guard catches additions or removals in
+ * one source that aren't mirrored in the other.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { BROWSER_OPERATION_META } from "../browser/operations.js";
+import { BROWSER_OPERATIONS } from "../browser/types.js";
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function sorted(arr: readonly string[]): string[] {
+  return [...arr].sort();
+}
+
+// ── Parity tests ─────────────────────────────────────────────────────
+
+describe("browser CLI/operation parity guard", () => {
+  test("CLI subcommand operations match BROWSER_OPERATIONS", () => {
+    const metaOperations = BROWSER_OPERATION_META.map((m) => m.operation);
+    expect(sorted(metaOperations)).toEqual(sorted(BROWSER_OPERATIONS));
+  });
+
+  test("both sources agree on the same count", () => {
+    const metaOperations = BROWSER_OPERATION_META.map((m) => m.operation);
+
+    const counts = {
+      BROWSER_OPERATIONS: BROWSER_OPERATIONS.length,
+      BROWSER_OPERATION_META: metaOperations.length,
+    };
+
+    // All counts must be identical.
+    const uniqueCounts = new Set(Object.values(counts));
+    expect(uniqueCounts.size).toBe(1);
+  });
+
+  test("every CLI subcommand has a help text referencing the assistant browser command", () => {
+    for (const meta of BROWSER_OPERATION_META) {
+      expect(meta.helpText).toBeDefined();
+      expect(meta.helpText).toContain("assistant browser");
+    }
+  });
+});