@vellumai/assistant 0.6.5 → 0.6.6

package/src/__tests__/compaction-strip-metadata-clear.test.ts

@@ -0,0 +1,181 @@
+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 },
+    secretDetection: { enabled: false },
+  }),
+}));
+
+import {
+  addMessage,
+  clearStrippedInjectionMetadataForConversation,
+  createConversation,
+  getMessages,
+} from "../memory/conversation-crud.js";
+import { getDb, initializeDb } from "../memory/db.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversations");
+}
+
+describe("clearStrippedInjectionMetadataForConversation", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("removes all three stripped-block fields and preserves the rest", async () => {
+    const conv = createConversation("Strip metadata test");
+    await addMessage(
+      conv.id,
+      "user",
+      "turn 1",
+      {
+        memoryInjectedBlock: "mem payload",
+        turnContextBlock: "<turn_context>\nctx\n</turn_context>",
+        workspaceBlock: "<workspace>\nws\n</workspace>",
+        nowScratchpadBlock:
+          "<NOW.md Always keep this up to date>\nnow body\n</NOW.md>",
+        pkbContextBlock: "<knowledge_base>\npkb body\n</knowledge_base>",
+        pkbSystemReminderBlock:
+          "<system_reminder>\nreminder body\n</system_reminder>",
+      },
+      { skipIndexing: true },
+    );
+
+    clearStrippedInjectionMetadataForConversation(conv.id);
+
+    const [row] = getMessages(conv.id);
+    const meta = JSON.parse(row.metadata ?? "{}");
+
+    expect(meta.pkbSystemReminderBlock).toBeUndefined();
+    expect(meta.nowScratchpadBlock).toBeUndefined();
+    expect(meta.pkbContextBlock).toBeUndefined();
+
+    // Non-stripped fields must survive — these back blocks that
+    // `stripInjectionsForCompaction` intentionally leaves in-memory.
+    expect(meta.memoryInjectedBlock).toBe("mem payload");
+    expect(meta.turnContextBlock).toBe("<turn_context>\nctx\n</turn_context>");
+    expect(meta.workspaceBlock).toBe("<workspace>\nws\n</workspace>");
+  });
+
+  test("is idempotent — re-running is a no-op on already-cleared rows", async () => {
+    const conv = createConversation("Idempotent clear");
+    await addMessage(
+      conv.id,
+      "user",
+      "turn 1",
+      {
+        memoryInjectedBlock: "keep me",
+        nowScratchpadBlock: "<NOW.md …>body</NOW.md>",
+      },
+      { skipIndexing: true },
+    );
+
+    clearStrippedInjectionMetadataForConversation(conv.id);
+    clearStrippedInjectionMetadataForConversation(conv.id);
+
+    const [row] = getMessages(conv.id);
+    const meta = JSON.parse(row.metadata ?? "{}");
+    expect(meta.nowScratchpadBlock).toBeUndefined();
+    expect(meta.memoryInjectedBlock).toBe("keep me");
+  });
+
+  test("only targets user rows — assistant metadata is untouched", async () => {
+    const conv = createConversation("Role scoping");
+    await addMessage(
+      conv.id,
+      "user",
+      "turn 1",
+      { nowScratchpadBlock: "<NOW.md …>body</NOW.md>" },
+      { skipIndexing: true },
+    );
+    await addMessage(
+      conv.id,
+      "assistant",
+      "reply",
+      // Assistant rows don't carry these blocks in practice, but guard the
+      // role filter anyway so an accidental drop of the WHERE clause is
+      // surfaced immediately.
+      { nowScratchpadBlock: "should-not-be-cleared" },
+      { skipIndexing: true },
+    );
+
+    clearStrippedInjectionMetadataForConversation(conv.id);
+
+    const rows = getMessages(conv.id);
+    const userMeta = JSON.parse(rows[0].metadata ?? "{}");
+    const assistantMeta = JSON.parse(rows[1].metadata ?? "{}");
+    expect(userMeta.nowScratchpadBlock).toBeUndefined();
+    expect(assistantMeta.nowScratchpadBlock).toBe("should-not-be-cleared");
+  });
+
+  test("post-clear, rehydration does not re-inject NOW.md / knowledge_base", async () => {
+    // Reproduces the divergence described in the Codex P1 feedback:
+    // stripInjectionsForCompaction removes <NOW.md …> and <knowledge_base>
+    // from the in-memory history during compaction. Without this clear,
+    // a subsequent loadFromDb would rehydrate those blocks from stale
+    // metadata — re-injecting exactly what compaction removed.
+    const conv = createConversation("Rehydrate after strip");
+    await addMessage(
+      conv.id,
+      "user",
+      "historical turn",
+      {
+        memoryInjectedBlock: "mem",
+        turnContextBlock: "<turn_context>\nctx\n</turn_context>",
+        workspaceBlock: "<workspace>\nws\n</workspace>",
+        nowScratchpadBlock:
+          "<NOW.md Always keep this up to date>\nnow\n</NOW.md>",
+        pkbContextBlock: "<knowledge_base>\npkb\n</knowledge_base>",
+        pkbSystemReminderBlock: "<system_reminder>\nsr\n</system_reminder>",
+      },
+      { skipIndexing: true },
+    );
+    await addMessage(conv.id, "assistant", "reply", undefined, {
+      skipIndexing: true,
+    });
+    await addMessage(conv.id, "user", "tail turn", undefined, {
+      skipIndexing: true,
+    });
+
+    // Simulate the compaction-strip lifecycle point.
+    clearStrippedInjectionMetadataForConversation(conv.id);
+
+    const rows = getMessages(conv.id);
+    const historicalMeta = JSON.parse(rows[0].metadata ?? "{}");
+
+    // Loading this back with loadFromDb prepends fields only when they
+    // are present on the row. Confirm the stripped fields are gone so
+    // rehydration cannot resurrect them.
+    expect(historicalMeta.nowScratchpadBlock).toBeUndefined();
+    expect(historicalMeta.pkbContextBlock).toBeUndefined();
+    expect(historicalMeta.pkbSystemReminderBlock).toBeUndefined();
+
+    // And the fields that back blocks `stripInjectionsForCompaction`
+    // intentionally preserves (<turn_context>, <workspace>, <memory __injected>)
+    // must still be present so the cache prefix remains stable.
+    expect(historicalMeta.turnContextBlock).toBe(
+      "<turn_context>\nctx\n</turn_context>",
+    );
+    expect(historicalMeta.workspaceBlock).toBe("<workspace>\nws\n</workspace>");
+    expect(historicalMeta.memoryInjectedBlock).toBe("mem");
+  });
+});

