@vellumai/assistant 0.6.6 → 0.7.0

package/src/__tests__/openai-responses-provider.test.ts

@@ -133,6 +133,7 @@ function completedEvent(
   outputTokens: number,
   opts?: {
     reasoningTokens?: number;
+    cachedTokens?: number;
     model?: string;
     status?: string;
     output?: unknown[];
@@ -155,6 +156,9 @@ function completedEvent(
         output_tokens_details: {
           reasoning_tokens: opts?.reasoningTokens ?? 0,
         },
+        ...(opts?.cachedTokens
+          ? { input_tokens_details: { cached_tokens: opts.cachedTokens } }
+          : {}),
       },
     },
   };
@@ -464,6 +468,40 @@ describe("OpenAIResponsesProvider", () => {
     expect(result.usage).not.toHaveProperty("reasoningTokens");
   });
 
+  // -----------------------------------------------------------------------
+  // Cached input tokens (prompt caching)
+  // -----------------------------------------------------------------------
+  test("maps cached input tokens to cacheReadInputTokens", async () => {
+    // OpenAI's input_tokens already includes the cached portion, so the
+    // normalized inputTokens stays at the API value and the cached subset
+    // surfaces separately as cacheReadInputTokens. Downstream code derives
+    // directInputTokens by subtracting cache read/creation from inputTokens.
+    fakeStreamEvents = [
+      textDeltaEvent("Cached reply"),
+      completedEvent(50_648, 114, { cachedTokens: 49_536 }),
+    ];
+
+    const result = await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "Hi" }] },
+    ]);
+
+    expect(result.usage).toEqual({
+      inputTokens: 50_648,
+      outputTokens: 114,
+      cacheReadInputTokens: 49_536,
+    });
+  });
+
+  test("omits cacheReadInputTokens when no cached tokens", async () => {
+    fakeStreamEvents = [textDeltaEvent("Fresh reply"), completedEvent(10, 5)];
+
+    const result = await provider.sendMessage([
+      { role: "user", content: [{ type: "text", text: "Hi" }] },
+    ]);
+
+    expect(result.usage).not.toHaveProperty("cacheReadInputTokens");
+  });
+
   // -----------------------------------------------------------------------
   // max_tokens → max_output_tokens
   // -----------------------------------------------------------------------
@@ -496,7 +534,7 @@ describe("OpenAIResponsesProvider", () => {
     expect(lastStreamParams!.reasoning).toEqual({ effort: "high" });
   });
 
