@vellumai/assistant 0.8.8 → 0.8.9-staging.2

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/router.ts

@@ -33,12 +33,12 @@ import { z } from "zod";
 import {
   extractToolUse,
   getConfiguredProvider,
-} from "../../providers/provider-send-message.js";
-import type { Message, ToolDefinition } from "../../providers/types.js";
-import { getLogger } from "../../util/logger.js";
+} from "../../../providers/provider-send-message.js";
+import type { Message, ToolDefinition } from "../../../providers/types.js";
+import { getLogger } from "../../../util/logger.js";
 import { retryForResult } from "./llm-retry.js";
 import { cachedTextBlock } from "./provider-blocks.js";
-import type { LeafPath, LeafTree, TurnContext } from "./types.js";
+import type { LeafPath, LeafTree, MemoryRoutingTurn } from "./types.js";
 
 const log = getLogger("memory-v3-router");
 
@@ -117,7 +117,7 @@ export function renderLeafBlock(tree: LeafTree): string {
  * degrading to the deterministic recall lanes the orchestrator unions in.
  */
 export async function routeL1(
-  turn: TurnContext,
+  turn: MemoryRoutingTurn,
   tree: LeafTree,
 ): Promise<LeafPath[]> {
   const paths = sortedLeaves(tree);

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/selection-log-store.ts

@@ -7,10 +7,10 @@
  * across turns) and can't be reproduced after the fact.
  */
 
-import type { MemoryV3SelectionLog } from "../../api/responses/memory-v3-selection-log.js";
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
-import { getConfig } from "../../config/loader.js";
-import { getDb, getSqliteFrom } from "../db-connection.js";
+import type { MemoryV3SelectionLog } from "../../../api/responses/memory-v3-selection-log.js";
+import { isAssistantFeatureFlagEnabled } from "../../../config/assistant-feature-flags.js";
+import { getConfig } from "../../../config/loader.js";
+import { getDb, getSqliteFrom } from "../../../memory/db-connection.js";
 import { renderV3PageContent } from "./page-content.js";
 import { renderMemoryBlock } from "./render-injection.js";
 import type { Slug } from "./types.js";

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/selector.ts

@@ -33,14 +33,14 @@ import { z } from "zod";
 import {
   extractToolUse,
   getConfiguredProvider,
-} from "../../providers/provider-send-message.js";
-import type { Message, ToolDefinition } from "../../providers/types.js";
-import { getLogger } from "../../util/logger.js";
-import { mapLimit } from "../../util/map-limit.js";
+} from "../../../providers/provider-send-message.js";
+import type { Message, ToolDefinition } from "../../../providers/types.js";
+import { getLogger } from "../../../util/logger.js";
+import { mapLimit } from "../../../util/map-limit.js";
 import { retryForResult } from "./llm-retry.js";
 import { cachedTextBlock } from "./provider-blocks.js";
 import { membersOf } from "./tree.js";
-import type { LeafPath, LeafTree, Slug, TurnContext } from "./types.js";
+import type { LeafPath, LeafTree, MemoryRoutingTurn, Slug } from "./types.js";
 
 const log = getLogger("memory-v3-selector");
 