package/src/__tests__/compaction-timeout-recovery.test.ts

@@ -0,0 +1,262 @@
+/**
+ * Tests for the compaction call-site recovery path added in JARVIS-587.
+ *
+ * When the `compaction` pipeline exceeds its 30s budget (manifest-wide
+ * `DEFAULT_TIMEOUTS.compaction`), the pipeline runner throws
+ * `PluginTimeoutError`. The three compaction call sites in
+ * `conversation-agent-loop.ts` (start-of-turn, mid-loop, emergency) catch
+ * that error, invoke `trackCompactionOutcome(..., true, onEvent)` so the
+ * circuit breaker records the failure, and degrade gracefully.
+ *
+ * This file asserts the tight coupling between:
+ *  (1) a `PluginTimeoutError`-driven failure and
+ *  (2) the compaction circuit breaker's 3-strike threshold.
+ *
+ * The existing `circuit-breaker-pipeline.test.ts` already exercises the
+ * breaker's transitions end-to-end. These tests verify that our new
+ * catch-blocks feed the breaker the same `"failure"` outcome a normal
+ * summary-LLM throw would, and that repeated timeouts therefore trip the
+ * same 3-strike trip.
+ */
+
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { trackCompactionOutcome } from "../daemon/conversation-agent-loop.js";
+import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
+import type { ServerMessage } from "../daemon/message-protocol.js";
+import {
+  COMPACTION_CIRCUIT_FAILURE_THRESHOLD,
+  defaultCircuitBreakerPlugin,
+} from "../plugins/defaults/circuit-breaker.js";
+import { DEFAULT_TIMEOUTS, runPipeline } from "../plugins/pipeline.js";
+import {
+  getMiddlewaresFor,
+  registerPlugin,
+  resetPluginRegistryForTests,
+} from "../plugins/registry.js";
+import {
+  type CompactionArgs,
+  type CompactionResult,
+  type Middleware,
+  PluginTimeoutError,
+  type TurnContext,
+} from "../plugins/types.js";
+
+// ─── Fixtures ───────────────────────────────────────────────────────────────
+
+interface FakeConversationCtx {
+  readonly conversationId: string;
+  consecutiveCompactionFailures: number;
+  compactionCircuitOpenUntil: number | null;
+  currentRequestId?: string;
+  currentTurnTrustContext?: TrustContext;
+  trustContext?: TrustContext;
+  turnCount: number;
+}
+
+function makeConversationCtx(
+  conversationId = "conv-timeout-test",
+): FakeConversationCtx {
+  return {
+    conversationId,
+    consecutiveCompactionFailures: 0,
+    compactionCircuitOpenUntil: null,
+    turnCount: 0,
+    trustContext: { sourceChannel: "vellum", trustClass: "guardian" },
+  };
+}
+
+const trust: TrustContext = {
+  sourceChannel: "vellum",
+  trustClass: "guardian",
+};
+
+function makeTurnCtx(conversationId: string): TurnContext {
+  return {
+    requestId: "req-timeout-test",
+    conversationId,
+    turnIndex: 0,
+    trust,
+  };
+}
+
+function collectEvents(): {
+  events: ServerMessage[];
+  onEvent: (msg: ServerMessage) => void;
+} {
+  const events: ServerMessage[] = [];
+  return { events, onEvent: (msg) => events.push(msg) };
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+describe("compaction timeout recovery (JARVIS-587)", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    registerPlugin(defaultCircuitBreakerPlugin);
+  });
+
+  afterEach(() => {
+    resetPluginRegistryForTests();
+  });
+
+  test("runPipeline('compaction', ...) throws PluginTimeoutError on budget breach", async () => {
+    // Baseline: the compaction pipeline still surfaces PluginTimeoutError when
+    // its timer fires. This guards the outer race from silently swallowing
+    // the timeout when the inner call is aborted by our Part A wiring.
+    const hang: Middleware<CompactionArgs, CompactionResult> = async (
+      _args,
+      _next,
+    ) =>
+      new Promise<CompactionResult>(() => {
+        // intentionally never resolves
+      });
+
+    let caught: unknown;
+    try {
+      await runPipeline<CompactionArgs, CompactionResult>(
+        "compaction",
+        [hang],
+        async () => ({ compacted: false }) as unknown as CompactionResult,
+        { messages: [] as unknown, signal: undefined, options: undefined },
+        makeTurnCtx("conv-budget-breach"),
+        // Override the manifest timeout to keep the test fast.
+        20,
+      );
+    } catch (err) {
+      caught = err;
+    }
+    expect(caught).toBeInstanceOf(PluginTimeoutError);
+    expect((caught as PluginTimeoutError).pipeline).toBe("compaction");
+  });
+
+  test("trackCompactionOutcome(failed=true) driven by PluginTimeoutError trips the breaker at the 3rd strike", async () => {
+    // Simulates the production sequence: each mid-loop compaction hits the
+    // pipeline's 30s ceiling, the orchestrator's catch block calls
+    // `trackCompactionOutcome(ctx, true, onEvent)`. After three such catches
+    // the circuit breaker must be open — matching the same invariant the
+    // existing breaker test file exercises for normal summary-LLM throws.
+    const ctx = makeConversationCtx();
+    const { onEvent, events } = collectEvents();
+
+    // First two timeouts — circuit still closed.
+    await trackCompactionOutcome(ctx, true, onEvent);
+    await trackCompactionOutcome(ctx, true, onEvent);
+    expect(ctx.consecutiveCompactionFailures).toBe(2);
+    expect(ctx.compactionCircuitOpenUntil).toBeNull();
+    expect(events).toHaveLength(0);
+
+    // Third timeout — breaker trips and emits the canonical transition event.
+    await trackCompactionOutcome(ctx, true, onEvent);
+    expect(ctx.consecutiveCompactionFailures).toBe(
+      COMPACTION_CIRCUIT_FAILURE_THRESHOLD,
+    );
+    expect(ctx.compactionCircuitOpenUntil).not.toBeNull();
+    expect(events).toHaveLength(1);
+    expect(events[0]).toEqual({
+      type: "compaction_circuit_open",
+      conversationId: ctx.conversationId,
+      reason: "3_consecutive_failures",
+      openUntil: ctx.compactionCircuitOpenUntil as number,
+    });
+  });
+
+  test("a successful compaction after two timeouts resets the counter", async () => {
+    // The recovery path doesn't interfere with the breaker's normal reset —
+    // once a compaction call eventually succeeds, the streak is broken and
+    // the next failure starts counting from 1.
+    const ctx = makeConversationCtx();
+    const { onEvent } = collectEvents();
+
+    await trackCompactionOutcome(ctx, true, onEvent);
+    await trackCompactionOutcome(ctx, true, onEvent);
+    expect(ctx.consecutiveCompactionFailures).toBe(2);
+
+    await trackCompactionOutcome(ctx, false, onEvent);
+    expect(ctx.consecutiveCompactionFailures).toBe(0);
+    expect(ctx.compactionCircuitOpenUntil).toBeNull();
+
+    await trackCompactionOutcome(ctx, true, onEvent);
+    expect(ctx.consecutiveCompactionFailures).toBe(1);
+  });
+
+  test("compaction call-site recovery remains defense-in-depth even when DEFAULT_TIMEOUTS.compaction is null", () => {
+    // At the time this PR landed, `DEFAULT_TIMEOUTS.compaction` was null
+    // (pipeline timeouts globally disabled — see #27608). That makes the
+    // call-site catch blocks unreachable in production right now, but the
+    // catch blocks still matter: any future reintroduction of a per-pipeline
+    // compaction timeout immediately benefits from circuit-breaker recording
+    // and graceful-degradation without needing to re-touch every call site.
+    //
+    // This test just documents the current value so a future change that
+    // reintroduces a timeout must also decide (intentionally) whether the
+    // recovery path should continue to fire.
+    const value = DEFAULT_TIMEOUTS.compaction;
+    expect(value === null || typeof value === "number").toBe(true);
+  });
+});
+
+describe("abort propagation end-to-end (Part A + updateSummary fallback)", () => {
+  beforeEach(() => {
+    resetPluginRegistryForTests();
+    registerPlugin(defaultCircuitBreakerPlugin);
+  });
+
+  afterEach(() => {
+    resetPluginRegistryForTests();
+  });
+
+  test("caller-provided signal is replaced with a linked signal that fires on timeout", async () => {
+    // Minimal proof that Part A actually wires the signal through the
+    // compaction pipeline: when the pipeline runner's timer fires, the
+    // signal seen by the inner terminal is aborted — allowing
+    // `updateSummary`'s try/catch around `provider.sendMessage` to trigger
+    // the local-fallback path instead of the call hanging indefinitely.
+    let observedSignal: AbortSignal | undefined;
+    const waitForAbort: Middleware<CompactionArgs, CompactionResult> = async (
+      args,
+      _next,
+    ) => {
+      observedSignal = args.signal;
+      return new Promise<CompactionResult>((_resolve, reject) => {
+        args.signal?.addEventListener("abort", () => {
+          reject(
+            Object.assign(new Error("aborted by signal"), {
+              name: "AbortError",
+            }),
+          );
+        });
+      });
+    };
+
+    const callerController = new AbortController();
+
+    let caught: unknown;
+    try {
+      await runPipeline<CompactionArgs, CompactionResult>(
+        "compaction",
+        [waitForAbort, ...getMiddlewaresFor("compaction")],
+        async () => ({ compacted: false }) as unknown as CompactionResult,
+        {
+          messages: [] as unknown,
+          signal: callerController.signal,
+          options: undefined,
+        },
+        makeTurnCtx("conv-abort-test"),
+        20,
+      );
+    } catch (err) {
+      caught = err;
+    }
+
+    expect(caught).toBeInstanceOf(PluginTimeoutError);
+    expect(observedSignal).toBeDefined();
+    // The runner swaps the caller's signal for a linked signal — the two are
+    // distinct objects but both should end up aborted once the timer fires.
+    expect(observedSignal).not.toBe(callerController.signal);
+    expect(observedSignal!.aborted).toBe(true);
+    // Caller's own signal is untouched — pipeline timeout does not cascade
+    // outward onto the caller's controller.
+    expect(callerController.signal.aborted).toBe(false);
+  });
+});

