@vellumai/assistant 0.7.0 → 0.7.2

package/src/workspace/hatched-date.ts

@@ -0,0 +1,86 @@
+import { mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { getDataDir } from "../util/platform.js";
+
+const HATCHED_SIDECAR_FILENAME = "hatched.json";
+
+export function getHatchedSidecarPath(): string {
+  return join(getDataDir(), HATCHED_SIDECAR_FILENAME);
+}
+
+function normalizeHatchedAt(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+
+  const parsedTime = Date.parse(value);
+  if (isNaN(parsedTime) || parsedTime <= 0) return undefined;
+
+  return new Date(parsedTime).toISOString();
+}
+
+export function readHatchedAtSidecar(): string | undefined {
+  try {
+    const parsed = JSON.parse(
+      readFileSync(getHatchedSidecarPath(), "utf-8"),
+    ) as { hatchedAt?: unknown };
+    return normalizeHatchedAt(parsed.hatchedAt);
+  } catch {
+    return undefined;
+  }
+}
+
+export function writeHatchedAtSidecar(hatchedAt: string): void {
+  const normalized = normalizeHatchedAt(hatchedAt);
+  if (!normalized) return;
+
+  try {
+    mkdirSync(getDataDir(), { recursive: true });
+    writeFileSync(
+      getHatchedSidecarPath(),
+      JSON.stringify({ hatchedAt: normalized }, null, 2),
+      "utf-8",
+    );
+  } catch {
+    // Best-effort stability; callers still return a valid timestamp.
+  }
+}
+
+export function selectHatchedAtFromStats(stats: {
+  birthtime: Date;
+  mtime: Date;
+}): Date | undefined {
+  const candidates = [stats.birthtime, stats.mtime];
+  return candidates.find((candidate) => candidate.getTime() > 0);
+}
+
+function readIdentityFileHatchedAt(identityPath: string): string | undefined {
+  try {
+    return selectHatchedAtFromStats(statSync(identityPath))?.toISOString();
+  } catch {
+    return undefined;
+  }
+}
+
+export function resolveHatchedAtReadOnly(
+  identityPath: string,
+  now: Date = new Date(),
+): string {
+  return (
+    readHatchedAtSidecar() ??
+    readIdentityFileHatchedAt(identityPath) ??
+    now.toISOString()
+  );
+}
+
+export function resolveAndPersistHatchedAt(
+  identityPath: string,
+  now: Date = new Date(),
+): string {
+  const sidecarHatchedAt = readHatchedAtSidecar();
+  if (sidecarHatchedAt) return sidecarHatchedAt;
+
+  const hatchedAt =
+    readIdentityFileHatchedAt(identityPath) ?? now.toISOString();
+  writeHatchedAtSidecar(hatchedAt);
+  return hatchedAt;
+}

package/src/workspace/migrations/003-seed-device-id.ts

@@ -45,7 +45,7 @@ export const seedDeviceIdMigration: WorkspaceMigration = {
 
     // b. Read the lockfile to find an existing installationId.
     //    The lockfile is always under the user's home directory, never under
-    //    BASE_DATA_DIR. Check both the current and legacy filenames.
+    //    Check both the current and legacy filenames.
     const home = homedir();
     const lockCandidates = [
       join(home, ".vellum.lock.json"),

package/src/workspace/migrations/006-services-config.ts

@@ -37,8 +37,9 @@ export const servicesConfigMigration: WorkspaceMigration = {
 
     // Skip if no legacy fields remain — either already migrated or a fresh install
     // where schema defaults are correct. We check for legacy fields instead of
-    // services existence because backfillConfigDefaults may have written a default
-    // services object before migrations run.
+    // services existence because legacy daemons (before defaults were applied
+    // only in-memory) may have written a default services object to disk
+    // before migrations run.
     const hasLegacyFields =
       "provider" in config ||
       "model" in config ||
@@ -46,7 +47,8 @@ export const servicesConfigMigration: WorkspaceMigration = {
       "webSearchProvider" in config;
     if (!hasLegacyFields) return;
 
-    // Start from existing services (may have been backfilled by loadConfig defaults)
+    // Start from existing services (legacy daemons may have written a
+    // schema-default services object to disk before this migration runs)
     // so we don't discard any non-default values already written there.
     const existingServices =
       config.services != null &&
@@ -96,8 +98,9 @@ export const servicesConfigMigration: WorkspaceMigration = {
     // Legacy top-level fields (provider, model) are the user's actual
     // configuration from before the services structure existed. If they're
     // present as strings they take precedence over any `existingServices`
-    // values, which are just defaults written by backfillConfigDefaults().
-    // The spread preserves any extra keys that future backfills may add.
+    // values, which on legacy daemons may just be schema defaults that an
+    // older loader wrote to disk. The spread preserves any extra keys that
+    // legacy daemons may have written alongside.
     services.inference = {
       ...(existingServices.inference ?? {}),
       mode: inferenceMode,

package/src/workspace/migrations/016-extract-feature-flags-to-protected.ts

@@ -7,16 +7,10 @@ import {
   unlinkSync,
   writeFileSync,
 } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 
 import type { WorkspaceMigration } from "./types.js";
-
-/** Inlined from platform.ts to satisfy migration self-containment rule (AGENTS.md). */
-function getRootDir(): string {
-  const base = process.env.BASE_DATA_DIR?.trim() || homedir();
-  return join(base, ".vellum");
-}
+import { getVellumRoot } from "./utils.js";
 
 export const extractFeatureFlagsToProtectedMigration: WorkspaceMigration = {
   id: "016-extract-feature-flags-to-protected",
@@ -26,7 +20,7 @@ export const extractFeatureFlagsToProtectedMigration: WorkspaceMigration = {
   down(workspaceDir: string): void {
     // Reverse: read feature flags from protected directory and write them
     // back to config.json as assistantFeatureFlagValues.
-    const protectedDir = join(getRootDir(), "protected");
+    const protectedDir = join(getVellumRoot(), "protected");
     const featureFlagsPath = join(protectedDir, "feature-flags.json");
 
     if (!existsSync(featureFlagsPath)) return;
@@ -111,7 +105,7 @@ export const extractFeatureFlagsToProtectedMigration: WorkspaceMigration = {
     }
 
     // Write feature flags to protected directory
-    const protectedDir = join(getRootDir(), "protected");
+    const protectedDir = join(getVellumRoot(), "protected");
     mkdirSync(protectedDir, { recursive: true });
 
     const featureFlagsPath = join(protectedDir, "feature-flags.json");

package/src/workspace/migrations/021-move-signals-to-workspace.ts

@@ -1,7 +1,7 @@
 /**
  * Workspace migration 021: Move signals directory from root to workspace.
  *
- * Previously, `~/.vellum/signals/` lived directly under getRootDir(). This
+ * Previously, `~/.vellum/signals/` lived directly under the Vellum root. This
  * migration moves any existing signal files into `~/.vellum/workspace/signals/`
  * so that getSignalsDir() resolves correctly under the workspace.
  *
@@ -13,23 +13,17 @@
  */
 
 import { existsSync, mkdirSync, readdirSync, renameSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 
 import type { WorkspaceMigration } from "./types.js";
-
-/** Inlined from platform.ts to satisfy migration self-containment rule (AGENTS.md). */
-function getRootDir(): string {
-  const base = process.env.BASE_DATA_DIR?.trim() || homedir();
-  return join(base, ".vellum");
-}
+import { getVellumRoot } from "./utils.js";
 
 export const moveSignalsToWorkspaceMigration: WorkspaceMigration = {
   id: "021-move-signals-to-workspace",
   description: "Move signals directory from root to workspace",
 
   run(workspaceDir: string): void {
-    const oldSignalsDir = join(getRootDir(), "signals");
+    const oldSignalsDir = join(getVellumRoot(), "signals");
     const newSignalsDir = join(workspaceDir, "signals");
 
     mkdirSync(newSignalsDir, { recursive: true });
@@ -56,7 +50,7 @@ export const moveSignalsToWorkspaceMigration: WorkspaceMigration = {
   },
 
   down(workspaceDir: string): void {
-    const oldSignalsDir = join(getRootDir(), "signals");
+    const oldSignalsDir = join(getVellumRoot(), "signals");
     const newSignalsDir = join(workspaceDir, "signals");
 
     mkdirSync(oldSignalsDir, { recursive: true });

package/src/workspace/migrations/022-move-hooks-to-workspace.ts

@@ -1,7 +1,7 @@
 /**
  * Workspace migration 022: Move hooks directory from root to workspace.
  *
- * Previously, `~/.vellum/hooks/` lived directly under getRootDir(). This
+ * Previously, `~/.vellum/hooks/` lived directly under the Vellum root. This
  * migration moves existing hook directories and files into
  * `~/.vellum/workspace/hooks/` so that getWorkspaceHooksDir() resolves
  * correctly under the workspace.
@@ -19,23 +19,17 @@ import {
   renameSync,
   rmSync,
 } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 
 import type { WorkspaceMigration } from "./types.js";
-
-/** Inlined from platform.ts to satisfy migration self-containment rule (AGENTS.md). */
-function getRootDir(): string {
-  const base = process.env.BASE_DATA_DIR?.trim() || homedir();
-  return join(base, ".vellum");
-}
+import { getVellumRoot } from "./utils.js";
 
 export const moveHooksToWorkspaceMigration: WorkspaceMigration = {
   id: "022-move-hooks-to-workspace",
   description: "Move hooks directory from root to workspace",
 
   run(workspaceDir: string): void {
-    const oldHooksDir = join(getRootDir(), "hooks");
+    const oldHooksDir = join(getVellumRoot(), "hooks");
     const newHooksDir = join(workspaceDir, "hooks");
 
     mkdirSync(newHooksDir, { recursive: true });
@@ -65,7 +59,7 @@ export const moveHooksToWorkspaceMigration: WorkspaceMigration = {
   },
 
   down(workspaceDir: string): void {
-    const oldHooksDir = join(getRootDir(), "hooks");
+    const oldHooksDir = join(getVellumRoot(), "hooks");
     const newHooksDir = join(workspaceDir, "hooks");
 
     mkdirSync(oldHooksDir, { recursive: true });

package/src/workspace/migrations/023-move-config-files-to-workspace.ts

@@ -2,23 +2,16 @@
  * Workspace migration 023: Move config/state JSON files from root to workspace.
  *
  * Previously, dictation-profiles.json, email-guardrails.json, and
- * active-call-leases.json lived directly under getRootDir() (~/.vellum/).
+ * active-call-leases.json lived directly under the Vellum root (~/.vellum/).
  * This migration moves them into the workspace directory so they follow
  * the workspace convention for organizational consistency.
  */
 
 import { existsSync, renameSync, unlinkSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 
 import type { WorkspaceMigration } from "./types.js";
-
-/** Inlined from platform.ts to satisfy migration self-containment rule (AGENTS.md). */
-function getRootDir(): string {
-  const base = process.env.BASE_DATA_DIR?.trim() || homedir();
-  return join(base, ".vellum");
-}
-
+import { getVellumRoot } from "./utils.js";
 /** Files to move from root → workspace. */
 const CONFIG_FILES = [
   "dictation-profiles.json",
@@ -32,7 +25,7 @@ export const moveConfigFilesToWorkspaceMigration: WorkspaceMigration = {
     "Move dictation-profiles, email-guardrails, and active-call-leases from root to workspace",
 
   run(workspaceDir: string): void {
-    const rootDir = getRootDir();
+    const rootDir = getVellumRoot();
 
     for (const file of CONFIG_FILES) {
       const oldPath = join(rootDir, file);
@@ -60,7 +53,7 @@ export const moveConfigFilesToWorkspaceMigration: WorkspaceMigration = {
   },
 
   down(workspaceDir: string): void {
-    const rootDir = getRootDir();
+    const rootDir = getVellumRoot();
 
     for (const file of CONFIG_FILES) {
       const newPath = join(workspaceDir, file);

package/src/workspace/migrations/024-move-runtime-files-to-workspace.ts

@@ -25,17 +25,10 @@ import {
   renameSync,
   unlinkSync,
 } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 
 import type { WorkspaceMigration } from "./types.js";
-
-/** Inlined from platform.ts to satisfy migration self-containment rule (AGENTS.md). */
-function getRootDir(): string {
-  const base = process.env.BASE_DATA_DIR?.trim() || homedir();
-  return join(base, ".vellum");
-}
-
+import { getVellumRoot } from "./utils.js";
 /** Individual files to move from root → workspace (with optional subdirectory). */
 const FILE_MOVES: Array<{ name: string; subdir?: string }> = [
   { name: "daemon-stderr.log", subdir: "logs" },
@@ -93,7 +86,7 @@ export const moveRuntimeFilesToWorkspaceMigration: WorkspaceMigration = {
     "Move daemon-stderr.log, daemon-startup.lock, embed-worker.pid, external/, and bin/ from root to workspace",
 
   run(workspaceDir: string): void {
-    const rootDir = getRootDir();
+    const rootDir = getVellumRoot();
 
     // Move individual files
     for (const { name, subdir } of FILE_MOVES) {
@@ -110,7 +103,7 @@ export const moveRuntimeFilesToWorkspaceMigration: WorkspaceMigration = {
   },
 
   down(workspaceDir: string): void {
-    const rootDir = getRootDir();
+    const rootDir = getVellumRoot();
 
     // Move individual files back
     for (const { name, subdir } of FILE_MOVES) {

package/src/workspace/migrations/040-seed-latency-callsite-defaults.ts

@@ -22,8 +22,9 @@ import type { WorkspaceMigration } from "./types.js";
  *   2. **Fresh install** (config.json absent): write a minimal starter
  *      config with just the callSite seeds, using the default provider
  *      (anthropic — same as the schema default). `loadConfig()` runs
- *      after migrations and backfills the remaining schema defaults via
- *      `deepMergeMissing`, which preserves our seeded callSites.
+ *      after migrations and applies schema defaults only to the
+ *      in-memory config (disk is left untouched), so our seeded
+ *      callSites are preserved verbatim.
  *
  * Without the fresh-install branch, new users permanently fall through
  * to `llm.default` (opus + max effort) because `LLMSchema.callSites`

package/src/workspace/migrations/050-seed-main-agent-opus-callsite.ts

@@ -12,7 +12,8 @@ import type { WorkspaceMigration } from "./types.js";
  *      `llm.callSites` without overwriting a user-defined override.
  *   2. **Fresh install** (config.json absent): write a minimal starter
  *      config with just this seed. `loadConfig()` runs after migrations
- *      and backfills the remaining schema defaults via `deepMergeMissing`.
+ *      and applies schema defaults to the in-memory config without
+ *      rewriting disk, so the seeded callSite is preserved as-is.
  *
  * Applied only when:
  *   - the resolved provider is Anthropic (other providers own their
@@ -60,9 +61,10 @@ export const seedMainAgentOpusCallsiteMigration: WorkspaceMigration = {
 
     if (readObject(callSites.mainAgent) !== null) return;
 
-    // maxTokens: 32000 matches Opus's maxOutputTokens (see
-    // model-catalog.ts); without it the site would inherit the
-    // default's 64000 and overshoot the model capability.
+    // Historical seed: at the time this migration shipped, Opus's standard
+    // output cap was 32k and this avoided inheriting a too-large default.
+    // The resolver now lets active/conversation profiles override this static
+    // mainAgent default.
     callSites.mainAgent = { model: "claude-opus-4-7", maxTokens: 32000 };
     llm.callSites = callSites;
     config.llm = llm;

package/src/workspace/migrations/052-seed-default-inference-profiles.ts

@@ -28,9 +28,9 @@ import type { WorkspaceMigration } from "./types.js";
  * Existing values are never overwritten:
  *   - A pre-existing profile by any of the three names is left intact.
  *   - A pre-existing `activeProfile` is preserved on Anthropic workspaces.
- *   - `llm.callSites` entries are not touched — they continue to win at
- *     resolver layer 5 over both `activeProfile` and per-site `profile`
- *     references.
+ *   - `llm.callSites` entries are not touched. Non-main-agent call sites
+ *     continue to win over profiles; `mainAgent` profiles now win over static
+ *     call-site defaults because they are the user's chat-model selection.
  *
  * **Skip when `VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH` is set.** Like
  * migration 040, a platform-provided default-config overlay (applied

package/src/workspace/migrations/059-move-pid-to-workspace.ts

@@ -7,22 +7,17 @@
  */
 
 import { existsSync, renameSync, unlinkSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 
 import type { WorkspaceMigration } from "./types.js";
-
-function getRootDir(): string {
-  const base = process.env.BASE_DATA_DIR?.trim() || homedir();
-  return join(base, ".vellum");
-}
+import { getVellumRoot } from "./utils.js";
 
 export const movePidToWorkspaceMigration: WorkspaceMigration = {
   id: "059-move-pid-to-workspace",
   description: "Move vellum.pid from root to workspace",
 
   run(workspaceDir: string): void {
-    const oldPath = join(getRootDir(), "vellum.pid");
+    const oldPath = join(getVellumRoot(), "vellum.pid");
     const newPath = join(workspaceDir, "vellum.pid");
     if (!existsSync(oldPath)) return;
     if (existsSync(newPath)) {
@@ -37,7 +32,7 @@ export const movePidToWorkspaceMigration: WorkspaceMigration = {
   },
 
   down(workspaceDir: string): void {
-    const oldPath = join(getRootDir(), "vellum.pid");
+    const oldPath = join(getVellumRoot(), "vellum.pid");
     const newPath = join(workspaceDir, "vellum.pid");
     if (!existsSync(newPath)) return;
     if (existsSync(oldPath)) {

package/src/workspace/migrations/060-memory-v2-init.ts

@@ -3,17 +3,6 @@ import { join } from "node:path";
 
 import type { WorkspaceMigration } from "./types.js";
 
-/**
- * Initial contents of `memory/edges.json` — the bidirectional concept-page
- * edge index for the v2 memory subsystem. The version field lets future
- * migrations bump the schema if needed.
- */
-const EMPTY_EDGES_INDEX = `${JSON.stringify(
-  { version: 1, edges: [] },
-  null,
-  2,
-)}\n`;
-
 const PROSE_FILES = ["essentials.md", "threads.md", "recent.md", "buffer.md"];
 
 export const memoryV2InitMigration: WorkspaceMigration = {
@@ -26,13 +15,8 @@ export const memoryV2InitMigration: WorkspaceMigration = {
     mkdirSync(join(memoryDir, "archive"), { recursive: true });
     mkdirSync(join(memoryDir, ".v2-state"), { recursive: true });
 
-    // Seed edges.json and the prose files only if missing — preserves any
-    // user content from manual setup or a prior migration.
-    const edgesPath = join(memoryDir, "edges.json");
-    if (!existsSync(edgesPath)) {
-      writeFileSync(edgesPath, EMPTY_EDGES_INDEX, "utf-8");
-    }
-
+    // Seed the prose files only if missing — preserves any user content from
+    // manual setup or a prior migration.
     for (const filename of PROSE_FILES) {
       const filePath = join(memoryDir, filename);
       if (!existsSync(filePath)) {

package/src/workspace/migrations/061-move-backup-key-to-workspace.ts

@@ -0,0 +1,54 @@
+/**
+ * Workspace migration 061: Move backup.key from protected/ to workspace.
+ *
+ * The backup encryption key previously lived at ~/.vellum/protected/backup.key.
+ * This migration copies it to ~/.vellum/workspace/.backup.key so the daemon
+ * no longer depends on the protected directory (owned by the gateway).
+ *
+ * The old file is removed after a successful copy. If the new file already
+ * exists (e.g. from VELLUM_BACKUP_KEY_PATH override or re-run), the old
+ * file is simply cleaned up.
+ */
+
+import { copyFileSync, existsSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+import { getVellumRoot } from "./utils.js";
+
+export const moveBackupKeyToWorkspaceMigration: WorkspaceMigration = {
+  id: "061-move-backup-key-to-workspace",
+  description: "Move backup.key from protected/ to workspace",
+
+  run(workspaceDir: string): void {
+    const oldPath = join(getVellumRoot(), "protected", "backup.key");
+    const newPath = join(workspaceDir, ".backup.key");
+    if (!existsSync(oldPath)) return;
+    if (existsSync(newPath)) {
+      try {
+        unlinkSync(oldPath);
+      } catch {}
+      return;
+    }
+    try {
+      copyFileSync(oldPath, newPath);
+      unlinkSync(oldPath);
+    } catch {}
+  },
+
+  down(workspaceDir: string): void {
+    const oldPath = join(getVellumRoot(), "protected", "backup.key");
+    const newPath = join(workspaceDir, ".backup.key");
+    if (!existsSync(newPath)) return;
+    if (existsSync(oldPath)) {
+      try {
+        unlinkSync(newPath);
+      } catch {}
+      return;
+    }
+    try {
+      copyFileSync(newPath, oldPath);
+      unlinkSync(newPath);
+    } catch {}
+  },
+};

package/src/workspace/migrations/062-drop-memory-v2-edges-json.ts

@@ -0,0 +1,27 @@
+import { rmSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Delete the legacy `memory/edges.json` file from any workspace that ran
+ * migration 060 before the v2 edge model moved to per-page frontmatter.
+ *
+ * Memory v2 now stores each page's outgoing directed edges directly in its
+ * frontmatter `edges:` list — there is no separate index file. Existing
+ * v1-shape edges.json files (undirected canonical 2-tuples) would fail
+ * validation under the new design and are no longer read by anything, so
+ * the safe move is simply to delete the file.
+ */
+export const dropMemoryV2EdgesJsonMigration: WorkspaceMigration = {
+  id: "062-drop-memory-v2-edges-json",
+  description: "Delete legacy memory/edges.json (edges now live per-page)",
+
+  run(workspaceDir: string): void {
+    rmSync(join(workspaceDir, "memory", "edges.json"), { force: true });
+  },
+
+  down(): void {
+    // No reversal — we don't reconstruct a legacy index file.
+  },
+};

package/src/workspace/migrations/063-release-notes-dynamic-model-context.ts

@@ -0,0 +1,70 @@
+import {
+  appendFileSync,
+  existsSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+
+import { getLogger } from "../../util/logger.js";
+import type { WorkspaceMigration } from "./types.js";
+
+const log = getLogger(
+  "workspace-migration-063-release-notes-dynamic-model-context",
+);
+
+const MIGRATION_ID = "063-release-notes-dynamic-model-context";
+const MARKER = `<!-- release-note-id:${MIGRATION_ID} -->`;
+
+const RELEASE_NOTE = `${MARKER}
+## Model-aware inference profile limits
+
+Inference profiles now show max output tokens as a model-aware slider, so the
+available range follows the selected model instead of accepting invalid values.
+
+You can also configure the context window per profile. New managed profiles
+stay at the conservative 200K context budget by default, and existing profiles
+keep their current effective context budget unless you edit them.
+`;
+
+export const releaseNotesDynamicModelContextMigration: WorkspaceMigration = {
+  id: MIGRATION_ID,
+  description:
+    "Append release notes for dynamic model context settings to UPDATES.md",
+
+  run(workspaceDir: string): void {
+    const updatesPath = join(workspaceDir, "UPDATES.md");
+
+    try {
+      if (existsSync(updatesPath)) {
+        const existing = readFileSync(updatesPath, "utf-8");
+        if (existing.includes(MARKER)) {
+          return;
+        }
+        const needsLeadingNewline = !existing.endsWith("\n\n");
+        const prefix = existing.endsWith("\n") ? "\n" : "\n\n";
+        appendFileSync(
+          updatesPath,
+          needsLeadingNewline ? `${prefix}${RELEASE_NOTE}` : RELEASE_NOTE,
+          "utf-8",
+        );
+      } else {
+        writeFileSync(updatesPath, RELEASE_NOTE, "utf-8");
+      }
+      log.info(
+        { path: updatesPath },
+        "Appended dynamic model context release note",
+      );
+    } catch (err) {
+      log.warn(
+        { err, path: updatesPath },
+        "Failed to append dynamic model context release note to UPDATES.md",
+      );
+    }
+  },
+
+  down(_workspaceDir: string): void {
+    // Forward-only: UPDATES.md is a user-facing bulletin the assistant
+    // processes and deletes on its own.
+  },
+};