@vellumai/assistant 0.8.4 → 0.8.5

package/src/tools/tool-defaults.ts

@@ -0,0 +1,94 @@
+/**
+ * Single source of truth for the defaults applied when a `ToolDefinition`
+ * omits one of the normally-required fields, plus the `finalizeTool`
+ * helper that lifts a `ToolDefinition` into a `LoadedTool`.
+ *
+ * Plugins, external loaders, and any other registration boundary that
+ * accepts loose `ToolDefinition` objects from authors must run them
+ * through `finalizeTool` before handing the result to a `registerXxxTools`
+ * call. The registry types make this a hard rule: every registered tool
+ * is a `LoadedTool` (`Required<ToolDefinition> & { name }`).
+ */
+
+import type {
+  LoadedTool,
+  RiskLevel,
+  ToolDefinition,
+  ToolExecutionResult,
+} from "./types.js";
+
+/**
+ * Default values applied by `finalizeTool` when the author omits a field.
+ *
+ * - `description` defaults to empty — the model sees the tool name only
+ *   for un-documented tools, which is the correct minimal-info signal.
+ * - `defaultRiskLevel` defaults to `medium` — the safe middle band that
+ *   forces explicit approval for risky calls without spamming approval
+ *   prompts on no-op tools.
+ * - `input_schema` defaults to an empty closed object — the model is
+ *   allowed to call the tool with no arguments, and unknown arguments
+ *   are rejected at the JSON-schema layer.
+ * - `executionTarget` defaults to `sandbox` — author-supplied tool code
+ *   runs in the assistant container by default; opt in to `host` when
+ *   the tool proxies work to the connected client.
+ *
+ * `execute` has no constant default because the default closure needs to
+ * close over the tool's name to produce a useful error message; see
+ * `finalizeTool` below.
+ */
+export const TOOL_DEFAULTS = Object.freeze({
+  description: "",
+  defaultRiskLevel: "medium" as RiskLevel,
+  input_schema: Object.freeze({
+    type: "object",
+    properties: {},
+    additionalProperties: false,
+  }) as object,
+  executionTarget: "sandbox" as const,
+});
+
+/**
+ * Fill the four normally-required `ToolDefinition` fields with documented
+ * defaults when the author omitted them, attach the registration-time
+ * `name`, and return a `LoadedTool` that is safe to hand to a
+ * `registerXxxTools` call.
+ *
+ * The default `execute` returns an error result so the model sees a clear
+ * "this tool isn't wired up" signal at call time. The owning loader still
+ * registers the tool cleanly — a broken individual tool must never block
+ * the registration batch.
+ */
+export function finalizeTool(
+  tool: ToolDefinition,
+  name: string,
+): LoadedTool {
+  const description =
+    typeof tool.description === "string"
+      ? tool.description
+      : TOOL_DEFAULTS.description;
+  const defaultRiskLevel =
+    typeof tool.defaultRiskLevel === "string"
+      ? tool.defaultRiskLevel
+      : TOOL_DEFAULTS.defaultRiskLevel;
+  const input_schema =
+    tool.input_schema !== null && typeof tool.input_schema === "object"
+      ? tool.input_schema
+      : TOOL_DEFAULTS.input_schema;
+  const execute =
+    typeof tool.execute === "function"
+      ? tool.execute
+      : async (): Promise<ToolExecutionResult> => ({
+          content: `tool ${name} has no execute implementation`,
+          isError: true,
+        });
+  const executionTarget = tool.executionTarget ?? TOOL_DEFAULTS.executionTarget;
+  return {
+    ...tool,
+    name,
+    description,
+    defaultRiskLevel,
+    input_schema,
+    executionTarget,
+    execute,
+  };
+}

package/src/tools/types.ts

