@vellumai/assistant 0.6.5 → 0.7.0

package/src/approvals/guardian-request-resolvers.ts

@@ -12,9 +12,9 @@
  */
 
 import { answerCall } from "../calls/call-domain.js";
-import { getGatewayInternalBaseUrl } from "../config/env.js";
 import { findContactChannel } from "../contacts/contact-store.js";
 import { upsertContactChannel } from "../contacts/contacts-write.js";
+import { emitFeedEvent } from "../home/emit-feed-event.js";
 import {
   type CanonicalGuardianRequest,
   getCanonicalGuardianRequest,
@@ -24,16 +24,12 @@ import {
   isNotificationSourceChannel,
   type NotificationSourceChannel,
 } from "../notifications/signal.js";
-import { addRule } from "../permissions/trust-store.js";
 import type { UserDecision } from "../permissions/types.js";
-import { isPermissionControlsV2Enabled } from "../permissions/v2-consent-policy.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
-import { mintDaemonDeliveryToken } from "../runtime/auth/token-service.js";
 import type { ApprovalAction } from "../runtime/channel-approval-types.js";
 import { createOutboundSession } from "../runtime/channel-verification-service.js";
 import { deliverChannelReply } from "../runtime/gateway-client.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
-import { getTool } from "../tools/registry.js";
 import { TC_GRANT_WAIT_MAX_MS } from "../tools/tool-approval-handler.js";
 import { getLogger } from "../util/logger.js";
 
@@ -77,7 +73,7 @@ export interface ActorContext {
 
 /** The decision being applied. */
 export interface ResolverDecision {
-  /** The effective action after any downgrade (e.g. approve_always -> approve_once). */
+  /** The effective action (approve_once or reject). */
   action: ApprovalAction;
   /** Optional user-supplied text (e.g. answer text for pending questions). */
   userText?: string;
@@ -131,7 +127,7 @@ function resolveDeliverCallbackUrlForChannel(channel: string): string | null {
     case "telegram":
     case "whatsapp":
     case "slack":
-      return `${getGatewayInternalBaseUrl()}/deliver/${channel}`;
+      return `/deliver/${channel}`;
     default:
       return null;
   }
@@ -190,36 +186,6 @@ const pendingInteractionResolver: GuardianRequestResolver = {
       return { ok: false, reason: "pending_interaction_not_found" };
     }
 
-    // Handle approve_always: persist a trust rule when the confirmation
-    // explicitly allows persistence and provides explicit options.
-    if (
-      !isPermissionControlsV2Enabled() &&
-      (decision.action === "approve_always" ||
-        decision.action === "approve_once")
-    ) {
-      const details = interaction.confirmationDetails;
-      if (
-        decision.action === "approve_always" &&
-        details &&
-        details.persistentDecisionsAllowed !== false &&
-        details.allowlistOptions?.length
-      ) {
-        const pattern = details.allowlistOptions[0].pattern;
-        // Non-scoped tools (web_fetch, network_request, etc.) have empty
-        // scopeOptions — default to 'everywhere' so approve_always still
-        // persists a trust rule instead of silently degrading to one-time.
-        const scope = details.scopeOptions?.length
-          ? details.scopeOptions[0].scope
-          : "everywhere";
-        const tool = getTool(details.toolName);
-        const executionTarget =
-          tool?.origin === "skill" ? details.executionTarget : undefined;
-        addRule(details.toolName, pattern, scope, "allow", 100, {
-          executionTarget,
-        });
-      }
-    }
-
     // Resolve the interaction: remove from tracker and get the session.
     const resolved = pendingInteractions.resolve(request.id);
     if (!resolved) {
@@ -235,28 +201,8 @@ const pendingInteractionResolver: GuardianRequestResolver = {
     }
 
     // Map action to the permission system's UserDecision type and notify session.
-    // Mirrors mapApprovalActionToUserDecision from channel-approvals.ts so
-    // temporal modes (approve_10m, approve_conversation) reach the session with
-    // the correct UserDecision instead of collapsing to plain "allow".
-    let userDecision: UserDecision;
-    if (isPermissionControlsV2Enabled()) {
-      userDecision = decision.action === "reject" ? "deny" : "allow";
-    } else {
-      switch (decision.action) {
-        case "reject":
-          userDecision = "deny";
-          break;
-        case "approve_10m":
-          userDecision = "allow_10m";
-          break;
-        case "approve_conversation":
-          userDecision = "allow_conversation";
-          break;
-        default:
-          userDecision = "allow";
-          break;
-      }
-    }
+    const userDecision: UserDecision =
+      decision.action === "reject" ? "deny" : "allow";
     resolved.conversation!.handleConfirmationResponse(
       request.id,
       userDecision,
@@ -266,6 +212,21 @@ const pendingInteractionResolver: GuardianRequestResolver = {
       ctx.emissionContext,
     );
 
+    const approved = decision.action !== "reject";
+    void emitFeedEvent({
+      source: "assistant",
+      title: approved ? "Tool Request Approved" : "Tool Request Denied",
+      summary: `${approved ? "Approved" : "Denied"} access to ${request.toolName ?? "unknown tool"}.`,
+      dedupKey: `guardian-approval:${request.id}`,
+      urgency: approved ? undefined : "medium",
+      detailPanel: { kind: "toolPermission" },
+    }).catch((err) => {
+      log.warn(
+        { err, requestId: request.id },
+        "Failed to emit guardian approval feed event",
+      );
+    });
+
     log.info(
       {
         event: "resolver_tool_approval_applied",
@@ -401,7 +362,6 @@ const accessRequestResolver: GuardianRequestResolver = {
     const decidedByExternalUserId = ctx.actor.actorExternalUserId ?? "";
     const assistantId = DAEMON_INTERNAL_ASSISTANT_ID;
     const desktopDeliverUrl = resolveDeliverCallbackUrlForChannel(channel);
-    const desktopBearerToken = mintDaemonDeliveryToken();
 
     // Resolve display names from the contacts database for enriched payloads
     const requesterContactResult = requesterExternalUserId
@@ -447,7 +407,6 @@ const accessRequestResolver: GuardianRequestResolver = {
           await deliverChannelReply(
             channelDeliveryContext.replyCallbackUrl,
             denialPayload,
-            channelDeliveryContext.bearerToken,
           );
         } catch (err) {
           log.error(
@@ -501,15 +460,11 @@ const accessRequestResolver: GuardianRequestResolver = {
             ? requesterExternalUserId
             : requesterChatId;
         try {
-          await deliverChannelReply(
-            desktopDeliverUrl,
-            {
-              chatId: targetChatId,
-              text: "Your access request has been denied.",
-              assistantId,
-            },
-            desktopBearerToken,
-          );
+          await deliverChannelReply(desktopDeliverUrl, {
+            chatId: targetChatId,
+            text: "Your access request has been denied.",
+            assistantId,
+          });
         } catch (err) {
           log.error(
             { err, requesterChatId },
@@ -518,6 +473,20 @@ const accessRequestResolver: GuardianRequestResolver = {
         }
       }
 
+      void emitFeedEvent({
+        source: "assistant",
+        title: "Access Request Denied",
+        summary: `Denied access request.`,
+        dedupKey: `guardian-access:${request.id}`,
+        urgency: "medium",
+        detailPanel: { kind: "permissionChat" },
+      }).catch((err) => {
+        log.warn(
+          { err, requestId: request.id },
+          "Failed to emit access request feed event",
+        );
+      });
+
       return {
         ok: true,
         applied: true,
@@ -558,6 +527,20 @@ const accessRequestResolver: GuardianRequestResolver = {
         "Access request resolver: voice approval — direct trusted-contact activation (no verification session)",
       );
 
+      void emitFeedEvent({
+        source: "assistant",
+        title: "Access Request Approved",
+        summary: `Granted access request.`,
+        dedupKey: `guardian-access:${request.id}`,
+        urgency: undefined,
+        detailPanel: { kind: "permissionChat" },
+      }).catch((err) => {
+        log.warn(
+          { err, requestId: request.id },
+          "Failed to emit access request feed event",
+        );
+      });
+
       return { ok: true, applied: true };
     }
 
@@ -612,7 +595,6 @@ const accessRequestResolver: GuardianRequestResolver = {
         await deliverChannelReply(
           channelDeliveryContext.replyCallbackUrl,
           codePayload,
-          channelDeliveryContext.bearerToken,
         );
       } catch (err) {
         log.error(
@@ -644,15 +626,11 @@ const accessRequestResolver: GuardianRequestResolver = {
         }
 
         try {
-          await deliverChannelReply(
-            dmCallbackUrl,
-            {
-              chatId: guardianUserId,
-              text: codeText,
-              assistantId,
-            },
-            channelDeliveryContext.bearerToken,
-          );
+          await deliverChannelReply(dmCallbackUrl, {
+            chatId: guardianUserId,
+            text: codeText,
+            assistantId,
+          });
         } catch (err) {
           // Best-effort: the code was already delivered in the shared channel
           log.warn(
@@ -696,11 +674,7 @@ const accessRequestResolver: GuardianRequestResolver = {
             approvalPayload.ephemeral = true;
             approvalPayload.user = requesterExternalUserId;
           }
-          await deliverChannelReply(
-            requesterCallbackUrl,
-            approvalPayload,
-            channelDeliveryContext.bearerToken,
-          );
+          await deliverChannelReply(requesterCallbackUrl, approvalPayload);
           requesterNotified = true;
         } catch (err) {
           log.error(
@@ -724,11 +698,7 @@ const accessRequestResolver: GuardianRequestResolver = {
             failurePayload.ephemeral = true;
             failurePayload.user = requesterExternalUserId;
           }
-          await deliverChannelReply(
-            requesterCallbackUrl,
-            failurePayload,
-            channelDeliveryContext.bearerToken,
-          );
+          await deliverChannelReply(requesterCallbackUrl, failurePayload);
         } catch (err) {
           log.error(
             { err, requesterChatId },
@@ -769,17 +739,13 @@ const accessRequestResolver: GuardianRequestResolver = {
           ? requesterExternalUserId
           : requesterChatId;
       try {
-        await deliverChannelReply(
-          desktopDeliverUrl,
-          {
-            chatId: targetChatId,
-            text:
-              "Your access request has been approved! " +
-              "Please enter the 6-digit verification code you receive from the guardian.",
-            assistantId,
-          },
-          desktopBearerToken,
-        );
+        await deliverChannelReply(desktopDeliverUrl, {
+          chatId: targetChatId,
+          text:
+            "Your access request has been approved! " +
+            "Please enter the 6-digit verification code you receive from the guardian.",
+          assistantId,
+        });
         requesterNotified = true;
       } catch (err) {
         log.error(
@@ -793,6 +759,20 @@ const accessRequestResolver: GuardianRequestResolver = {
       ? `Access approved for ${requesterLabel}. Give them this verification code: \`${session.secret}\`. The code expires in 10 minutes.`
       : `Access approved for ${requesterLabel}. Give them this verification code: \`${session.secret}\`. The code expires in 10 minutes. I could not notify them automatically, so please tell them to send the code manually.`;
 
+    void emitFeedEvent({
+      source: "assistant",
+      title: "Access Request Approved",
+      summary: `Granted access request.`,
+      dedupKey: `guardian-access:${request.id}`,
+      urgency: undefined,
+      detailPanel: { kind: "permissionChat" },
+    }).catch((err) => {
+      log.warn(
+        { err, requestId: request.id },
+        "Failed to emit access request feed event",
+      );
+    });
+
     return {
       ok: true,
       applied: true,
@@ -857,7 +837,6 @@ const toolGrantRequestResolver: GuardianRequestResolver = {
           await deliverChannelReply(
             channelDeliveryContext.replyCallbackUrl,
             grantDenialPayload,
-            channelDeliveryContext.bearerToken,
           );
         } catch (err) {
           log.error(
@@ -867,6 +846,20 @@ const toolGrantRequestResolver: GuardianRequestResolver = {
         }
       }
 
+      void emitFeedEvent({
+        source: "assistant",
+        title: "Tool Grant Denied",
+        summary: `Denied grant request for ${request.toolName ?? "unknown tool"}.`,
+        dedupKey: `guardian-grant:${request.id}`,
+        urgency: "medium",
+        detailPanel: { kind: "toolPermission" },
+      }).catch((err) => {
+        log.warn(
+          { err, requestId: request.id },
+          "Failed to emit tool grant denial feed event",
+        );
+      });
+
       return { ok: true, applied: true };
     }
 
@@ -955,7 +948,6 @@ const toolGrantRequestResolver: GuardianRequestResolver = {
         await deliverChannelReply(
           channelDeliveryContext.replyCallbackUrl,
           grantApprovalPayload,
-          channelDeliveryContext.bearerToken,
         );
       } catch (err) {
         log.error(
@@ -965,6 +957,20 @@ const toolGrantRequestResolver: GuardianRequestResolver = {
       }
     }
 
+    void emitFeedEvent({
+      source: "assistant",
+      title: "Tool Grant Approved",
+      summary: `Approved grant request for ${request.toolName ?? "unknown tool"}.`,
+      dedupKey: `guardian-grant:${request.id}`,
+      urgency: undefined,
+      detailPanel: { kind: "toolPermission" },
+    }).catch((err) => {
+      log.warn(
+        { err, requestId: request.id },
+        "Failed to emit tool grant approval feed event",
+      );
+    });
+
     return { ok: true, applied: true, grantMinted: false };
   },
 };

package/src/avatar/character-components.ts

@@ -1,34 +1,34 @@
-export interface BodyShapeDefinition {
+interface BodyShapeDefinition {
   id: string;
   viewBox: { width: number; height: number };
   faceCenter: { x: number; y: number };
   svgPath: string;
 }
 
-export interface EyePathDefinition {
+interface EyePathDefinition {
   svgPath: string;
   color: string; // hex e.g. "#F2F2F2"
 }
 
-export interface EyeStyleDefinition {
+interface EyeStyleDefinition {
   id: string;
   sourceViewBox: { width: number; height: number };
   eyeCenter: { x: number; y: number };
   paths: EyePathDefinition[];
 }
 
-export interface ColorDefinition {
+interface ColorDefinition {
   id: string;
   hex: string; // e.g. "#4C9B50"
 }
 
-export interface FaceCenterOverride {
+interface FaceCenterOverride {
   bodyShape: string;
   eyeStyle: string;
   faceCenter: { x: number; y: number };
 }
 
-export interface CharacterComponents {
+interface CharacterComponents {
   bodyShapes: BodyShapeDefinition[];
   eyeStyles: EyeStyleDefinition[];
   colors: ColorDefinition[];

package/src/{config/bundled-skills/settings/tools → avatar}/identity-avatar.ts

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { getWorkspaceDir } from "../../../../util/platform.js";
+import { getWorkspaceDir } from "../util/platform.js";
 
 /**
  * Update the `## Avatar` section in IDENTITY.md with a plain-text description.

package/src/backup/__tests__/backup-worker.test.ts

@@ -20,23 +20,13 @@ import {
 import { unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  test,
-} from "bun:test";
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { BackupConfig, BackupDestination } from "../../config/schema.js";
 import { BackupConfigSchema } from "../../config/schema.js";
 import type { StreamExportVBundleResult } from "../../runtime/migrations/vbundle-builder.js";
 import type { BackupDeps } from "../backup-worker.js";
-import {
-  createSnapshotNow,
-  runBackupTick,
-} from "../backup-worker.js";
+import { createSnapshotNow, runBackupTick } from "../backup-worker.js";
 
 // ---------------------------------------------------------------------------
 // Test fixtures
@@ -188,9 +178,6 @@ describe("runBackupTick — gating", () => {
       workspaceDir: ROOT,
       localDir,
       snapshotLockPath: join(ROOT, ".snapshot.lock"),
-      // Explicit plaintext to avoid touching the key file
-      trustPath: join(ROOT, "trust.json"),
-      hooksDir: join(ROOT, "hooks"),
     });
 
     expect(result).toBeNull();

package/src/backup/__tests__/paths.test.ts

@@ -88,8 +88,9 @@ describe("VELLUM_BACKUP_DIR override", () => {
 describe("deriveSafeAncestor", () => {
   test("iCloud Drive subtree anchors on the iCloud Drive root", () => {
     const iCloudRoot = getICloudDriveRoot();
-    expect(deriveSafeAncestor(join(iCloudRoot, "VellumAssistant", "backups")))
-      .toBe(iCloudRoot);
+    expect(
+      deriveSafeAncestor(join(iCloudRoot, "VellumAssistant", "backups")),
+    ).toBe(iCloudRoot);
     // The default offsite path specifically — this is the regression the
     // feature exists to fix.
     expect(deriveSafeAncestor(getDefaultOffsiteBackupsDir())).toBe(iCloudRoot);

package/src/backup/backup-worker.ts

@@ -26,7 +26,6 @@
  * surface against temp directories with tiny fake bundles.
  */
 
-import { join } from "node:path";
 import { Database } from "bun:sqlite";
 
 import { getConfig } from "../config/loader.js";
@@ -38,18 +37,10 @@ import {
 import type { StreamExportVBundleResult } from "../runtime/migrations/vbundle-builder.js";
 import { streamExportVBundle as realStreamExportVBundle } from "../runtime/migrations/vbundle-builder.js";
 import { getLogger } from "../util/logger.js";
-import {
-  getDbPath,
-  getProtectedDir,
-  getWorkspaceDir,
-  getWorkspaceHooksDir,
-} from "../util/platform.js";
+import { getDbPath, getWorkspaceDir } from "../util/platform.js";
 import { ensureBackupKey as realEnsureBackupKey } from "./backup-key.js";
 import type { SnapshotEntry } from "./list-snapshots.js";
-import {
-  pruneLocalSnapshots,
-  writeLocalSnapshot,
-} from "./local-writer.js";
+import { pruneLocalSnapshots, writeLocalSnapshot } from "./local-writer.js";
 import type { OffsiteWriteResult } from "./offsite-writer.js";
 import {
   pruneOffsiteSnapshotsInAll,
@@ -60,10 +51,7 @@ import {
   getLocalBackupsDir,
   resolveOffsiteDestinations,
 } from "./paths.js";
-import {
-  acquireSnapshotLock,
-  getSnapshotLockPath,
-} from "./snapshot-lock.js";
+import { acquireSnapshotLock, getSnapshotLockPath } from "./snapshot-lock.js";
 
 const log = getLogger("backup-worker");
 
@@ -116,10 +104,6 @@ export interface BackupDeps {
   workspaceDir?: string;
   /** Override for the local backup directory (tests). */
   localDir?: string;
-  /** Override for the trust.json path (tests). */
-  trustPath?: string;
-  /** Override for the hooks directory (tests). */
-  hooksDir?: string;
   /** Override for the backup key file path (tests). */
   backupKeyPath?: string;
   /**
@@ -187,9 +171,6 @@ async function performBackup(
   const ensureKey = deps.ensureBackupKey ?? realEnsureBackupKey;
   const workspaceDir = deps.workspaceDir ?? getWorkspaceDir();
   const localDir = deps.localDir ?? getLocalBackupsDir(config.localDirectory);
-  const trustPath =
-    deps.trustPath ?? join(getProtectedDir(), "trust.json");
-  const hooksDir = deps.hooksDir ?? getWorkspaceHooksDir();
   const backupKeyPath = deps.backupKeyPath ?? getBackupKeyPath();
 
   const startTimestamp = Date.now();
@@ -206,8 +187,6 @@ async function performBackup(
   // best-effort — the export still proceeds with whatever is on disk.
   const result = await streamExport({
     workspaceDir,
-    trustPath,
-    hooksDir,
     source: "backup-worker",
     description: "Automated backup snapshot",
     checkpoint: () => {

package/src/backup/paths.ts

@@ -8,24 +8,13 @@ import {
 import type { BackupDestination } from "../config/schema.js";
 import { getProtectedDir } from "../util/platform.js";
 
-/**
- * Computes the root ~/.vellum directory without introducing a new export from
- * `platform.ts`. `getProtectedDir()` returns `join(vellumRoot(), "protected")`,
- * so its parent directory is the vellum root. Using `dirname(getProtectedDir())`
- * keeps this module self-contained and avoids expanding the platform.ts surface
- * area just for backups.
- */
-function vellumRootFromProtected(): string {
-  return dirname(getProtectedDir());
-}
-
 /**
  * Returns the backup root directory. Respects the `VELLUM_BACKUP_DIR`
  * environment variable override (used in containerized deployments where
  * backups must be on a persistent volume); falls back to `~/.vellum/backups`.
  */
 export function getBackupRootDir(): string {
-  return getBackupDirOverride() ?? join(vellumRootFromProtected(), "backups");
+  return getBackupDirOverride() ?? join(homedir(), ".vellum", "backups");
 }
 
 /**
@@ -69,12 +58,7 @@ function safeUserInfoHomedir(): string {
  */
 export function getICloudDriveRoot(): string {
   const home = process.env.HOME || safeUserInfoHomedir() || homedir();
-  const root = join(
-    home,
-    "Library",
-    "Mobile Documents",
-    "com~apple~CloudDocs",
-  );
+  const root = join(home, "Library", "Mobile Documents", "com~apple~CloudDocs");
   if (!isAbsolute(root)) {
     throw new Error(
       `getICloudDriveRoot resolved to a relative path: ${root}. ` +

package/src/backup/restore.ts

@@ -27,14 +27,10 @@
  * in-process CLI caller get the reset for free. Tests can inject a fake via
  * `opts.resetDbImpl`.
  *
- * `commitImport` does NOT invalidate cached config or clear the trust cache.
- * Callers are responsible for:
- *   1. Calling `invalidateConfigCache()` and `clearTrustCache()` AFTER a
- *      successful restore so the daemon re-reads the restored `config.json`
- *      and `trust.json` instead of serving stale in-process caches.
- *   2. Considering a daemon restart as the simplest, most reliable recovery
- *      path — a CLI caller should refuse to restore against a live daemon
- *      unless explicitly forced.
+ * `commitImport` does NOT invalidate cached config. Callers are responsible
+ * for calling `invalidateConfigCache()` AFTER a successful restore so the
+ * daemon re-reads the restored `config.json` instead of serving stale
+ * in-process caches. A daemon restart is the simplest recovery path.
  *
  * Credentials are intentionally excluded from backups — they live in the OS
  * keychain / CES and are not restored by this path. Users re-authenticate
@@ -63,9 +59,9 @@ import { decryptFile } from "./stream-crypt.js";
  * live workspace. Production callers should leave this unset so the real
  * importer is used.
  */
-export type CommitImpl = typeof commitImport;
+type CommitImpl = typeof commitImport;
 
-export interface RestoreOptions {
+interface RestoreOptions {
   /** AES-256 decryption key. Required for `.vbundle.enc` snapshots. */
   key?: Buffer;
   /**
@@ -100,7 +96,7 @@ export interface RestoreResult {
   restoredFiles: number;
 }
 
-export interface VerifyOptions {
+interface VerifyOptions {
   /** AES-256 decryption key. Required for `.vbundle.enc` snapshots. */
   key?: Buffer;
 }

package/src/browser/__tests__/operations.test.ts

@@ -2,19 +2,11 @@ import { describe, expect, test } from "bun:test";
 
 import {
   BROWSER_OPERATION_META,
-  BROWSER_OPERATION_NAMES,
   executeBrowserOperation,
-  getBrowserOperationMeta,
 } from "../operations.js";
 import { BROWSER_OPERATIONS, type BrowserOperation } from "../types.js";
 
 describe("browser operations contract", () => {
-  // ── Exactly 17 operations ──────────────────────────────────────────
-
-  test("defines exactly 17 operations", () => {
-    expect(BROWSER_OPERATION_NAMES).toHaveLength(17);
-  });
-
   // ── CLI subcommand / operation 1:1 parity ──────────────────────────
 
   test("CLI subcommand metadata is in 1:1 parity with BROWSER_OPERATIONS", () => {
@@ -23,24 +15,6 @@ describe("browser operations contract", () => {
     expect(metaOps).toEqual(declaredOps);
   });
 
-  test("BROWSER_OPERATION_NAMES matches BROWSER_OPERATIONS", () => {
-    expect([...BROWSER_OPERATION_NAMES].sort()).toEqual(
-      [...BROWSER_OPERATIONS].sort(),
-    );
-  });
-
-  // ── Every operation has metadata ───────────────────────────────────
-
-  test("every operation has command metadata", () => {
-    for (const op of BROWSER_OPERATIONS) {
-      const meta = getBrowserOperationMeta(op);
-      expect(meta).toBeDefined();
-      expect(meta!.operation).toBe(op);
-      expect(typeof meta!.description).toBe("string");
-      expect(meta!.description.length).toBeGreaterThan(0);
-    }
-  });
-
   test("metadata count matches operation count", () => {
     expect(BROWSER_OPERATION_META).toHaveLength(BROWSER_OPERATIONS.length);
   });
@@ -67,15 +41,6 @@ describe("browser operations contract", () => {
 
   // ── wait_for_download mode constraints ─────────────────────────────
 
-  test("wait_for_download metadata restricts modes to auto and local", () => {
-    const meta = getBrowserOperationMeta("wait_for_download");
-    expect(meta).toBeDefined();
-    expect(meta!.allowedModes).toBeDefined();
-    expect(meta!.allowedModes).toContain("auto");
-    expect(meta!.allowedModes).toContain("local");
-    expect(meta!.allowedModes).toHaveLength(2);
-  });
-
   test("wait_for_download rejects extension mode", async () => {
     const result = await executeBrowserOperation(
       "wait_for_download",