@vellumai/assistant 0.7.2 → 0.7.3

package/src/workspace/migrations/066-seed-heartbeat-callsite-cost-default.ts

@@ -0,0 +1,146 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+/**
+ * Seed a cheap, bounded default for the `heartbeatAgent` LLM call site.
+ *
+ * Heartbeats are default-on and now run frequently, so they should not inherit
+ * the workspace's active chat profile. The default managed profile is Sonnet
+ * with high effort and thinking enabled, which is appropriate for interactive
+ * chat but too expensive for a periodic background triage pass.
+ *
+ * Preserve user-owned model selection. If `heartbeatAgent` already has a
+ * `profile`, `provider`, or `model`, this migration leaves the entry unchanged
+ * so call-site leaves do not silently override the selected profile/model.
+ * Speed-only legacy entries from migration 038 are treated as defaultable.
+ */
+export const seedHeartbeatCallsiteCostDefaultMigration: WorkspaceMigration = {
+  id: "066-seed-heartbeat-callsite-cost-default",
+  description:
+    "Seed cost-optimized defaults for the heartbeatAgent LLM call site",
+  run(workspaceDir: string): void {
+    if (process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH) return;
+
+    const configPath = join(workspaceDir, "config.json");
+    const configExisted = existsSync(configPath);
+
+    let config: Record<string, unknown> = {};
+    if (configExisted) {
+      try {
+        const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
+        config = raw as Record<string, unknown>;
+      } catch {
+        return;
+      }
+    }
+
+    const llm = readObject(config.llm) ?? {};
+    const defaultBlock = readObject(llm.default);
+    const provider = readString(defaultBlock?.provider) ?? "anthropic";
+    const cheapModel = resolveCheapModel(provider);
+    if (cheapModel === undefined) return;
+
+    const callSites = readObject(llm.callSites) ?? {};
+    const existing = readObject(callSites.heartbeatAgent) ?? {};
+    if (hasExplicitModelSelection(existing)) return;
+
+    const seeded: Record<string, unknown> = { ...existing };
+    let changed = false;
+
+    const profiles = readObject(llm.profiles) ?? {};
+    const costProfile = readObject(profiles["cost-optimized"]);
+    if (readString(costProfile?.provider) === provider) {
+      seeded.profile = "cost-optimized";
+    } else {
+      seeded.provider = provider;
+      seeded.model = cheapModel;
+    }
+    changed = true;
+
+    changed = seedMissingLeaf(seeded, "maxTokens", 2048) || changed;
+    changed = seedMissingLeaf(seeded, "effort", "low") || changed;
+    changed = seedMissingLeaf(seeded, "temperature", 0) || changed;
+
+    const thinking = readObject(seeded.thinking) ?? {};
+    const seededThinking = { ...thinking };
+    const enabledChanged = seedMissingLeaf(seededThinking, "enabled", false);
+    const streamThinkingChanged = seedMissingLeaf(
+      seededThinking,
+      "streamThinking",
+      false,
+    );
+    const thinkingChanged = enabledChanged || streamThinkingChanged;
+    if (thinkingChanged || readObject(seeded.thinking) === null) {
+      seeded.thinking = seededThinking;
+      changed = true;
+    }
+
+    const contextWindow = readObject(seeded.contextWindow) ?? {};
+    const seededContextWindow = { ...contextWindow };
+    const contextChanged = seedMissingLeaf(
+      seededContextWindow,
+      "maxInputTokens",
+      16_000,
+    );
+    if (contextChanged || readObject(seeded.contextWindow) === null) {
+      seeded.contextWindow = seededContextWindow;
+      changed = true;
+    }
+
+    if (!changed) return;
+
+    callSites.heartbeatAgent = seeded;
+    llm.callSites = callSites;
+    config.llm = llm;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+  },
+  down(_workspaceDir: string): void {
+    // Forward-only: removing the seeded default would make frequent
+    // heartbeats inherit the user's potentially expensive chat profile again.
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Helpers — self-contained per workspace migrations AGENTS.md
+// ---------------------------------------------------------------------------
+
+const CHEAP_MODELS_BY_PROVIDER: Record<string, string> = {
+  anthropic: "claude-haiku-4-5-20251001",
+  openai: "gpt-5.4-nano",
+  gemini: "gemini-3-flash",
+  ollama: "llama3.2",
+  fireworks: "accounts/fireworks/models/kimi-k2p5",
+  openrouter: "anthropic/claude-haiku-4.5",
+};
+
+function resolveCheapModel(provider: string): string | undefined {
+  return CHEAP_MODELS_BY_PROVIDER[provider];
+}
+
+function hasExplicitModelSelection(value: Record<string, unknown>): boolean {
+  return "profile" in value || "provider" in value || "model" in value;
+}
+
+function seedMissingLeaf(
+  target: Record<string, unknown>,
+  key: string,
+  value: unknown,
+): boolean {
+  if (key in target) return false;
+  target[key] = value;
+  return true;
+}
+
+function readObject(value: unknown): Record<string, unknown> | null {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value as Record<string, unknown>;
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}

package/src/workspace/migrations/067-release-notes-safe-storage-limits.ts

@@ -0,0 +1,72 @@
+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-067-release-notes-safe-storage-limits",
+);
+
+const MIGRATION_ID = "067-release-notes-safe-storage-limits";
+const MARKER = `<!-- release-note-id:${MIGRATION_ID} -->`;
+
+const RELEASE_NOTE = `${MARKER}
+## Safe storage limits
+
+A new storage protection mode is available behind the safe-storage-limits
+rollout flag. When enabled, the assistant watches workspace disk usage and
+enters cleanup mode if the volume reaches the critical 95% threshold.
+
+In cleanup mode, background processes pause and remote messages, including
+trusted-contact messages, are blocked until the guardian frees enough space or
+explicitly overrides the lock. The macOS app now shows a storage cleanup banner
+that must be acknowledged before cleanup chat continues, then keeps a status
+banner visible while cleanup mode is active.
+`;
+
+export const releaseNotesSafeStorageLimitsMigration: WorkspaceMigration = {
+  id: MIGRATION_ID,
+  description: "Append release notes for safe storage limits 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 safe storage limits release note",
+      );
+    } catch (err) {
+      log.warn(
+        { err, path: updatesPath },
+        "Failed to append safe storage limits 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.
+  },
+};