-  test('effort: "max" maps to reasoning: { effort: "high" }', async () => {
+  test('effort: "max" maps to reasoning: { effort: "xhigh" }', async () => {
     fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
 
     await provider.sendMessage(
@@ -506,10 +544,10 @@ describe("OpenAIResponsesProvider", () => {
       { config: { effort: "max" } },
     );
 
-    expect(lastStreamParams!.reasoning).toEqual({ effort: "high" });
+    expect(lastStreamParams!.reasoning).toEqual({ effort: "xhigh" });
   });
 
-  test('effort: "xhigh" maps to reasoning: { effort: "high" }', async () => {
+  test('effort: "xhigh" maps to reasoning: { effort: "xhigh" }', async () => {
     fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
 
     await provider.sendMessage(
@@ -519,7 +557,7 @@ describe("OpenAIResponsesProvider", () => {
       { config: { effort: "xhigh" } },
     );
 
-    expect(lastStreamParams!.reasoning).toEqual({ effort: "high" });
+    expect(lastStreamParams!.reasoning).toEqual({ effort: "xhigh" });
   });
 
   test("no effort config means no reasoning in params", async () => {
@@ -535,6 +573,110 @@ describe("OpenAIResponsesProvider", () => {
     expect(lastStreamParams!.reasoning).toBeUndefined();
   });
 
+  test('effort: "none" is sent explicitly as reasoning: { effort: "none" }', async () => {
+    // The OpenAI Responses API defaults `reasoning.effort` to "medium" when
+    // the field is omitted, so the user's opt-out is only honored when we
+    // send the explicit "none" value on the wire.
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      { config: { effort: "none" } },
+    );
+
+    expect(lastStreamParams!.reasoning).toEqual({ effort: "none" });
+  });
+
+  // -----------------------------------------------------------------------
+  // Verbosity → text param
+  // -----------------------------------------------------------------------
+  test('verbosity: "low" maps to text: { verbosity: "low" }', async () => {
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      { config: { verbosity: "low" } },
+    );
+
+    expect(lastStreamParams!.text).toEqual({ verbosity: "low" });
+  });
+
+  test('verbosity: "high" maps to text: { verbosity: "high" }', async () => {
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      { config: { verbosity: "high" } },
+    );
+
+    expect(lastStreamParams!.text).toEqual({ verbosity: "high" });
+  });
+
+  test("no verbosity config means no text param", async () => {
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      { config: {} },
+    );
+
+    expect(lastStreamParams!.text).toBeUndefined();
+  });
+
+  test("unrecognized verbosity value is ignored", async () => {
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await provider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      // Cast through unknown — the test deliberately exercises the runtime
+      // guard against malformed values that would bypass the type system
+      // (e.g. arriving via the index signature on `SendMessageConfig`).
+      { config: { verbosity: "bogus" as unknown as "low" } },
+    );
+
+    expect(lastStreamParams!.text).toBeUndefined();
+  });
+
+  test("verbosity is suppressed for non-GPT-5 models", async () => {
+    // `text.verbosity` is a GPT-5-series-only parameter; forwarding it to
+    // older Responses-API models (o-series, etc.) risks HTTP 400 rejections.
+    const oSeriesProvider = new OpenAIResponsesProvider("sk-test", "o3");
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await oSeriesProvider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      { config: { verbosity: "high" } },
+    );
+
+    expect(lastStreamParams!.text).toBeUndefined();
+  });
+
+  test("verbosity is forwarded when model override is GPT-5", async () => {
+    const oSeriesProvider = new OpenAIResponsesProvider("sk-test", "o3");
+    fakeStreamEvents = [textDeltaEvent("OK"), completedEvent(10, 2)];
+
+    await oSeriesProvider.sendMessage(
+      [{ role: "user", content: [{ type: "text", text: "Hi" }] }],
+      undefined,
+      undefined,
+      { config: { verbosity: "high", model: "gpt-5.2" } },
+    );
+
+    expect(lastStreamParams!.text).toEqual({ verbosity: "high" });
+  });
+
   // -----------------------------------------------------------------------
   // Model override
   // -----------------------------------------------------------------------

package/src/__tests__/openrouter-provider-only.test.ts

@@ -9,9 +9,7 @@ import type { SendMessageOptions } from "../providers/types.js";
 
 /** Expose the protected `buildExtraCreateParams` hook for assertion. */
 class ProbeOpenRouterProvider extends OpenRouterProvider {
-  public probeExtras(
-    options?: SendMessageOptions,
-  ): Record<string, unknown> {
+  public probeExtras(options?: SendMessageOptions): Record<string, unknown> {
     return this.buildExtraCreateParams(options);
   }
 }
@@ -61,7 +59,10 @@ describe("OpenRouter provider.only plumbing", () => {
 
     test("returns options unchanged when only list is empty", () => {
       const options = {
-        config: { model: "anthropic/claude-opus-4.7", openrouter: { only: [] } },
+        config: {
+          model: "anthropic/claude-opus-4.7",
+          openrouter: { only: [] },
+        },
       };
       expect(withOpenRouterBodyExtras(options)).toBe(options);
     });
@@ -131,5 +132,22 @@ describe("OpenRouter provider.only plumbing", () => {
         provider: { only: ["xAI"] },
       });
     });
+
+    test("disabled thinking keeps reasoning disabled alongside provider.only", () => {
+      const provider = new ProbeOpenRouterProvider(
+        "fake-key",
+        "x-ai/grok-4.20-beta",
+      );
+      const extras = provider.probeExtras({
+        config: {
+          thinking: { type: "disabled" },
+          openrouter: { only: ["xAI"] },
+        },
+      });
+      expect(extras).toEqual({
+        reasoning: { enabled: false },
+        provider: { only: ["xAI"] },
+      });
+    });
   });
 });

package/src/__tests__/overflow-reduce-pipeline.test.ts

@@ -31,10 +31,8 @@ import {
   reduceContextOverflow,
   type ReducerState,
 } from "../daemon/context-overflow-reducer.js";
-import type {
-  InjectionMode,
-  TrustContext,
-} from "../daemon/conversation-runtime-assembly.js";
+import type { InjectionMode } from "../daemon/conversation-runtime-assembly.js";
+import type { TrustContext } from "../daemon/trust-context.js";
 import {
   defaultOverflowReduceMiddleware,
   defaultOverflowReducePlugin,
@@ -591,7 +589,7 @@ describe("overflow-reduce pipeline", () => {
         },
       };
 
-      expect(
+      await expect(
         defaultOverflowReduceMiddleware(
           aborting,
           async () => {
@@ -600,8 +598,6 @@ describe("overflow-reduce pipeline", () => {
           makeTurnContext(),
         ),
       ).rejects.toThrow();
-      // Give the event loop a tick to resolve the rejected promise.
-      await Promise.resolve();
       // Exactly one iteration ran; the abort gate stopped the next round.
       expect(estimateCalls).toBe(1);
     });
@@ -616,7 +612,7 @@ describe("overflow-reduce pipeline", () => {
         abortSignal: controller.signal,
       };
 
-      expect(
+      await expect(
         defaultOverflowReduceMiddleware(
           args,
           async () => {
@@ -625,7 +621,6 @@ describe("overflow-reduce pipeline", () => {
           makeTurnContext(),
         ),
       ).rejects.toThrow();
-      await Promise.resolve();
       // Reducer never ran — zero compaction and reinject callbacks observed.
       expect(build.compactionResults).toHaveLength(0);
       expect(build.reinjectCalls).toHaveLength(0);

package/src/__tests__/permission-types.test.ts

@@ -1,6 +1,5 @@
 import { describe, expect, test } from "bun:test";
 
-import type { UserDecision } from "../permissions/types.js";
 import { isAllowDecision } from "../permissions/types.js";
 
 // ---------------------------------------------------------------------------
@@ -8,25 +7,11 @@ import { isAllowDecision } from "../permissions/types.js";
 // ---------------------------------------------------------------------------
 
 describe("isAllowDecision", () => {
-  const allowDecisions: UserDecision[] = [
-    "allow",
-    "allow_10m",
-    "allow_conversation",
-    "always_allow",
-    "temporary_override",
-  ];
-
-  for (const decision of allowDecisions) {
-    test(`returns true for '${decision}'`, () => {
-      expect(isAllowDecision(decision)).toBe(true);
-    });
-  }
+  test("returns true for 'allow'", () => {
+    expect(isAllowDecision("allow")).toBe(true);
+  });
 
   test("returns false for 'deny'", () => {
     expect(isAllowDecision("deny")).toBe(false);
   });
-
-  test("returns false for 'always_deny'", () => {
-    expect(isAllowDecision("always_deny")).toBe(false);
-  });
 });

package/src/__tests__/persistence-pipeline.test.ts

@@ -19,7 +19,7 @@
 
 import { afterAll, beforeEach, describe, expect, test } from "bun:test";
 
-import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
+import type { TrustContext } from "../daemon/trust-context.js";
 import {
   addMessage,
   createConversation,
@@ -27,7 +27,8 @@ import {
   getMessages,
   updateMessageMetadata,
 } from "../memory/conversation-crud.js";
-import { getDb, initializeDb } from "../memory/db.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
 import {
   defaultPersistencePlugin,
   defaultPersistenceTerminal,

package/src/__tests__/pipeline-runner.test.ts

@@ -11,7 +11,7 @@
 
 import { beforeEach, describe, expect, test } from "bun:test";
 
-import type { TrustContext } from "../daemon/conversation-runtime-assembly.js";
+import type { TrustContext } from "../daemon/trust-context.js";
 import {
   composeMiddleware,
   DEFAULT_TIMEOUTS,

package/src/__tests__/platform-bash-auto-approve.test.ts

@@ -51,9 +51,7 @@ const mockConfig = {
     action: "warn" as const,
     entropyThreshold: 4.0,
   },
-  permissions: {
-    mode: "workspace" as const,
-  },
+  permissions: {},
 };
 
 let fakeToolResult: ToolExecutionResult = { content: "ok", isError: false };
@@ -97,6 +95,7 @@ mock.module("../permissions/checker.js", () => ({
   ],
   generateScopeOptions: () =>
     scopeOptionsOverride ?? [{ label: "/tmp", scope: "/tmp" }],
+  getCachedAssessment: () => undefined,
 }));
 
 // Mock every export so downstream test files that dynamically import modules
@@ -131,15 +130,13 @@ mock.module("../tools/terminal/sandbox.js", () => ({
   wrapCommand: () => ({ command: "", sandboxed: false }),
 }));
 
-mock.module("../approvals/approval-primitive.js", () => ({
-  consumeGrantForInvocation: async () => ({ ok: false, reason: "no_grant" }),
-}));
-
+import { initializeDb } from "../memory/db-init.js";
 import { PermissionPrompter } from "../permissions/prompter.js";
-import { clearAll as clearAllOverrides } from "../runtime/conversation-approval-overrides.js";
 import { ToolExecutor } from "../tools/executor.js";
 import type { ToolContext as TC } from "../tools/types.js";
 
+initializeDb();
+
 function makeContext(overrides?: Partial<TC>): TC {
   return {
     workingDir: "/tmp/project",
@@ -173,11 +170,9 @@ describe("platform-hosted bash auto-approval", () => {
     checkResultOverride = undefined;
     scopeOptionsOverride = undefined;
     riskOverride = "medium";
-    clearAllOverrides();
   });
 
   afterEach(() => {
-    clearAllOverrides();
   });
 
   test("bash auto-approved in platform-hosted mode", async () => {
@@ -247,26 +242,38 @@ describe("platform-hosted bash auto-approval", () => {
     await executor.execute(
       "bash",
       { command: "echo hello" },
-      makeContext({ isPlatformHosted: false, trustClass: "guardian" }),
+      makeContext({ isPlatformHosted: false, trustClass: "guardian", requireFreshApproval: true }),
     );
 
     expect(promptCalled).toBe(true);
   });
 
-  test("bash NOT auto-approved for non-guardian actors", async () => {
+  test("bash NOT auto-approved for non-guardian actors via platform path (sandbox bash is allowed)", async () => {
     checkResultOverride = { decision: "prompt", reason: "Needs approval" };
 
-    const executor = new ToolExecutor(makePrompter());
+    const platformAutoApproveCalled = false;
+    const trackingPrompter = {
+      prompt: async () => {
+        // If this is called, we know the platform auto-approve did NOT fire
+        return { decision: "allow" as const };
+      },
+      resolveConfirmation: () => {},
+      updateSender: () => {},
+      dispose: () => {},
+    } as unknown as PermissionPrompter;
+
+    const executor = new ToolExecutor(trackingPrompter);
     const result = await executor.execute(
       "bash",
       { command: "echo hello" },
-      makeContext({ isPlatformHosted: true, trustClass: "trusted_contact" }),
+      makeContext({ isPlatformHosted: true, trustClass: "trusted_contact", requireFreshApproval: true }),
     );
 
-    // Non-guardian actors are blocked by the pre-execution guardian approval
-    // gate before reaching the permission checker. The tool must NOT succeed
-    // via platform auto-approve.
-    expect(result.isError).toBe(true);
+    // With requireFreshApproval, trusted_contact+bash goes through check()
+    // which returns "prompt" and then the interactive prompter is called.
+    // The platform auto-approve path (guardian-only) is NOT taken.
+    expect(result.isError).toBe(false);
+    void platformAutoApproveCalled; // suppress unused warning
   });
 
   test("bash NOT auto-approved when requireFreshApproval is set", async () => {
@@ -304,7 +311,7 @@ describe("platform-hosted bash auto-approval", () => {
     const result = await executor.execute(
       "bash",
       { command: "rm -rf /" },
-      makeContext({ isPlatformHosted: true, trustClass: "guardian" }),
+      makeContext({ isPlatformHosted: true, trustClass: "guardian", requireFreshApproval: true }),
     );
 
     expect(result.isError).toBe(true);
@@ -355,7 +362,7 @@ describe("platform-hosted bash auto-approval", () => {
     await executor.execute(
       "file_write",
       { path: "/tmp/test.txt", content: "hello" },
-      makeContext({ isPlatformHosted: true, trustClass: "guardian" }),
+      makeContext({ isPlatformHosted: true, trustClass: "guardian", requireFreshApproval: true }),
     );
 
     expect(promptCalled).toBe(true);

package/src/__tests__/platform.test.ts

@@ -7,13 +7,10 @@ import {
   ensureDataDir,
   getDataDir,
   getDbPath,
-  getDotEnvPath,
   getHistoryPath,
   getInterfacesDir,
   getLogPath,
   getPidPath,
-  getProtectedDir,
-  getRuntimePortFilePath,
   getSandboxRootDir,
   getSandboxWorkingDir,
   getWorkspaceConfigPath,
@@ -21,12 +18,10 @@ import {
   getWorkspaceHooksDir,
   getWorkspacePromptPath,
   getWorkspaceSkillsDir,
-  getXdgPlatformTokenPath,
   getXdgVellumConfigDirName,
 } from "../util/platform.js";
 
 const originalWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
-const originalBaseDataDir = process.env.BASE_DATA_DIR;
 const originalVellumEnvironment = process.env.VELLUM_ENVIRONMENT;
 const originalXdgConfigHome = process.env.XDG_CONFIG_HOME;
 
@@ -36,11 +31,6 @@ afterEach(() => {
   } else {
     process.env.VELLUM_WORKSPACE_DIR = originalWorkspaceDir;
   }
-  if (originalBaseDataDir == null) {
-    delete process.env.BASE_DATA_DIR;
-  } else {
-    process.env.BASE_DATA_DIR = originalBaseDataDir;
-  }
   if (originalVellumEnvironment == null) {
     delete process.env.VELLUM_ENVIRONMENT;
   } else {
@@ -59,9 +49,8 @@ afterEach(() => {
 // otherwise under ~/.vellum/workspace.
 describe("path characterization", () => {
   test("all path helpers resolve to expected locations", () => {
-    // Without VELLUM_WORKSPACE_DIR or BASE_DATA_DIR override, everything is under ~/.vellum
+    // Without VELLUM_WORKSPACE_DIR override, workspace is under ~/.vellum
     delete process.env.VELLUM_WORKSPACE_DIR;
-    delete process.env.BASE_DATA_DIR;
     const root = join(homedir(), ".vellum");
     const ws = getWorkspaceDir();
     const data = getDataDir();
@@ -83,41 +72,20 @@ describe("path characterization", () => {
     // Hooks live under workspace
     expect(getWorkspaceHooksDir()).toBe(join(ws, "hooks"));
 
-    // Root-level runtime files remain at ~/.vellum/
-    expect(getPidPath()).toBe(join(root, "vellum.pid"));
+    // PID file lives in the workspace directory
+    expect(getPidPath()).toBe(join(ws, "vellum.pid"));
   });
 
   test("VELLUM_WORKSPACE_DIR overrides workspace location", () => {
-    delete process.env.BASE_DATA_DIR;
     process.env.VELLUM_WORKSPACE_DIR = "/tmp/custom-workspace";
     expect(getWorkspaceDir()).toBe("/tmp/custom-workspace");
     expect(getDataDir()).toBe("/tmp/custom-workspace/data");
-    // Root-level paths are NOT affected by VELLUM_WORKSPACE_DIR
-    expect(getPidPath()).toBe(join(homedir(), ".vellum", "vellum.pid"));
-  });
-
-  test("BASE_DATA_DIR relocates vellumRoot()-derived paths", () => {
-    const saved = process.env.BASE_DATA_DIR;
-    process.env.BASE_DATA_DIR = "/tmp/fake-instance";
-    try {
-      delete process.env.VELLUM_WORKSPACE_DIR;
-      expect(getPidPath()).toBe("/tmp/fake-instance/.vellum/vellum.pid");
-      expect(getProtectedDir()).toBe("/tmp/fake-instance/.vellum/protected");
-      expect(getRuntimePortFilePath()).toBe(
-        "/tmp/fake-instance/.vellum/runtime-port",
-      );
-      expect(getDotEnvPath()).toBe("/tmp/fake-instance/.vellum/.env");
-      // Workspace transitively relocates via vellumRoot()
-      expect(getWorkspaceDir()).toBe("/tmp/fake-instance/.vellum/workspace");
-    } finally {
-      if (saved === undefined) delete process.env.BASE_DATA_DIR;
-      else process.env.BASE_DATA_DIR = saved;
-    }
+    // PID path follows workspace override
+    expect(getPidPath()).toBe("/tmp/custom-workspace/vellum.pid");
   });
 
   test("hooks directory is inside the workspace boundary", () => {
     delete process.env.VELLUM_WORKSPACE_DIR;
-    delete process.env.BASE_DATA_DIR;
     expect(getWorkspaceHooksDir().startsWith(getWorkspaceDir())).toBe(true);
   });
 
@@ -125,7 +93,6 @@ describe("path characterization", () => {
     // Use a temp VELLUM_WORKSPACE_DIR so ensureDataDir writes to a temp dir
     // rather than the real ~/.vellum. Root-level dirs still go to ~/.vellum
     // but we only verify workspace dirs here to avoid side effects.
-    delete process.env.BASE_DATA_DIR;
     const wsDir = join(tmpdir(), `platform-test-ws-${Date.now()}`);
     process.env.VELLUM_WORKSPACE_DIR = wsDir;
 
@@ -154,53 +121,34 @@ describe("path characterization", () => {
   });
 });
 
-describe("XDG platform-token path env-awareness", () => {
-  test("production returns ~/.config/vellum/platform-token", () => {
+describe("XDG config dir name env-awareness", () => {
+  test("production returns vellum", () => {
     delete process.env.VELLUM_ENVIRONMENT;
     delete process.env.XDG_CONFIG_HOME;
     expect(getXdgVellumConfigDirName()).toBe("vellum");
-    expect(getXdgPlatformTokenPath()).toBe(
-      join(homedir(), ".config", "vellum", "platform-token"),
-    );
   });
 
-  test("production (explicit) returns ~/.config/vellum/platform-token", () => {
+  test("production (explicit) returns vellum", () => {
     process.env.VELLUM_ENVIRONMENT = "production";
-    delete process.env.XDG_CONFIG_HOME;
     expect(getXdgVellumConfigDirName()).toBe("vellum");
-    expect(getXdgPlatformTokenPath()).toBe(
-      join(homedir(), ".config", "vellum", "platform-token"),
-    );
   });
 
-  test("dev environment returns $XDG_CONFIG_HOME/vellum-dev/platform-token", () => {
+  test("dev environment returns vellum-dev", () => {
     process.env.VELLUM_ENVIRONMENT = "dev";
-    process.env.XDG_CONFIG_HOME = "/tmp/fake-xdg";
     expect(getXdgVellumConfigDirName()).toBe("vellum-dev");
-    expect(getXdgPlatformTokenPath()).toBe(
-      "/tmp/fake-xdg/vellum-dev/platform-token",
-    );
   });
 
   test.each(["staging", "test", "local"])(
-    "%s environment returns env-scoped path",
+    "%s environment returns vellum-%s",
     (env) => {
       process.env.VELLUM_ENVIRONMENT = env;
-      process.env.XDG_CONFIG_HOME = "/tmp/fake-xdg";
       expect(getXdgVellumConfigDirName()).toBe(`vellum-${env}`);
-      expect(getXdgPlatformTokenPath()).toBe(
-        `/tmp/fake-xdg/vellum-${env}/platform-token`,
-      );
     },
   );
 
-  test("unknown environment falls back to production path", () => {
+  test("unknown environment falls back to production", () => {
     process.env.VELLUM_ENVIRONMENT = "no-such-env";
-    process.env.XDG_CONFIG_HOME = "/tmp/fake-xdg";
     expect(getXdgVellumConfigDirName()).toBe("vellum");
-    expect(getXdgPlatformTokenPath()).toBe(
-      "/tmp/fake-xdg/vellum/platform-token",
-    );
   });
 });
 

package/src/__tests__/playbook-execution.test.ts

@@ -26,7 +26,8 @@ import { executePlaybookCreate } from "../config/bundled-skills/playbooks/tools/
 import { executePlaybookDelete } from "../config/bundled-skills/playbooks/tools/playbook-delete.js";
 import { executePlaybookList } from "../config/bundled-skills/playbooks/tools/playbook-list.js";
 import { executePlaybookUpdate } from "../config/bundled-skills/playbooks/tools/playbook-update.js";
-import { getDb, initializeDb } from "../memory/db.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
 import { getNode } from "../memory/graph/store.js";
 import { compilePlaybooks } from "../playbooks/playbook-compiler.js";
 import { parsePlaybookStatement } from "../playbooks/types.js";

package/src/__tests__/playbook-tools.test.ts

@@ -25,7 +25,8 @@ import { executePlaybookCreate } from "../config/bundled-skills/playbooks/tools/
 import { executePlaybookDelete } from "../config/bundled-skills/playbooks/tools/playbook-delete.js";
 import { executePlaybookList } from "../config/bundled-skills/playbooks/tools/playbook-list.js";
 import { executePlaybookUpdate } from "../config/bundled-skills/playbooks/tools/playbook-update.js";
-import { getDb, initializeDb } from "../memory/db.js";
+import { getDb } from "../memory/db-connection.js";
+import { initializeDb } from "../memory/db-init.js";
 import type { ToolContext } from "../tools/types.js";
 
 initializeDb();