@vellumai/assistant 0.5.5 → 0.5.6

package/Dockerfile

@@ -25,6 +25,9 @@ COPY packages/egress-proxy ./packages/egress-proxy
 COPY assistant/package.json assistant/bun.lock ./assistant/
 RUN cd /app/assistant && bun install --frozen-lockfile
 
+# Copy meta files needed by assistant (provider-env-vars.json)
+COPY meta/provider-env-vars.json ./meta/provider-env-vars.json
+
 # Copy source
 COPY assistant ./assistant
 
@@ -47,14 +50,10 @@ RUN apt-get update && apt-get install -y \
     g++ \
     git \
     sudo \
-    bubblewrap \
     htop \
     procps \
     && rm -rf /var/lib/apt/lists/*
 
-## Alias bwrap to bubblewrap
-RUN ln -sf /usr/bin/bwrap /usr/bin/bubblewrap
-
 # Copy bun binary from builder instead of re-installing
 COPY --from=builder /root/.bun/bin/bun /usr/local/bin/bun
 RUN ln -sf /usr/local/bin/bun /usr/local/bin/bunx

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.5.5",
+  "version": "0.5.6",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"

package/src/__tests__/actor-token-service.test.ts

@@ -57,6 +57,8 @@ import {
 } from "../runtime/actor-token-store.js";
 import { resetExternalAssistantIdCache } from "../runtime/auth/external-assistant-id.js";
 import {
+  BootstrapAlreadyCompleted,
+  fetchSigningKeyFromGateway,
   hashToken,
   initAuthSigningKey,
 } from "../runtime/auth/token-service.js";
@@ -729,3 +731,114 @@ describe("bootstrap private-network guard", () => {
     expect(res.status).toBe(200);
   });
 });
+
+// ---------------------------------------------------------------------------
+// fetchSigningKeyFromGateway
+// ---------------------------------------------------------------------------
+
+describe("fetchSigningKeyFromGateway", () => {
+  const VALID_HEX_KEY = "a".repeat(64); // 64 hex chars = 32 bytes
+  const originalEnv = process.env.GATEWAY_INTERNAL_URL;
+  const originalFetch = globalThis.fetch;
+
+  beforeEach(() => {
+    process.env.GATEWAY_INTERNAL_URL = "http://gateway:7822";
+  });
+
+  afterAll(() => {
+    if (originalEnv !== undefined) {
+      process.env.GATEWAY_INTERNAL_URL = originalEnv;
+    } else {
+      delete process.env.GATEWAY_INTERNAL_URL;
+    }
+    globalThis.fetch = originalFetch;
+  });
+
+  test("returns 32-byte buffer on successful 200 response", async () => {
+    globalThis.fetch = (async () =>
+      new Response(JSON.stringify({ key: VALID_HEX_KEY }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      })) as unknown as typeof fetch;
+
+    const key = await fetchSigningKeyFromGateway();
+    expect(key).toBeInstanceOf(Buffer);
+    expect(key.length).toBe(32);
+    expect(key.toString("hex")).toBe(VALID_HEX_KEY);
+  });
+
+  test("throws BootstrapAlreadyCompleted on 403 response", async () => {
+    globalThis.fetch = (async () =>
+      new Response("Forbidden", { status: 403 })) as unknown as typeof fetch;
+
+    await expect(fetchSigningKeyFromGateway()).rejects.toBeInstanceOf(
+      BootstrapAlreadyCompleted,
+    );
+  });
+
+  test("throws timeout error after max retry attempts on persistent failure", async () => {
+    // Mock Bun.sleep to avoid waiting 30s in tests
+    const origSleep = Bun.sleep;
+    Bun.sleep = (() => Promise.resolve()) as typeof Bun.sleep;
+
+    let callCount = 0;
+    globalThis.fetch = (async () => {
+      callCount++;
+      throw new Error("ECONNREFUSED");
+    }) as unknown as typeof fetch;
+
+    try {
+      await expect(fetchSigningKeyFromGateway()).rejects.toThrow(
+        "timed out waiting for gateway",
+      );
+      expect(callCount).toBe(30);
+    } finally {
+      Bun.sleep = origSleep;
+    }
+  });
+
+  test("throws when GATEWAY_INTERNAL_URL is not set", async () => {
+    delete process.env.GATEWAY_INTERNAL_URL;
+
+    await expect(fetchSigningKeyFromGateway()).rejects.toThrow(
+      "GATEWAY_INTERNAL_URL not set",
+    );
+  });
+
+  test("rejects invalid key length", async () => {
+    globalThis.fetch = (async () =>
+      new Response(JSON.stringify({ key: "aabb" }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      })) as unknown as typeof fetch;
+
+    await expect(fetchSigningKeyFromGateway()).rejects.toThrow(
+      "Invalid signing key length",
+    );
+  });
+
+  test("retries on non-200/non-403 status and eventually succeeds", async () => {
+    const origSleep = Bun.sleep;
+    Bun.sleep = (() => Promise.resolve()) as typeof Bun.sleep;
+
+    let callCount = 0;
+    globalThis.fetch = (async () => {
+      callCount++;
+      if (callCount < 3) {
+        return new Response("Service Unavailable", { status: 503 });
+      }
+      return new Response(JSON.stringify({ key: VALID_HEX_KEY }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }) as unknown as typeof fetch;
+
+    try {
+      const key = await fetchSigningKeyFromGateway();
+      expect(key.length).toBe(32);
+      expect(callCount).toBe(3);
+    } finally {
+      Bun.sleep = origSleep;
+    }
+  });
+});

package/src/__tests__/config-schema.test.ts

@@ -437,7 +437,7 @@ describe("AssistantConfigSchema", () => {
 
   test("defaults permissions.mode to workspace", () => {
     const result = AssistantConfigSchema.parse({});
-    expect(result.permissions).toEqual({ mode: "workspace" });
+    expect(result.permissions).toEqual({ mode: "workspace", dangerouslySkipPermissions: false });
   });
 
   test("accepts explicit permissions.mode strict", () => {
@@ -1139,7 +1139,7 @@ describe("loadConfig with schema validation", () => {
   test("defaults permissions.mode to workspace when not specified", () => {
     writeConfig({});
     const config = loadConfig();
-    expect(config.permissions).toEqual({ mode: "workspace" });
+    expect(config.permissions).toEqual({ mode: "workspace", dangerouslySkipPermissions: false });
   });
 
   test("loads explicit permissions.mode strict", () => {

package/src/__tests__/context-window-manager.test.ts

@@ -344,6 +344,84 @@ describe("ContextWindowManager", () => {
     expect(result.compactedPersistedMessages).toBe(4);
   });
 
+  test("adjusts keep boundary to preserve tool_use/tool_result pairs", async () => {
+    const provider = createProvider(() => ({
+      content: [{ type: "text", text: "## Goals\n- compacted summary" }],
+      model: "mock-model",
+      usage: { inputTokens: 75, outputTokens: 20 },
+      stopReason: "end_turn",
+    }));
+    // Configure budget so compaction keeps only the last user turn,
+    // which would normally split the tool pair because the last user
+    // turn start is a mixed message (tool_result + text) whose matching
+    // tool_use lives in the preceding assistant message.
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config: makeConfig({
+        maxInputTokens: 320,
+        targetBudgetRatio: 0.58,
+      }),
+    });
+    const long = "k".repeat(220);
+    const history: Message[] = [
+      message("user", `u1 ${long}`), // index 0: old user turn (long)
+      message("assistant", `a1 ${long}`), // index 1: assistant reply (long)
+      message("user", `u2 ${long}`), // index 2: second user turn (long)
+      {
+        // index 3: assistant with tool_use
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            id: "t1",
+            name: "read_file",
+            input: { path: "/tmp/a" },
+          },
+        ],
+      },
+      {
+        // index 4: user with tool_result AND text (mixed = user turn start)
+        // Without adjustForToolPairs, the raw boundary would land here,
+        // orphaning the tool_result from its tool_use at index 3.
+        role: "user",
+        content: [
+          { type: "tool_result", tool_use_id: "t1", content: "file contents" },
+          { type: "text", text: "thanks, now continue" },
+        ],
+      },
+    ];
+
+    const result = await manager.maybeCompact(history);
+    expect(result.compacted).toBe(true);
+    // The kept messages must include the tool_use assistant message (index 3)
+    // and tool_result user message (index 4) as a pair, not split them.
+    // Verify no orphaned tool_result blocks exist in the kept messages.
+    const keptMessages = result.messages;
+    for (let i = 0; i < keptMessages.length; i++) {
+      const msg = keptMessages[i];
+      if (msg.role !== "user") continue;
+      for (const block of msg.content) {
+        if (block.type === "tool_result") {
+          // Every tool_result must have a matching tool_use in a preceding assistant message
+          const toolUseId = (block as { tool_use_id: string }).tool_use_id;
+          const hasMatchingToolUse = keptMessages
+            .slice(0, i)
+            .some(
+              (prev) =>
+                prev.role === "assistant" &&
+                prev.content.some(
+                  (b) =>
+                    b.type === "tool_use" &&
+                    (b as { id: string }).id === toolUseId,
+                ),
+            );
+          expect(hasMatchingToolUse).toBe(true);
+        }
+      }
+    }
+  });
+
   test("counts mixed tool_result+text user messages as persisted", async () => {
     const provider = createProvider(() => ({
       content: [{ type: "text", text: "## Goals\n- mixed summary" }],

package/src/__tests__/conversation-title-service.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-const mockRunBtwSidechain = mock(async () => ({
+const mockRunBtwSidechain = mock(async (_params: Record<string, unknown>) => ({
   text: "Project kickoff",
   hadTextDeltas: true,
   response: {
@@ -93,6 +93,8 @@ describe("conversation-title-service", () => {
     expect(mockRunBtwSidechain).toHaveBeenCalledWith(
       expect.objectContaining({
         provider,
+        systemPrompt: expect.stringContaining("conversation titles"),
+        tools: [],
         maxTokens: 37,
         modelIntent: "latency-optimized",
         timeoutMs: 10_000,
@@ -123,6 +125,8 @@ describe("conversation-title-service", () => {
     expect(mockRunBtwSidechain).toHaveBeenCalledWith(
       expect.objectContaining({
         provider,
+        systemPrompt: expect.stringContaining("conversation titles"),
+        tools: [],
         maxTokens: 37,
         modelIntent: "latency-optimized",
         timeoutMs: 10_000,
@@ -134,4 +138,29 @@ describe("conversation-title-service", () => {
       1,
     );
   });
+
+  test("title prompt content does not contain generation instructions", async () => {
+    const provider = {
+      name: "test-provider",
+      sendMessage: mock(async () => {
+        throw new Error("provider.sendMessage should not be called directly");
+      }),
+    };
+
+    await generateAndPersistConversationTitle({
+      conversationId: "conv-1",
+      provider,
+      userMessage: "Help me plan the kickoff",
+    });
+
+    const call = mockRunBtwSidechain.mock.calls[0]![0] as {
+      content: string;
+      systemPrompt: string;
+    };
+    // Instructions should be in systemPrompt, not in content
+    expect(call.content).not.toContain("Generate a very short title");
+    expect(call.content).not.toContain("do NOT respond");
+    expect(call.systemPrompt).toContain("Do NOT respond");
+    expect(call.systemPrompt).toContain("Maximum 5 words");
+  });
 });

package/src/__tests__/docker-signing-key-bootstrap.test.ts

@@ -0,0 +1,207 @@
+/**
+ * Integration tests for resolveSigningKey() covering the Docker bootstrap
+ * lifecycle: fresh fetch from gateway, daemon restart (load from disk),
+ * and local mode (file-based load/create).
+ */
+
+import { mkdtempSync, readFileSync, realpathSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Temp directory for signing key persistence
+// ---------------------------------------------------------------------------
+
+const testDir = realpathSync(mkdtempSync(join(tmpdir(), "docker-signing-key-test-")));
+
+// ---------------------------------------------------------------------------
+// Mock platform to redirect signing key file to our temp directory
+// ---------------------------------------------------------------------------
+
+mock.module("../util/platform.js", () => ({
+  getRootDir: () => testDir,
+  getDataDir: () => testDir,
+  getDbPath: () => join(testDir, "test.db"),
+  normalizeAssistantId: (id: string) => (id === "self" ? "self" : id),
+  readLockfile: () => null,
+  writeLockfile: () => {},
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPidPath: () => join(testDir, "test.pid"),
+  getLogPath: () => join(testDir, "test.log"),
+  ensureDataDir: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// ---------------------------------------------------------------------------
+// Import the functions under test (after mocks are installed)
+// ---------------------------------------------------------------------------
+
+const {
+  resolveSigningKey,
+  loadOrCreateSigningKey: _loadOrCreateSigningKey,
+  BootstrapAlreadyCompleted: _BootstrapAlreadyCompleted,
+} = await import("../runtime/auth/token-service.js");
+
+// ---------------------------------------------------------------------------
+// Test constants
+// ---------------------------------------------------------------------------
+
+const VALID_32_BYTE_KEY = "ab".repeat(32); // 64 hex chars = 32 bytes
+const SIGNING_KEY_PATH = join(testDir, "protected", "actor-token-signing-key");
+
+// ---------------------------------------------------------------------------
+// Environment & fetch state management
+// ---------------------------------------------------------------------------
+
+const originalFetch = globalThis.fetch;
+const savedEnv: Record<string, string | undefined> = {};
+
+function saveEnv(...keys: string[]) {
+  for (const key of keys) {
+    savedEnv[key] = process.env[key];
+  }
+}
+
+function restoreEnv() {
+  for (const [key, val] of Object.entries(savedEnv)) {
+    if (val === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = val;
+    }
+  }
+}
+
+beforeEach(() => {
+  saveEnv("IS_CONTAINERIZED", "GATEWAY_INTERNAL_URL");
+});
+
+afterEach(() => {
+  globalThis.fetch = originalFetch;
+  restoreEnv();
+});
+
+afterAll(() => {
+  try {
+    rmSync(testDir, { recursive: true, force: true });
+  } catch {}
+});
+
+// ---------------------------------------------------------------------------
+// Docker mode tests — resolveSigningKey() bootstrap lifecycle
+// ---------------------------------------------------------------------------
+
+describe("resolveSigningKey — Docker bootstrap lifecycle", () => {
+  test("fresh bootstrap: fetches key from gateway and persists to disk", async () => {
+    process.env.IS_CONTAINERIZED = "true";
+    process.env.GATEWAY_INTERNAL_URL = "http://localhost:19876";
+
+    // Mock fetch to return a known 32-byte key on first call.
+    globalThis.fetch = (async () =>
+      new Response(JSON.stringify({ key: VALID_32_BYTE_KEY }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      })) as unknown as typeof fetch;
+
+    const key = await resolveSigningKey();
+
+    // Verify the returned key is a 32-byte buffer with the expected content.
+    expect(key).toBeInstanceOf(Buffer);
+    expect(key.length).toBe(32);
+    expect(key.toString("hex")).toBe(VALID_32_BYTE_KEY);
+
+    // Verify the key was persisted to disk.
+    const persisted = readFileSync(SIGNING_KEY_PATH);
+    expect(persisted.length).toBe(32);
+    expect(Buffer.from(persisted).equals(key)).toBe(true);
+  });
+
+  test("daemon restart: gateway returns 403, loads persisted key from disk", async () => {
+    process.env.IS_CONTAINERIZED = "true";
+    process.env.GATEWAY_INTERNAL_URL = "http://localhost:19876";
+
+    // The previous test persisted the key. Simulate a daemon restart where
+    // the gateway returns 403 (bootstrap already completed).
+    globalThis.fetch = (async () =>
+      new Response(JSON.stringify({ error: "Bootstrap already completed" }), {
+        status: 403,
+      })) as unknown as typeof fetch;
+
+    const key = await resolveSigningKey();
+
+    // Should have loaded the previously persisted key from disk.
+    expect(key).toBeInstanceOf(Buffer);
+    expect(key.length).toBe(32);
+    expect(key.toString("hex")).toBe(VALID_32_BYTE_KEY);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Local mode tests — resolveSigningKey() file-based path
+// ---------------------------------------------------------------------------
+
+describe("resolveSigningKey — local mode", () => {
+  test("uses file-based loadOrCreateSigningKey without calling fetch", async () => {
+    // Ensure Docker env vars are unset.
+    delete process.env.IS_CONTAINERIZED;
+    delete process.env.GATEWAY_INTERNAL_URL;
+
+    let fetchCalled = false;
+    globalThis.fetch = (async () => {
+      fetchCalled = true;
+      return new Response("should not be called", { status: 500 });
+    }) as unknown as typeof fetch;
+
+    const key = await resolveSigningKey();
+
+    // Should return a valid 32-byte key (loaded from disk or newly created).
+    expect(key).toBeInstanceOf(Buffer);
+    expect(key.length).toBe(32);
+
+    // Crucially, fetch should NOT have been called.
+    expect(fetchCalled).toBe(false);
+  });
+
+  test("IS_CONTAINERIZED=false does not trigger gateway fetch", async () => {
+    process.env.IS_CONTAINERIZED = "false";
+    process.env.GATEWAY_INTERNAL_URL = "http://localhost:19876";
+
+    let fetchCalled = false;
+    globalThis.fetch = (async () => {
+      fetchCalled = true;
+      return new Response("should not be called", { status: 500 });
+    }) as unknown as typeof fetch;
+
+    const key = await resolveSigningKey();
+
+    expect(key).toBeInstanceOf(Buffer);
+    expect(key.length).toBe(32);
+    expect(fetchCalled).toBe(false);
+  });
+
+  test("IS_CONTAINERIZED=true without GATEWAY_INTERNAL_URL uses local path", async () => {
+    process.env.IS_CONTAINERIZED = "true";
+    delete process.env.GATEWAY_INTERNAL_URL;
+
+    let fetchCalled = false;
+    globalThis.fetch = (async () => {
+      fetchCalled = true;
+      return new Response("should not be called", { status: 500 });
+    }) as unknown as typeof fetch;
+
+    const key = await resolveSigningKey();
+
+    expect(key).toBeInstanceOf(Buffer);
+    expect(key.length).toBe(32);
+    expect(fetchCalled).toBe(false);
+  });
+});

package/src/__tests__/memory-regressions.test.ts

@@ -540,23 +540,13 @@ describe("Memory regressions", () => {
 
   test("memory_save sets verificationState to user_confirmed", async () => {
     const { handleMemorySave } = await import("../tools/memory/handlers.js");
-    const legacyConfig = {
-      ...DEFAULT_CONFIG,
-      memory: {
-        ...DEFAULT_CONFIG.memory,
-        simplified: {
-          ...DEFAULT_CONFIG.memory.simplified,
-          enabled: false,
-        },
-      },
-    };
 
     const result = await handleMemorySave(
       {
         statement: "User explicitly saved this preference",
         kind: "preference",
       },
-      legacyConfig,
+      DEFAULT_CONFIG,
       "conv-verify-save",
       "msg-verify-save",
     );
@@ -573,23 +563,13 @@ describe("Memory regressions", () => {
 
   test("memory_save in different scopes creates separate items", async () => {
     const { handleMemorySave } = await import("../tools/memory/handlers.js");
-    const legacyConfig = {
-      ...DEFAULT_CONFIG,
-      memory: {
-        ...DEFAULT_CONFIG.memory,
-        simplified: {
-          ...DEFAULT_CONFIG.memory.simplified,
-          enabled: false,
-        },
-      },
-    };
 
     const sharedArgs = { statement: "I prefer dark mode", kind: "preference" };
 
     // Save in the default scope
     const r1 = await handleMemorySave(
       sharedArgs,
-      legacyConfig,
+      DEFAULT_CONFIG,
       "conv-scope-1",
       "msg-scope-1",
       "default",
@@ -600,7 +580,7 @@ describe("Memory regressions", () => {
     // Save the identical statement in a private scope
     const r2 = await handleMemorySave(
       sharedArgs,
-      legacyConfig,
+      DEFAULT_CONFIG,
       "conv-scope-2",
       "msg-scope-2",
       "private-abc",
@@ -624,7 +604,7 @@ describe("Memory regressions", () => {
     // Saving the same statement again in default scope should dedup (not create a third)
     const r3 = await handleMemorySave(
       sharedArgs,
-      legacyConfig,
+      DEFAULT_CONFIG,
       "conv-scope-3",
       "msg-scope-3",
       "default",
@@ -3227,9 +3207,8 @@ describe("Memory regressions", () => {
       .filter((j) => JSON.parse(j.payload).messageId === "msg-untrusted-gate");
     expect(extractJobs.length).toBe(0);
 
-    // enqueuedJobs reflects legacy embed_segment + archive embed_chunk per
-    // segment, plus the summary job, with extract_items gated off.
-    const expectedJobs = result.indexedSegments * 2 + 1;
+    // enqueuedJobs should reflect: embed jobs + summary (1), no extract (0)
+    const expectedJobs = result.indexedSegments + 1; // embed per segment + summary
     expect(result.enqueuedJobs).toBe(expectedJobs);
   });
 
@@ -3410,9 +3389,8 @@ describe("Memory regressions", () => {
       .filter((j) => JSON.parse(j.payload).messageId === "msg-unverified-gate");
     expect(extractJobs.length).toBe(0);
 
-    // enqueuedJobs reflects legacy embed_segment + archive embed_chunk per
-    // segment, plus the summary job, with extract_items gated off.
-    const expectedJobs = result.indexedSegments * 2 + 1;
+    // enqueuedJobs should reflect: embed jobs + summary (1), no extract (0)
+    const expectedJobs = result.indexedSegments + 1; // embed per segment + summary
     expect(result.enqueuedJobs).toBe(expectedJobs);
   });
 

package/src/__tests__/require-fresh-approval.test.ts

@@ -58,6 +58,10 @@ const mockConfig = {
     action: "warn" as const,
     entropyThreshold: 4.0,
   },
+  permissions: {
+    mode: "workspace" as const,
+    dangerouslySkipPermissions: false,
+  },
 };
 
 let fakeToolResult: ToolExecutionResult = { content: "ok", isError: false };

package/src/__tests__/tool-executor-lifecycle-events.test.ts

@@ -32,6 +32,10 @@ const mockConfig = {
     action: "warn" as const,
     entropyThreshold: 4.0,
   },
+  permissions: {
+    mode: "workspace" as const,
+    dangerouslySkipPermissions: false,
+  },
 };
 
 let checkerDecision: "allow" | "prompt" | "deny" = "allow";

package/src/__tests__/tool-executor.test.ts

@@ -50,6 +50,10 @@ const mockConfig = {
     action: "warn" as const,
     entropyThreshold: 4.0,
   },
+  permissions: {
+    mode: "workspace" as const,
+    dangerouslySkipPermissions: false,
+  },
 };
 
 let fakeToolResult: ToolExecutionResult = { content: "ok", isError: false };

package/src/cli/commands/conversations.ts

@@ -375,24 +375,6 @@ Examples:
           targetId: summaryId,
         });
       }
-      for (const obsId of result.deletedObservationIds) {
-        enqueueMemoryJob("delete_qdrant_vectors", {
-          targetType: "observation",
-          targetId: obsId,
-        });
-      }
-      for (const chunkId of result.deletedChunkIds) {
-        enqueueMemoryJob("delete_qdrant_vectors", {
-          targetType: "chunk",
-          targetId: chunkId,
-        });
-      }
-      for (const episodeId of result.deletedEpisodeIds) {
-        enqueueMemoryJob("delete_qdrant_vectors", {
-          targetType: "episode",
-          targetId: episodeId,
-        });
-      }
 
       log.info(
         `Wiped conversation "${conversation.title ?? "Untitled"}". ` +