@vellumai/assistant 0.8.7 → 0.8.8

package/Dockerfile

@@ -77,6 +77,7 @@ RUN apt-get update && apt-get install -y \
     debootstrap \
     debian-archive-keyring \
     debconf \
+    e2fsprogs \
     ffmpeg \
     fonts-freefont-ttf \
     g++ \
@@ -113,11 +114,13 @@ RUN apt-get update && apt-get install -y \
     libxtst6 \
     lsof \
     make \
+    mount \
     openssl \
     procps \
     python3 \
     sqlite3 \
     sudo \
+    util-linux \
     unzip \
     uuid-runtime \
     vim \
@@ -180,7 +183,8 @@ RUN printf '%s\n' \
 RUN printf '%s\n' \
     '#!/usr/bin/env sh' \
     'set -eu' \
-    'if [ "${VELLUM_SANDBOX_RUNTIME:-}" != "kata" ]; then' \
+    '. /app/assistant/docker-kata-runtime-family.sh' \
+    'if ! vellum_is_kata_family_runtime; then' \
     '  exec /usr/bin/apt-get "$@"' \
     'fi' \
     'export DEBIAN_FRONTEND=noninteractive' \
@@ -195,7 +199,8 @@ RUN printf '%s\n' \
     printf '%s\n' \
     '#!/usr/bin/env sh' \
     'set -eu' \
-    'if [ "${VELLUM_SANDBOX_RUNTIME:-}" != "kata" ]; then' \
+    '. /app/assistant/docker-kata-runtime-family.sh' \
+    'if ! vellum_is_kata_family_runtime; then' \
     '  exec /usr/bin/apt "$@"' \
     'fi' \
     'export DEBIAN_FRONTEND=noninteractive' \
@@ -210,7 +215,8 @@ RUN printf '%s\n' \
     printf '%s\n' \
     '#!/usr/bin/env sh' \
     'set -eu' \
-    'if [ "${VELLUM_SANDBOX_RUNTIME:-}" != "kata" ]; then' \
+    '. /app/assistant/docker-kata-runtime-family.sh' \
+    'if ! vellum_is_kata_family_runtime; then' \
     '  exec /usr/bin/dpkg "$@"' \
     'fi' \
     'DATA_ROOT="${VELLUM_APT_DATA_ROOT:-/data/system}"' \
@@ -236,7 +242,17 @@ ENV IS_CONTAINERIZED=true
 # and the generated meet-join manifest from the builder stage.
 COPY --from=builder /app /app
 
