@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

package/src/plugins/defaults/empty-response.ts

@@ -1,124 +0,0 @@
-/**
- * Default `emptyResponse` plugin.
- *
- * The plugin's middleware is a passthrough — it calls `next(args)` and returns
- * the result unchanged. The actual decision lives in
- * {@link defaultEmptyResponseTerminal}, which is wired in as the pipeline's
- * `terminal` argument by the `runPipeline` call site in `agent/loop.ts`. This
- * separation matters: the default plugin is registered before any user plugin
- * (defaults load first in `bootstrapPlugins()`), which puts it at the
- * OUTERMOST position of the onion chain. If the default middleware were to
- * decide directly without calling `next`, it would shadow every
- * later-registered plugin. Routing through `next(args)` lets user middleware
- * participate normally.
- *
- * Wiring the terminal at the call site (rather than relying on the plugin to
- * be registered) also means the loop's nudge/accept/error behavior survives
- * configurations that boot without the default plugin — e.g. unit tests that
- * skip `bootstrapPlugins()`.
- *
- * The terminal inspects the turn snapshot and returns one of:
- *
- * 1. `"nudge"`  — the turn produced no visible text, no tool calls, follows
- *                 at least one prior tool-use turn, no earlier turn in this
- *                 run() has already delivered visible text, AND the retry
- *                 counter is below `maxEmptyResponseRetries`. The loop
- *                 appends `nudgeText` (the `<system_notice>…` message below)
- *                 as a `user` turn and re-queries the model.
- * 2. `"accept"` — every other case. The turn either legitimately ended
- *                 (model said its piece earlier), is still in progress
- *                 (tool calls pending), or exhausted its retry budget. The
- *                 loop pushes the assistant message and continues normally.
- *
- * The default never returns `"error"` — that action is an escape hatch for
- * downstream plugins (e.g. a circuit breaker) that want to surface an
- * explicit error instead of silently absorbing an empty turn.
- *
- * `MAX_EMPTY_RESPONSE_RETRIES` lives in `agent/loop.ts` and is threaded into
- * the pipeline via `EmptyResponseArgs.maxEmptyResponseRetries` so the cap is
- * declared in one place only.
- */
-
-import { registerPlugin } from "../registry.js";
-import {
-  type EmptyResponseArgs,
-  type EmptyResponseResult,
-  type Middleware,
-  type Plugin,
-  PluginExecutionError,
-} from "../types.js";
-
-/**
- * Canonical nudge text. Must stay verbatim so a plugin that wraps the
- * default cannot accidentally see a different string.
- *
- * Wire-compat note: this is shown to the LLM, not the user. Edits here
- * affect model behavior but not end-user UX directly.
- */
-const NUDGE_TEXT =
-  "<system_notice>Your previous response was empty. You must respond to the user with a summary of what you found or did. Do not use any tools — just respond with text.</system_notice>";
-
-/**
- * Terminal handler for the `emptyResponse` pipeline. Exported so tests can
- * verify default behavior directly without going through `runPipeline`, and
- * so `agent/loop.ts` can pass it as the `terminal` argument to `runPipeline`.
- */
-export function defaultEmptyResponseTerminal(
-  args: EmptyResponseArgs,
-): EmptyResponseResult {
-  const hasVisibleText = args.responseContent.some(
-    (block) =>
-      block.type === "text" &&
-      typeof (block as { text?: unknown }).text === "string" &&
-      (block as { text: string }).text.trim().length > 0,
-  );
-
-  const isEmptyTurn =
-    !hasVisibleText &&
-    args.toolUseBlocksLength === 0 &&
-    args.toolUseTurns > 0 &&
-    !args.priorAssistantHadVisibleText;
-
-  if (isEmptyTurn && args.emptyResponseRetries < args.maxEmptyResponseRetries) {
-    return { action: "nudge", nudgeText: NUDGE_TEXT };
-  }
-  return { action: "accept" };
-}
-
-const passthrough: Middleware<EmptyResponseArgs, EmptyResponseResult> = async (
-  args,
-  next,
-) => next(args);
-
-/** Singleton plugin — the registry rejects duplicate registrations by name. */
-export const defaultEmptyResponsePlugin: Plugin = {
-  manifest: {
-    name: "default-empty-response",
-    version: "1.0.0",
-  },
-  middleware: {
-    emptyResponse: passthrough,
-  },
-};
-
-// Module-load side effect: register this default at import time so
-// downstream consumers (including tests that skip `bootstrapPlugins()`)
-// observe a populated registry by default. Idempotent via the swallowed
-// duplicate-name check. Kept local to this module (rather than iterating
-// an array in `defaults/index.ts`) so the registration only references
-// the already-initialized `defaultEmptyResponsePlugin` identifier —
-// avoiding a TDZ crash when tests `mock.module(...)` a dependency of any
-// other default plugin and directly import this file.
-try {
-  registerPlugin(defaultEmptyResponsePlugin);
-} catch (err) {
-  if (
-    err instanceof PluginExecutionError &&
-    err.message.includes("already registered")
-  ) {
-    // already registered — expected when both index.ts and the direct
-    // file are imported in the same process
-  } else {
-    throw err;
-  }
-}

