@vellumai/assistant 0.5.1 → 0.5.3

package/src/__tests__/attachments-store.test.ts

@@ -1,4 +1,4 @@
-import { mkdtempSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
@@ -15,6 +15,8 @@ mock.module("../util/platform.js", () => ({
   getLogPath: () => join(testDir, "test.log"),
   ensureDataDir: () => {},
   getRootDir: () => testDir,
+  getWorkspaceDir: () => join(testDir, "workspace"),
+  getConversationsDir: () => join(testDir, "workspace", "conversations"),
 }));
 
 mock.module("../util/logger.js", () => ({
@@ -40,8 +42,10 @@ import {
   deleteAttachment,
   deleteOrphanAttachments,
   getAttachmentById,
+  getAttachmentContent,
   getAttachmentsByIds,
   getAttachmentsForMessage,
+  getFilePathForAttachment,
   isValidBase64,
   linkAttachmentToMessage,
   MAX_UPLOAD_BYTES,
@@ -49,7 +53,8 @@ import {
   validateAttachmentUpload,
 } from "../memory/attachments-store.js";
 import { addMessage, createConversation } from "../memory/conversation-crud.js";
-import { getDb, initializeDb, resetDb } from "../memory/db.js";
+import { getConversationDirPath } from "../memory/conversation-disk-view.js";
+import { getDb, initializeDb, rawGet, rawRun, resetDb } from "../memory/db.js";
 
 initializeDb();
 
@@ -70,8 +75,24 @@ function resetTables() {
   db.run("DELETE FROM conversations");
 }
 
+function getConversationTimestamp(createdAt: number): string {
+  return new Date(createdAt).toISOString().replace(/:/g, "-");
+}
+
+function getLegacyConversationDirPath(
+  conversationId: string,
+  createdAt: number,
+): string {
+  return join(
+    testDir,
+    "workspace",
+    "conversations",
+    `${conversationId}_${getConversationTimestamp(createdAt)}`,
+  );
+}
+
 // ---------------------------------------------------------------------------
-// uploadAttachment
+// uploadAttachment — stages until linked
 // ---------------------------------------------------------------------------
 
 describe("uploadAttachment", () => {
@@ -88,6 +109,29 @@ describe("uploadAttachment", () => {
     expect(stored.createdAt).toBeGreaterThan(0);
   });
 
+  test("keeps uploads staged until linked", () => {
+    const stored = uploadAttachment("small.txt", "text/plain", "aGVsbG8=");
+    const filePath = getFilePathForAttachment(stored.id);
+
+    expect(filePath).toBeNull();
+    expect(getAttachmentContent(stored.id)?.toString()).toBe("hello");
+  });
+
+  test("stores base64 in the DB row until linked", () => {
+    const stored = uploadAttachment("test.txt", "text/plain", "dGVzdA==");
+
+    // Staged uploads keep the payload inline until they are attached to a message.
+    const rawRow = rawGet<{ data_base64: string }>(
+      "SELECT data_base64 FROM attachments WHERE id = ?",
+      stored.id,
+    );
+    expect(rawRow!.data_base64).toBe("dGVzdA==");
+
+    const row = getAttachmentById(stored.id, { hydrateFileData: true });
+    expect(row).not.toBeNull();
+    expect(row!.dataBase64).toBe("dGVzdA==");
+  });
+
   test("classifies image MIME as image kind", () => {
     const stored = uploadAttachment("pic.jpg", "image/jpeg", "AAAA");
     expect(stored.kind).toBe("image");
@@ -105,12 +149,12 @@ describe("uploadAttachment", () => {
   });
 
   test("computes sizeBytes from base64 correctly", () => {
-    // "hello" = "aGVsbG8=" (8 chars, 1 pad → 5 bytes)
+    // "hello" = "aGVsbG8=" (8 chars, 1 pad -> 5 bytes)
     const stored = uploadAttachment("hello.txt", "text/plain", "aGVsbG8=");
     expect(stored.sizeBytes).toBe(5);
   });
 
-  test("deduplicates by content hash", () => {
+  test("does not deduplicate identical uploads before linking", () => {
     const first = uploadAttachment(
       "photo.png",
       "image/png",
@@ -121,10 +165,10 @@ describe("uploadAttachment", () => {
       "image/png",
       "iVBORw0KGgoAAAANSUh",
     );
-    expect(second.id).toBe(first.id);
+    expect(second.id).not.toBe(first.id);
   });
 
-  test("deduplicates even when filenames differ", () => {
+  test("does not deduplicate identical content when filenames differ", () => {
     const first = uploadAttachment(
       "original.png",
       "image/png",
@@ -135,7 +179,7 @@ describe("uploadAttachment", () => {
       "image/png",
       "DUPECONTENT123",
     );
-    expect(second.id).toBe(first.id);
+    expect(second.id).not.toBe(first.id);
   });
 
   test("does not deduplicate different content", () => {
@@ -146,7 +190,7 @@ describe("uploadAttachment", () => {
 
   test("rejects payloads exceeding MAX_UPLOAD_BYTES", () => {
     // Build a base64 string that decodes to just over the limit.
-    // 4 base64 chars → 3 bytes, so we need ceil((MAX_UPLOAD_BYTES+1)/3)*4 chars.
+    // 4 base64 chars -> 3 bytes, so we need ceil((MAX_UPLOAD_BYTES+1)/3)*4 chars.
     const oversizedLength = Math.ceil((MAX_UPLOAD_BYTES + 1) / 3) * 4;
     const oversizedData = "A".repeat(oversizedLength);
 
@@ -162,7 +206,7 @@ describe("uploadAttachment", () => {
   });
 
   test("accepts base64 with non-standard padding/length", () => {
-    // Lenient on length — only character set is validated
+    // Lenient on length -- only character set is validated
     expect(() => uploadAttachment("ok.txt", "text/plain", "AAA")).not.toThrow();
   });
 
@@ -178,6 +222,41 @@ describe("uploadAttachment", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// getAttachmentContent — staged inline or materialized on disk
+// ---------------------------------------------------------------------------
+
+describe("getAttachmentContent", () => {
+  beforeEach(resetTables);
+
+  test("returns staged content before the attachment is linked", () => {
+    const stored = uploadAttachment("hello.txt", "text/plain", "aGVsbG8=");
+    const content = getAttachmentContent(stored.id);
+
+    expect(content).not.toBeNull();
+    expect(content!.toString()).toBe("hello");
+  });
+
+  test("returns null for nonexistent attachment", () => {
+    const content = getAttachmentContent("no-such-id");
+    expect(content).toBeNull();
+  });
+
+  test("returns null when a materialized on-disk file is missing (ENOENT)", async () => {
+    const conv = createConversation();
+    const msg = await addMessage(conv.id, "assistant", "File");
+    const stored = uploadAttachment("test.txt", "text/plain", "dGVzdA==");
+    linkAttachmentToMessage(msg.id, stored.id, 0);
+    const filePath = getFilePathForAttachment(stored.id);
+
+    // Remove the file to simulate ENOENT
+    rmSync(filePath!);
+
+    const content = getAttachmentContent(stored.id);
+    expect(content).toBeNull();
+  });
+});
+
 // ---------------------------------------------------------------------------
 // isValidBase64
 // ---------------------------------------------------------------------------
@@ -219,6 +298,23 @@ describe("deleteAttachment", () => {
     expect(fetched).toBeNull();
   });
 
+  test("cleans up on-disk file when deleting", async () => {
+    const conv = createConversation();
+    const msg = await addMessage(conv.id, "assistant", "cleanup");
+    const stored = uploadAttachment("cleanup.txt", "text/plain", "dGVzdA==");
+    linkAttachmentToMessage(msg.id, stored.id, 0);
+    const filePath = getFilePathForAttachment(stored.id);
+    expect(existsSync(filePath!)).toBe(true);
+
+    rawRun(
+      "DELETE FROM message_attachments WHERE attachment_id = ?",
+      stored.id,
+    );
+
+    deleteAttachment(stored.id);
+    expect(existsSync(filePath!)).toBe(false);
+  });
+
   test("returns not_found for nonexistent attachment", () => {
     const result = deleteAttachment("nonexistent-id");
     expect(result).toBe("not_found");
@@ -229,13 +325,9 @@ describe("deleteAttachment", () => {
     const msg1 = await addMessage(conv.id, "user", "First upload");
     const msg2 = await addMessage(conv.id, "user", "Duplicate upload");
 
-    // Dedup: both uploads return the same attachment row
     const first = uploadAttachment("photo.png", "image/png", "SHAREDCONTENT1");
-    const second = uploadAttachment("photo.png", "image/png", "SHAREDCONTENT1");
-    expect(second.id).toBe(first.id);
-
     linkAttachmentToMessage(msg1.id, first.id, 0);
-    linkAttachmentToMessage(msg2.id, second.id, 0);
+    linkAttachmentToMessage(msg2.id, first.id, 0);
 
     // Delete should return still_referenced and NOT remove the attachment row
     const result = deleteAttachment(first.id);
@@ -254,7 +346,7 @@ describe("deleteAttachment", () => {
 
   test("deletes attachment when no messages reference it", () => {
     const stored = uploadAttachment("lonely.txt", "text/plain", "UNREFERENCED");
-    // No linkAttachmentToMessage call — zero references
+    // No linkAttachmentToMessage call -- zero references
     const result = deleteAttachment(stored.id);
     expect(result).toBe("deleted");
 
@@ -270,11 +362,13 @@ describe("deleteAttachment", () => {
 describe("getAttachmentsByIds", () => {
   beforeEach(resetTables);
 
-  test("returns matching attachments with data", () => {
+  test("returns matching attachments with hydrated dataBase64", () => {
     const a = uploadAttachment("a.txt", "text/plain", "AAAA");
     const b = uploadAttachment("b.txt", "text/plain", "BBBB");
 
-    const results = getAttachmentsByIds([a.id, b.id]);
+    const results = getAttachmentsByIds([a.id, b.id], {
+      hydrateFileData: true,
+    });
     expect(results).toHaveLength(2);
     expect(results[0].dataBase64).toBe("AAAA");
     expect(results[1].dataBase64).toBe("BBBB");
@@ -299,9 +393,9 @@ describe("getAttachmentsByIds", () => {
 describe("getAttachmentById", () => {
   beforeEach(resetTables);
 
-  test("returns attachment with data when found", () => {
+  test("returns attachment with hydrated dataBase64 when found", () => {
     const stored = uploadAttachment("report.pdf", "application/pdf", "JVBER");
-    const result = getAttachmentById(stored.id);
+    const result = getAttachmentById(stored.id, { hydrateFileData: true });
 
     expect(result).not.toBeNull();
     expect(result!.id).toBe(stored.id);
@@ -334,6 +428,43 @@ describe("linkAttachmentToMessage + getAttachmentsForMessage", () => {
     expect(linked[0].id).toBe(stored.id);
     expect(linked[0].originalFilename).toBe("chart.png");
     expect(linked[0].dataBase64).toBe("iVBORw0K");
+    expect(getFilePathForAttachment(stored.id)).toContain("/conversations/");
+  });
+
+  test("uses timestamp-first conversation directory and does not recreate a legacy sibling", async () => {
+    const conv = createConversation();
+    const msg = await addMessage(conv.id, "assistant", "Disk view repaired");
+    const canonicalDir = getConversationDirPath(conv.id, conv.createdAt);
+    const legacyDir = getLegacyConversationDirPath(conv.id, conv.createdAt);
+    rmSync(legacyDir, { recursive: true, force: true });
+
+    const stored = uploadAttachment("repaired.png", "image/png", "iVBORw0K");
+    linkAttachmentToMessage(msg.id, stored.id, 0);
+
+    const filePath = getFilePathForAttachment(stored.id);
+    expect(filePath).not.toBeNull();
+    expect(filePath!).toContain(join(canonicalDir, "attachments"));
+    expect(existsSync(filePath!)).toBe(true);
+    expect(existsSync(legacyDir)).toBe(false);
+  });
+
+  test("reuses an existing legacy conversation directory when timestamp-first is absent", async () => {
+    const conv = createConversation();
+    const msg = await addMessage(conv.id, "assistant", "Legacy path");
+    const canonicalDir = getConversationDirPath(conv.id, conv.createdAt);
+    const legacyDir = getLegacyConversationDirPath(conv.id, conv.createdAt);
+
+    rmSync(canonicalDir, { recursive: true, force: true });
+    mkdirSync(legacyDir, { recursive: true });
+
+    const stored = uploadAttachment("legacy.png", "image/png", "iVBORw0K");
+    linkAttachmentToMessage(msg.id, stored.id, 0);
+
+    const filePath = getFilePathForAttachment(stored.id);
+    expect(filePath).not.toBeNull();
+    expect(filePath!).toContain(join(legacyDir, "attachments"));
+    expect(existsSync(filePath!)).toBe(true);
+    expect(existsSync(canonicalDir)).toBe(false);
   });
 
   test("returns attachments in position order", async () => {
@@ -375,6 +506,23 @@ describe("deleteOrphanAttachments", () => {
     expect(removed).toBe(1);
   });
 
+  test("cleans up on-disk files when removing orphaned materialized attachments", async () => {
+    const conv = createConversation();
+    const msg = await addMessage(conv.id, "assistant", "Orphan me");
+    const stored = uploadAttachment("orphan.txt", "text/plain", "ZGF0YQ==");
+    linkAttachmentToMessage(msg.id, stored.id, 0);
+    const filePath = getFilePathForAttachment(stored.id);
+    expect(existsSync(filePath!)).toBe(true);
+
+    rawRun(
+      "DELETE FROM message_attachments WHERE attachment_id = ?",
+      stored.id,
+    );
+
+    deleteOrphanAttachments([stored.id]);
+    expect(existsSync(filePath!)).toBe(false);
+  });
+
   test("preserves attachments that are still linked", async () => {
     const conv = createConversation();
     const msg = await addMessage(conv.id, "assistant", "With attachment");
@@ -500,7 +648,7 @@ describe("validateAttachmentUpload", () => {
   });
 
   test("handles filenames without extensions", () => {
-    // No extension — only MIME check applies
+    // No extension -- only MIME check applies
     expect(validateAttachmentUpload("Makefile", "text/plain").ok).toBe(true);
     expect(validateAttachmentUpload("Makefile", "application/x-evil").ok).toBe(
       false,

package/src/__tests__/attachments.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, test } from "bun:test";
 
-import { attachmentsToContentBlocks } from "../agent/attachments.js";
+import {
+  attachmentsToContentBlocks,
+  enrichMessageWithSourcePaths,
+} from "../agent/attachments.js";
 import { createUserMessage } from "../agent/message-types.js";
 
 // ---------------------------------------------------------------------------
@@ -141,3 +144,114 @@ describe("createUserMessage with image attachments", () => {
     expect(imageBlock.source.type).toBe("base64");
   });
 });
+
+// ---------------------------------------------------------------------------
+// enrichMessageWithSourcePaths
+// ---------------------------------------------------------------------------
+
+describe("enrichMessageWithSourcePaths", () => {
+  test("appends a source path annotation for images with filePath", () => {
+    const attachments = [
+      {
+        filename: "photo.jpg",
+        mimeType: "image/jpeg",
+        data: "base64img",
+        filePath: "/Users/me/Desktop/photo.jpg",
+      },
+    ];
+    const original = createUserMessage("what is this?", attachments);
+    const enriched = enrichMessageWithSourcePaths(original, attachments);
+
+    expect(enriched).not.toBe(original);
+    // Original has text + image = 2 blocks; enriched adds 1 annotation = 3
+    expect(enriched.content).toHaveLength(3);
+    const annotation = enriched.content[2] as { type: "text"; text: string };
+    expect(annotation.type).toBe("text");
+    expect(annotation.text).toBe(
+      "[Attached image source: /Users/me/Desktop/photo.jpg]",
+    );
+  });
+
+  test("returns the original message (same reference) when no images have filePath", () => {
+    const attachments = [
+      {
+        filename: "photo.jpg",
+        mimeType: "image/jpeg",
+        data: "base64img",
+      },
+    ];
+    const original = createUserMessage("what is this?", attachments);
+    const result = enrichMessageWithSourcePaths(original, attachments);
+
+    expect(result).toBe(original);
+  });
+
+  test("skips non-image attachments with filePath", () => {
+    const attachments = [
+      {
+        filename: "doc.pdf",
+        mimeType: "application/pdf",
+        data: "pdfdata",
+        filePath: "/Users/me/Documents/doc.pdf",
+      },
+    ];
+    const original = createUserMessage("review this", attachments);
+    const result = enrichMessageWithSourcePaths(original, attachments);
+
+    // Non-image attachments are not annotated, so we get back the same ref
+    expect(result).toBe(original);
+  });
+
+  test("handles multiple images with file paths", () => {
+    const attachments = [
+      {
+        filename: "a.jpg",
+        mimeType: "image/jpeg",
+        data: "img1",
+        filePath: "/path/to/a.jpg",
+      },
+      {
+        filename: "b.png",
+        mimeType: "image/png",
+        data: "img2",
+        filePath: "/path/to/b.png",
+      },
+    ];
+    const original = createUserMessage("compare", attachments);
+    const enriched = enrichMessageWithSourcePaths(original, attachments);
+
+    expect(enriched).not.toBe(original);
+    // text + 2 images + 1 annotation = 4
+    expect(enriched.content).toHaveLength(4);
+    const annotation = enriched.content[3] as { type: "text"; text: string };
+    expect(annotation.type).toBe("text");
+    expect(annotation.text).toBe(
+      "[Attached image source: /path/to/a.jpg]\n[Attached image source: /path/to/b.png]",
+    );
+  });
+
+  test("only annotates images that have filePath, skips those without", () => {
+    const attachments = [
+      {
+        filename: "a.jpg",
+        mimeType: "image/jpeg",
+        data: "img1",
+        filePath: "/path/to/a.jpg",
+      },
+      {
+        filename: "b.png",
+        mimeType: "image/png",
+        data: "img2",
+        // no filePath — e.g. pasted screenshot
+      },
+    ];
+    const original = createUserMessage("compare", attachments);
+    const enriched = enrichMessageWithSourcePaths(original, attachments);
+
+    expect(enriched).not.toBe(original);
+    // text + 2 images + 1 annotation (only for a.jpg) = 4
+    expect(enriched.content).toHaveLength(4);
+    const annotation = enriched.content[3] as { type: "text"; text: string };
+    expect(annotation.text).toBe("[Attached image source: /path/to/a.jpg]");
+  });
+});

package/src/__tests__/btw-routes.test.ts

@@ -348,6 +348,7 @@ describe("POST /v1/btw", () => {
 
     // Options: tool_choice must be "none"
     expect(options!.config!.tool_choice).toEqual({ type: "none" });
+    expect(options!.config!.modelIntent).toBe("latency-optimized");
   });
 
   // -- No persistence --

package/src/__tests__/canonical-guardian-store.test.ts

@@ -813,6 +813,44 @@ describe("canonical-guardian-store", () => {
     );
   });
 
+  test("expireAllPendingCanonicalRequests expires persistent kinds with past expiresAt", () => {
+    const expiredAccess = createCanonicalGuardianRequest({
+      kind: "access_request",
+      sourceType: "channel",
+      conversationId: "conv-bulk-persist-expired-1",
+      guardianPrincipalId: TEST_PRINCIPAL,
+      expiresAt: Date.now() - 10_000,
+    });
+    const expiredGrant = createCanonicalGuardianRequest({
+      kind: "tool_grant_request",
+      sourceType: "channel",
+      conversationId: "conv-bulk-persist-expired-2",
+      guardianPrincipalId: TEST_PRINCIPAL,
+      expiresAt: Date.now() - 10_000,
+    });
+    // Persistent kind with future expiresAt should NOT be expired
+    const futureAccess = createCanonicalGuardianRequest({
+      kind: "access_request",
+      sourceType: "channel",
+      conversationId: "conv-bulk-persist-expired-3",
+      guardianPrincipalId: TEST_PRINCIPAL,
+      expiresAt: Date.now() + 60_000,
+    });
+
+    const count = expireAllPendingCanonicalRequests();
+    expect(count).toBe(2);
+
+    expect(getCanonicalGuardianRequest(expiredAccess.id)!.status).toBe(
+      "expired",
+    );
+    expect(getCanonicalGuardianRequest(expiredGrant.id)!.status).toBe(
+      "expired",
+    );
+    expect(getCanonicalGuardianRequest(futureAccess.id)!.status).toBe(
+      "pending",
+    );
+  });
+
   test("expireAllPendingCanonicalRequests does not affect already-resolved requests", () => {
     const approved = createCanonicalGuardianRequest({
       kind: "tool_approval",

package/src/__tests__/channel-reply-delivery.test.ts

@@ -365,6 +365,61 @@ describe("channel-reply-delivery", () => {
     expect(deliveryCalls[0].payload.user).toBeUndefined();
   });
 
+  it("suppresses delivery when the only text segment is <no_response/>", async () => {
+    await deliverRenderedReplyViaCallback({
+      callbackUrl: "http://gateway/deliver/slack",
+      chatId: "chat-silent",
+      textSegments: ["<no_response/>"],
+      fallbackText: "Fallback text",
+      interSegmentDelayMs: 0,
+    });
+
+    expect(deliveryCalls).toHaveLength(0);
+  });
+
+  it("suppresses attachment delivery when <no_response/> is present", async () => {
+    await deliverRenderedReplyViaCallback({
+      callbackUrl: "http://gateway/deliver/slack",
+      chatId: "chat-silent-att",
+      textSegments: ["<no_response/>"],
+      attachments: [
+        {
+          id: "att-no-resp",
+          filename: "secret.txt",
+          mimeType: "text/plain",
+          sizeBytes: 10,
+          kind: "uploaded",
+        },
+      ],
+      interSegmentDelayMs: 0,
+    });
+
+    expect(deliveryCalls).toHaveLength(0);
+  });
+
+  it("suppresses delivery for <no_response/> with surrounding whitespace", async () => {
+    await deliverRenderedReplyViaCallback({
+      callbackUrl: "http://gateway/deliver/slack",
+      chatId: "chat-silent-ws",
+      textSegments: ["  <no_response/>  "],
+      interSegmentDelayMs: 0,
+    });
+
+    expect(deliveryCalls).toHaveLength(0);
+  });
+
+  it("delivers other segments when <no_response/> is mixed with real text", async () => {
+    await deliverRenderedReplyViaCallback({
+      callbackUrl: "http://gateway/deliver/slack",
+      chatId: "chat-mixed",
+      textSegments: ["<no_response/>", "Real response."],
+      interSegmentDelayMs: 0,
+    });
+
+    expect(deliveryCalls).toHaveLength(1);
+    expect(deliveryCalls[0].payload.text).toBe("Real response.");
+  });
+
   it("passes startFromSegment through deliverReplyViaCallback options", async () => {
     conversationMessages.push(
       { id: "msg-u", role: "user", content: "hi" },

package/src/__tests__/checker.test.ts

@@ -294,6 +294,28 @@ describe("Permission Checker", () => {
         );
       });
 
+      test("git --no-pager log is low risk (boolean global flag before subcommand)", async () => {
+        expect(
+          await classifyRisk("bash", { command: "git --no-pager log" }),
+        ).toBe(RiskLevel.Low);
+      });
+
+      test("git -C /some/path status is low risk (value-taking flag before subcommand)", async () => {
+        expect(
+          await classifyRisk("bash", {
+            command: "git -C /some/path status",
+          }),
+        ).toBe(RiskLevel.Low);
+      });
+
+      test("git -c core.editor=vim diff is low risk (value-taking -c flag before subcommand)", async () => {
+        expect(
+          await classifyRisk("bash", {
+            command: "git -c core.editor=vim diff",
+          }),
+        ).toBe(RiskLevel.Low);
+      });
+
       test("echo is low risk", async () => {
         expect(await classifyRisk("bash", { command: "echo hello" })).toBe(
           RiskLevel.Low,
@@ -381,6 +403,38 @@ describe("Permission Checker", () => {
         ).toBe(RiskLevel.Medium);
       });
 
+      test("git -C status commit is medium risk (value-taking flag with dir named like a subcommand)", async () => {
+        expect(
+          await classifyRisk("bash", {
+            command: "git -C status commit",
+          }),
+        ).toBe(RiskLevel.Medium);
+      });
+
+      test("git -C /path push is medium risk (value-taking flag before mutating subcommand)", async () => {
+        expect(
+          await classifyRisk("bash", {
+            command: "git -C /path push",
+          }),
+        ).toBe(RiskLevel.Medium);
+      });
+
+      test("git --git-dir /path/to/.git push is medium risk", async () => {
+        expect(
+          await classifyRisk("bash", {
+            command: "git --git-dir /path/to/.git push",
+          }),
+        ).toBe(RiskLevel.Medium);
+      });
+
+      test("git --no-pager push is medium risk (boolean flag before mutating subcommand)", async () => {
+        expect(
+          await classifyRisk("bash", {
+            command: "git --no-pager push",
+          }),
+        ).toBe(RiskLevel.Medium);
+      });
+
       test("opaque construct (eval) is medium risk", async () => {
         expect(await classifyRisk("bash", { command: 'eval "ls"' })).toBe(
           RiskLevel.Medium,

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

@@ -56,6 +56,8 @@ mock.module("../config/loader.js", () => ({
 mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: async (name: string) =>
     name === "anthropic" ? "fake-anthropic-key" : null,
+  getProviderKeyAsync: async (provider: string) =>
+    provider === "anthropic" ? "fake-anthropic-key" : undefined,
 }));
 
 // ---------------------------------------------------------------------------

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

@@ -40,6 +40,8 @@ mock.module("../config/loader.js", () => ({
 mock.module("../security/secure-keys.js", () => ({
   getSecureKeyAsync: async (name: string) =>
     name === "anthropic" ? "fake-anthropic-key" : null,
+  getProviderKeyAsync: async (provider: string) =>
+    provider === "anthropic" ? "fake-anthropic-key" : undefined,
 }));
 
 import { claudeCodeTool } from "../tools/claude-code/claude-code.js";

package/src/__tests__/compaction.benchmark.test.ts

@@ -149,7 +149,8 @@ describe("Compaction benchmark", () => {
     );
     // Target is maxInputTokens * (targetBudgetRatio - summaryBudgetRatio)
     const targetTokens = Math.floor(
-      config.maxInputTokens * (config.targetBudgetRatio - config.summaryBudgetRatio),
+      config.maxInputTokens *
+        (config.targetBudgetRatio - config.summaryBudgetRatio),
     );
     expect(result.estimatedInputTokens).toBeLessThanOrEqual(targetTokens);
   });