@@ -5,7 +5,6 @@ import type {
   ProxyApprovalCallback,
   RiskLevel,
   SensitiveOutputBinding,
-  ToolDefinition,
   ToolExecutionErrorEvent,
   ToolExecutionStartEvent,
   ToolPermissionDeniedEvent,
@@ -64,7 +63,6 @@ export type {
   ProxyEnvVars,
   SensitiveOutputBinding,
   SensitiveOutputKind,
-  ToolDefinition,
   ToolExecutionErrorEvent,
   ToolExecutionStartEvent,
   ToolPermissionDeniedEvent,
@@ -76,19 +74,7 @@ export { RiskLevel } from "@vellumai/skill-host-contracts";
 // Assistant-side concrete overlays
 // ---------------------------------------------------------------------------
 
-/**
- * Public, narrow subset of {@link ToolExecutionResult} that plugin-authored
- * tools are responsible for producing. Re-exported from
- * `@vellumai/plugin-api` as `ToolExecutionResult` — the type name plugin
- * authors actually import. The daemon-internal version below extends
- * this and adds runtime-only fields (risk metadata, approval
- * bookkeeping, sensitive-output bindings, etc.) that the executor
- * populates around the call — plugins MUST NOT set those.
- *
- * Adding fields here is a non-breaking change; renaming or removing
- * fields is breaking and gated on a major bump of `@vellumai/plugin-api`.
- */
-export interface PluginToolExecutionResult {
+export interface ToolExecutionResult {
   /** Textual result shown to the model in the tool-result block. Empty string is valid. */
   content: string;
   /** When true, the agent loop treats `content` as an error and may surface it / retry. */
@@ -105,9 +91,6 @@ export interface PluginToolExecutionResult {
    * the LLM voluntarily end its turn.
    */
   yieldToUser?: boolean;
-}
-
-export interface ToolExecutionResult extends PluginToolExecutionResult {
   diff?: DiffInfo;
   /** Optional rich content blocks (e.g. images) to include alongside text in the tool result. */
   contentBlocks?: ContentBlock[];
@@ -211,20 +194,7 @@ export type ToolLifecycleEventHandler = (
   event: ToolLifecycleEvent,
 ) => void | Promise<void>;
 
-/**
- * Public, narrow subset of {@link ToolContext} handed to plugin-authored
- * tools. Re-exported from `@vellumai/plugin-api` as `ToolContext` — the
- * type name plugin authors actually import. The daemon-internal version
- * below extends this and adds host-only fields (CES client, trust class,
- * lifecycle handlers, requester metadata, host-bash proxy, etc.). Plugin
- * tools see this shape only — the runtime still hands them the full
- * {@link ToolContext} value, but the structural extension here guarantees
- * the assignment without a manual cast.
- *
- * Adding fields here is a non-breaking change; renaming or removing
- * fields is breaking and gated on a major bump of `@vellumai/plugin-api`.
- */
-export interface PluginToolContext {
+export interface ToolContext {
   /** Identifier of the conversation this tool invocation belongs to. */
   conversationId: string;
   /** Working directory the daemon was launched from. */
@@ -235,9 +205,6 @@ export interface PluginToolContext {
   signal?: AbortSignal;
   /** Optional incremental-output callback for streaming tools. Streaming tools should fall back to returning the full result in `content` when this is absent. */
   onOutput?: (chunk: string) => void;
-}
-
-export interface ToolContext extends PluginToolContext {
   /** Logical assistant scope for multi-assistant routing. */
   assistantId?: string;
   /** When set, the tool execution is part of a task run. Used to retrieve ephemeral permission rules. */
@@ -349,11 +316,32 @@ export interface ToolContext extends PluginToolContext {
   sourceActorPrincipalId?: string;
 }
 
-export interface Tool {
-  name: string;
-  description: string;
+/**
+ * Author-facing tool spec — re-exported from `@vellumai/plugin-api`.
+ * Loaders fill documented defaults for omitted fields via `finalizeTool`
+ * in `tool-defaults.ts`.
+ */
+export interface ToolDefinition {
+  /** Human-readable description shown to the model in the tool catalog. */
+  description?: string;
+  /** Author-asserted risk band — low / medium / high. Drives default permission gating. */
+  defaultRiskLevel?: RiskLevel;
+  /** JSON schema describing the tool's input arguments. */
+  input_schema?: object;
+  /** Where the tool runs — sandbox (assistant container) or host (guardian device via proxy). Resolved by `resolveExecutionTarget` if omitted. */
+  executionTarget?: ExecutionTarget;
+  /** Implementation invoked when the model calls the tool. */
+  execute?: (
+    input: Record<string, unknown>,
+    context: ToolContext,
+  ) => Promise<ToolExecutionResult>;
+}
+
+/** Tool after the loader has derived its name and filled defaults. */
+export type LoadedTool = Required<ToolDefinition> & { name: string };
+
+export interface Tool extends LoadedTool {
   category: string;
-  defaultRiskLevel: RiskLevel;
   /** When set to 'proxy', the tool is forwarded to a connected client rather than executed locally. */
   executionMode?: "local" | "proxy";
   /** Whether this tool is a core built-in, provided by a skill, contributed by a plugin, or from an MCP server. */
@@ -368,63 +356,4 @@ export interface Tool {
   ownerSkillVersionHash?: string;
   /** Whether the owning skill is bundled with the daemon (trusted first-party). */
   ownerSkillBundled?: boolean;
-  /** Declared execution target from the skill manifest. Used by resolveExecutionTarget
-   * to accurately label lifecycle events for skill-provided tools. */
-  executionTarget?: ExecutionTarget;
-  getDefinition(): ToolDefinition;
-  execute(
-    input: Record<string, unknown>,
-    context: ToolContext,
-  ): Promise<ToolExecutionResult>;
 }
-
-/**
- * Plugin-facing tool shape. The narrow surface plugin authors implement;
- * differs from {@link Tool} in four ways:
- * - Plugins declare `input_schema` as a top-level field instead of
- *   implementing `getDefinition()`. The registration boundary synthesizes
- *   `getDefinition()` from `{name, description, input_schema}` before the
- *   tool enters the internal registry.
- * - `name` is derived from the tool file's basename by the external plugin
- *   loader.
- * - `category` is registry-owned and stamped to `"plugin"` when the tool is
- *   registered.
- * - All ownership stamps (`origin`, `ownerPluginId`, etc.) are set
- *   authoritatively by the bootstrap; plugin authors leave them blank.
- *
- * Every author-visible field is optional. The loader fills the four
- * normally-required slots (`description`, `defaultRiskLevel`,
- * `input_schema`, `execute`) with documented defaults when a plugin omits
- * them — see `applyPluginToolDefaults` in `external-plugin-loader.ts`.
- * A nameless, body-less `export default {}` is a valid (if useless) tool;
- * misconfigured tools surface at call time rather than blocking plugin
- * load.
- */
-export type PluginTool = Omit<
-  Tool,
-  "category" | "getDefinition" | "name" | "description" | "defaultRiskLevel"
-> & {
-  description?: string;
-  defaultRiskLevel?: RiskLevel;
-  input_schema?: object;
-  execute?: (
-    input: Record<string, unknown>,
-    context: ToolContext,
-  ) => Promise<ToolExecutionResult>;
-};
-
-/**
- * Plugin tool after the external loader has derived its registry name and
- * filled defaults for any author-omitted fields. All four normally-required
- * slots are guaranteed present.
- */
-export type LoadedPluginTool = PluginTool & {
-  name: string;
-  description: string;
-  defaultRiskLevel: RiskLevel;
-  input_schema: object;
-  execute: (
-    input: Record<string, unknown>,
-    context: ToolContext,
-  ) => Promise<ToolExecutionResult>;
-};

package/src/tools/ui-surface/definitions.ts

@@ -8,7 +8,6 @@
  */
 
 import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
 import type { Tool, ToolExecutionResult } from "../types.js";
 
 // ---------------------------------------------------------------------------
@@ -42,12 +41,9 @@ export const uiShowTool: Tool = {
   category: "ui-surface",
   defaultRiskLevel: RiskLevel.Low,
   executionMode: "proxy",
+  executionTarget: "host",
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
+  input_schema: {
         type: "object",
         properties: {
           surface_type: {
@@ -109,8 +105,6 @@ export const uiShowTool: Tool = {
         },
         required: ["surface_type", "data"],
       },
-    };
-  },
 
   execute: proxyExecute,
 };
@@ -127,12 +121,9 @@ const uiUpdateTool: Tool = {
   category: "ui-surface",
   defaultRiskLevel: RiskLevel.Low,
   executionMode: "proxy",
+  executionTarget: "host",
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
+  input_schema: {
         type: "object",
         properties: {
           surface_id: {
@@ -146,8 +137,6 @@ const uiUpdateTool: Tool = {
         },
         required: ["surface_id", "data"],
       },
-    };
-  },
 
   execute: proxyExecute,
 };
@@ -162,12 +151,9 @@ const uiDismissTool: Tool = {
   category: "ui-surface",
   defaultRiskLevel: RiskLevel.Low,
   executionMode: "proxy",
+  executionTarget: "host",
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
+  input_schema: {
         type: "object",
         properties: {
           surface_id: {
@@ -177,8 +163,6 @@ const uiDismissTool: Tool = {
         },
         required: ["surface_id"],
       },
-    };
-  },
 
   execute: proxyExecute,
 };

package/src/usage/pricing.ts

@@ -20,9 +20,32 @@ function normalizeTokenCount(value: number | null | undefined): number {
 
 function asRecord(value: unknown): Record<string, unknown> | null {
   if (typeof value !== "object" || value == null) return null;
+  if (Array.isArray(value)) return null;
   return value as Record<string, unknown>;
 }
 
+/**
+ * Extract the provider's untouched `usage` block from a `rawResponse`
+ * payload for opaque end-to-end forwarding (the `raw_usage` column /
+ * telemetry field).
+ *
+ * Returns `null` when there is no usage object to surface. For streaming
+ * providers that pass `rawResponse` as an accumulated array of chunks,
+ * the final element's `usage` is preferred — Anthropic and OpenAI both
+ * stamp the complete tally on the terminal chunk, so taking the last
+ * element captures the post-completion state without re-aggregating.
+ */
+export function extractRawUsage(
+  rawResponse: unknown,
+): Record<string, unknown> | null {
+  if (rawResponse == null) return null;
+  const candidate = Array.isArray(rawResponse)
+    ? rawResponse[rawResponse.length - 1]
+    : rawResponse;
+  const record = asRecord(candidate);
+  return asRecord(record?.usage);
+}
+
 function extractAnthropicCacheCreationFromResponse(
   response: unknown,
 ): AnthropicCacheCreationTokenDetails | null {

package/src/usage/types.ts

@@ -42,6 +42,18 @@ export interface UsageEventInput {
   outputTokens: number;
   cacheCreationInputTokens: number | null;
   cacheReadInputTokens: number | null;
+  /**
+   * The provider's untouched `usage` block (the literal object returned in
+   * the API response), preserved as JSON so downstream consumers can
+   * extract any provider-specific detail without requiring a schema
+   * change. Anthropic nests its TTL breakdown under
+   * `cache_creation.ephemeral_{5m,1h}_input_tokens`; OpenAI nests cached
+   * read counts under `prompt_tokens_details.cached_tokens`; both shapes
+   * are stored as-is. `null` when the provider did not return a usage
+   * block and for rows persisted before the
+   * `260-llm-usage-add-raw-usage` migration.
+   */
+  rawUsage: Record<string, unknown> | null;
   actor: UsageActor;
   conversationId: string | null;
   runId: string | null;

package/src/util/logger.ts

@@ -17,7 +17,7 @@ import {
   getIsContainerized,
 } from "../config/env-registry.js";
 import { logSerializers } from "./log-redact.js";
-import { getLogPath } from "./platform.js";
+import { getLogsDir } from "./platform.js";
 import { createSentryLogStream } from "./sentry-log-stream.js";
 
 /** Common pino-pretty options that inline [module] into the message prefix. */
@@ -87,7 +87,7 @@ function resolveLogDir(config: LogFileConfig): string | undefined {
       if (getIsContainerized()) {
         // Config has a host-specific path that can't be created inside the
         // container (e.g. /Users/…). Fall back to the default log directory.
-        const fallback = join(getLogPath(), "..");
+        const fallback = getLogsDir();
         console.warn(
           `[logger] Configured logFile.dir "${config.dir}" cannot be created ` +
             `in container (${(err as Error).message}). Falling back to "${fallback}".`,
@@ -210,7 +210,8 @@ function getRootLogger(): pino.Logger {
     }
 
     try {
-      const logPath = getLogPath();
+      const logDir = getLogsDir();
+      const logPath = logFilePathForDate(logDir, new Date());
       // Use sync: true so the fd is opened immediately. This prevents
       // "sonic boom is not ready yet" errors when commander calls
       // process.exit(0) for --help/--version before the async fd is ready.
@@ -247,6 +248,10 @@ function getRootLogger(): pino.Logger {
           fileStream,
         );
       }
+
+      // Register state so ensureCurrentDate() rebuilds across UTC midnight.
+      activeLogFileConfig = { dir: logDir, retentionDays: 0 };
+      activeLogDate = formatDate(new Date());
     } catch {
       rootLogger = pino(
         {
@@ -274,16 +279,20 @@ export function truncateForLog(value: string, maxLen = 500): string {
 /**
  * Returns a lazy logger that only initializes pino when a log method is called.
  * This avoids "sonic boom is not ready yet" errors when the process exits
- * quickly (e.g. `assistant --help`).
+ * quickly (e.g. `assistant --help`). The child is rebuilt whenever the
+ * underlying root logger changes (e.g. day rollover, late initLogger()).
  */
 export function getLogger(name: string): pino.Logger {
+  let cachedRoot: pino.Logger | null = null;
   let child: pino.Logger | null = null;
   const handler: ProxyHandler<pino.Logger> = {
     get(_target, prop, receiver) {
-      if (!child) {
-        child = getRootLogger().child({ module: name });
+      const root = getRootLogger();
+      if (root !== cachedRoot) {
+        cachedRoot = root;
+        child = root.child({ module: name });
       }
-      const val = Reflect.get(child, prop, receiver);
+      const val = Reflect.get(child!, prop, receiver);
       if (typeof val === "function") {
         return val.bind(child);
       }

package/src/util/platform.ts

@@ -158,8 +158,13 @@ export function getDbPath(): string {
   return join(getDataDir(), "db", "assistant.db");
 }
 
-export function getLogPath(): string {
-  return join(getDataDir(), "logs", "vellum.log");
+/**
+ * Returns the directory where logs live: `<dataDir>/logs/`. Files rotate
+ * daily (`assistant-YYYY-MM-DD.log`), so callers ask for the directory and
+ * let the logger own the filename.
+ */
+export function getLogsDir(): string {
+  return join(getDataDir(), "logs");
 }
 
 export function getHistoryPath(): string {

package/src/util/sqlite3-runtime.ts

@@ -0,0 +1,65 @@
+/**
+ * Shared helper for locating a `sqlite3` CLI binary on the host.
+ *
+ * Used by `memory/db-async-query.ts` so slow statements (`VACUUM`,
+ * `PRAGMA optimize`, large bulk deletes) can be shelled out to a
+ * subprocess and run without blocking the daemon's main event loop.
+ *
+ * Resolution order (matches the spirit of `bun-runtime.ts#findBun()`):
+ *   1. Common system install locations
+ *   2. `Bun.which("sqlite3")` (PATH lookup)
+ *
+ * Unlike `bun-runtime.ts`, this module does **not** download `sqlite3`
+ * when missing. The async path is opt-out (callers fall back to the
+ * synchronous in-process `bun:sqlite` connection); if a user wants the
+ * non-blocking behavior they install one package.
+ *
+ * On platform (k8s assistant container) `sqlite3` is installed in the
+ * Dockerfile, so the primary path is always available there. On macOS
+ * `sqlite3` ships with the OS. On most Linux distros it's available via
+ * the system package manager.
+ */
+
+import { existsSync } from "node:fs";
+
+let cachedSqlite3Path: string | undefined | null;
+
+/**
+ * Synchronous lookup for a usable `sqlite3` CLI binary.
+ * Returns the path if found, `undefined` otherwise. Result is cached
+ * per-process so the filesystem checks only happen once.
+ */
+export function findSqlite3(): string | undefined {
+  if (cachedSqlite3Path !== undefined) {
+    return cachedSqlite3Path ?? undefined;
+  }
+
+  // 1. Common install locations. We check these before `Bun.which` so we
+  //    pick a deterministic, predictable binary even when PATH is
+  //    unusual (e.g. a daemon launched with a stripped env).
+  for (const p of [
+    "/usr/bin/sqlite3",
+    "/usr/local/bin/sqlite3",
+    "/opt/homebrew/bin/sqlite3",
+  ]) {
+    if (existsSync(p)) {
+      cachedSqlite3Path = p;
+      return p;
+    }
+  }
+
+  // 2. PATH lookup.
+  const which = Bun.which("sqlite3");
+  if (which) {
+    cachedSqlite3Path = which;
+    return which;
+  }
+
+  cachedSqlite3Path = null;
+  return undefined;
+}
+
+/** Reset the cached lookup. Test-only. */
+export function _resetSqlite3Cache(): void {
+  cachedSqlite3Path = undefined;
+}

package/src/workspace/migrations/086-revert-stale-gemini-mis-rewrites.ts

@@ -140,6 +140,7 @@ const GEMINI_CATALOG_MODELS = new Set<string>([
   "gemini-3.1-pro-preview-customtools",
   "gemini-3-flash-preview",
   "gemini-3.1-flash-lite-preview",
+  "gemini-3.1-flash-lite",
   "gemini-2.5-flash",
   "gemini-2.5-flash-lite",
   "gemini-2.5-pro",

package/src/workspace/migrations/089-move-memory-tree-out-of-v3.ts

@@ -0,0 +1,86 @@
+import * as fs from "node:fs";
+import { dirname, join } from "node:path";
+
+import { getLogger } from "../../util/logger.js";
+import type { WorkspaceMigration } from "./types.js";
+
+const log = getLogger("workspace-migration-089-move-memory-tree-out-of-v3");
+
+function isNotFoundError(err: unknown): boolean {
+  return (
+    typeof err === "object" &&
+    err !== null &&
+    "code" in err &&
+    err.code === "ENOENT"
+  );
+}
+
+/**
+ * Move `<workspace>/memory/<fromRel>` to `<workspace>/memory/<toRel>` when the
+ * source exists and the destination does not. Idempotent: a missing source is a
+ * no-op (already migrated, or never created), and an existing destination is
+ * left untouched (we never clobber). Both directions go through here so `run`
+ * and `down` share the same safety checks.
+ */
+function moveMemorySubdir(
+  workspaceDir: string,
+  fromRel: string,
+  toRel: string,
+): void {
+  const memoryDir = join(workspaceDir, "memory");
+  const src = join(memoryDir, fromRel);
+  const dest = join(memoryDir, toRel);
+  try {
+    if (!fs.existsSync(src)) return;
+    if (fs.existsSync(dest)) {
+      log.warn(
+        { src, dest },
+        "Both source and destination tree dirs exist; leaving in place for manual resolution",
+      );
+      return;
+    }
+    fs.mkdirSync(dirname(dest), { recursive: true });
+    fs.renameSync(src, dest);
+    log.info({ src, dest }, "Moved memory tree directory");
+  } catch (err) {
+    if (isNotFoundError(err)) return;
+    log.warn({ err, src, dest }, "Failed to move memory tree directory");
+    throw err;
+  }
+}
+
+/** Remove `<workspace>/memory/v3` if it is now an empty wrapper (the tree was
+ *  its only child). Best-effort — a non-empty or missing dir is left alone. */
+function removeEmptyV3Wrapper(workspaceDir: string): void {
+  const v3Dir = join(workspaceDir, "memory", "v3");
+  try {
+    if (fs.existsSync(v3Dir) && fs.readdirSync(v3Dir).length === 0) {
+      fs.rmdirSync(v3Dir);
+    }
+  } catch {
+    // Non-fatal: leaving an empty memory/v3 wrapper is harmless.
+  }
+}
+
+/**
+ * Relocate the v3 memory tree from `memory/v3/tree` to `memory/tree`.
+ *
+ * The tree is a DAG overlay over the flat `memory/concepts/` pages and is now a
+ * top-level sibling of `concepts/` (matching the storage design), no longer
+ * nested under a `v3/` wrapper. `getTreeDir` reads `memory/tree` after this
+ * change, so any pre-existing hand-authored tree must move with it.
+ */
+export const moveMemoryTreeOutOfV3Migration: WorkspaceMigration = {
+  id: "089-move-memory-tree-out-of-v3",
+  description: "Relocate the v3 memory tree from memory/v3/tree to memory/tree",
+  retryFailedCheckpoint: true,
+
+  run(workspaceDir: string): void {
+    moveMemorySubdir(workspaceDir, join("v3", "tree"), "tree");
+    removeEmptyV3Wrapper(workspaceDir);
+  },
+
+  down(workspaceDir: string): void {
+    moveMemorySubdir(workspaceDir, "tree", join("v3", "tree"));
+  },
+};

package/src/workspace/migrations/registry.ts

@@ -86,6 +86,7 @@ import { memoryV2Bm25BReembedDisabledV2PagesMigration } from "./085-memory-v2-bm
 import { revertStaleGeminiMisRewritesMigration } from "./086-revert-stale-gemini-mis-rewrites.js";
 import { memoryRouterBalancedProfileMigration } from "./087-memory-router-balanced-profile.js";
 import { deprecateBackgroundConversationOverrideMigration } from "./088-deprecate-background-conversation-override.js";
+import { moveMemoryTreeOutOfV3Migration } from "./089-move-memory-tree-out-of-v3.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -183,4 +184,5 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   revertStaleGeminiMisRewritesMigration,
   memoryRouterBalancedProfileMigration,
   deprecateBackgroundConversationOverrideMigration,
+  moveMemoryTreeOutOfV3Migration,
 ];