@vellumai/assistant 0.8.4 → 0.8.6

package/src/__tests__/secret-ingress-http.test.ts

@@ -106,6 +106,7 @@ mock.module("../memory/conversation-crud.js", () => ({
   provenanceFromTrustContext: () => undefined,
   setConversationOriginChannelIfUnset: () => {},
   setConversationOriginInterfaceIfUnset: () => {},
+  reserveMessage: mock(async () => ({ id: "msg-reserve" })),
 }));
 
 mock.module("../runtime/local-actor-identity.js", () => ({
@@ -187,7 +188,10 @@ function makeRequest(
   });
 }
 
-const persistUserMessageMock = mock(async () => "persisted-id");
+const persistUserMessageMock = mock(async () => ({
+  id: "persisted-id",
+  deduplicated: false,
+}));
 const runAgentLoopMock = mock(async () => undefined);
 
 function makeSendMessageDeps() {

package/src/__tests__/secure-keys.test.ts

@@ -25,7 +25,6 @@ mock.module("../util/logger.js", () => ({
 
 import type { CesClient } from "../credential-execution/client.js";
 import * as encryptedStore from "../security/encrypted-store.js";
-import { _setStorePath } from "../security/encrypted-store.js";
 import {
   _resetBackend,
   deleteSecureKeyAsync,
@@ -36,6 +35,7 @@ import {
   setCesReconnect,
   setSecureKeyAsync,
 } from "../security/secure-keys.js";
+import { setStorePathForTesting } from "./encrypted-store-test-helpers.js";
 
 // ---------------------------------------------------------------------------
 // Use a temp directory for encrypted store tests
@@ -59,11 +59,11 @@ describe("secure-keys", () => {
       rmSync(TEST_DIR, { recursive: true });
     }
     mkdirSync(TEST_DIR, { recursive: true });
-    _setStorePath(STORE_PATH);
+    setStorePathForTesting(STORE_PATH);
   });
 
   afterEach(() => {
-    _setStorePath(null);
+    setStorePathForTesting(null);
     _resetBackend();
     delete process.env.VELLUM_DEV;
     delete process.env.VELLUM_DESKTOP_APP;

package/src/__tests__/send-endpoint-busy.test.ts

@@ -136,13 +136,9 @@ function makeCompletingConversation(): Conversation {
   const messages: unknown[] = [];
   return {
     isProcessing: () => processing,
-    persistUserMessage: (
-      _content: string,
-      _attachments: unknown[],
-      requestId?: string,
-    ) => {
+    persistUserMessage: (options: { requestId?: string }) => {
       processing = true;
-      return requestId ?? "msg-1";
+      return { id: options.requestId ?? "msg-1", deduplicated: false };
     },
     memoryPolicy: {
       scopeId: "default",
@@ -188,18 +184,14 @@ function makeHangingConversation(): Conversation {
   const messages: unknown[] = [];
   const enqueuedMessages: Array<{
     content: string;
-    onEvent: (msg: ServerMessage) => void;
-    requestId: string;
+    onEvent?: (msg: ServerMessage) => void;
+    requestId?: string;
   }> = [];
   return {
     isProcessing: () => processing,
-    persistUserMessage: (
-      _content: string,
-      _attachments: unknown[],
-      requestId?: string,
-    ) => {
+    persistUserMessage: (options: { requestId?: string }) => {
       processing = true;
-      return requestId ?? "msg-1";
+      return { id: options.requestId ?? "msg-1", deduplicated: false };
     },
     memoryPolicy: {
       scopeId: "default",
@@ -223,14 +215,20 @@ function makeHangingConversation(): Conversation {
     hasPendingConfirmation: () => false,
     denyAllPendingConfirmations: () => {},
     getQueueDepth: () => enqueuedMessages.length,
-    enqueueMessage: (
-      content: string,
-      _attachments: unknown[],
-      onEvent: (msg: ServerMessage) => void,
-      requestId: string,
-    ) => {
-      enqueuedMessages.push({ content, onEvent, requestId });
-      return { queued: true, requestId };
+    enqueueMessage: (options: {
+      content: string;
+      onEvent?: (msg: ServerMessage) => void;
+      requestId?: string;
+    }) => {
+      enqueuedMessages.push({
+        content: options.content,
+        onEvent: options.onEvent,
+        requestId: options.requestId,
+      });
+      return {
+        queued: true,
+        requestId: options.requestId ?? "hanging-req",
+      };
     },
     runAgentLoop: async () => {
       // Hang forever
@@ -259,14 +257,9 @@ function makePendingApprovalConversation(
   const messages: unknown[] = [];
   const runAgentLoopMock = mock(async () => {});
   const enqueueMessageMock = mock(
-    (
-      _content: string,
-      _attachments: unknown[],
-      _onEvent: (msg: ServerMessage) => void,
-      queuedRequestId: string,
-    ) => ({
+    (options: { content: string; requestId?: string }) => ({
       queued: true,
-      requestId: queuedRequestId,
+      requestId: options.requestId ?? "queued-req",
     }),
   );
   const denyAllPendingConfirmationsMock = mock(() => {
@@ -278,11 +271,10 @@ function makePendingApprovalConversation(
 
   const conversation = {
     isProcessing: () => processing,
-    persistUserMessage: (
-      _content: string,
-      _attachments: unknown[],
-      reqId?: string,
-    ) => reqId ?? "msg-1",
+    persistUserMessage: (options: { requestId?: string }) => ({
+      id: options.requestId ?? "msg-1",
+      deduplicated: false,
+    }),
     memoryPolicy: {
       scopeId: "default",
       includeDefaultFallback: false,
@@ -895,7 +887,7 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
     await stopServer();
   });
 
-  test("accepts message when conversationKey is omitted (defaults to stable channel key)", async () => {
+  test("accepts message when conversationKey is omitted (vellum channel mints fresh)", async () => {
     await startServer(() => makeCompletingConversation());
 
     const res = await fetch(messagesUrl(), {
@@ -908,14 +900,24 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
       }),
     });
     expect(res.status).toBe(202);
+    const body = (await res.json()) as {
+      accepted: boolean;
+      conversationId: string;
+    };
+    expect(body.accepted).toBe(true);
+    expect(body.conversationId).toBeTruthy();
+
+    // The vellum channel never falls through to the shared
+    // `default:vellum:<interface>` thread: each empty-handed send mints
+    // a fresh conversation so the first-message id surfaces to the client.
+    expect(getConversationByKey("default:vellum:macos")).toBeNull();
 
     await stopServer();
   });
 
-  test("two calls without conversationKey use the same conversation", async () => {
+  test("two empty-handed vellum sends each mint distinct conversations", async () => {
     await startServer(() => makeCompletingConversation());
 
-    // First message — no conversationKey
     const res1 = await fetch(messagesUrl(), {
       method: "POST",
       headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
@@ -926,8 +928,8 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
       }),
     });
     expect(res1.status).toBe(202);
+    const body1 = (await res1.json()) as { conversationId: string };
 
-    // Second message — same channel/interface, still no conversationKey
     const res2 = await fetch(messagesUrl(), {
       method: "POST",
       headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
@@ -938,12 +940,49 @@ describe("POST /v1/messages — queue-if-busy and hub publishing", () => {
       }),
     });
     expect(res2.status).toBe(202);
+    const body2 = (await res2.json()) as { conversationId: string };
+
+    expect(body1.conversationId).toBeTruthy();
+    expect(body2.conversationId).toBeTruthy();
+    expect(body1.conversationId).not.toBe(body2.conversationId);
+
+    await stopServer();
+  });
+
+  test("two empty-handed phone sends share the default channel thread", async () => {
+    await startServer(() => makeCompletingConversation());
+
+    const res1 = await fetch(messagesUrl(), {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
+      body: JSON.stringify({
+        content: "First",
+        sourceChannel: "phone",
+        interface: "phone",
+      }),
+    });
+    expect(res1.status).toBe(202);
+    const body1 = (await res1.json()) as { conversationId: string };
+
+    const res2 = await fetch(messagesUrl(), {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...AUTH_HEADERS },
+      body: JSON.stringify({
+        content: "Second",
+        sourceChannel: "phone",
+        interface: "phone",
+      }),
+    });
+    expect(res2.status).toBe(202);
+    const body2 = (await res2.json()) as { conversationId: string };
 
-    // Both should have resolved to the same default conversation key
-    // ("default:vellum:macos"), which maps to the same conversationId.
-    const mapping = getConversationByKey("default:vellum:macos");
+    // Non-vellum channels keep the legacy `default:<channel>:<interface>`
+    // co-location so repeated inbound messages from the same external
+    // channel/interface land on a single thread.
+    expect(body1.conversationId).toBe(body2.conversationId);
+    const mapping = getConversationByKey("default:phone:phone");
     expect(mapping).not.toBeNull();
-    expect(mapping!.conversationId).toBeTruthy();
+    expect(mapping!.conversationId).toBe(body1.conversationId);
 
     await stopServer();
   });

package/src/__tests__/server-history-render.test.ts

@@ -578,7 +578,10 @@ describe("getAttachmentsForMessage", () => {
     db.run("DELETE FROM conversations");
   });
 
-  async function createMessage(role: string, content: string): Promise<string> {
+  async function createMessage(
+    role: "user" | "assistant" | "system",
+    content: string,
+  ): Promise<string> {
     const conv = createConversation("test");
     const msg = await addMessage(conv.id, role, content);
     return msg.id;

package/src/__tests__/shell-tool-proxy-mode.test.ts

@@ -287,7 +287,7 @@ describe("shell tool proxy mode", () => {
   });
 
   test("schema includes network_mode and credential_ids", () => {
-    const def = shellTool.getDefinition();
+    const def = shellTool;
     const props = (def.input_schema as { properties: Record<string, unknown> })
       .properties;
     expect(props.network_mode).toBeDefined();

package/src/__tests__/skill-feature-flags-integration.test.ts

@@ -7,17 +7,15 @@
  */
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import {
-  _setOverridesForTesting,
-  isAssistantFeatureFlagEnabled,
-} from "../config/assistant-feature-flags.js";
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 beforeEach(() => {
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
 afterEach(() => {
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 import type { AssistantConfig } from "../config/schema.js";
 import { resolveSkillStates, skillFlagKey } from "../config/skill-state.js";
@@ -150,7 +148,7 @@ describe("frontmatter feature-flag integration", () => {
   });
 
   test("resolveSkillStates includes skill with featureFlag when flag is ON", () => {
-    _setOverridesForTesting({
+    setOverridesForTesting({
       "email-channel": true,
     });
     const skill = buildSkillSummary("email-setup", SKILL_MD_WITH_FLAG)!;
@@ -174,7 +172,7 @@ describe("frontmatter feature-flag integration", () => {
   test("resolveSkillStates never gates skill without featureFlag", () => {
     const skill = buildSkillSummary("plain-skill", SKILL_MD_WITHOUT_FLAG)!;
     // Even with an explicit false override for this skill ID, it should pass through
-    _setOverridesForTesting({
+    setOverridesForTesting({
       "plain-skill": false,
     });
     const config = makeConfig();
@@ -210,7 +208,7 @@ describe("frontmatter feature-flag integration", () => {
     expect(resolvedDefault.length).toBe(0);
 
     // Step 6: With override enabled, skill passes through
-    _setOverridesForTesting({ [key!]: true });
+    setOverridesForTesting({ [key!]: true });
     const configOn = makeConfig();
     expect(isAssistantFeatureFlagEnabled(key!, configOn)).toBe(true);
 
@@ -219,7 +217,7 @@ describe("frontmatter feature-flag integration", () => {
     expect(resolvedOn[0].summary.id).toBe("email-setup");
 
     // Step 7: With override disabled, skill is filtered out
-    _setOverridesForTesting({ [key!]: false });
+    setOverridesForTesting({ [key!]: false });
     const configOff = makeConfig();
     expect(isAssistantFeatureFlagEnabled(key!, configOff)).toBe(false);
 

package/src/__tests__/skill-feature-flags.test.ts

@@ -1,19 +1,17 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
-import {
-  _setOverridesForTesting,
-  isAssistantFeatureFlagEnabled,
-} from "../config/assistant-feature-flags.js";
+import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags.js";
 import type { AssistantConfig } from "../config/schema.js";
 import { resolveSkillStates, skillFlagKey } from "../config/skill-state.js";
 import type { SkillSummary } from "../config/skills.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 beforeEach(() => {
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
 afterEach(() => {
-  _setOverridesForTesting({});
+  setOverridesForTesting({});
 });
 
 const DECLARED_FLAG_ID = "email-channel";
@@ -103,7 +101,7 @@ describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
   });
 
   test("returns true when skill key is explicitly true", () => {
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
     const config = makeConfig();
     expect(
       isAssistantFeatureFlagEnabled(
@@ -114,7 +112,7 @@ describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
   });
 
   test("returns false when skill key is explicitly false", () => {
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
     const config = makeConfig();
     expect(
       isAssistantFeatureFlagEnabled(
@@ -130,13 +128,13 @@ describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
 // ---------------------------------------------------------------------------
 
 describe("isAssistantFeatureFlagEnabled", () => {
-  test("returns true for unknown flags (open by default)", () => {
+  test("returns false for unknown flags (closed by default)", () => {
     const config = makeConfig();
-    expect(isAssistantFeatureFlagEnabled("unknown", config)).toBe(true);
+    expect(isAssistantFeatureFlagEnabled("unknown", config)).toBe(false);
   });
 
   test("file-based override overrides registry default", () => {
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
     const config = makeConfig();
     expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(
       false,
@@ -152,7 +150,7 @@ describe("isAssistantFeatureFlagEnabled", () => {
   });
 
   test("respects persisted overrides for undeclared keys", () => {
-    _setOverridesForTesting({ "some-undeclared-flag": false });
+    setOverridesForTesting({ "some-undeclared-flag": false });
     const config = makeConfig();
     expect(isAssistantFeatureFlagEnabled("some-undeclared-flag", config)).toBe(
       false,
@@ -166,7 +164,7 @@ describe("isAssistantFeatureFlagEnabled", () => {
 
 describe("resolveSkillStates with feature flags", () => {
   test("flag OFF skill does not appear in resolved list", () => {
-    _setOverridesForTesting({
+    setOverridesForTesting({
       [DECLARED_FLAG_KEY]: false,
       [ENABLED_UNDECLARED_FLAG_KEY]: true,
     });
@@ -188,7 +186,7 @@ describe("resolveSkillStates with feature flags", () => {
   });
 
   test("flag ON skill appears normally", () => {
-    _setOverridesForTesting({
+    setOverridesForTesting({
       [DECLARED_FLAG_KEY]: true,
       [ENABLED_UNDECLARED_FLAG_KEY]: true,
     });
@@ -230,7 +228,7 @@ describe("resolveSkillStates with feature flags", () => {
   });
 
   test("feature flag OFF takes precedence over user-enabled config entry", () => {
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
     const catalog = [makeSkill(DECLARED_SKILL_ID, "bundled", DECLARED_FLAG_ID)];
     const config = makeConfig({
       skills: {
@@ -256,7 +254,7 @@ describe("resolveSkillStates with feature flags", () => {
   });
 
   test("multiple skills with mixed flags — persisted overrides respected", () => {
-    _setOverridesForTesting({
+    setOverridesForTesting({
       [DECLARED_FLAG_KEY]: false,
       [ENABLED_UNDECLARED_FLAG_KEY]: true,
       deploy: false,
@@ -296,7 +294,7 @@ describe("resolveSkillStates with frontmatter featureFlag", () => {
   });
 
   test("skill with featureFlag is included when override enables it", () => {
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
     const catalog = [makeSkill(DECLARED_SKILL_ID, "bundled", DECLARED_FLAG_ID)];
     const config = makeConfig();
 
@@ -320,7 +318,7 @@ describe("resolveSkillStates with frontmatter featureFlag", () => {
     // This proves the implicit skillId→flag mapping is gone:
     // setting feature_flags.my-skill.enabled = false has no effect
     // when the skill itself does not declare a featureFlag.
-    _setOverridesForTesting({
+    setOverridesForTesting({
       "my-skill": false,
     });
     const catalog = [makeSkill("my-skill")];

package/src/__tests__/skill-load-feature-flag.test.ts

@@ -6,7 +6,7 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
+import { setOverridesForTesting } from "./feature-flag-test-helpers.js";
 
 const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
 
@@ -89,11 +89,11 @@ describe("skill_load feature flag enforcement", () => {
   beforeEach(() => {
     mkdirSync(join(TEST_DIR, "skills"), { recursive: true });
     currentConfig = {};
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
   });
 
   afterEach(() => {
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
   });
 
   test("returns deterministic error for flag OFF skill", async () => {
@@ -104,7 +104,7 @@ describe("skill_load feature flag enforcement", () => {
       "Use the feature.",
     );
 
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
 
     const result = await executeSkillLoad({ skill: DECLARED_SKILL_ID });
 
@@ -121,7 +121,7 @@ describe("skill_load feature flag enforcement", () => {
       "Use the feature.",
     );
 
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
 
     const result = await executeSkillLoad({ skill: DECLARED_SKILL_ID });
 

package/src/__tests__/skill-projection-feature-flag.test.ts

@@ -45,20 +45,26 @@ mock.module("../config/skill-state.js", () => ({
 
 // Mock assistant-feature-flags to avoid loading the real module (which
 // triggers file I/O and env-registry imports that hang in test context).
+// The seed-state backdoor is the test-only helper module — we mirror
+// production's design: tests reach into `feature-flag-cache.ts` (or its
+// test-helper wrapper) to seed cached overrides, never through the
+// resolver module itself.
 let _mockOverrides: Record<string, boolean> = {};
 mock.module("../config/assistant-feature-flags.js", () => ({
   isAssistantFeatureFlagEnabled: (key: string, _config: unknown): boolean => {
     const explicit = _mockOverrides[key];
     if (typeof explicit === "boolean") return explicit;
-    return true; // undeclared flags default to enabled
+    return false; // undeclared flags default to disabled
   },
   clearFeatureFlagOverridesCache: () => {
     _mockOverrides = {};
   },
-  _setOverridesForTesting: (overrides: Record<string, boolean>) => {
+  getAssistantFeatureFlagDefaults: () => ({}),
+}));
+mock.module("./feature-flag-test-helpers.js", () => ({
+  setOverridesForTesting: (overrides: Record<string, boolean>) => {
     _mockOverrides = { ...overrides };
   },
-  getAssistantFeatureFlagDefaults: () => ({}),
 }));
 
 mock.module("../skills/active-skill-tools.js", () => {
@@ -109,45 +115,35 @@ mock.module("../skills/tool-manifest.js", () => ({
 }));
 
 mock.module("../tools/skills/skill-tool-factory.js", () => ({
+  // Mirrors the real factory: no skillId in/out — ownership is recorded by
+  // the registry at `registerSkillTools(skillId, tools)` time.
   createSkillToolsFromManifest: (
     entries: SkillToolManifest["tools"],
-    skillId: string,
     _skillDir: string,
-    versionHash: string,
-    bundled?: boolean,
+    _versionHash: string,
+    _bundled?: boolean,
   ): Tool[] => {
     return entries.map((entry) => ({
       name: entry.name,
       description: entry.description,
       category: entry.category,
       defaultRiskLevel: RiskLevel.Medium,
-      origin: "skill" as const,
-      ownerSkillId: skillId,
-      ownerSkillVersionHash: versionHash,
-      ownerSkillBundled: bundled ?? undefined,
-      getDefinition: () => ({
-        name: entry.name,
-        description: entry.description,
-        input_schema: entry.input_schema as object,
-      }),
+      executionTarget: "sandbox" as const,
+      input_schema: entry.input_schema as object,
       execute: async () => ({ content: "", isError: false }),
     }));
   },
 }));
 
 mock.module("../tools/registry.js", () => ({
-  registerSkillTools: (tools: Tool[]) => {
-    const skillIds = new Set<string>();
-    for (const tool of tools) {
-      const skillId = tool.ownerSkillId!;
-      skillIds.add(skillId);
-      const existing = mockRegisteredTools.get(skillId) ?? [];
-      existing.push(tool);
-      mockRegisteredTools.set(skillId, existing);
-    }
-    for (const id of skillIds) {
-      mockSkillRefCount.set(id, (mockSkillRefCount.get(id) ?? 0) + 1);
-    }
+  // Matches the new signature: `registerSkillTools(skillId, tools)`. The
+  // skillId comes from the caller (conversation-skill-tools) and is the
+  // sole source of truth for ownership.
+  registerSkillTools: (skillId: string, tools: Tool[]) => {
+    const existing = mockRegisteredTools.get(skillId) ?? [];
+    existing.push(...tools);
+    mockRegisteredTools.set(skillId, existing);
+    mockSkillRefCount.set(skillId, (mockSkillRefCount.get(skillId) ?? 0) + 1);
     return tools;
   },
   unregisterSkillTools: (skillId: string) => {
@@ -169,6 +165,23 @@ mock.module("../tools/registry.js", () => ({
     }
     return found;
   },
+  // Mirrors the registry's `ownersByName` accessor: derives the owning
+  // skillId from `mockRegisteredTools` keying so the production
+  // `getToolOwner(name)` call in `conversation-skill-tools.ts` resolves to
+  // the same shape the real registry would return.
+  getToolOwner: (
+    name: string,
+  ): { kind: "skill" | "plugin" | "mcp"; id: string } | undefined => {
+    let ownerSkillId: string | undefined;
+    for (const [skillId, tools] of mockRegisteredTools.entries()) {
+      for (const tool of tools) {
+        if (tool.name === name) ownerSkillId = skillId;
+      }
+    }
+    return ownerSkillId === undefined
+      ? undefined
+      : { kind: "skill", id: ownerSkillId };
+  },
   getSkillToolNames: () => {
     const names: string[] = [];
     for (const tools of mockRegisteredTools.values()) {
@@ -215,10 +228,8 @@ mock.module("../util/logger.js", () => ({
 
 const { projectSkillTools, resetSkillToolProjection } =
   await import("../daemon/conversation-skill-tools.js");
-const { _setOverridesForTesting } =
-  (await import("../config/assistant-feature-flags.js")) as {
-    _setOverridesForTesting: (o: Record<string, boolean>) => void;
-  };
+const { setOverridesForTesting } =
+  await import("./feature-flag-test-helpers.js");
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -292,12 +303,12 @@ describe("projectSkillTools feature flag enforcement", () => {
     mockUnregisteredSkillIds = [];
     mockSkillRefCount = new Map();
     currentConfig = {};
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
     resetSkillToolProjection();
   });
 
   afterEach(() => {
-    _setOverridesForTesting({});
+    setOverridesForTesting({});
   });
 
   test("no skill tools projected for flag OFF skill even with old markers", () => {
@@ -311,7 +322,7 @@ describe("projectSkillTools feature flag enforcement", () => {
     const prevActive = new Map<string, string>();
 
     // Feature flag is OFF — use protected directory override
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
 
     const result = projectSkillTools(history, {
       previouslyActiveSkillIds: prevActive,
@@ -332,7 +343,7 @@ describe("projectSkillTools feature flag enforcement", () => {
     const prevActive = new Map<string, string>();
 
     // Feature flag is ON — use protected directory override
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: true });
 
     const result = projectSkillTools(history, {
       previouslyActiveSkillIds: prevActive,
@@ -422,8 +433,8 @@ describe("projectSkillTools feature flag enforcement", () => {
     ];
     const prevActive = new Map<string, string>();
 
-    // Declared skill is OFF, plain-skill is undeclared with no persisted override so remains ON.
-    _setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
+    // Declared skill is OFF; plain-skill has no featureFlag so remains ON.
+    setOverridesForTesting({ [DECLARED_FLAG_KEY]: false });
 
     const result = projectSkillTools(history, {
       previouslyActiveSkillIds: prevActive,