package/src/plugins/defaults/history-repair.ts

@@ -1,83 +0,0 @@
-/**
- * Default `historyRepair` plugin.
- *
- * The plugin's middleware is a passthrough — it calls `next(args)` and returns
- * the result unchanged. The actual repair lives in
- * {@link defaultHistoryRepairTerminal}, which is wired in as the pipeline's
- * `terminal` argument by `runPipeline` call sites in
- * `daemon/conversation-agent-loop.ts`. This separation matters: the default
- * plugin is registered before any user plugin (defaults load first in
- * `bootstrapPlugins()`), which puts it at the OUTERMOST position of the onion
- * chain. If the default middleware were to invoke the terminal directly
- * without calling `next`, it would shadow every later-registered plugin.
- * Routing through `next(args)` lets user middleware participate normally.
- *
- * Plugins that override this middleware receive both `history` and `provider`
- * so they can route behavior per provider (e.g. strip blocks a specific
- * provider can't handle) without reaching into ambient state.
- *
- * Scope: this pipeline wraps only the standard pre-run repair (`repairHistory`).
- * The orchestrator's one-shot deep-repair fallback (`deepRepairHistory`),
- * invoked only after a provider ordering error, intentionally bypasses the
- * pipeline today — see the design note at the `deepRepairHistory` call site
- * in `daemon/conversation-agent-loop.ts`.
- */
-
-import { repairHistory } from "../../daemon/history-repair.js";
-import { registerPlugin } from "../registry.js";
-import {
-  type HistoryRepairArgs,
-  type HistoryRepairResult,
-  type Middleware,
-  type Plugin,
-  PluginExecutionError,
-} from "../types.js";
-
-/**
- * Terminal handler for the `historyRepair` pipeline. Exported so tests can
- * verify default behavior directly without going through `runPipeline`, and
- * so `daemon/conversation-agent-loop.ts` can pass it as the `terminal`
- * argument to `runPipeline`.
- */
-export function defaultHistoryRepairTerminal(
-  args: HistoryRepairArgs,
-): HistoryRepairResult {
-  return repairHistory(args.history);
-}
-
-const passthrough: Middleware<HistoryRepairArgs, HistoryRepairResult> = async (
-  args,
-  next,
-) => next(args);
-
-export const defaultHistoryRepairPlugin: Plugin = {
-  manifest: {
-    name: "default-history-repair",
-    version: "1.0.0",
-  },
-  middleware: {
-    historyRepair: passthrough,
-  },
-};
-
-// Module-load side effect: register this default at import time so
-// downstream consumers (including tests that skip `bootstrapPlugins()`)
-// observe a populated registry by default. Idempotent via the swallowed
-// duplicate-name check. Kept local to this module (rather than iterating
-// an array in `defaults/index.ts`) so the registration only references
-// the already-initialized `defaultHistoryRepairPlugin` identifier —
-// avoiding a TDZ crash when tests `mock.module(...)` a dependency of any
-// other default plugin and directly import this file.
-try {
-  registerPlugin(defaultHistoryRepairPlugin);
-} catch (err) {
-  if (
-    err instanceof PluginExecutionError &&
-    err.message.includes("already registered")
-  ) {
-    // already registered — expected when both index.ts and the direct
-    // file are imported in the same process
-  } else {
-    throw err;
-  }
-}

