@vellumai/assistant 0.10.7 → 0.10.8-dev.202607102228.5945895

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

@@ -1,4 +1,6 @@
+import { readdirSync, readFileSync, rmSync } from "node:fs";
 import { createRequire } from "node:module";
+import { join } from "node:path";
 import {
   afterAll,
   beforeEach,
@@ -15,11 +17,13 @@ import {
   resetConversationNoticesForTests,
 } from "../daemon/conversation-notices.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
+import { getConversationDirName } from "../persistence/conversation-directories.js";
 import type { UserPromptSubmitContext } from "../plugin-api/types.js";
 import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
 import { registerPlugin } from "../plugins/registry.js";
 import type { Message, Provider, ToolDefinition } from "../providers/types.js";
 import { ContextOverflowError } from "../providers/types.js";
+import { getWorkspaceDir } from "../util/platform.js";
 
 const conversationCrudRealSnapshot = {
   ...(createRequire(import.meta.url)(
@@ -32,7 +36,13 @@ const conversationDiskViewRealSnapshot = {
   ) as Record<string, unknown>),
 };
 let mockUiConfig: { userTimezone?: string; detectedTimezone?: string } = {};
-let mockLlmProfiles: Record<string, unknown> = {};
+// Disable the catalog default so resolution lands on llm.default.
+const disabledCatalogDefaultProfiles: Record<string, unknown> = {
+  balanced: { source: "managed", status: "disabled" },
+};
+let mockLlmProfiles: Record<string, unknown> = {
+  ...disabledCatalogDefaultProfiles,
+};
 let mockLlmActiveProfile: string | undefined;
 
 // ── Module mocks (must precede imports of the module under test) ─────
@@ -51,11 +61,6 @@ mock.module("../plugins/defaults/compaction/manager-store.js", () => ({
   },
 }));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
-
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     llm: {
@@ -83,7 +88,29 @@ mock.module("../config/loader.js", () => ({
         },
       },
       profiles: mockLlmProfiles,
-      callSites: {},
+      // The call-site tweak applies under BOTH resolution semantics (the
+      // legacy cascade layers it over llm.default; override-or-default
+      // applies it over the winner), so the small context window that the
+      // overflow/compaction tests depend on holds regardless of the
+      // override-or-default-resolution flag.
+      callSites: {
+        mainAgent: {
+          contextWindow: {
+            enabled: true,
+            maxInputTokens: 100000,
+            targetBudgetRatio: 0.3,
+            compactThreshold: 0.8,
+            summaryBudgetRatio: 0.05,
+            overflowRecovery: {
+              enabled: true,
+              safetyMarginRatio: 0.05,
+              maxAttempts: 3,
+              interactiveLatestTurnCompression: "summarize",
+              nonInteractiveLatestTurnCompression: "truncate",
+            },
+          },
+        },
+      },
       activeProfile: mockLlmActiveProfile,
       pricingOverrides: [],
     },
@@ -134,7 +161,9 @@ const runMockReducer = async (
   cfg: unknown,
   state: unknown,
 ) => {
-  if (mockReducerStepFn) return mockReducerStepFn(msgs, cfg, state);
+  if (mockReducerStepFn) {
+    return mockReducerStepFn(msgs, cfg, state);
+  }
   return {
     messages: msgs,
     tier: "forced_compaction",
@@ -181,7 +210,9 @@ function makeOverflowLadderStub(): {
 } {
   let state: unknown;
   const reduceOverflowOneRung = async (msgs: Message[], opts: unknown) => {
-    if (!state) state = makeInitialReducerState();
+    if (!state) {
+      state = makeInitialReducerState();
+    }
     const step = (await runMockReducer(msgs, opts, state)) as {
       state: unknown;
     };
@@ -266,6 +297,7 @@ const updateConversationSlackContextWatermarkMock = mock(
 );
 let mockConversationRow: Record<string, unknown> = {
   id: "conv-1",
+  createdAt: 1_700_000_000_000,
   contextSummary: null,
   contextCompactedMessageCount: 0,
   slackContextCompactionWatermarkTs: null,
@@ -275,12 +307,46 @@ let mockConversationRow: Record<string, unknown> = {
   title: null,
 };
 let mockMessageById: Record<string, unknown> | null = null;
+
+// The in-flight delta files the writers create for the (unmocked-path)
+// test conversation. Files are uuid-named at reserve time, so tests locate
+// them by listing the directory. Partial flushes land here instead of
+// `updateMessageContent`; the finalize seam folds the file inline and
+// deletes it, so mid-turn assertions read it during the provider's hold.
+function inflightDir(): string {
+  return join(
+    getWorkspaceDir(),
+    "conversations",
+    getConversationDirName("test-conv", 1_700_000_000_000),
+    "inflight",
+  );
+}
+
+function inflightDeltaFiles(): string[] {
+  try {
+    return readdirSync(inflightDir())
+      .filter((f) => f.endsWith(".jsonl"))
+      .map((f) => join(inflightDir(), f));
+  } catch {
+    return [];
+  }
+}
+
+/** The single in-flight delta file expected during a mid-hold read. */
+function soleInflightDeltaPath(): string {
+  const files = inflightDeltaFiles();
+  if (files.length !== 1) {
+    throw new Error(`expected exactly one in-flight file, saw ${files.length}`);
+  }
+  return files[0];
+}
 const deleteMessageByIdMock = mock(() => ({
   segmentIds: [],
   deletedSummaryIds: [],
 }));
 const reserveMessageMock = mock(async () => ({ id: "msg-reserve" }));
 const updateMessageContentMock = mock(() => {});
+const finalizeMessageContentMock = mock(() => {});
 const addMessageMock = mock(() => ({ id: "mock-msg-id" }));
 mock.module("../persistence/conversation-crud.js", () => ({
   setConversationProcessingStartedAt: () => {},
@@ -307,6 +373,7 @@ mock.module("../persistence/conversation-crud.js", () => ({
   getLastUserTimestampBefore: () => 0,
   reserveMessage: reserveMessageMock,
   updateMessageContent: updateMessageContentMock,
+  finalizeMessageContent: finalizeMessageContentMock,
   recordConversationPersistedSeq: () => {},
   getConversationPersistedSeq: () => null,
   // The real schema is a Zod object; tests don't exercise validation,
@@ -433,7 +500,9 @@ const getSlackCompactionWatermarkForPrefixMock = mock(
     context: typeof mockSlackChronologicalContext,
     compactedRenderedMessages: number,
   ) => {
-    if (!context || compactedRenderedMessages <= 0) return null;
+    if (!context || compactedRenderedMessages <= 0) {
+      return null;
+    }
     const start = context.compactableStartIndex;
     const end = Math.min(
       context.renderedMessages.length,
@@ -571,9 +640,15 @@ mock.module("../daemon/conversation-error.js", () => ({
   classifyConversationError: (_err: unknown, _ctx: unknown) =>
     mockConversationErrorClassification,
   isUserCancellation: (err: unknown, ctx: { aborted?: boolean }) => {
-    if (!ctx.aborted) return false;
-    if (err instanceof DOMException && err.name === "AbortError") return true;
-    if (err instanceof Error && err.name === "AbortError") return true;
+    if (!ctx.aborted) {
+      return false;
+    }
+    if (err instanceof DOMException && err.name === "AbortError") {
+      return true;
+    }
+    if (err instanceof Error && err.name === "AbortError") {
+      return true;
+    }
     return false;
   },
   buildConversationErrorMessage: (
@@ -715,8 +790,6 @@ function makeCtx(
       mockConversationRow?.lastNotifiedInferenceProfile ?? null,
     processingStartedAt: mockConversationRow?.processingStartedAt ?? null,
 
-    memoryPolicy: { scopeId: "default", includeDefaultFallback: true },
-
     currentActiveSurfaceId: undefined,
     currentPage: undefined,
     surfaceState: new Map(),
@@ -736,10 +809,6 @@ function makeCtx(
     skillProjectionCache:
       new Map() as unknown as Conversation["skillProjectionCache"],
 
-    profiler: {
-      startRequest: () => {},
-      emitSummary: () => {},
-    } as unknown as Conversation["profiler"],
     usageStats: {
       totalInputTokens: 0,
       totalOutputTokens: 0,
@@ -832,7 +901,7 @@ function makeCompactionResult(
 
 beforeEach(() => {
   mockUiConfig = {};
-  mockLlmProfiles = {};
+  mockLlmProfiles = { ...disabledCatalogDefaultProfiles };
   mockLlmActiveProfile = undefined;
   mockEstimateTokens = 1000;
   mockReducerStepFn = null;
@@ -852,6 +921,7 @@ beforeEach(() => {
   updateConversationSlackContextWatermarkMock.mockImplementation(() => {});
   mockConversationRow = {
     id: "conv-1",
+    createdAt: 1_700_000_000_000,
     contextSummary: null,
     contextCompactedMessageCount: 0,
     slackContextCompactionWatermarkTs: null,
@@ -875,6 +945,8 @@ beforeEach(() => {
   deleteMessageByIdMock.mockClear();
   reserveMessageMock.mockClear();
   updateMessageContentMock.mockClear();
+  finalizeMessageContentMock.mockClear();
+  rmSync(inflightDir(), { recursive: true, force: true });
   addMessageMock.mockClear();
   mockConversationErrorClassification = {
     code: "CONVERSATION_PROCESSING_FAILED",
@@ -1572,6 +1644,31 @@ describe("session-agent-loop", () => {
       expect(mainAgentCall?.[2]).toBe(3);
       expect(mainAgentCall?.[3]).toBe("gpt-4.1-2026-03-01");
     });
+
+    test("persists the served model onto the assistant row's metadata at finalize", async () => {
+      const events: ServerMessage[] = [];
+
+      const ctx = makeCtx({
+        providerResponses: [
+          {
+            content: [{ type: "text", text: "Hi there." }],
+            model: "gpt-4.1-2026-03-01",
+            usage: { inputTokens: 12, outputTokens: 3 },
+            stopReason: "end_turn",
+          },
+        ],
+      });
+
+      await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
+
+      // The finalize write carries the `message_complete` event's model
+      // (`response.model`) as metadata alongside the content, in one write.
+      const finalizeCall = finalizeMessageContentMock.mock.calls.find(
+        (call) => (call as unknown[])[2] !== undefined,
+      ) as unknown[] | undefined;
+      expect(finalizeCall).toBeDefined();
+      expect(finalizeCall?.[2]).toEqual({ model: "gpt-4.1-2026-03-01" });
+    });
   });
 
   describe("checkpoint handoff (infinite loop prevention)", () => {
@@ -2220,7 +2317,6 @@ describe("session-agent-loop", () => {
           role: string;
           content: string;
           createdAt: number;
-          scopeId: string;
         },
         unknown,
       ];
@@ -2230,7 +2326,6 @@ describe("session-agent-loop", () => {
         conversationId: "test-conv",
         role: "assistant",
         createdAt: 1234567,
-        scopeId: "default",
       });
       expect(indexCall.content).toContain("indexed reply");
 
@@ -2503,13 +2598,21 @@ describe("session-agent-loop", () => {
       // the 1024-char size gate) then holds the turn open past the 250ms
       // debounce window before completing, so a single debounced partial
       // flush lands before `message_complete`.
+      let midTurnDeltaLines: string[] | undefined;
       const ctx = makeCtx({
         loopProvider: {
           name: "mock-provider",
           async sendMessage(_messages, options) {
             options?.onEvent?.({ type: "text_delta", text: "Hello, " });
             options?.onEvent?.({ type: "text_delta", text: "world." });
-            await new Promise((resolve) => setTimeout(resolve, 1100));
+            // The debounced flush lands at PARTIAL_PERSIST_DEBOUNCE_MS
+            // (1000ms); read the delta file mid-hold (finalize deletes it
+            // at turn end).
+            await new Promise((resolve) => setTimeout(resolve, 1050));
+            midTurnDeltaLines = readFileSync(soleInflightDeltaPath(), "utf8")
+              .trim()
+              .split("\n");
+            await new Promise((resolve) => setTimeout(resolve, 100));
             return textResponse("Hello, world.");
           },
         },
@@ -2518,22 +2621,28 @@ describe("session-agent-loop", () => {
       // WHEN the orchestrator runs the turn to completion
       await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
 
-      // Exactly two `updateContent` calls land:
-      //   1. the debounced partial flush after both deltas accumulated, and
-      //   2. the final authoritative flush in `handleMessageComplete`.
-      // Without the debounce gate this would be one-per-delta + one final
-      // (3). Without the partial flush at all it would be just 1.
-      expect(updateMessageContentMock).toHaveBeenCalledTimes(2);
-      const calls = updateMessageContentMock.mock.calls as unknown as Array<
-        [string, string]
-      >;
-      const partialFlush = calls[0];
-      expect(partialFlush?.[0]).toBe("msg-reserve");
-      const partialBlocks = JSON.parse(partialFlush?.[1] ?? "[]") as Array<{
-        type: string;
-        text?: string;
-      }>;
-      expect(partialBlocks).toEqual([{ type: "text", text: "Hello, world." }]);
+      // Exactly one debounced partial flush landed, in the delta file:
+      // one flush of both accumulated deltas writes block 0 once — one
+      // JSONL line. Without the debounce gate each delta would flush
+      // separately (2 lines). The row itself sees no mid-stream write at
+      // all — it was born holding the `{ ref }` at reserve time.
+      expect(updateMessageContentMock).toHaveBeenCalledTimes(0);
+      expect(midTurnDeltaLines).toHaveLength(1);
+      const delta = JSON.parse(midTurnDeltaLines![0]) as {
+        block: { type: string; text?: string };
+      };
+      expect(delta.block).toEqual({ type: "text", text: "Hello, world." });
+      // The finalize seam folds the authoritative content inline and
+      // removes the delta file.
+      const finalize = finalizeMessageContentMock.mock.calls[0] as unknown as [
+        string,
+        string,
+      ];
+      expect(finalize[0]).toBe("msg-reserve");
+      expect(JSON.parse(finalize[1])).toEqual([
+        { type: "text", text: "Hello, world." },
+      ]);
+      expect(inflightDeltaFiles()).toHaveLength(0);
     });
 
     test("handleToolUse does NOT trigger a partial flush of its own", async () => {
@@ -2575,14 +2684,16 @@ describe("session-agent-loop", () => {
       // WHEN the orchestrator runs the turn to completion
       await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
 
-      // Four authoritative writes land and no stray partial flush:
-      //   - one final flush per `message_complete` (the tool turn and the final
+      // Three finalize writes land and no stray partial flush:
+      //   - one finalize per `message_complete` (the tool turn and the final
       //     text turn), plus
-      //   - two grouped tool-result user-row writes (persist-on-arrival and the
-      //     turn-boundary finalize).
-      // `handleToolUse` contributes no partial flush of its own; one would make
-      // this 5. That stray flush is the regression this test guards against.
-      expect(updateMessageContentMock).toHaveBeenCalledTimes(4);
+      //   - the grouped tool-result user-row's turn-boundary finalize.
+      // `handleToolUse` fires after `message_complete` removed the assistant
+      // writer, so a stray flush from it would fall back to
+      // `updateMessageContent` — the zero count is the regression guard.
+      expect(updateMessageContentMock).toHaveBeenCalledTimes(0);
+      expect(finalizeMessageContentMock).toHaveBeenCalledTimes(3);
+      expect(inflightDeltaFiles()).toHaveLength(0);
     });
 
     test("handleMessageComplete clears any pending debounce timer before the final flush", async () => {
@@ -2635,13 +2746,16 @@ describe("session-agent-loop", () => {
       // WHEN the orchestrator runs the turn to completion
       await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
 
-      // Four authoritative writes land: one final flush per `message_complete`
-      // (the tool turn and the final text turn) plus two grouped tool-result
-      // user-row writes (persist-on-arrival and the turn-boundary finalize).
-      // The debounced partial would have fired around T+250ms — during the tool
-      // executor's hold — but the timer-clear at the top of
-      // `handleMessageComplete` cancels it, so no stray fifth flush appears.
-      expect(updateMessageContentMock).toHaveBeenCalledTimes(4);
+      // Three finalize writes land: one per `message_complete` (the tool
+      // turn and the final text turn) plus the grouped tool-result row's
+      // turn-boundary finalize. The debounced partial would have fired
+      // during the tool executor's hold — after `message_complete` removed
+      // the assistant writer — so a stray late flush would fall back to
+      // `updateMessageContent`; the timer-clear at the top of
+      // `handleMessageComplete` is what keeps that count at zero.
+      expect(updateMessageContentMock).toHaveBeenCalledTimes(0);
+      expect(finalizeMessageContentMock).toHaveBeenCalledTimes(3);
+      expect(inflightDeltaFiles()).toHaveLength(0);
     });
 
     test("partial flushes never trigger the indexer or attention projector", async () => {
@@ -2707,12 +2821,15 @@ describe("session-agent-loop", () => {
       // GIVEN a real loop whose provider streams the PAT-bearing payload as a
       // delta then holds the turn open past the 250ms debounce window so the
       // partial flush lands before `message_complete`.
+      let midTurnDeltaFile: string | undefined;
       const ctx = makeCtx({
         loopProvider: {
           name: "mock-provider",
           async sendMessage(_messages, options) {
             options?.onEvent?.({ type: "text_delta", text: payload });
-            await new Promise((resolve) => setTimeout(resolve, 1100));
+            await new Promise((resolve) => setTimeout(resolve, 1050));
+            midTurnDeltaFile = readFileSync(soleInflightDeltaPath(), "utf8");
+            await new Promise((resolve) => setTimeout(resolve, 100));
             return textResponse(payload);
           },
         },
@@ -2721,14 +2838,16 @@ describe("session-agent-loop", () => {
       // WHEN the orchestrator runs the turn to completion
       await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
 
-      expect(updateMessageContentMock).toHaveBeenCalledTimes(2);
-      const partialPayload = (
-        updateMessageContentMock.mock.calls[0] as unknown as [string, string]
-      )[1];
-      // The raw PAT must never appear in the persisted snapshot. The
-      // redaction substitute is implementation-defined; the contract here
-      // is "the literal token string is gone".
-      expect(partialPayload).not.toContain(ghToken);
+      // The raw PAT must never appear in the persisted snapshot — neither
+      // in the in-flight delta file the partial flush wrote, nor in the
+      // finalized inline content. The redaction substitute is
+      // implementation-defined; the contract here is "the literal token
+      // string is gone".
+      expect(midTurnDeltaFile).toBeDefined();
+      expect(midTurnDeltaFile).not.toContain(ghToken);
+      const finalizeArgs = finalizeMessageContentMock.mock
+        .calls[0] as unknown as [string, string];
+      expect(finalizeArgs[1]).not.toContain(ghToken);
     });
 
     test("provider-error cleanup deletes a row that has accumulated partial content", async () => {
@@ -2759,16 +2878,19 @@ describe("session-agent-loop", () => {
       // WHEN the orchestrator runs the turn
       await runAgentLoopImpl(ctx, "hi", "msg-1", () => {});
 
-      // Partial flush fired exactly once (before the provider error).
+      // The partial flush landed in the orphan row's in-flight delta file
+      // exactly once (before the provider error) — the stranded fold skips
+      // the deleted row, so the file's single delta line is the evidence.
       // The orphan row was then deleted; the synthetic error message is
       // inserted separately via `addMessage` (`mock-msg-id`) and never
-      // touched by `updateContent`.
-      const partialFlushes = (
-        updateMessageContentMock.mock.calls as unknown as Array<
-          [string, string]
-        >
-      ).filter(([id]) => id === "msg-orphan-with-partial");
-      expect(partialFlushes).toHaveLength(1);
+      // touched by a content write.
+      const orphanFiles = inflightDeltaFiles();
+      expect(orphanFiles).toHaveLength(1);
+      const orphanLines = readFileSync(orphanFiles[0], "utf8")
+        .trim()
+        .split("\n");
+      expect(orphanLines).toHaveLength(1);
+      expect(updateMessageContentMock).toHaveBeenCalledTimes(0);
       expect(deleteMessageByIdMock).toHaveBeenCalledTimes(1);
       const deleteCall = deleteMessageByIdMock.mock.calls[0] as unknown as [
         string,

package/src/__tests__/conversation-app-control-instantiation.test.ts

@@ -43,15 +43,12 @@ import type { Tool } from "../tools/types.js";
 // Module mocks for the skill-projection layer
 // ---------------------------------------------------------------------------
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
-
 let appControlFlagEnabled = false;
 mock.module("../config/assistant-feature-flags.js", () => ({
   isAssistantFeatureFlagEnabled: (key: string) => {
-    if (key === "app-control") return appControlFlagEnabled;
+    if (key === "app-control") {
+      return appControlFlagEnabled;
+    }
     return true;
   },
   loadDefaultsRegistry: () => ({}),
@@ -143,7 +140,20 @@ mock.module("../tools/registry.js", () => ({
     let found: Tool | undefined;
     for (const tools of mockRegisteredTools.values()) {
       for (const tool of tools) {
-        if (tool.name === name) found = tool;
+        if (tool.name === name) {
+          found = tool;
+        }
+      }
+    }
+    return found;
+  },
+  resolveTool: (name: string) => {
+    let found: Tool | undefined;
+    for (const tools of mockRegisteredTools.values()) {
+      for (const tool of tools) {
+        if (tool.name === name) {
+          found = tool;
+        }
       }
     }
     return found;
@@ -158,7 +168,9 @@ mock.module("../tools/registry.js", () => ({
     let ownerSkillId: string | undefined;
     for (const [skillId, tools] of mockRegisteredTools.entries()) {
       for (const tool of tools) {
-        if (tool.name === name) ownerSkillId = skillId;
+        if (tool.name === name) {
+          ownerSkillId = skillId;
+        }
       }
     }
     return ownerSkillId === undefined

package/src/__tests__/conversation-app-control-lifecycle.test.ts

@@ -15,11 +15,6 @@
 
 import { describe, expect, mock, test } from "bun:test";
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
-
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
   initializeProviders: async () => {},
@@ -107,10 +102,6 @@ mock.module("../persistence/jobs-store.js", () => ({
   enqueueMemoryJob: () => {},
 }));
 
-mock.module("../runtime/services/auto-analysis-enqueue.js", () => ({
-  enqueueAutoAnalysisIfEnabled: () => {},
-}));
-
 mock.module("../runtime/services/auto-analysis-guard.js", () => ({
   isAutoAnalysisConversation: () => false,
 }));

package/src/__tests__/conversation-attachments.test.ts

@@ -1,13 +1,6 @@
 import { existsSync } from "node:fs";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
@@ -29,6 +22,7 @@ const checkSpy = mock(() => Promise.resolve({ decision: "allow" }));
 const addRuleSpy = mock(() => {});
 
 mock.module("../permissions/checker.js", () => ({
+  isDynamicSkillLoadInvocation: () => false,
   check: checkSpy,
   classifyRisk: () => Promise.resolve({ level: "low" }),
   generateAllowlistOptions: () => Promise.resolve([]),

package/src/__tests__/conversation-attention-store.test.ts

@@ -1,12 +1,4 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (value: string) => value,
-}));
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import { eq } from "drizzle-orm";
 

package/src/__tests__/conversation-attention-telegram.test.ts

@@ -14,14 +14,6 @@ mock.module("../daemon/conversation-store.js", () => ({
 // Test isolation: in-memory SQLite via temp directory
 // ---------------------------------------------------------------------------
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-  truncateForLog: (value: string) => value,
-}));
-
 // Mock render to return the raw content as text
 mock.module("../daemon/handlers/shared.js", () => ({
   renderHistoryContent: (content: unknown) => ({

package/src/__tests__/conversation-clear-safety.test.ts

@@ -11,13 +11,6 @@
 
 import { describe, expect, mock, test } from "bun:test";
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, {
-      get: () => () => {},
-    }),
-}));
-
 // Auth is NOT disabled — we need enforcePolicy to actually check scopes.
 let authDisabled = false;
 mock.module("../config/env.js", () => ({

package/src/__tests__/conversation-confirmation-signals.test.ts

@@ -20,27 +20,6 @@ import type { Message, ProviderResponse } from "../providers/types.js";
 // Mocks — must precede Conversation import
 // ---------------------------------------------------------------------------
 
-function makeLoggerStub(): Record<string, unknown> {
-  const stub: Record<string, unknown> = {};
-  for (const m of [
-    "info",
-    "warn",
-    "error",
-    "debug",
-    "trace",
-    "fatal",
-    "silent",
-    "child",
-  ]) {
-    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
-  }
-  return stub;
-}
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () => makeLoggerStub(),
-}));
-
 mock.module("../providers/registry.js", () => ({
   getProvider: () => ({ name: "mock-provider" }),
   initializeProviders: async () => {},

package/src/__tests__/conversation-crud-enabled-plugins.test.ts

@@ -1,10 +1,4 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import { makeMockLogger } from "./helpers/mock-logger.js";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import {
   addMessage,

package/src/__tests__/conversation-crud-inference-profile.test.ts

@@ -1,10 +1,4 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import { makeMockLogger } from "./helpers/mock-logger.js";
-
-mock.module("../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
+import { beforeEach, describe, expect, test } from "bun:test";
 
 import {
   createConversation,