@vellumai/assistant 0.10.4-dev.202607012136.5ef7865 → 0.10.4-dev.202607012234.a9be056

package/openapi.yaml

@@ -21119,6 +21119,11 @@ paths:
                         name:
                           type: string
                           description: Display name. Equal to `id` today.
+                        enabled:
+                          type: boolean
+                          description:
+                            Whether the plugin is active in this workspace. `false` when a `.disabled` sentinel is present under its
+                            directory; `true` otherwise.
                         description:
                           anyOf:
                             - type: string
@@ -21147,6 +21152,7 @@ paths:
                       required:
                         - id
                         - name
+                        - enabled
                         - description
                         - version
                       additionalProperties: false
@@ -21430,6 +21436,80 @@ paths:
           description: The install recorded no commit or no fingerprint to re-materialize and verify a baseline from.
         "503":
           description: The plugin source (GitHub) was temporarily unavailable; the diff is retryable.
+  /v1/plugins/{name}/disable:
+    post:
+      operationId: plugins_by_name_disable_post
+      summary: Disable a plugin
+      description:
+        Disable a plugin in this workspace by dropping a `.disabled` sentinel, mirroring the CLI's `assistant
+        plugins disable <name>`. The change is honored live at read time by every tool / injector / hook gate — no
+        restart required. Broadcasts a `sync_changed` invalidation carrying the `plugins:list` tag so other clients
+        refetch `GET /v1/plugins`. An already-disabled plugin returns 409; a user plugin with no directory returns 404
+        (default plugins are stubbed on demand via the `default-` prefix); a malformed name returns 400.
+      tags:
+        - plugins
+      parameters:
+        - name: name
+          in: path
+          required: true
+          schema:
+            type: string
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  ok:
+                    type: boolean
+                required:
+                  - ok
+                additionalProperties: false
+        "400":
+          description: The plugin name failed validation (not kebab-case alphanumerics).
+        "404":
+          description: No plugin directory exists with the given name (user plugins must already be installed).
+        "409":
+          description: The plugin is already disabled.
+  /v1/plugins/{name}/enable:
+    post:
+      operationId: plugins_by_name_enable_post
+      summary: Enable a plugin
+      description:
+        Enable a plugin in this workspace by removing its `.disabled` sentinel, mirroring the CLI's `assistant
+        plugins enable <name>`. The change is honored live at read time by every tool / injector / hook gate — no
+        restart required. Broadcasts a `sync_changed` invalidation carrying the `plugins:list` tag so other clients
+        refetch `GET /v1/plugins`. An already-enabled plugin returns 409; a name with no plugin directory returns 404
+        (prefix a default plugin with `default-`); a malformed name returns 400.
+      tags:
+        - plugins
+      parameters:
+        - name: name
+          in: path
+          required: true
+          schema:
+            type: string
+      responses:
+        "200":
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  ok:
+                    type: boolean
+                required:
+                  - ok
+                additionalProperties: false
+        "400":
+          description: The plugin name failed validation (not kebab-case alphanumerics).
+        "404":
+          description: No plugin directory exists with the given name.
+        "409":
+          description: The plugin is already enabled.
   /v1/plugins/{name}/inspect:
     get:
       operationId: plugins_by_name_inspect_get

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.10.4-dev.202607012136.5ef7865",
+  "version": "0.10.4-dev.202607012234.a9be056",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/context-search-conversations-source.test.ts

@@ -2,13 +2,12 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
 import { writeSlackMetadata } from "../messaging/providers/slack/message-metadata.js";
 import type { MessageLexicalSearchResult } from "../persistence/embeddings/messages-lexical-index.js";
-import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 // Mutable stand-in for the Qdrant lexical candidate helper. The default
 // throws so any qdrant-path test that forgets to set an implementation fails
 // loudly rather than silently exercising an empty candidate set. FTS-path
-// tests never reach it (the flag defaults to fts5), so its value is irrelevant
-// there.
+// tests never reach it (fts5 is used until the backfill completes), so its
+// value is irrelevant there.
 let lexicalMockImpl: (
   query: string,
   limit: number,
@@ -407,14 +406,13 @@ describe("searchConversationSource with the qdrant backend", () => {
     getDb().run("DELETE FROM conversations");
     lexicalCalls = [];
     suppressIndexing = false;
-    // These tests exercise the populated-index (post-backfill) qdrant path, so
-    // mark the backfill complete. The completion gate is covered by its own test.
+    // The qdrant backend is selected once the index is populated: not suppressed
+    // + backfill complete. These tests exercise that post-backfill path, so mark
+    // the backfill complete. The completion gate is covered by its own test.
     setMemoryCheckpoint(LEXICAL_BACKFILL_COMPLETE_KEY, "1");
-    setOverridesForTesting({ "messages-search-backend": true });
   });
 
   afterEach(() => {
-    setOverridesForTesting({});
     suppressIndexing = false;
     deleteMemoryCheckpoint(LEXICAL_BACKFILL_COMPLETE_KEY);
     lexicalMockImpl = () => {
@@ -424,7 +422,7 @@ describe("searchConversationSource with the qdrant backend", () => {
     };
   });
 
-  test("falls back to FTS when memory indexing is suppressed, even with the qdrant flag on", async () => {
+  test("falls back to FTS when memory indexing is suppressed", async () => {
     const match = await seedConversation({
       title: "Suppressed indexing notes",
       content: "The suppressedtoken decision is recorded here.",
@@ -451,7 +449,7 @@ describe("searchConversationSource with the qdrant backend", () => {
     ]);
   });
 
-  test("falls back to FTS until the backfill completion checkpoint is set, even with the qdrant flag on", async () => {
+  test("falls back to FTS until the backfill completion checkpoint is set", async () => {
     const match = await seedConversation({
       title: "Pre-backfill notes",
       content: "The prebackfilltoken decision is recorded here.",

package/src/__tests__/non-member-access-request.test.ts

@@ -94,12 +94,17 @@ function seedGatewayGuardian(
 }
 
 import {
+  createCanonicalGuardianRequest,
   listCanonicalGuardianDeliveries,
   listCanonicalGuardianRequests,
+  resolveCanonicalGuardianRequest,
 } from "../contacts/canonical-guardian-store.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
-import { notifyGuardianOfAccessRequest } from "../runtime/access-request-helper.js";
+import {
+  isAccessRequestDenied,
+  notifyGuardianOfAccessRequest,
+} from "../runtime/access-request-helper.js";
 import { handleChannelInbound } from "./helpers/channel-test-adapter.js";
 import { createGuardianBinding } from "./helpers/create-guardian-binding.js";
 
@@ -304,6 +309,74 @@ describe("non-member access request notification", () => {
     expect(pending.length).toBe(1);
   });
 
+  // After the guardian denies an access request, subsequent DMs from the same
+  // sender do not re-prompt the guardian. Drives the real inbound path for both
+  // messages so the deny-dedup matches the exact assistant-scoped
+  // conversationId the notify path derives — a hand-crafted fixture could mask
+  // a mismatch.
+  test("a denied sender's subsequent DM does not re-prompt the guardian", async () => {
+    seedGatewayGuardian({
+      channelType: "telegram",
+      address: "guardian-user-789",
+      externalChatId: "guardian-chat-789",
+      principalId: anchorPrincipalId,
+    });
+    createGuardianBinding({
+      channel: "telegram",
+      guardianExternalUserId: "guardian-user-789",
+      guardianDeliveryChatId: "guardian-chat-789",
+      guardianPrincipalId: anchorPrincipalId,
+      verifiedVia: "test",
+    });
+
+    // 1) First DM from the unknown sender → guardian is prompted once.
+    await handleChannelInbound(
+      buildInboundRequest(),
+      undefined,
+      TEST_BEARER_TOKEN,
+    );
+    expect(emitSignalCalls.length).toBe(1);
+
+    const created = listCanonicalGuardianRequests({
+      status: "pending",
+      requesterExternalUserId: "user-unknown-456",
+      sourceChannel: "telegram",
+      kind: "access_request",
+    });
+    expect(created.length).toBe(1);
+
+    // 2) Guardian denies — resolve the *real* request (same CAS transition the
+    // deny primitive performs), preserving its conversationId.
+    const denied = resolveCanonicalGuardianRequest(created[0].id, "pending", {
+      status: "denied",
+      decidedByExternalUserId: "guardian-user-789",
+    });
+    expect(denied?.status).toBe("denied");
+
+    // 3) Same sender DMs again → still denied, but NO new guardian prompt.
+    const resp2 = await handleChannelInbound(
+      buildInboundRequest({
+        externalMessageId: `msg-after-deny-${Date.now()}`,
+      }),
+      undefined,
+      TEST_BEARER_TOKEN,
+    );
+    const json2 = (await resp2.json()) as Record<string, unknown>;
+    expect(json2.denied).toBe(true);
+
+    // No additional access-request signal was emitted (still just the first).
+    expect(emitSignalCalls.length).toBe(1);
+
+    // And no fresh pending request was created for the denied sender.
+    const pendingAfter = listCanonicalGuardianRequests({
+      status: "pending",
+      requesterExternalUserId: "user-unknown-456",
+      sourceChannel: "telegram",
+      kind: "access_request",
+    });
+    expect(pendingAfter.length).toBe(0);
+  });
+
   test("access request is created with self-healed principal even without same-channel guardian binding", async () => {
     // No guardian binding on any channel — self-heal creates a vellum binding
     // so the access_request (now decisionable) has a guardianPrincipalId.
@@ -826,4 +899,154 @@ describe("access-request-helper unit tests", () => {
     expect(telegram!.destinationChatId).toBe("guardian-chat-456");
     expect(telegram!.status).toBe("sent");
   });
+
+  test("notifyGuardianOfAccessRequest is suppressed after a prior deny for the same sender", async () => {
+    // Simulate a previously-denied access request for this sender on this
+    // channel/assistant. The conversationId must match the assistant-scoped
+    // key the helper derives: access-req-<assistantId>-<channel>-<actor>.
+    createCanonicalGuardianRequest({
+      id: `denied-${Date.now()}`,
+      kind: "access_request",
+      sourceType: "channel",
+      sourceChannel: "telegram",
+      conversationId: "access-req-self-telegram-denied-user",
+      requesterExternalUserId: "denied-user",
+      guardianPrincipalId: anchorPrincipalId,
+      toolName: "ingress_access_request",
+      status: "denied",
+    });
+
+    const result = await notifyGuardianOfAccessRequest({
+      canonicalAssistantId: "self",
+      sourceChannel: "telegram",
+      conversationExternalId: "chat-denied",
+      actorExternalId: "denied-user",
+      actorDisplayName: "Denied User",
+    });
+
+    // Suppressed: no new prompt, no signal, no new pending request.
+    expect(result.notified).toBe(false);
+    if (!result.notified) {
+      expect(result.reason).toBe("already_denied");
+    }
+    expect(emitSignalCalls.length).toBe(0);
+
+    const pending = listCanonicalGuardianRequests({
+      status: "pending",
+      requesterExternalUserId: "denied-user",
+      kind: "access_request",
+    });
+    expect(pending.length).toBe(0);
+  });
+
+  test("a prior deny for one sender does not suppress prompts for a different sender", async () => {
+    createCanonicalGuardianRequest({
+      id: `denied-other-${Date.now()}`,
+      kind: "access_request",
+      sourceType: "channel",
+      sourceChannel: "telegram",
+      conversationId: "access-req-self-telegram-denied-user",
+      requesterExternalUserId: "denied-user",
+      guardianPrincipalId: anchorPrincipalId,
+      toolName: "ingress_access_request",
+      status: "denied",
+    });
+
+    // A different sender still gets a fresh prompt.
+    const result = await notifyGuardianOfAccessRequest({
+      canonicalAssistantId: "self",
+      sourceChannel: "telegram",
+      conversationExternalId: "chat-fresh",
+      actorExternalId: "fresh-user",
+      actorDisplayName: "Fresh User",
+    });
+
+    expect(result.notified).toBe(true);
+    expect(emitSignalCalls.length).toBe(1);
+
+    const pending = listCanonicalGuardianRequests({
+      status: "pending",
+      requesterExternalUserId: "fresh-user",
+      kind: "access_request",
+    });
+    expect(pending.length).toBe(1);
+  });
+
+  test("a denied request on a different channel does not suppress a new channel's prompt", async () => {
+    // Denied on telegram; the same actor id messaging on slack is a distinct
+    // (channel-scoped) context and still surfaces to the guardian.
+    createCanonicalGuardianRequest({
+      id: `denied-tg-${Date.now()}`,
+      kind: "access_request",
+      sourceType: "channel",
+      sourceChannel: "telegram",
+      conversationId: "access-req-self-telegram-cross-user",
+      requesterExternalUserId: "cross-user",
+      guardianPrincipalId: anchorPrincipalId,
+      toolName: "ingress_access_request",
+      status: "denied",
+    });
+
+    const result = await notifyGuardianOfAccessRequest({
+      canonicalAssistantId: "self",
+      sourceChannel: "slack",
+      conversationExternalId: "C-cross",
+      actorExternalId: "cross-user",
+      actorDisplayName: "Cross User",
+    });
+
+    expect(result.notified).toBe(true);
+    const pending = listCanonicalGuardianRequests({
+      status: "pending",
+      requesterExternalUserId: "cross-user",
+      sourceChannel: "slack",
+      kind: "access_request",
+    });
+    expect(pending.length).toBe(1);
+  });
+
+  test("isAccessRequestDenied is true only for the denied (assistant, channel, sender)", () => {
+    const key = {
+      canonicalAssistantId: "self",
+      sourceChannel: "telegram",
+      actorExternalId: "denied-user",
+    };
+    expect(isAccessRequestDenied(key)).toBe(false);
+
+    createCanonicalGuardianRequest({
+      id: `denied-${Date.now()}`,
+      kind: "access_request",
+      sourceType: "channel",
+      sourceChannel: "telegram",
+      conversationId: "access-req-self-telegram-denied-user",
+      requesterExternalUserId: "denied-user",
+      guardianPrincipalId: anchorPrincipalId,
+      toolName: "ingress_access_request",
+      status: "denied",
+    });
+
+    expect(isAccessRequestDenied(key)).toBe(true);
+    // Scoped: a different channel or sender is not treated as denied.
+    expect(isAccessRequestDenied({ ...key, sourceChannel: "slack" })).toBe(
+      false,
+    );
+    expect(isAccessRequestDenied({ ...key, actorExternalId: "other" })).toBe(
+      false,
+    );
+    // A still-pending request is not a terminal deny.
+    createCanonicalGuardianRequest({
+      id: `pending-${Date.now()}`,
+      kind: "access_request",
+      sourceType: "channel",
+      sourceChannel: "telegram",
+      conversationId: "access-req-self-telegram-pending-user",
+      requesterExternalUserId: "pending-user",
+      guardianPrincipalId: anchorPrincipalId,
+      toolName: "ingress_access_request",
+      status: "pending",
+    });
+    expect(
+      isAccessRequestDenied({ ...key, actorExternalId: "pending-user" }),
+    ).toBe(false);
+  });
 });

package/src/__tests__/plugin-import-boundary-guard.test.ts

@@ -78,7 +78,6 @@ const BASELINE: Record<string, readonly string[]> = {
     "../../../util/logger.js",
   ],
   memory: [
-    "../../../../../config/assistant-feature-flags.js",
     "../../../../../config/types.js",
     "../../../../../messaging/providers/slack/message-metadata.js",
     "../../../../../persistence/auto-analysis-constants.js",

package/src/__tests__/slack-inbound-verification.test.ts

@@ -84,6 +84,7 @@ function seedGatewayGuardian(
   });
 }
 
+import { createCanonicalGuardianRequest } from "../contacts/canonical-guardian-store.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { findActiveSession } from "../runtime/channel-verification-service.js";
@@ -186,6 +187,41 @@ describe("Slack inbound trusted contact verification", () => {
     ).toContain("I don't recognize you yet");
   });
 
+  test("a terminally-denied Slack sender gets no challenge and no guardian re-prompt", async () => {
+    // Guardian previously denied this sender (terminal). Seed the denied
+    // canonical request under the assistant-scoped conversationId the ingress
+    // path derives for (self, slack, U0123UNKNOWN).
+    createCanonicalGuardianRequest({
+      id: `denied-${Date.now()}`,
+      kind: "access_request",
+      sourceType: "channel",
+      sourceChannel: "slack",
+      conversationId: "access-req-self-slack-U0123UNKNOWN",
+      requesterExternalUserId: "U0123UNKNOWN",
+      guardianPrincipalId: "guardian-principal",
+      toolName: "ingress_access_request",
+      status: "denied",
+    });
+
+    const resp = await handleChannelInbound(
+      buildSlackInboundRequest(),
+      undefined,
+      TEST_BEARER_TOKEN,
+    );
+    const json = (await resp.json()) as Record<string, unknown>;
+
+    // Still denied — but not via a fresh, unusable verification challenge.
+    expect(json.denied).toBe(true);
+    expect(json.reason).not.toBe("verification_challenge_sent");
+    expect(json.verificationSessionId).toBeUndefined();
+
+    // No verification session was minted for the denied sender.
+    expect(findActiveSession("slack")).toBeNull();
+
+    // And the guardian was not re-notified.
+    expect(emitSignalCalls.length).toBe(0);
+  });
+
   test("verification session is identity-bound to the Slack user", async () => {
     const req = buildSlackInboundRequest();
     await handleChannelInbound(req, undefined, TEST_BEARER_TOKEN);

package/src/__tests__/trusted-contact-multichannel.test.ts

@@ -52,6 +52,10 @@ mock.module("../runtime/access-request-helper.js", () => ({
       requestId: `mock-req-${Date.now()}`,
     };
   },
+  // acl-enforcement imports this alongside notifyGuardianOfAccessRequest; stub
+  // it so the terminal-deny check never falls through to the real DB-backed
+  // helper in this mocked suite.
+  isAccessRequestDenied: () => false,
 }));
 
 const deliverReplyCalls: Array<{

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

@@ -17,7 +17,10 @@ import {
   getCanonicalGuardianRequest,
 } from "../contacts/canonical-guardian-store.js";
 import { findContactChannel } from "../contacts/contact-store.js";
-import { activateMemberChannel } from "../contacts/member-write-relay.js";
+import {
+  activateMemberChannel,
+  seedUnverifiedMemberChannel,
+} from "../contacts/member-write-relay.js";
 import { findConversation } from "../daemon/conversation-registry.js";
 import { emitNotificationSignal } from "../notifications/emit-signal.js";
 import {
@@ -499,6 +502,23 @@ const accessRequestResolver: GuardianRequestResolver = {
         "Access request resolver: deny",
       );
 
+      // Persist the denied sender as an unverified_contact (gateway-first).
+      // Denial is a terminal decision: the sender becomes a known, unverified
+      // contact so future inbound resolves as unverified_contact rather than
+      // re-triggering discovery. Paired with the denied-request suppression in
+      // notifyGuardianOfAccessRequest, this stops the prompt from re-firing on
+      // every subsequent DM. The guardian can still verify them later. Skipped
+      // for desktop-origin (vellum) requests, which carry no channel identity.
+      if (requesterExternalUserId && channel !== "vellum") {
+        await seedUnverifiedMemberChannel({
+          sourceChannel: channel,
+          externalUserId: requesterExternalUserId,
+          ...(requesterDisplayName
+            ? { displayName: requesterDisplayName }
+            : {}),
+        });
+      }
+
       // Deliver denial notification and lifecycle signals when channel context is available
       if (channelDeliveryContext) {
         try {

package/src/calls/relay-server.ts

@@ -1450,6 +1450,16 @@ export class RelayConnection {
           },
           "Guardian notified of voice access request with caller name",
         );
+      } else if (accessResult.reason === "already_denied") {
+        // The guardian already denied this caller; they are intentionally not
+        // re-notified. Deliver the denial copy rather than the "I'll let them
+        // know" timeout copy, which would falsely promise a notification.
+        log.info(
+          { callSessionId: this.callSessionId },
+          "Voice caller previously denied — suppressing re-notification, delivering denial",
+        );
+        void this.handleAccessRequestDenied();
+        return;
       } else {
         log.warn(
           { callSessionId: this.callSessionId },

package/src/cli/lib/__tests__/toggle-plugin.test.ts

@@ -132,6 +132,13 @@ describe("enablePlugin", () => {
     );
   });
 
+  it("throws PluginDirectoryNotFoundError for non-default plugin with no directory", () => {
+    // A missing user plugin must 404, not surface as an already-enabled no-op.
+    expect(() => enablePlugin("nonexistent-plugin")).toThrow(
+      PluginDirectoryNotFoundError,
+    );
+  });
+
   it("throws InvalidPluginNameError for path traversal attempts", () => {
     expect(() => enablePlugin("../state")).toThrow(InvalidPluginNameError);
     expect(() => enablePlugin("foo/bar")).toThrow(InvalidPluginNameError);

package/src/cli/lib/toggle-plugin.ts

@@ -16,7 +16,14 @@
  * it was the sentinel).
  */
 
-import { existsSync, mkdirSync, readdirSync, rmSync, unlinkSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  rmSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
 import { join } from "node:path";
 
 import { getWorkspacePluginsDir } from "../../util/platform.js";
@@ -111,7 +118,11 @@ export function disablePlugin(name: string): TogglePluginResult {
   }
 
   // Write empty sentinel file — content is irrelevant, existence is the signal.
-  Bun.write(sentinelPath, "");
+  // Synchronous (like `enablePlugin`'s `unlinkSync`) so the sentinel is durable
+  // before the caller returns, and a write failure throws synchronously into the
+  // caller's try/catch instead of an unawaited `Bun.write` promise that could
+  // resolve/reject after the response.
+  writeFileSync(sentinelPath, "");
   return { name: validated, action: "disable", sentinelPath };
 }
 
@@ -126,6 +137,14 @@ export function enablePlugin(name: string): TogglePluginResult {
   const pluginDir = join(pluginsDir, validated);
   const sentinelPath = join(pluginDir, DISABLED_FILE);
 
+  // A missing user plugin is a 404, not a no-op: without this, a typo/deleted
+  // name has no sentinel and would fall through to "already enabled" (409),
+  // indistinguishable from a genuinely-enabled plugin. Default plugins have no
+  // directory when enabled, so they skip this check (their no-op stays 409).
+  if (!validated.startsWith("default-") && !existsSync(pluginDir)) {
+    throw new PluginDirectoryNotFoundError(validated);
+  }
+
   if (!existsSync(sentinelPath)) {
     throw new PluginAlreadyInStateException(validated, "enable");
   }

package/src/config/assistant-feature-flags.ts

@@ -326,25 +326,3 @@ export function isAssistantFeatureFlagEnabled(
 ): boolean {
   return !!getAssistantFeatureFlagValue(key, config);
 }
-
-/**
- * Backends that resolve lexical message-content search.
- *   fts5   — SQLite FTS5 full-text index (default)
- *   qdrant — BM25-style sparse Qdrant lexical index (messages_lexical)
- */
-export type MessagesSearchBackend = "fts5" | "qdrant";
-
-/**
- * Resolve the active messages search backend from the boolean
- * `messages-search-backend` flag. Disabled (default) ⇒ `fts5`; enabled
- * (boolean `true`) ⇒ `qdrant`. The raw comparison also treats a stray
- * string override of `"qdrant"` as enabled; every other value (`false`,
- * `"fts5"`, any other string, undefined) falls back to `fts5` so the safe
- * default always wins for an unexpected override.
- */
-export function getMessagesSearchBackend(
-  config: AssistantConfig,
-): MessagesSearchBackend {
-  const raw = getAssistantFeatureFlagValue("messages-search-backend", config);
-  return raw === "qdrant" || raw === true ? "qdrant" : "fts5";
-}

package/src/config/feature-flag-registry.json

@@ -417,14 +417,6 @@
       "label": "New-thread suggestions library",
       "description": "Replace the empty-state conversation-starter chips with the scrollable, categorized suggestions library and detail drawer (currently mocked data).",
       "defaultEnabled": false
-    },
-    {
-      "id": "messages-search-backend",
-      "scope": "assistant",
-      "key": "messages-search-backend",
-      "label": "Messages Search Backend",
-      "description": "When disabled (default), message content search uses SQLite FTS5. When enabled, it uses the sparse Qdrant lexical index.",
-      "defaultEnabled": false
     }
   ]
 }