@vellumai/assistant 0.8.7 → 0.8.8

package/src/gallery/gallery-manifest.ts

@@ -1,28 +0,0 @@
-export interface GalleryManifest {
-  version: number;
-  updatedAt: string;
-  categories: GalleryCategory[];
-  apps: GalleryApp[];
-}
-
-export interface GalleryCategory {
-  id: string; // e.g. "productivity", "health", "fun"
-  name: string; // Display name
-  icon: string; // Emoji
-}
-
-export interface GalleryApp {
-  id: string; // Unique identifier
-  name: string;
-  description: string;
-  icon: string; // Emoji
-  category: string; // Category ID
-  version: string; // e.g. "1.0.0"
-  featured?: boolean;
-  schemaJson: string; // JSON schema for app records
-  htmlDefinition: string; // Complete HTML app (also serves as compiled fallback)
-  /** 2 = multi-file TSX format with sourceFiles */
-  formatVersion?: number;
-  /** Maps relative path to file content, e.g. { "src/main.tsx": "...", "src/index.html": "..." } */
-  sourceFiles?: Record<string, string>;
-}

package/src/home/feature-gate.ts

@@ -1,22 +0,0 @@
-import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
-import type { AssistantConfig } from "../config/schema.js";
-
-const HOME_PAGE_FLAG_KEY = "home-page" as const;
-
-/**
- * Whether the home page / home feed surface is enabled for this install.
- *
- * `home-page` is a `"both"`-scope flag: the client renders the home feed as the
- * landing view, and the notification pipeline uses it to decide whether passive
- * notifications have a home-feed surface to land on (when off, they fall back to
- * materializing a conversation instead of being suppressed).
- *
- * `config` is accepted for parity with the other gate modules but is unused —
- * the value resolves from the gateway override cache / registry default.
- */
-export function isHomePageEnabled(config?: AssistantConfig): boolean {
-  return isAssistantFeatureFlagEnabled(
-    HOME_PAGE_FLAG_KEY,
-    (config ?? {}) as AssistantConfig,
-  );
-}

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

@@ -1,22 +0,0 @@
-import type {
-  EmptyResponseArgs,
-  EmptyResponseResult,
-  Middleware,
-} from "../../../types.js";
-
-/**
- * Passthrough middleware for the `emptyResponse` pipeline. Forwards to
- * `next(args)` unchanged; the actual empty-response decision lives in the
- * terminal handler (`../terminal.ts`), wired in at the `runPipeline` call site
- * in `agent/loop.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<EmptyResponseArgs, EmptyResponseResult> = async (
-  args,
-  next,
-) => next(args);
-
-export default passthrough;

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

@@ -1,106 +0,0 @@
-/**
- * Default `emptyResponse` behavior: decides whether an empty assistant turn
- * should be nudged (re-queried) or accepted.
- *
- * This module is side-effect free: importing it does not register any plugin.
- *
- * The handler inspects the turn snapshot and returns one of:
- *
- * 1. `"nudge"`  — fired in two distinct shapes:
- *                 (a) **Post-tool empty.** 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`. Uses `NUDGE_TEXT`.
- *                 (b) **Refusal stop.** The provider returned
- *                     `stopReason === "refusal"` with no visible text and no
- *                     tool calls (Anthropic's safety classifier). Nudges even
- *                     on turn 0 / before any tool use, because a refusal on
- *                     the first model call of the run is a hard guarantee
- *                     that no organic text exists yet — without intervening
- *                     we'd persist an empty assistant bubble to the user.
- *                     Uses the refusal-specific `REFUSAL_NUDGE_TEXT`. The
- *                     retry cap still applies; after `maxEmptyResponseRetries`
- *                     refusals in a row the terminal falls through to accept.
- *                 The loop appends the chosen `nudgeText` 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 passed in via
- * `EmptyResponseArgs.maxEmptyResponseRetries` so the cap is declared in one
- * place only.
- */
-
-import type { EmptyResponseArgs, EmptyResponseResult } 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>";
-
-/**
- * Refusal-specific nudge. Used when the provider stops with `"refusal"`
- * before any tool use — i.e. the safety classifier zeroed the response.
- * Kept distinct from `NUDGE_TEXT` so the model gets context-appropriate
- * guidance (no "summary of what you found or did" — there is no tool
- * trail to summarize on a turn-0 refusal).
- *
- * Wire-compat note: this is shown to the LLM, not the user. Edits here
- * affect retry behavior but not end-user UX directly.
- */
-export const REFUSAL_NUDGE_TEXT =
-  '<system_notice>Your previous response was empty because the upstream provider returned stop_reason="refusal". Please answer the user\'s last message directly with a plain-text response. Do not use any tools — just respond with text.</system_notice>';
-
-/**
- * Decide whether an empty turn should be nudged or accepted. Exported so the
- * agent loop can call it directly and tests can verify the decision logic.
- */
-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,
-  );
-
-  // Refusal stop with zero usable content — the provider's safety
-  // classifier zeroed the response. Nudge regardless of toolUseTurns or
-  // priorAssistantHadVisibleText: a `"refusal"` stop with no visible
-  // text and no tool calls IS the failure mode this branch exists to
-  // catch (otherwise we persist an empty assistant bubble to the user).
-  // Still respect the retry cap so a persistent classifier doesn't
-  // burn turns indefinitely.
-  const isRefusal =
-    args.stopReason === "refusal" &&
-    !hasVisibleText &&
-    args.toolUseBlocksLength === 0;
-
-  if (isRefusal && args.emptyResponseRetries < args.maxEmptyResponseRetries) {
-    return { action: "nudge", nudgeText: REFUSAL_NUDGE_TEXT };
-  }
-
-  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" };
-}

package/src/plugins/defaults/injectors/package.json

@@ -1,15 +0,0 @@
-{
-  "name": "default-injectors",
-  "version": "1.0.0",
-  "description": "First-party default plugin wrapping the assistant's built-in injectors 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/llm-call/middlewares/llmCall.ts

@@ -1,17 +0,0 @@
-import type { LLMCallArgs, LLMCallResult, Middleware } from "../../../types.js";
-
-/**
- * Passthrough middleware for the `llmCall` pipeline. 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 (`agent/loop.ts`)
- * performs the actual `provider.sendMessage(...)` call.
- *
- * Defaults register at the OUTERMOST onion position; forwarding
- * unconditionally keeps user-registered middleware reachable.
- */
-const defaultLlmCall: Middleware<LLMCallArgs, LLMCallResult> =
-  async function defaultLlmCall(args, next, _ctx) {
-    return next(args);
-  };
-
-export default defaultLlmCall;

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

@@ -1,15 +0,0 @@
-{
-  "name": "default-llm-call",
-  "version": "1.0.0",
-  "description": "First-party default plugin wrapping the assistant's built-in llm-call 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/llm-call/register.ts

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

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

@@ -1,17 +0,0 @@
-import type { MemoryArgs, MemoryResult, Middleware } from "../../../types.js";
-
-/**
- * Passthrough middleware for the `memoryRetrieval` pipeline.
- *
- * 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 `runDefaultMemoryRetrieval`.
- */
-const defaultMemoryRetrievalMiddleware: Middleware<MemoryArgs, MemoryResult> =
-  async function defaultMemoryRetrieval(args, next) {
-    return next(args);
-  };
-
-export default defaultMemoryRetrievalMiddleware;

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

@@ -1,15 +0,0 @@
-{
-  "name": "default-memory-retrieval",
-  "version": "0.0.1",
-  "description": "First-party default plugin wrapping the assistant's built-in memory-retrieval 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/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/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,
-      };
-    }
-  }
-}