package/src/plugins/defaults/llm-call.ts

@@ -1,77 +0,0 @@
-/**
- * Default `llmCall` plugin — a passthrough that declares the pipeline
- * surface and yields to downstream middleware.
- *
- * The plugin system wraps every LLM request in the `llmCall` pipeline. The
- * actual call to {@link Provider.sendMessage} lives in the `runPipeline`
- * terminal at the call site (`agent/loop.ts`); this default's only job is to
- * contribute the manifest (`provides.llmCall: "v1"`) so other plugins can
- * negotiate against the pipeline surface.
- *
- * This plugin registers at module load — before user plugins are loaded by
- * `bootstrapPlugins()` — so it sits at the outermost layer in
- * `composeMiddleware`'s onion ordering. To keep user-registered middleware
- * reachable, the middleware forwards unconditionally via `next(args)`.
- *
- * Registered from `daemon/external-plugins-bootstrap.ts` via a side-effect
- * import so the plugin is present in the registry before
- * {@link bootstrapPlugins} walks it.
- *
- * Design doc: `.private/plans/agent-plugin-system.md` (PR 15).
- */
-
-import { registerPlugin } from "../registry.js";
-import {
-  type LLMCallArgs,
-  type LLMCallResult,
-  type Plugin,
-  PluginExecutionError,
-} from "../types.js";
-
-/**
- * The default LLM-call plugin. Its `llmCall` middleware is a passthrough that
- * forwards to `next(args)` unchanged so any user-registered middleware
- * (registered later, inner in the onion) still runs and the terminal at the
- * call site performs the actual `provider.sendMessage(...)` call.
- *
- * Manifest declares `provides.llmCall: "v1"` so other plugins can negotiate
- * against the pipeline surface and `requires.pluginRuntime: "v1"` to satisfy
- * the registry's mandatory capability check.
- */
-export const defaultLlmCallPlugin: Plugin = {
-  manifest: {
-    name: "default-llm-call",
-    version: "1.0.0",
-  },
-  middleware: {
-    llmCall: async function defaultLlmCall(
-      args: LLMCallArgs,
-      next,
-      _ctx,
-    ): Promise<LLMCallResult> {
-      return next(args);
-    },
-  },
-};
-
-// Module-load side effect: register this default at import time so
-// downstream consumers (including tests that skip `bootstrapPlugins()`)
-// observe a populated registry by default. Idempotent via the swallowed
-// duplicate-name check. Kept local to this module (rather than iterating
-// an array in `defaults/index.ts`) so the registration only references
-// the already-initialized `defaultLlmCallPlugin` identifier —
-// avoiding a TDZ crash when tests `mock.module(...)` a dependency of any
-// other default plugin and directly import this file.
-try {
-  registerPlugin(defaultLlmCallPlugin);
-} catch (err) {
-  if (
-    err instanceof PluginExecutionError &&
-    err.message.includes("already registered")
-  ) {
-    // already registered — expected when both index.ts and the direct
-    // file are imported in the same process
-  } else {
-    throw err;
-  }
-}

package/src/plugins/defaults/memory-retrieval.ts

