@vellumai/assistant 0.8.7 → 0.8.8-dev.202606052332.17fc8ea

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

@@ -1,181 +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 {
-  type MemoryArgs,
-  type MemoryResult,
-  type Plugin,
-} from "../../types.js";
-import defaultMemoryRetrievalMiddleware from "./middlewares/memoryRetrieval.js";
-import pkg from "./package.json" with { type: "json" };
-
-/**
- * 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 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: pkg.name,
-    version: pkg.version,
-  },
-  middleware: {
-    memoryRetrieval: defaultMemoryRetrievalMiddleware,
-  },
-};

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

@@ -1,126 +0,0 @@
-import type { ContextWindowCompactOptions } from "../../../../context/window-manager.js";
-import {
-  createInitialReducerState,
-  reduceContextOverflow,
-  type ReducerState,
-} from "../../../../daemon/context-overflow-reducer.js";
-import type {
-  Middleware,
-  OverflowReduceArgs,
-  OverflowReduceResult,
-} from "../../../types.js";
-
-/**
- * Default middleware for the `overflowReduce` pipeline — implements the
- * historical tier-loop semantics (forced compaction, tool-result truncation,
- * media stubbing, injection downgrade) plus the post-step re-injection /
- * re-estimation dance.
- *
- * 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.
- */
-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,
-  };
-};
-
-export default defaultOverflowReduceMiddleware;

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

@@ -1,15 +0,0 @@
-{
-  "name": "default-overflow-reduce",
-  "version": "1.0.0",
-  "description": "First-party default plugin wrapping the assistant's built-in overflow-reduce pipeline with a passthrough implementation.",
-  "private": true,
-  "license": "MIT",
-  "type": "module",
-  "main": "./register.ts",
-  "engines": {
-    "node": ">=20.12.0"
-  },
-  "peerDependencies": {
-    "@vellumai/plugin-api": "^0.8.0"
-  }
-}

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

@@ -1,42 +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 Plugin } from "../../types.js";
-import defaultOverflowReduceMiddleware from "./middlewares/overflowReduce.js";
-import pkg from "./package.json" with { type: "json" };
-
-/**
- * The default plugin registered at bootstrap. No `init`/`onShutdown` —
- * registering the middleware is the only behavior.
- */
-export const defaultOverflowReducePlugin: Plugin = {
-  manifest: {
-    name: pkg.name,
-    version: pkg.version,
-  },
-  middleware: {
-    overflowReduce: defaultOverflowReduceMiddleware,
-  },
-};

package/src/plugins/defaults/persistence/middlewares/persistence.ts

@@ -1,19 +0,0 @@
-import type { Middleware, PersistArgs, PersistResult } from "../../../types.js";
-
-/**
- * Passthrough middleware for the `persistence` pipeline. Forwards to
- * `next(args)` unchanged; the actual dispatch lives in the terminal handler
- * (`../terminal.ts`), wired in at the `runPipeline` call sites in
- * `daemon/conversation-agent-loop.ts` and
- * `daemon/conversation-agent-loop-handlers.ts`.
- *
- * Defaults register at the OUTERMOST onion position, so deciding here without
- * calling `next` would shadow every later-registered plugin. Routing through
- * `next(args)` lets user middleware participate normally.
- */
-const passthrough: Middleware<PersistArgs, PersistResult> = async (
-  args,
-  next,
-) => next(args);
-
-export default passthrough;

package/src/plugins/defaults/persistence/package.json

@@ -1,15 +0,0 @@
-{
-  "name": "default-persistence",
-  "version": "1.0.0",
-  "description": "First-party default plugin wrapping the assistant's built-in persistence pipeline with a passthrough implementation.",
-  "private": true,
-  "license": "MIT",
-  "type": "module",
-  "main": "./register.ts",
-  "engines": {
-    "node": ">=20.12.0"
-  },
-  "peerDependencies": {
-    "@vellumai/plugin-api": "^0.8.0"
-  }
-}

package/src/plugins/defaults/persistence/register.ts

