@vellumai/assistant 0.4.43 → 0.4.45

package/src/daemon/handlers/shared.ts

@@ -13,7 +13,6 @@ import { getLogger } from "../../util/logger.js";
 import { estimateBase64Bytes } from "../assistant-attachments.js";
 import { ComputerUseSession } from "../computer-use-session.js";
 import type {
-  ClientMessage,
   ServerMessage,
   SessionTransportMetadata,
 } from "../message-protocol.js";
@@ -41,7 +40,7 @@ export const pendingStandaloneSecrets = new Map<
   }
 >();
 
-// Pending IPC signing responses (bundle signing orchestration), keyed by unique requestId
+// Pending signing responses (bundle signing orchestration), keyed by unique requestId
 interface PendingSigningResolve {
   resolve: (result: {
     signature: string;
@@ -132,7 +131,7 @@ export interface SessionCreateOptions {
   transport?: SessionTransportMetadata;
   assistantId?: string;
   trustContext?: TrustContext;
-  /** Normalized auth context for the session (IPC or HTTP-derived). */
+  /** Normalized auth context for the session. */
   authContext?: AuthContext;
   /** Whether this turn can block on interactive approval prompts. */
   isInteractive?: boolean;
@@ -171,29 +170,6 @@ export interface HandlerContext {
   heartbeatService?: HeartbeatService;
 }
 
-// ─── Typed dispatch ──────────────────────────────────────────────────────────
-
-type MessageType = ClientMessage["type"];
-// 'auth' is handled at the transport layer (server.ts) and never reaches dispatch.
-export type DispatchableType = Exclude<MessageType, "auth">;
-type MessageOfType<T extends MessageType> = Extract<ClientMessage, { type: T }>;
-type MessageHandler<T extends MessageType> = (
-  msg: MessageOfType<T>,
-  ctx: HandlerContext,
-) => void | Promise<void>;
-export type DispatchMap = { [T in DispatchableType]: MessageHandler<T> };
-
-/**
- * Type-safe handler group definition. Preserves exact key types so the
- * combined spread in index.ts can be checked for exhaustiveness via
- * `satisfies DispatchMap` instead of an unsafe `as DispatchMap` cast.
- */
-export function defineHandlers<K extends DispatchableType>(
-  handlers: Pick<DispatchMap, K>,
-): Pick<DispatchMap, K> {
-  return handlers;
-}
-
 /**
  * Query the main display dimensions via CoreGraphics.
  * Cached after the first successful call; falls back to 1920x1080.
@@ -276,7 +252,10 @@ export function wireEscalationHandler(
         }
         ctx.cuSessions.delete(sid);
         ctx.cuObservationParseSequence.delete(sid);
-        log.info({ sessionId: sid }, "Computer-use session cleaned up after terminal state");
+        log.info(
+          { sessionId: sid },
+          "Computer-use session cleaned up after terminal state",
+        );
       };
 
       const cuSession = new ComputerUseSession(
@@ -623,7 +602,7 @@ const SIGNING_TIMEOUT_MS = 30_000;
 
 /**
  * Create a SigningCallback that sends `sign_bundle_payload` to the Swift client
- * over IPC and waits for the `sign_bundle_payload_response`.
+ * over HTTP and waits for the `sign_bundle_payload_response`.
  */
 export function createSigningCallback(
   ctx: HandlerContext,

package/src/daemon/handlers/skills.ts

@@ -1,13 +1,14 @@
 import { existsSync, rmSync } from "node:fs";
 import { join } from "node:path";
 
+import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
 import {
   getConfig,
   invalidateConfigCache,
   loadRawConfig,
   saveRawConfig,
 } from "../../config/loader.js";
-import { resolveSkillStates } from "../../config/skill-state.js";
+import { resolveSkillStates, skillFlagKey } from "../../config/skill-state.js";
 import {
   ensureSkillIcon,
   loadSkillBySelector,
@@ -51,7 +52,6 @@ import type {
 } from "../message-protocol.js";
 import {
   CONFIG_RELOAD_DEBOUNCE_MS,
-  defineHandlers,
   ensureSkillEntry,
   type HandlerContext,
   log,
@@ -62,7 +62,7 @@ import {
 /**
  * Minimal context needed by the standalone skill business-logic functions.
  * HandlerContext satisfies this interface, but HTTP routes can also provide
- * a compatible object without coupling to IPC internals.
+ * a compatible object without coupling to handler internals.
  */
 export interface SkillOperationContext {
   debounceTimers: HandlerContext["debounceTimers"];
@@ -204,7 +204,7 @@ function heuristicDraft(body: string): {
 const LLM_DRAFT_TIMEOUT_MS = 15_000;
 
 // ─── Standalone business-logic functions ─────────────────────────────────────
-// These are consumed by both the IPC handlers below and the HTTP route layer.
+// These are consumed by both the handlers below and the HTTP route layer.
 
 /** Helper: suppress config reload, save, debounce, and update fingerprint. */
 function saveConfigWithSuppression(
@@ -318,7 +318,11 @@ export function disableSkill(
 
 export function configureSkill(
   skillId: string,
-  config: { env?: Record<string, string>; apiKey?: string; config?: Record<string, unknown> },
+  config: {
+    env?: Record<string, string>;
+    apiKey?: string;
+    config?: Record<string, unknown>;
+  },
   ctx: SkillOperationContext,
 ): { success: true } | { success: false; error: string } {
   try {
@@ -343,6 +347,20 @@ export async function installSkill(
   try {
     // Bundled skills are already available — no install needed
     const catalog = loadSkillCatalog();
+
+    // Feature flag gate: reject install if the skill's flag is disabled
+    const config = getConfig();
+    const flaggedSkill = catalog.find((s) => s.id === spec.slug);
+    if (flaggedSkill) {
+      const flagKey = skillFlagKey(flaggedSkill);
+      if (flagKey && !isAssistantFeatureFlagEnabled(flagKey, config)) {
+        return {
+          success: false,
+          error: `Skill "${spec.slug}" is currently unavailable (disabled by feature flag)`,
+        };
+      }
+    }
+
     const bundled = catalog.find(
       (s) => s.id === spec.slug && s.source === "bundled",
     );
@@ -484,7 +502,9 @@ export async function updateSkill(
 
 export async function checkSkillUpdates(
   _ctx: SkillOperationContext,
-): Promise<{ success: true; data: unknown } | { success: false; error: string }> {
+): Promise<
+  { success: true; data: unknown } | { success: false; error: string }
+> {
   try {
     const updates = await clawhubCheckUpdates();
     return { success: true, data: updates };
@@ -498,7 +518,9 @@ export async function checkSkillUpdates(
 export async function searchSkills(
   query: string,
   _ctx: SkillOperationContext,
-): Promise<{ success: true; data: unknown } | { success: false; error: string }> {
+): Promise<
+  { success: true; data: unknown } | { success: false; error: string }
+> {
   try {
     const result = await clawhubSearch(query);
     return { success: true, data: result };
@@ -742,11 +764,9 @@ export async function createSkill(
   }
 }
 
-// ─── IPC handlers (thin wrappers) ───────────────────────────────────────────
+// ─── HTTP handlers (thin wrappers) ──────────────────────────────────────────
 
-export function handleSkillsList(
-  ctx: HandlerContext,
-): void {
+export function handleSkillsList(ctx: HandlerContext): void {
   const skills = listSkills(ctx);
   ctx.send({ type: "skills_list_response", skills });
 }
@@ -923,19 +943,3 @@ export async function handleSkillsCreate(
     ...result,
   });
 }
-
-export const skillHandlers = defineHandlers({
-  skills_list: (_msg, ctx) => handleSkillsList(ctx),
-  skill_detail: handleSkillDetail,
-  skills_enable: handleSkillsEnable,
-  skills_disable: handleSkillsDisable,
-  skills_configure: handleSkillsConfigure,
-  skills_install: handleSkillsInstall,
-  skills_uninstall: handleSkillsUninstall,
-  skills_update: handleSkillsUpdate,
-  skills_check_updates: handleSkillsCheckUpdates,
-  skills_search: handleSkillsSearch,
-  skills_inspect: handleSkillsInspect,
-  skills_draft: handleSkillsDraft,
-  skills_create: handleSkillsCreate,
-});

package/src/daemon/host-bash-proxy.ts

@@ -0,0 +1,148 @@
+import { v4 as uuid } from "uuid";
+
+import { getConfig } from "../config/loader.js";
+import { formatShellOutput } from "../tools/shared/shell-output.js";
+import type { ToolExecutionResult } from "../tools/types.js";
+import { AssistantError, ErrorCode } from "../util/errors.js";
+import { getLogger } from "../util/logger.js";
+import type { ServerMessage } from "./message-protocol.js";
+
+const log = getLogger("host-bash-proxy");
+
+interface PendingRequest {
+  resolve: (result: ToolExecutionResult) => void;
+  reject: (err: Error) => void;
+  timer: ReturnType<typeof setTimeout>;
+  timeoutSec: number;
+}
+
+export class HostBashProxy {
+  private pending = new Map<string, PendingRequest>();
+  private sendToClient: (msg: ServerMessage) => void;
+  private onInternalResolve?: (requestId: string) => void;
+  private clientConnected = false;
+
+  constructor(
+    sendToClient: (msg: ServerMessage) => void,
+    onInternalResolve?: (requestId: string) => void,
+  ) {
+    this.sendToClient = sendToClient;
+    this.onInternalResolve = onInternalResolve;
+  }
+
+  updateSender(
+    sendToClient: (msg: ServerMessage) => void,
+    clientConnected: boolean,
+  ): void {
+    this.sendToClient = sendToClient;
+    this.clientConnected = clientConnected;
+  }
+
+  request(
+    input: { command: string; working_dir?: string; timeout_seconds?: number },
+    sessionId: string,
+    signal?: AbortSignal,
+  ): Promise<ToolExecutionResult> {
+    if (signal?.aborted) {
+      const result = formatShellOutput("", "Aborted", null, false, 0);
+      return Promise.resolve(result);
+    }
+
+    const requestId = uuid();
+
+    return new Promise<ToolExecutionResult>((resolve, reject) => {
+      const shellMaxTimeoutSec = getConfig().timeouts.shellMaxTimeoutSec;
+      const timeoutSec = input.timeout_seconds ?? shellMaxTimeoutSec;
+      // Proxy timeout: slightly after client-side timeout, but before executor's outer timeout
+      const proxyTimeoutSec = timeoutSec + 3;
+      const timer = setTimeout(() => {
+        this.pending.delete(requestId);
+        this.onInternalResolve?.(requestId);
+        log.warn(
+          { requestId, command: input.command },
+          "Host bash proxy request timed out",
+        );
+        resolve(
+          formatShellOutput(
+            "",
+            "Host bash proxy timed out waiting for client response",
+            null,
+            true,
+            timeoutSec,
+          ),
+        );
+      }, proxyTimeoutSec * 1000);
+
+      this.pending.set(requestId, { resolve, reject, timer, timeoutSec });
+
+      if (signal) {
+        const onAbort = () => {
+          if (this.pending.has(requestId)) {
+            clearTimeout(timer);
+            this.pending.delete(requestId);
+            this.onInternalResolve?.(requestId);
+            resolve(formatShellOutput("", "Aborted", null, false, 0));
+          }
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+
+      this.sendToClient({
+        type: "host_bash_request",
+        requestId,
+        sessionId,
+        command: input.command,
+        working_dir: input.working_dir,
+        timeout_seconds: input.timeout_seconds,
+      } as ServerMessage);
+    });
+  }
+
+  resolve(
+    requestId: string,
+    response: {
+      stdout: string;
+      stderr: string;
+      exitCode: number | null;
+      timedOut: boolean;
+    },
+  ): void {
+    const entry = this.pending.get(requestId);
+    if (!entry) {
+      log.warn({ requestId }, "No pending host bash request for response");
+      return;
+    }
+    clearTimeout(entry.timer);
+    this.pending.delete(requestId);
+    const result = formatShellOutput(
+      response.stdout,
+      response.stderr,
+      response.exitCode,
+      response.timedOut,
+      entry.timeoutSec,
+    );
+    entry.resolve(result);
+  }
+
+  hasPendingRequest(requestId: string): boolean {
+    return this.pending.has(requestId);
+  }
+
+  isAvailable(): boolean {
+    return this.clientConnected;
+  }
+
+  dispose(): void {
+    for (const [requestId, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      this.onInternalResolve?.(requestId);
+      entry.reject(
+        new AssistantError(
+          "Host bash proxy disposed",
+          ErrorCode.INTERNAL_ERROR,
+        ),
+      );
+    }
+    this.pending.clear();
+  }
+}

package/src/daemon/host-file-proxy.ts

@@ -0,0 +1,135 @@
+import { v4 as uuid } from "uuid";
+
+import type { ToolExecutionResult } from "../tools/types.js";
+import { AssistantError, ErrorCode } from "../util/errors.js";
+import { getLogger } from "../util/logger.js";
+import type { ServerMessage } from "./message-protocol.js";
+import type { HostFileRequest } from "./message-types/host-file.js";
+
+/** Distributive omit that preserves union variant fields. */
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown
+  ? Omit<T, K>
+  : never;
+
+/** Clean input type for callers — transport envelope fields are added by the proxy. */
+export type HostFileInput = DistributiveOmit<
+  HostFileRequest,
+  "type" | "requestId" | "sessionId"
+>;
+
+const log = getLogger("host-file-proxy");
+
+interface PendingRequest {
+  resolve: (result: ToolExecutionResult) => void;
+  reject: (err: Error) => void;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+export class HostFileProxy {
+  private pending = new Map<string, PendingRequest>();
+  private sendToClient: (msg: ServerMessage) => void;
+  private onInternalResolve?: (requestId: string) => void;
+  private clientConnected = false;
+
+  constructor(
+    sendToClient: (msg: ServerMessage) => void,
+    onInternalResolve?: (requestId: string) => void,
+  ) {
+    this.sendToClient = sendToClient;
+    this.onInternalResolve = onInternalResolve;
+  }
+
+  updateSender(
+    sendToClient: (msg: ServerMessage) => void,
+    clientConnected: boolean,
+  ): void {
+    this.sendToClient = sendToClient;
+    this.clientConnected = clientConnected;
+  }
+
+  request(
+    input: HostFileInput,
+    sessionId: string,
+    signal?: AbortSignal,
+  ): Promise<ToolExecutionResult> {
+    if (signal?.aborted) {
+      return Promise.resolve({ content: "Aborted", isError: true });
+    }
+
+    const requestId = uuid();
+
+    return new Promise<ToolExecutionResult>((resolve, reject) => {
+      // File operations should be fast — 30 second timeout.
+      const timeoutSec = 30;
+      const timer = setTimeout(() => {
+        this.pending.delete(requestId);
+        this.onInternalResolve?.(requestId);
+        log.warn(
+          { requestId, operation: input.operation },
+          "Host file proxy request timed out",
+        );
+        resolve({
+          content: "Host file proxy timed out waiting for client response",
+          isError: true,
+        });
+      }, timeoutSec * 1000);
+
+      this.pending.set(requestId, { resolve, reject, timer });
+
+      if (signal) {
+        const onAbort = () => {
+          if (this.pending.has(requestId)) {
+            clearTimeout(timer);
+            this.pending.delete(requestId);
+            this.onInternalResolve?.(requestId);
+            resolve({ content: "Aborted", isError: true });
+          }
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+
+      this.sendToClient({
+        ...input,
+        type: "host_file_request",
+        requestId,
+        sessionId,
+      } as ServerMessage);
+    });
+  }
+
+  resolve(
+    requestId: string,
+    response: { content: string; isError: boolean },
+  ): void {
+    const entry = this.pending.get(requestId);
+    if (!entry) {
+      log.warn({ requestId }, "No pending host file request for response");
+      return;
+    }
+    clearTimeout(entry.timer);
+    this.pending.delete(requestId);
+    entry.resolve({ content: response.content, isError: response.isError });
+  }
+
+  hasPendingRequest(requestId: string): boolean {
+    return this.pending.has(requestId);
+  }
+
+  isAvailable(): boolean {
+    return this.clientConnected;
+  }
+
+  dispose(): void {
+    for (const [requestId, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      this.onInternalResolve?.(requestId);
+      entry.reject(
+        new AssistantError(
+          "Host file proxy disposed",
+          ErrorCode.INTERNAL_ERROR,
+        ),
+      );
+    }
+    this.pending.clear();
+  }
+}

package/src/daemon/lifecycle.ts

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { chmodSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
@@ -30,6 +31,7 @@ import {
   getMessages,
 } from "../memory/conversation-crud.js";
 import { initializeDb } from "../memory/db.js";
+import { selectEmbeddingBackend } from "../memory/embedding-backend.js";
 import { startMemoryJobsWorker } from "../memory/jobs-worker.js";
 import { initQdrantClient } from "../memory/qdrant-client.js";
 import { QdrantManager } from "../memory/qdrant-manager.js";
@@ -43,10 +45,10 @@ import { syncUpdateBulletinOnStartup } from "../prompts/update-bulletin.js";
 import { buildAssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import { mintCredentialPair } from "../runtime/auth/credential-service.js";
 import {
   initAuthSigningKey,
   loadOrCreateSigningKey,
-  mintCliEdgeToken,
   mintPairingBearerToken,
 } from "../runtime/auth/token-service.js";
 import { ensureVellumGuardianBinding } from "../runtime/guardian-vellum-migration.js";
@@ -77,7 +79,6 @@ import {
   createGuardianActionCopyGenerator,
   createGuardianFollowUpConversationGenerator,
 } from "./guardian-action-generators.js";
-import { initPairingHandlers } from "./handlers/pairing.js";
 import {
   cancelGeneration,
   clearAllSessions,
@@ -93,7 +94,10 @@ import {
   registerMessagingProviders,
   registerWatcherProviders,
 } from "./providers-setup.js";
-import { handleRideShotgunStart, handleRideShotgunStop } from "./ride-shotgun-handler.js";
+import {
+  handleRideShotgunStart,
+  handleRideShotgunStop,
+} from "./ride-shotgun-handler.js";
 import { seedInterfaceFiles } from "./seed-files.js";
 import { DaemonServer } from "./server.js";
 import { initSlashPairingContext } from "./session-slash.js";
@@ -138,14 +142,6 @@ export async function runDaemon(): Promise<void> {
     const signingKey = loadOrCreateSigningKey();
     initAuthSigningKey(signingKey);
 
-    // Mint a CLI edge token (JWT) so the CLI can authenticate with the
-    // gateway. Written early so the CLI doesn't time out polling.
-    const httpTokenPath = join(getRootDir(), "http-token");
-    const bearerToken = mintCliEdgeToken();
-    writeFileSync(httpTokenPath, bearerToken, { mode: 0o600 });
-    chmodSync(httpTokenPath, 0o600);
-    log.info("Daemon startup: bearer token written");
-
     log.info("Daemon startup: migrations complete");
 
     seedInterfaceFiles();
@@ -165,9 +161,13 @@ export async function runDaemon(): Promise<void> {
     initializeDb();
     log.info("Daemon startup: DB initialized");
 
-    // Backfill vellum guardian binding for existing installations
+    // Ensure a vellum guardian binding exists and mint the CLI edge token
+    // as an actor token bound to the guardian principal.
+    let guardianPrincipalId: string | undefined;
     try {
-      ensureVellumGuardianBinding(DAEMON_INTERNAL_ASSISTANT_ID);
+      guardianPrincipalId = ensureVellumGuardianBinding(
+        DAEMON_INTERNAL_ASSISTANT_ID,
+      );
     } catch (err) {
       log.warn(
         { err },
@@ -175,6 +175,29 @@ export async function runDaemon(): Promise<void> {
       );
     }
 
+    if (guardianPrincipalId) {
+      const cliDeviceId = "daemon-cli";
+      const hashedDeviceId = createHash("sha256")
+        .update(cliDeviceId)
+        .digest("hex");
+      const credentials = mintCredentialPair({
+        platform: "cli",
+        deviceId: cliDeviceId,
+        guardianPrincipalId,
+        hashedDeviceId,
+      });
+
+      // DEPRECATED: The http-token file is deprecated. Readers will be
+      // migrated to use the credential store instead. This write is kept
+      // for backward compatibility until all consumers are updated.
+      const httpTokenPath = join(getRootDir(), "http-token");
+      writeFileSync(httpTokenPath, credentials.accessToken, { mode: 0o600 });
+      chmodSync(httpTokenPath, 0o600);
+      log.info("Daemon startup: CLI edge token written to credential store and http-token");
+    } else {
+      log.warn("No guardian principal available — CLI edge token not written");
+    }
+
     try {
       syncUpdateBulletinOnStartup();
     } catch (err) {
@@ -249,12 +272,17 @@ export async function runDaemon(): Promise<void> {
     const qdrantManager = new QdrantManager({ url: qdrantUrl });
     try {
       await qdrantManager.start();
+      const embeddingSelection = selectEmbeddingBackend(config);
+      const embeddingModel = embeddingSelection.backend
+        ? `${embeddingSelection.backend.provider}:${embeddingSelection.backend.model}`
+        : undefined;
       initQdrantClient({
         url: qdrantUrl,
         collection: config.memory.qdrant.collection,
         vectorSize: config.memory.qdrant.vectorSize,
         onDisk: config.memory.qdrant.onDisk,
         quantization: config.memory.qdrant.quantization,
+        embeddingModel,
       });
       log.info("Qdrant vector store initialized");
     } catch (err) {
@@ -290,11 +318,11 @@ export async function runDaemon(): Promise<void> {
             : undefined,
         );
       },
-      (reminder) => {
-        void emitNotificationSignal({
-          sourceEventName: "reminder.fired",
+      async (schedule) => {
+        await emitNotificationSignal({
+          sourceEventName: "schedule.notify",
           sourceChannel: "scheduler",
-          sourceSessionId: reminder.id,
+          sourceSessionId: schedule.id,
           attentionHints: {
             requiresAction: true,
             urgency: "high",
@@ -302,13 +330,14 @@ export async function runDaemon(): Promise<void> {
             visibleInSourceNow: false,
           },
           contextPayload: {
-            reminderId: reminder.id,
-            label: reminder.label,
-            message: reminder.message,
+            scheduleId: schedule.id,
+            label: schedule.label,
+            message: schedule.message,
           },
-          routingIntent: reminder.routingIntent,
-          routingHints: reminder.routingHints,
-          dedupeKey: `reminder:${reminder.id}`,
+          routingIntent: schedule.routingIntent,
+          routingHints: schedule.routingHints,
+          dedupeKey: `schedule:notify:${schedule.id}:${Date.now()}`,
+          throwOnError: true,
         });
       },
       (schedule) => {
@@ -381,7 +410,7 @@ export async function runDaemon(): Promise<void> {
     const hostname = getRuntimeHttpHost();
 
     // Mint a JWT bearer token for the pairing flow. This replaces the
-    // old static http-token that was removed — the pairing IPC handler
+    // old static http-token that was removed — the pairing handler
     // and HTTP auto-approve logic both guard on a non-empty bearer token.
     const pairingBearerToken = mintPairingBearerToken();
 
@@ -439,23 +468,7 @@ export async function runDaemon(): Promise<void> {
           undoLastMessage(sessionId, server.getHandlerContext()),
         regenerateResponse: (sessionId) => {
           let hubChain: Promise<void> = Promise.resolve();
-          const session = server
-            .getHandlerContext()
-            .sessions.get(sessionId);
           const sendEvent = (event: ServerMessage) => {
-            // Skip state-signal events only when the session has an
-            // onStateSignal listener wired (set in conversation-routes.ts),
-            // since that listener already publishes them to the hub.
-            // Without the listener (e.g. IPC-originated sessions regenerated
-            // via HTTP), we must let these events through to avoid silent loss.
-            if (
-              session?.hasStateSignalListener &&
-              "type" in event &&
-              (event.type === "assistant_activity_state" ||
-                event.type === "confirmation_state_changed")
-            ) {
-              return;
-            }
             const ae = buildAssistantEvent(
               DAEMON_INTERNAL_ASSISTANT_ID,
               event,
@@ -719,7 +732,6 @@ export async function runDaemon(): Promise<void> {
       runtimeHttp.setPairingBroadcast((msg) =>
         server.broadcast(msg as ServerMessage),
       );
-      initPairingHandlers(runtimeHttp.getPairingStore(), pairingBearerToken);
       initSlashPairingContext(runtimeHttp.getPairingStore());
       server.setHttpPort(httpPort);
       log.info(