@@ -122,7 +122,7 @@ async function renderPagesBlock(
  */
 export async function selectFromLeaf(
   leaf: LeafPath,
-  turn: TurnContext,
+  turn: MemoryRoutingTurn,
   tree: LeafTree,
   pageSummary: (slug: Slug) => Promise<string>,
 ): Promise<SelectedPage[]> {
@@ -214,7 +214,7 @@ export async function selectFromLeaf(
  */
 export async function selectAcrossLeaves(
   leaves: LeafPath[],
-  turn: TurnContext,
+  turn: MemoryRoutingTurn,
   tree: LeafTree,
   pageSummary: (slug: Slug) => Promise<string>,
   concurrency = 4,

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/shadow-plugin.ts

@@ -1,75 +1,66 @@
 /**
- * Memory v3 — flag-gated shadow/live injector.
+ * Memory v3 — flag-gated shadow/live orchestration engine.
  *
- * An {@link Injector} that runs the v3 orchestrator each turn and
- * records its selection set to `memory_v3_selections`. Two flags gate its
- * injection behavior:
+ * Runs the v3 orchestrator each turn and records its selection set to
+ * `memory_v3_selections`. Two flags gate behavior:
  *
- *   - `memory-v3-shadow` (and live OFF): observation-only. `produce()` returns
- *     `null`, so v2 injection is bit-for-bit identical whether the flag is on
- *     or off — the only difference is the side-effect telemetry write.
- *   - `memory-v3-live`: live injection. `produce()` additionally renders the
- *     working-set selection into a `<memory>` block via {@link renderMemoryBlock}
- *     and returns it as an injection block at v2's dynamic-memory placement
+ *   - `memory-v3-shadow` (live OFF): observation-only. {@link observeTurn}
+ *     orchestrates and logs the selection set; no injection is produced, so v2
+ *     injection is bit-for-bit identical — the only difference is the
+ *     side-effect telemetry write.
+ *   - `memory-v3-live`: live injection. The injector (`memoryV3Injector` in
+ *     `./injector.ts`) additionally renders the working-set selection into a
+ *     `<memory>` block and returns it at v2's dynamic-memory placement
  *     (`after-memory-prefix`). Selections are still logged.
- *   - both OFF: `produce()` returns `null` and skips orchestration entirely.
+ *   - both OFF: orchestration is skipped entirely.
  *
  * On each turn (either flag on):
  *   1. Lazy-init the v3 lanes ONCE across the whole process (leaf tree, core
  *      set, BM25 needle, carry-forward working set), memoizing the init
  *      promise so concurrent first turns share a single build.
- *   2. Build a {@link TurnContext} from the conversation's recent messages.
+ *   2. Build a {@link MemoryRoutingTurn} from the conversation's recent messages.
  *   3. Run {@link orchestrate} and record its selection set to
  *      `memory_v3_selections` with a best-effort lane attribution.
  *
- * Everything after the flag read is wrapped in try/catch — any failure is
- * logged and swallowed so it can never affect the live turn. In live mode a
- * failure returns `null` (no v3 injection); v2 suppression keys off BOTH the
- * flag AND whether `produce()` actually returned a block, so a v3 failure (or
- * empty selection) falls back to v2 memory rather than dropping all memory.
+ * {@link observeTurn} wraps everything after the flag read in try/catch — any
+ * failure is logged and swallowed so it can never affect the live turn. The
+ * injector treats a `null`/empty result as "no v3 injection", so v2 memory
+ * remains the fallback rather than dropping all memory.
  */
 
 import { existsSync, readFileSync } from "node:fs";
 
-import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-flags.js";
-import { getConfig } from "../../config/loader.js";
-import type { AssistantConfig } from "../../config/schema.js";
-import { getMessages } from "../../memory/conversation-crud.js";
-import { getDb, getSqliteFrom } from "../../memory/db-connection.js";
-import { stringifyMessageContent } from "../../memory/message-content.js";
-import {
-  type InjectionBlock,
-  type Injector,
-  type TurnContext as PluginTurnContext,
-} from "../../plugins/types.js";
-import { getLogger } from "../../util/logger.js";
+import { isAssistantFeatureFlagEnabled } from "../../../config/assistant-feature-flags.js";
+import { getConfig } from "../../../config/loader.js";
+import type { AssistantConfig } from "../../../config/schema.js";
+import { getMessages } from "../../../memory/conversation-crud.js";
+import { getDb, getSqliteFrom } from "../../../memory/db-connection.js";
+import { stringifyMessageContent } from "../../../memory/message-content.js";
+import { getPageIndex } from "../../../memory/v2/page-index.js";
+import { getLogger } from "../../../util/logger.js";
 import {
   getWorkspaceDir,
   getWorkspacePromptPath,
-} from "../../util/platform.js";
-import { stripCommentLines } from "../../util/strip-comment-lines.js";
-import { getPageIndex } from "../v2/page-index.js";
+} from "../../../util/platform.js";
+import { stripCommentLines } from "../../../util/strip-comment-lines.js";
 import { injectCapabilitiesLeaf, isCapabilitySlug } from "./capabilities.js";
 import { loadCore } from "./core.js";
 import type { NeedleIndex } from "./needle.js";
 import { buildNeedleIndex } from "./needle.js";
 import type { OrchestrateResult } from "./orchestrate.js";
 import { orchestrate } from "./orchestrate.js";
-import { renderV3PageContent } from "./page-content.js";
-import { renderMemoryBlock } from "./render-injection.js";
 import { coreSlugs, loadLeafTree, resolveDataDir } from "./tree.js";
 import {
   type LeafPath,
   type LeafTree,
-  MEMORY_V3_BLOCK_ID,
+  type MemoryRoutingTurn,
   type SelectionSource,
   type Slug,
-  type TurnContext,
 } from "./types.js";
 import { WorkingSet } from "./working-set.js";
 
-const MEMORY_V3_SHADOW = "memory-v3-shadow" as const;
-const MEMORY_V3_LIVE = "memory-v3-live" as const;
+export const MEMORY_V3_SHADOW = "memory-v3-shadow" as const;
+export const MEMORY_V3_LIVE = "memory-v3-live" as const;
 
 const log = getLogger("memory-v3-shadow");
 
@@ -202,7 +193,7 @@ function buildSituationalContext(): string {
 }
 
 /**
- * Build a v3 {@link TurnContext} from the conversation's persisted messages.
+ * Build a v3 {@link MemoryRoutingTurn} from the conversation's persisted messages.
  * `currentMessage` is the latest user message; `recentContext` is the tail of
  * the recent transcript; `situationalContext` carries the current date and the
  * live NOW.md scratchpad. Returns `null` when there is no user message to route
@@ -211,7 +202,7 @@ function buildSituationalContext(): string {
 function buildShadowTurn(
   conversationId: string,
   turnIndex: number,
-): TurnContext | null {
+): MemoryRoutingTurn | null {
   const rows = getMessages(conversationId);
   if (rows.length === 0) return null;
 
@@ -310,7 +301,7 @@ function writeSelections(
  * failures are logged and swallowed (returning `null`) so the live turn is
  * unaffected. Returns `null` when there is no user message to route on.
  */
-async function observeTurn(
+export async function observeTurn(
   conversationId: string,
   turnIndex: number,
 ): Promise<OrchestrateResult | null> {
@@ -356,56 +347,3 @@ export async function runShadowObservation(
   if (!isAssistantFeatureFlagEnabled(MEMORY_V3_SHADOW, getConfig())) return;
   await observeTurn(conversationId, turnIndex);
 }
-
-/**
- * The v3 injector. Reads both flags:
- *   - `memory-v3-live` on → orchestrate, log, render the working-set selection
- *     into a `<memory>` block, and return it at v2's dynamic-memory placement.
- *   - `memory-v3-shadow` on (live off) → orchestrate + log only, return `null`.
- *   - both off → return `null` (no orchestration).
- *
- * Empty selection and any failure return `null` (no v3 injection). v2
- * suppression keys off BOTH the flag AND this return value, so a `null` here
- * (failure or empty selection) falls back to v2 memory rather than dropping all
- * memory.
- */
-export const memoryV3Injector: Injector = {
-  name: "memory-v3-shadow",
-  // High order so it sorts last; the live `<memory>` block uses the
-  // after-memory-prefix placement so it lands at the memory boundary regardless
-  // of this sort key, which only orders content-producing injectors.
-  order: 1000,
-  async produce(ctx: PluginTurnContext): Promise<InjectionBlock | null> {
-    const config = getConfig();
-    const live = isAssistantFeatureFlagEnabled(MEMORY_V3_LIVE, config);
-    const shadow = isAssistantFeatureFlagEnabled(MEMORY_V3_SHADOW, config);
-    if (!live && !shadow) return null;
-
-    const result = await observeTurn(ctx.conversationId, ctx.turnIndex);
-    if (!live || !result) return null;
-
-    try {
-      // `renderMemoryBlock` returns "" for an empty selection; inject nothing.
-      const text = await renderMemoryBlock(
-        result.finalInjection,
-        renderV3PageContent,
-      );
-      if (text.length === 0) return null;
-      return {
-        id: MEMORY_V3_BLOCK_ID,
-        text,
-        // Mirror v2's dynamic `<memory>` block placement.
-        placement: "after-memory-prefix",
-      };
-    } catch (err) {
-      log.warn(
-        {
-          err: err instanceof Error ? err.message : String(err),
-          conversationId: ctx.conversationId,
-        },
-        "memory-v3 live render failed (non-fatal) — falling back to v2",
-      );
-      return null;
-    }
-  },
-};

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/tree.ts

@@ -5,7 +5,7 @@ import { fileURLToPath } from "node:url";
 
 import { parse as parseYaml } from "yaml";
 
-import { getWorkspaceDir } from "../../util/platform.js";
+import { getWorkspaceDir } from "../../../util/platform.js";
 import type {
   LeafFrontmatter,
   LeafNode,

package/src/{memory/v3 → plugins/defaults/memory-v3-shadow}/types.ts

@@ -41,7 +41,7 @@ export interface WorkingSetEntry {
   lastSeenTurn: number;
 }
 
-export interface TurnContext {
+export interface MemoryRoutingTurn {
   conversationId: string;
   turnNumber: number;
   currentMessage: string;

package/src/plugins/defaults/title-generate/package.json

@@ -5,7 +5,6 @@
   "private": true,
   "license": "MIT",
   "type": "module",
-  "main": "./register.ts",
   "engines": {
     "node": ">=20.12.0"
   },

package/src/plugins/defaults/tool-error/package.json

@@ -5,7 +5,6 @@
   "private": true,
   "license": "MIT",
   "type": "module",
-  "main": "./register.ts",
   "engines": {
     "node": ">=20.12.0"
   },

package/src/plugins/defaults/tool-result-truncate/package.json

@@ -5,7 +5,6 @@
   "private": true,
   "license": "MIT",
   "type": "module",
-  "main": "./register.ts",
   "engines": {
     "node": ">=20.12.0"
   },

package/src/plugins/pipeline.ts

@@ -1,297 +1,16 @@
 /**
- * Plugin pipeline runner.
+ * Plugin hook runner.
  *
- * A "pipeline" is a named chain of {@link Middleware}s wrapped around a
- * terminal handler (the original behavior that existed before plugins). The
- * runner composes the chain in onion order, runs it under an optional
- * per-pipeline timeout, and emits one structured log record per invocation
- * covering success, error, and timeout uniformly.
+ * A "hook" is a named lifecycle event (`user-prompt-submit`, `post-tool-use`,
+ * …) that every registered plugin may handle. The runner walks each plugin's
+ * hook for a given event in registration order, threading a context value
+ * through the chain so hooks can observe and transform it.
  *
- * Design doc: `.private/plans/agent-plugin-system.md` (PR 12 notes).
- *
- * Semantics:
- * - Onion composition — the first element of `middlewares` is the outermost
- *   wrapper; it sees the request first and the response last. Terminal runs
- *   in the middle.
- * - Strict-fail — there is NO `try/catch` around user middleware. Errors,
- *   including `PluginTimeoutError` from a breached budget, propagate to the
- *   caller. The `finally` block only handles logging, never error recovery.
- * - Timeout — when `timeoutMs` is a finite number, the invocation races a
- *   timer. A timeout rejection is a `PluginTimeoutError` carrying the
- *   pipeline name, the best-known offending plugin (from `ctx.pluginName`),
- *   and elapsed ms. When `timeoutMs` is `null`/`undefined`, no timer is
- *   armed — pipelines like `compaction` rely on downstream timeouts instead.
+ * Design doc: `.private/plans/agent-plugin-system.md`.
  */
 
-import type { Logger } from "pino";
-
 import type { HookName } from "../plugin-api/constants.js";
-import { getLogger } from "../util/logger.js";
 import { getHooksFor } from "./registry.js";
-import {
-  type Middleware,
-  type PipelineName,
-  PluginTimeoutError,
-  type TurnContext,
-} from "./types.js";
-
-const moduleLogger = getLogger("plugin-pipeline");
-
-// ─── Default timeouts ───────────────────────────────────────────────────────
-
-/**
- * Default per-pipeline timeout budgets in milliseconds. A value of `null`
- * means the runner does NOT arm a timer — the pipeline relies on its
- * downstream for budgeting (e.g. `compaction` defers to the provider-level
- * HTTP timeouts of the summary call it wraps).
- *
- * Callers pass the appropriate entry as `runPipeline`'s `timeoutMs` argument.
- * The design doc locks these numbers in; do not tweak without coordinating
- * a design update.
- */
-export const DEFAULT_TIMEOUTS: Record<PipelineName, number | null> = {
-  compaction: null,
-  overflowReduce: null,
-  circuitBreaker: null,
-};
-
-// ─── Composition ────────────────────────────────────────────────────────────
-
-/**
- * Compose an ordered list of {@link Middleware}s around a terminal handler
- * using onion semantics. The first element of `middlewares` is the outermost
- * layer.
- *
- * The returned function accepts `(args, ctx)` and runs the entire chain:
- * ```
- *   middlewares[0] → middlewares[1] → ... → terminal → ... → middlewares[1] → middlewares[0]
- * ```
- *
- * Middlewares that never call `next` short-circuit the chain — the terminal
- * and any deeper middleware are never invoked. Middlewares that throw abort
- * the chain; the error flows back out through any outer middleware unchanged
- * (no internal try/catch).
- */
-export function composeMiddleware<A, R>(
-  middlewares: ReadonlyArray<Middleware<A, R>>,
-  terminal: (args: A) => Promise<R>,
-): (args: A, ctx: TurnContext) => Promise<R> {
-  return (args, ctx) => {
-    // Walk back-to-front, wrapping each middleware around `next`. The last
-    // middleware in the array wraps `terminal`; earlier entries wrap the
-    // accumulated chain so they execute first.
-    let next: (args: A) => Promise<R> = terminal;
-    for (let i = middlewares.length - 1; i >= 0; i--) {
-      const mw = middlewares[i]!;
-      const downstream = next;
-      next = (innerArgs: A) => mw(innerArgs, downstream, ctx);
-    }
-    return next(args);
-  };
-}
-
-// ─── Abort-signal linking ───────────────────────────────────────────────────
-
-/**
- * Return a shallow-cloned `args` object where every `AbortSignal`-typed
- * top-level property is swapped for a signal linked to `internalController`.
- *
- * "Linked" here means: the returned signal aborts when either the caller's
- * original signal aborts OR `internalController` aborts (e.g. the pipeline
- * timer fires). The caller's args are never mutated.
- *
- * When `args` carries no `AbortSignal` property, the original object is
- * returned unchanged — pipelines whose terminals don't consume a signal
- * (e.g. `circuitBreaker`) see identical behavior to before.
- * The return value's `cleanup()` tears down any `addEventListener("abort",
- * ...)` handlers attached to the caller's signal so a pipeline that
- * completes successfully doesn't leak listeners on the caller's controller.
- */
-function linkAbortSignal<A>(
-  args: A,
-  internalController: AbortController,
-): { args: A; cleanup: () => void } {
-  if (args === null || typeof args !== "object") {
-    return { args, cleanup: () => {} };
-  }
-  const abortListeners: Array<{
-    signal: AbortSignal;
-    listener: () => void;
-  }> = [];
-  const record = args as Record<string, unknown>;
-  const patched: Record<string, unknown> = { ...record };
-  let swappedAny = false;
-  for (const key of Object.keys(record)) {
-    const value = record[key];
-    if (value instanceof AbortSignal) {
-      swappedAny = true;
-      if (value.aborted) {
-        // Caller already aborted — propagate immediately so the inner call
-        // sees the abort without waiting for the listener to fire.
-        internalController.abort();
-      } else {
-        const listener = () => internalController.abort();
-        value.addEventListener("abort", listener, { once: true });
-        abortListeners.push({ signal: value, listener });
-      }
-      patched[key] = internalController.signal;
-    }
-  }
-  const cleanup = () => {
-    for (const { signal, listener } of abortListeners) {
-      signal.removeEventListener("abort", listener);
-    }
-  };
-  return { args: (swappedAny ? patched : args) as A, cleanup };
-}
-
-// ─── Runner ─────────────────────────────────────────────────────────────────
-
-type PipelineLogRecord = {
-  event: "plugin.pipeline";
-  pipeline: PipelineName;
-  chain: ReadonlyArray<string>;
-  durationMs: number;
-  outcome: "success" | "error" | "timeout";
-  pluginName?: string;
-  errorName?: string;
-  errorMessage?: string;
-  errorStack?: string;
-  timeoutMs?: number;
-  requestId: string;
-  conversationId: string;
-  turnIndex?: number;
-};
-
-/**
- * Best-effort detection of a pino-compatible logger on the `TurnContext`.
- *
- * `TurnContext` intentionally doesn't require a logger slot — most code paths
- * use the module-level logger. Some callers (notably plugin-scoped pipelines
- * in later PRs) may attach a child logger via `(ctx as any).logger`. We type
- * the field loosely to avoid coupling `TurnContext` to pino.
- */
-function selectLogger(ctx: TurnContext): Logger {
-  const maybe = (ctx as { logger?: unknown }).logger;
-  if (maybe && typeof maybe === "object" && "info" in maybe) {
-    return maybe as Logger;
-  }
-  return moduleLogger;
-}
-
-/**
- * Execute a named pipeline: compose middleware, run it under an optional
- * timeout, and emit one structured log record covering success, error, or
- * timeout uniformly.
- *
- * @param name        The pipeline identifier. Used for telemetry and error
- *                    attribution.
- * @param middlewares Ordered list of middlewares to wrap around `terminal`.
- *                    Names for the log `chain` are pulled from `Function.name`
- *                    (empty strings are kept so length always matches).
- * @param terminal    The original behavior. Runs when all middlewares call
- *                    `next`.
- * @param args        Pipeline-specific input payload.
- * @param ctx         Per-turn context. May carry an optional `logger` slot;
- *                    otherwise the module logger is used.
- * @param timeoutMs   Deadline in milliseconds. `null`/`undefined` disables
- *                    the timer entirely (inherits downstream timeouts).
- *
- * @throws {PluginTimeoutError} When `timeoutMs` is non-null and the chain
- *         exceeds the budget. `ctx.pluginName` (if set) is attached as the
- *         offending plugin.
- * @throws Any error produced by user middleware or the terminal — flows
- *         through unchanged.
- */
-export async function runPipeline<A, R>(
-  name: PipelineName,
-  middlewares: ReadonlyArray<Middleware<A, R>>,
-  terminal: (args: A) => Promise<R>,
-  args: A,
-  ctx: TurnContext,
-  timeoutMs?: number | null,
-): Promise<R> {
-  const logger = selectLogger(ctx);
-  const chain = middlewares.map((m) => m.name || "anonymous");
-  const composed = composeMiddleware(middlewares, terminal);
-  const start = performance.now();
-
-  let outcome: "success" | "error" | "timeout" = "success";
-  let thrown: unknown = undefined;
-  let timer: ReturnType<typeof setTimeout> | undefined;
-
-  try {
-    if (typeof timeoutMs === "number" && Number.isFinite(timeoutMs)) {
-      const budget = timeoutMs;
-      // Internal controller: fires on either (a) the timer, so the inner call
-      // actually observes the budget breach instead of running forever after
-      // `Promise.race` rejects; or (b) the caller's own signal, so external
-      // cancellation still reaches the inner call transparently. Any
-      // `AbortSignal`-typed property on `args` (e.g. `signal` on
-      // `CompactionArgs`, `abortSignal` on `OverflowReduceArgs`) is swapped
-      // for this linked signal on a shallow-cloned args object — we never
-      // mutate the caller's args.
-      const internalController = new AbortController();
-      const { args: effectiveArgs, cleanup } = linkAbortSignal(
-        args,
-        internalController,
-      );
-      const timeoutPromise = new Promise<never>((_resolve, reject) => {
-        timer = setTimeout(() => {
-          internalController.abort();
-          reject(
-            new PluginTimeoutError(
-              name,
-              ctx.pluginName,
-              Math.round(performance.now() - start),
-            ),
-          );
-        }, budget);
-      });
-      try {
-        return await Promise.race([
-          composed(effectiveArgs, ctx),
-          timeoutPromise,
-        ]);
-      } finally {
-        cleanup();
-      }
-    }
-    return await composed(args, ctx);
-  } catch (err) {
-    thrown = err;
-    outcome = err instanceof PluginTimeoutError ? "timeout" : "error";
-    throw err;
-  } finally {
-    if (timer !== undefined) clearTimeout(timer);
-    const durationMs = Math.round(performance.now() - start);
-    const record: PipelineLogRecord = {
-      event: "plugin.pipeline",
-      pipeline: name,
-      chain,
-      durationMs,
-      outcome,
-      requestId: ctx.requestId,
-      conversationId: ctx.conversationId,
-    };
-    if (ctx.turnIndex !== undefined) record.turnIndex = ctx.turnIndex;
-    if (ctx.pluginName !== undefined) record.pluginName = ctx.pluginName;
-    if (typeof timeoutMs === "number" && Number.isFinite(timeoutMs)) {
-      record.timeoutMs = timeoutMs;
-    }
-    if (thrown !== undefined) {
-      if (thrown instanceof Error) {
-        record.errorName = thrown.name;
-        record.errorMessage = thrown.message;
-        if (thrown.stack) record.errorStack = thrown.stack;
-      } else {
-        record.errorName = "NonError";
-        record.errorMessage = String(thrown);
-      }
-    }
-    logger.info(record, "plugin.pipeline");
-  }
-}
 
 // ─── Hook runner ────────────────────────────────────────────────────────────
 
@@ -302,12 +21,6 @@ export async function runPipeline<A, R>(
  * that replaces the threaded value for subsequent hooks. The final context
  * after the chain settles is returned.
  *
- * `runHook` is the hook-side counterpart to {@link runPipeline}:
- * `runPipeline` composes middleware around a terminal handler for stateful
- * request/response pipelines (compaction, overflow reduction, etc.);
- * `runHook` walks ordered hook functions for declarative chain-style
- * context transformations (`user-prompt-submit`, `post-tool-use`).
- *
  * @param name        The hook identifier — pick one from {@link HOOKS}.
  * @param initialCtx  Context the first hook receives.
  * @returns The final context after the chain settles. Same reference as