package/src/workspace/migrations/068-release-notes-local-timezone.ts

@@ -0,0 +1,65 @@
+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-068-release-notes-local-timezone");
+
+const MIGRATION_ID = "068-release-notes-local-timezone";
+const MARKER = `<!-- release-note-id:${MIGRATION_ID} -->`;
+
+const RELEASE_NOTE = `${MARKER}
+## Local timezone grounding
+
+The assistant now grounds \`current_time\` in your local timezone across clients,
+instead of falling back to UTC when the client can report the device timezone.
+
+Manual timezone overrides still win when configured, and the assistant can help
+update a stale override after you confirm that your device timezone should be
+used going forward.
+`;
+
+export const releaseNotesLocalTimezoneMigration: WorkspaceMigration = {
+  id: MIGRATION_ID,
+  description:
+    "Append release notes for local timezone grounding 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 local timezone release note");
+    } catch (err) {
+      log.warn(
+        { err, path: updatesPath },
+        "Failed to append local timezone 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.
+  },
+};

package/src/workspace/migrations/registry.ts

@@ -62,6 +62,10 @@ import { moveBackupKeyToWorkspaceMigration } from "./061-move-backup-key-to-work
 import { dropMemoryV2EdgesJsonMigration } from "./062-drop-memory-v2-edges-json.js";
 import { releaseNotesDynamicModelContextMigration } from "./063-release-notes-dynamic-model-context.js";
 import { unwindMainAgentOpusSeedMigration } from "./064-unwind-main-agent-opus-seed.js";
+import { bumpStaleHeartbeatIntervalMigration } from "./065-bump-stale-heartbeat-interval.js";
+import { seedHeartbeatCallsiteCostDefaultMigration } from "./066-seed-heartbeat-callsite-cost-default.js";
+import { releaseNotesSafeStorageLimitsMigration } from "./067-release-notes-safe-storage-limits.js";
+import { releaseNotesLocalTimezoneMigration } from "./068-release-notes-local-timezone.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -135,4 +139,8 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   dropMemoryV2EdgesJsonMigration,
   releaseNotesDynamicModelContextMigration,
   unwindMainAgentOpusSeedMigration,
+  bumpStaleHeartbeatIntervalMigration,
+  seedHeartbeatCallsiteCostDefaultMigration,
+  releaseNotesSafeStorageLimitsMigration,
+  releaseNotesLocalTimezoneMigration,
 ];

package/src/__tests__/conversation-tool-setup-memory-scope.test.ts