@@ -1,38 +0,0 @@
-/**
- * Default `persistence` plugin.
- *
- * The plugin's middleware is a passthrough — it calls `next(args)` and returns
- * the result unchanged. The actual dispatch lives in the terminal handler in
- * `./terminal.ts`, which is wired in as the pipeline's `terminal` argument by
- * `runPipeline` call sites in `daemon/conversation-agent-loop.ts` and
- * `daemon/conversation-agent-loop-handlers.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.
- *
- * Manifest declares `provides.persistence: "v1"` so other plugins can
- * negotiate against the pipeline surface and `requires.pluginRuntime: "v1"`
- * to satisfy the registry's mandatory capability check.
- *
- * 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 27).
- */
-
-import { type Plugin } from "../../types.js";
-import persistence from "./middlewares/persistence.js";
-import pkg from "./package.json" with { type: "json" };
-
-export const defaultPersistencePlugin: Plugin = {
-  manifest: {
-    name: pkg.name,
-    version: pkg.version,
-  },
-  middleware: {
-    persistence,
-  },
-};

package/src/plugins/defaults/persistence/terminal.ts

@@ -1,83 +0,0 @@
-/**
- * Default `persistence` behavior: writes conversation messages to the database
- * (and optionally the JSONL disk view).
- *
- * This module is side-effect free: importing it does not register any plugin.
- *
- * The handler dispatches on the discriminated {@link PersistArgs.op} field:
- *
- * - `add`           → {@link addMessage}, optionally followed by
- *                     {@link syncMessageToDisk} when `args.syncToDisk` is true.
- * - `reserve`       → {@link reserveMessage} — pre-allocates an empty row
- *                     for assistant anchor stamping.
- * - `updateContent` → {@link updateMessageContent} — overwrites an existing
- *                     row's content (returns `void`, wrapped as
- *                     `{ op: "updateContent" }`).
- * - `update`        → {@link updateMessageMetadata} (returns `void`, wrapped
- *                     as `{ op: "update" }`).
- * - `delete`        → {@link deleteMessageById} (returns the segment/summary
- *                     IDs the caller must clean up out-of-band).
- */
-
-import {
-  addMessage,
-  deleteMessageById,
-  reserveMessage,
-  updateMessageContent,
-  updateMessageMetadata,
-} from "../../../memory/conversation-crud.js";
-import { syncMessageToDisk } from "../../../memory/conversation-disk-view.js";
-import type { PersistArgs, PersistResult } from "../../types.js";
-
-/**
- * Persist a message according to `args.op`. Exported so the agent-loop call
- * sites can invoke it directly and tests can verify each op in isolation.
- */
-export async function defaultPersistenceTerminal(
-  args: PersistArgs,
-): Promise<PersistResult> {
-  switch (args.op) {
-    case "add": {
-      const message = await addMessage(
-        args.conversationId,
-        args.role,
-        args.content,
-        {
-          metadata: args.metadata,
-          ...args.addOptions,
-        },
-      );
-      // Sync the just-persisted row to the JSONL disk view when the caller
-      // opted in. The handler that emits tool-result rows sets
-      // `syncToDisk: true` so the disk view stays in lockstep with the DB.
-      if (args.syncToDisk && args.createdAtMs !== undefined) {
-        syncMessageToDisk(args.conversationId, message.id, args.createdAtMs);
-      }
-      return { op: "add", message };
-    }
-    case "reserve": {
-      const message = await reserveMessage(
-        args.conversationId,
-        args.role,
-        args.metadata,
-      );
-      return { op: "reserve", message };
-    }
-    case "updateContent": {
-      updateMessageContent(args.messageId, args.content);
-      return { op: "updateContent" };
-    }
-    case "update": {
-      updateMessageMetadata(args.messageId, args.updates);
-      return { op: "update" };
-    }
-    case "delete": {
-      const deleted = deleteMessageById(args.messageId);
-      return {
-        op: "delete",
-        segmentIds: deleted.segmentIds,
-        deletedSummaryIds: deleted.deletedSummaryIds,
-      };
-    }
-  }
-}

package/src/plugins/defaults/title-generate/terminal.ts

@@ -1,31 +0,0 @@
-/**
- * Default `titleGenerate` behavior: kicks off conversation-title generation.
- *
- * This module is side-effect free: importing it does not register any plugin.
- *
- * Delegates to {@link queueGenerateConversationTitle}, which schedules title
- * generation as fire-and-forget background work and falls back to a
- * deterministic placeholder on failure.
- */
-
-import { queueGenerateConversationTitle } from "../../../memory/conversation-title-service.js";
-import type { TitleArgs, TitleResult } from "../../types.js";
-
-/**
- * Invoke the title-generation service with the provided arguments. Exported
- * for tests that want to exercise the default directly.
- *
- * Returns an empty result — the service is fire-and-forget and surfaces its
- * output through `onTitleUpdated`.
- */
-export async function defaultTitleGenerateTerminal(
-  args: TitleArgs,
-): Promise<TitleResult> {
-  queueGenerateConversationTitle({
-    conversationId: args.conversationId,
-    provider: args.provider,
-    userMessage: args.userMessage,
-    onTitleUpdated: args.onTitleUpdated,
-  });
-  return {};
-}

