@vellumai/assistant 0.8.9-staging.1 → 0.8.9-staging.2

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

@@ -39,6 +39,20 @@ const conversationRuntimeAssemblyRealSnapshot = {
 
 // ── 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 overflow 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: () => () => {} }),
@@ -137,35 +151,38 @@ mock.module("../context/token-estimator.js", () => ({
 let mockReducerStepFn:
   | ((msgs: Message[], cfg: unknown, state: unknown) => unknown)
   | null = null;
-mock.module("../daemon/context-overflow-reducer.js", () => ({
-  createInitialReducerState: () => ({
-    appliedTiers: [],
-    injectionMode: "full" as const,
-    exhausted: false,
+mock.module(
+  "../plugins/defaults/compaction/context-overflow-reducer.js",
+  () => ({
+    createInitialReducerState: () => ({
+      appliedTiers: [],
+      injectionMode: "full" as const,
+      exhausted: false,
+    }),
+    reduceContextOverflow: async (
+      msgs: Message[],
+      cfg: unknown,
+      state: unknown,
+    ) => {
+      if (mockReducerStepFn) return mockReducerStepFn(msgs, cfg, state);
+      return {
+        messages: msgs,
+        tier: "forced_compaction",
+        state: {
+          appliedTiers: [
+            "forced_compaction",
+            "tool_result_truncation",
+            "media_stubbing",
+            "injection_downgrade",
+          ],
+          injectionMode: "full",
+          exhausted: true,
+        },
+        estimatedTokens: 1000,
+      };
+    },
   }),
-  reduceContextOverflow: async (
-    msgs: Message[],
-    cfg: unknown,
-    state: unknown,
-  ) => {
-    if (mockReducerStepFn) return mockReducerStepFn(msgs, cfg, state);
-    return {
-      messages: msgs,
-      tier: "forced_compaction",
-      state: {
-        appliedTiers: [
-          "forced_compaction",
-          "tool_result_truncation",
-          "media_stubbing",
-          "injection_downgrade",
-        ],
-        injectionMode: "full",
-        exhausted: true,
-      },
-      estimatedTokens: 1000,
-    };
-  },
-}));
+);
 
 // Policy: default to fail_gracefully
 let mockOverflowAction: string = "fail_gracefully";
@@ -471,7 +488,7 @@ function makeCtx(
     toolExecutor,
   });
 
-  return {
+  const ctx = {
     conversationId: "test-conv",
     messages: [
       { role: "user", content: [{ type: "text", text: "Hello" }] },
@@ -582,6 +599,8 @@ function makeCtx(
 
     ...ctxOverrides,
   } as unknown as Conversation;
+  fakeContextWindowManagers.set(conversationId, ctx.contextWindowManager);
+  return ctx;
 }
 
 /**

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

@@ -28,6 +28,20 @@ let mockUiConfig: { userTimezone?: string; detectedTimezone?: string } = {};
 
 // ── 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: () => () => {} }),
@@ -100,35 +114,38 @@ mock.module("../context/token-estimator.js", () => ({
 let mockReducerStepFn:
   | ((msgs: Message[], cfg: unknown, state: unknown) => unknown)
   | null = null;
-mock.module("../daemon/context-overflow-reducer.js", () => ({
-  createInitialReducerState: () => ({
-    appliedTiers: [],
-    injectionMode: "full" as const,
-    exhausted: false,
+mock.module(
+  "../plugins/defaults/compaction/context-overflow-reducer.js",
+  () => ({
+    createInitialReducerState: () => ({
+      appliedTiers: [],
+      injectionMode: "full" as const,
+      exhausted: false,
+    }),
+    reduceContextOverflow: async (
+      msgs: Message[],
+      cfg: unknown,
+      state: unknown,
+    ) => {
+      if (mockReducerStepFn) return mockReducerStepFn(msgs, cfg, state);
+      return {
+        messages: msgs,
+        tier: "forced_compaction",
+        state: {
+          appliedTiers: [
+            "forced_compaction",
+            "tool_result_truncation",
+            "media_stubbing",
+            "injection_downgrade",
+          ],
+          injectionMode: "full",
+          exhausted: true,
+        },
+        estimatedTokens: 1000,
+      };
+    },
   }),
-  reduceContextOverflow: async (
-    msgs: Message[],
-    cfg: unknown,
-    state: unknown,
-  ) => {
-    if (mockReducerStepFn) return mockReducerStepFn(msgs, cfg, state);
-    return {
-      messages: msgs,
-      tier: "forced_compaction",
-      state: {
-        appliedTiers: [
-          "forced_compaction",
-          "tool_result_truncation",
-          "media_stubbing",
-          "injection_downgrade",
-        ],
-        injectionMode: "full",
-        exhausted: true,
-      },
-      estimatedTokens: 1000,
-    };
-  },
-}));
+);
 
 // Policy: default to fail_gracefully
 let mockOverflowAction: string = "fail_gracefully";
@@ -520,17 +537,6 @@ mock.module("../memory/llm-request-log-store.js", () => ({
   setAgentLoopExitReasonOnLatestLog: setAgentLoopExitReasonOnLatestLogMock,
 }));
 
-let mockHasProactiveArtifactCompleted = true;
-let mockTryClaimProactiveArtifactTrigger = false;
-const runProactiveArtifactJobMock = mock(
-  async (_params: Record<string, unknown>) => {},
-);
-mock.module("../proactive-artifact/index.js", () => ({
-  hasProactiveArtifactCompleted: () => mockHasProactiveArtifactCompleted,
-  tryClaimProactiveArtifactTrigger: () => mockTryClaimProactiveArtifactTrigger,
-  runProactiveArtifactJob: runProactiveArtifactJobMock,
-}));
-
 // ── Imports (after mocks) ────────────────────────────────────────────
 
 import { AgentLoop } from "../agent/loop.js";
@@ -594,7 +600,7 @@ function makeCtx(
     toolExecutor,
   });
 
-  return {
+  const ctx = {
     conversationId: "test-conv",
     messages: [
       { role: "user", content: [{ type: "text", text: "Hello" }] },
@@ -710,6 +716,8 @@ function makeCtx(
 
     ...ctxOverrides,
   } as unknown as Conversation;
+  fakeContextWindowManagers.set(conversationId, ctx.contextWindowManager);
+  return ctx;
 }
 
 type CompactionResult = Parameters<typeof applyCompactionResult>[1];
@@ -765,9 +773,6 @@ beforeEach(() => {
     title: null,
   };
   mockMessageById = null;
-  mockHasProactiveArtifactCompleted = true;
-  mockTryClaimProactiveArtifactTrigger = false;
-  runProactiveArtifactJobMock.mockClear();
   setConversationHistoryStrippedAtMock.mockClear();
   setConversationHistoryStrippedAtMock.mockImplementation(() => {});
   applyRuntimeInjectionsMock.mockClear();
@@ -862,59 +867,6 @@ describe("session-agent-loop", () => {
     });
   });
 
-  describe("proactive artifact trigger", () => {
-    test("does not start proactive artifact jobs after foreground user turns", async () => {
-      mockConversationRow = {
-        ...mockConversationRow,
-        id: "test-conv",
-        conversationType: "standard",
-      };
-      mockMessageById = {
-        id: "user-msg-1",
-        conversationId: "test-conv",
-        createdAt: 1000,
-      };
-      mockHasProactiveArtifactCompleted = false;
-      mockTryClaimProactiveArtifactTrigger = true;
-
-      // A two-call agent turn: the model invokes `app_create`, then wraps up
-      // with a final text reply.
-      const ctx = makeCtx({
-        conversationId: "test-conv",
-        providerResponses: [
-          {
-            content: [
-              { type: "text", text: "I'll build that app." },
-              {
-                type: "tool_use",
-                id: "tool-1",
-                name: "app_create",
-                input: { name: "Flow" },
-              },
-            ],
-            model: "mock-model",
-            usage: { inputTokens: 10, outputTokens: 5 },
-            stopReason: "tool_use",
-          },
-          textResponse("Done."),
-        ],
-        toolExecutor: async () => ({ content: "{}", isError: false }),
-      });
-      await runAgentLoopImpl(
-        ctx,
-        "build a kanban app",
-        "user-msg-1",
-        () => {},
-        {
-          isUserMessage: true,
-        },
-      );
-      await new Promise((resolve) => setTimeout(resolve, 0));
-
-      expect(runProactiveArtifactJobMock).toHaveBeenCalledTimes(0);
-    });
-  });
-
   describe("disk pressure injection context", () => {
     // The loop sets `ctx.diskPressureCleanupModeActive` for the duration of the
     // turn (the disk-pressure-warning injector reads it via the per-conversation

package/src/__tests__/conversation-history-web-search.test.ts

@@ -807,7 +807,7 @@ describe("web_search_tool_result structural guard", () => {
     // Media token counting iterates tool_result.contentBlocks for nested
     // image/file blocks. web_search_tool_result has opaque content with no
     // contentBlocks property, so it cannot contain nested media.
-    "daemon/context-overflow-reducer.ts",
+    "plugins/defaults/compaction/context-overflow-reducer.ts",
 
     // Final orphan-pair safety pass in the Slack transcript renderer.
     // Server-side block types (`server_tool_use`, `web_search_tool_result`)

package/src/__tests__/conversation-provider-retry-repair.test.ts

@@ -100,56 +100,59 @@ mock.module("../context/token-estimator.js", () => ({
 // but these tests exercise the Conversation-level flow, not the reducer internals.
 // The reducer mock delegates to the compactFn to simulate a forced compaction
 // tier, matching the real reducer's behavior for Tier 1.
-mock.module("../daemon/context-overflow-reducer.js", () => ({
-  createInitialReducerState: () => ({
-    appliedTiers: [],
-    injectionMode: "full" as const,
-    exhausted: false,
-  }),
-  reduceContextOverflow: async (
-    msgs: Message[],
-    _cfg: unknown,
-    _state: unknown,
-    compactFn?: (
-      m: Message[],
-      s: AbortSignal | undefined,
-      o: Record<string, unknown>,
-    ) => Promise<{
-      compacted: boolean;
-      messages: Message[];
-      compactedPersistedMessages?: number;
-      summaryText?: string;
-      [k: string]: unknown;
-    }>,
-    signal?: AbortSignal,
-  ) => {
-    let resultMessages = msgs;
-    let compactionResult;
-    if (compactFn) {
-      const cr = await compactFn(msgs, signal, { force: true });
-      if (cr.compacted) {
-        resultMessages = cr.messages;
-        compactionResult = cr;
+mock.module(
+  "../plugins/defaults/compaction/context-overflow-reducer.js",
+  () => ({
+    createInitialReducerState: () => ({
+      appliedTiers: [],
+      injectionMode: "full" as const,
+      exhausted: false,
+    }),
+    reduceContextOverflow: async (
+      msgs: Message[],
+      _cfg: unknown,
+      _state: unknown,
+      compactFn?: (
+        m: Message[],
+        s: AbortSignal | undefined,
+        o: Record<string, unknown>,
+      ) => Promise<{
+        compacted: boolean;
+        messages: Message[];
+        compactedPersistedMessages?: number;
+        summaryText?: string;
+        [k: string]: unknown;
+      }>,
+      signal?: AbortSignal,
+    ) => {
+      let resultMessages = msgs;
+      let compactionResult;
+      if (compactFn) {
+        const cr = await compactFn(msgs, signal, { force: true });
+        if (cr.compacted) {
+          resultMessages = cr.messages;
+          compactionResult = cr;
+        }
       }
-    }
-    return {
-      messages: resultMessages,
-      tier: "forced_compaction",
-      state: {
-        appliedTiers: [
-          "forced_compaction",
-          "tool_result_truncation",
-          "media_stubbing",
-          "injection_downgrade",
-        ],
-        injectionMode: "full",
-        exhausted: true,
-      },
-      estimatedTokens: 1000,
-      compactionResult,
-    };
-  },
-}));
+      return {
+        messages: resultMessages,
+        tier: "forced_compaction",
+        state: {
+          appliedTiers: [
+            "forced_compaction",
+            "tool_result_truncation",
+            "media_stubbing",
+            "injection_downgrade",
+          ],
+          injectionMode: "full",
+          exhausted: true,
+        },
+        estimatedTokens: 1000,
+        compactionResult,
+      };
+    },
+  }),
+);
 
 mock.module("../daemon/context-overflow-policy.js", () => ({
   resolveOverflowAction: () => "fail_gracefully",

package/src/__tests__/memory-retrieval-hook.test.ts

@@ -6,10 +6,11 @@
  * metadata, recall log, `memory_recalled` event), trust gating, the runtime
  * injection the hook applies for every actor (and the assembled-block persist),
  * error propagation, and abort-signal forwarding. Uses `mock.module` to stub
- * the persistence helpers and `applyRuntimeInjections` so the test doesn't touch
- * the developer's real `~/.vellum`, database, or live conversation state. The
- * memory graph handle is a hand-rolled fake passed on the hook context — the
- * hook only needs `prepareMemory`.
+ * the persistence helpers, `applyRuntimeInjections`, and the conversation
+ * registry / trust resolver so the test doesn't touch the developer's real
+ * `~/.vellum`, database, or live conversation state. The memory graph handle,
+ * abort signal, and trust class are self-resolved by the hook from a fake
+ * conversation installed in the registry mock.
  */
 
 import { beforeEach, describe, expect, mock, test } from "bun:test";
@@ -37,7 +38,25 @@ mock.module("../daemon/conversation-runtime-assembly.js", () => ({
   applyRuntimeInjections: applyRuntimeInjectionsMock,
 }));
 
+// The hook self-resolves the live conversation and its trust class; both are
+// driven from these refs so each test controls what the hook sees.
+let currentConversation: Conversation | undefined;
+let currentTrustClass: "guardian" | "unknown" = "guardian";
+const findConversationOrSubagentMock = mock(
+  (_conversationId?: string) => currentConversation,
+);
+mock.module("../daemon/conversation-registry.js", () => ({
+  findConversationOrSubagent: findConversationOrSubagentMock,
+}));
+mock.module("../daemon/trust-context.js", () => ({
+  resolveTrustClass: () => currentTrustClass,
+}));
+mock.module("../config/loader.js", () => ({
+  getConfig: () => ({}) as AssistantConfig,
+}));
+
 import type { AssistantConfig } from "../config/schema.js";
+import type { Conversation } from "../daemon/conversation.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
 import type { QdrantSparseVector } from "../memory/qdrant-client.js";
@@ -118,18 +137,13 @@ function makeFakeGraphMemory(overrides?: {
 function makeHookCtx(
   overrides: Partial<MemoryRetrievalHookContext> = {},
 ): MemoryRetrievalHookContext {
-  const { memory } = makeFakeGraphMemory();
   return {
-    graphMemory: memory,
-    config: {} as AssistantConfig,
     onEvent: () => {},
-    isTrustedActor: true,
     conversationId: "conv-test",
     userMessageId: "msg-test",
     logger: {
       warn: () => {},
     } as unknown as MemoryRetrievalHookContext["logger"],
-    signal: new AbortController().signal,
     latestMessages: [],
     requestId: "req-test",
     mode: "full",
@@ -140,10 +154,30 @@ function makeHookCtx(
   };
 }
 
+/**
+ * Install a fake live conversation for the hook to self-resolve by id: the
+ * graph handle, abort signal, and trust class all come from here rather than
+ * the hook context.
+ */
+function installConversation(
+  graphMemory: ConversationGraphMemory,
+  opts?: { trusted?: boolean; signal?: AbortSignal },
+): void {
+  currentTrustClass = opts?.trusted === false ? "unknown" : "guardian";
+  currentConversation = {
+    graphMemory,
+    trustContext: undefined,
+    abortController: { signal: opts?.signal ?? new AbortController().signal },
+  } as unknown as Conversation;
+}
+
 beforeEach(() => {
   updateMessageMetadataMock.mockReset();
   recordMemoryRecallLogMock.mockReset();
   applyRuntimeInjectionsMock.mockClear();
+  findConversationOrSubagentMock.mockClear();
+  currentConversation = undefined;
+  currentTrustClass = "guardian";
 });
 
 describe("user-prompt-submit-temp hook (memory retrieval)", () => {
@@ -154,7 +188,8 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
     const { memory, prepareMemoryMock } = makeFakeGraphMemory({
       messages: injected,
     });
-    const ctx = makeHookCtx({ graphMemory: memory, isTrustedActor: true });
+    installConversation(memory, { trusted: true });
+    const ctx = makeHookCtx();
 
     await userPromptSubmitMemoryRetrieval(ctx);
 
@@ -176,7 +211,8 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
       userQueryVector: userDense,
       userQuerySparseVector: userSparse,
     });
-    const userCtx = makeHookCtx({ graphMemory: withUserQuery.memory });
+    installConversation(withUserQuery.memory, { trusted: true });
+    const userCtx = makeHookCtx();
     await userPromptSubmitMemoryRetrieval(userCtx);
     // User-query pair wins — never crossed with the summary signal — and is
     // recorded back onto the graph handle for the PKB-reminder injector.
@@ -189,7 +225,8 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
       queryVector: summaryDense,
       sparseVector: summarySparse,
     });
-    const summaryCtx = makeHookCtx({ graphMemory: summaryOnly.memory });
+    installConversation(summaryOnly.memory, { trusted: true });
+    const summaryCtx = makeHookCtx();
     await userPromptSubmitMemoryRetrieval(summaryCtx);
     expect(summaryOnly.recordPkbQueryVectorsMock).toHaveBeenCalledWith(
       summaryDense,
@@ -209,7 +246,8 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
       messages: injected,
       blocks: { unifiedTurnContext: "tc-block" },
     }));
-    const ctx = makeHookCtx({ graphMemory: memory, userMessageId: "msg-77" });
+    installConversation(memory, { trusted: true });
+    const ctx = makeHookCtx({ userMessageId: "msg-77" });
 
     await userPromptSubmitMemoryRetrieval(ctx);
 
@@ -229,11 +267,8 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
     const seeded: Message[] = [
       { role: "user", content: [{ type: "text", text: "seeded" }] },
     ];
-    const ctx = makeHookCtx({
-      graphMemory: memory,
-      isTrustedActor: false,
-      latestMessages: seeded,
-    });
+    installConversation(memory, { trusted: false });
+    const ctx = makeHookCtx({ latestMessages: seeded });
 
     await userPromptSubmitMemoryRetrieval(ctx);
 
@@ -250,11 +285,8 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
     const seeded: Message[] = [
       { role: "user", content: [{ type: "text", text: "seeded" }] },
     ];
-    const ctx = makeHookCtx({
-      graphMemory: memory,
-      isTrustedActor: false,
-      latestMessages: seeded,
-    });
+    installConversation(memory, { trusted: false });
+    const ctx = makeHookCtx({ latestMessages: seeded });
 
     await userPromptSubmitMemoryRetrieval(ctx);
 
@@ -273,8 +305,8 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
       injectedBlockText: "injected-block",
       metrics: makeMetrics(),
     });
+    installConversation(memory, { trusted: true });
     const ctx = makeHookCtx({
-      graphMemory: memory,
       onEvent: (msg) => received.push(msg),
       userMessageId: "msg-42",
       conversationId: "conv-42",
@@ -298,7 +330,8 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
 
   test("skips metadata persist when no block text is injected", async () => {
     const { memory } = makeFakeGraphMemory({ injectedBlockText: null });
-    const ctx = makeHookCtx({ graphMemory: memory });
+    installConversation(memory, { trusted: true });
+    const ctx = makeHookCtx();
 
     await userPromptSubmitMemoryRetrieval(ctx);
 
@@ -321,16 +354,17 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
     const graphMemory = {
       prepareMemory: failingPrepare,
     } as unknown as ConversationGraphMemory;
-    const ctx = makeHookCtx({ graphMemory, isTrustedActor: true });
+    installConversation(graphMemory, { trusted: true });
+    const ctx = makeHookCtx();
 
     await expect(userPromptSubmitMemoryRetrieval(ctx)).rejects.toThrow(
       "retrieval failed",
     );
   });
 
-  test("forwards the context abort signal into prepareMemory", async () => {
-    // The hook hands its `ctx.signal` straight to `prepareMemory` so an
-    // external cancel aborts the underlying retrieval.
+  test("forwards the conversation abort signal into prepareMemory", async () => {
+    // The hook hands the live conversation's abort signal straight to
+    // `prepareMemory` so an external cancel aborts the underlying retrieval.
     let capturedSignal: AbortSignal | undefined;
     const prepareMemoryMock = mock(
       async (
@@ -355,7 +389,11 @@ describe("user-prompt-submit-temp hook (memory retrieval)", () => {
       recordPkbQueryVectors: mock(() => {}),
     } as unknown as ConversationGraphMemory;
     const controller = new AbortController();
-    const ctx = makeHookCtx({ graphMemory, signal: controller.signal });
+    installConversation(graphMemory, {
+      trusted: true,
+      signal: controller.signal,
+    });
+    const ctx = makeHookCtx();
 
     await userPromptSubmitMemoryRetrieval(ctx);