@vellumai/assistant 0.10.8 → 0.10.9-dev.202607152225.ec6fdbf

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,14 @@ 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";
+import { setConfig } from "./helpers/set-config.js";
 
 const conversationCrudRealSnapshot = {
   ...(createRequire(import.meta.url)(
@@ -31,48 +36,25 @@ const conversationDiskViewRealSnapshot = {
     "../persistence/conversation-disk-view.js",
   ) as Record<string, unknown>),
 };
-let mockUiConfig: { userTimezone?: string; detectedTimezone?: string } = {};
 // 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) ─────
-
-// The real AgentLoop resolves the per-conversation ContextWindowManager from
-// the compaction store keyed by conversationId. These orchestrator tests build
-// fake conversations whose manager is a canned stub, so register each stub in a
-// map the mocked store reads from.
-const fakeContextWindowManagers = new Map<string, unknown>();
-mock.module("../plugins/defaults/compaction/manager-store.js", () => ({
-  createContextWindowManager: () => undefined,
-  getContextWindowManager: (conversationId: string) =>
-    fakeContextWindowManagers.get(conversationId),
-  disposeContextWindowManager: (conversationId: string) => {
-    fakeContextWindowManagers.delete(conversationId);
-  },
-}));
 
-mock.module("../util/logger.js", () => ({
-  getLogger: () =>
-    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
-}));
-
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    llm: {
-      default: {
-        provider: "mock-provider",
-        model: "mock-model",
-        maxTokens: 4096,
-        effort: "max" as const,
-        speed: "standard" as const,
-        temperature: null,
-        thinking: { enabled: false, streamThinking: true },
+/**
+ * Seed the workspace `llm` config for real. `setConfig` replaces the top-level
+ * key wholesale, so every call carries the mainAgent call-site tweak — it
+ * applies over the winning profile, so the small context window that the
+ * overflow/compaction tests depend on holds regardless of which profile wins
+ * selection.
+ */
+function seedLlmConfig(options?: {
+  profiles?: Record<string, unknown>;
+  activeProfile?: string;
+}): void {
+  setConfig("llm", {
+    callSites: {
+      mainAgent: {
         contextWindow: {
           enabled: true,
           maxInputTokens: 100000,
@@ -88,45 +70,35 @@ mock.module("../config/loader.js", () => ({
           },
         },
       },
-      profiles: mockLlmProfiles,
-      // 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: [],
     },
-    rateLimit: { maxRequestsPerMinute: 0 },
-    workspaceGit: { turnCommitMaxWaitMs: 10 },
-    memory: { retrieval: { scratchpadInjection: { enabled: true } } },
-    ui: mockUiConfig,
-    compaction: { enabled: true, autoThreshold: 0.7 },
-    conversations: { skipAutoRetitling: true },
-  }),
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  invalidateConfigCache: () => {},
+    profiles: options?.profiles ?? { ...disabledCatalogDefaultProfiles },
+    ...(options?.activeProfile !== undefined
+      ? { activeProfile: options.activeProfile }
+      : {}),
+  });
+}
+
+// ── Module mocks (must precede imports of the module under test) ─────
+
+// The real AgentLoop resolves the per-conversation ContextWindowManager from
+// the compaction store keyed by conversationId. These orchestrator tests build
+// fake conversations whose manager is a canned stub, so register each stub in a
+// map the mocked store reads from.
+const fakeContextWindowManagers = new Map<string, unknown>();
+mock.module("../plugins/defaults/compaction/manager-store.js", () => ({
+  createContextWindowManager: () => undefined,
+  getContextWindowManager: (conversationId: string) =>
+    fakeContextWindowManagers.get(conversationId),
+  disposeContextWindowManager: (conversationId: string) => {
+    fakeContextWindowManagers.delete(conversationId);
+  },
 }));
 
+// Keep the turn-boundary commit wait short and skip second-pass retitling so
+// loop teardown stays fast and deterministic across these orchestrator tests.
+setConfig("workspaceGit", { turnCommitMaxWaitMs: 10 });
+setConfig("conversations", { skipAutoRetitling: true });
+
 // ── Overflow recovery mocks ──────────────────────────────────────────
 
 // Token estimator returns a small value by default (well within budget)
@@ -298,6 +270,7 @@ const updateConversationSlackContextWatermarkMock = mock(
 );
 let mockConversationRow: Record<string, unknown> = {
   id: "conv-1",
+  createdAt: 1_700_000_000_000,
   contextSummary: null,
   contextCompactedMessageCount: 0,
   slackContextCompactionWatermarkTs: null,
@@ -307,12 +280,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: () => {},
@@ -339,6 +346,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,
@@ -767,7 +775,6 @@ function makeCtx(
     commandIntent: undefined,
     trustContext: undefined,
 
-    coreToolNames: new Set(),
     allowedToolNames: undefined,
     preactivatedSkillIds: undefined,
     skillProjectionState: new Map(),
@@ -865,9 +872,8 @@ function makeCompactionResult(
 // ── Tests ────────────────────────────────────────────────────────────
 
 beforeEach(() => {
-  mockUiConfig = {};
-  mockLlmProfiles = { ...disabledCatalogDefaultProfiles };
-  mockLlmActiveProfile = undefined;
+  setConfig("ui", {});
+  seedLlmConfig();
   mockEstimateTokens = 1000;
   mockReducerStepFn = null;
   mockOverflowAction = "fail_gracefully";
@@ -886,6 +892,7 @@ beforeEach(() => {
   updateConversationSlackContextWatermarkMock.mockImplementation(() => {});
   mockConversationRow = {
     id: "conv-1",
+    createdAt: 1_700_000_000_000,
     contextSummary: null,
     contextCompactedMessageCount: 0,
     slackContextCompactionWatermarkTs: null,
@@ -909,6 +916,8 @@ beforeEach(() => {
   deleteMessageByIdMock.mockClear();
   reserveMessageMock.mockClear();
   updateMessageContentMock.mockClear();
+  finalizeMessageContentMock.mockClear();
+  rmSync(inflightDir(), { recursive: true, force: true });
   addMessageMock.mockClear();
   mockConversationErrorClassification = {
     code: "CONVERSATION_PROCESSING_FAILED",
@@ -937,14 +946,24 @@ beforeEach(() => {
 describe("session-agent-loop", () => {
   describe("user-prompt-submit hook failures", () => {
     test("passes the effective profile to hooks even when it was already announced", async () => {
-      mockLlmProfiles = {
-        balanced: {
-          label: "Balanced",
-          model: "accounts/fireworks/models/glm-5p2",
+      // Both profiles are complete (provider + model) so each is a usable
+      // winner: the conversation's pinned "balanced" must win selection over
+      // the workspace-active "quality".
+      seedLlmConfig({
+        profiles: {
+          balanced: {
+            label: "Balanced",
+            provider: "fireworks",
+            model: "accounts/fireworks/models/glm-5p2",
+          },
+          quality: {
+            label: "Quality",
+            provider: "anthropic",
+            model: "claude-opus-4-8",
+          },
         },
-        quality: { label: "Quality", model: "claude-opus-4-8" },
-      };
-      mockLlmActiveProfile = "quality";
+        activeProfile: "quality",
+      });
       const observedProfileKeys: string[] = [];
       registerPlugin({
         manifest: {
@@ -1084,10 +1103,10 @@ describe("session-agent-loop", () => {
 
   describe("timezone turn context", () => {
     test("passes ctx.clientTimezone and ui.detectedTimezone into timezone resolution", async () => {
-      mockUiConfig = {
+      setConfig("ui", {
         userTimezone: "America/New_York",
         detectedTimezone: "America/Chicago",
-      };
+      });
       const ctx = makeCtx({ clientTimezone: "America/Los_Angeles" });
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", () => {});
@@ -1102,10 +1121,10 @@ describe("session-agent-loop", () => {
     });
 
     test("freezes the client timezone snapshot on the conversation, not the options bag", async () => {
-      mockUiConfig = {
+      setConfig("ui", {
         userTimezone: "US/Eastern",
         detectedTimezone: "US/Central",
-      };
+      });
       resolveTurnTimezoneContextMock.mockImplementationOnce(() => ({
         configuredUserTimezone: "America/New_York",
         clientTimezone: "America/Los_Angeles",
@@ -1606,6 +1625,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)", () => {
@@ -2535,13 +2579,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.");
           },
         },
@@ -2550,22 +2602,34 @@ 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; _redactionVersion?: number };
+      };
+      expect(delta.block).toEqual({
+        type: "text",
+        text: "Hello, world.",
+        // Stamped by the persist path's sentinel forgery guard (LUM-2768):
+        // marks the block as neutralization-aware for the history read seam.
+        _redactionVersion: 2,
+      });
+      // 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.", _redactionVersion: 2 },
+      ]);
+      expect(inflightDeltaFiles()).toHaveLength(0);
     });
 
     test("handleToolUse does NOT trigger a partial flush of its own", async () => {
@@ -2607,14 +2671,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 () => {
@@ -2667,13 +2733,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 () => {
@@ -2739,12 +2808,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);
           },
         },
@@ -2753,14 +2825,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 () => {
@@ -2791,16 +2865,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

@@ -30,9 +30,18 @@
  * `app-control` tools end up in the LLM tool list.
  */
 
-import * as realFs from "node:fs";
+import { createRequire } from "node:module";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
+// Freeze the real node:fs exports before `mock.module("node:fs", ...)` below
+// registers. A live `import * as` namespace would be remapped to the mock
+// itself once the factory runs, turning the pass-through fallback into
+// unbounded self-recursion; the synchronous require + spread pins the real
+// function references.
+const realFs = {
+  ...(createRequire(import.meta.url)("node:fs") as typeof import("node:fs")),
+};
+
 import type { InterfaceId } from "../channels/types.js";
 import { supportsHostProxy } from "../channels/types.js";
 import type { SkillSummary, SkillToolManifest } from "../config/skills.js";
@@ -43,11 +52,6 @@ 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) => {
@@ -64,16 +68,6 @@ mock.module("../config/skill-state.js", () => ({
     skill.featureFlag ?? undefined,
 }));
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    skills: { entries: {}, allowBundled: null },
-  }),
-  loadConfig: () => ({
-    skills: { entries: {}, allowBundled: null },
-  }),
-  invalidateConfigCache: () => {},
-}));
-
 let mockCatalog: SkillSummary[] = [];
 let mockManifests: Record<string, SkillToolManifest | null> = {};
 const mockRegisteredTools = new Map<string, Tool[]>();

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

@@ -15,54 +15,11 @@
 
 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 () => {},
 }));
 
-mock.module("../config/loader.js", () => ({
-  getConfig: () => ({
-    ui: {},
-    llm: {
-      default: {
-        provider: "mock-provider",
-        model: "mock-model",
-        maxTokens: 4096,
-        effort: "max" as const,
-        speed: "standard" as const,
-        temperature: null,
-        thinking: { enabled: false, streamThinking: true },
-        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",
-          },
-        },
-      },
-      profiles: {},
-      callSites: {},
-      pricingOverrides: [],
-    },
-    rateLimit: { maxRequestsPerMinute: 0 },
-  }),
-  loadRawConfig: () => ({}),
-  saveRawConfig: () => {},
-  invalidateConfigCache: () => {},
-}));
-
 mock.module("../prompts/system-prompt.js", () => ({
   buildSystemPrompt: () => "system prompt",
 }));

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

@@ -1,23 +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: {},
-    model: "test",
-    provider: "test",
-    memory: { enabled: false },
-    rateLimit: { maxRequestsPerMinute: 0 },
-  }),
-}));
-
 // Stub out video thumbnail generation (requires ffmpeg)
 mock.module("../daemon/video-thumbnail.js", () => ({
   generateVideoThumbnail: () => Promise.resolve(null),