@vellumai/assistant 0.8.8-dev.202606071935.547b6d2 → 0.8.8-dev.202606072033.0e97ff6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.8.8-dev.202606071935.547b6d2",
+  "version": "0.8.8-dev.202606072033.0e97ff6",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/agent-loop-exit-reason.test.ts

@@ -22,8 +22,8 @@ import type {
   CheckpointInfo,
 } from "../agent/loop.js";
 import { AgentLoop, isMaxTokensStopReason } from "../agent/loop.js";
+import type { TrustContext } from "../daemon/trust-context.js";
 import type { PostCompactionHookInput } from "../plugins/defaults/memory-retrieval/hooks/post-compact.js";
-import type { TurnContext } from "../plugins/types.js";
 import type {
   Message,
   Provider,
@@ -120,21 +120,16 @@ const userMessage: Message = {
   content: [{ type: "text", text: "Hello" }],
 };
 
-// A turn context plus a context-window manager whose `maybeCompact` returns a
+// A trust snapshot plus a context-window manager whose `maybeCompact` returns a
 // canned result, so the loop's compaction call runs without the real
-// orchestrator machinery. The manager is supplied to the loop as a dedicated
-// run option rather than riding on the turn context.
+// orchestrator machinery. Both are supplied to the loop as dedicated run
+// options.
 function fakeCompaction(result: { compacted: boolean; exhausted: boolean }): {
-  turnContext: TurnContext;
+  trust: TrustContext;
   contextWindowManager: AgentLoopRunOptions["contextWindowManager"];
 } {
   return {
-    turnContext: {
-      requestId: "req-compact",
-      conversationId: "conv-compact",
-      turnIndex: 0,
-      trust: { sourceChannel: "vellum", trustClass: "unknown" },
-    },
+    trust: { sourceChannel: "vellum", trustClass: "unknown" },
     contextWindowManager: {
       maybeCompact: async () => result,
     } as unknown as AgentLoopRunOptions["contextWindowManager"],

package/src/__tests__/compaction-events.test.ts

@@ -190,7 +190,6 @@ let mockCompactResult: ContextWindowResult = {
 mock.module("../context/window-manager.js", () => ({
   ContextWindowManager: class {
     nonPersistedPrefixCount = 0;
-    summaryIsInjected = false;
     constructor() {}
     updateConfig() {}
     shouldCompact() {

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

@@ -1019,20 +1019,17 @@ describe("applyRuntimeInjections — injection mode", () => {
     expect(texts).toContain("Hello");
   });
 
-  test("post-compaction re-injection resolves the live conversation from the turn context", async () => {
+  test("post-compaction re-injection resolves the live conversation from the conversation id", async () => {
     // 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 its per-turn context as
-    // a single nested `turnContext` (its own working-state unit)
+    // AND the agent loop hands the post-compaction hook the turn-identity fields
+    // flat (`requestId`, `conversationId`, `trust`)
     const { messages: result } = await postCompactReinject({
       history: baseMessages,
-      turnContext: {
-        requestId: "reinject-req",
-        conversationId: "injection-mode-conv",
-        turnIndex: 0,
-        trust: { sourceChannel: "vellum", trustClass: "guardian" },
-      },
+      requestId: "reinject-req",
+      conversationId: "injection-mode-conv",
+      trust: { sourceChannel: "vellum", trustClass: "guardian" },
       isNonInteractive: false,
       mode: "full",
       modelProfile: null,
@@ -1043,9 +1040,9 @@ describe("applyRuntimeInjections — injection mode", () => {
       .map((b) => b.text)
       .join("\n");
 
-    // THEN the hook unnests `turnContext.conversationId` onto the flat injection
-    // options, so the re-injection resolves the same live conversation as the
-    // turn's initial assembly rather than the synthetic fallback.
+    // THEN the hook forwards `conversationId` onto the flat injection options,
+    // so the re-injection resolves the same live conversation as the turn's
+    // initial assembly rather than the synthetic fallback.
     expect(allText).toContain("<active_workspace>");
     expect(allText).toContain("<channel_capabilities>");
   });

package/src/agent/loop.ts

@@ -16,6 +16,10 @@ import type {
 } from "../context/window-manager.js";
 import type { InboundActorContext } from "../daemon/conversation-runtime-assembly.js";
 import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
+import {
+  FALLBACK_TURN_TRUST,
+  type TrustContext,
+} from "../daemon/trust-context.js";
 import { HOOKS } from "../plugin-api/constants.js";
 import type {
   AssistantMessageContext,
@@ -29,7 +33,7 @@ import {
 } from "../plugins/defaults/compaction/compact.js";
 import postCompactReinject from "../plugins/defaults/memory-retrieval/hooks/post-compact.js";
 import { runHook } from "../plugins/pipeline.js";
-import type { CompactionCircuitEvent, TurnContext } from "../plugins/types.js";
+import type { CompactionCircuitEvent } from "../plugins/types.js";
 import { PluginExecutionError } from "../plugins/types.js";
 import { normalizeThinkingConfigForWire } from "../providers/thinking-config.js";
 import type {
@@ -403,37 +407,6 @@ function assistantTextOf(content: ReadonlyArray<ContentBlock>): string {
   return text;
 }
 
-/**
- * Build a minimal {@link TurnContext} for pipeline invocations inside the
- * agent loop. Real production call sites thread a full `TurnContext` into
- * `AgentLoop.run()` (see the `turnContext` parameter on
- * {@link AgentLoop.run}); this helper is the fallback used only by unit
- * tests that construct `AgentLoop` directly without an orchestrator.
- *
- * When the orchestrator-supplied context is present it is used directly so the
- * pipeline sees the real `conversationId` and trust class.
- * In the fallback path the returned context is still useful for pipeline
- * logging: `requestId` surfaces in every structured record, and `turnIndex`
- * reflects the current tool-use iteration.
- */
-function buildLoopTurnContext(
-  requestId: string | undefined,
-  turnIndex: number,
-): TurnContext {
-  return {
-    requestId: requestId ?? "agent-loop",
-    // Loop-scoped pipelines do not currently carry a conversation ID; the
-    // outer orchestrator owns that dimension. Use a fixed sentinel so log
-    // consumers can filter loop-origin records out of conversation queries.
-    conversationId: "agent-loop",
-    turnIndex,
-    trust: {
-      sourceChannel: "vellum",
-      trustClass: "unknown",
-    },
-  };
-}
-
 /**
  * User-config HTTP status codes that should never page the on-call: billing
  * exhaustion (402), invalid credentials (401), and forbidden/plan-gated (403).
@@ -484,13 +457,15 @@ export interface AgentLoopRunOptions {
   ) => CheckpointDecision | Promise<CheckpointDecision>;
   callSite?: LLMCallSite;
   /**
-   * Per-turn context supplied by the orchestrator. Every pipeline
-   * invocation inside the loop clones from this value (overwriting only
-   * `turnIndex`/`requestId`) so middleware sees the real conversation
-   * identity and trust class rather than the `"agent-loop"` sentinel used
-   * when the loop is instantiated standalone in unit tests.
+   * Trust classification and channel identity for the turn's inbound actor,
+   * supplied by the orchestrator as the turn-start snapshot. Read only on the
+   * mid-loop in-place compaction path — to scope the compactor's image
+   * manifest (guardian-only attachments are excluded for untrusted actors) and
+   * forwarded to {@link postCompactReinject}. Absent for callers without a
+   * compaction path (agent wakes, standalone unit tests); the loop otherwise
+   * resolves its conversation identity from its own {@link conversationId}.
    */
-  turnContext?: TurnContext;
+  trust?: TrustContext;
   /**
    * The conversation's {@link ContextWindowManager}, supplied by the
    * orchestrator so mid-loop in-place compaction can run against the real
@@ -623,6 +598,15 @@ export class AgentLoop {
     | null;
   private toolExecutor: LoopToolExecutor | null;
 
+  /**
+   * Conversation this loop drives, or an empty string for standalone test
+   * loops constructed without one. Source of truth for the `conversationId`
+   * the loop's pipeline contexts and post-compaction re-injection resolve the
+   * live conversation through, so the loop no longer needs a turn context
+   * threaded in to know its own identity.
+   */
+  private readonly conversationId: string;
+
   /**
    * Loop-held compaction circuit breaker. The loop has a 1:1 lifetime with its
    * conversation, so it is the source of truth for the cross-turn failure
@@ -652,7 +636,8 @@ export class AgentLoop {
     this.resolveTools = resolveTools ?? null;
     this.resolveSystemPrompt = resolveSystemPrompt ?? null;
     this.toolExecutor = toolExecutor ?? null;
-    this.compactionCircuit = new CompactionCircuit(conversationId ?? "");
+    this.conversationId = conversationId ?? "";
+    this.compactionCircuit = new CompactionCircuit(this.conversationId);
   }
 
   /**
@@ -704,7 +689,7 @@ export class AgentLoop {
    * compaction outcome into a user-visible turn failure.
    */
   private async recordCompactionOutcome(
-    turnContext: TurnContext,
+    requestId: string | undefined,
     summaryFailed: boolean,
     onEvent: (event: AgentEvent) => void | Promise<void>,
   ): Promise<void> {
@@ -712,7 +697,7 @@ export class AgentLoop {
       await this.compactionCircuit.recordOutcome(summaryFailed, onEvent);
     } catch (recordError) {
       log.error(
-        { err: recordError, requestId: turnContext.requestId },
+        { err: recordError, requestId },
         "Recording a compaction outcome against the circuit breaker failed; suppressing to keep the agent loop alive",
       );
     }
@@ -728,7 +713,8 @@ export class AgentLoop {
    */
   private async compact(
     history: Message[],
-    turnContext: TurnContext,
+    requestId: string | undefined,
+    trust: TrustContext,
     manager: ContextWindowManager | undefined,
     signal: AbortSignal | undefined,
     onEvent: (event: AgentEvent) => void | Promise<void>,
@@ -752,8 +738,8 @@ export class AgentLoop {
     }
     // The mid-loop budget gate is reached only when this turn decides to
     // compact in place, so `force` past the auto-threshold check.
-    // `actorTrustClass` comes from the turn context (the actor whose turn
-    // triggered compaction) so the compactor's image manifest excludes
+    // `actorTrustClass` comes from the turn's trust snapshot (the actor whose
+    // turn triggered compaction) so the compactor's image manifest excludes
     // guardian-only attachments for untrusted actors. `overrideProfile` is the
     // turn's resolved inference-profile override for the summary call.
     const compactResult = await defaultCompact({
@@ -761,7 +747,7 @@ export class AgentLoop {
       messages: rawHistory,
       signal,
       force: true,
-      actorTrustClass: turnContext.trust.trustClass,
+      actorTrustClass: trust.trustClass,
       overrideProfile,
     });
     // `force: true` bypasses the auto-threshold gate, but early returns
@@ -770,7 +756,7 @@ export class AgentLoop {
     // actually ran.
     if (compactResult.summaryFailed !== undefined) {
       await this.recordCompactionOutcome(
-        turnContext,
+        requestId,
         compactResult.summaryFailed,
         onEvent,
       );
@@ -792,7 +778,9 @@ export class AgentLoop {
     // pre-compaction history otherwise.
     const injection = await postCompactReinject({
       history: compactResult.compacted ? compactResult.messages : rawHistory,
-      turnContext,
+      requestId,
+      conversationId: this.conversationId,
+      trust,
       isNonInteractive,
       // Mid-loop re-injection always runs at full injection volume.
       mode: "full",
@@ -812,7 +800,7 @@ export class AgentLoop {
       requestId,
       onCheckpoint,
       callSite,
-      turnContext,
+      trust,
       overrideProfile,
       resolveOverrideProfile,
       resolveContextWindow,
@@ -880,13 +868,6 @@ export class AgentLoop {
       let toolUseBlocks: Extract<ContentBlock, { type: "tool_use" }>[] = [];
 
       try {
-        // Per-turn pipeline context. Real call sites thread a full
-        // `turnContext` into `run()` and it is used directly; standalone
-        // unit-test instantiations that never plumb a context through fall
-        // back to a synthesized placeholder scoped to the tool-use iteration.
-        const turnCtx =
-          turnContext ?? buildLoopTurnContext(requestId, toolUseTurns);
-
         // ── Pre-call budget gate ─────────────────────────────────────
         // When overflow recovery is enabled, estimate the running context
         // size as it approaches the preflight budget before issuing the
@@ -929,7 +910,8 @@ export class AgentLoop {
                 );
                 const compacted = await this.compact(
                   history,
-                  turnCtx,
+                  requestId,
+                  trust ?? FALLBACK_TURN_TRUST,
                   contextWindowManager,
                   signal,
                   onEvent,
@@ -1048,14 +1030,14 @@ export class AgentLoop {
           providerConfig.callSite = callSite;
           providerConfig.usageTracking = "manual";
           // Per-conversation seed for deterministic `mix`-profile expansion.
-          // Sourced from the orchestrator-supplied turn context's
-          // conversationId so every LLM call in a conversation resolves the
-          // same mix arm (stable across turns and retries, and across daemon
-          // restarts since the seed is the durable conversation id). Absent
-          // for standalone `AgentLoop` instances (unit tests / no turnContext)
-          // — those fall back to per-call random mix selection.
-          if (turnContext?.conversationId) {
-            providerConfig.selectionSeed = turnContext.conversationId;
+          // Sourced from the loop's own conversation id so every LLM call in a
+          // conversation resolves the same mix arm (stable across turns and
+          // retries, and across daemon restarts since the seed is the durable
+          // conversation id). Absent for standalone `AgentLoop` instances
+          // (unit tests constructed without a conversation id) — those fall
+          // back to per-call random mix selection.
+          if (this.conversationId) {
+            providerConfig.selectionSeed = this.conversationId;
           }
         }
 
@@ -1190,8 +1172,8 @@ export class AgentLoop {
         // request unchanged and streaming live.
         try {
           const preModelCtx: PreModelCallContext = {
-            conversationId: turnCtx.conversationId,
-            callSite: turnCtx.callSite,
+            conversationId: this.conversationId,
+            callSite,
             systemPrompt: providerOptions.systemPrompt,
             deferAssistantOutput: false,
             logger: rlog,
@@ -1308,8 +1290,8 @@ export class AgentLoop {
           let finalized = message;
           try {
             const ctx: AssistantMessageContext = {
-              conversationId: turnCtx.conversationId,
-              callSite: turnCtx.callSite,
+              conversationId: this.conversationId,
+              callSite,
               content: structuredClone(message.content),
               stopReason: response.stopReason,
               logger: rlog,
@@ -1420,7 +1402,7 @@ export class AgentLoop {
           // follow-up turn. It receives the full history and, when it asks to
           // continue, appends the follow-up turn itself.
           const stopCtx: StopContext = {
-            conversationId: turnCtx.conversationId,
+            conversationId: this.conversationId,
             messages: [...history],
             responseContent: response.content,
             stopReason: response.stopReason,
@@ -1615,7 +1597,7 @@ export class AgentLoop {
             continue;
           }
           const postToolUseCtx: PostToolUseContext = {
-            conversationId: turnCtx.conversationId,
+            conversationId: this.conversationId,
             toolResponse: block as ToolResultContent,
             messages: history,
             maxInputTokens: contextWindowTokens,

package/src/context/window-manager.ts

@@ -199,8 +199,7 @@ export class ContextWindowManager {
    * `compactedMessages` so `compactedPersistedMessages` only reflects DB
    * rows. Decremented after a successful compaction.
    */
-  nonPersistedPrefixCount = 0;
-  summaryIsInjected = false;
+  private _nonPersistedPrefixCount = 0;
   private _resolvedSystemPrompt: string | undefined;
 
   constructor(options: ContextWindowManagerOptions) {
@@ -216,6 +215,21 @@ export class ContextWindowManager {
     this.config = config;
   }
 
+  /** Leading non-persisted inherited-context messages the compactor preserves. */
+  get nonPersistedPrefixCount(): number {
+    return this._nonPersistedPrefixCount;
+  }
+
+  /**
+   * Seed the non-persisted inherited-context prefix when a forked/sub
+   * conversation inherits its parent's in-memory context. The compactor folds
+   * this prefix into the summary and {@link consumeCompactionState} decrements
+   * it as the leading messages are compacted away.
+   */
+  seedNonPersistedPrefix(count: number): void {
+    this._nonPersistedPrefixCount = count;
+  }
+
   private get estimationProviderName(): string {
     return this.provider.tokenEstimationProvider ?? this.provider.name;
   }
@@ -353,7 +367,7 @@ export class ContextWindowManager {
       signal,
       overrideProfile: options?.overrideProfile ?? null,
       actorTrustClass: options?.actorTrustClass,
-      nonPersistedPrefixCount: this.nonPersistedPrefixCount,
+      nonPersistedPrefixCount: this._nonPersistedPrefixCount,
     };
 
     // Retry budget for the compactor itself. Lives here (not in the
@@ -391,7 +405,7 @@ export class ContextWindowManager {
         ...baseArgs,
         messages: result.messages,
         previousEstimatedInputTokens: previousEstimate,
-        nonPersistedPrefixCount: this.nonPersistedPrefixCount,
+        nonPersistedPrefixCount: this._nonPersistedPrefixCount,
       });
       if (!nextResult.compacted) break;
       const nextEstimate = this.recomputePostCompactionEstimate(
@@ -435,21 +449,20 @@ export class ContextWindowManager {
   }
 
   /**
-   * Decrement the non-persisted prefix bookkeeping and clear the
-   * injected-summary flag after a productive compaction. Called once per
-   * successful internal attempt so multi-attempt runs keep the count
-   * honest as the leading injected messages get folded into the summary.
+   * Decrement the non-persisted prefix bookkeeping after a productive
+   * compaction. Called once per successful internal attempt so multi-attempt
+   * runs keep the count honest as the leading injected messages get folded
+   * into the summary.
    */
   private consumeCompactionState(compactedMessages: number): void {
     const compactedAway = Math.min(
-      this.nonPersistedPrefixCount,
+      this._nonPersistedPrefixCount,
       compactedMessages,
     );
-    this.nonPersistedPrefixCount = Math.max(
+    this._nonPersistedPrefixCount = Math.max(
       0,
-      this.nonPersistedPrefixCount - compactedAway,
+      this._nonPersistedPrefixCount - compactedAway,
     );
-    this.summaryIsInjected = false;
   }
 }
 

package/src/daemon/conversation-agent-loop.ts

@@ -83,7 +83,6 @@ import userPromptSubmitMemoryRetrieval, {
   type MemoryRetrievalHookContext,
 } from "../plugins/defaults/memory-retrieval/hooks/user-prompt-submit-temp.js";
 import { runHook } from "../plugins/pipeline.js";
-import type { TurnContext as PluginTurnContext } from "../plugins/types.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 import type { Provider } from "../providers/types.js";
 import {
@@ -185,11 +184,6 @@ function formatDiskPressureBlockedMessage(): string {
 }
 
 // ── Plugin pipeline helpers ──────────────────────────────────────────
-//
-// Canonical {@link PluginTurnContext} builder threaded into every
-// `runHook` call inside `runAgentLoopImpl`. The orchestrator composes
-// the context on demand at each call site from ambient state rather than
-// carrying a persistent `TurnContext` instance across the turn.
 
 /**
  * Synthetic fallback trust context used when the orchestrator fires a hook
@@ -314,8 +308,8 @@ export async function runAgentLoopImpl(
   // `resolveCallSiteConfig`, picking up any user overrides under
   // `llm.callSites.mainAgent` (falling back to `llm.default` when absent).
   const turnCallSite: LLMCallSite = options?.callSite ?? "mainAgent";
-  // Expose the turn's call site to plugin pipeline/injector contexts (read by
-  // buildPluginTurnContext) so plugins can scope behaviour to the main reply.
+  // Expose the turn's call site on the live conversation so the runtime
+  // injection assembly self-resolves it for the turn's plugin contexts.
   ctx.currentCallSite = turnCallSite;
 
   // Optional per-turn inference-profile override. Plumbed through to every
@@ -1228,22 +1222,14 @@ export async function runAgentLoopImpl(
 
     rlog.info({ callSite: turnCallSite }, "Starting agent loop run");
 
-    // Thread the orchestrator's canonical per-turn context into the agent
-    // loop so its internal pipeline invocations (e.g. compaction) see the
-    // real conversation identity / trust / contextWindowManager instead of
-    // the synthesized `"agent-loop"` placeholder. The loop clones this value
-    // and overwrites `turnIndex` with its own tool-use iteration counter.
-    // Trust prefers the per-turn snapshot, then the conversation-level
+    // Trust snapshot the loop forwards to its mid-loop in-place compaction
+    // (scoping the compactor's image manifest) and the post-compaction
+    // re-injection. Prefers the per-turn snapshot, then the conversation-level
     // context, then the fallback — matching the trust the runtime injection
-    // assembly resolves for the same turn.
-    const loopTurnCtx: PluginTurnContext = {
-      requestId: reqId,
-      conversationId: ctx.conversationId,
-      turnIndex: ctx.turnCount,
-      trust:
-        ctx.currentTurnTrustContext ?? ctx.trustContext ?? FALLBACK_TURN_TRUST,
-      callSite: ctx.currentCallSite,
-    };
+    // assembly resolves for the same turn. The loop's other turn-identity
+    // fields self-resolve from its own conversation id.
+    const loopTrust =
+      ctx.currentTurnTrustContext ?? ctx.trustContext ?? FALLBACK_TURN_TRUST;
 
     /**
      * Shared closure: runs the agent loop with the orchestrator's turn
@@ -1263,7 +1249,7 @@ export async function runAgentLoopImpl(
           requestId: reqId,
           onCheckpoint,
           callSite: turnCallSite,
-          turnContext: loopTurnCtx,
+          trust: loopTrust,
           contextWindowManager: ctx.contextWindowManager,
           overrideProfile: turnOverrideProfile,
           resolveOverrideProfile: resolveCurrentOverrideProfile,

package/src/daemon/conversation-lifecycle.ts

@@ -14,6 +14,7 @@ import { enqueueMemoryJob, isMemoryEnabled } from "../memory/jobs-store.js";
 import { enqueueMemoryRetrospectiveIfEnabled } from "../memory/memory-retrospective-enqueue.js";
 import type { PermissionPrompter } from "../permissions/prompter.js";
 import type { SecretPrompter } from "../permissions/secret-prompter.js";
+import { disposeContextWindowManager } from "../plugins/defaults/compaction/manager-store.js";
 import type { ContentBlock, Message } from "../providers/types.js";
 import {
   isUntrustedTrustClass,
@@ -241,4 +242,5 @@ export function disposeConversation(ctx: DisposeContext): void {
   ctx.accumulatedSurfaceState.clear();
   ctx.lastSurfaceAction.clear();
   ctx.workspaceTopLevelContext = null;
+  disposeContextWindowManager(ctx.conversationId);
 }

package/src/daemon/conversation.ts

@@ -34,10 +34,9 @@ import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import { getConfig } from "../config/loader.js";
 import type { LLMCallSite, Speed } from "../config/schemas/llm.js";
 import {
-  ContextWindowManager,
+  type ContextWindowManager,
   type ContextWindowResult,
   createContextSummaryMessage,
-  getSummaryFromContextMessage,
 } from "../context/window-manager.js";
 import type { CesClient } from "../credential-execution/client.js";
 import { EventBus } from "../events/bus.js";
@@ -64,6 +63,7 @@ import { PermissionPrompter } from "../permissions/prompter.js";
 import { SecretPrompter } from "../permissions/secret-prompter.js";
 import type { UserDecision } from "../permissions/types.js";
 import { defaultCompact } from "../plugins/defaults/compaction/compact.js";
+import { createContextWindowManager } from "../plugins/defaults/compaction/manager-store.js";
 import { repairHistory } from "../plugins/defaults/history-repair/terminal.js";
 import { buildSystemPrompt } from "../prompts/system-prompt.js";
 import type { ContentBlock, Message } from "../providers/types.js";
@@ -608,7 +608,7 @@ export class Conversation {
       resolveTools,
       resolveSystemPrompt: resolveSystemPromptCallback,
     });
-    this.contextWindowManager = new ContextWindowManager({
+    this.contextWindowManager = createContextWindowManager({
       provider,
       systemPrompt: () => resolveSystemPromptCallback([]).systemPrompt,
       config: initialContextWindowConfig,
@@ -1060,9 +1060,7 @@ export class Conversation {
       );
     }
     this.messages = [...messages];
-    this.contextWindowManager.nonPersistedPrefixCount = messages.length;
-    this.contextWindowManager.summaryIsInjected =
-      getSummaryFromContextMessage(messages[0]) != null;
+    this.contextWindowManager.seedNonPersistedPrefix(messages.length);
   }
 
   /**

package/src/plugins/defaults/compaction/manager-store.ts

@@ -0,0 +1,44 @@
+/**
+ * Per-conversation {@link ContextWindowManager} ownership for the default
+ * compaction module.
+ *
+ * Construction of the manager lives here rather than in the conversation so the
+ * compaction surface owns the manager's lifetime: {@link createContextWindowManager}
+ * builds the instance and records it in a per-conversation store, and
+ * {@link disposeContextWindowManager} drops it when the conversation is torn
+ * down so the store doesn't grow unbounded.
+ *
+ * This module is side-effect free: importing it only initializes an empty
+ * store and registers no plugin.
+ */
+
+import {
+  ContextWindowManager,
+  type ContextWindowManagerOptions,
+} from "../../../context/window-manager.js";
+
+/** Live managers keyed by conversation id. */
+const managersByConversation = new Map<string, ContextWindowManager>();
+
+/**
+ * Build the conversation's {@link ContextWindowManager} and register it under
+ * its conversation id. Construction is owned by the compaction module; the
+ * conversation supplies the provider, prompt/tool resolvers, and initial
+ * config. Replaces any prior manager for the same conversation so each
+ * construction yields a fresh instance, matching a direct `new` call.
+ */
+export function createContextWindowManager(
+  options: ContextWindowManagerOptions & { conversationId: string },
+): ContextWindowManager {
+  const manager = new ContextWindowManager(options);
+  managersByConversation.set(options.conversationId, manager);
+  return manager;
+}
+
+/**
+ * Release the manager registered for a conversation. Called from conversation
+ * teardown so the store releases the instance once the conversation is gone.
+ */
+export function disposeContextWindowManager(conversationId: string): void {
+  managersByConversation.delete(conversationId);
+}

package/src/plugins/defaults/memory-retrieval/hooks/post-compact.ts

@@ -21,40 +21,62 @@
  * The memory graph handle is sourced internally from the plugin's own
  * conversation-keyed registry ({@link getLiveGraphMemory}) rather than being
  * threaded in by the loop — it is memory-retrieval-specific state, not
- * something the generic loop or the shared {@link TurnContext} should carry.
+ * something the generic loop should carry.
  */
 
 import {
   applyRuntimeInjections,
   type InboundActorContext,
   type InjectionMode,
-  type RuntimeInjectionOptions,
   type RuntimeInjectionResult,
 } from "../../../../daemon/conversation-runtime-assembly.js";
-import { resolveTrustClass } from "../../../../daemon/trust-context.js";
+import {
+  resolveTrustClass,
+  type TrustContext,
+} from "../../../../daemon/trust-context.js";
 import { stripHistoricalWebSearchResults } from "../../../../daemon/web-search-history.js";
 import { getLiveGraphMemory } from "../../../../memory/graph/conversation-graph-memory.js";
 import type { Message } from "../../../../providers/types.js";
 import { getLogger } from "../../../../util/logger.js";
-import type { TurnContext } from "../../../types.js";
 
 const log = getLogger("post-compact-reinject");
 
 /**
- * The slice of the hook's context the agent loop supplies from its own working
- * state. Re-injection inputs migrate loop-ward by growing this type; the loop
- * hands the hook an object of this shape when it calls
+ * Everything the post-compaction hook needs, supplied by the agent loop from
+ * its own working state. Re-injection inputs migrate loop-ward by growing this
+ * type; the loop hands the hook an object of this shape when it calls
  * {@link postCompactReinject} directly.
+ *
+ * The turn-identity fields are flat here: `conversationId` is the key the
+ * re-injection resolves the live conversation through (and the only one that,
+ * together with `requestId` and `trust`, cannot be recovered from that live
+ * conversation), while `turnIndex` and `callSite` are intentionally omitted so
+ * {@link applyRuntimeInjections} self-resolves them from the live conversation.
+ * The memory graph handle is likewise sourced internally via
+ * {@link getLiveGraphMemory} rather than threaded in.
  */
 export interface PostCompactionHookInput {
   /** Compacted message history to re-inject onto. */
   history: Message[];
   /**
-   * Per-turn conversation context forwarded to the injector chain. Its
-   * `conversationId` is the key the re-injection resolves the live
-   * conversation through, so the loop always supplies it.
+   * Stable ID for the current request, forwarded onto the injector turn
+   * context. The one turn-identity field that cannot be recovered from the
+   * live conversation, so the loop supplies it.
+   */
+  requestId: string | undefined;
+  /**
+   * Conversation the turn is scoped to. The key the re-injection resolves the
+   * live conversation (and its channel/trust/transcript state) through, so the
+   * loop always supplies it.
+   */
+  conversationId: string;
+  /**
+   * Trust classification and channel identity for the inbound actor, forwarded
+   * onto the injector turn context and used to gate the memory-graph re-track.
+   * Supplied by the loop as the turn-start snapshot rather than re-resolved
+   * mid-turn.
    */
-  turnContext: TurnContext;
+  trust: TrustContext;
   /**
    * Whether the in-flight turn has no human present to answer clarification
    * questions. Resolved once by the agent loop at turn start (from its
@@ -91,82 +113,40 @@ export interface PostCompactionHookInput {
   actorContext: InboundActorContext | null;
 }
 
-/**
- * Everything the hook needs in a single context: the loop-supplied
- * {@link PostCompactionHookInput} plus the non-identity
- * {@link RuntimeInjectionOptions} (spread top-level so each field stays
- * individually addressable). The turn-identity fields (`requestId`,
- * `conversationId`, `turnIndex`, `trust`, `callSite`) are omitted from the
- * inherited options because the hook sources them from
- * {@link PostCompactionHookInput.turnContext}; the memory graph handle is
- * likewise sourced internally via {@link getLiveGraphMemory} rather than
- * threaded in.
- */
-export interface PostCompactContext
-  extends
-    Omit<
-      RuntimeInjectionOptions,
-      "requestId" | "conversationId" | "turnIndex" | "trust" | "callSite"
-    >,
-    PostCompactionHookInput {
-  /**
-   * Re-declared to reconcile the optional {@link RuntimeInjectionOptions} field
-   * with the required {@link PostCompactionHookInput} one: the hook always
-   * receives this from the loop, and it flows into {@link applyRuntimeInjections}
-   * via the spread options.
-   */
-  isNonInteractive: boolean;
-  /**
-   * Re-declared for the same reason as {@link isNonInteractive}: required on
-   * {@link PostCompactionHookInput} but optional on {@link RuntimeInjectionOptions}.
-   */
-  mode: InjectionMode;
-  /**
-   * Re-declared for the same reason as {@link isNonInteractive}: required on
-   * {@link PostCompactionHookInput} but optional on {@link RuntimeInjectionOptions}.
-   */
-  modelProfile: string | null;
-  /**
-   * Re-declared for the same reason as {@link isNonInteractive}: required on
-   * {@link PostCompactionHookInput} but optional on {@link RuntimeInjectionOptions}.
-   */
-  actorContext: InboundActorContext | null;
-}
-
 export default async function postCompactReinject(
-  ctx: PostCompactContext,
+  ctx: PostCompactionHookInput,
 ): Promise<RuntimeInjectionResult> {
-  const { history, turnContext, ...options } = ctx;
-  // The loop hands its canonical per-turn context as a single `turnContext`;
-  // unnest its turn-identity fields onto the flat injection options so the
-  // re-injection resolves the same live conversation (and its channel/trust/
-  // transcript state) as the turn's initial assembly.
+  const { history, requestId, conversationId, trust, ...options } = ctx;
+  // The remaining `options` carry the non-identity injection inputs
+  // (`isNonInteractive`, `mode`, `modelProfile`, `actorContext`). Forward the
+  // turn-identity fields the live conversation can't supply (`requestId`,
+  // `conversationId`, `trust`); `turnIndex` and `callSite` self-resolve from
+  // the live conversation so the re-injection matches the turn's initial
+  // assembly.
   const result = await applyRuntimeInjections(history, {
     ...options,
-    requestId: turnContext.requestId,
-    conversationId: turnContext.conversationId,
-    turnIndex: turnContext.turnIndex,
-    trust: turnContext.trust,
-    callSite: turnContext.callSite,
+    requestId,
+    conversationId,
+    trust,
   });
   // Re-track the nodes the memory graph last injected so they survive against
   // the re-injected history. Untrusted actors and minimal-mode turns never
   // received a memory-graph injection, so there is nothing to re-track. The
   // actor's trust class is derived from the turn's own trust context (the same
-  // value the injector chain resolves), not threaded in from the loop. The
-  // live graph handle is looked up from the plugin's own registry by the
-  // turn's conversation id — the same instance the turn's retrieval mutated,
-  // so re-tracking sees the real cached-node state.
-  const isTrustedActor = resolveTrustClass(turnContext.trust) === "guardian";
+  // value the injector chain resolves). The live graph handle is looked up
+  // from the plugin's own registry by the turn's conversation id — the same
+  // instance the turn's retrieval mutated, so re-tracking sees the real
+  // cached-node state.
+  const isTrustedActor = resolveTrustClass(trust) === "guardian";
   if (isTrustedActor && options.mode !== "minimal") {
-    getLiveGraphMemory(turnContext.conversationId)?.retrackCachedNodes();
+    getLiveGraphMemory(conversationId)?.retrackCachedNodes();
   }
   const strip = stripHistoricalWebSearchResults(result.messages);
   if (strip.stats.blocksStripped > 0) {
     log.info(
       {
         phase: "mid-loop-compact",
-        conversationId: turnContext.conversationId,
+        conversationId,
         ...strip.stats,
       },
       "Converted historical web_search_tool_result blocks to text summaries",

package/src/runtime/__tests__/agent-wake.test.ts

@@ -47,7 +47,7 @@ interface WakeConversationProbe {
   runCalls: Array<{
     input: Message[];
     requestId?: string;
-    turnContext?: unknown;
+    trust?: unknown;
     allowedTools?: string[];
     order: number;
   }>;
@@ -369,7 +369,7 @@ function makeWakeConversation(options: {
         probe.runCalls.push({
           input: [...input],
           requestId: runOptions?.requestId,
-          turnContext: runOptions?.turnContext,
+          trust: runOptions?.trust,
           allowedTools: snapshotAllowedTools(),
           order: order++,
         });
@@ -520,7 +520,7 @@ describe("wakeAgentForOpportunity", () => {
     expect(conversation.runCalls).toHaveLength(0);
   });
 
-  test("builds a guardian turn context for explicit local-owner cleanup-mode wakes", async () => {
+  test("forwards a guardian trust snapshot for explicit local-owner cleanup-mode wakes", async () => {
     mockDiskPressureStatus = {
       enabled: true,
       state: "critical",
@@ -551,11 +551,9 @@ describe("wakeAgentForOpportunity", () => {
 
     expect(result).toEqual({ invoked: true, producedToolCalls: false });
     expect(conversation.runCalls).toHaveLength(1);
-    expect(conversation.runCalls[0]!.turnContext).toEqual({
-      requestId: "wake:local-cleanup",
-      conversationId: conversation.conversationId,
-      turnIndex: 0,
-      trust: { sourceChannel: "vellum", trustClass: "guardian" },
+    expect(conversation.runCalls[0]!.trust).toEqual({
+      sourceChannel: "vellum",
+      trustClass: "guardian",
     });
   });
 

package/src/runtime/agent-wake.ts

@@ -69,7 +69,6 @@ import {
   recordRequestLog,
   setAgentLoopExitReasonOnLatestLog,
 } from "../memory/llm-request-log-store.js";
-import type { TurnContext } from "../plugins/types.js";
 import type { Message } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
 
@@ -327,22 +326,24 @@ function classifyWakeDiskPressurePolicy(opts: WakeOptions): {
   return { decision, status };
 }
 
-function buildWakeTurnContext(
+/**
+ * Trust snapshot the wake hands to the agent loop. Only needed on the
+ * disk-pressure cleanup-mode path, whose guardian fallback lets the cleanup
+ * turn clear the side-effect approval gate; other wakes leave it unset (the
+ * loop has no compaction path during a wake, so trust is otherwise unread).
+ */
+function buildWakeTrust(
   opts: WakeOptions,
   decision: DiskPressureTurnPolicyDecision,
-): TurnContext | undefined {
+): TrustContext | undefined {
   if (decision.action !== "allow-cleanup-mode") return undefined;
-  return {
-    requestId: `wake:${opts.source}`,
-    conversationId: opts.conversationId,
-    turnIndex: 0,
-    trust:
-      opts.trustContext ??
-      ({
-        sourceChannel: opts.sourceChannel ?? "vellum",
-        trustClass: "guardian",
-      } satisfies TrustContext),
-  };
+  return (
+    opts.trustContext ??
+    ({
+      sourceChannel: opts.sourceChannel ?? "vellum",
+      trustClass: "guardian",
+    } satisfies TrustContext)
+  );
 }
 
 /**
@@ -482,7 +483,7 @@ export async function wakeAgentForOpportunity(
     // post-run would therefore include the tail we just pushed and the
     // tail-slice math would skip every message.
     const baselineLength = baseline.length;
-    const wakeTurnContext = buildWakeTurnContext(opts, diskPressureDecision);
+    const wakeTrust = buildWakeTrust(opts, diskPressureDecision);
     // Build the hint injection. Three modes:
     //   - `skipHintInjection`: caller has already persisted an instruction
     //     message into the conversation history (typical for fork-based
@@ -838,7 +839,7 @@ export async function wakeAgentForOpportunity(
             // short-circuit and silently drop both per-callsite config and the
             // pinned `overrideProfile` below.
             callSite,
-            turnContext: wakeTurnContext,
+            trust: wakeTrust,
             overrideProfile,
             // Wake runs have no orchestrator-side mid-loop compaction path,
             // so the budget gate stays disabled (`overflowRecovery.enabled =