@vellumai/assistant 0.6.5 → 0.6.6

package/src/__tests__/workspace-migration-050-seed-main-agent-opus-callsite.test.ts

@@ -0,0 +1,171 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { seedMainAgentOpusCallsiteMigration } from "../workspace/migrations/050-seed-main-agent-opus-callsite.js";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-050-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+function configPath(): string {
+  return join(workspaceDir, "config.json");
+}
+
+beforeEach(() => {
+  freshWorkspace();
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+});
+
+afterEach(() => {
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("050-seed-main-agent-opus-callsite migration", () => {
+  test("has correct migration id", () => {
+    expect(seedMainAgentOpusCallsiteMigration.id).toBe(
+      "050-seed-main-agent-opus-callsite",
+    );
+  });
+
+  test("seeds mainAgent with Opus + matching maxTokens on empty Anthropic workspace", () => {
+    writeConfig({
+      llm: { default: { provider: "anthropic" } },
+    });
+
+    seedMainAgentOpusCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.mainAgent).toEqual({
+      model: "claude-opus-4-7",
+      maxTokens: 32000,
+    });
+  });
+
+  test("writes fresh starter config when config.json is absent", () => {
+    seedMainAgentOpusCallsiteMigration.run(workspaceDir);
+
+    expect(existsSync(configPath())).toBe(true);
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.mainAgent).toEqual({
+      model: "claude-opus-4-7",
+      maxTokens: 32000,
+    });
+  });
+
+  test("preserves an existing user override on mainAgent", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          mainAgent: {
+            model: "claude-haiku-4-5-20251001",
+            effort: "low",
+          },
+        },
+      },
+    });
+
+    seedMainAgentOpusCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.mainAgent).toEqual({
+      model: "claude-haiku-4-5-20251001",
+      effort: "low",
+    });
+  });
+
+  test("skips entirely when provider is non-Anthropic", () => {
+    writeConfig({
+      llm: { default: { provider: "openai", model: "gpt-5.4" } },
+    });
+
+    seedMainAgentOpusCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites?: Record<string, unknown> };
+    };
+    expect(config.llm.callSites).toBeUndefined();
+  });
+
+  test("skips when user picked a non-Opus Anthropic model explicitly", () => {
+    writeConfig({
+      llm: {
+        default: {
+          provider: "anthropic",
+          model: "claude-haiku-4-5-20251001",
+        },
+      },
+    });
+
+    seedMainAgentOpusCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites?: Record<string, unknown> };
+    };
+    expect(config.llm.callSites).toBeUndefined();
+  });
+
+  test("seeds when user's default.model equals the prior default claude-opus-4-7", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic", model: "claude-opus-4-7" },
+      },
+    });
+
+    seedMainAgentOpusCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.mainAgent).toEqual({
+      model: "claude-opus-4-7",
+      maxTokens: 32000,
+    });
+  });
+
+  test("skips when VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH is set", () => {
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = "/tmp/overlay.json";
+    writeConfig({ llm: { default: { provider: "anthropic" } } });
+
+    seedMainAgentOpusCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites?: Record<string, unknown> };
+    };
+    expect(config.llm.callSites).toBeUndefined();
+  });
+});

package/src/__tests__/workspace-migration-051-seed-conversation-summarization-callsite.test.ts