-RUN chmod +x /app/assistant/docker-entrypoint.sh /app/assistant/docker-init-apt-root.sh /app/assistant/docker-kata-apt-env.sh
+COPY packages/block-volume-bootstrap/scripts/*.sh /usr/local/bin/
+
+RUN chmod +x \
+    /app/assistant/docker-entrypoint.sh \
+    /app/assistant/docker-init-apt-root.sh \
+    /app/assistant/docker-kata-apt-env.sh \
+    /app/assistant/docker-kata-runtime-family.sh \
+    /usr/local/bin/vellum-block-volume-common.sh \
+    /usr/local/bin/vellum-block-volume-init.sh \
+    /usr/local/bin/vellum-block-volume-mount.sh \
+    /usr/local/bin/vellum-block-volume-resize.sh
 
 # Run the daemon + http server
 CMD ["/app/assistant/docker-entrypoint.sh"]

package/docker-entrypoint.sh

@@ -6,9 +6,11 @@ set -eu
 chmod 1777 /tmp 2>/dev/null || true
 
 KATA_APT_INIT_PID=""
-if [ "${VELLUM_SANDBOX_RUNTIME:-}" = "kata" ] && [ -x /app/assistant/docker-init-apt-root.sh ]; then
+. /app/assistant/docker-kata-runtime-family.sh
+
+if vellum_is_kata_family_runtime && [ -x /app/assistant/docker-init-apt-root.sh ]; then
   export VELLUM_APT_DATA_ROOT="${VELLUM_APT_DATA_ROOT:-/data/system}"
-  # Warm the chroot used by kata apt wrappers without blocking assistant readiness.
+  # Warm the chroot used by Kata-family apt wrappers without blocking assistant readiness.
   /app/assistant/docker-init-apt-root.sh &
   KATA_APT_INIT_PID="$!"
 fi

package/docker-init-apt-root.sh

@@ -10,7 +10,9 @@ LOCK_DIR="${DATA_ROOT}.rootfs-init.lock"
 LOCK_PID="${LOCK_DIR}/pid"
 HOST_PATH="/usr/sbin:/usr/bin:/sbin:/bin"
 
-if [ "${VELLUM_SANDBOX_RUNTIME:-}" != "kata" ]; then
+. /app/assistant/docker-kata-runtime-family.sh
+
+if ! vellum_is_kata_family_runtime; then
   exit 0
 fi
 

package/docker-kata-apt-env.sh

@@ -1,6 +1,8 @@
 #!/usr/bin/env sh
 
-if [ "${VELLUM_SANDBOX_RUNTIME:-}" != "kata" ]; then
+. /app/assistant/docker-kata-runtime-family.sh
+
+if ! vellum_is_kata_family_runtime; then
   return 0 2>/dev/null || exit 0
 fi
 

package/docker-kata-runtime-family.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env sh
+
+vellum_is_kata_family_runtime() {
+  case "${VELLUM_SANDBOX_RUNTIME:-}" in
+    kata|firecracker|cloud-hypervisor)
+      return 0
+      ;;
+    *)
+      return 1
+      ;;
+  esac
+}

package/docs/architecture/memory.md

@@ -244,7 +244,7 @@ graph TB
 
 Normal context compaction (the "Context Window Management" subgraph above) runs proactively as the conversation approaches the token limit, using cooldown guards and a severity-pressure override to balance compaction frequency against cost. This is the primary defense against context overflow.
 
-When compaction alone is insufficient — either because the conversation grew too fast between turns or because a single turn contains extremely large payloads — the overflow recovery pipeline takes over. The pipeline's first tier (forced compaction) reuses the same `maybeCompact()` summarization machinery but with emergency parameters: `force: true` bypasses cooldown guards, `minKeepRecentUserTurns: 0` allows summarizing even the most recent history, and `targetInputTokensOverride` sets a tighter budget. Subsequent tiers (tool-result truncation, media stubbing, injection downgrade) apply progressively more aggressive payload reduction without involving the summarizer.
+When compaction alone is insufficient — either because the conversation grew too fast between turns or because a single turn contains extremely large payloads — the overflow recovery pipeline takes over. The pipeline's first tier (forced compaction) reuses the same `maybeCompact()` summarization machinery but with emergency parameters: `force: true` bypasses cooldown guards and `minKeepRecentUserTurns: 0` allows summarizing even the most recent history. The reducer drives convergence toward a tighter budget by re-invoking each tier until the estimated tokens fall under its `targetTokens` ceiling. Subsequent tiers (tool-result truncation, media stubbing, injection downgrade) apply progressively more aggressive payload reduction without involving the summarizer.
 
 If all four reducer tiers are exhausted, the overflow policy resolver determines whether to compress the latest user turn. All sessions — interactive and non-interactive alike — auto-compress the latest turn without prompting. The only explicit opt-out is setting `contextWindow.overflowRecovery.interactiveLatestTurnCompression` (or `nonInteractiveLatestTurnCompression`) to `"drop"`, which short-circuits to a graceful failure instead. Disabling overflow recovery entirely (`contextWindow.overflowRecovery.enabled: false`) also yields a graceful failure.
 

package/docs/plugins.md

@@ -27,6 +27,7 @@ wired surface.
 - [Manifest](#manifest)
 - [Registration](#registration)
 - [Middleware patterns](#middleware-patterns)
+- [Hooks](#hooks)
 - [Pipeline reference](#pipeline-reference)
 - [Timeouts](#timeouts)
 - [Strict-fail semantics](#strict-fail-semantics)
@@ -49,14 +50,14 @@ wired surface.
 
 ## What a plugin can contribute today
 
-| Surface                 | Where                     | Discovery                                         |
-| ----------------------- | ------------------------- | ------------------------------------------------- |
-| Pipeline middleware     | `plugin.middleware`       | keyed by pipeline name in `PipelineMiddlewareMap` |
-| Model-visible tools     | `plugin.tools`            | each `PluginToolRegistration`                     |
-| HTTP routes             | `plugin.routes`           | each `PluginRouteRegistration`                    |
-| Skills                  | `plugin.skills`           | each `PluginSkillRegistration`                    |
-| System-prompt injectors | `plugin.injectors`        | each `Injector`                                   |
-| Lifecycle               | `init()` / `onShutdown()` | methods on the `Plugin` object                    |
+| Surface                    | Where               | Discovery                                         |
+| -------------------------- | ------------------- | ------------------------------------------------- |
+| Pipeline middleware        | `plugin.middleware` | keyed by pipeline name in `PipelineMiddlewareMap` |
+| Model-visible tools        | `plugin.tools`      | each `PluginToolRegistration`                     |
+| HTTP routes                | `plugin.routes`     | each `PluginRouteRegistration`                    |
+| Skills                     | `plugin.skills`     | each `PluginSkillRegistration`                    |
+| System-prompt injectors    | `plugin.injectors`  | each `Injector`                                   |
+| Lifecycle & per-turn hooks | `plugin.hooks`      | keyed by hook name (`init`, `shutdown`, …)        |
 
 The modern schema wires only **hooks** and **tools**; the middleware
 pipelines, routes, skills, and injectors above are the surfaces that still
@@ -85,9 +86,8 @@ The `Plugin` shape is declared in
 ```typescript
 export interface Plugin {
   manifest: PluginManifest;
-  init?(ctx: PluginInitContext): Promise<void>;
-  onShutdown?(): Promise<void>;
-  tools?: PluginToolRegistration[];
+  hooks?: PluginHooks;
+  tools?: Tool[];
   routes?: PluginRouteRegistration[];
   skills?: PluginSkillRegistration[];
   injectors?: Injector[];
@@ -96,8 +96,9 @@ export interface Plugin {
 ```
 
 Every field except `manifest` is optional. A plugin that only contributes
-middleware doesn't need tools or routes; a plugin that only contributes a
-skill can omit middleware entirely.
+a hook doesn't need tools or routes; a plugin that only contributes a
+skill can omit everything else. Lifecycle and per-turn behavior live under
+`hooks` (see [Hooks](#hooks)).
 
 ## Where plugins live
 
@@ -310,7 +311,7 @@ terminal runs at the innermost layer. See
 [`assistant/src/plugins/pipeline.ts`](../src/plugins/pipeline.ts) for the
 composition algorithm.
 
-Four common patterns emerge from that signature:
+Five common patterns emerge from that signature:
 
 ### Observe-only
 
@@ -319,8 +320,8 @@ return the result unchanged. Wrap the call in `try`/`finally` so your
 observer runs on both success and failure paths.
 
 ```typescript
-const observer: Middleware<ToolExecuteArgs, ToolExecuteResult> =
-  async function observeToolExecute(args, next, ctx) {
+const observer: Middleware<MemoryArgs, MemoryResult> =
+  async function observeRetrieval(args, next, ctx) {
     const start = performance.now();
     let outcome: "success" | "error" = "success";
     try {
@@ -330,27 +331,22 @@ const observer: Middleware<ToolExecuteArgs, ToolExecuteResult> =
       throw err;
     } finally {
       const ms = Math.round(performance.now() - start);
-      console.error(JSON.stringify({ tool: args.name, ms, outcome }));
+      console.error(
+        JSON.stringify({ conversationId: args.conversationId, ms, outcome }),
+      );
     }
   };
 ```
 
 ### Transform input
 
-Rewrite `args` before calling downstream. Useful for request shimming
-(adding headers, redacting inputs, picking a different provider).
+Rewrite `args` before calling downstream. Useful for reshaping the inputs
+(forcing an untrusted read, narrowing the turn the retriever sees).
 
 ```typescript
-const addHeader: Middleware<LLMCallArgs, LLMCallResult> =
-  async function addHeader(args, next, ctx) {
-    const tagged = {
-      ...args,
-      options: {
-        ...args.options,
-        config: { ...args.options?.config, requestId: ctx.requestId },
-      },
-    };
-    return next(tagged);
+const untrustedRead: Middleware<MemoryArgs, MemoryResult> =
+  async function untrustedRead(args, next, ctx) {
+    return next({ ...args, trustContext: undefined });
   };
 ```
 
@@ -359,14 +355,14 @@ const addHeader: Middleware<LLMCallArgs, LLMCallResult> =
 Call `next(args)` first, then modify the result before returning.
 
 ```typescript
-const redactPII: Middleware<LLMCallArgs, LLMCallResult> =
-  async function redactPII(args, next, ctx) {
-    const response = await next(args);
-    return {
-      ...response,
-      content: response.content.map(redactBlock),
-    };
-  };
+const dropNow: Middleware<MemoryArgs, MemoryResult> = async function dropNow(
+  args,
+  next,
+  ctx,
+) {
+  const result = await next(args);
+  return { ...result, nowContent: null };
+};
 ```
 
 ### Short-circuit
@@ -376,10 +372,11 @@ terminal and any inner middleware are skipped. Use this to stub, cache,
 or mock a pipeline.
 
 ```typescript
-const cacheHit: Middleware<LLMCallArgs, LLMCallResult> =
-  async function cacheHit(args, next, ctx) {
-    const cached = await lookupCache(args);
-    if (cached) return cached;
+const skipUntrusted: Middleware<MemoryArgs, MemoryResult> =
+  async function skipUntrusted(args, next, ctx) {
+    if (!isTrusted(ctx.trust)) {
+      return { pkbContent: null, nowContent: null, graphResult: null };
+    }
     return next(args);
   };
 ```
@@ -391,10 +388,10 @@ through any outer middleware unchanged — there is no internal
 `try`/`catch` around user middleware.
 
 ```typescript
-const denyIfUnauthorized: Middleware<ToolExecuteArgs, ToolExecuteResult> =
-  async function denyIfUnauthorized(args, next, ctx) {
-    if (!isAuthorizedFor(args.name, ctx.trust)) {
-      throw new Error(`tool ${args.name} denied by policy`);
+const denyIfUntrusted: Middleware<CompactionArgs, CompactionResult> =
+  async function denyIfUntrusted(args, next, ctx) {
+    if (!isTrusted(ctx.trust)) {
+      throw new Error(`compaction denied by policy`);
     }
     return next(args);
   };
@@ -407,30 +404,40 @@ pipeline runner pulls `Function.name` into its `chain` log field so
 operators can see the registered chain at a glance:
 
 ```
-plugin.pipeline pipeline=llmCall chain=["observeLlm","addHeader","defaultLlmCall"] durationMs=1840 outcome=success
+plugin.pipeline pipeline=compaction chain=["observeCompaction","defaultCompaction"] durationMs=1840 outcome=success
 ```
 
+## Hooks
+
+Hooks are the **modern** lifecycle surface: a plugin contributes one
+function per phase under `plugin.hooks`, keyed by hook name. The wired
+hook names live in [`HOOKS`](../src/plugin-api/constants.ts); the context
+shapes and a full authoring walkthrough live in the
+[experimental plugin guide](../../experimental/plugins/README.md#hooks).
+
+Every hook implements `PluginHookFn` — it receives a context and either
+mutates it in place (returning `void`) or returns a replacement. Hooks
+from multiple plugins chain in registration order, and defaults register
+first.
+
+| Hook                 | Fires                                                             | Context                   |
+| -------------------- | ----------------------------------------------------------------- | ------------------------- |
+| `init`               | Once when the plugin is registered.                               | `PluginInitContext`       |
+| `shutdown`           | Once when the plugin is torn down.                                | `PluginShutdownContext`   |
+| `user-prompt-submit` | Once per user turn, before the agent loop receives the messages.  | `UserPromptSubmitContext` |
+| `post-tool-use`      | Once per tool result, before it joins the provider-bound history. | `PostToolUseContext`      |
+| `stop`               | Once per run when the model yields a turn with no tool calls.     | `StopContext`             |
+
 ## Pipeline reference
 
 Every pipeline slot and its purpose. Type details live in
 [`types.ts`](../src/plugins/types.ts).
 
-| Pipeline             | Purpose                                                                                                                                            |
-| -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `turn`               | The outermost wrapper around a single assistant turn. Middleware here sees everything a turn does end-to-end.                                      |
-| `llmCall`            | Every call to `Provider.sendMessage`. Input carries `messages` and `options` (with `tools`, `systemPrompt`, `config`, `onEvent`, `signal` inside). |
-| `toolExecute`        | Every `ToolExecutor.execute` call. Input carries `name`, `input`, and the full `ToolContext`.                                                      |
-| `memoryRetrieval`    | PKB, NOW.md, and memory-graph retrieval for a turn. Output is a merged `MemoryResult`.                                                             |
-| `historyRepair`      | The pre-run repair pass on the message history. Wraps `repairHistory`.                                                                             |
-| `tokenEstimate`      | The token-count estimate used for budgeting. Wraps `estimatePromptTokensRaw`.                                                                      |
-| `compaction`         | The conversation-compaction step. Wraps `ContextWindowManager.maybeCompact`.                                                                       |
-| `overflowReduce`     | The reducer tier loop invoked when a turn blows the context budget.                                                                                |
-| `persistence`        | Every message CRUD op (`add` / `update` / `delete`). Discriminated by `args.op`.                                                                   |
-| `titleGenerate`      | Conversation title generation. Fire-and-forget by default.                                                                                         |
-| `toolResultTruncate` | The per-tool-result truncation step that fits a tool's output into the context window.                                                             |
-| `emptyResponse`      | The decision about what to do when the model returns an empty turn (nudge / accept / error).                                                       |
-| `toolError`          | The decision about what to do when one or more tool calls errored on a turn.                                                                       |
-| `circuitBreaker`     | The compaction circuit breaker. Tracks consecutive-failure state, decides whether to open the circuit.                                             |
+| Pipeline         | Purpose                                                                                                |
+| ---------------- | ------------------------------------------------------------------------------------------------------ |
+| `compaction`     | The conversation-compaction step. Wraps `ContextWindowManager.maybeCompact`.                           |
+| `overflowReduce` | The reducer tier loop invoked when a turn blows the context budget.                                    |
+| `circuitBreaker` | The compaction circuit breaker. Tracks consecutive-failure state, decides whether to open the circuit. |
 
 ## Timeouts
 
@@ -441,22 +448,11 @@ duration. See
 [`assistant/src/plugins/pipeline.ts`](../src/plugins/pipeline.ts) for the
 current values.
 
-| Pipeline             | Timeout  | Rationale                                                                                                      |
-| -------------------- | -------- | -------------------------------------------------------------------------------------------------------------- |
-| `turn`               | none     | Turn duration is bounded by the downstream `llmCall` / `toolExecute` timeouts, not a pipeline-level timer.     |
-| `llmCall`            | none     | Deferred to the provider's HTTP timeout so network hiccups surface as provider errors, not pipeline timeouts.  |
-| `toolExecute`        | none     | Deferred to the per-tool timeout already enforced by `ToolExecutor`.                                           |
-| `memoryRetrieval`    | 5000 ms  | Memory reads may hit Qdrant and disk; 5 s leaves slack for cold caches without blocking the turn indefinitely. |
-| `historyRepair`      | 1000 ms  | CPU-bound list walk — should finish in a few ms.                                                               |
-| `tokenEstimate`      | 1000 ms  | Same — CPU-bound, should return instantly.                                                                     |
-| `compaction`         | 30000 ms | Summarization involves a provider call; mirrors the pipeline-level budget for LLM-backed operations.           |
-| `overflowReduce`     | 30000 ms | Iterative compaction; matches the `compaction` budget since each tier step may invoke it.                      |
-| `persistence`        | 10000 ms | SQLite writes, Qdrant deletes, and disk syncs. 10 s is generous for the slowest op (batched segment inserts).  |
-| `titleGenerate`      | 30000 ms | Provider-backed. Fire-and-forget, but the budget exists so a stuck call doesn't leak forever.                  |
-| `toolResultTruncate` | 1000 ms  | Pure string op.                                                                                                |
-| `emptyResponse`      | 500 ms   | Decision logic only — must be near-instant.                                                                    |
-| `toolError`          | 500 ms   | Decision logic only — must be near-instant.                                                                    |
-| `circuitBreaker`     | 500 ms   | Numeric state update — must be near-instant.                                                                   |
+| Pipeline         | Timeout  | Rationale                                                                                            |
+| ---------------- | -------- | ---------------------------------------------------------------------------------------------------- |
+| `compaction`     | 30000 ms | Summarization involves a provider call; mirrors the pipeline-level budget for LLM-backed operations. |
+| `overflowReduce` | 30000 ms | Iterative compaction; matches the `compaction` budget since each tier step may invoke it.            |
+| `circuitBreaker` | 500 ms   | Numeric state update — must be near-instant.                                                         |
 
 `null` timeouts skip the timer entirely. Finite timeouts arm a
 `setTimeout` that races the pipeline via `Promise.race`.
@@ -793,7 +789,7 @@ Every pipeline invocation emits one structured line tagged
 
 | Field                                      | Meaning                                                                 |
 | ------------------------------------------ | ----------------------------------------------------------------------- |
-| `pipeline`                                 | Pipeline name (`llmCall`, `toolExecute`, …).                            |
+| `pipeline`                                 | Pipeline name (`compaction`, `overflowReduce`, …).                      |
 | `chain`                                    | Ordered list of middleware function names, outermost first.             |
 | `durationMs`                               | Total time spent in the composed chain.                                 |
 | `outcome`                                  | `"success"`, `"error"`, or `"timeout"`.                                 |

package/examples/plugins/echo/README.md

@@ -4,8 +4,8 @@ Minimal example plugin. Observes every assistant pipeline and logs one JSON
 line per invocation to `stderr`:
 
 ```json
-{"plugin":"echo","pipeline":"toolExecute","durationMs":42,"outcome":"success"}
-{"plugin":"echo","pipeline":"llmCall","durationMs":1873,"outcome":"success"}
+{"plugin":"echo","pipeline":"compaction","durationMs":1590,"outcome":"success"}
+{"plugin":"echo","pipeline":"overflowReduce","durationMs":42,"outcome":"success"}
 ```
 
 Use this as a starting point for writing your own plugin, or as a quick way
@@ -18,10 +18,8 @@ For the full plugin authoring guide, see
 ## What it does
 
 - Registers one observer middleware per slot in
-  `PipelineMiddlewareMap` — `turn`, `llmCall`, `toolExecute`,
-  `memoryRetrieval`, `historyRepair`, `tokenEstimate`, `compaction`,
-  `overflowReduce`, `persistence`, `titleGenerate`, `toolResultTruncate`,
-  `emptyResponse`, `toolError`, and `circuitBreaker`.
+  `PipelineMiddlewareMap` — `compaction`, `overflowReduce`, and
+  `circuitBreaker`.
 - Each middleware calls `next(args)` to pass the request through unchanged,
   measures wall-clock duration, and emits one line to `stderr` whether the
   downstream succeeded or threw.
@@ -96,12 +94,8 @@ tail -f ~/.vellum/daemon.log
 You should see one line per pipeline invocation, similar to:
 
 ```json
-{"plugin":"echo","pipeline":"persistence","durationMs":3,"outcome":"success"}
-{"plugin":"echo","pipeline":"tokenEstimate","durationMs":1,"outcome":"success"}
-{"plugin":"echo","pipeline":"memoryRetrieval","durationMs":64,"outcome":"success"}
-{"plugin":"echo","pipeline":"historyRepair","durationMs":0,"outcome":"success"}
-{"plugin":"echo","pipeline":"llmCall","durationMs":1520,"outcome":"success"}
-{"plugin":"echo","pipeline":"turn","durationMs":1590,"outcome":"success"}
+{"plugin":"echo","pipeline":"compaction","durationMs":1590,"outcome":"success"}
+{"plugin":"echo","pipeline":"overflowReduce","durationMs":42,"outcome":"success"}
 ```
 
 If a pipeline throws (for example, a tool that errors out), you'll see a

package/examples/plugins/echo/register.ts

@@ -40,37 +40,15 @@
  * user-plugin-loader contract (see `assistant/src/plugins/user-loader.ts`).
  */
 
