@mycadet/assistant 0.12.6-dev.202610072225.d7acd73 → 0.12.6-dev.202610080102.d7d1bec

package/node_modules/@mycadet/egress-proxy/src/__tests__/package-boundary.test.ts

@@ -134,7 +134,7 @@ describe("package boundary", () => {
     const forbidden = [
       "@mycadet/assistant",
       "@mycadet/ces",
-      "@mycadet/cadet-gateway",
+      "@mycadet/gateway",
       "@mycadet/assistant-client",
       "@mycadet/ces-client",
       "@mycadet/ces-contracts",

package/node_modules/@mycadet/gateway-client/src/__tests__/package-boundary.test.ts

@@ -129,7 +129,7 @@ describe("package boundary", () => {
     const forbidden = Object.keys(allDeps).filter((dep) =>
       [
         "@mycadet/assistant",
-        "@mycadet/cadet-gateway",
+        "@mycadet/gateway",
         "@mycadet/credential-storage",
         "@mycadet/egress-proxy",
       ].includes(dep),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mycadet/assistant",
-  "version": "0.12.6-dev.202610072225.d7acd73",
+  "version": "0.12.6-dev.202610080102.d7d1bec",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/attachment-upload-trusted-source.test.ts

@@ -5,12 +5,14 @@
  * carries the x-cadet-principal-type: svc_gateway header (injected by
  * the HTTP adapter from AuthContext).
  */
-import { beforeAll, beforeEach, describe, expect, mock, test } from "bun:test";
-
-mock.module("../config/env.js", () => ({
-  isHttpAuthDisabled: () => true,
-  getAssistantDomain: () => "mycadet.bot",
-}));
+import {
+  afterAll,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "bun:test";
 
 import { initializeDb } from "../persistence/db-init.js";
 import {
@@ -52,9 +54,16 @@ describe("attachment upload — trustedSource flag", () => {
   // initializeDb runs the full migration chain (hundreds of steps); under
   // parallel CI load it can exceed bun's default 5s hook timeout, so allow more.
   beforeAll(async () => {
+    // Real env gate: the route only honors trustedSource when HTTP auth is
+    // disabled (the gateway-fronted deployment posture).
+    process.env.DISABLE_HTTP_AUTH = "true";
     await initializeDb();
   }, 30_000);
 
+  afterAll(() => {
+    delete process.env.DISABLE_HTTP_AUTH;
+  });
+
   beforeEach(() => {
     // Each test uploads a fresh attachment with unique filename; no per-test
     // cleanup needed since the staging directory is recreated lazily.

package/src/__tests__/conversation-delete-watch-timeline.test.ts

@@ -10,7 +10,7 @@
  * `conversations` is emptied: an append that beat it is a row it deletes, and
  * one that follows it has no conversation to key itself to.
  */
-import { describe, expect, mock, test } from "bun:test";
+import { beforeAll, describe, expect, mock, spyOn, test } from "bun:test";
 
 // Keep the rest of the module real; only the Qdrant collection drop is
 // replaced, so `clearAll` does not reach for a lexical index that is not
@@ -34,34 +34,16 @@ mock.module("../persistence/job-handlers/message-lexical.js", () => ({
 let appendDuringWipe: { onStatement: string; run: () => void } | null = null;
 
 // Every bulk delete in `clearAll` goes through `runAsyncSqlite`, which spawns
-// a sqlite3 subprocess and yields the event loop. The wrapper runs the real
-// statement and stands in for whatever else the daemon would have done while
-// it was in flight.
-const actualAsyncQuery = await import("../persistence/db-async-query.js");
-const realRunAsyncSqlite = actualAsyncQuery.runAsyncSqlite;
-mock.module("../persistence/db-async-query.js", () => ({
-  ...actualAsyncQuery,
-  runAsyncSqlite: async (
-    sql: string,
-    label: string,
-    options?: Parameters<typeof actualAsyncQuery.runAsyncSqlite>[2],
-  ) => {
-    const result = await realRunAsyncSqlite(sql, label, options);
-    if (appendDuringWipe && appendDuringWipe.onStatement === sql) {
-      const pending = appendDuringWipe;
-      appendDuringWipe = null;
-      pending.run();
-    }
-    return result;
-  },
-}));
-
+// a sqlite3 subprocess and yields the event loop. A pass-through spy on the
+// live module namespace lets the real subprocess run while the race hook below
+// schedules an append onto the statement it is keyed to.
 import {
   clearAll,
   createConversation,
   deleteConversation,
   deleteConversationGently,
 } from "../persistence/conversation-crud.js";
+import * as dbAsyncQuery from "../persistence/db-async-query.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { attachments } from "../persistence/schema/conversations.js";
@@ -73,7 +55,25 @@ import {
   renderWatchTimeline,
 } from "../watch/watch-timeline.js";
 
-await initializeDb();
+beforeAll(async () => {
+  await initializeDb();
+  const realRunAsyncSqlite = dbAsyncQuery.runAsyncSqlite;
+  spyOn(dbAsyncQuery, "runAsyncSqlite").mockImplementation(
+    async (
+      sql: string,
+      label: string,
+      options?: Parameters<typeof realRunAsyncSqlite>[2],
+    ) => {
+      const result = await realRunAsyncSqlite(sql, label, options);
+      if (appendDuringWipe && appendDuringWipe.onStatement === sql) {
+        const pending = appendDuringWipe;
+        appendDuringWipe = null;
+        pending.run();
+      }
+      return result;
+    },
+  );
+});
 
 /** A 1x1 JPEG, the shape the host hands over on every observe. */
 const SCREENSHOT_BASE64 =

package/src/__tests__/conversation-retry-discard.test.ts

@@ -253,8 +253,10 @@ describe("discardLastAssistantDisplayTurn keeps the memory-retrospective cursor
 
     expect(getMessages(CONV_ID).some((m) => m.id === assistantId)).toBe(false);
     // The hook chain is fire-and-forget from the delete primitive, so the
-    // stamp lands shortly after the discard returns.
-    const deadline = Date.now() + 2_000;
+    // stamp lands shortly after the discard returns — but hook discovery is
+    // async and unbounded under CI's 8-workers-on-2-cores contention, so the
+    // budget needs CI headroom (same family as message-deleted-hook-dispatch).
+    const deadline = Date.now() + 10_000;
     let stamped =
       getRetrospectiveState(CONV_ID)?.lastProcessedCreatedAt ?? null;
     while (stamped === null && Date.now() < deadline) {

package/src/__tests__/conversation-unread-route.test.ts

@@ -1,19 +1,12 @@
-import { afterAll, beforeEach, describe, expect, mock, test } from "bun:test";
-
-process.env.DISABLE_HTTP_AUTH = "true";
-
-const mockMarkConversationUnread = mock((_conversationId: string) => true);
-
-mock.module("../persistence/conversation-attention-store.js", () => ({
-  getAttentionStateByConversationIds: () => new Map(),
-  recordConversationSeenSignal: () => ({}),
-  markConversationUnread: mockMarkConversationUnread,
-}));
-
-mock.module("../persistence/conversation-key-store.js", () => ({
-  resolveConversationId: (id: string) => id,
-}));
-
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+
+import { getAttentionStateByConversationIds } from "../persistence/conversation-attention-store.js";
+import {
+  addMessage,
+  ensureConversationExists,
+} from "../persistence/conversation-crud.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { RuntimeHttpServer } from "../runtime/http-server.js";
 import { ROUTES } from "../runtime/routes/index.js";
 
 /**
@@ -27,18 +20,20 @@ function routePolicy(endpoint: string, method?: string) {
   );
   return route?.policy ?? null;
 }
-import { RuntimeHttpServer } from "../runtime/http-server.js";
-import { UserError } from "../util/errors.js";
 
 describe("POST /v1/conversations/unread", () => {
   let server: RuntimeHttpServer;
   let port: number;
 
-  beforeEach(() => {
-    mockMarkConversationUnread.mockClear();
+  beforeAll(async () => {
+    await initializeDb();
+    // The HTTP adapter only serves unauthenticated local requests when HTTP
+    // auth is disabled (the gateway-fronted deployment posture).
+    process.env.DISABLE_HTTP_AUTH = "true";
   });
 
   afterAll(async () => {
+    delete process.env.DISABLE_HTTP_AUTH;
     await server?.stop();
   });
 
@@ -79,12 +74,14 @@ describe("POST /v1/conversations/unread", () => {
         message: "Missing conversationId",
       },
     });
-    expect(mockMarkConversationUnread).not.toHaveBeenCalled();
 
     await stopServer();
   });
 
   test("marks a conversation unread", async () => {
+    ensureConversationExists("conv-123", "telegram");
+    addMessage("conv-123", "assistant", "the only assistant reply");
+
     await startServer();
 
     const res = await fetch(unreadUrl(), {
@@ -95,18 +92,22 @@ describe("POST /v1/conversations/unread", () => {
 
     expect(res.status).toBe(200);
     expect(await res.json()).toEqual({ ok: true });
-    expect(mockMarkConversationUnread).toHaveBeenCalledTimes(1);
-    expect(mockMarkConversationUnread).toHaveBeenCalledWith("conv-123");
+
+    // Unread = seen cursor behind the latest assistant message. With a single
+    // assistant message there is no previous one, so the seen cursor is null.
+    const state = getAttentionStateByConversationIds(["conv-123"]).get(
+      "conv-123",
+    );
+    expect(state?.latestAssistantMessageId).not.toBeNull();
+    expect(state?.lastSeenAssistantMessageId).toBeNull();
 
     await stopServer();
   });
 
   test("returns UNPROCESSABLE_ENTITY when the conversation has no assistant message", async () => {
-    mockMarkConversationUnread.mockImplementationOnce(() => {
-      throw new UserError(
-        "Conversation has no assistant message to mark unread",
-      );
-    });
+    // Real store semantics: no assistant message means no cursor to mark
+    // unread against, and markConversationUnread throws this exact UserError.
+    ensureConversationExists("conv-no-assistant", "telegram");
 
     await startServer();
 

package/src/__tests__/empty-state-greeting-cache.test.ts

@@ -6,31 +6,32 @@
  * behavior that disables caching entirely.
  */
 
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
-
-// ---------------------------------------------------------------------------
-// Mocks — defined before importing the module under test
-// ---------------------------------------------------------------------------
-
-const checkpointStore = new Map<string, string>();
-
-mock.module("../persistence/checkpoints.js", () => ({
-  getMemoryCheckpoint: (key: string) => checkpointStore.get(key) ?? null,
-  setMemoryCheckpoint: (key: string, value: string) => {
-    checkpointStore.set(key, value);
-  },
-}));
-
-// ---------------------------------------------------------------------------
-// Imports (after mocks)
-// ---------------------------------------------------------------------------
+import {
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  test,
+} from "bun:test";
 
+import {
+  getMemoryCheckpoint,
+  setMemoryCheckpoint,
+} from "../persistence/checkpoints.js";
+import { getSqlite } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
 import {
   getCachedEmptyStateGreeting,
   setCachedEmptyStateGreeting,
 } from "../runtime/routes/empty-state-greeting-cache.js";
 import { setConfig } from "./helpers/set-config.js";
 
+// The checkpoint store is real: rows live in the per-process workspace DB.
+beforeAll(async () => {
+  await initializeDb();
+});
+
 /** Seed the cache TTL into the real workspace config. */
 function setCacheTtlMs(ttlMs: number): void {
   setConfig("ui", { emptyStateGreetingCacheTtlMs: ttlMs });
@@ -43,7 +44,7 @@ beforeEach(() => {
 });
 
 afterEach(() => {
-  checkpointStore.clear();
+  getSqlite().run("DELETE FROM memory_checkpoints");
 });
 
 describe("empty-state greeting cache", () => {
@@ -67,7 +68,7 @@ describe("empty-state greeting cache", () => {
 
   test("returns null once the TTL is exceeded", () => {
     setCachedEmptyStateGreeting("stale");
-    checkpointStore.set(
+    setMemoryCheckpoint(
       TIMESTAMP_KEY,
       String(Date.now() - (4 * 60 + 1) * 60 * 1000),
     );
@@ -76,7 +77,7 @@ describe("empty-state greeting cache", () => {
 
   test("returns the cached value just within the TTL", () => {
     setCachedEmptyStateGreeting("fresh enough");
-    checkpointStore.set(
+    setMemoryCheckpoint(
       TIMESTAMP_KEY,
       String(Date.now() - (3 * 60 + 59) * 60 * 1000),
     );
@@ -86,7 +87,7 @@ describe("empty-state greeting cache", () => {
   test("TTL of 0 disables caching: writes are skipped and reads miss", () => {
     setCacheTtlMs(0);
     setCachedEmptyStateGreeting("should not persist");
-    expect(checkpointStore.size).toBe(0);
+    expect(getMemoryCheckpoint(TIMESTAMP_KEY)).toBeNull();
     expect(getCachedEmptyStateGreeting()).toBeNull();
   });
 
@@ -97,7 +98,7 @@ describe("empty-state greeting cache", () => {
   });
 
   test("returns null when the timestamp checkpoint is missing", () => {
-    checkpointStore.set("empty_state:greeting:text", "orphaned");
+    setMemoryCheckpoint("empty_state:greeting:text", "orphaned");
     expect(getCachedEmptyStateGreeting()).toBeNull();
   });
 });

package/src/__tests__/interrupt-on-send.test.ts

@@ -8,8 +8,21 @@
  * queue), and what the repaired history looks like.
  */
 import { readFileSync } from "node:fs";
-import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import {
+  afterEach,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  spyOn,
+  test,
+} from "bun:test";
 
+import {
+  clearCachedOverrides,
+  setCachedOverrides,
+} from "../config/feature-flag-cache.js";
+import { INTERRUPT_ON_SEND_FLAG_KEY } from "../config/interrupt-on-send-flag.js";
 import type { Conversation } from "../daemon/conversation.js";
 import {
   deleteConversation,
@@ -26,37 +39,18 @@ import {
 } from "../util/abort-reasons.js";
 
 // ---------------------------------------------------------------------------
-// Mocks must precede the module imports so Bun applies them at load time.
+// Real persistence, observed. The repair writes land in the per-process
+// workspace DB; a pass-through spy on the live module namespace records each
+// call so the timing/failure scaffolding below still works.
 // ---------------------------------------------------------------------------
 
-let flagEnabled = true;
-mock.module("../config/interrupt-on-send-gate.js", () => ({
-  isInterruptOnSendEnabled: () => flagEnabled,
-}));
-
 const persisted: Array<{ role: string; content: string }> = [];
 let persistGate: Promise<void> = Promise.resolve();
 let persistShouldFail = false;
 
-// Only the persist seam is replaced; every other CRUD export stays real so the
-// repair module's import graph resolves as it does in production.
-const realConversationCrud =
-  await import("../persistence/conversation-crud.js");
-mock.module("../persistence/conversation-crud.js", () => ({
-  ...realConversationCrud,
-  addMessage: async (
-    _conversationId: string,
-    role: string,
-    content: string,
-  ) => {
-    await persistGate;
-    if (persistShouldFail) {
-      throw new Error("simulated persist failure");
-    }
-    persisted.push({ role, content });
-    return { id: `msg-${persisted.length}` };
-  },
-}));
+import * as conversationCrud from "../persistence/conversation-crud.js";
+import { ensureConversationExists } from "../persistence/conversation-crud.js";
+import { initializeDb } from "../persistence/db-init.js";
 
 const {
   classifyInterruptEligibility,
@@ -79,6 +73,23 @@ const {
 
 const CONV = "interrupt-on-send-conv";
 
+beforeAll(async () => {
+  await initializeDb();
+  ensureConversationExists(CONV, "telegram");
+  const realAddMessage = conversationCrud.addMessage;
+  spyOn(conversationCrud, "addMessage").mockImplementation(
+    async (...args: Parameters<typeof realAddMessage>) => {
+      await persistGate;
+      if (persistShouldFail) {
+        throw new Error("simulated persist failure");
+      }
+      const result = await realAddMessage(...args);
+      persisted.push({ role: args[1], content: args[2] });
+      return result;
+    },
+  );
+});
+
 const assistantWithToolUse = (...ids: string[]): Message => ({
   role: "assistant",
   content: ids.map((id) => ({
@@ -276,7 +287,12 @@ function registerBusyTurn(
 }
 
 beforeEach(() => {
-  flagEnabled = true;
+  setCachedOverrides(
+    { [INTERRUPT_ON_SEND_FLAG_KEY]: true },
+    {
+      fromGateway: false,
+    },
+  );
   persisted.length = 0;
   persistGate = Promise.resolve();
   persistShouldFail = false;
@@ -288,10 +304,9 @@ afterEach(() => {
   deleteConversation(CONV);
   pendingInteractions.clear();
   resetTurnFinalizationsForTesting();
-  // `mock.module` is process-wide, so this stub outlives the file. Leave it
-  // reading off, which is the flag's shipped state, so a later file's
-  // flag-off expectations are not answered by this file's last setting.
-  flagEnabled = false;
+  // Drop the override so the flag reads its shipped (off) state — a later
+  // file's flag-off expectations must not be answered by this file's setting.
+  clearCachedOverrides();
 });
 
 describe("interruptRunningTurn", () => {
@@ -496,7 +511,12 @@ describe("interruptRunningTurn", () => {
   });
 
   test("declines when the flag is off, touching nothing", async () => {
-    flagEnabled = false;
+    setCachedOverrides(
+      { [INTERRUPT_ON_SEND_FLAG_KEY]: false },
+      {
+        fromGateway: false,
+      },
+    );
     const turn = registerBusyTurn({
       messages: [assistantWithToolUse("tool-1")],
     });
@@ -787,7 +807,12 @@ describe("classifyInterruptEligibility", () => {
   });
 
   test("names the flag when it is off", () => {
-    flagEnabled = false;
+    setCachedOverrides(
+      { [INTERRUPT_ON_SEND_FLAG_KEY]: false },
+      {
+        fromGateway: false,
+      },
+    );
     const turn = registerBusyTurn();
     expect(classifyInterruptEligibility(turn.conversation, opts)).toBe(
       "flag_off",

package/src/__tests__/llm-schema.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
+import { ModelPricingOverrideSchema } from "../config/schemas/inference.js";
 import { LLMConfigBase, LLMSchema } from "../config/schemas/llm.js";
 
 // A legacy `llm.default` blob as older configs persisted it. The schema has
@@ -391,3 +392,74 @@ describe("LLMSchema", () => {
     });
   });
 });
+
+// `llm.pricingOverrides` entries are validated by `PricingOverrideSchema`
+// inside `LLMSchema`, while `ModelPricingOverrideSchema` types the same entries
+// for consumers such as `resolvePricingForUsageWithOverrides`. Both shapes are
+// asserted here so they stay in step.
+describe("pricing override cache rates", () => {
+  const baseOverride = {
+    provider: "openai-compatible",
+    modelPattern: "claude-opus-4-6",
+    inputPer1M: 10,
+    outputPer1M: 20,
+  };
+
+  test("LLMSchema keeps optional cache rates on a pricing override", () => {
+    const parsed = LLMSchema.parse({
+      pricingOverrides: [
+        { ...baseOverride, cacheReadPer1M: 1, cacheWritePer1M: 12.5 },
+      ],
+    });
+    expect(parsed.pricingOverrides[0]).toEqual({
+      ...baseOverride,
+      cacheReadPer1M: 1,
+      cacheWritePer1M: 12.5,
+    });
+  });
+
+  test("LLMSchema accepts a pricing override that omits cache rates", () => {
+    const parsed = LLMSchema.parse({ pricingOverrides: [baseOverride] });
+    expect(parsed.pricingOverrides[0]).toEqual(baseOverride);
+  });
+
+  test.each(["cacheReadPer1M", "cacheWritePer1M"] as const)(
+    "LLMSchema rejects a negative %s",
+    (field) => {
+      const result = LLMSchema.safeParse({
+        pricingOverrides: [{ ...baseOverride, [field]: -1 }],
+      });
+      expect(result.success).toBe(false);
+    },
+  );
+
+  test("ModelPricingOverrideSchema parses optional cache rates", () => {
+    const parsed = ModelPricingOverrideSchema.parse({
+      ...baseOverride,
+      cacheReadPer1M: 1,
+      cacheWritePer1M: 12.5,
+    });
+    expect(parsed.cacheReadPer1M).toBe(1);
+    expect(parsed.cacheWritePer1M).toBe(12.5);
+  });
+
+  test("ModelPricingOverrideSchema leaves cache rates undefined when omitted", () => {
+    const parsed = ModelPricingOverrideSchema.parse(baseOverride);
+    expect(parsed.cacheReadPer1M).toBeUndefined();
+    expect(parsed.cacheWritePer1M).toBeUndefined();
+  });
+
+  test.each([
+    ["cacheReadPer1M", "pricingOverrides[].cacheReadPer1M"],
+    ["cacheWritePer1M", "pricingOverrides[].cacheWritePer1M"],
+  ])("ModelPricingOverrideSchema rejects a negative %s", (field, label) => {
+    const result = ModelPricingOverrideSchema.safeParse({
+      ...baseOverride,
+      [field]: -1,
+    });
+    expect(result.success).toBe(false);
+    expect(result.error?.issues[0]?.message).toBe(
+      `${label} must be a non-negative number`,
+    );
+  });
+});

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

@@ -8,8 +8,17 @@ import {
 } from "node:fs";
 import { tmpdir } from "node:os";
 import { join, sep } from "node:path";
-import { afterEach, describe, expect, mock, test } from "bun:test";
+import { afterEach, describe, expect, test } from "bun:test";
 
+import { getBundledSkillsDir } from "../config/skills.js";
+import {
+  getBundledSkillsRoot,
+  getManagedSkillsRoot,
+  getSkillRoots,
+  isSkillSourcePath,
+  normalizeDirPath,
+  normalizeFilePath,
+} from "../skills/path-classifier.js";
 import {
   hostPolicy,
   resolveRealPath,
@@ -17,30 +26,13 @@ import {
   sandboxPolicyWithHostFallback,
   sandboxReadPolicy,
 } from "../tools/shared/filesystem/path-policy.js";
-import { getDotEnvPath } from "../util/platform.js";
-
-// ── Mock setup for skill path classifier ────────────────────────────────────
-// The classifier imports getWorkspaceSkillsDir and getBundledSkillsDir, which
-// need stable test directories to avoid depending on the real home directory.
-// We create and realpath the root eagerly so that macOS's /tmp -> /private/tmp
-// symlink doesn't cause prefix mismatches between normalized roots and paths.
+import { getDotEnvPath, getWorkspaceSkillsDir } from "../util/platform.js";
 
-const CLASSIFIER_TEST_ROOT = process.env.CADET_WORKSPACE_DIR!;
-const MOCK_MANAGED_DIR = join(CLASSIFIER_TEST_ROOT, "skills");
-const MOCK_BUNDLED_DIR = join(CLASSIFIER_TEST_ROOT, "bundled-skills");
-
-mock.module("../config/skills.js", () => ({
-  getBundledSkillsDir: () => MOCK_BUNDLED_DIR,
-}));
-
-const {
-  isSkillSourcePath,
-  normalizeDirPath,
-  normalizeFilePath,
-  getSkillRoots,
-  getManagedSkillsRoot,
-  getBundledSkillsRoot,
-} = await import("../skills/path-classifier.js");
+// The classifier reads REAL roots: managed = the per-process workspace skills
+// dir (writable, from the test preload), bundled = the repo's bundled-skills
+// dir (read-only — tests only classify existing paths under it).
+const MOCK_MANAGED_DIR = getWorkspaceSkillsDir();
+const MOCK_BUNDLED_DIR = getBundledSkillsDir();
 
 const testDirs: string[] = [];
 
@@ -360,12 +352,7 @@ describe("sandboxPolicyWithHostFallback", () => {
     const boundary = makeTempDir();
 
     const result = sandboxPolicyWithHostFallback(
-      join(
-        process.env.HOME!,
-        ".cadet",
-        "protected",
-        "actor-token-signing-key",
-      ),
+      join(process.env.HOME!, ".cadet", "protected", "actor-token-signing-key"),
       boundary,
       { mustExist: false },
     );
@@ -882,8 +869,8 @@ describe("isSkillSourcePath", () => {
   });
 
   test("returns true for path inside bundled skills dir", () => {
-    mkdirSync(MOCK_BUNDLED_DIR, { recursive: true });
-    const filePath = join(MOCK_BUNDLED_DIR, "web-search", "SKILL.md");
+    // The real bundled dir ships skills — classify one instead of creating it.
+    const filePath = join(MOCK_BUNDLED_DIR, "acp", "SKILL.md");
     expect(isSkillSourcePath(filePath)).toBe(true);
   });