@vellumai/assistant 0.7.0 → 0.7.1

package/src/__tests__/vellum-self-knowledge-inline-command.test.ts

@@ -1,17 +1,10 @@
 /**
- * Tests that vellum-self-knowledge uses inline command expansion to inject
- * the current assistant info at skill_load time.
- *
- * Validates that:
- * - The `!\`bun run .../self-info.ts\`` token in SKILL.md is replaced by an
- *   `<inline_skill_command>` block containing the runner's output.
- * - The rest of the skill body (architecture, config, references, critical rule)
- *   remains unchanged.
- * - The inline command token does NOT appear verbatim in the loaded output
- *   (i.e. the model is never told to shell out manually).
+ * Tests that vellum-self-knowledge loads correctly and contains the expected
+ * routing structure — pointers to sources of truth (CLI, docs, source code)
+ * rather than static content.
  */
 
-import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { copyFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -39,48 +32,6 @@ mock.module("../util/logger.js", () => ({
   truncateForLog: (s: unknown) => String(s),
 }));
 
-// Track inline command runner calls
-interface RunInlineCommandCall {
-  command: string;
-  workingDir: string;
-}
-const runInlineCommandCalls: RunInlineCommandCall[] = [];
-
-/** Return type matching InlineCommandResult from the runner module. */
-interface MockInlineCommandResult {
-  output: string;
-  ok: boolean;
-  failureReason?:
-    | "timeout"
-    | "non_zero_exit"
-    | "binary_output"
-    | "spawn_failure";
-}
-
-type MockRunFn = (
-  command: string,
-  workingDir: string,
-) => Promise<MockInlineCommandResult>;
-
-// Default: commands succeed, returning a realistic self-info summary
-const MOCK_SELF_INFO_OUTPUT =
-  "You are running as Claude Opus 4.6 via Anthropic (your-own API key).";
-
-let mockRunInlineCommand = mock<MockRunFn>(
-  (command: string, workingDir: string) => {
-    runInlineCommandCalls.push({ command, workingDir });
-    return Promise.resolve({
-      output: MOCK_SELF_INFO_OUTPUT,
-      ok: true,
-    });
-  },
-);
-
-mock.module("../skills/inline-command-runner.js", () => ({
-  runInlineCommand: (command: string, workingDir: string, _options?: unknown) =>
-    mockRunInlineCommand(command, workingDir),
-}));
-
 // Mock autoInstallFromCatalog
 const mockAutoInstall = mock((_skillId: string) => Promise.resolve(false));
 mock.module("../skills/catalog-install.js", () => ({
@@ -116,8 +67,6 @@ mock.module("../config/loader.js", () => ({
 
 await import("../tools/skills/load.js");
 const { getTool } = await import("../tools/registry.js");
-const { _setOverridesForTesting } =
-  await import("../config/assistant-feature-flags.js");
 
 // ── Helpers ──────────────────────────────────────────────────────────────
 
@@ -126,13 +75,6 @@ function installSelfKnowledgeSkill(): void {
   const destDir = join(TEST_DIR, "skills", "vellum-self-knowledge");
   mkdirSync(destDir, { recursive: true });
   copyFileSync(join(SKILL_SRC_DIR, "SKILL.md"), join(destDir, "SKILL.md"));
-  // Also copy references/ so that the reference listing still works
-  const refsSrc = join(SKILL_SRC_DIR, "references");
-  if (existsSync(refsSrc)) {
-    const refsDir = join(destDir, "references");
-    mkdirSync(refsDir, { recursive: true });
-    copyFileSync(join(refsSrc, "inference.md"), join(refsDir, "inference.md"));
-  }
 }
 
 async function executeSkillLoad(
@@ -152,116 +94,86 @@ async function executeSkillLoad(
 
 // ── Tests ────────────────────────────────────────────────────────────────
 
-describe("vellum-self-knowledge inline command expansion", () => {
+describe("vellum-self-knowledge skill", () => {
   beforeEach(() => {
     mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
-    runInlineCommandCalls.length = 0;
     mockAutoInstall.mockReset();
     mockAutoInstall.mockImplementation(() => Promise.resolve(false));
-
-    // Reset to default: commands succeed with self-info output
-    mockRunInlineCommand = mock<MockRunFn>(
-      (command: string, workingDir: string) => {
-        runInlineCommandCalls.push({ command, workingDir });
-        return Promise.resolve({
-          output: MOCK_SELF_INFO_OUTPUT,
-          ok: true,
-        });
-      },
-    );
-    mock.module("../skills/inline-command-runner.js", () => ({
-      runInlineCommand: (
-        command: string,
-        workingDir: string,
-        _options?: unknown,
-      ) => mockRunInlineCommand(command, workingDir),
-    }));
-
-    // Enable the feature flag via protected directory override
-    _setOverridesForTesting({
-      "inline-skill-commands": true,
-    });
     testConfig.skills = { load: { extraDirs: [] } };
-
     installSelfKnowledgeSkill();
   });
 
-  afterEach(() => {
-    _setOverridesForTesting({});
-  });
+  afterEach(() => {});
 
-  // ── Inline token replacement ─────────────────────────────────────────
+  // ── Loads successfully ───────────────────────────────────────────────
 
-  test("inline token is replaced by an <inline_skill_command> block", async () => {
+  test("loads without error", async () => {
     const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
     expect(result.isError).toBe(false);
-    expect(result.content).toContain(
-      `<inline_skill_command index="0">${MOCK_SELF_INFO_OUTPUT}</inline_skill_command>`,
-    );
   });
 
-  test("the raw inline token does not appear in the loaded output", async () => {
+  // ── Contains no static content ───────────────────────────────────────
+
+  test("does not contain hard-coded model names or provider catalogs", async () => {
     const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
-    expect(result.isError).toBe(false);
-    // The original `!\`...\`` token must be fully replaced
-    expect(result.content).not.toContain("!`bun run");
-    expect(result.content).not.toContain("scripts/self-info.ts`");
+    // Old skill had a model catalog table with specific model IDs
+    expect(result.content).not.toContain("claude-sonnet-4-6");
+    expect(result.content).not.toContain("claude-opus-4-6");
+    expect(result.content).not.toContain("gpt-4o");
+    expect(result.content).not.toContain("gemini-2.5");
   });
 
-  test("the model is not told to shell out manually", async () => {
+  test("does not contain inline command tokens", async () => {
     const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
-    expect(result.isError).toBe(false);
-    // The old instruction "Always run this script" should be gone
-    expect(result.content).not.toContain("Always run this script");
-    // No code block instructing manual execution
-    expect(result.content).not.toContain("```bash\nbun run");
+    expect(result.content).not.toContain("!`bun run");
+    expect(result.content).not.toContain("self-info.ts");
   });
 
-  // ── Runner invocation ────────────────────────────────────────────────
+  // ── Routes to CLI ────────────────────────────────────────────────────
 
-  test("invokes the inline command runner with the self-info script command", async () => {
-    await executeSkillLoad({ skill: "vellum-self-knowledge" });
-    expect(runInlineCommandCalls).toHaveLength(1);
-    expect(runInlineCommandCalls[0].command).toContain("bun run");
-    expect(runInlineCommandCalls[0].command).toContain("scripts/self-info.ts");
+  test("references the assistant CLI for runtime state", async () => {
+    const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
+    expect(result.content).toContain("assistant config get llm");
+    expect(result.content).toContain("assistant --version");
+    expect(result.content).toContain("assistant skills list");
+    expect(result.content).toContain("assistant platform status");
   });
 
-  // ── Rest of skill body preserved ─────────────────────────────────────
+  // ── Routes to docs site ──────────────────────────────────────────────
 
-  test("architecture section is preserved", async () => {
+  test("references the docs site for conceptual questions", async () => {
     const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("## Architecture at a Glance");
-    expect(result.content).toContain("AgentLoop");
+    expect(result.content).toContain("https://www.vellum.ai/docs");
+    expect(result.content).toContain("/getting-started/what-is-vellum");
+    expect(result.content).toContain("/developer-guide/architecture");
+    expect(result.content).toContain("/trust-security/the-permissions-model");
   });
 
-  test("configuration section is preserved", async () => {
-    const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("## Configuration System");
-    expect(result.content).toContain("assistant config get");
-  });
+  // ── Routes to source code ────────────────────────────────────────────
 
-  test("references section is preserved", async () => {
+  test("references the GitHub repo for deep implementation questions", async () => {
     const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("## When to Consult References");
-    expect(result.content).toContain("references/inference.md");
+    expect(result.content).toContain(
+      "github.com/vellum-ai/vellum-assistant",
+    );
+    expect(result.content).toContain("ARCHITECTURE.md");
   });
 
-  test("critical rule section is preserved", async () => {
+  // ── Critical rule ────────────────────────────────────────────────────
+
+  test("contains the critical rule about not answering from memory", async () => {
     const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
-    expect(result.isError).toBe(false);
     expect(result.content).toContain("## Critical Rule");
-    expect(result.content).toContain(
-      "populated at skill-load time and reflects the live configuration",
-    );
+    expect(result.content).toContain("Never answer from memory");
   });
 
-  test("what is vellum section is preserved", async () => {
+  // ── Resolution order ─────────────────────────────────────────────────
+
+  test("specifies resolution order (CLI → docs → source)", async () => {
     const result = await executeSkillLoad({ skill: "vellum-self-knowledge" });
-    expect(result.isError).toBe(false);
-    expect(result.content).toContain("## What is Vellum");
-    expect(result.content).toContain("personal AI assistant platform");
+    expect(result.content).toContain("### Resolution Order");
+    expect(result.content).toContain("CLI first");
+    expect(result.content).toContain("Docs second");
+    expect(result.content).toContain("Source code last");
   });
 });

package/src/__tests__/verification-control-plane-policy.test.ts

@@ -40,8 +40,6 @@ const mockConfig = {
   rateLimit: { maxRequestsPerMinute: 0 },
   secretDetection: {
     enabled: false,
-    action: "warn" as const,
-    entropyThreshold: 4.0,
   },
 };
 
@@ -106,10 +104,6 @@ mock.module("../tools/shared/filesystem/path-policy.js", () => ({
   hostPolicy: () => ({ ok: false }),
 }));
 
-mock.module("../tools/terminal/sandbox.js", () => ({
-  wrapCommand: () => ({ command: "", sandboxed: false }),
-}));
-
 // Re-assert the real verification-control-plane-policy implementation.
 // This overrides any mock that an earlier test file may have installed for
 // this module (e.g. tool-approval-handler.test.ts mocks it with denied:false).
@@ -194,7 +188,10 @@ mock.module("../tools/verification-control-plane-policy.js", () => {
     };
   }
 
-  return { isVerificationControlPlaneInvocation, enforceVerificationControlPlanePolicy };
+  return {
+    isVerificationControlPlaneInvocation,
+    enforceVerificationControlPlanePolicy,
+  };
 });
 
 // -- Real imports --

package/src/__tests__/voice-session-bridge.test.ts

@@ -944,15 +944,15 @@ describe("voice-session-bridge", () => {
       decision: string;
     }> = [];
     const publishedMessages: ServerMessage[] = [];
-    const subscription = assistantEventHub.subscribe(
-      {
-        assistantId: "self",
+    const subscription = assistantEventHub.subscribe({
+      type: "process",
+      filter: {
         conversationId: conversation.id,
       },
-      (event) => {
+      callback: (event) => {
         publishedMessages.push(event.message);
       },
-    );
+    });
 
     const session = {
       isProcessing: () => false,

package/src/__tests__/workspace-migration-062-drop-memory-v2-edges-json.test.ts

@@ -0,0 +1,103 @@
+/**
+ * Tests for workspace migration `062-drop-memory-v2-edges-json`.
+ *
+ * Removes the legacy `memory/edges.json` file from any workspace seeded by
+ * an older revision of `060-memory-v2-init`. Outgoing edges now live in
+ * concept-page frontmatter, so the index file is no longer read by anything.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  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 { dropMemoryV2EdgesJsonMigration } from "../workspace/migrations/062-drop-memory-v2-edges-json.js";
+
+let workspaceDir: string;
+
+beforeEach(() => {
+  workspaceDir = mkdtempSync(join(tmpdir(), "vellum-migration-062-test-"));
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("062-drop-memory-v2-edges-json migration", () => {
+  test("has correct id and description", () => {
+    expect(dropMemoryV2EdgesJsonMigration.id).toBe(
+      "062-drop-memory-v2-edges-json",
+    );
+    expect(dropMemoryV2EdgesJsonMigration.description).toContain("edges.json");
+  });
+
+  test("deletes memory/edges.json when present", () => {
+    const memoryDir = join(workspaceDir, "memory");
+    mkdirSync(memoryDir, { recursive: true });
+    const edgesPath = join(memoryDir, "edges.json");
+    writeFileSync(
+      edgesPath,
+      JSON.stringify({ version: 1, edges: [] }, null, 2),
+      "utf-8",
+    );
+
+    dropMemoryV2EdgesJsonMigration.run(workspaceDir);
+
+    expect(existsSync(edgesPath)).toBe(false);
+  });
+
+  test("is a no-op when memory/edges.json is absent", () => {
+    expect(existsSync(join(workspaceDir, "memory", "edges.json"))).toBe(false);
+    expect(() =>
+      dropMemoryV2EdgesJsonMigration.run(workspaceDir),
+    ).not.toThrow();
+  });
+
+  test("is idempotent — running twice does not throw", () => {
+    const memoryDir = join(workspaceDir, "memory");
+    mkdirSync(memoryDir, { recursive: true });
+    writeFileSync(join(memoryDir, "edges.json"), "{}", "utf-8");
+
+    dropMemoryV2EdgesJsonMigration.run(workspaceDir);
+    expect(() =>
+      dropMemoryV2EdgesJsonMigration.run(workspaceDir),
+    ).not.toThrow();
+  });
+
+  test("does not touch sibling files in memory/", () => {
+    const memoryDir = join(workspaceDir, "memory");
+    mkdirSync(memoryDir, { recursive: true });
+    writeFileSync(
+      join(memoryDir, "edges.json"),
+      JSON.stringify({ version: 1, edges: [] }),
+      "utf-8",
+    );
+    writeFileSync(
+      join(memoryDir, "essentials.md"),
+      "Alice's preferred IDE is VS Code.\n",
+      "utf-8",
+    );
+
+    dropMemoryV2EdgesJsonMigration.run(workspaceDir);
+
+    expect(existsSync(join(memoryDir, "edges.json"))).toBe(false);
+    expect(readFileSync(join(memoryDir, "essentials.md"), "utf-8")).toBe(
+      "Alice's preferred IDE is VS Code.\n",
+    );
+  });
+
+  test("down() is a no-op", () => {
+    expect(() =>
+      dropMemoryV2EdgesJsonMigration.down(workspaceDir),
+    ).not.toThrow();
+  });
+});

package/src/__tests__/workspace-migration-063-release-notes-dynamic-model-context.test.ts

@@ -0,0 +1,77 @@
+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 { releaseNotesDynamicModelContextMigration } from "../workspace/migrations/063-release-notes-dynamic-model-context.js";
+
+const MIGRATION_ID = "063-release-notes-dynamic-model-context";
+const MARKER = `<!-- release-note-id:${MIGRATION_ID} -->`;
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-063-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function updatesPath(): string {
+  return join(workspaceDir, "UPDATES.md");
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("workspace migration 063-release-notes-dynamic-model-context", () => {
+  test("has the correct id", () => {
+    expect(releaseNotesDynamicModelContextMigration.id).toBe(MIGRATION_ID);
+  });
+
+  test("creates UPDATES.md with marker and key copy when file is absent", () => {
+    expect(existsSync(updatesPath())).toBe(false);
+
+    releaseNotesDynamicModelContextMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content).toContain(MARKER);
+    expect(content).toContain("max output tokens as a model-aware slider");
+    expect(content).toContain("configure the context window per profile");
+    expect(content).toContain("existing profiles");
+  });
+
+  test("is a no-op when marker is already present", () => {
+    const seeded = `## Prior\n\n${MARKER}\nSomething.\n`;
+    writeFileSync(updatesPath(), seeded, "utf-8");
+
+    releaseNotesDynamicModelContextMigration.run(workspaceDir);
+
+    expect(readFileSync(updatesPath(), "utf-8")).toBe(seeded);
+  });
+
+  test("appends to existing UPDATES.md when marker is absent", () => {
+    const prior = "## Prior\n\nExisting release note.\n";
+    writeFileSync(updatesPath(), prior, "utf-8");
+
+    releaseNotesDynamicModelContextMigration.run(workspaceDir);
+
+    const content = readFileSync(updatesPath(), "utf-8");
+    expect(content.startsWith(prior)).toBe(true);
+    expect(content).toContain(MARKER);
+  });
+});