@mycadet/assistant 0.12.9 → 0.12.10

package/src/__tests__/tool-audit.test.ts

@@ -1,50 +1,19 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-// Tri-state share_analytics consent consulted when populating the telemetry
-// columns: only a confirmed `false` NULLs them.
-let shareAnalytics: boolean | "unknown" = true;
-
-mock.module("../cloud/consent-cache.js", () => ({
-  getRawShareAnalytics: () => shareAnalytics,
-}));
-
-// Capture the audit rows the terminals would insert, and the lifecycle events
-// they would record, without touching the database.
+// Capture the audit rows the terminals would insert, without touching the
+// database.
 const records: Array<Record<string, unknown>> = [];
-const lifecycleEvents: Array<{
-  eventName: string;
-  attributes: Record<string, unknown>;
-}> = [];
-const lifecycleEventNames = (): string[] =>
-  lifecycleEvents.map((event) => event.eventName);
-// Simulates the telemetry store failing (degraded DB) for the one test that
-// asserts the terminals swallow it.
-let lifecycleRecorderThrows = false;
-
-mock.module("../telemetry/tool-usage-store.js", () => ({
+
+mock.module("../persistence/tool-usage-store.js", () => ({
   recordToolInvocation: (record: Record<string, unknown>) =>
     records.push(record),
 }));
 
-mock.module("../persistence/lifecycle-events-store.js", () => ({
-  recordLifecycleEvent: (
-    eventName: string,
-    attributes: Record<string, unknown> = {},
-  ) => {
-    if (lifecycleRecorderThrows) {
-      throw new Error("telemetry db down");
-    }
-    lifecycleEvents.push({ eventName, attributes });
-  },
-}));
-
 import {
   recordToolDenied,
   recordToolError,
   recordToolExecuted,
-  recordToolPermissionDecided,
-  recordToolPermissionPrompted,
-} from "../telemetry/tool-audit.js";
+} from "../persistence/tool-audit.js";
 import {
   OPENAI_PROJECT_KEY_REDACTION_MARKER,
   SYNTHETIC_OPENAI_PROJECT_KEY,
@@ -64,10 +33,7 @@ const ATTRIBUTION = {
 
 describe("tool audit terminals", () => {
   beforeEach(() => {
-    shareAnalytics = true;
-    lifecycleRecorderThrows = false;
     records.length = 0;
-    lifecycleEvents.length = 0;
   });
 
   test("records executed rows with truncated output", () => {
@@ -333,87 +299,6 @@ describe("tool audit terminals", () => {
     );
   });
 
-  test("persists NULL telemetry columns when share_analytics is opted out", () => {
-    shareAnalytics = false;
-
-    recordToolExecuted({
-      conversationId: "conv-opt-out",
-      toolName: "file_read",
-      input: { path: "/tmp/a" },
-      resultContent: "ok",
-      resultBytes: 99,
-      decision: "allow",
-      riskLevel: "low",
-      durationMs: 12,
-      attribution: ATTRIBUTION,
-    });
-    recordToolError({
-      conversationId: "conv-opt-out",
-      toolName: "file_read",
-      input: { path: "/tmp/b" },
-      errorMessage: "boom",
-      isExpected: false,
-      riskLevel: "low",
-      durationMs: 9,
-      attribution: ATTRIBUTION,
-    });
-
-    // Telemetry columns are NULL — the tool_executed projection's
-    // arg_bytes IS NOT NULL filter makes these rows permanently unreportable.
-    expect(records).toHaveLength(2);
-    for (const record of records) {
-      expect(record.argBytes).toBeNull();
-      expect(record.resultBytes).toBeNull();
-      expect(record.provider).toBeNull();
-      expect(record.model).toBeNull();
-      expect(record.inferenceProfile).toBeNull();
-      expect(record.inferenceProfileSource).toBeNull();
-    }
-    // The audit row itself is unaffected by the opt-out.
-    expect(records[0]).toMatchObject({
-      conversationId: "conv-opt-out",
-      toolName: "file_read",
-      input: JSON.stringify({ path: "/tmp/a" }),
-      result: "ok",
-      decision: "allow",
-      durationMs: 12,
-    });
-    expect(records[1]).toMatchObject({
-      result: "error: boom",
-      decision: "error",
-      durationMs: 9,
-    });
-  });
-
-  test("populates telemetry columns under unknown consent (cold cache)", () => {
-    // NULL columns are permanently excluded by the projection's
-    // arg_bytes IS NOT NULL filter, so only a CONFIRMED opt-out may NULL
-    // them — unknown records, and flush-time consent gating decides later.
-    shareAnalytics = "unknown";
-
-    recordToolExecuted({
-      conversationId: "conv-unknown",
-      toolName: "file_read",
-      input: { path: "/tmp/a" },
-      resultContent: "ok",
-      resultBytes: 99,
-      decision: "allow",
-      riskLevel: "low",
-      durationMs: 12,
-      attribution: ATTRIBUTION,
-    });
-
-    expect(records).toHaveLength(1);
-    expect(records[0]).toMatchObject({
-      argBytes: Buffer.byteLength(JSON.stringify({ path: "/tmp/a" }), "utf8"),
-      resultBytes: 99,
-      provider: "anthropic",
-      model: "model-a",
-      inferenceProfile: "balanced",
-      inferenceProfileSource: "active",
-    });
-  });
-
   test("maps attribution onto executed rows and leaves denied rows null", () => {
     recordToolExecuted({
       conversationId: "conv-attr",
@@ -463,119 +348,4 @@ describe("tool audit terminals", () => {
     expect(records[2].argBytes).toBeUndefined();
     expect(records[2].resultBytes).toBeUndefined();
   });
-
-  test("audit terminals record no permission lifecycle telemetry", () => {
-    recordToolExecuted({
-      conversationId: "conv-prompt",
-      toolName: "bash",
-      input: { command: "ls" },
-      resultContent: "ok",
-      resultBytes: 2,
-      decision: "allow",
-      riskLevel: "high",
-      durationMs: 3,
-      attribution: null,
-    });
-    recordToolDenied({
-      conversationId: "conv-prompt",
-      toolName: "bash",
-      input: { command: "rm -rf /" },
-      reason: "Permission denied by user",
-      riskLevel: "high",
-      durationMs: 1,
-    });
-
-    expect(lifecycleEvents).toEqual([]);
-  });
-
-  test("prompt and decision carry the same grouping dimensions", () => {
-    const prompt = {
-      toolName: "bash",
-      riskLevel: "high",
-      riskThreshold: "low",
-      surface: "slack",
-      conversationId: "conv-prompt",
-    };
-
-    recordToolPermissionPrompted(prompt);
-    recordToolPermissionDecided(prompt, "deny");
-
-    expect(lifecycleEventNames()).toEqual([
-      "permission_prompt:bash",
-      "permission_decided:bash:deny",
-    ]);
-    for (const event of lifecycleEvents) {
-      expect(event.attributes).toEqual({
-        toolName: "bash",
-        riskLevel: "high",
-        riskThreshold: "low",
-        surface: "slack",
-        conversationId: "conv-prompt",
-      });
-    }
-  });
-
-  test("optional grouping dimensions are left unset when unknown", () => {
-    recordToolPermissionPrompted({ toolName: "file_read", riskLevel: "low" });
-
-    const attributes = lifecycleEvents[0]!.attributes;
-    expect(attributes.toolName).toBe("file_read");
-    expect(attributes.riskLevel).toBe("low");
-    expect(attributes.riskThreshold).toBeUndefined();
-    expect(attributes.surface).toBeUndefined();
-    expect(attributes.conversationId).toBeUndefined();
-  });
-
-  test("records an abandoned decision distinctly from a user denial", () => {
-    const prompt = { toolName: "bash", riskLevel: "medium" };
-
-    recordToolPermissionPrompted(prompt);
-    recordToolPermissionDecided(prompt, "abandoned");
-
-    expect(lifecycleEventNames()).toEqual([
-      "permission_prompt:bash",
-      "permission_decided:bash:abandoned",
-    ]);
-  });
-
-  test("truncates a long tool name to the wire event-name bound", () => {
-    const toolName = `mcp__${"a".repeat(80)}__run`;
-    const prompt = { toolName, riskLevel: "high" };
-
-    recordToolPermissionPrompted(prompt);
-    recordToolPermissionDecided(prompt, "abandoned");
-
-    for (const event of lifecycleEvents) {
-      expect(event.eventName.length).toBeLessThanOrEqual(64);
-      // The full name still joins the pair.
-      expect(event.attributes.toolName).toBe(toolName);
-    }
-    expect(lifecycleEvents[1]!.eventName.endsWith(":abandoned")).toBe(true);
-  });
-
-  test("clamps a tool name past the wire tool_name bound", () => {
-    // A field over its bound fails validation, and a failed event is acked and
-    // discarded rather than retried.
-    const toolName = `mcp__${"a".repeat(300)}__run`;
-
-    recordToolPermissionPrompted({ toolName, riskLevel: "high" });
-
-    expect(lifecycleEvents[0]!.attributes.toolName).toBe(
-      toolName.slice(0, 255),
-    );
-  });
-
-  test("a failing lifecycle recorder never propagates out of the terminals", () => {
-    lifecycleRecorderThrows = true;
-
-    expect(() =>
-      recordToolPermissionPrompted({ toolName: "bash", riskLevel: "high" }),
-    ).not.toThrow();
-    expect(() =>
-      recordToolPermissionDecided(
-        { toolName: "bash", riskLevel: "high" },
-        "abandoned",
-      ),
-    ).not.toThrow();
-  });
 });

package/src/__tests__/tool-executor-lifecycle-events.test.ts

@@ -16,7 +16,7 @@ let abortDuringCheck: AbortController | null = null;
 // ── audit-terminal captures ───────────────────────────────
 // The executor and its permission/approval collaborators no longer emit
 // lifecycle events through a context callback; they call direct terminal
-// functions in `../telemetry/tool-audit.js`. Mock those terminals here
+// functions in `../persistence/tool-audit.js`. Mock those terminals here
 // (declared before importing the ToolExecutor so the mock intercepts the
 // executor's static import) and capture each call into an array. Every test
 // below asserts against these captures instead of an emitted-event stream.
@@ -59,28 +59,19 @@ interface DeniedCapture {
   durationMs: number;
 }
 
-interface PromptTelemetryCapture {
-  toolName: string;
-  riskLevel: string;
-  riskThreshold?: string;
-  surface?: string;
-  conversationId?: string;
-}
-
 const executedCaptures: ExecutedCapture[] = [];
 const errorCaptures: ErrorCapture[] = [];
 const deniedCaptures: DeniedCapture[] = [];
-const promptedCaptures: PromptTelemetryCapture[] = [];
-const decidedCaptures: Array<{
-  entry: PromptTelemetryCapture;
-  outcome: string;
+// The permission-prompt telemetry pair (recordToolPermissionPrompted/Decided)
+// died with the telemetry removal; whether a prompt was surfaced is observed
+// through the fake prompter instead (see makePrompter below).
+const promptCalls: Array<{
+  toolName: string;
+  riskLevel: string;
+  conversationId?: string;
 }> = [];
-const promptedToolNames = (): string[] =>
-  promptedCaptures.map((entry) => entry.toolName);
-const decidedOutcomes = (): string[] =>
-  decidedCaptures.map((decided) => decided.outcome);
 
-mock.module("../telemetry/tool-audit.js", () => ({
+mock.module("../persistence/tool-audit.js", () => ({
   recordToolExecuted: (entry: ExecutedCapture) => {
     executedCaptures.push(entry);
   },
@@ -90,15 +81,6 @@ mock.module("../telemetry/tool-audit.js", () => ({
   recordToolDenied: (entry: DeniedCapture) => {
     deniedCaptures.push(entry);
   },
-  recordToolPermissionPrompted: (entry: PromptTelemetryCapture) => {
-    promptedCaptures.push(entry);
-  },
-  recordToolPermissionDecided: (
-    entry: PromptTelemetryCapture,
-    outcome: string,
-  ) => {
-    decidedCaptures.push({ entry, outcome });
-  },
 }));
 
 // Analytics consent is granted so any consent-gated telemetry path the audit
@@ -156,8 +138,8 @@ mock.module("../persistence/conversation-crud.js", () => ({
 }));
 
 // Mock every export so downstream test files that dynamically import modules
-// with a static `from "../telemetry/tool-usage-store.js"` still see all symbols.
-mock.module("../telemetry/tool-usage-store.js", () => ({
+// with a static `from "../persistence/tool-usage-store.js"` still see all symbols.
+mock.module("../persistence/tool-usage-store.js", () => ({
   recordToolInvocation: () => {},
   getRecentInvocations: () => [],
   rotateToolInvocations: async () => 0,
@@ -302,7 +284,21 @@ function makePrompter(
   }>,
 ) {
   return {
-    prompt: promptImpl ?? (async () => ({ decision: promptDecision })),
+    prompt: async (
+      toolName: string,
+      _input: unknown,
+      riskLevel: string,
+      _allowlistOptions: unknown,
+      _scopeOptions: unknown,
+      _previewDiff: unknown,
+      conversationId?: string,
+    ) => {
+      // Record that a prompt was actually surfaced (with the risk and
+      // conversation the checker resolved) — the telemetry "prompted" half is
+      // gone, so the surfaced-prompt observation lives here now.
+      promptCalls.push({ toolName, riskLevel, conversationId });
+      return promptImpl ? promptImpl() : { decision: promptDecision };
+    },
     resolveConfirmation: () => {},
     updateSender: () => {},
     dispose: () => {},
@@ -323,8 +319,7 @@ describe("ToolExecutor audit terminals", () => {
     executedCaptures.length = 0;
     errorCaptures.length = 0;
     deniedCaptures.length = 0;
-    promptedCaptures.length = 0;
-    decidedCaptures.length = 0;
+    promptCalls.length = 0;
   });
 
   test("records executed terminal for allowed execution", async () => {
@@ -356,7 +351,7 @@ describe("ToolExecutor audit terminals", () => {
   test("records permission telemetry per-invocation, not from the turn-level flag", async () => {
     // A prior tool this turn was interactively approved (turn-level
     // `approvedViaPrompt` already true), but THIS call is auto-approved, so it
-    // surfaces no prompt and records neither half of the pair.
+    // surfaces no prompt and lands directly on the executed terminal.
     const executor = new ToolExecutor(makePrompter());
 
     const result = await executor.execute(
@@ -367,8 +362,7 @@ describe("ToolExecutor audit terminals", () => {
 
     expect(result).toMatchObject({ isError: false });
     expect(executedCaptures).toHaveLength(1);
-    expect(promptedCaptures).toHaveLength(0);
-    expect(decidedCaptures).toHaveLength(0);
+    expect(promptCalls).toHaveLength(0);
   });
 
   test("records denied terminal when user denies prompt", async () => {
@@ -389,8 +383,7 @@ describe("ToolExecutor audit terminals", () => {
     expect(result.content).toContain("Permission denied");
 
     // A prompt was surfaced, then the user's denial recorded a denied terminal.
-    expect(promptedToolNames()).toEqual(["bash"]);
-    expect(decidedOutcomes()).toEqual(["deny"]);
+    expect(promptCalls.map((c) => c.toolName)).toEqual(["bash"]);
     expect(executedCaptures).toHaveLength(0);
     expect(deniedCaptures).toHaveLength(1);
     const denied = deniedCaptures[0];
@@ -399,7 +392,7 @@ describe("ToolExecutor audit terminals", () => {
     expect(denied.reason).toBe("Permission denied by user");
   });
 
-  test("records an allow decision when the user approves the prompt", async () => {
+  test("runs the tool when the user approves the prompt", async () => {
     checkerDecision = "prompt";
     checkerReason = "medium risk: requires approval";
     checkerRisk = "medium";
@@ -413,11 +406,12 @@ describe("ToolExecutor audit terminals", () => {
       makeContext({ forcePromptSideEffects: true }),
     );
 
-    expect(promptedToolNames()).toEqual(["bash"]);
-    expect(decidedOutcomes()).toEqual(["allow"]);
+    expect(promptCalls.map((c) => c.toolName)).toEqual(["bash"]);
+    expect(executedCaptures).toHaveLength(1);
+    expect(deniedCaptures).toHaveLength(0);
   });
 
-  test("carries risk level and access preset onto both halves of the pair", async () => {
+  test("carries risk level and conversation onto the prompt request", async () => {
     checkerDecision = "prompt";
     checkerReason = "high risk: requires approval";
     checkerRisk = "high";
@@ -434,14 +428,10 @@ describe("ToolExecutor audit terminals", () => {
     const expected = {
       toolName: "bash",
       riskLevel: "high",
-      // The gateway is unreachable under test, so the reader falls back to the
-      // strict preset. What matters is that the resolved value is recorded.
-      riskThreshold: "none",
-      surface: "slack",
       conversationId: "conversation-1",
     };
-    expect(promptedCaptures[0]).toMatchObject(expected);
-    expect(decidedCaptures[0].entry).toMatchObject(expected);
+    expect(promptCalls[0]).toMatchObject(expected);
+    expect(deniedCaptures).toHaveLength(1);
   });
 
   // ── abandoned prompts ───────────────────────────────
@@ -470,8 +460,8 @@ describe("ToolExecutor audit terminals", () => {
       );
 
       expect(result.isError).toBe(true);
-      expect(promptedToolNames()).toEqual(["bash"]);
-      expect(decidedOutcomes()).toEqual(["abandoned"]);
+      expect(promptCalls.map((c) => c.toolName)).toEqual(["bash"]);
+      expect(deniedCaptures).toHaveLength(1);
     },
   );
 
@@ -496,14 +486,12 @@ describe("ToolExecutor audit terminals", () => {
     );
 
     expect(result.isError).toBe(true);
-    // The invocation did reach the prompt branch and was denied there, so the
-    // empty telemetry below is the guard working, not the branch being skipped.
+    // The invocation did reach the prompt branch and was denied there — the
+    // deny is the guard working, not the branch being skipped.
     expect(deniedCaptures).toHaveLength(1);
-    expect(promptedCaptures).toHaveLength(0);
-    expect(decidedCaptures).toHaveLength(0);
   });
 
-  test("records an abandoned decision when the prompter is disposed mid-prompt", async () => {
+  test("records an error terminal when the prompter is disposed mid-prompt", async () => {
     checkerDecision = "prompt";
     checkerReason = "medium risk: requires approval";
     checkerRisk = "medium";
@@ -521,61 +509,13 @@ describe("ToolExecutor audit terminals", () => {
     );
 
     expect(result.isError).toBe(true);
-    expect(promptedToolNames()).toEqual(["bash"]);
-    expect(decidedOutcomes()).toEqual(["abandoned"]);
-  });
-
-  test("every prompt reconciles against exactly one decision", async () => {
-    checkerDecision = "prompt";
-    checkerReason = "medium risk: requires approval";
-    checkerRisk = "medium";
-
-    // One of each terminal shape a prompted invocation can reach: approved and
-    // the tool runs, approved and the tool throws, denied, and abandoned.
-    const runs: Array<() => Promise<unknown>> = [
-      async () => {
-        promptDecision = "allow";
-        toolThrow = null;
-        return new ToolExecutor(makePrompter()).execute(
-          "bash",
-          { command: "ls" },
-          makeContext({ forcePromptSideEffects: true }),
-        );
-      },
-      async () => {
-        promptDecision = "allow";
-        toolThrow = new Error("boom");
-        return new ToolExecutor(makePrompter()).execute(
-          "bash",
-          { command: "ls" },
-          makeContext({ forcePromptSideEffects: true }),
-        );
-      },
-      async () => {
-        promptDecision = "deny";
-        toolThrow = null;
-        return new ToolExecutor(makePrompter()).execute(
-          "bash",
-          { command: "ls" },
-          makeContext({ forcePromptSideEffects: true }),
-        );
-      },
-      async () =>
-        new ToolExecutor(
-          makePrompter(async () => ({ decision: "deny", wasTimeout: true })),
-        ).execute(
-          "bash",
-          { command: "ls" },
-          makeContext({ forcePromptSideEffects: true }),
-        ),
-    ];
-    for (const run of runs) {
-      await run();
-    }
-
-    expect(promptedCaptures).toHaveLength(runs.length);
-    expect(decidedCaptures).toHaveLength(runs.length);
-    expect(decidedOutcomes()).toEqual(["allow", "allow", "deny", "abandoned"]);
+    expect(promptCalls.map((c) => c.toolName)).toEqual(["bash"]);
+    // The prompter rejected rather than resolved: the throw rides the
+    // executor's generic error path to an unexpected-error terminal, not a
+    // denied one.
+    expect(errorCaptures).toHaveLength(1);
+    expect(errorCaptures[0].errorMessage).toBe("Prompter disposed");
+    expect(errorCaptures[0].isExpected).toBe(false);
   });
 
   test("uses contextual deny messaging when provided by prompter", async () => {
@@ -644,7 +584,7 @@ describe("ToolExecutor audit terminals", () => {
       isError: true,
     });
     // A deterministic deny rule blocks without prompting.
-    expect(promptedCaptures).toHaveLength(0);
+    expect(promptCalls).toHaveLength(0);
     expect(deniedCaptures).toHaveLength(1);
     expect(deniedCaptures[0].reason).toBe("Blocked by deny rule: rm *");
   });
@@ -977,7 +917,7 @@ describe("ToolExecutor audit terminals", () => {
     );
 
     // forcePromptSideEffects promotes the auto-allow to an interactive prompt.
-    expect(promptedToolNames()).toEqual(["bash"]);
+    expect(promptCalls.map((c) => c.toolName)).toEqual(["bash"]);
     expect(executedCaptures).toHaveLength(1);
     expect(executedCaptures[0].toolName).toBe("bash");
   });
@@ -995,8 +935,8 @@ describe("ToolExecutor audit terminals", () => {
       makeContext({ forcePromptSideEffects: true }),
     );
 
-    // file_read is not a side-effect tool, so no prompt terminal should fire.
-    expect(promptedCaptures).toHaveLength(0);
+    // file_read is not a side-effect tool, so no prompt is surfaced.
+    expect(promptCalls).toHaveLength(0);
     expect(executedCaptures).toHaveLength(1);
     expect(executedCaptures[0].toolName).toBe("file_read");
   });
@@ -1022,7 +962,7 @@ describe("ToolExecutor audit terminals", () => {
     );
 
     expect(result).toMatchObject({ content: "ok", isError: false });
-    expect(promptedToolNames()).toEqual(["file_edit"]);
+    expect(promptCalls.map((c) => c.toolName)).toEqual(["file_edit"]);
     expect(executedCaptures).toHaveLength(1);
     expect(executedCaptures[0].toolName).toBe("file_edit");
   });

package/src/__tests__/tools-get-route.test.ts

@@ -28,7 +28,7 @@ import {
   registerWorkspaceTools,
 } from "../tools/registry.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../tools/types.js";
-import { getWorkspacePluginsDir } from "../util/platform.js";
+import { getWorkspacePluginsDir } from "../util/layout.js";
 
 interface ToolListEntry {
   name: string;

package/src/__tests__/turn-outcome-read.test.ts

@@ -20,7 +20,7 @@ import { initializeDb } from "../persistence/db-init.js";
 import {
   readTurnFailure,
   stampTurnOutcome,
-} from "../telemetry/turn-outcome.js";
+} from "../persistence/turn-outcome.js";
 
 await initializeDb();
 

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

@@ -364,7 +364,6 @@ function createTestSession(
 ) {
   ensureConversation(convId);
   const session = createCallSession({
-    direction: "inbound",
     conversationId: convId,
     provider: "twilio",
     fromNumber: "+14155550111",

package/src/__tests__/usage-attribution.test.ts

@@ -109,37 +109,6 @@ describe("resolveUsageAttribution", () => {
     expectResolvedProviderModelMatchesResolver("mainAgent", "pinned");
   });
 
-  test("reports an override the Auto router chose as the auto source", () => {
-    setLlmConfig({
-      profiles: {
-        active: { provider: "openai", model: "gpt-5.4" },
-        routed: { provider: "gemini", model: "gemini-3-pro" },
-      },
-      activeProfile: "active",
-    });
-
-    const snapshot = resolveUsageAttribution({
-      callSite: "mainAgent",
-      overrideProfile: "routed",
-      overrideProfileOrigin: "auto",
-    });
-
-    expect(snapshot).toMatchObject({
-      appliedProfile: "routed",
-      profileSource: "auto",
-      resolvedProvider: "gemini",
-      resolvedModel: "gemini-3-pro",
-    });
-    // The origin only relabels an override that actually won.
-    expect(
-      resolveUsageAttribution({
-        callSite: "mainAgent",
-        overrideProfile: "missing",
-        overrideProfileOrigin: "auto",
-      }).profileSource,
-    ).toBe("active");
-  });
-
   test("resolves call-site profile attribution", () => {
     setLlmConfig({
       profiles: {

package/src/__tests__/verification-control-plane-policy.test.ts

@@ -29,8 +29,8 @@ mock.module("../persistence/conversation-crud.js", () => ({
 }));
 
 // Mock every export so downstream test files that dynamically import modules
-// with a static `from "../telemetry/tool-usage-store.js"` still see all symbols.
-mock.module("../telemetry/tool-usage-store.js", () => ({
+// with a static `from "../persistence/tool-usage-store.js"` still see all symbols.
+mock.module("../persistence/tool-usage-store.js", () => ({
   recordToolInvocation: () => {},
   getRecentInvocations: () => [],
   rotateToolInvocations: async () => 0,
@@ -42,24 +42,17 @@ const auditCalls = {
   denied: [] as any[],
   error: [] as any[],
   executed: [] as any[],
-  prompted: [] as any[],
-  decided: [] as any[],
 };
-mock.module("../telemetry/tool-audit.js", () => ({
+mock.module("../persistence/tool-audit.js", () => ({
   recordToolDenied: (e: any) => auditCalls.denied.push(e),
   recordToolError: (e: any) => auditCalls.error.push(e),
   recordToolExecuted: (e: any) => auditCalls.executed.push(e),
-  recordToolPermissionPrompted: (e: any) => auditCalls.prompted.push(e),
-  recordToolPermissionDecided: (e: any, outcome: string) =>
-    auditCalls.decided.push({ entry: e, outcome }),
 }));
 
 function resetAuditCalls(): void {
   auditCalls.denied.length = 0;
   auditCalls.error.length = 0;
   auditCalls.executed.length = 0;
-  auditCalls.prompted.length = 0;
-  auditCalls.decided.length = 0;
 }
 
 mock.module("../tools/registry.js", () => ({