@vellumai/assistant 0.11.7 → 0.11.8-staging.1

package/src/__tests__/attachments.test.ts

@@ -6,6 +6,92 @@ import {
   enrichMessageWithSourcePaths,
 } from "../agent/attachments.js";
 import { createUserMessage } from "../agent/message-types.js";
+import {
+  attachmentIdFragment,
+  mediaBlockAttachmentId,
+} from "../providers/types.js";
+
+// ---------------------------------------------------------------------------
+// attachmentIdFragment
+// ---------------------------------------------------------------------------
+
+describe("attachmentIdFragment", () => {
+  test("yields the property when an id is present", () => {
+    expect(attachmentIdFragment("att-1")).toEqual({ _attachmentId: "att-1" });
+  });
+
+  test("yields nothing for a missing or empty id", () => {
+    // Absent rather than present-and-empty: the read side requires a non-empty
+    // string before it treats the field as an id.
+    expect(attachmentIdFragment(undefined)).toEqual({});
+    expect(attachmentIdFragment("")).toEqual({});
+    expect("_attachmentId" in attachmentIdFragment("")).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// mediaBlockAttachmentId
+// ---------------------------------------------------------------------------
+
+describe("mediaBlockAttachmentId", () => {
+  test("reads a reference's id off its source", () => {
+    expect(
+      mediaBlockAttachmentId({
+        type: "image",
+        source: {
+          type: "workspace_ref",
+          media_type: "image/png",
+          attachmentId: "att-ref",
+          sizeBytes: 10,
+        },
+      }),
+    ).toBe("att-ref");
+  });
+
+  test("reads an inline block's id off the top-level field", () => {
+    expect(
+      mediaBlockAttachmentId({
+        type: "image",
+        source: { type: "base64", media_type: "image/png", data: "AAAA" },
+        _attachmentId: "att-inline",
+      }),
+    ).toBe("att-inline");
+  });
+
+  test("is undefined for a block that came from no attachment", () => {
+    expect(
+      mediaBlockAttachmentId({
+        type: "image",
+        source: { type: "base64", media_type: "image/png", data: "AAAA" },
+      }),
+    ).toBeUndefined();
+  });
+
+  test("covers file blocks in both shapes", () => {
+    expect(
+      mediaBlockAttachmentId({
+        type: "file",
+        source: {
+          type: "workspace_ref",
+          media_type: "application/pdf",
+          attachmentId: "att-file-ref",
+          sizeBytes: 10,
+        },
+      }),
+    ).toBe("att-file-ref");
+    expect(
+      mediaBlockAttachmentId({
+        type: "file",
+        source: {
+          type: "base64",
+          media_type: "application/pdf",
+          data: "AAAA",
+        },
+        _attachmentId: "att-file-inline",
+      }),
+    ).toBe("att-file-inline");
+  });
+});
 
 // ---------------------------------------------------------------------------
 // attachmentsToReferenceBlocks
@@ -152,6 +238,42 @@ describe("attachmentsToContentBlocks", () => {
     const blocks = await attachmentsToContentBlocks([]);
     expect(blocks).toHaveLength(0);
   });
+
+  test("stamps the attachment id on image and file blocks alike", async () => {
+    const blocks = await attachmentsToContentBlocks([
+      {
+        id: "att-img",
+        filename: "photo.jpg",
+        mimeType: "image/jpeg",
+        data: "imgdata",
+      },
+      {
+        id: "att-doc",
+        filename: "doc.pdf",
+        mimeType: "application/pdf",
+        data: "pdfdata",
+      },
+    ]);
+
+    expect(blocks[0].type).toBe("image");
+    expect((blocks[0] as { _attachmentId?: string })._attachmentId).toBe(
+      "att-img",
+    );
+    expect(blocks[1].type).toBe("file");
+    expect((blocks[1] as { _attachmentId?: string })._attachmentId).toBe(
+      "att-doc",
+    );
+  });
+
+  test("omits the attachment id when the upload has none", async () => {
+    const blocks = await attachmentsToContentBlocks([
+      { filename: "photo.jpg", mimeType: "image/jpeg", data: "imgdata" },
+      { filename: "doc.pdf", mimeType: "application/pdf", data: "pdfdata" },
+    ]);
+
+    expect("_attachmentId" in blocks[0]).toBe(false);
+    expect("_attachmentId" in blocks[1]).toBe(false);
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/bundled-asset.test.ts

@@ -3,7 +3,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import { resolveBundledDir } from "../util/bundled-asset.js";
+import { isBunVirtualPath, resolveBundledDir } from "../util/bundled-asset.js";
 
 let tempDir: string;
 
@@ -17,6 +17,13 @@ afterEach(() => {
 });
 
 describe("resolveBundledDir", () => {
+  test("recognizes Bun virtual paths on Unix and Windows", () => {
+    expect(isBunVirtualPath("/$bunfs/root/src/config")).toBeTrue();
+    expect(isBunVirtualPath("B:\\~BUN\\root")).toBeTrue();
+    expect(isBunVirtualPath("B:/~BUN/root/src/config")).toBeTrue();
+    expect(isBunVirtualPath("C:\\dev\\vellum-assistant")).toBeFalse();
+  });
+
   test("source mode: returns join(callerDir, relativePath) when callerDir is a normal path", () => {
     const result = resolveBundledDir(
       "/some/source/path",
@@ -82,6 +89,20 @@ describe("resolveBundledDir", () => {
       expect(result).toBe(join(binDir, "templates"));
     });
 
+    test("resolves Windows Bun virtual paths beside the executable", () => {
+      const binDir = join(tempDir, "bin");
+      mkdirSync(join(binDir, "default-plugins"), { recursive: true });
+
+      process.execPath = join(binDir, "vellum-daemon.exe");
+
+      const result = resolveBundledDir(
+        "B:\\~BUN\\root",
+        ".",
+        "default-plugins",
+      );
+      expect(result).toBe(join(binDir, "default-plugins"));
+    });
+
     test("falls back to source path when neither Resources nor execDir have the asset", () => {
       const binDir = join(tempDir, "bin");
       mkdirSync(binDir, { recursive: true });

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

@@ -16,7 +16,7 @@ describe("parseCallbackData", () => {
     expect(result).not.toBeNull();
     expect(result!.action).toBe(expectedAction);
     expect(result!.requestId).toBe("req-123");
-    expect(result!.source).toBe("telegram_button");
+    expect(result!.source).toBe("button");
   });
 
   test.each<[string, string]>([
@@ -33,12 +33,19 @@ describe("parseCallbackData", () => {
     },
   );
 
-  test("parses slack source channel", () => {
-    const result = parseCallbackData("apr:req-789:approve_once", "slack");
-    expect(result).not.toBeNull();
-    expect(result!.action).toBe("approve_once");
-    expect(result!.requestId).toBe("req-789");
-    expect(result!.source).toBe("slack_button");
+  test("every channel's button press attributes as the button modality", () => {
+    for (const channel of ["slack", "telegram", "whatsapp", "discord"]) {
+      const result = parseCallbackData("apr:req-789:approve_once", channel);
+      expect(result).not.toBeNull();
+      expect(result!.action).toBe("approve_once");
+      expect(result!.requestId).toBe("req-789");
+      expect(result!.source).toBe("button");
+    }
+  });
+
+  test("an in-app surface press attributes as vellum_surface", () => {
+    const result = parseCallbackData("apr:req-789:approve_once", "vellum");
+    expect(result!.source).toBe("vellum_surface");
   });
 
   test("returns null for unknown action", () => {

package/src/__tests__/channel-approvals.test.ts

@@ -241,7 +241,7 @@ describe("handleChannelDecision", () => {
     const mockConv = conversationMocks.get("conv-1") as Conversation;
     const decision: ApprovalDecisionResult = {
       action: "reject",
-      source: "telegram_button",
+      source: "button",
     };
 
     const result = handleChannelDecision("conv-1", decision);
@@ -261,7 +261,7 @@ describe("handleChannelDecision", () => {
     const newerMock = conversationMocks.get("conv-1") as Conversation;
     const decision: ApprovalDecisionResult = {
       action: "approve_once",
-      source: "telegram_button",
+      source: "button",
       requestId: "req-newer",
     };
 
@@ -280,7 +280,7 @@ describe("handleChannelDecision", () => {
     registerPendingConfirmation("req-1", "conv-1", "shell");
     const decision: ApprovalDecisionResult = {
       action: "approve_once",
-      source: "telegram_button",
+      source: "button",
       requestId: "req-missing",
     };
 

package/src/__tests__/channel-delivery-store.test.ts

@@ -10,6 +10,7 @@ import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import {
   clearPayload,
+  findConversationByProviderMessageId,
   findMessageBySourceId,
   linkMessage,
   recordInbound,
@@ -122,6 +123,63 @@ describe("channel-delivery-store", () => {
     expect(row!.sourceMessageId).toBe("src-42");
   });
 
+  test("resolves an assistant post by its provider id on a non-Slack channel", () => {
+    const chatId = "999000111222333444";
+    const minted = recordInbound("discord", chatId, "evt-seed");
+    const db = getDb();
+    db.insert(messages)
+      .values({
+        id: "assistant-post-1",
+        conversationId: minted.conversationId,
+        role: "assistant",
+        content: "outbound reply",
+        createdAt: Date.now(),
+        metadata: JSON.stringify({
+          providerMeta: JSON.stringify({
+            source: "discord",
+            conversationExternalId: chatId,
+            messageId: "1234567890123456789",
+            additionalMessageIds: ["2234567890123456789"],
+            eventKind: "message",
+          }),
+        }),
+      })
+      .run();
+
+    expect(
+      findConversationByProviderMessageId(
+        "discord",
+        chatId,
+        "1234567890123456789",
+      ),
+    ).toBe(minted.conversationId);
+    // A split reply posts several provider messages from one row; any of
+    // their ids resolves it.
+    expect(
+      findConversationByProviderMessageId(
+        "discord",
+        chatId,
+        "2234567890123456789",
+      ),
+    ).toBe(minted.conversationId);
+    // The scan is scoped to the reaction's own channel address: the same id
+    // is invisible from another channel's or another chat's key space.
+    expect(
+      findConversationByProviderMessageId(
+        "telegram",
+        chatId,
+        "1234567890123456789",
+      ),
+    ).toBeNull();
+    expect(
+      findConversationByProviderMessageId(
+        "discord",
+        "other-chat",
+        "1234567890123456789",
+      ),
+    ).toBeNull();
+  });
+
   test("same chat on same channel reuses the same conversation", () => {
     const r1 = recordInbound("telegram", "chat-1", "msg-1");
     const r2 = recordInbound("telegram", "chat-1", "msg-2");

package/src/__tests__/channel-inbound-disk-pressure.test.ts

@@ -243,6 +243,7 @@ describe("channel inbound disk pressure gate", () => {
         content: "reaction:thumbsup",
         actorExternalId: "slack-user-1",
         callbackData: "reaction:thumbsup",
+        sourceMetadata: { messageId: "1700000000.1" },
         replyCallbackUrl: "https://gateway.test/deliver/slack",
       }),
     );

package/src/__tests__/channel-invite-transport.test.ts

@@ -109,6 +109,7 @@ describe("resolveAdapterHandle", () => {
 
 describe("createInviteAdapterRegistry", () => {
   const builtInChannels = [
+    "discord",
     "email",
     "slack",
     "telegram",

package/src/__tests__/channel-readiness-slack-remote.test.ts

@@ -174,9 +174,9 @@ describe("slack remote probe (auth.test)", () => {
 
 /**
  * Slack can install an app with a fraction of the manifest's scopes while
- * auth.test still succeeds — a live install produced 2 of 18, and the first
- * real API call failed with missing_scope. auth.test passing is therefore not
- * evidence the install is usable.
+ * auth.test still succeeds, leaving the first real API call to fail with
+ * missing_scope. auth.test passing is therefore not evidence the install is
+ * usable.
  */
 describe("slack auth.test response validation", () => {
   test("reports an unexpected shape instead of trusting the field types", async () => {

package/src/__tests__/compaction-events.test.ts

@@ -123,18 +123,6 @@ mock.module("../persistence/attachments-store.js", () => ({
   linkAttachmentToMessage: () => {},
 }));
 
-mock.module("../memory/retriever.js", () => ({
-  buildMemoryRecall: async () => ({
-    enabled: false,
-    degraded: false,
-    injectedText: "",
-    semanticHits: 0,
-    injectedTokens: 0,
-    latencyMs: 0,
-  }),
-  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
-}));
-
 // Per-test compaction result — set before calling forceCompact().
 let mockCompactResult: ContextWindowResult = {
   messages: [],

package/src/__tests__/compactor-call-site-logging.test.ts

@@ -149,10 +149,12 @@ describe("compactor records llm_request_logs with call_site=compactionAgent", ()
   });
 
   test("successful compaction call stamps call_site = compactionAgent", async () => {
-    await runAssistantDrivenCompaction(args(makeProvider()));
+    const result = await runAssistantDrivenCompaction(args(makeProvider()));
 
     expect(recordRequestLogCalls.length).toBe(1);
     expect(recordRequestLogCalls[0]!.callSite).toBe("compactionAgent");
+    expect(result.summaryCallSite).toBe("compactionAgent");
+    expect(result.summaryResolutionCallSite).toBe("mainAgent");
     expect(recordRequestLogCalls[0]!.conversationId).toBe(
       "conv-compaction-log-1",
     );
@@ -228,6 +230,10 @@ describe("compaction result reports what actually served the summary", () => {
     expect(result.summaryActualInferenceProfile).toBe("backupProfile");
     // The primary's resolution is still reported, just outranked downstream.
     expect(result.summaryOverrideProfile).toBe("primaryProfile");
+    // Request log and usage attribution share the observability call site.
+    expect(result.summaryCallSite).toBe("compactionAgent");
+    expect(result.summaryResolutionCallSite).toBe("mainAgent");
+    expect(recordRequestLogCalls[0]!.callSite).toBe("compactionAgent");
     // Same value the request log recorded: one source of truth, not two.
     expect(recordRequestLogCalls[0]!.provider).toBe("anthropic");
   });

package/src/__tests__/compactor-retained-image-validation.test.ts

@@ -125,6 +125,21 @@ describe("buildRetainedImageBlocks corrupt-bytes gate", () => {
     expect(blocks).toHaveLength(0);
   });
 
+  test("a retained block carries the attachment id it rehydrated from", async () => {
+    // The rebuilt block is inline bytes, so this id is the only handle left on
+    // the row it came from. Camera-frame retention matches on it: without it a
+    // frame compaction chose to keep would be invisible to every later pass.
+    const conv = createConversation();
+    await addImageMessage(conv.id, "good.png", PNG_1X1_BASE64);
+    const manifest = collectImageManifest(conv.id, "guardian");
+
+    const { blocks } = await buildRetainedImageBlocks(["good.png"], manifest);
+
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0]._attachmentId).toBe(manifest[0].attachmentId);
+    expect(blocks[0]._attachmentId).toBeTruthy();
+  });
+
   test("unresolvable filenames still land in missing", async () => {
     const conv = createConversation();
     await addImageMessage(conv.id, "good.png", PNG_1X1_BASE64);

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

@@ -811,6 +811,40 @@ describe("AssistantConfigSchema", () => {
     expect(result.success).toBe(false);
   });
 
+  test("applies sight defaults", () => {
+    expect(AssistantConfigSchema.parse({}).sight).toEqual({
+      keepLatestFrames: 2,
+    });
+  });
+
+  test("accepts a custom sight.keepLatestFrames", () => {
+    const result = AssistantConfigSchema.parse({
+      sight: { keepLatestFrames: 4 },
+    });
+    expect(result.sight.keepLatestFrames).toBe(4);
+  });
+
+  test("keeps an out-of-range sight.keepLatestFrames for the reader to clamp", () => {
+    // Rejecting it would reset the key to the default, which is fewer frames
+    // than either the config or the guardrail asked for. The clamp lives at
+    // read (`resolveSightKeepLatestFrames`).
+    const result = AssistantConfigSchema.parse({
+      sight: { keepLatestFrames: 99 },
+    });
+    expect(result.sight.keepLatestFrames).toBe(99);
+  });
+
+  test("rejects a non-integer sight.keepLatestFrames", () => {
+    expect(
+      AssistantConfigSchema.safeParse({ sight: { keepLatestFrames: 2.5 } })
+        .success,
+    ).toBe(false);
+    expect(
+      AssistantConfigSchema.safeParse({ sight: { keepLatestFrames: "two" } })
+        .success,
+    ).toBe(false);
+  });
+
   // ── commitMessageLLM config ──────────────────────────────────────────
 
   test("default commitMessageLLM values are correct", () => {
@@ -937,6 +971,7 @@ describe("AssistantConfigSchema", () => {
       mode: "open-mic",
       vad: {
         speechEnergyThreshold: 800,
+        noiseFloorMargin: 3,
         silenceThresholdMs: 1200,
         maxTurnDurationMs: 30000,
         bargeInMinSpeechMs: 250,

package/src/__tests__/contacts-write.test.ts

@@ -39,6 +39,24 @@ function channelCount(type: string, address: string): number {
   return row.n;
 }
 
+function contactExists(contactId: string): boolean {
+  // bun:sqlite .get() returns null (not undefined) when no row matches.
+  const row = getSqlite()
+    .query("SELECT 1 AS one FROM contacts WHERE id = ?")
+    .get(contactId) as { one: number } | null;
+  return row !== null;
+}
+
+/** Contacts parenting zero channels: the guardian-duplicate shape. */
+function channelLessContactCount(): number {
+  const row = getSqlite()
+    .query(
+      "SELECT COUNT(*) AS n FROM contacts c WHERE NOT EXISTS (SELECT 1 FROM contact_channels ch WHERE ch.contact_id = c.id)",
+    )
+    .get() as { n: number };
+  return row.n;
+}
+
 function workspaceDir(): string {
   const dir = process.env.VELLUM_WORKSPACE_DIR;
   if (!dir) {
@@ -112,6 +130,34 @@ describe("identity-mirror faithful-replica semantics", () => {
     expect(result?.contact.userFile).toBeNull();
   });
 
+  test("an op carrying the gateway channel id adopts it onto a divergent legacy row", () => {
+    upsertContactChannel({
+      sourceChannel: "slack",
+      externalUserId: "UADOPTID",
+      displayName: "Alice",
+      contactId: "co-adopt-id",
+      channelId: "legacy-ch",
+      refreshDisplayName: true,
+      userFileOnCreate: null,
+    });
+
+    // The gateway's row for the same identity lives under a different UUID;
+    // the mirror adopts it so both stores key the channel identically.
+    upsertContactChannel({
+      sourceChannel: "slack",
+      externalUserId: "UADOPTID",
+      displayName: "Alice",
+      contactId: "co-adopt-id",
+      channelId: "gw-ch-aligned",
+      refreshDisplayName: true,
+      userFileOnCreate: null,
+    });
+
+    expect(channelOwnerById("gw-ch-aligned")).toBe("co-adopt-id");
+    expect(channelOwnerById("legacy-ch")).toBeUndefined();
+    expect(channelCount("slack", "UADOPTID")).toBe(1);
+  });
+
   test("Finding B: an explicit (gateway-minted) channel id is reused verbatim", () => {
     const result = upsertContactChannel({
       sourceChannel: "slack",
@@ -215,10 +261,102 @@ describe("mirror channel-reparenting race semantics", () => {
       reassignConflictingChannels: false,
     });
 
-    // Original channel stays under contact #1; no duplicate channel was created.
-    expect(channelOwnerById("gw-ch-race-1")).toBe("co-race-1");
-    expect(channelOwnerById("gw-ch-race-2")).toBeUndefined();
+    // Ownership never moves without reassign and no duplicate channel is
+    // created; the row's id follows the latest gateway-sourced op (id
+    // adoption), which is what keeps the two stores' keys aligned.
+    expect(channelOwnerById("gw-ch-race-2")).toBe("co-race-1");
+    expect(channelOwnerById("gw-ch-race-1")).toBeUndefined();
     expect(channelCount("slack", "URACE")).toBe(1);
+    // The losing seed adopts contact #1 rather than minting a channel-less
+    // contact under its own id.
+    expect(contactExists("co-race-2")).toBe(false);
+    expect(channelLessContactCount()).toBe(0);
+  });
+
+  test("adoption and re-seen seeds never clobber curated record fields", () => {
+    // First-seen bot sender: classification and notes land on CREATE.
+    const created = upsertContactChannel({
+      sourceChannel: "slack",
+      externalUserId: "UCURATED",
+      externalChatId: "DCURATED",
+      displayName: "Peer Assistant",
+      contactId: "co-curated",
+      channelId: "gw-ch-curated",
+      contactType: "assistant",
+      notes: "Automated Slack bot",
+      refreshDisplayName: true,
+      userFileOnCreate: null,
+      reassignConflictingChannels: false,
+    });
+    expect(created?.contact.contactType).toBe("assistant");
+    expect(created?.contact.notes).toBe("Automated Slack bot");
+
+    // A later seed for the same identity (mirror row present) carries record
+    // fields for gap recovery, but they are create-only: the stored
+    // classification and notes stand.
+    const reseen = upsertContactChannel({
+      sourceChannel: "slack",
+      externalUserId: "UCURATED",
+      contactId: "co-curated",
+      displayName: "Peer Assistant",
+      contactType: "human",
+      notes: "seed-refresh notes that must not land",
+      refreshDisplayName: true,
+      userFileOnCreate: null,
+      reassignConflictingChannels: false,
+    });
+    expect(reseen?.contact.contactType).toBe("assistant");
+    expect(reseen?.contact.notes).toBe("Automated Slack bot");
+
+    // Adoption (a create-shaped op under a foreign id for the same identity)
+    // is equally forbidden from touching the adopted contact's record fields.
+    const adopted = upsertContactChannel({
+      sourceChannel: "slack",
+      externalUserId: "UCURATED",
+      contactId: "co-curated-foreign",
+      displayName: "Peer Assistant",
+      contactType: "human",
+      notes: "adoption notes that must not land",
+      refreshDisplayName: true,
+      userFileOnCreate: null,
+      reassignConflictingChannels: false,
+    });
+    expect(adopted?.contact.id).toBe("co-curated");
+    expect(adopted?.contact.contactType).toBe("assistant");
+    expect(adopted?.contact.notes).toBe("Automated Slack bot");
+    expect(contactExists("co-curated-foreign")).toBe(false);
+  });
+
+  test("explicit-id create over a conflicting channel adopts the owner instead of minting an empty contact", () => {
+    upsertContactChannel({
+      sourceChannel: "slack",
+      externalUserId: "UADOPT",
+      externalChatId: "DADOPT",
+      displayName: "Owner",
+      contactId: "co-adopt-owner",
+      channelId: "gw-ch-adopt",
+      refreshDisplayName: true,
+      userFileOnCreate: null,
+      reassignConflictingChannels: false,
+    });
+
+    // A divergence-shaped write: the gateway hands down a contact id the
+    // mirror has never seen, for an identity the mirror already parents.
+    const result = upsertContactChannel({
+      sourceChannel: "slack",
+      externalUserId: "UADOPT",
+      displayName: "Owner Renamed",
+      contactId: "co-adopt-foreign",
+      refreshDisplayName: true,
+      userFileOnCreate: null,
+      reassignConflictingChannels: false,
+    });
+
+    expect(result?.contact.id).toBe("co-adopt-owner");
+    expect(result?.contact.displayName).toBe("Owner Renamed");
+    expect(channelOwnerById("gw-ch-adopt")).toBe("co-adopt-owner");
+    expect(contactExists("co-adopt-foreign")).toBe(false);
+    expect(channelLessContactCount()).toBe(0);
   });
 
   test("INVITE-binding path (reassignConflictingChannels:true) DOES reparent", () => {

package/src/__tests__/conversation-abort-tool-results.test.ts

@@ -83,19 +83,6 @@ mock.module("../persistence/conversation-queries.js", () => ({
   listConversations: () => [],
 }));
 
-mock.module("../memory/retriever.js", () => ({
-  buildMemoryRecall: async () => ({
-    enabled: false,
-    degraded: false,
-    injectedText: "",
-
-    semanticHits: 0,
-    injectedTokens: 0,
-    latencyMs: 0,
-  }),
-  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
-}));
-
 mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
     estimateInputTokens() {

package/src/__tests__/conversation-agent-loop-inference-profile.test.ts

@@ -165,18 +165,6 @@ mock.module("../persistence/conversation-disk-view.js", () => ({
   rebuildConversationDiskViewFromDbState: () => {},
 }));
 
-mock.module("../memory/retriever.js", () => ({
-  buildMemoryRecall: async () => ({
-    enabled: false,
-    degraded: false,
-    injectedText: "",
-    semanticHits: 0,
-    injectedTokens: 0,
-    latencyMs: 0,
-  }),
-  injectMemoryRecallAsUserBlock: (msgs: Message[]) => msgs,
-}));
-
 mock.module("../apps/app-store.js", () => ({
   getApp: () => null,
   listAppFiles: () => [],