@@ -1,219 +0,0 @@
-/**
- * Default `memoryRetrieval` plugin.
- *
- * Encapsulates the three retrievals the agent loop performs before building
- * the runtime-injection block for a turn:
- *
- * 1. **PKB context** via {@link readPkbContext} — always-loaded workspace
- *    notes (INDEX.md, essentials.md, …) that precede the user's message.
- * 2. **NOW.md scratchpad** via {@link readNowScratchpad} — the short
- *    user-maintained note the assistant keeps up to date.
- * 3. **Memory graph** via {@link ConversationGraphMemory.prepareMemory} —
- *    dispatches to context-load or per-turn retrieval depending on
- *    initialization state; gated on the actor being trusted (guardian).
- *
- * The default plugin registers a pass-through middleware so the pipeline
- * runner always has at least one entry and downstream telemetry observes a
- * deterministic chain. The actual retrieval runs in the terminal supplied
- * by the agent loop; centralizing the helper here (as
- * {@link runDefaultMemoryRetrieval}) makes it trivial for a plugin to
- * fall back to the default behavior by calling this helper from its own
- * middleware.
- *
- * See `.private/plans/agent-plugin-system.md` PR 20 for the containing
- * milestone.
- */
-
-import type { AssistantConfig } from "../../config/schema.js";
-import {
-  readNowScratchpad,
-  readPkbContext,
-} from "../../daemon/conversation-runtime-assembly.js";
-import type { ServerMessage } from "../../daemon/message-protocol.js";
-import type { ConversationGraphMemory } from "../../memory/graph/conversation-graph-memory.js";
-import type { Message } from "../../providers/types.js";
-import { registerPlugin } from "../registry.js";
-import {
-  type MemoryArgs,
-  type MemoryResult,
-  type Middleware,
-  type Plugin,
-  PluginExecutionError,
-} from "../types.js";
-
-/**
- * Discriminator the agent loop uses to narrow `MemoryResult.memoryGraphBlocks`
- * back into the full {@link GraphMemoryPayload} shape. Plugins that substitute
- * their own memory blocks without setting this marker will fall through the
- * agent loop's graph-result consumption path — which is the intended escape
- * hatch for custom retrievers.
- */
-export const DEFAULT_MEMORY_GRAPH_KIND = "default.graph" as const;
-
-/**
- * Shape of the single block the default memory-graph retriever emits.
- *
- * Mirrors the object returned by
- * {@link ConversationGraphMemory.prepareMemory} — the agent loop consumes
- * every field downstream (PKB query vectors, metrics persistence, memory
- * event emission). Kept as a concrete type here so both the terminal and the
- * agent loop can share one import.
- */
-export interface GraphMemoryPayload {
-  readonly kind: typeof DEFAULT_MEMORY_GRAPH_KIND;
-  readonly result: Awaited<
-    ReturnType<ConversationGraphMemory["prepareMemory"]>
-  >;
-}
-
-/**
- * External state the default retriever needs but the pipeline args cannot
- * carry (conversation-scoped graph handle, event sink, live message list).
- * Passed as a second argument to {@link runDefaultMemoryRetrieval} rather
- * than threaded through {@link MemoryArgs} to keep the plugin-facing
- * pipeline surface minimal.
- */
-export interface DefaultMemoryRetrievalDeps {
-  /** Live message list for this turn (pre-injection). */
-  readonly messages: Message[];
-  /** Per-conversation memory graph handle. */
-  readonly graphMemory: ConversationGraphMemory;
-  /** Assistant config snapshot. */
-  readonly config: AssistantConfig;
-  /** Event sink used by the graph retriever (memory_status events). */
-  readonly onEvent: (msg: ServerMessage) => void;
-  /** True when the actor for this turn is trusted (guardian-class). */
-  readonly isTrustedActor: boolean;
-}
-
-/**
- * Run the default retrieval. Always returns a {@link MemoryResult}; skips
- * the memory-graph call entirely when the actor is not trusted (matches the
- * prior agent-loop gate).
- *
- * The returned `memoryGraphBlocks` is either empty (when the actor is not
- * trusted) or a single {@link GraphMemoryPayload} wrapping the graph
- * retriever's full output. The agent loop narrows via
- * {@link DEFAULT_MEMORY_GRAPH_KIND} to consume it.
- *
- * Memory retrieval blocks the turn — there is no soft timeout here. Memory
- * is critical context, and silently dropping it produces a worse outcome
- * than a slower turn. Cancellation still works via `args.signal`, which is
- * threaded into `prepareMemory`.
- */
-export async function runDefaultMemoryRetrieval(
-  args: MemoryArgs,
-  deps: DefaultMemoryRetrievalDeps,
-): Promise<MemoryResult> {
-  // NOW.md and PKB are read unconditionally — the agent loop decides
-  // whether to inject them based on first-turn / post-compaction gating.
-  const pkbContent = readPkbContext();
-  const nowContent = readNowScratchpad();
-
-  if (!deps.isTrustedActor) {
-    // Untrusted actors skip memory-graph retrieval entirely — preserves the
-    // pre-plugin gate that lived inline in `conversation-agent-loop.ts`.
-    return {
-      pkbContent,
-      nowContent,
-      memoryGraphBlocks: [],
-    };
-  }
-
-  const graphResult = await deps.graphMemory.prepareMemory(
-    deps.messages,
-    deps.config,
-    args.signal,
-    deps.onEvent,
-  );
-
-  const payload: GraphMemoryPayload = {
-    kind: DEFAULT_MEMORY_GRAPH_KIND,
-    result: graphResult,
-  };
-
-  return {
-    pkbContent,
-    nowContent,
-    memoryGraphBlocks: [payload],
-  };
-}
-
-/**
- * Narrow a {@link MemoryResult} memory-graph block back into the full
- * {@link GraphMemoryPayload} the default retriever emits. Returns `null` when
- * the pipeline output came from a custom retriever (no blocks, or a block
- * without the {@link DEFAULT_MEMORY_GRAPH_KIND} discriminator).
- *
- * The agent loop uses this helper to decide whether to run its downstream
- * graph-result consumption path (query-vector propagation, metric
- * persistence, memory-event emission). Custom retrievers that skip that
- * path are expected to handle their own side effects inside their
- * middleware.
- */
-export function asDefaultGraphPayload(
-  blocks: ReadonlyArray<unknown>,
-): GraphMemoryPayload | null {
-  const first = blocks[0];
-  if (
-    first != null &&
-    typeof first === "object" &&
-    "kind" in first &&
-    (first as { kind?: unknown }).kind === DEFAULT_MEMORY_GRAPH_KIND
-  ) {
-    return first as GraphMemoryPayload;
-  }
-  return null;
-}
-
-/**
- * Default `memoryRetrieval` middleware — a pure pass-through.
- *
- * Keeping a real middleware registered (rather than an empty list) makes
- * the pipeline observable in `plugin.pipeline` logs with a non-empty
- * `chain` field and lets third-party plugins rely on the default slot
- * being present even when nothing is overriding it. The work happens in
- * the terminal supplied by the agent loop, which calls
- * {@link runDefaultMemoryRetrieval}.
- */
-const defaultMemoryRetrievalMiddleware: Middleware<MemoryArgs, MemoryResult> =
-  async function defaultMemoryRetrieval(args, next) {
-    return next(args);
-  };
-
-/**
- * Default plugin exposing the `memoryRetrieval` pipeline slot. Registered
- * by {@link registerDefaultMemoryRetrievalPlugin} from the plugin
- * bootstrap wiring so ordering is deterministic across boots.
- */
-export const defaultMemoryRetrievalPlugin: Plugin = {
-  manifest: {
-    name: "default-memory-retrieval",
-    version: "0.0.1",
-  },
-  middleware: {
-    memoryRetrieval: defaultMemoryRetrievalMiddleware,
-  },
-};
-
-// Module-load side effect: register this default at import time so
-// downstream consumers (including tests that skip `bootstrapPlugins()`)
-// observe a populated registry by default. Idempotent via the swallowed
-// duplicate-name check. Kept local to this module (rather than iterating
-// an array in `defaults/index.ts`) so the registration only references
-// the already-initialized `defaultMemoryRetrievalPlugin` identifier —
-// avoiding a TDZ crash when tests `mock.module(...)` a dependency of any
-// other default plugin and directly import this file.
-try {
-  registerPlugin(defaultMemoryRetrievalPlugin);
-} catch (err) {
-  if (
-    err instanceof PluginExecutionError &&
-    err.message.includes("already registered")
-  ) {
-    // already registered — expected when both index.ts and the direct
-    // file are imported in the same process
-  } else {
-    throw err;
-  }
-}

