@vellumai/assistant 0.8.9 → 0.8.10-dev.202606092334.09948c8

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

@@ -114,39 +114,70 @@ mock.module("../context/token-estimator.js", () => ({
 let mockReducerStepFn:
   | ((msgs: Message[], cfg: unknown, state: unknown) => unknown)
   | null = null;
+const makeInitialReducerState = () => ({
+  appliedTiers: [] as string[],
+  injectionMode: "full" as const,
+  exhausted: false,
+});
+const runMockReducer = 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,
+  };
+};
 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,
-      };
-    },
+    createInitialReducerState: makeInitialReducerState,
+    reduceContextOverflow: runMockReducer,
   }),
 );
 
+// Stand-in for `ContextWindowManager`'s turn-scoped overflow ladder. Threads
+// reducer state across a turn's rungs and delegates each rung to the mocked
+// reducer, mirroring `reduceOverflowOneRung` / `resetOverflowRecovery` so the
+// convergence driver exercises the same per-rung escalation the real manager
+// drives.
+function makeOverflowLadderStub(): {
+  resetOverflowRecovery: () => void;
+  reduceOverflowOneRung: (
+    msgs: Message[],
+    opts: unknown,
+    signal?: AbortSignal,
+  ) => Promise<unknown>;
+} {
+  let state: unknown;
+  return {
+    resetOverflowRecovery: () => {
+      state = undefined;
+    },
+    reduceOverflowOneRung: async (msgs: Message[], opts: unknown) => {
+      if (!state) state = makeInitialReducerState();
+      const step = (await runMockReducer(msgs, opts, state)) as {
+        state: unknown;
+      };
+      state = step.state;
+      return step;
+    },
+  };
+}
+
 // Policy: default to fail_gracefully
 let mockOverflowAction: string = "fail_gracefully";
 mock.module("../daemon/context-overflow-policy.js", () => ({
@@ -716,6 +747,16 @@ function makeCtx(
 
     ...ctxOverrides,
   } as unknown as Conversation;
+  // The convergence driver resolves the turn-scoped overflow ladder off the
+  // manager; give every fake manager the ladder methods unless a test supplied
+  // its own.
+  const manager = ctx.contextWindowManager as unknown as Record<
+    string,
+    unknown
+  >;
+  if (typeof manager.reduceOverflowOneRung !== "function") {
+    Object.assign(manager, makeOverflowLadderStub());
+  }
   fakeContextWindowManagers.set(conversationId, ctx.contextWindowManager);
   return ctx;
 }
@@ -1710,27 +1751,31 @@ describe("session-agent-loop", () => {
     test("non-interactive auto-compress continues without approval prompt", async () => {
       const events: ServerMessage[] = [];
 
-      // Reducer exhausts all tiers
-      mockReducerStepFn = (msgs: Message[]) => ({
-        messages: msgs,
-        tier: "injection_downgrade",
-        state: {
-          appliedTiers: [
-            "forced_compaction",
-            "tool_result_truncation",
-            "media_stubbing",
-            "injection_downgrade",
-          ],
-          injectionMode: "minimal",
-          exhausted: true,
-        },
-        estimatedTokens: 120000,
-      });
+      // The ladder applies a middle tier first, then escalates to its terminal
+      // auto-compress-latest-turn rung (permitted by the overflow policy) and
+      // reports exhaustion — mirroring the reducer owning every rung.
+      let reducerCalls = 0;
+      mockReducerStepFn = (msgs: Message[]) => {
+        reducerCalls++;
+        const terminal = reducerCalls >= 2;
+        return {
+          messages: msgs,
+          tier: terminal ? "auto_compress_latest_turn" : "forced_compaction",
+          state: {
+            appliedTiers: terminal
+              ? ["forced_compaction", "auto_compress_latest_turn"]
+              : ["forced_compaction"],
+            injectionMode: "full",
+            exhausted: terminal,
+          },
+          estimatedTokens: 120000,
+        };
+      };
 
       mockOverflowAction = "auto_compress_latest_turn";
 
       // The provider rejects the first two calls with context-too-large errors,
-      // then succeeds after the emergency auto-compress runs.
+      // then succeeds after the terminal auto-compress rung runs.
       const ctx = makeCtx({
         providerResponses: [
           new Error("context_length_exceeded"),
@@ -1785,24 +1830,26 @@ describe("session-agent-loop", () => {
       // attribute the silent stall.
       const events: ServerMessage[] = [];
 
-      // Reducer exhausts all 4 tiers on first call so the convergence
-      // loop runs exactly one iteration before falling through to
-      // the auto_compress_latest_turn branch.
-      mockReducerStepFn = (msgs: Message[]) => ({
-        messages: msgs,
-        tier: "injection_downgrade",
-        state: {
-          appliedTiers: [
-            "forced_compaction",
-            "tool_result_truncation",
-            "media_stubbing",
-            "injection_downgrade",
-          ],
-          injectionMode: "minimal",
-          exhausted: true,
-        },
-        estimatedTokens: 120_000,
-      });
+      // The ladder applies a middle tier, then runs its terminal
+      // auto-compress-latest-turn rung and reports exhaustion. Its rerun is the
+      // one that still yields at the mid-loop budget checkpoint.
+      let reducerCalls = 0;
+      mockReducerStepFn = (msgs: Message[]) => {
+        reducerCalls++;
+        const terminal = reducerCalls >= 2;
+        return {
+          messages: msgs,
+          tier: terminal ? "auto_compress_latest_turn" : "forced_compaction",
+          state: {
+            appliedTiers: terminal
+              ? ["forced_compaction", "auto_compress_latest_turn"]
+              : ["forced_compaction"],
+            injectionMode: "full",
+            exhausted: terminal,
+          },
+          estimatedTokens: 120_000,
+        };
+      };
 
       mockOverflowAction = "auto_compress_latest_turn";
 
@@ -1934,8 +1981,10 @@ describe("session-agent-loop", () => {
 
       await runAgentLoopImpl(ctx, "hello", "msg-1", (msg) => events.push(msg));
 
-      // maxAttempts is 3 — reducer should be called at most 3 times
-      expect(reducerCalls).toBeLessThanOrEqual(3);
+      // A misbehaving reducer that never reports exhaustion is bounded by the
+      // driver's safety backstop: at most the middle-tier budget plus the
+      // emergency and terminal rungs (maxAttempts + 2 = 5).
+      expect(reducerCalls).toBeLessThanOrEqual(5);
     });
   });
 

package/src/__tests__/conversation-confirmation-signals.test.ts

@@ -174,6 +174,7 @@ mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
     async maybeCompact() {
       return { compacted: false };
     }
+    resetOverflowRecovery() {}
   },
   createContextSummaryMessage: () => ({
     role: "user",

package/src/__tests__/conversation-fork-crud.test.ts

@@ -922,6 +922,116 @@ describe("forkConversation", () => {
     expect(loadGraphMemoryState(fork.id)).toBeNull();
   });
 
+  test("truncated fork seeds everInjected from inherited memory attachments", async () => {
+    const source = createConversation("Truncated seed thread");
+    await addMessage(source.id, "user", "first turn", {
+      metadata: {
+        memoryInjectedBlock:
+          "# memory/concepts/topics/page-a.md\nSummary A\n\n# memory/concepts/topics/page-b.md\nSummary B",
+      },
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "assistant", "first reply", {
+      skipIndexing: true,
+    });
+    const boundaryMessage = await addMessage(source.id, "user", "second turn", {
+      metadata: {
+        memoryInjectedBlock: "# memory/concepts/topics/page-c.md\nSummary C",
+      },
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "assistant", "second reply", {
+      skipIndexing: true,
+    });
+    // Past the fork boundary — its attachment must NOT be claimed.
+    await addMessage(source.id, "user", "third turn", {
+      metadata: {
+        memoryInjectedBlock: "# memory/concepts/topics/page-d.md\nSummary D",
+      },
+      skipIndexing: true,
+    });
+
+    const db = getDb();
+    db.insert(activationState)
+      .values({
+        conversationId: source.id,
+        messageId: "parent-msg",
+        stateJson: JSON.stringify({ "topics/page-d": 0.9 }),
+        everInjectedJson: JSON.stringify([
+          { slug: "topics/page-a", turn: 1 },
+          { slug: "topics/page-b", turn: 1 },
+          { slug: "topics/page-c", turn: 2 },
+          { slug: "topics/page-d", turn: 3 },
+        ]),
+        currentTurn: 3,
+        updatedAt: 1_700_000_000_000,
+      })
+      .run();
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: boundaryMessage.id,
+    });
+
+    const childState = await hydrateActivationState(db, fork.id);
+    expect(childState).not.toBeNull();
+    // Exactly the slugs whose attachments live in the copied history —
+    // page-d (injected past the boundary) stays re-injectable.
+    expect(childState?.everInjected.map((e) => e.slug).sort()).toEqual([
+      "topics/page-a",
+      "topics/page-b",
+      "topics/page-c",
+    ]);
+    expect(childState?.everInjected.every((e) => e.turn === 0)).toBe(true);
+    // Activation scores and the turn counter start fresh, matching the
+    // graph tracker (also not copied for truncated forks).
+    expect(childState?.state).toEqual({});
+    expect(childState?.currentTurn).toBe(0);
+  });
+
+  test("truncated fork ignores attachments behind an inherited compaction boundary", async () => {
+    const source = createConversation("Compacted truncated thread");
+    await addMessage(source.id, "user", "compacted turn", {
+      metadata: {
+        memoryInjectedBlock:
+          "# memory/concepts/topics/page-compacted.md\nOld summary",
+      },
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "assistant", "compacted reply", {
+      skipIndexing: true,
+    });
+    const boundaryMessage = await addMessage(source.id, "user", "live turn", {
+      metadata: {
+        memoryInjectedBlock: "# memory/concepts/topics/page-live.md\nSummary",
+      },
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "assistant", "live reply", {
+      skipIndexing: true,
+    });
+    await addMessage(source.id, "user", "past boundary", {
+      skipIndexing: true,
+    });
+    // First two messages sit behind the compaction boundary: their
+    // attachments are not rendered, so the fork must not claim them.
+    getDb()
+      .update(conversations)
+      .set({ contextCompactedMessageCount: 2 })
+      .where(eq(conversations.id, source.id))
+      .run();
+
+    const fork = forkConversation({
+      conversationId: source.id,
+      throughMessageId: boundaryMessage.id,
+    });
+
+    const childState = await hydrateActivationState(getDb(), fork.id);
+    expect(childState?.everInjected.map((e) => e.slug)).toEqual([
+      "topics/page-live",
+    ]);
+  });
+
   test("defaults conversationType to standard and inherits the parent's group", async () => {
     const source = createConversation("Default inheritance thread");
     await addMessage(source.id, "user", "first message", {

package/src/__tests__/conversation-process-callsite.test.ts

@@ -259,6 +259,7 @@ mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
     async maybeCompact() {
       return { compacted: false };
     }
+    resetOverflowRecovery() {}
   },
   createContextSummaryMessage: () => ({
     role: "user",

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

@@ -96,10 +96,9 @@ mock.module("../context/token-estimator.js", () => ({
   estimateToolsTokens: () => 0,
 }));
 
-// Overflow recovery module mocks — the convergence loop delegates to these
-// 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.
+// The wrapper's convergence loop seeds its gate-loop reducer state from this
+// factory; the per-rung reduction itself runs through the manager's
+// `reduceOverflowOneRung` (see the ContextWindowManager mock below).
 mock.module(
   "../plugins/defaults/compaction/context-overflow-reducer.js",
   () => ({
@@ -108,49 +107,6 @@ mock.module(
       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,
-      };
-    },
   }),
 );
 
@@ -223,7 +179,10 @@ let forceCompactionEnabled = false;
 
 mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
   ContextWindowManager: class {
-    constructor() {}
+    conversationId: string | undefined;
+    constructor(options?: { conversationId?: string }) {
+      this.conversationId = options?.conversationId;
+    }
     updateConfig() {}
     shouldCompact() {
       return { needed: false, estimatedTokens: 0 };
@@ -253,6 +212,47 @@ mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
       }
       return { compacted: false };
     }
+    resetOverflowRecovery() {}
+    // Mirrors the real reducer's Tier 1: run forced compaction through
+    // defaultCompact (which resolves this same manager from the store) and
+    // report the ladder exhausted in one rung.
+    async reduceOverflowOneRung(
+      msgs: Message[],
+      _options: unknown,
+      signal?: AbortSignal,
+    ) {
+      const { defaultCompact } =
+        await import("../plugins/defaults/compaction/compact.js");
+      const cr = await defaultCompact({
+        conversationId: this.conversationId!,
+        messages: msgs,
+        signal,
+        force: true,
+        minKeepRecentUserTurns: 0,
+      });
+      let resultMessages = msgs;
+      let compactionResult;
+      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,
+      };
+    }
   },
   createContextSummaryMessage: () => ({
     role: "user",

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

@@ -272,6 +272,7 @@ mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
     async maybeCompact() {
       return { compacted: false };
     }
+    resetOverflowRecovery() {}
   },
   createContextSummaryMessage: () => ({
     role: "user",

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -2,6 +2,7 @@ import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import type { PostCompactContext } from "@vellumai/plugin-api";
 import { eq } from "drizzle-orm";
 
 // This test exercises v1 PKB injection. `config.memory.v2.enabled` (default
@@ -64,6 +65,8 @@ mock.module("../daemon/date-context.js", () => ({
   formatTurnTimestamp: () => FIXED_TURN_TIMESTAMP,
 }));
 
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
+import { LLMSchema } from "../config/schemas/llm.js";
 import {
   clearConversations,
   setConversation,
@@ -87,6 +90,7 @@ import {
   loadSlackChronologicalMessages,
   resolveChannelCapabilities,
   resolveTurnInboundActorContext,
+  resolveTurnModelProfileLabel,
   stripChannelCapabilityContext,
   stripInjectionsForCompaction,
   stripNowScratchpad,
@@ -1025,18 +1029,18 @@ describe("applyRuntimeInjections — injection mode", () => {
     // GIVEN the seeded live conversation `injection-mode-conv` whose
     // conversation-scoped blocks (`<active_workspace>`, `<channel_capabilities>`)
     // only resolve when `applyRuntimeInjections` finds it by conversation id
-    // AND the agent loop hands the post-compaction hook the turn-identity fields
-    // flat (`requestId`, `conversationId`, `trust`)
-    const { messages: result } = await postCompact({
+    // AND the agent loop hands the post-compaction hook the irreducible
+    // turn-identity fields flat (`requestId`, `conversationId`), with trust and
+    // actor identity self-resolved by the hook from the live conversation
+    const postCompactCtx: PostCompactContext = {
       history: baseMessages,
       requestId: "reinject-req",
       conversationId: "injection-mode-conv",
-      trust: { sourceChannel: "vellum", trustClass: "guardian" },
       isNonInteractive: false,
-      mode: "full",
-      modelProfile: null,
-      actorContext: null,
-    });
+      modelProfileKey: null,
+    };
+    await postCompact(postCompactCtx);
+    const result = postCompactCtx.history;
     const allText = result[0].content
       .filter((b): b is { type: "text"; text: string } => b.type === "text")
       .map((b) => b.text)
@@ -1509,6 +1513,113 @@ describe("resolveTurnInboundActorContext", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// resolveTurnModelProfileLabel
+// ---------------------------------------------------------------------------
+
+describe("resolveTurnModelProfileLabel", () => {
+  /**
+   * A null key means the active profile is unchanged since the last notified
+   * one, so there is no `model_profile` line to render this turn.
+   */
+  test("returns null when the profile key is null", () => {
+    // GIVEN a turn whose profile is unchanged since the last notification
+    const llm = LLMSchema.parse({
+      default: { provider: "anthropic", model: "claude-sonnet-4-7" },
+    });
+
+    // WHEN the label is resolved for a null key
+    const label = resolveTurnModelProfileLabel(null, "mainAgent", llm);
+
+    // THEN there is no profile line to inject
+    expect(label).toBeNull();
+  });
+
+  /**
+   * A known profile renders its configured display label paired with the model
+   * the call site resolves to.
+   */
+  test("renders the profile's label with the resolved model", () => {
+    // GIVEN a workspace with a labelled "fast" profile
+    const llm = LLMSchema.parse({
+      default: { provider: "anthropic", model: "claude-sonnet-4-7" },
+      profiles: {
+        fast: { label: "Fast", provider: "anthropic", model: "claude-haiku-4" },
+      },
+    });
+
+    // WHEN the label is resolved for that profile at the main-agent call site
+    const label = resolveTurnModelProfileLabel("fast", "mainAgent", llm);
+
+    // THEN the rendered line pairs the display label with the resolved model
+    expect(label).toBe("Fast (claude-haiku-4)");
+  });
+
+  /**
+   * A profile with no configured label falls back to its raw key so the model
+   * still gets a stable identifier.
+   */
+  test("falls back to the raw key when the profile has no label", () => {
+    // GIVEN a profile that sets a model but no display label
+    const llm = LLMSchema.parse({
+      default: { provider: "anthropic", model: "claude-sonnet-4-7" },
+      profiles: {
+        deep: { provider: "anthropic", model: "claude-opus-4" },
+      },
+    });
+
+    // WHEN the label is resolved for that profile
+    const label = resolveTurnModelProfileLabel("deep", "mainAgent", llm);
+
+    // THEN the raw key stands in for the missing label
+    expect(label).toBe("deep (claude-opus-4)");
+  });
+
+  /**
+   * A key naming a `mix` profile must announce the arm the turn's provider
+   * calls actually run on. The conversation id is threaded as the selection
+   * seed so the announced model is a deterministic function of the
+   * conversation, matching the seeded expansion the provider layer performs.
+   */
+  test("announces the seeded mix arm so it matches the turn's model", () => {
+    // GIVEN a mix profile routing between two models
+    const llm = LLMSchema.parse({
+      default: { provider: "anthropic", model: "claude-sonnet-4-7" },
+      profiles: {
+        a: { label: "Arm A", provider: "anthropic", model: "model-a" },
+        b: { label: "Arm B", provider: "anthropic", model: "model-b" },
+        ab: {
+          label: "AB",
+          mix: [
+            { profile: "a", weight: 50 },
+            { profile: "b", weight: 50 },
+          ],
+        },
+      },
+    });
+
+    // AND the model the provider calls resolve to for this conversation's seed
+    const seededModel = resolveCallSiteConfig("mainAgent", llm, {
+      overrideProfile: "ab",
+      selectionSeed: "conv-seed-1",
+    }).model;
+
+    // WHEN the label is resolved with the same conversation seed
+    const label = resolveTurnModelProfileLabel(
+      "ab",
+      "mainAgent",
+      llm,
+      "conv-seed-1",
+    );
+
+    // THEN the announced model is the seeded arm (deterministic, not re-rolled)
+    expect(label).toBe(`AB (${seededModel})`);
+    expect(
+      resolveTurnModelProfileLabel("ab", "mainAgent", llm, "conv-seed-1"),
+    ).toBe(label);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // buildUnifiedTurnContextBlock
 // ---------------------------------------------------------------------------

package/src/__tests__/conversation-slash-queue.test.ts

@@ -163,6 +163,7 @@ mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
     async maybeCompact() {
       return { compacted: false };
     }
+    resetOverflowRecovery() {}
   },
   createContextSummaryMessage: () => ({
     role: "user",

package/src/__tests__/conversation-slash-unknown.test.ts

@@ -164,6 +164,7 @@ mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
     async maybeCompact() {
       return { compacted: false };
     }
+    resetOverflowRecovery() {}
   },
   createContextSummaryMessage: () => ({
     role: "user",

package/src/__tests__/conversation-speed-override.test.ts

@@ -180,6 +180,7 @@ mock.module("../plugins/defaults/compaction/window-manager.js", () => ({
     async maybeCompact() {
       return { compacted: false };
     }
+    resetOverflowRecovery() {}
   },
   createContextSummaryMessage: () => ({
     role: "user",