-import type {
-  ToolResultTruncateArgs,
-  ToolResultTruncateResult,
-} from "../../../src/plugins/defaults/tool-result-truncate/types.js";
 import type { VellumPluginRuntime } from "../../../src/plugins/external-api.js";
 import type {
   CircuitBreakerArgs,
   CircuitBreakerResult,
   CompactionArgs,
   CompactionResult,
-  EmptyResponseArgs,
-  EmptyResponseResult,
-  LLMCallArgs,
-  LLMCallResult,
-  MemoryArgs,
-  MemoryResult,
   OverflowReduceArgs,
   OverflowReduceResult,
-  PersistArgs,
-  PersistResult,
   Plugin,
-  TitleArgs,
-  TitleResult,
-  TokenEstimateArgs,
-  TokenEstimateResult,
-  ToolErrorArgs,
-  ToolErrorResult,
-  ToolExecuteArgs,
-  ToolExecuteResult,
-  TurnArgs,
-  TurnResult,
 } from "../../../src/plugins/types.js";
 
 const runtime = (globalThis as { __vellumPluginRuntime?: VellumPluginRuntime })
@@ -150,29 +128,10 @@ const echoPlugin: Plugin = {
     version: "0.1.0",
   },
   middleware: {
-    turn: makeObserver<TurnArgs, TurnResult>("turn"),
-    llmCall: makeObserver<LLMCallArgs, LLMCallResult>("llmCall"),
-    toolExecute: makeObserver<ToolExecuteArgs, ToolExecuteResult>(
-      "toolExecute",
-    ),
-    memoryRetrieval: makeObserver<MemoryArgs, MemoryResult>("memoryRetrieval"),
-    tokenEstimate: makeObserver<TokenEstimateArgs, TokenEstimateResult>(
-      "tokenEstimate",
-    ),
     compaction: makeObserver<CompactionArgs, CompactionResult>("compaction"),
     overflowReduce: makeObserver<OverflowReduceArgs, OverflowReduceResult>(
       "overflowReduce",
     ),
-    persistence: makeObserver<PersistArgs, PersistResult>("persistence"),
-    titleGenerate: makeObserver<TitleArgs, TitleResult>("titleGenerate"),
-    toolResultTruncate: makeObserver<
-      ToolResultTruncateArgs,
-      ToolResultTruncateResult
-    >("toolResultTruncate"),
-    emptyResponse: makeObserver<EmptyResponseArgs, EmptyResponseResult>(
-      "emptyResponse",
-    ),
-    toolError: makeObserver<ToolErrorArgs, ToolErrorResult>("toolError"),
     circuitBreaker: makeObserver<CircuitBreakerArgs, CircuitBreakerResult>(
       "circuitBreaker",
     ),

package/node_modules/@vellumai/skill-host-contracts/src/server-message.ts

@@ -16,9 +16,9 @@
  * Moving the fully typed discriminated union into this package would
  * require relocating `assistant/src/daemon/message-types/` and its
  * cross-file type dependencies (`channels/types.ts`,
- * `skills/skillssh-registry.ts`, `runtime/guardian-decision-types.ts`,
- * `gallery/gallery-manifest.ts`). That is out of scope for PR 3 of the
- * skill-isolation plan and is tracked for later iteration.
+ * `skills/skillssh-registry.ts`, `runtime/guardian-decision-types.ts`).
+ * That is out of scope for PR 3 of the skill-isolation plan and is
+ * tracked for later iteration.
  */
 
 /**