package/src/__tests__/config-model-image-provider.test.ts

@@ -0,0 +1,110 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { invalidateConfigCache } from "../config/loader.js";
+import {
+  type ModelSetContext,
+  setImageGenModel,
+} from "../daemon/handlers/config-model.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const WORKSPACE_DIR = process.env.VELLUM_WORKSPACE_DIR!;
+const CONFIG_PATH = join(WORKSPACE_DIR, "config.json");
+
+function ensureTestDir(): void {
+  const dirs = [WORKSPACE_DIR, join(WORKSPACE_DIR, "data")];
+  for (const dir of dirs) {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  }
+}
+
+function writeConfig(obj: unknown): void {
+  writeFileSync(CONFIG_PATH, JSON.stringify(obj));
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+}
+
+function makeCtx(): ModelSetContext {
+  return {
+    conversations: new Map(),
+    suppressConfigReload: false,
+    setSuppressConfigReload: () => {},
+    updateConfigFingerprint: () => {},
+    debounceTimers: {
+      // No-op scheduler: the test asserts the persisted config shape, not
+      // the debounce behaviour. Firing the callback synchronously would
+      // mutate state after the assertion; dropping it keeps the test
+      // deterministic.
+      schedule: (_key: string, _fn: () => void, _ms: number) => {},
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Setup / Teardown
+// ---------------------------------------------------------------------------
+
+beforeEach(() => {
+  ensureTestDir();
+  writeConfig({});
+  invalidateConfigCache();
+});
+
+afterEach(() => {
+  try {
+    writeConfig({});
+    invalidateConfigCache();
+  } catch {
+    // best-effort cleanup
+  }
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("setImageGenModel — provider derived from model prefix", () => {
+  test("gemini model writes provider=gemini", () => {
+    setImageGenModel("gemini-3.1-flash-image-preview", makeCtx());
+
+    const config = readConfig();
+    const imageGen = (config.services as any)?.["image-generation"];
+    expect(imageGen?.model).toBe("gemini-3.1-flash-image-preview");
+    expect(imageGen?.provider).toBe("gemini");
+  });
+
+  test("gpt-image-2 writes provider=openai", () => {
+    setImageGenModel("gpt-image-2", makeCtx());
+
+    const config = readConfig();
+    const imageGen = (config.services as any)?.["image-generation"];
+    expect(imageGen?.model).toBe("gpt-image-2");
+    expect(imageGen?.provider).toBe("openai");
+  });
+
+  test("dall-e-3 writes provider=openai", () => {
+    setImageGenModel("dall-e-3", makeCtx());
+
+    const config = readConfig();
+    const imageGen = (config.services as any)?.["image-generation"];
+    expect(imageGen?.model).toBe("dall-e-3");
+    expect(imageGen?.provider).toBe("openai");
+  });
+
+  test("switching from gemini to openai flips provider in place", () => {
+    setImageGenModel("gemini-3.1-flash-image-preview", makeCtx());
+    let imageGen = (readConfig().services as any)?.["image-generation"];
+    expect(imageGen?.provider).toBe("gemini");
+
+    setImageGenModel("gpt-image-2", makeCtx());
+    imageGen = (readConfig().services as any)?.["image-generation"];
+    expect(imageGen?.model).toBe("gpt-image-2");
+    expect(imageGen?.provider).toBe("openai");
+  });
+});

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

@@ -85,7 +85,7 @@ describe("AssistantConfigSchema", () => {
     // llm.default.{provider,model} (see PR 19 of unify-llm-callsites).
     expect(result.services.inference.mode).toBe("your-own");
     expect(result.llm.default.provider).toBe("anthropic");
-    expect(result.llm.default.model).toBe("claude-opus-4-7");
+    expect(result.llm.default.model).toBe("claude-sonnet-4-6");
     expect(result.services["image-generation"].provider).toBe("gemini");
     expect(result.services["image-generation"].model).toBe(
       "gemini-3.1-flash-image-preview",
@@ -170,7 +170,7 @@ describe("AssistantConfigSchema", () => {
     expect(result.llm).toBeDefined();
     expect(result.llm.default).toEqual({
       provider: "anthropic",
-      model: "claude-opus-4-7",
+      model: "claude-sonnet-4-6",
       maxTokens: 64000,
       effort: "max",
       speed: "standard",
@@ -305,7 +305,7 @@ describe("AssistantConfigSchema", () => {
       (result.services.inference as Record<string, unknown>).model,
     ).toBeUndefined();
     expect(result.llm.default.provider).toBe("anthropic");
-    expect(result.llm.default.model).toBe("claude-opus-4-7");
+    expect(result.llm.default.model).toBe("claude-sonnet-4-6");
   });
 
   test("partial llm config (empty `llm: {}`) doesn't trigger full config reset", () => {
@@ -320,7 +320,7 @@ describe("AssistantConfigSchema", () => {
     });
     expect(result.llm.default.maxTokens).toBe(32000);
     expect(result.llm.default.provider).toBe("anthropic");
-    expect(result.llm.default.model).toBe("claude-opus-4-7");
+    expect(result.llm.default.model).toBe("claude-sonnet-4-6");
   });
 
   test("llm.default with one missing field still parses (defaults applied)", () => {
@@ -748,11 +748,11 @@ describe("AssistantConfigSchema", () => {
     expect(result.permissions.autoApproveUpTo).toBe("medium");
   });
 
-  test("rejects autoApproveUpTo high", () => {
-    const result = AssistantConfigSchema.safeParse({
+  test("accepts autoApproveUpTo high", () => {
+    const result = AssistantConfigSchema.parse({
       permissions: { autoApproveUpTo: "high" },
     });
-    expect(result.success).toBe(false);
+    expect(result.permissions.autoApproveUpTo).toBe("high");
   });
 
   test("rejects invalid autoApproveUpTo string", () => {
@@ -804,12 +804,25 @@ describe("AssistantConfigSchema", () => {
   test("per-context object rejects invalid enum values", () => {
     const result = AssistantConfigSchema.safeParse({
       permissions: {
-        autoApproveUpTo: { conversation: "high" },
+        autoApproveUpTo: { conversation: "extreme" },
       },
     });
     expect(result.success).toBe(false);
   });
 
+  test("per-context object accepts high enum value", () => {
+    const result = AssistantConfigSchema.parse({
+      permissions: {
+        autoApproveUpTo: { conversation: "high" },
+      },
+    });
+    expect(result.permissions.autoApproveUpTo).toEqual({
+      conversation: "high",
+      background: "medium",
+      headless: "none",
+    });
+  });
+
   test("per-context object round-trips through JSON serialization", () => {
     const original = AssistantConfigSchema.parse({
       permissions: {
@@ -2254,7 +2267,7 @@ describe("loadConfig with schema validation", () => {
     writeConfig({});
     const config = loadConfig();
     expect(config.llm.default.provider).toBe("anthropic");
-    expect(config.llm.default.model).toBe("claude-opus-4-7");
+    expect(config.llm.default.model).toBe("claude-sonnet-4-6");
     expect(config.llm.default.maxTokens).toBe(64000);
     expect(config.llm.default.thinking).toEqual({
       enabled: true,

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

@@ -219,10 +219,6 @@ mock.module("../signals/mcp-reload.js", () => ({
   handleMcpReloadSignal: () => {},
 }));
 
-mock.module("../signals/shotgun.js", () => ({
-  handleShotgunSignal: () => {},
-}));
-
 mock.module("../signals/user-message.js", () => ({
   handleUserMessageSignal: () => {},
 }));

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

@@ -37,6 +37,32 @@ mock.module("../runtime/auth/token-service.js", () => ({
   mintEdgeRelayToken: () => "test-token",
 }));
 
+// contact-search now calls cliIpcCall instead of the gateway HTTP.
+// Mock the IPC client to dispatch search_contacts to the real store
+// (backed by the test DB) without needing a running IPC server.
+mock.module("../ipc/cli-client.js", () => ({
+  cliIpcCall: async (method: string, params?: Record<string, unknown>) => {
+    const store = await import("../contacts/contact-store.js");
+    if (method === "search_contacts") {
+      return { ok: true, result: store.searchContacts(params ?? {}) };
+    }
+    if (method === "upsert_contact") {
+      return { ok: true, result: store.upsertContact(params as never) };
+    }
+    if (method === "get_contact") {
+      return {
+        ok: true,
+        result: store.getContact((params as { id: string }).id) ?? null,
+      };
+    }
+    if (method === "merge_contacts") {
+      const { keepId, mergeId } = params as { keepId: string; mergeId: string };
+      return { ok: true, result: store.mergeContacts(keepId, mergeId) };
+    }
+    return { ok: false, error: `Unknown IPC method: ${method}` };
+  },
+}));
+
 import type { Database } from "bun:sqlite";
 
 import { executeContactMerge } from "../config/bundled-skills/contacts/tools/contact-merge.js";