@vellumai/assistant 0.4.43 → 0.4.45

package/src/__tests__/computer-use-session-working-dir.test.ts

@@ -39,7 +39,6 @@ mock.module("../util/platform.js", () => ({
   getWorkspacePromptPath: (file: string) => `/tmp/workspace/${file}`,
   getPlatformName: () => "linux",
   getClipboardCommand: () => null,
-  getSocketPath: () => "/tmp/test.sock",
   getPidPath: () => "/tmp/test.pid",
   getDbPath: () => "/tmp/data/db/assistant.db",
   getLogPath: () => "/tmp/test.log",
@@ -75,11 +74,8 @@ mock.module("../config/loader.js", () => ({
     contextWindow: {
       enabled: true,
       maxInputTokens: 180000,
-      targetInputTokens: 110000,
-      compactThreshold: 0.8,
-      preserveRecentUserTurns: 8,
-      summaryMaxTokens: 1200,
-      chunkTokens: 12000,
+      targetBudgetRatio: 0.30,
+      compactThreshold: 0.8,      summaryBudgetRatio: 0.05,
     },
     assistantFeatureFlagValues: {},
   }),

package/src/__tests__/computer-use-skill-lifecycle-cleanup.test.ts

@@ -15,11 +15,8 @@ mock.module("../config/loader.js", () => ({
     contextWindow: {
       enabled: true,
       maxInputTokens: 180000,
-      targetInputTokens: 110000,
-      compactThreshold: 0.8,
-      preserveRecentUserTurns: 8,
-      summaryMaxTokens: 1200,
-      chunkTokens: 12000,
+      targetBudgetRatio: 0.30,
+      compactThreshold: 0.8,      summaryBudgetRatio: 0.05,
     },
   }),
   invalidateConfigCache: () => {},

package/src/__tests__/computer-use-tools.test.ts

@@ -4,12 +4,10 @@ import {
   allComputerUseTools,
   computerUseClickTool,
   computerUseDoneTool,
-  computerUseDoubleClickTool,
   computerUseDragTool,
   computerUseKeyTool,
   computerUseOpenAppTool,
   computerUseRespondTool,
-  computerUseRightClickTool,
   computerUseRunAppleScriptTool,
   computerUseScrollTool,
   computerUseTypeTextTool,
@@ -42,8 +40,8 @@ const ctx: ToolContext = {
 // ── Tool definitions ────────────────────────────────────────────────
 
 describe("computer-use tool definitions", () => {
-  test("allComputerUseTools contains 12 tools", () => {
-    expect(allComputerUseTools.length).toBe(12);
+  test("allComputerUseTools contains 10 tools", () => {
+    expect(allComputerUseTools.length).toBe(10);
   });
 
   test("all tools have proxy execution mode", () => {
@@ -72,33 +70,39 @@ describe("computer-use tool definitions", () => {
   });
 });
 
-// ── Click tool variants ─────────────────────────────────────────────
-
-describe("click tool variants", () => {
-  for (const [tool, label] of [
-    [computerUseClickTool, "click"],
-    [computerUseDoubleClickTool, "double_click"],
-    [computerUseRightClickTool, "right_click"],
-  ] as const) {
-    test(`${tool.name} has correct name`, () => {
-      expect(tool.name).toBe(`computer_use_${label}`);
-    });
-
-    test(`${tool.name} schema requires reasoning`, () => {
-      expect(schema(tool).required).toContain("reasoning");
-    });
-
-    test(`${tool.name} schema supports element_id and coordinates`, () => {
-      const props = schema(tool).properties as Record<string, { type: string }>;
-      expect(props.element_id.type).toBe("integer");
-      expect(props.x.type).toBe("integer");
-      expect(props.y.type).toBe("integer");
-    });
-
-    test(`${tool.name} execute throws proxy error`, () => {
-      expect(() => tool.execute({}, ctx)).toThrow("Proxy tool");
-    });
-  }
+// ── Unified click tool ──────────────────────────────────────────────
+
+describe("computer_use_click (unified)", () => {
+  test("has correct name", () => {
+    expect(computerUseClickTool.name).toBe("computer_use_click");
+  });
+
+  test("schema requires reasoning", () => {
+    expect(schema(computerUseClickTool).required).toContain("reasoning");
+  });
+
+  test("schema supports click_type enum", () => {
+    const props = schema(computerUseClickTool).properties as Record<
+      string,
+      { type: string; enum?: string[] }
+    >;
+    expect(props.click_type.type).toBe("string");
+    expect(props.click_type.enum).toEqual(["single", "double", "right"]);
+  });
+
+  test("schema supports element_id and coordinates", () => {
+    const props = schema(computerUseClickTool).properties as Record<
+      string,
+      { type: string }
+    >;
+    expect(props.element_id.type).toBe("integer");
+    expect(props.x.type).toBe("integer");
+    expect(props.y.type).toBe("integer");
+  });
+
+  test("execute throws proxy error", () => {
+    expect(() => computerUseClickTool.execute({}, ctx)).toThrow("Proxy tool");
+  });
 });
 
 // ── type_text ───────────────────────────────────────────────────────

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

@@ -97,11 +97,9 @@ describe("AssistantConfigSchema", () => {
     expect(result.contextWindow).toEqual({
       enabled: true,
       maxInputTokens: 200000,
-      targetInputTokens: 110000,
+      targetBudgetRatio: 0.3,
       compactThreshold: 0.8,
-      preserveRecentUserTurns: 8,
-      summaryMaxTokens: 1200,
-      chunkTokens: 12000,
+      summaryBudgetRatio: 0.05,
       overflowRecovery: {
         enabled: true,
         safetyMarginRatio: 0.05,
@@ -322,18 +320,18 @@ describe("AssistantConfigSchema", () => {
     }
   });
 
-  test("rejects contextWindow targetInputTokens >= maxInputTokens", () => {
+  test("rejects contextWindow targetBudgetRatio >= compactThreshold", () => {
     const result = AssistantConfigSchema.safeParse({
-      contextWindow: { maxInputTokens: 1000, targetInputTokens: 1000 },
+      contextWindow: { targetBudgetRatio: 0.8, compactThreshold: 0.8 },
     });
     expect(result.success).toBe(false);
     if (!result.success) {
       expect(
         result.error.issues.some(
           (issue) =>
-            issue.path.join(".") === "contextWindow.targetInputTokens" &&
+            issue.path.join(".") === "contextWindow.targetBudgetRatio" &&
             issue.message.includes(
-              "must be less than contextWindow.maxInputTokens",
+              "must be less than contextWindow.compactThreshold",
             ),
         ),
       ).toBe(true);
@@ -1102,11 +1100,9 @@ describe("loadConfig with schema validation", () => {
     expect(config.contextWindow).toEqual({
       enabled: true,
       maxInputTokens: 200000,
-      targetInputTokens: 110000,
+      targetBudgetRatio: 0.3,
       compactThreshold: 0.8,
-      preserveRecentUserTurns: 8,
-      summaryMaxTokens: 1200,
-      chunkTokens: 12000,
+      summaryBudgetRatio: 0.05,
       overflowRecovery: {
         enabled: true,
         safetyMarginRatio: 0.05,
@@ -1196,11 +1192,11 @@ describe("loadConfig with schema validation", () => {
 
   test("falls back for invalid contextWindow relationship", () => {
     writeConfig({
-      contextWindow: { maxInputTokens: 1000, targetInputTokens: 1000 },
+      contextWindow: { targetBudgetRatio: 0.8, compactThreshold: 0.8 },
     });
     const config = loadConfig();
-    expect(config.contextWindow.maxInputTokens).toBe(200000);
-    expect(config.contextWindow.targetInputTokens).toBe(110000);
+    expect(config.contextWindow.targetBudgetRatio).toBe(0.3);
+    expect(config.contextWindow.compactThreshold).toBe(0.8);
   });
 
   test("falls back for invalid rateLimit values", () => {

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

@@ -33,7 +33,6 @@ mock.module("../util/platform.js", () => ({
   getWorkspacePromptPath: (file: string) => join(WORKSPACE_DIR, file),
   ensureDataDir: () => {},
   getDataDir: () => join(WORKSPACE_DIR, "data"),
-  getSocketPath: () => join(TEST_DIR, "vellum.sock"),
   getPidPath: () => join(TEST_DIR, "vellum.pid"),
   getDbPath: () => join(WORKSPACE_DIR, "data", "assistant.db"),
   getLogPath: () => join(WORKSPACE_DIR, "data", "logs", "vellum.log"),

package/src/__tests__/confirmation-request-guardian-bridge.test.ts

@@ -20,7 +20,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

package/src/__tests__/conflict-store.test.ts

@@ -12,7 +12,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

package/src/__tests__/connection-policy.test.ts

@@ -51,7 +51,6 @@ describe("hasNoAuthOverride", () => {
   test("returns false when VELLUM_DAEMON_NOAUTH is true without safety gate", () => {
     expect(hasNoAuthOverride({ VELLUM_DAEMON_NOAUTH: "true" })).toBe(false);
   });
-
 });
 
 describe("shouldAutoStartDaemon", () => {
@@ -60,15 +59,13 @@ describe("shouldAutoStartDaemon", () => {
   });
 
   test("returns true when VELLUM_DAEMON_AUTOSTART=1", () => {
-    expect(
-      shouldAutoStartDaemon({ VELLUM_DAEMON_AUTOSTART: "1" }),
-    ).toBe(true);
+    expect(shouldAutoStartDaemon({ VELLUM_DAEMON_AUTOSTART: "1" })).toBe(true);
   });
 
   test("returns true when VELLUM_DAEMON_AUTOSTART=true", () => {
-    expect(
-      shouldAutoStartDaemon({ VELLUM_DAEMON_AUTOSTART: "true" }),
-    ).toBe(true);
+    expect(shouldAutoStartDaemon({ VELLUM_DAEMON_AUTOSTART: "true" })).toBe(
+      true,
+    );
   });
 
   test("returns false when VELLUM_DAEMON_AUTOSTART=0", () => {

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

@@ -21,7 +21,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

package/src/__tests__/context-memory-e2e.test.ts

@@ -36,7 +36,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),
@@ -430,10 +429,9 @@ describe("Context + Memory E2E regression", () => {
       config: {
         ...DEFAULT_CONFIG.contextWindow,
         maxInputTokens: 5200,
-        targetInputTokens: 2600,
+        targetBudgetRatio: 0.55,
         compactThreshold: 0.55,
-        preserveRecentUserTurns: 6,
-        chunkTokens: 900,
+        summaryBudgetRatio: 0.05,
       },
     });
 

package/src/__tests__/context-overflow-reducer.test.ts

@@ -57,11 +57,9 @@ function makeConfig(overrides?: Partial<ReducerConfig>): ReducerConfig {
     contextWindow: {
       enabled: true,
       maxInputTokens: 2000,
-      targetInputTokens: 1200,
+      targetBudgetRatio: 0.65,
       compactThreshold: 0.6,
-      preserveRecentUserTurns: 2,
-      summaryMaxTokens: 128,
-      chunkTokens: 80,
+      summaryBudgetRatio: 0.05,
       overflowRecovery: {
         enabled: true,
         safetyMarginRatio: 0.05,

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

@@ -20,11 +20,9 @@ function makeConfig(
   return {
     enabled: true,
     maxInputTokens: 450,
-    targetInputTokens: 300,
+    targetBudgetRatio: 0.67,
     compactThreshold: 0.6,
-    preserveRecentUserTurns: 2,
-    summaryMaxTokens: 128,
-    chunkTokens: 80,
+    summaryBudgetRatio: 0.05,
     overflowRecovery: {
       enabled: true,
       safetyMarginRatio: 0.05,
@@ -85,7 +83,7 @@ describe("ContextWindowManager", () => {
     const manager = new ContextWindowManager({
       provider,
       systemPrompt: "system prompt",
-      config: makeConfig(),
+      config: makeConfig({ maxInputTokens: 600 }),
     });
     const long = "x".repeat(240);
     const history: Message[] = [
@@ -117,28 +115,26 @@ describe("ContextWindowManager", () => {
     expect(userTexts.some((text) => text.startsWith("u3 "))).toBe(true);
   });
 
-  test("aggregates cache-aware summary usage across compaction chunks", async () => {
-    let summaryCalls = 0;
+  test("returns cache-aware summary usage from single-pass compaction", async () => {
     const provider = createProvider(() => {
-      summaryCalls += 1;
       return {
         content: [
-          { type: "text", text: `## Goals\n- summary chunk ${summaryCalls}` },
+          { type: "text", text: `## Goals\n- summary of full transcript` },
         ],
         model: "claude-opus-4-6",
         usage: {
-          inputTokens: 1_000 + summaryCalls,
-          outputTokens: 20 + summaryCalls,
-          cacheCreationInputTokens: 10 * summaryCalls,
-          cacheReadInputTokens: 100 * summaryCalls,
+          inputTokens: 5_000,
+          outputTokens: 80,
+          cacheCreationInputTokens: 50,
+          cacheReadInputTokens: 200,
         },
         rawResponse: {
           usage: {
             cache_creation: {
-              ephemeral_5m_input_tokens: 10 * summaryCalls,
+              ephemeral_5m_input_tokens: 50,
               ephemeral_1h_input_tokens: 0,
             },
-            cache_read_input_tokens: 100 * summaryCalls,
+            cache_read_input_tokens: 200,
           },
         },
         stopReason: "end_turn",
@@ -149,8 +145,7 @@ describe("ContextWindowManager", () => {
       systemPrompt: "system prompt",
       config: makeConfig({
         maxInputTokens: 7_000,
-        targetInputTokens: 2_500,
-        preserveRecentUserTurns: 1,
+        targetBudgetRatio: 0.41,
       }),
     });
     const long = "q".repeat(6_000);
@@ -165,19 +160,14 @@ describe("ContextWindowManager", () => {
     const result = await manager.maybeCompact(history);
 
     expect(result.compacted).toBe(true);
-    expect(result.summaryCalls).toBe(summaryCalls);
-    expect(result.summaryCalls).toBeGreaterThan(1);
-    expect(result.summaryCacheCreationInputTokens).toBe(
-      summaryCalls * (summaryCalls + 1) * 5,
-    );
-    expect(result.summaryCacheReadInputTokens).toBe(
-      summaryCalls * (summaryCalls + 1) * 50,
-    );
-    expect(result.summaryRawResponses).toHaveLength(summaryCalls);
+    expect(result.summaryCalls).toBe(1);
+    expect(result.summaryCacheCreationInputTokens).toBe(50);
+    expect(result.summaryCacheReadInputTokens).toBe(200);
+    expect(result.summaryRawResponses).toHaveLength(1);
     expect(result.summaryRawResponses?.[0]).toMatchObject({
       usage: {
-        cache_creation: { ephemeral_5m_input_tokens: 10 },
-        cache_read_input_tokens: 100,
+        cache_creation: { ephemeral_5m_input_tokens: 50 },
+        cache_read_input_tokens: 200,
       },
     });
   });
@@ -194,8 +184,7 @@ describe("ContextWindowManager", () => {
       systemPrompt: "system prompt",
       config: makeConfig({
         maxInputTokens: 300,
-        targetInputTokens: 160,
-        preserveRecentUserTurns: 1,
+        targetBudgetRatio: 0.58,
       }),
     });
     const long = "y".repeat(220);
@@ -234,8 +223,7 @@ describe("ContextWindowManager", () => {
       systemPrompt: "system prompt",
       config: makeConfig({
         maxInputTokens: 260,
-        targetInputTokens: 140,
-        preserveRecentUserTurns: 1,
+        targetBudgetRatio: 0.59,
       }),
     });
     const long = "z".repeat(220);
@@ -272,12 +260,11 @@ describe("ContextWindowManager", () => {
       provider,
       systemPrompt: "system prompt",
       config: makeConfig({
-        maxInputTokens: 280,
-        targetInputTokens: 150,
-        preserveRecentUserTurns: 1,
+        maxInputTokens: 550,
+        targetBudgetRatio: 0.59,
       }),
     });
-    const long = "f".repeat(220);
+    const long = "f".repeat(500);
     const history: Message[] = [
       {
         role: "user",
@@ -322,8 +309,7 @@ describe("ContextWindowManager", () => {
       systemPrompt: "system prompt",
       config: makeConfig({
         maxInputTokens: 320,
-        targetInputTokens: 170,
-        preserveRecentUserTurns: 1,
+        targetBudgetRatio: 0.58,
       }),
     });
     const long = "k".repeat(220);
@@ -370,8 +356,7 @@ describe("ContextWindowManager", () => {
       systemPrompt: "system prompt",
       config: makeConfig({
         maxInputTokens: 320,
-        targetInputTokens: 170,
-        preserveRecentUserTurns: 1,
+        targetBudgetRatio: 0.58,
       }),
     });
     const long = "k".repeat(220);
@@ -431,8 +416,7 @@ describe("ContextWindowManager", () => {
       systemPrompt: "system prompt",
       config: makeConfig({
         maxInputTokens: 2600,
-        targetInputTokens: 1500,
-        preserveRecentUserTurns: 1,
+        targetBudgetRatio: 0.63,
       }),
     });
     const long = "c".repeat(5000);
@@ -445,11 +429,11 @@ describe("ContextWindowManager", () => {
     const result = await manager.maybeCompact(history);
 
     expect(result.compacted).toBe(true);
-    expect(result.summaryCalls).toBe(2);
-    expect(result.summaryInputTokens).toBe(1000);
-    expect(result.summaryCacheCreationInputTokens).toBe(240);
-    expect(result.summaryCacheReadInputTokens).toBe(680);
-    expect(result.summaryRawResponses).toEqual([rawResponse, rawResponse]);
+    expect(result.summaryCalls).toBe(1);
+    expect(result.summaryInputTokens).toBe(500);
+    expect(result.summaryCacheCreationInputTokens).toBe(120);
+    expect(result.summaryCacheReadInputTokens).toBe(340);
+    expect(result.summaryRawResponses).toEqual([rawResponse]);
   });
 
   test("does not parse user-authored summary marker text as internal summary", () => {
@@ -476,8 +460,7 @@ describe("ContextWindowManager", () => {
       systemPrompt: "system prompt",
       config: makeConfig({
         maxInputTokens: 260,
-        targetInputTokens: 180,
-        preserveRecentUserTurns: 1,
+        targetBudgetRatio: 0.74,
       }),
     });
     const long = "c".repeat(220);
@@ -506,8 +489,7 @@ describe("ContextWindowManager", () => {
       systemPrompt: "system prompt",
       config: makeConfig({
         maxInputTokens: 320,
-        targetInputTokens: 180,
-        preserveRecentUserTurns: 1,
+        targetBudgetRatio: 0.61,
       }),
     });
     const long = "p".repeat(340);
@@ -538,8 +520,7 @@ describe("ContextWindowManager", () => {
       systemPrompt: "system prompt",
       config: makeConfig({
         maxInputTokens: 260,
-        targetInputTokens: 180,
-        preserveRecentUserTurns: 1,
+        targetBudgetRatio: 0.74,
       }),
     });
     const long = "c".repeat(220);
@@ -572,9 +553,8 @@ describe("ContextWindowManager", () => {
       systemPrompt: "system prompt",
       config: makeConfig({
         maxInputTokens: 7000,
-        targetInputTokens: 5000,
+        targetBudgetRatio: 0.76,
         compactThreshold: 0.8,
-        preserveRecentUserTurns: 1,
       }),
     });
 
@@ -624,8 +604,7 @@ describe("ContextWindowManager", () => {
       systemPrompt: "system prompt",
       config: makeConfig({
         maxInputTokens: 260,
-        targetInputTokens: 60,
-        preserveRecentUserTurns: 2,
+        targetBudgetRatio: 0.28,
       }),
     });
     const long = "e".repeat(220);
@@ -640,7 +619,7 @@ describe("ContextWindowManager", () => {
       minKeepRecentUserTurns: 0,
     });
     expect(result.compacted).toBe(true);
-    // With minKeepRecentUserTurns=0 and a tight targetInputTokens budget,
+    // With minKeepRecentUserTurns=0 and a tight target budget,
     // pickKeepBoundary drops keepTurns all the way to 0.
     // All three messages are compacted into a single summary message.
     expect(result.compactedMessages).toBe(3);
@@ -709,6 +688,115 @@ describe("ContextWindowManager", () => {
     expect(result.estimatedTokens).toBe(0);
   });
 
+  test("truncates tool results in kept turns to preserve more conversation", async () => {
+    const provider = createProvider(() => ({
+      content: [{ type: "text", text: "## Goals\n- truncation summary" }],
+      model: "mock-model",
+      usage: { inputTokens: 60, outputTokens: 12 },
+      stopReason: "end_turn",
+    }));
+    // Budget is tight enough that full 8K tool results would force dropping turns,
+    // but truncated results (≤6K chars) should allow more turns to be kept.
+    const config = makeConfig({
+      maxInputTokens: 4000,
+      targetBudgetRatio: 0.7,
+    });
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config,
+    });
+
+    const largeToolResult = "x".repeat(8000);
+    const history: Message[] = [
+      message("user", "u1"),
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            id: "t1",
+            name: "read_file",
+            input: { path: "/tmp/a" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "t1",
+            content: largeToolResult,
+          },
+        ],
+      },
+      message("assistant", "a1"),
+      message("user", "u2"),
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            id: "t2",
+            name: "read_file",
+            input: { path: "/tmp/b" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "t2",
+            content: largeToolResult,
+          },
+        ],
+      },
+      message("assistant", "a2"),
+      message("user", "u3"),
+      {
+        role: "assistant",
+        content: [
+          {
+            type: "tool_use",
+            id: "t3",
+            name: "read_file",
+            input: { path: "/tmp/c" },
+          },
+        ],
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "t3",
+            content: largeToolResult,
+          },
+        ],
+      },
+      message("assistant", "a3"),
+      message("user", "u4"),
+      message("assistant", "a4"),
+    ];
+
+    const result = await manager.maybeCompact(history, undefined, {
+      force: true,
+    });
+    expect(result.compacted).toBe(true);
+
+    // Verify tool results in output are truncated (should be < 8K chars each).
+    for (const msg of result.messages) {
+      for (const block of msg.content) {
+        if (block.type === "tool_result") {
+          expect(block.content.length).toBeLessThan(8000);
+        }
+      }
+    }
+  });
+
   test("targetInputTokensOverride reduces retained turns beyond normal compaction", async () => {
     const provider = createProvider(() => ({
       content: [{ type: "text", text: "## Goals\n- tight fit summary" }],
@@ -720,8 +808,7 @@ describe("ContextWindowManager", () => {
     // Use generous default target so normal compaction would keep all 3 user turns.
     const config = makeConfig({
       maxInputTokens: 1200,
-      targetInputTokens: 1000,
-      preserveRecentUserTurns: 3,
+      targetBudgetRatio: 0.88,
     });
     const long = "t".repeat(220);
     const history: Message[] = [

package/src/__tests__/contradiction-checker.test.ts

@@ -67,7 +67,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),

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

@@ -10,7 +10,6 @@ mock.module("../util/platform.js", () => ({
   isMacOS: () => process.platform === "darwin",
   isLinux: () => process.platform === "linux",
   isWindows: () => process.platform === "win32",
-  getSocketPath: () => join(testDir, "test.sock"),
   getPidPath: () => join(testDir, "test.pid"),
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),