@@ -0,0 +1,252 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { resolveCallSiteConfig } from "../config/llm-resolver.js";
+import { LLMSchema } from "../config/schemas/llm.js";
+import { seedConversationSummarizationCallsiteMigration } from "../workspace/migrations/051-seed-conversation-summarization-callsite.js";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-051-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+function configPath(): string {
+  return join(workspaceDir, "config.json");
+}
+
+beforeEach(() => {
+  freshWorkspace();
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+});
+
+afterEach(() => {
+  delete process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH;
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("051-seed-conversation-summarization-callsite migration", () => {
+  test("has correct migration id", () => {
+    expect(seedConversationSummarizationCallsiteMigration.id).toBe(
+      "051-seed-conversation-summarization-callsite",
+    );
+  });
+
+  test("seeds opus model + low effort + disabled thinking on Anthropic workspace without override", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic", model: "claude-opus-4-7" },
+      },
+    });
+
+    seedConversationSummarizationCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.conversationSummarization).toEqual({
+      model: "claude-opus-4-7",
+      effort: "low",
+      thinking: { enabled: false },
+    });
+  });
+
+  test("fills in missing effort and thinking when only model is set (post-038 state)", () => {
+    // Migration 038 may have seeded `{ model: "..." }` from legacy
+    // `memory.summarization.modelIntent`. That leaves `effort` + `thinking`
+    // falling through to `llm.default` — the bug this migration fixes.
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          conversationSummarization: { model: "claude-opus-4-6" },
+        },
+      },
+    });
+
+    seedConversationSummarizationCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.conversationSummarization).toEqual({
+      model: "claude-opus-4-6",
+      effort: "low",
+      thinking: { enabled: false },
+    });
+  });
+
+  test("preserves user-set effort and thinking values", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          conversationSummarization: {
+            model: "claude-opus-4-7",
+            effort: "high",
+            thinking: { enabled: true },
+          },
+        },
+      },
+    });
+
+    seedConversationSummarizationCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.conversationSummarization).toEqual({
+      model: "claude-opus-4-7",
+      effort: "high",
+      thinking: { enabled: true },
+    });
+  });
+
+  test("seeds openrouter-shaped model ID on openrouter workspace", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "openrouter", model: "anthropic/claude-opus-4.7" },
+      },
+    });
+
+    seedConversationSummarizationCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.conversationSummarization).toEqual({
+      model: "anthropic/claude-opus-4.7",
+      effort: "low",
+      thinking: { enabled: false },
+    });
+  });
+
+  test("skips entirely when non-Anthropic, non-OpenRouter provider is configured", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "openai", model: "gpt-5.4" },
+      },
+    });
+
+    seedConversationSummarizationCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites?: Record<string, unknown> };
+    };
+    expect(config.llm.callSites).toBeUndefined();
+  });
+
+  test("skips when VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH is set", () => {
+    process.env.VELLUM_DEFAULT_WORKSPACE_CONFIG_PATH = "/tmp/overlay.json";
+    writeConfig({
+      llm: { default: { provider: "anthropic" } },
+    });
+
+    seedConversationSummarizationCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites?: Record<string, unknown> };
+    };
+    expect(config.llm.callSites).toBeUndefined();
+  });
+
+  test("runs on fresh install (no config.json) and writes starter config", () => {
+    expect(existsSync(configPath())).toBe(false);
+
+    seedConversationSummarizationCallsiteMigration.run(workspaceDir);
+
+    expect(existsSync(configPath())).toBe(true);
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.conversationSummarization).toEqual({
+      model: "claude-opus-4-7",
+      effort: "low",
+      thinking: { enabled: false },
+    });
+  });
+
+  test("is idempotent — a second run is a no-op", () => {
+    writeConfig({
+      llm: { default: { provider: "anthropic" } },
+    });
+
+    seedConversationSummarizationCallsiteMigration.run(workspaceDir);
+    const afterFirst = readFileSync(configPath(), "utf-8");
+    seedConversationSummarizationCallsiteMigration.run(workspaceDir);
+    const afterSecond = readFileSync(configPath(), "utf-8");
+
+    expect(afterSecond).toBe(afterFirst);
+  });
+
+  test("does not clobber unrelated call-site entries", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic" },
+        callSites: {
+          interactionClassifier: { model: "claude-haiku-4-5-20251001" },
+        },
+      },
+    });
+
+    seedConversationSummarizationCallsiteMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { callSites: Record<string, Record<string, unknown>> };
+    };
+    expect(config.llm.callSites.interactionClassifier).toEqual({
+      model: "claude-haiku-4-5-20251001",
+    });
+    expect(config.llm.callSites.conversationSummarization).toBeDefined();
+  });
+
+  test("resolved conversationSummarization config has thinking disabled and non-max effort", () => {
+    // End-to-end check: after the migration runs, parsing the seeded
+    // config through `LLMSchema` and resolving the `conversationSummarization`
+    // call site must produce a config that has thinking disabled and a
+    // non-max effort. This is the invariant the JARVIS-587 fix depends on
+    // — any regression that leaks `effort: "max"` or `thinking.enabled:
+    // true` into the resolved summary config revives the 30s pipeline-
+    // timeout bug.
+    writeConfig({
+      llm: {
+        default: { provider: "anthropic", model: "claude-opus-4-7" },
+      },
+    });
+
+    seedConversationSummarizationCallsiteMigration.run(workspaceDir);
+
+    const onDisk = readConfig() as { llm: unknown };
+    const parsed = LLMSchema.parse(onDisk.llm);
+    const resolved = resolveCallSiteConfig("conversationSummarization", parsed);
+    expect(resolved.thinking.enabled).toBe(false);
+    expect(resolved.effort).not.toBe("max");
+    expect(resolved.effort).toBe("low");
+    expect(resolved.model).toBe("claude-opus-4-7");
+  });
+});

package/src/__tests__/workspace-migration-remove-hooks.test.ts