@@ -1,167 +0,0 @@
-/**
- * Tests that createToolExecutor propagates memoryScopeId from the session's
- * memory policy into the ToolContext passed to the underlying executor.
- */
-
-import { describe, expect, mock, test } from "bun:test";
-
-import type { ToolSetupContext } from "../daemon/conversation-tool-setup.js";
-import type { SurfaceData, SurfaceType } from "../daemon/message-protocol.js";
-import type { PermissionPrompter } from "../permissions/prompter.js";
-import type { SecretPrompter } from "../permissions/secret-prompter.js";
-import type { ToolExecutor } from "../tools/executor.js";
-import type { ToolContext, ToolExecutionResult } from "../tools/types.js";
-
-// ---------------------------------------------------------------------------
-// Mocks — must be set up before importing the module under test
-// ---------------------------------------------------------------------------
-
-mock.module("../daemon/conversation-surfaces.js", () => ({
-  refreshSurfacesForApp: mock(() => {}),
-  surfaceProxyResolver: mock(() =>
-    Promise.resolve({ content: "", isError: false }),
-  ),
-}));
-
-mock.module("../services/published-app-updater.js", () => ({
-  updatePublishedAppDeployment: mock(() => Promise.resolve()),
-}));
-
-mock.module("../tools/browser/browser-screencast.js", () => ({
-  registerConversationSender: mock(() => {}),
-}));
-
-// ---------------------------------------------------------------------------
-// Import after mocks
-// ---------------------------------------------------------------------------
-
-import { createToolExecutor } from "../daemon/conversation-tool-setup.js";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function makeCtx(overrides: Partial<ToolSetupContext> = {}): ToolSetupContext {
-  return {
-    conversationId: "conv-scope",
-    currentRequestId: "req-1",
-    workingDir: "/tmp/test",
-    abortController: null,
-    traceEmitter: { emit: () => {} },
-    sendToClient: mock(() => {}),
-    pendingSurfaceActions: new Map(),
-    lastSurfaceAction: new Map(),
-    surfaceState: new Map<
-      string,
-      { surfaceType: SurfaceType; data: SurfaceData; title?: string }
-    >(),
-    surfaceUndoStacks: new Map(),
-    accumulatedSurfaceState: new Map(),
-    surfaceActionRequestIds: new Set<string>(),
-    currentTurnSurfaces: [],
-    isProcessing: () => false,
-    enqueueMessage: () => ({ queued: false, requestId: "r" }),
-    getQueueDepth: () => 0,
-    processMessage: async () => "",
-    withSurface: async <T>(_id: string, fn: () => T | Promise<T>) => fn(),
-    memoryPolicy: { scopeId: "default" },
-    ...overrides,
-  };
-}
-
-/** Executor spy that captures the ToolContext passed to execute(). */
-function makeCapturingExecutor(
-  result: ToolExecutionResult = { content: "ok", isError: false },
-) {
-  let captured: ToolContext | undefined;
-  return {
-    executor: {
-      execute: mock(
-        async (
-          _name: string,
-          _input: Record<string, unknown>,
-          ctx: ToolContext,
-        ) => {
-          captured = ctx;
-          return result;
-        },
-      ),
-    },
-    getCaptured: () => captured,
-  };
-}
-
-const noopPrompter = {
-  prompt: mock(async () => ({ decision: "allow" as const })),
-} as unknown as PermissionPrompter;
-const noopSecretPrompter = {
-  prompt: mock(async () => ({ cancelled: true })),
-} as unknown as SecretPrompter;
-const noopLifecycleHandler = mock(() => {});
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("session-tool-setup memoryScopeId propagation", () => {
-  test("passes default memoryScopeId to executor context", async () => {
-    const ctx = makeCtx({
-      memoryPolicy: { scopeId: "default" },
-    });
-    const { executor, getCaptured } = makeCapturingExecutor();
-
-    const toolFn = createToolExecutor(
-      executor as unknown as ToolExecutor,
-      noopPrompter,
-      noopSecretPrompter,
-      ctx,
-      noopLifecycleHandler,
-    );
-
-    await toolFn("some_tool", { key: "value" });
-
-    expect(getCaptured()).toBeDefined();
-    expect(getCaptured()!.memoryScopeId).toBe("default");
-  });
-
-  test("passes custom memoryScopeId from session memory policy", async () => {
-    const ctx = makeCtx({
-      memoryPolicy: { scopeId: "custom-scope-abc" },
-    });
-    const { executor, getCaptured } = makeCapturingExecutor();
-
-    const toolFn = createToolExecutor(
-      executor as unknown as ToolExecutor,
-      noopPrompter,
-      noopSecretPrompter,
-      ctx,
-      noopLifecycleHandler,
-    );
-
-    await toolFn("memory_write", { content: "test" });
-
-    expect(getCaptured()!.memoryScopeId).toBe("custom-scope-abc");
-  });
-
-  test("reads memoryScopeId at call time, not construction time", async () => {
-    const ctx = makeCtx({
-      memoryPolicy: { scopeId: "initial" },
-    });
-    const { executor, getCaptured } = makeCapturingExecutor();
-
-    const toolFn = createToolExecutor(
-      executor as unknown as ToolExecutor,
-      noopPrompter,
-      noopSecretPrompter,
-      ctx,
-      noopLifecycleHandler,
-    );
-
-    // Mutate the memory policy after construction
-    ctx.memoryPolicy = { scopeId: "updated-scope" };
-
-    await toolFn("some_tool", {});
-
-    expect(getCaptured()!.memoryScopeId).toBe("updated-scope");
-  });
-});