@vellumai/assistant 0.4.55 → 0.4.57

package/src/__tests__/checker.test.ts

@@ -1,5 +1,5 @@
 // Smoke command (run all security test files together):
-// bun test src/__tests__/checker.test.ts src/__tests__/trust-store.test.ts src/__tests__/session-skill-tools.test.ts src/__tests__/skill-script-runner-host.test.ts
+// bun test src/__tests__/checker.test.ts src/__tests__/trust-store.test.ts src/__tests__/conversation-skill-tools.test.ts src/__tests__/skill-script-runner-host.test.ts
 
 import {
   mkdirSync,
@@ -201,18 +201,18 @@ describe("Permission Checker", () => {
       });
     });
 
-    // file_write is always medium
+    // file_write is always low (sandboxed)
     describe("file_write", () => {
-      test("file_write is always medium risk", async () => {
+      test("file_write is always low risk", async () => {
         const risk = await classifyRisk("file_write", {
           path: "/tmp/file.txt",
         });
-        expect(risk).toBe(RiskLevel.Medium);
+        expect(risk).toBe(RiskLevel.Low);
       });
 
-      test("file_write with any path is medium risk", async () => {
+      test("file_write with any path is low risk", async () => {
         const risk = await classifyRisk("file_write", { path: "/etc/passwd" });
-        expect(risk).toBe(RiskLevel.Medium);
+        expect(risk).toBe(RiskLevel.Low);
       });
     });
 
@@ -673,23 +673,22 @@ describe("Permission Checker", () => {
       expect(result.decision).toBe("allow");
     });
 
-    test("file_write within workspace with no rule → prompt (medium risk bypasses workspace auto-allow)", async () => {
+    test("file_write → auto-allow (workspace-scoped)", async () => {
       const result = await check(
         "file_write",
         { path: "/tmp/file.txt" },
         "/tmp",
       );
-      expect(result.decision).toBe("prompt");
-      expect(result.reason).toContain("medium risk");
+      expect(result.decision).toBe("allow");
     });
 
-    test("file_write outside workspace with no rule → prompt", async () => {
+    test("file_write outside workspace → auto-allow (Low risk)", async () => {
       const result = await check(
         "file_write",
         { path: "/etc/some-file.txt" },
         "/tmp",
       );
-      expect(result.decision).toBe("prompt");
+      expect(result.decision).toBe("allow");
     });
 
     test("file_write with matching rule → allow", async () => {
@@ -1486,12 +1485,12 @@ describe("Permission Checker", () => {
       expect(result.matchedRule!.id).toBe("default:allow-file_edit-updates");
     });
 
-    test("file_write of non-workspace file is not auto-allowed", async () => {
+    test("file_write of non-workspace file is auto-allowed (Low risk)", async () => {
       const otherPath = join(checkerTestDir, "workspace", "OTHER.md");
       // Use a workingDir that doesn't contain the path so it's not workspace-scoped
       const result = await check("file_write", { path: otherPath }, "/home");
-      // Medium risk with no matching allow rule → prompt
-      expect(result.decision).toBe("prompt");
+      // Low risk → auto-allowed even outside workspace
+      expect(result.decision).toBe("allow");
     });
   });
 
@@ -2096,16 +2095,16 @@ describe("Permission Checker", () => {
       expect(risk).toBe(RiskLevel.High);
     });
 
-    test("file_write to non-skill path remains Medium risk", async () => {
+    test("file_write to non-skill path is Low risk", async () => {
       const normalPath = "/tmp/some-file.txt";
       const risk = await classifyRisk("file_write", { path: normalPath });
-      expect(risk).toBe(RiskLevel.Medium);
+      expect(risk).toBe(RiskLevel.Low);
     });
 
-    test("file_edit of non-skill path remains Medium risk", async () => {
+    test("file_edit of non-skill path is Low risk", async () => {
       const normalPath = "/tmp/some-file.txt";
       const risk = await classifyRisk("file_edit", { path: normalPath });
-      expect(risk).toBe(RiskLevel.Medium);
+      expect(risk).toBe(RiskLevel.Low);
     });
 
     test("host_file_write to non-skill path remains Medium risk (via registry)", async () => {
@@ -2557,12 +2556,12 @@ describe("Permission Checker", () => {
         expect(result.reason).toContain("requires approval");
       });
 
-      test("strict mode: file_write to non-skill path prompts as Strict mode (not High risk)", async () => {
+      test("strict mode: file_write to non-skill path prompts as Strict mode", async () => {
         testConfig.permissions.mode = "strict";
         const normalPath = "/tmp/some-file.txt";
         const result = await check("file_write", { path: normalPath }, "/tmp");
         expect(result.decision).toBe("prompt");
-        // Medium-risk file_write in strict mode with no rule → Strict mode reason
+        // Low-risk file_write in strict mode with no rule → Strict mode reason
         expect(result.reason).toContain("Strict mode");
       });
 
@@ -2865,7 +2864,7 @@ describe("Permission Checker", () => {
       const symlinkedFile = join(symDir, "config.json");
       const realFileResolved = join(realDirResolved, "config.json");
 
-      // file_write is Medium risk — needs a matching rule to allow.
+      // file_write is Low risk — but add a rule to verify symlink path matching.
       addRule("file_write", `file_write:${realFileResolved}`, "everywhere");
       const result = await check(
         "file_write",
@@ -3597,7 +3596,7 @@ describe("Permission Checker", () => {
         expect(result.matchedRule!.pattern).toBe("skill_load:*");
       });
 
-      test("medium-risk file_write with no rule prompts in strict mode", async () => {
+      test("low-risk file_write with no rule prompts in strict mode", async () => {
         testConfig.permissions.mode = "strict";
         const result = await check(
           "file_write",
@@ -3996,14 +3995,14 @@ describe("Permission Checker", () => {
     );
 
     test(
-      "file_write to non-extra dir remains Medium when extra dirs are configured",
+      "file_write to non-extra dir remains Low when extra dirs are configured",
       withExtraDirs(async () => {
         const risk = await classifyRisk(
           "file_write",
           { path: "/tmp/unrelated.txt" },
           "/tmp",
         );
-        expect(risk).toBe(RiskLevel.Medium);
+        expect(risk).toBe(RiskLevel.Low);
       }),
     );
 
@@ -4583,24 +4582,24 @@ describe("workspace mode — auto-allow workspace-scoped operations", () => {
     expect(result.reason).toContain("Workspace mode");
   });
 
-  test("file_write within workspace → prompt (Medium risk bypasses workspace auto-allow)", async () => {
+  test("file_write within workspace → allow (workspace-scoped)", async () => {
     const result = await check(
       "file_write",
       { file_path: "/home/user/my-project/src/index.ts" },
       workspaceDir,
     );
-    expect(result.decision).toBe("prompt");
-    expect(result.reason).toContain("medium risk");
+    expect(result.decision).toBe("allow");
+    expect(result.reason).toContain("Workspace mode");
   });
 
-  test("file_edit within workspace → prompt (Medium risk bypasses workspace auto-allow)", async () => {
+  test("file_edit within workspace → allow (workspace-scoped)", async () => {
     const result = await check(
       "file_edit",
       { file_path: "/home/user/my-project/src/index.ts" },
       workspaceDir,
     );
-    expect(result.decision).toBe("prompt");
-    expect(result.reason).toContain("medium risk");
+    expect(result.decision).toBe("allow");
+    expect(result.reason).toContain("Workspace mode");
   });
 
   // ── file operations outside workspace follow risk-based fallback ──
@@ -4615,14 +4614,14 @@ describe("workspace mode — auto-allow workspace-scoped operations", () => {
     expect(result.reason).toContain("Low risk");
   });
 
-  test("file_write outside workspace → prompt (Medium risk fallback)", async () => {
+  test("file_write outside workspace → allow (Low risk fallback)", async () => {
     const result = await check(
       "file_write",
       { file_path: "/tmp/outside.txt" },
       workspaceDir,
     );
-    expect(result.decision).toBe("prompt");
-    expect(result.reason).toContain("risk");
+    expect(result.decision).toBe("allow");
+    expect(result.reason).toContain("Low risk");
   });
 
   // ── bash (sandbox) — default rule matches, workspace mode not reached ──

package/src/__tests__/chrome-cdp.test.ts

@@ -145,21 +145,37 @@ describe("ensureChromeWithCdp", () => {
       throw new Error("Connection refused");
     };
 
-    const session = await ensureChromeWithCdp({
-      startUrl: "https://example.com/",
-    });
-    expect(session.launchedByUs).toBe(true);
-    expect(session.baseUrl).toBe("http://localhost:9222");
-    expect(spawnMock).toHaveBeenCalledTimes(1);
-
-    // Verify spawn was called with the right Chrome path and args
-    const spawnArgs = spawnMock.mock.calls[0] as unknown as [string, string[]];
-    expect(spawnArgs[0]).toContain("Google Chrome");
-    const flags = spawnArgs[1];
-    expect(flags).toContain("--remote-debugging-port=9222");
-    expect(flags).toContain("--force-renderer-accessibility");
-    expect(flags.some((f: string) => f.includes("Chrome-CDP"))).toBe(true);
-    expect(flags).toContain("https://example.com/");
+    // Replace setTimeout with a zero-delay version to skip retry waits
+    const origSetTimeout = globalThis.setTimeout;
+    globalThis.setTimeout = ((
+      fn: TimerHandler,
+      _ms?: number,
+      ...args: unknown[]
+    ) => {
+      return origSetTimeout(fn, 0, ...args);
+    }) as typeof setTimeout;
+    try {
+      const session = await ensureChromeWithCdp({
+        startUrl: "https://example.com/",
+      });
+      expect(session.launchedByUs).toBe(true);
+      expect(session.baseUrl).toBe("http://localhost:9222");
+      expect(spawnMock).toHaveBeenCalledTimes(1);
+
+      // Verify spawn was called with the right Chrome path and args
+      const spawnArgs = spawnMock.mock.calls[0] as unknown as [
+        string,
+        string[],
+      ];
+      expect(spawnArgs[0]).toContain("Google Chrome");
+      const flags = spawnArgs[1];
+      expect(flags).toContain("--remote-debugging-port=9222");
+      expect(flags).toContain("--force-renderer-accessibility");
+      expect(flags.some((f: string) => f.includes("Chrome-CDP"))).toBe(true);
+      expect(flags).toContain("https://example.com/");
+    } finally {
+      globalThis.setTimeout = origSetTimeout;
+    }
   });
 
   test("uses custom port when specified", async () => {
@@ -182,9 +198,22 @@ describe("ensureChromeWithCdp", () => {
       throw new Error("Connection refused");
     };
 
-    const promise = ensureChromeWithCdp();
-    await expect(promise).rejects.toThrow("CDP endpoint not responding");
-  }, 20_000);
+    // Replace setTimeout with a zero-delay version to skip retry waits
+    const origSetTimeout = globalThis.setTimeout;
+    globalThis.setTimeout = ((
+      fn: TimerHandler,
+      _ms?: number,
+      ...args: unknown[]
+    ) => {
+      return origSetTimeout(fn, 0, ...args);
+    }) as typeof setTimeout;
+    try {
+      const promise = ensureChromeWithCdp();
+      await expect(promise).rejects.toThrow("CDP endpoint not responding");
+    } finally {
+      globalThis.setTimeout = origSetTimeout;
+    }
+  });
 });
 
 // ---------------------------------------------------------------------------

package/src/__tests__/claude-code-skill-regression.test.ts

@@ -29,7 +29,28 @@ mock.module("../util/logger.js", () => ({
 mock.module("../config/loader.js", () => ({
   getConfig: () => ({
     ui: {},
+    services: {
+      inference: {
+        mode: "your-own",
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+      },
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-3.1-flash-image-preview",
+      },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
+    },
   }),
+  loadConfig: () => ({}),
+  loadRawConfig: () => ({}),
+  saveConfig: () => {},
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+  syncConfigToLockfile: () => {},
 }));
 
 mock.module("../security/secure-keys.js", () => ({
@@ -52,6 +73,11 @@ const SKILL_DIR = path.resolve(
   "../config/bundled-skills/claude-code",
 );
 
+const SHARED_DIR = path.resolve(
+  import.meta.dirname ?? __dirname,
+  "../config/bundled-skills/_shared",
+);
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -121,7 +147,7 @@ describe("Claude Code skill migration regression", () => {
 
     const input = { prompt: "hello" };
     const ctx = {
-      sessionId: "test",
+      conversationId: "test",
       workingDir: "/tmp",
       onOutput: () => {},
     };
@@ -136,3 +162,43 @@ describe("Claude Code skill migration regression", () => {
     spy.mockRestore();
   });
 });
+
+// ---------------------------------------------------------------------------
+// Bundled skill shared guidance — CES tools instead of token-reveal
+// ---------------------------------------------------------------------------
+
+describe("CLI_RETRIEVAL_PATTERN.md CES guidance", () => {
+  const patternPath = path.join(SHARED_DIR, "CLI_RETRIEVAL_PATTERN.md");
+  const content = fs.readFileSync(patternPath, "utf-8");
+
+  test("teaches handle discovery via assistant credentials list", () => {
+    expect(content).toContain("assistant credentials list");
+  });
+
+  test("teaches handle discovery via assistant oauth connections list", () => {
+    expect(content).toContain("assistant oauth connections list");
+  });
+
+  test("teaches make_authenticated_request CES tool", () => {
+    expect(content).toContain("make_authenticated_request");
+  });
+
+  test("teaches run_authenticated_command CES tool", () => {
+    expect(content).toContain("run_authenticated_command");
+  });
+
+  test("warns that host_bash is outside CES secrecy boundary", () => {
+    expect(content).toContain("outside the CES secrecy boundary");
+  });
+
+  // -- Deprecated patterns must NOT appear --
+
+  test("does not teach proxied bash with credential_ids", () => {
+    expect(content).not.toContain("credential_ids");
+    expect(content).not.toContain("network_mode: proxied");
+  });
+
+  test("does not teach oauth connections token for raw token extraction", () => {
+    expect(content).not.toContain("oauth connections token");
+  });
+});

package/src/__tests__/claude-code-tool-profiles.test.ts

@@ -47,7 +47,7 @@ import type { ToolContext } from "../tools/types.js";
 
 function makeContext(overrides?: Partial<ToolContext>): ToolContext {
   return {
-    sessionId: "test-session",
+    conversationId: "test-session",
     workingDir: "/tmp/test",
     trustClass: "guardian",
     onOutput: () => {},

package/src/__tests__/clipboard.test.ts

@@ -2,32 +2,32 @@ import { describe, expect, test } from "bun:test";
 
 import {
   extractLastCodeBlock,
-  formatSessionForExport,
+  formatConversationForExport,
 } from "../util/clipboard.js";
 
-describe("formatSessionForExport", () => {
+describe("formatConversationForExport", () => {
   test("formats user and assistant messages", () => {
     const messages = [
       { role: "user", text: "Hello" },
       { role: "assistant", text: "Hi there!" },
     ];
-    expect(formatSessionForExport(messages)).toBe(
+    expect(formatConversationForExport(messages)).toBe(
       "you> Hello\n\nassistant> Hi there!",
     );
   });
 
   test("handles a single message", () => {
     const messages = [{ role: "user", text: "Just me" }];
-    expect(formatSessionForExport(messages)).toBe("you> Just me");
+    expect(formatConversationForExport(messages)).toBe("you> Just me");
   });
 
   test("handles empty messages array", () => {
-    expect(formatSessionForExport([])).toBe("");
+    expect(formatConversationForExport([])).toBe("");
   });
 
   test("preserves multiline message text", () => {
     const messages = [{ role: "assistant", text: "Line 1\nLine 2\nLine 3" }];
-    expect(formatSessionForExport(messages)).toBe(
+    expect(formatConversationForExport(messages)).toBe(
       "assistant> Line 1\nLine 2\nLine 3",
     );
   });

package/src/__tests__/commit-guarantee.test.ts

@@ -89,7 +89,7 @@ describe("Commit guarantees", () => {
       //   2. Post-processing (resolveAssistantAttachments) throws
       //   3. Turn-boundary commit must still happen in finally block
 
-      const sessionId = "sess_post_processing_error";
+      const conversationId = "sess_post_processing_error";
       const service = getWorkspaceGitService(testDir);
       await service.ensureInitialized();
 
@@ -114,7 +114,7 @@ describe("Commit guarantees", () => {
         // Step 3: Turn-boundary commit in finally block — the key guarantee
         if (turnStarted) {
           turnCount++;
-          await commitTurnChanges(testDir, sessionId, turnCount);
+          await commitTurnChanges(testDir, conversationId, turnCount);
         }
       }
 
@@ -124,7 +124,7 @@ describe("Commit guarantees", () => {
 
       const msg = lastCommitMessage(testDir);
       expect(msg).toContain("Turn:");
-      expect(msg).toContain("Session: sess_post_processing_error");
+      expect(msg).toContain("Conversation: sess_post_processing_error");
       expect(msg).toContain("Turn: 1");
       expect(msg).toContain("Files: 2 changed");
     });
@@ -161,7 +161,7 @@ describe("Commit guarantees", () => {
     test("commits workspace changes when user cancels mid-turn", async () => {
       // When the user cancels, the agent loop may have already modified files.
       // The finally-block commit must still run.
-      const sessionId = "sess_cancelled";
+      const conversationId = "sess_cancelled";
       const service = getWorkspaceGitService(testDir);
       await service.ensureInitialized();
 
@@ -182,7 +182,7 @@ describe("Commit guarantees", () => {
       } finally {
         if (turnStarted) {
           turnCount++;
-          await commitTurnChanges(testDir, sessionId, turnCount);
+          await commitTurnChanges(testDir, conversationId, turnCount);
         }
       }
 
@@ -195,7 +195,7 @@ describe("Commit guarantees", () => {
     test("commits across multiple turns with intermittent errors", async () => {
       // Verify commit guarantees hold across multiple turns where some
       // succeed normally and others have post-processing errors.
-      const sessionId = "sess_mixed";
+      const conversationId = "sess_mixed";
       const service = getWorkspaceGitService(testDir);
       await service.ensureInitialized();
 
@@ -211,7 +211,7 @@ describe("Commit guarantees", () => {
         } finally {
           if (turnStarted) {
             turnCount++;
-            await commitTurnChanges(testDir, sessionId, turnCount);
+            await commitTurnChanges(testDir, conversationId, turnCount);
           }
         }
       }
@@ -228,7 +228,7 @@ describe("Commit guarantees", () => {
         } finally {
           if (turnStarted) {
             turnCount++;
-            await commitTurnChanges(testDir, sessionId, turnCount);
+            await commitTurnChanges(testDir, conversationId, turnCount);
           }
         }
       }
@@ -242,7 +242,7 @@ describe("Commit guarantees", () => {
         } finally {
           if (turnStarted) {
             turnCount++;
-            await commitTurnChanges(testDir, sessionId, turnCount);
+            await commitTurnChanges(testDir, conversationId, turnCount);
           }
         }
       }

package/src/__tests__/commit-message-enrichment-service.test.ts

@@ -1,5 +1,11 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  rmSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
@@ -50,7 +56,7 @@ describe("CommitEnrichmentService", () => {
     return {
       workspaceDir: testDir,
       trigger: "turn",
-      sessionId: "sess_test",
+      conversationId: "sess_test",
       turnNumber: 1,
       changedFiles: ["file.txt"],
       timestampMs: Date.now(),
@@ -59,9 +65,34 @@ describe("CommitEnrichmentService", () => {
   }
 
   async function createCommit(): Promise<string> {
-    writeFileSync(join(testDir, `file-${Date.now()}.txt`), "content");
-    await gitService.commitChanges("test commit");
-    return await gitService.getHeadHash();
+    const filename = `file-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`;
+    writeFileSync(join(testDir, filename), "content");
+    // Use execFileSync directly for test setup commits to avoid async
+    // timing issues that can leave stale index.lock files on loaded CI runners.
+    const lockPath = join(testDir, ".git", "index.lock");
+    try {
+      unlinkSync(lockPath);
+    } catch {
+      /* no lock to clean */
+    }
+    execFileSync("git", ["add", "-A"], { cwd: testDir });
+    execFileSync(
+      "git",
+      [
+        "-c",
+        "core.hooksPath=/dev/null",
+        "commit",
+        "--no-verify",
+        "-m",
+        "test commit",
+        "--allow-empty",
+      ],
+      { cwd: testDir },
+    );
+    return execFileSync("git", ["rev-parse", "HEAD"], {
+      cwd: testDir,
+      encoding: "utf-8",
+    }).trim();
   }
 
   async function waitForDrain(
@@ -111,7 +142,7 @@ describe("CommitEnrichmentService", () => {
     const note = JSON.parse(noteContent);
     expect(note.enriched).toBe(true);
     expect(note.trigger).toBe("turn");
-    expect(note.sessionId).toBe("sess_test");
+    expect(note.conversationId).toBe("sess_test");
     expect(note.turnNumber).toBe(1);
     expect(note.filesChanged).toBe(1);
     expect(service._getSucceededCount()).toBe(1);

package/src/__tests__/computer-use-tools.test.ts

@@ -31,7 +31,6 @@ function schema(tool: {
 
 const ctx: ToolContext = {
   workingDir: "/tmp",
-  sessionId: "test-session",
   conversationId: "test-conversation",
   trustClass: "guardian",
 };

package/src/__tests__/config-loader-backfill.test.ts

@@ -230,8 +230,9 @@ describe("config loader backfill", () => {
 
   test("preserves existing user-defined values during backfill", () => {
     writeConfig({
-      provider: "openai",
-      model: "gpt-4",
+      services: {
+        inference: { provider: "openai", model: "gpt-4" },
+      },
       telegram: { botUsername: "mybot", timeoutMs: 30_000 },
       whatsapp: { phoneNumber: "+1234567890" },
     });
@@ -240,8 +241,9 @@ describe("config loader backfill", () => {
 
     const raw = readConfig();
     // User values preserved
-    expect(raw.provider).toBe("openai");
-    expect(raw.model).toBe("gpt-4");
+    const services = raw.services as Record<string, Record<string, unknown>>;
+    expect(services.inference.provider).toBe("openai");
+    expect(services.inference.model).toBe("gpt-4");
     expect((raw.telegram as Record<string, unknown>).botUsername).toBe("mybot");
     expect((raw.telegram as Record<string, unknown>).timeoutMs).toBe(30_000);
     expect((raw.whatsapp as Record<string, unknown>).phoneNumber).toBe(