@@ -0,0 +1,99 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { removeWorkspaceHooksMigration } from "../workspace/migrations/048-remove-workspace-hooks.js";
+
+let workspaceDir: string;
+let hooksDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-046-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  hooksDir = join(workspaceDir, "hooks");
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+const dirs: string[] = [];
+
+beforeEach(() => {
+  freshWorkspace();
+  dirs.push(workspaceDir);
+});
+
+afterEach(() => {
+  for (const dir of dirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe("048-remove-workspace-hooks migration", () => {
+  test("has correct migration id", () => {
+    expect(removeWorkspaceHooksMigration.id).toBe("048-remove-workspace-hooks");
+  });
+
+  test("removes a populated hooks directory", () => {
+    mkdirSync(hooksDir, { recursive: true });
+    mkdirSync(join(hooksDir, "my-hook"), { recursive: true });
+    writeFileSync(join(hooksDir, "my-hook", "manifest.json"), "{}");
+    writeFileSync(join(hooksDir, "my-hook", "run.sh"), "#!/bin/sh\n");
+    writeFileSync(join(hooksDir, "README.md"), "hooks live here");
+
+    removeWorkspaceHooksMigration.run(workspaceDir);
+
+    expect(existsSync(hooksDir)).toBe(false);
+  });
+
+  test("removes an empty hooks directory", () => {
+    mkdirSync(hooksDir, { recursive: true });
+
+    removeWorkspaceHooksMigration.run(workspaceDir);
+
+    expect(existsSync(hooksDir)).toBe(false);
+  });
+
+  test("no-op when the hooks directory does not exist", () => {
+    expect(existsSync(hooksDir)).toBe(false);
+
+    removeWorkspaceHooksMigration.run(workspaceDir);
+
+    expect(existsSync(hooksDir)).toBe(false);
+    // The workspace itself must remain intact.
+    expect(existsSync(workspaceDir)).toBe(true);
+  });
+
+  test("idempotent — safe to re-run after the directory is gone", () => {
+    mkdirSync(hooksDir, { recursive: true });
+    writeFileSync(join(hooksDir, "stale.json"), "{}");
+
+    removeWorkspaceHooksMigration.run(workspaceDir);
+    // Second invocation is a no-op and must not throw.
+    removeWorkspaceHooksMigration.run(workspaceDir);
+
+    expect(existsSync(hooksDir)).toBe(false);
+  });
+
+  test("does not touch unrelated workspace entries", () => {
+    mkdirSync(hooksDir, { recursive: true });
+    writeFileSync(join(hooksDir, "stale.json"), "{}");
+    const skillsDir = join(workspaceDir, "skills");
+    mkdirSync(skillsDir, { recursive: true });
+    writeFileSync(join(skillsDir, "keep.md"), "keep me");
+
+    removeWorkspaceHooksMigration.run(workspaceDir);
+
+    expect(existsSync(hooksDir)).toBe(false);
+    expect(existsSync(skillsDir)).toBe(true);
+    expect(existsSync(join(skillsDir, "keep.md"))).toBe(true);
+  });
+
+  describe("down()", () => {
+    test("is a no-op", () => {
+      removeWorkspaceHooksMigration.down(workspaceDir);
+      expect(existsSync(hooksDir)).toBe(false);
+    });
+  });
+});

package/src/__tests__/workspace-policy.test.ts

@@ -1,8 +1,9 @@
 import { mkdirSync, mkdtempSync, rmSync, symlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { afterAll, beforeAll, describe, expect, spyOn, test } from "bun:test";
 
+import * as envRegistry from "../config/env-registry.js";
 import {
   isPathWithinWorkspaceRoot,
   isWorkspaceScopedInvocation,
@@ -198,14 +199,31 @@ describe("isWorkspaceScopedInvocation", () => {
   // ── Bash ───────────────────────────────────────────────────────────
 
   describe("bash", () => {
-    test("returns true (container handles isolation)", () => {
+    test("returns false when not containerized", () => {
       expect(
         isWorkspaceScopedInvocation(
           "bash",
           { command: "ls -la" },
           workspaceRoot,
         ),
-      ).toBe(true);
+      ).toBe(false);
+    });
+
+    test("returns true when containerized", () => {
+      const spy = spyOn(envRegistry, "getIsContainerized").mockReturnValue(
+        true,
+      );
+      try {
+        expect(
+          isWorkspaceScopedInvocation(
+            "bash",
+            { command: "ls -la" },
+            workspaceRoot,
+          ),
+        ).toBe(true);
+      } finally {
+        spy.mockRestore();
+      }
     });
   });