package/src/plugins/defaults/overflow-reduce.ts

@@ -1,185 +0,0 @@
-/**
- * Default `overflowReduce` plugin — extracted verbatim from the inline
- * preflight reducer loop that previously lived in
- * `daemon/conversation-agent-loop.ts` (the `while (preflightAttempts < …)`
- * block around lines 1045–1156 before PR 23).
- *
- * The plugin owns the reducer tier-loop (forced compaction, tool-result
- * truncation, media stubbing, injection downgrade) and the post-step
- * re-injection / re-estimation dance. Orchestrator-specific coupling
- * (activity emission, circuit-breaker tracking, compaction-result
- * application, runtime injection reassembly) is threaded in through the
- * callbacks carried on {@link OverflowReduceArgs}; the plugin itself has no
- * access to the agent-loop context object.
- *
- * The forced-compaction tier runs through the orchestrator-supplied
- * `compactFn`, which routes into the `compaction` plugin pipeline so
- * registered compaction middleware observes reducer-initiated invocations
- * alongside the orchestrator-owned call sites. Non-compaction tiers
- * (tool-result truncation, media stubbing, injection downgrade) remain
- * in-process: they mutate message arrays directly without crossing a
- * pipeline boundary. The reducer itself runs under the `overflowReduce`
- * pipeline, so the full layering is `overflowReduce` → reducer tier loop
- * → (for the forced-compaction tier only) nested `compaction` pipeline.
- */
-
-import type { ContextWindowCompactOptions } from "../../context/window-manager.js";
-import {
-  createInitialReducerState,
-  reduceContextOverflow,
-  type ReducerState,
-} from "../../daemon/context-overflow-reducer.js";
-import { registerPlugin } from "../registry.js";
-import {
-  type Middleware,
-  type OverflowReduceArgs,
-  type OverflowReduceResult,
-  type Plugin,
-  PluginExecutionError,
-} from "../types.js";
-
-/**
- * Default middleware — implements the historical tier-loop semantics.
- *
- * The middleware intentionally ignores `next`. Overflow reduction is a
- * *terminal* behavior: there is no downstream implementation to defer to
- * when a user-supplied middleware short-circuits. Later plugins may still
- * wrap this one (outer middleware can observe each reduction iteration via
- * their own `next` callback) but the default never delegates to a
- * hypothetical base handler — the inline loop was the base.
- */
-export const defaultOverflowReduceMiddleware: Middleware<
-  OverflowReduceArgs,
-  OverflowReduceResult
-> = async function defaultOverflowReduceMiddleware(args, _next, _ctx) {
-  let messages = args.messages;
-  let runMessages = args.runMessages;
-  let injectionMode: "full" | "minimal" = "full";
-  let reducerState: ReducerState = createInitialReducerState();
-  let reducerCompacted = false;
-  let attempts = 0;
-
-  while (attempts < args.maxAttempts && !reducerState.exhausted) {
-    // Abort check at the top of every iteration. When the pipeline runner
-    // arms a timeout (or the caller aborts externally), `args.abortSignal`
-    // is linked to that trigger via `linkAbortSignal`, so this check lets
-    // us bail out BETWEEN iterations rather than letting another round of
-    // compaction / re-injection mutate `ctx.messages` after the turn has
-    // already failed. Individual `reduceContextOverflow` calls also honor
-    // the signal, but without this gate a fresh iteration could still
-    // start after the signal fires, since the previous one returned
-    // normally before the abort propagated.
-    args.abortSignal?.throwIfAborted();
-
-    attempts++;
-    args.emitActivityState();
-
-    const basisMessages = messages;
-    const step = await reduceContextOverflow(
-      basisMessages,
-      {
-        providerName: args.providerName,
-        systemPrompt: args.systemPrompt,
-        contextWindow: args.contextWindow,
-        targetTokens: args.preflightBudget,
-        toolTokenBudget: args.toolTokenBudget,
-      },
-      reducerState,
-      (msgs, signal, opts: ContextWindowCompactOptions) =>
-        args.compactFn(msgs, signal, opts),
-      args.abortSignal,
-    );
-
-    reducerState = step.state;
-    messages = step.messages;
-    injectionMode = step.state.injectionMode;
-
-    // Per-iteration compaction flag: whether THIS step just produced a
-    // fresh compaction. PKB / NOW re-injection is gated on this — see the
-    // reinjectForMode JSDoc for why the two signals differ.
-    const stepCompacted = step.compactionResult?.compacted === true;
-
-    // Let the orchestrator apply compaction side effects (circuit-breaker
-    // tracking, event emission, ctx mutation) before we re-inject.
-    if (step.compactionResult) {
-      await args.onCompactionResult(step.compactionResult, basisMessages);
-      if (stepCompacted) {
-        reducerCompacted = true;
-      }
-    }
-
-    // Second abort gate — if the side effects or the step itself took us
-    // past the deadline, don't rebuild runMessages or iterate again.
-    args.abortSignal?.throwIfAborted();
-
-    // Rebuild runMessages via the orchestrator-supplied helper (which
-    // re-runs `applyRuntimeInjections` with potentially downgraded mode
-    // and freshly re-hydrated PKB/NOW blocks after compaction). We pass
-    // the current reduced `messages` explicitly so the orchestrator never
-    // has to read from mutable shared state to rebuild runMessages — a
-    // tier that doesn't trigger compaction (tool-result truncation, media
-    // stubbing) won't update `ctx.messages` on its own.
-    //
-    // `stepCompacted` and `reducerCompacted` are both passed so the
-    // orchestrator can gate PKB / NOW re-injection per-iteration while
-    // keeping `slackChronologicalMessages` suppressed once any iteration
-    // has compacted.
-    runMessages = await args.reinjectForMode(
-      messages,
-      injectionMode,
-      stepCompacted,
-      reducerCompacted,
-    );
-
-    // Re-estimate with injections included — `step.estimatedTokens` was
-    // computed on bare history and doesn't account for tokens added by
-    // runtime injections.
-    const postInjectionTokens = args.estimatePostInjection(runMessages);
-    if (postInjectionTokens <= args.preflightBudget) break;
-  }
-
-  return {
-    messages,
-    runMessages,
-    injectionMode,
-    reducerState,
-    reducerCompacted,
-    attempts,
-  };
-};
-
-/**
- * The default plugin registered at bootstrap. No `init`/`onShutdown` —
- * registering the middleware is the only behavior.
- */
-export const defaultOverflowReducePlugin: Plugin = {
-  manifest: {
-    name: "default-overflow-reduce",
-    version: "1.0.0",
-  },
-  middleware: {
-    overflowReduce: defaultOverflowReduceMiddleware,
-  },
-};
-
-// Module-load side effect: register this default at import time so
-// downstream consumers (including tests that skip `bootstrapPlugins()`)
-// observe a populated registry by default. Idempotent via the swallowed
-// duplicate-name check. Kept local to this module (rather than iterating
-// an array in `defaults/index.ts`) so the registration only references
-// the already-initialized `defaultOverflowReducePlugin` identifier —
-// avoiding a TDZ crash when tests `mock.module(...)` a dependency of any
-// other default plugin and directly import this file.
-try {
-  registerPlugin(defaultOverflowReducePlugin);
-} catch (err) {
-  if (
-    err instanceof PluginExecutionError &&
-    err.message.includes("already registered")
-  ) {
-    // already registered — expected when both index.ts and the direct
-    // file are imported in the same process
-  } else {
-    throw err;
-  }
-}