@vellumai/assistant 0.8.8 → 0.8.9-staging.2

package/src/__tests__/conversation-workspace-tool-tracking.test.ts

@@ -141,7 +141,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   getMessageById: () => null,
   getLastUserTimestampBefore: () => 0,
   setLastNotifiedInferenceProfile: () => {},
-  getConversationOverrideProfileFromRow: () => undefined,
+  resolveOverrideProfile: () => undefined,
   updateMessageMetadata: () => {},
   reserveMessage: mock(async () => ({ id: "msg-reserve" })),
   updateMessageContent: mock(() => {}),
@@ -180,6 +180,7 @@ mock.module("../memory/retrieval-budget.js", () => ({
 }));
 mock.module("../context/window-manager.js", () => ({
   ContextWindowManager: class {
+    updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };
     }
@@ -228,10 +229,11 @@ mock.module("../agent/loop.js", () => ({
     getActiveModel() {
       return undefined;
     }
-    async run(
-      messages: Message[],
-      onEvent: (event: AgentEvent) => void,
-    ): Promise<Message[]> {
+    async run(options: {
+      messages: Message[];
+      onEvent: (event: AgentEvent) => void;
+    }): Promise<Message[]> {
+      const { messages, onEvent } = options;
       // Prime the assistant row anchor — production code emits this from
       // `AgentLoop.run` just before `provider.sendMessage`.
       await onEvent({ type: "llm_call_started" });
@@ -273,6 +275,7 @@ mock.module("../memory/canonical-guardian-store.js", () => ({
 }));
 
 import { Conversation } from "../daemon/conversation.js";
+import { refreshWorkspaceTopLevelContextIfNeeded } from "../daemon/conversation-workspace.js";
 
 function makeConversation(): Conversation {
   const provider = {
@@ -310,7 +313,7 @@ describe("Conversation workspace dirty on file mutations", () => {
     await conversation.loadFromDb();
 
     // Prime the cache so dirty=false
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     agentLoopScript = (onEvent) => {
@@ -339,7 +342,7 @@ describe("Conversation workspace dirty on file mutations", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     agentLoopScript = (onEvent) => {
@@ -370,7 +373,7 @@ describe("Conversation workspace dirty on file mutations", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     agentLoopScript = (onEvent) => {
@@ -399,7 +402,7 @@ describe("Conversation workspace dirty on file mutations", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     agentLoopScript = (onEvent) => {
@@ -428,7 +431,7 @@ describe("Conversation workspace dirty on file mutations", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     agentLoopScript = (onEvent) => {
@@ -457,7 +460,7 @@ describe("Conversation workspace dirty on file mutations", () => {
     const conversation = makeConversation();
     await conversation.loadFromDb();
 
-    conversation.refreshWorkspaceTopLevelContextIfNeeded();
+    refreshWorkspaceTopLevelContextIfNeeded(conversation);
     expect(conversation.isWorkspaceTopLevelDirty()).toBe(false);
 
     agentLoopScript = (onEvent) => {

package/src/__tests__/conversations-import-system-filter.test.ts

@@ -0,0 +1,101 @@
+/**
+ * Tests that the conversations import route never persists non-renderable
+ * roles. The messages store is UI-facing (`ConversationMessage`), so an
+ * imported export carrying agent-context `system` rows must land only its
+ * `user`/`assistant` turns — the `system` rows are dropped, not persisted.
+ */
+
+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 },
+  }),
+}));
+
+mock.module("../memory/indexer.js", () => ({
+  indexMessageNow: async () => {},
+}));
+
+import { getMessages } from "../memory/conversation-crud.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
+import { conversations, messages } from "../memory/schema.js";
+import { ROUTES } from "../runtime/routes/conversations-import-routes.js";
+import type { RouteHandlerArgs } from "../runtime/routes/types.js";
+
+initializeDb();
+
+function resetTables() {
+  const db = getDb();
+  db.run("DELETE FROM message_attachments");
+  db.run("DELETE FROM attachments");
+  db.run("DELETE FROM messages");
+  db.run("DELETE FROM conversation_keys");
+  db.run("DELETE FROM conversations");
+}
+
+const importHandler = ROUTES.find(
+  (r) => r.operationId === "conversations_import",
+)!.handler;
+
+describe("conversations import system-row filtering", () => {
+  beforeEach(resetTables);
+
+  test("imports renderable turns but drops system rows", async () => {
+    // GIVEN an export whose conversation sandwiches a system row between two
+    // renderable turns (e.g. agent-context scaffolding an export carried)
+    const body = {
+      conversations: [
+        {
+          sourceKey: "src-1",
+          title: "Imported chat",
+          messages: [
+            { role: "user", content: "first visible" },
+            { role: "system", content: "agent-context scaffolding" },
+            { role: "assistant", content: "second visible" },
+          ],
+        },
+      ],
+    };
+
+    // WHEN the conversation is imported
+    const result = (await importHandler({
+      body,
+    } as unknown as RouteHandlerArgs)) as {
+      ok: boolean;
+      imported: number;
+      messages: number;
+    };
+
+    // THEN the import succeeds and only counts the renderable turns
+    expect(result.ok).toBe(true);
+    expect(result.imported).toBe(1);
+    expect(result.messages).toBe(2);
+
+    // AND the persisted rows are exactly the user/assistant turns, never the
+    // system scaffolding
+    const db = getDb();
+    const conv = db.select().from(conversations).all()[0];
+    const rows = getMessages(conv.id);
+    expect(rows.map((m) => m.role)).toEqual(["user", "assistant"]);
+    expect(
+      db
+        .select()
+        .from(messages)
+        .all()
+        .some((m) => m.role === "system"),
+    ).toBe(false);
+  });
+});

package/src/__tests__/credential-security-invariants.test.ts

@@ -230,7 +230,6 @@ describe("Invariant 2: no generic plaintext secret read API", () => {
       "runtime/routes/platform-routes.ts", // CLI platform connect/disconnect/status routes (CLI-migrated to IPC)
       "ipc/skill-routes/providers.ts", // host.providers.secureKeys.getProviderKey IPC route (out-of-process SkillHost companion)
       "daemon/external-plugins-bootstrap.ts", // reads credentials at plugin init (manifest.requiresCredential) via the CES-mediated getSecureKeyAsync path
-      "plugins/external-api.ts", // globalThis runtime bridge that exposes getSecureKeyAsync to dynamically-imported workspace plugins (compiled-binary plugin loading)
       "inbound/platform-callback-registration.ts", // managed credential lookup for platform base URL, assistant ID, and API key
       "tts/providers/elevenlabs-provider.ts", // ElevenLabs TTS API key lookup
       "tts/providers/deepgram-provider.ts", // Deepgram TTS API key lookup

package/src/__tests__/db-acp-history.test.ts

@@ -5,6 +5,7 @@ import { drizzle } from "drizzle-orm/bun-sqlite";
 
 import { getSqliteFrom } from "../memory/db-connection.js";
 import { migrate230AcpSessionHistory } from "../memory/migrations/230-acp-session-history.js";
+import { migrateAcpSessionHistoryCwd } from "../memory/migrations/272-acp-session-history-cwd.js";
 import * as schema from "../memory/schema.js";
 
 function createTestDb() {
@@ -282,3 +283,103 @@ describe("acp_session_history migration", () => {
     expect(row?.id).toBe("history-rerun");
   });
 });
+
+describe("acp_session_history cwd migration (272)", () => {
+  function readColumns(raw: Database): Map<string, ColumnRow> {
+    const columns = raw
+      .query(`PRAGMA table_info(acp_session_history)`)
+      .all() as ColumnRow[];
+    return new Map(columns.map((c) => [c.name, c]));
+  }
+
+  test("adds a nullable cwd TEXT column to an upgraded table", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+
+    migrate230AcpSessionHistory(db);
+    expect(readColumns(raw).has("cwd")).toBe(false);
+
+    migrateAcpSessionHistoryCwd(db);
+
+    const cwd = readColumns(raw).get("cwd");
+    expect(cwd).toBeDefined();
+    expect(cwd?.type).toBe("TEXT");
+    expect(cwd?.notnull).toBe(0);
+  });
+
+  test("re-running is a no-op, including with a cleared checkpoint", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+
+    migrate230AcpSessionHistory(db);
+    migrateAcpSessionHistoryCwd(db);
+
+    // Second run short-circuits on the completed checkpoint.
+    expect(() => migrateAcpSessionHistoryCwd(db)).not.toThrow();
+
+    // Even with the checkpoint cleared (simulating crash recovery), the
+    // column-existence guard makes the ALTER a no-op.
+    raw
+      .query(`DELETE FROM memory_checkpoints WHERE key = ?`)
+      .run("migration_acp_session_history_cwd_v1");
+    expect(() => migrateAcpSessionHistoryCwd(db)).not.toThrow();
+
+    const columns = raw
+      .query(`PRAGMA table_info(acp_session_history)`)
+      .all() as ColumnRow[];
+    expect(columns.filter((c) => c.name === "cwd")).toHaveLength(1);
+  });
+
+  test("legacy rows read back with cwd null; new rows round-trip cwd", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+
+    migrate230AcpSessionHistory(db);
+
+    // Legacy row inserted before the cwd column existed.
+    raw
+      .query(
+        /*sql*/ `
+        INSERT INTO acp_session_history (
+          id, agent_id, acp_session_id, parent_conversation_id,
+          started_at, status
+        ) VALUES (?, ?, ?, ?, ?, ?)
+      `,
+      )
+      .run("legacy-1", "agent-old", "acp-old", "conv-old", 100, "completed");
+
+    migrateAcpSessionHistoryCwd(db);
+
+    const legacy = raw
+      .query(`SELECT cwd FROM acp_session_history WHERE id = 'legacy-1'`)
+      .get() as { cwd: string | null } | null;
+    expect(legacy?.cwd).toBeNull();
+
+    raw
+      .query(
+        /*sql*/ `
+        INSERT INTO acp_session_history (
+          id, agent_id, acp_session_id, parent_conversation_id,
+          started_at, status, cwd
+        ) VALUES (?, ?, ?, ?, ?, ?, ?)
+      `,
+      )
+      .run(
+        "new-1",
+        "agent-new",
+        "acp-new",
+        "conv-new",
+        200,
+        "completed",
+        "/Users/me/project",
+      );
+
+    const fresh = raw
+      .query(`SELECT cwd FROM acp_session_history WHERE id = 'new-1'`)
+      .get() as { cwd: string | null } | null;
+    expect(fresh?.cwd).toBe("/Users/me/project");
+  });
+});

package/src/__tests__/dynamic-page-surface.test.ts

@@ -94,6 +94,37 @@ describe("ui_show dynamic_page app substitute guard", () => {
     expect(proxied).toBe(false);
   });
 
+  test("rejects dynamic_page with a clean title but substantial interactive html", async () => {
+    let proxied = false;
+
+    const result = await uiShowTool.execute(
+      {
+        surface_type: "dynamic_page",
+        title: "Labor Market Stats",
+        data: {
+          html:
+            "<div id='root'></div><script>" +
+            "const data=[/*...*/];".padEnd(2100, "/") +
+            "new Chart(document.getElementById('root'), {});</script>",
+          preview: { title: "Labor Market Stats" },
+        },
+      },
+      {
+        conversationId: "conversation-123",
+        workingDir: "/tmp",
+        trustClass: "guardian",
+        proxyToolResolver: async () => {
+          proxied = true;
+          return { content: "proxied", isError: false };
+        },
+      },
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('skill: "app-builder"');
+    expect(proxied).toBe(false);
+  });
+
   test("allows transient non-app dynamic_page surfaces", async () => {
     let proxied = false;
 

package/src/__tests__/empty-response-hook.test.ts

@@ -31,7 +31,7 @@ import {
   REFUSAL_NUDGE_TEXT,
 } from "../plugins/defaults/empty-response/hooks/stop.js";
 import stop from "../plugins/defaults/empty-response/hooks/stop.js";
-import { defaultEmptyResponsePlugin } from "../plugins/defaults/empty-response/register.js";
+import { defaultEmptyResponsePlugin } from "../plugins/defaults/index.js";
 import { runHook } from "../plugins/pipeline.js";
 import {
   registerPlugin,

package/src/__tests__/file-write-tool.test.ts

@@ -260,3 +260,66 @@ describe("file_write tool PKB re-index hook", () => {
     expect(existsSync(join(workingDir, "pkb", "oops.md"))).toBe(true);
   });
 });
+
+describe("file_write artifact-HTML guard", () => {
+  test("rejects a self-contained interactive HTML visualization", async () => {
+    const dir = makeTempDir();
+    const html =
+      "<!doctype html><html><head><title>Food Market</title></head>" +
+      "<body><canvas id='c'></canvas><script>" +
+      ("const data=[{x:1,y:2}];").padEnd(4000, "/") +
+      "new Chart(document.getElementById('c'), {data});</script></body></html>";
+
+    const result = await fileWriteTool.execute(
+      { path: "food-market-stats.html", content: html },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('skill: "app-builder"');
+    expect(existsSync(join(dir, "food-market-stats.html"))).toBe(false);
+  });
+
+  test("allows app-builder's thin shell index.html (external module script)", async () => {
+    const dir = makeTempDir();
+    const shell =
+      "<!doctype html><html><head>" +
+      "<link rel='stylesheet' href='/src/styles.css'>".padEnd(3200, " ") +
+      "</head><body><div id='app'></div>" +
+      "<script type='module' src='/src/main.tsx'></script></body></html>";
+
+    const result = await fileWriteTool.execute(
+      { path: "src/index.html", content: shell },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(existsSync(join(dir, "src", "index.html"))).toBe(true);
+  });
+
+  test("allows a small/static HTML snippet", async () => {
+    const dir = makeTempDir();
+    const result = await fileWriteTool.execute(
+      { path: "note.html", content: "<html><body><h1>Hi</h1></body></html>" },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(existsSync(join(dir, "note.html"))).toBe(true);
+  });
+
+  test("allows a non-HTML file even with inline script-like content", async () => {
+    const dir = makeTempDir();
+    const result = await fileWriteTool.execute(
+      {
+        path: "notes.md",
+        content:
+          "<script>" + "x".padEnd(2000, "x") + "</script>" + "\n# notes\n",
+      },
+      makeContext(dir),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(existsSync(join(dir, "notes.md"))).toBe(true);
+  });
+});

package/src/__tests__/gateway-only-guard.test.ts

@@ -27,6 +27,7 @@ const ALLOWLIST = new Set([
   "clients/shared/App/Auth/PlatformOAuthService.swift", // comment explaining runtimeUrl vs platformUrl
   "clients/macos/vellum-assistant/App/AppDelegate.swift",
   "clients/macos/vellum-assistant/Features/Settings/SettingsConnectTab.swift",
+  "apps/macos/src/main/bundle-flow.ts", // Electron main calls the local gateway (gatewayPort) with a Guardian token to scan bundles
   ".claude/skills/update/SKILL.md", // daemon health check script
 
   // --- Test fixtures that poll the daemon directly (gateway may require auth) ---
@@ -84,12 +85,21 @@ function isGatewayInternal(filePath: string): boolean {
   return filePath.startsWith("gateway/");
 }
 
+/** Additional files allowed for the interpolated-port check only (use gateway port, not runtime). */
+const INTERPOLATED_PORT_ALLOWLIST = new Set([
+  "apps/macos/src/main/bundle-flow.ts",
+]);
+
 /** Shared violation filter: exempt test files, gateway internals, and allowlisted paths. */
-function filterViolations(files: string[]): string[] {
+function filterViolations(
+  files: string[],
+  extraAllowlist?: Set<string>,
+): string[] {
   return files.filter((f) => {
     if (isTestFile(f)) return false;
     if (isGatewayInternal(f)) return false;
     if (ALLOWLIST.has(f)) return false;
+    if (extraAllowlist?.has(f)) return false;
     return true;
   });
 }
@@ -181,7 +191,7 @@ describe("gateway-only API consumption guard", () => {
     }
 
     const files = grepOutput.split("\n").filter((f) => f.length > 0);
-    const violations = filterViolations(files);
+    const violations = filterViolations(files, INTERPOLATED_PORT_ALLOWLIST);
 
     if (violations.length > 0) {
       const message = [

package/src/__tests__/guardian-grant-minting.test.ts

@@ -20,7 +20,7 @@ mock.module("../util/logger.js", () => ({
 }));
 
 const _conversationMocks = new Map<string, unknown>();
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => _conversationMocks.get(id),
 }));
 

package/src/__tests__/guardian-routing-invariants.test.ts

@@ -21,7 +21,7 @@ import { beforeEach, describe, expect, mock, test } from "bun:test";
 mock.module("../config/env.js", () => ({ isHttpAuthDisabled: () => true }));
 
 const _conversationMocks = new Map<string, unknown>();
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => _conversationMocks.get(id),
 }));
 
@@ -51,9 +51,7 @@ import {
   routeGuardianReply,
 } from "../runtime/guardian-reply-router.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
-import {
-  listGuardianDecisionPrompts,
-} from "../runtime/routes/guardian-action-routes.js";
+import { listGuardianDecisionPrompts } from "../runtime/routes/guardian-action-routes.js";
 
 initializeDb();
 

package/src/__tests__/handlers-user-message-approval-consumption.test.ts

@@ -143,7 +143,7 @@ mock.module("../util/logger.js", () => ({
 import {
   clearConversations,
   setConversation,
-} from "../daemon/conversation-store.js";
+} from "../daemon/conversation-registry.js";
 import { handleConfirmationResponse } from "../daemon/handlers/conversations.js";
 
 describe("handleConfirmationResponse canonical status sync", () => {

package/src/__tests__/heartbeat-disk-pressure.test.ts

@@ -56,6 +56,7 @@ mock.module("../heartbeat/heartbeat-run-store.js", () => ({
   markStaleRunsAsMissed: mockMarkStaleRunsAsMissed,
   markStaleRunningAsError: mockMarkStaleRunningAsError,
   countCompletedHeartbeatRuns: mock(() => 10),
+  countCompletedRunsToday: mock(() => 0),
   countRecentConsecutiveRuns: mock(() => 0),
 }));
 

package/src/__tests__/heartbeat-service.test.ts

@@ -32,6 +32,7 @@ mock.module("../heartbeat/heartbeat-run-store.js", () => ({
   markStaleRunningAsError: mockMarkStaleRunningAsError,
   listHeartbeatRuns: mockListHeartbeatRuns,
   countCompletedHeartbeatRuns: mockCountCompletedHeartbeatRuns,
+  countCompletedRunsToday: mock(() => 0),
   countRecentConsecutiveRuns: mock(() => 0),
 }));
 

package/src/__tests__/history-repair-hook.test.ts

@@ -21,8 +21,8 @@ import type {
   UserPromptSubmitContext,
 } from "../plugin-api/types.js";
 import userPromptSubmit from "../plugins/defaults/history-repair/hooks/user-prompt-submit.js";
-import { defaultHistoryRepairPlugin } from "../plugins/defaults/history-repair/register.js";
 import { repairHistory } from "../plugins/defaults/history-repair/terminal.js";
+import { defaultHistoryRepairPlugin } from "../plugins/defaults/index.js";
 import { runHook } from "../plugins/pipeline.js";
 import {
   registerPlugin,

package/src/__tests__/host-app-control-routes.test.ts

@@ -47,7 +47,7 @@ interface FakeConversation {
 
 const conversations = new Map<string, FakeConversation>();
 
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (id: string) => conversations.get(id),
 }));
 

package/src/__tests__/host-cu-routes-targeted.test.ts

@@ -8,9 +8,9 @@
  *  4. Untargeted (no targetClientId, no header) → 200 accepted (regression)
  *
  * Resolution goes through conversation.hostCuProxy?.resolve(...). The
- * conversation store is mocked to return a controlled conversation object.
+ * conversation registry is mocked to return a controlled conversation object.
  *
- * Note: host-cu-routes.ts has a deep import chain (conversation-store →
+ * Note: host-cu-routes.ts has a deep import chain (conversation-registry →
  * conversation.ts → ces-client → service-contracts) that requires mocking
  * before the module loads. We use dynamic imports to ensure all mocks are
  * registered before the route module is evaluated.
@@ -75,7 +75,7 @@ const conversationStore = new Map<
   { hostCuProxy?: { processObservation: (...args: unknown[]) => void } }
 >();
 
-mock.module("../daemon/conversation-store.js", () => ({
+mock.module("../daemon/conversation-registry.js", () => ({
   findConversation: (conversationId: string) =>
     conversationStore.get(conversationId),
 }));

package/src/__tests__/inference-profile-reaper.test.ts

@@ -7,6 +7,11 @@ mock.module("../util/logger.js", () => ({
   getLogger: () => makeMockLogger(),
 }));
 
+import type { Conversation } from "../daemon/conversation.js";
+import {
+  deleteConversation,
+  setConversation,
+} from "../daemon/conversation-registry.js";
 import {
   createConversation,
   getConversation,
@@ -113,6 +118,63 @@ describe("inference-profile-session-reaper", () => {
     subscription.dispose();
   });
 
+  test("syncs the live in-memory Conversation instance for each cleared session", async () => {
+    // GIVEN an expired session-backed override persisted on a conversation row
+    const conv = createConversation("reaper-live-sync");
+    setConversationInferenceProfileSession(
+      conv.id,
+      "balanced",
+      "session-live",
+      Date.now() - 1,
+    );
+
+    // AND a live Conversation instance registered for that conversation,
+    // seeded with the same override state the reaper is about to expire
+    const appliedStates: Array<{
+      profile: string | null;
+      sessionId: string | null;
+      expiresAt: number | null;
+    }> = [];
+    const liveConversation = {
+      conversationId: conv.id,
+      inferenceProfile: "balanced",
+      inferenceProfileSessionId: "session-live",
+      inferenceProfileExpiresAt: Date.now() - 1,
+      applyInferenceProfileState(
+        this: {
+          inferenceProfile: string | null;
+          inferenceProfileSessionId: string | null;
+          inferenceProfileExpiresAt: number | null;
+        },
+        state: {
+          profile: string | null;
+          sessionId: string | null;
+          expiresAt: number | null;
+        },
+      ) {
+        appliedStates.push(state);
+        this.inferenceProfile = state.profile;
+        this.inferenceProfileSessionId = state.sessionId;
+        this.inferenceProfileExpiresAt = state.expiresAt;
+      },
+    } as unknown as Conversation;
+    setConversation(conv.id, liveConversation);
+
+    // WHEN the reaper sweeps the expired session
+    tickInferenceProfileReaper();
+
+    // THEN the live instance is cleared in lock-step with the DB row, so the
+    // per-turn override derivation reads the cleared state without re-fetching
+    expect(appliedStates).toEqual([
+      { profile: null, sessionId: null, expiresAt: null },
+    ]);
+    expect(liveConversation.inferenceProfile).toBeNull();
+    expect(liveConversation.inferenceProfileSessionId).toBeNull();
+    expect(liveConversation.inferenceProfileExpiresAt).toBeNull();
+
+    deleteConversation(conv.id);
+  });
+
   test("CAS protection: row with NULL expiresAt (sticky override) is not touched", async () => {
     const conv = createConversation("reaper-cas-conv");