package/src/plugins/defaults/token-estimate/middlewares/tokenEstimate.ts

@@ -1,23 +0,0 @@
-import type {
-  EstimateArgs,
-  EstimateResult,
-  Middleware,
-} from "../../../types.js";
-
-/**
- * Passthrough middleware for the `tokenEstimate` pipeline. Forwards to
- * `next(args)` unchanged; the actual estimate lives in the terminal handler
- * (`../terminal.ts`), wired in at the `runPipeline` call sites in
- * `daemon/conversation-agent-loop.ts`.
- *
- * Defaults register at the OUTERMOST onion position, so deciding here without
- * calling `next` would shadow every later-registered plugin. The passthrough
- * lets user middleware that wraps the default (e.g. a doubler, a
- * provider-native `countTokens` override) participate normally.
- */
-const passthrough: Middleware<EstimateArgs, EstimateResult> = async (
-  args,
-  next,
-) => next(args);
-
-export default passthrough;

package/src/plugins/defaults/token-estimate/package.json

@@ -1,15 +0,0 @@
-{
-  "name": "default-token-estimate",
-  "version": "1.0.0",
-  "description": "First-party default plugin wrapping the assistant's built-in token-estimate pipeline with a passthrough implementation.",
-  "private": true,
-  "license": "MIT",
-  "type": "module",
-  "main": "./register.ts",
-  "engines": {
-    "node": ">=20.12.0"
-  },
-  "peerDependencies": {
-    "@vellumai/plugin-api": "^0.8.0"
-  }
-}

package/src/plugins/defaults/token-estimate/register.ts

@@ -1,34 +0,0 @@
-/**
- * Default `tokenEstimate` plugin.
- *
- * The plugin's middleware is a passthrough — it calls `next(args)` and returns
- * the result unchanged. The actual estimate lives in the terminal handler in
- * `./terminal.ts`, 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. The passthrough lets user middleware that wraps the
- * default (e.g. a doubler, a provider-native `countTokens` override)
- * participate normally.
- */
-
-import { type Plugin } from "../../types.js";
-import tokenEstimate from "./middlewares/tokenEstimate.js";
-import pkg from "./package.json" with { type: "json" };
-
-/**
- * Default `tokenEstimate` plugin. Registered by
- * {@link bootstrapPlugins} on daemon startup so the pipeline always has a
- * terminal handler even when no other plugin contributes one.
- */
-export const defaultTokenEstimatePlugin: Plugin = {
-  manifest: {
-    name: pkg.name,
-    version: pkg.version,
-  },
-  middleware: {
-    tokenEstimate,
-  },
-};

package/src/plugins/defaults/token-estimate/terminal.ts

@@ -1,40 +0,0 @@
-/**
- * Default `tokenEstimate` behavior: estimates the prompt token count used by
- * the overflow gate.
- *
- * This module is side-effect free: importing it does not register any plugin.
- *
- * Delegates to
- * {@link estimatePromptTokens}, which applies the EWMA calibration correction
- * recorded from past provider responses. Preflight + mid-loop checks must use
- * the calibrated estimate — the calibrated value keeps the overflow gate
- * consistent with the convergence path in the reducer. The pre-send
- * calibration capture in `agent/loop.ts` still uses `estimatePromptTokensRaw`
- * on purpose — the calibrator must learn against the raw estimate so the EWMA
- * converges against provider ground truth rather than chasing its own
- * corrected output. This path produces the user-facing estimate; calibration
- * capture stays separate.
- */
-
-import {
-  estimatePromptTokens,
-  estimateToolsTokens,
-} from "../../../context/token-estimator.js";
-import type { EstimateArgs, EstimateResult } from "../../types.js";
-
-/**
- * Compute the tool token budget from `args.tools` and delegate to
- * {@link estimatePromptTokens} with the canonical provider key, applying the
- * EWMA calibration correction. Exported so the agent loop can call it directly
- * and tests can verify the default behavior.
- */
-export const defaultTokenEstimateTerminal = async (
-  args: EstimateArgs,
-): Promise<EstimateResult> => {
-  const toolTokenBudget =
-    args.tools.length > 0 ? estimateToolsTokens(args.tools) : 0;
-  return estimatePromptTokens(args.history, args.systemPrompt, {
-    providerName: args.providerName,
-    toolTokenBudget,
-  });
-};