muonroi-cli 1.4.0 → 1.5.0

package/src/ee/__tests__/bb-design.test.ts

@@ -1,223 +0,0 @@
-/**
- * Tests for src/ee/bb-design.ts (Plan 23-01a).
- *
- * Covers 5 scenarios:
- *  1. happy path — template + commercial filter
- *  2. allowCommercial=true — commercial pkgs not filtered
- *  3. no template recipe — returns null
- *  4. EE 503 — returns null + ee-error logged
- *  5. EE timeout — returns null + ee-timeout logged
- *
- * Mocks `global.fetch` via vi.spyOn. Routes EE base URL through
- * MUONROI_EE_BASE_URL so we don't depend on ~/.experience/config.json.
- */
-
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import * as eeLogger from "../../utils/ee-logger.js";
-import { designBBPackages } from "../bb-design.js";
-
-const FAKE_BASE = "http://127.0.0.1:65535";
-
-interface RawPoint {
-  text: string;
-  score: number;
-}
-
-interface MockResponse {
-  status?: number;
-  body?: { points: RawPoint[] };
-  /** When true, returns a never-resolving Promise to simulate timeout. */
-  hang?: boolean;
-}
-
-type CollectionResponses = Record<string, MockResponse>;
-
-function makeFetchMock(byCollection: CollectionResponses) {
-  return vi.fn(async (url: string | URL | Request, init?: RequestInit) => {
-    const u = typeof url === "string" ? url : (url as URL).toString();
-    if (!u.endsWith("/api/search")) {
-      throw new Error(`unexpected fetch URL: ${u}`);
-    }
-    const bodyStr = typeof init?.body === "string" ? init.body : "";
-    const body = JSON.parse(bodyStr) as { query: string; collections: string[]; limit: number };
-    const collection = body.collections[0];
-    const mock = byCollection[collection];
-    if (!mock) {
-      // Default empty hit set.
-      return new Response(JSON.stringify({ points: [] }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    }
-    if (mock.hang) {
-      // Never resolve — let AbortSignal.timeout fire.
-      return await new Promise<Response>((_resolve, reject) => {
-        init?.signal?.addEventListener("abort", () => {
-          const e = new Error("aborted");
-          e.name = "AbortError";
-          reject(e);
-        });
-      });
-    }
-    return new Response(JSON.stringify(mock.body ?? { points: [] }), {
-      status: mock.status ?? 200,
-      headers: { "Content-Type": "application/json" },
-    });
-  });
-}
-
-const TEMPLATE_TEXT =
-  "Template Muonroi Microservices Solution (mr-micro-sln): Muonroi microservices template with selectable OSS or enterprise tier and optional control-plane integration. | uses: Muonroi.AspNetCore, Muonroi.Tenancy, Muonroi.AuthZ";
-
-const PRINCIPLE_AUTHZ_TEXT =
-  "Commercial package Muonroi.AuthZ requires a valid Muonroi commercial license for production use";
-
-const PRINCIPLE_CONSUL_TEXT =
-  "Commercial package Muonroi.ServiceDiscovery.Consul requires a valid Muonroi commercial license for production use";
-
-describe("designBBPackages", () => {
-  const originalFetch = global.fetch;
-  const originalEnv = { ...process.env };
-
-  beforeEach(() => {
-    process.env.MUONROI_EE_BASE_URL = FAKE_BASE;
-    delete process.env.MUONROI_BB_DESIGN_TIMEOUT_MS;
-  });
-
-  afterEach(() => {
-    global.fetch = originalFetch;
-    process.env = { ...originalEnv };
-    vi.restoreAllMocks();
-  });
-
-  it("returns the matched template with commercial pkgs blocked (happy path)", async () => {
-    const fetchMock = makeFetchMock({
-      "bb-recipes": {
-        body: {
-          points: [
-            { text: TEMPLATE_TEXT, score: 0.87 },
-            { text: "Sample TodoApi project not a template", score: 0.6 },
-          ],
-        },
-      },
-      "experience-principles": {
-        body: {
-          points: [
-            { text: PRINCIPLE_AUTHZ_TEXT, score: 0.9 },
-            { text: PRINCIPLE_CONSUL_TEXT, score: 0.85 },
-          ],
-        },
-      },
-      "bb-behavioral": {
-        body: {
-          points: [
-            { text: "Register infrastructure via AddInfrastructure()", score: 0.8 },
-            { text: "Use modular boundaries: never import Application from Domain", score: 0.75 },
-            { text: "Register infrastructure via AddInfrastructure()", score: 0.72 },
-          ],
-        },
-      },
-    });
-    vi.spyOn(global, "fetch").mockImplementation(fetchMock as unknown as typeof fetch);
-
-    const result = await designBBPackages("multi-tenant SaaS billing");
-
-    expect(result).not.toBeNull();
-    expect(result!.template.shortName).toBe("mr-micro-sln");
-    expect(result!.template.nugetId).toBe("Muonroi.Microservices.Template");
-    expect(result!.template.version).toBe("1.10.0");
-    expect(result!.packageIds).toEqual(["Muonroi.AspNetCore", "Muonroi.Tenancy"]);
-    expect(result!.commercialBlocked).toEqual(["Muonroi.AuthZ"]);
-    expect(result!.confidence).toBeCloseTo(0.87);
-    expect(result!.rationale).toContain("Muonroi microservices template");
-    // Dedup of duplicate AddInfrastructure entries -> 2 hints, not 3.
-    expect(result!.behavioralHints).toHaveLength(2);
-    expect(result!.behavioralHints[0]).toContain("AddInfrastructure");
-  });
-
-  it("includes commercial packages when allowCommercial=true", async () => {
-    const fetchMock = makeFetchMock({
-      "bb-recipes": { body: { points: [{ text: TEMPLATE_TEXT, score: 0.87 }] } },
-      "experience-principles": { body: { points: [{ text: PRINCIPLE_AUTHZ_TEXT, score: 0.9 }] } },
-      "bb-behavioral": { body: { points: [] } },
-    });
-    vi.spyOn(global, "fetch").mockImplementation(fetchMock as unknown as typeof fetch);
-
-    const result = await designBBPackages("multi-tenant SaaS billing", { allowCommercial: true });
-
-    expect(result).not.toBeNull();
-    expect(result!.packageIds).toEqual(["Muonroi.AspNetCore", "Muonroi.Tenancy", "Muonroi.AuthZ"]);
-    expect(result!.commercialBlocked).toEqual([]);
-  });
-
-  it("returns null when no template recipe is found in top-5", async () => {
-    const fetchMock = makeFetchMock({
-      "bb-recipes": {
-        body: {
-          points: [
-            { text: "Sample TodoApi project: not a template", score: 0.5 },
-            { text: "Some other text", score: 0.4 },
-          ],
-        },
-      },
-      "experience-principles": { body: { points: [] } },
-      "bb-behavioral": { body: { points: [] } },
-    });
-    vi.spyOn(global, "fetch").mockImplementation(fetchMock as unknown as typeof fetch);
-
-    const logSpy = vi.spyOn(eeLogger, "logEeFailure");
-    const result = await designBBPackages("anything");
-
-    expect(result).toBeNull();
-    expect(logSpy).toHaveBeenCalled();
-    const lastCall = logSpy.mock.calls.at(-1)!;
-    expect(lastCall[0]).toBe("bb-design");
-    expect(lastCall[1]).toBe("error");
-  });
-
-  it("returns null + logs ee-error when EE returns 503", async () => {
-    const fetchMock = makeFetchMock({
-      "bb-recipes": { status: 503, body: { points: [] } },
-      "experience-principles": { status: 503, body: { points: [] } },
-      "bb-behavioral": { status: 503, body: { points: [] } },
-    });
-    vi.spyOn(global, "fetch").mockImplementation(fetchMock as unknown as typeof fetch);
-
-    const logSpy = vi.spyOn(eeLogger, "logEeFailure");
-    const result = await designBBPackages("anything");
-
-    expect(result).toBeNull();
-    expect(logSpy).toHaveBeenCalled();
-    const errorCall = logSpy.mock.calls.find((c) => c[0] === "bb-design" && c[1] === "error");
-    expect(errorCall).toBeDefined();
-  });
-
-  it("returns null + logs ee-timeout when fetch hangs past budget", async () => {
-    process.env.MUONROI_BB_DESIGN_TIMEOUT_MS = "500";
-
-    // Re-import bb-design so it picks up the lowered timeout at module init.
-    vi.resetModules();
-    const { designBBPackages: designFresh } = await import("../bb-design.js");
-
-    const fetchMock = makeFetchMock({
-      "bb-recipes": { hang: true },
-      "experience-principles": { hang: true },
-      "bb-behavioral": { hang: true },
-    });
-    vi.spyOn(global, "fetch").mockImplementation(fetchMock as unknown as typeof fetch);
-
-    const freshLogger = await import("../../utils/ee-logger.js");
-    const logSpy = vi.spyOn(freshLogger, "logEeFailure");
-
-    const t0 = Date.now();
-    const result = await designFresh("anything");
-    const elapsed = Date.now() - t0;
-
-    expect(result).toBeNull();
-    // Should resolve within roughly the budget (some slack for CI scheduling).
-    expect(elapsed).toBeLessThan(3000);
-    expect(logSpy).toHaveBeenCalled();
-    const timeoutCall = logSpy.mock.calls.find((c) => c[0] === "bb-design" && c[1] === "timeout");
-    expect(timeoutCall).toBeDefined();
-  });
-});

package/src/ee/__tests__/export-transcripts.test.ts

@@ -1,222 +0,0 @@
-/**
- * export-transcripts.test.ts
- *
- * Unit tests for exportTranscripts() — SQLite → JSONL transcript export.
- *
- * Strategy: redirect USERPROFILE (Windows) / HOME (POSIX) to a temp dir,
- * create a real SQLite DB at `~/.muonroi-cli/muonroi.db`, and call the
- * function.  Also creates `~/.experience/config.json` so the emit sidecar
- * (transcript-emit) does not gate-return null.
- */
-
-import { Database } from "bun:sqlite";
-// @ts-expect-error — bun:test is provided by the bun runtime; this file runs
-// via `bun test`, not vitest (vitest cannot resolve bun:sqlite's `db.run` API).
-// Excluded from vitest in vitest.config.ts.
-import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-let tmpHome = "";
-let origUserProfile: string | undefined;
-
-function cleanDb() {
-  if (tmpHome) {
-    try {
-      rmSync(tmpHome, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-    } catch {
-      /* ok */
-    }
-  }
-}
-
-function bootstrapDb(
-  sessions: Array<{
-    sessionId: string;
-    updatedAt: string;
-    cwdLast: string | null;
-    messages: Array<{ seq: number; role: string; messageJson: string }>;
-  }>,
-) {
-  const dbDir = join(tmpHome, ".muonroi-cli");
-  const dbPath = join(dbDir, "muonroi.db");
-  mkdirSync(dbDir, { recursive: true });
-  const db = new Database(dbPath, { create: true });
-  db.run(
-    "CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, updated_at TEXT NOT NULL, cwd_last TEXT DEFAULT NULL)",
-  );
-  db.run(
-    "CREATE TABLE IF NOT EXISTS messages (session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE, seq INTEGER NOT NULL, role TEXT NOT NULL, message_json TEXT NOT NULL, created_at TEXT DEFAULT NULL, status TEXT DEFAULT NULL)",
-  );
-  for (const s of sessions) {
-    db.run("INSERT INTO sessions (id, updated_at, cwd_last) VALUES (?, ?, ?)", [s.sessionId, s.updatedAt, s.cwdLast]);
-    for (const m of s.messages) {
-      db.run("INSERT INTO messages (session_id, seq, role, message_json) VALUES (?, ?, ?, ?)", [
-        s.sessionId,
-        m.seq,
-        m.role,
-        m.messageJson,
-      ]);
-    }
-  }
-  db.close();
-}
-
-beforeEach(() => {
-  tmpHome = join(tmpdir(), "muonroi-test-export-" + Date.now());
-  const muonroiDir = join(tmpHome, ".muonroi-cli");
-  const experienceDir = join(tmpHome, ".experience");
-  mkdirSync(muonroiDir, { recursive: true });
-  mkdirSync(experienceDir, { recursive: true });
-  // Create a minimal config so transcript-emit's isEnabled() returns true.
-  writeFileSync(join(experienceDir, "config.json"), JSON.stringify({}), "utf-8");
-  origUserProfile = process.env.USERPROFILE;
-  process.env.USERPROFILE = tmpHome;
-});
-
-afterEach(() => {
-  cleanDb();
-  if (origUserProfile !== undefined) process.env.USERPROFILE = origUserProfile;
-  else delete process.env.USERPROFILE;
-});
-
-// ── tests ────────────────────────────────────────────────────────────
-
-describe("exportTranscripts", () => {
-  it("no DB file → throws", async () => {
-    // No bootstrapDb call — DB doesn't exist.
-    const mod = await import("../export-transcripts.js");
-    await expect(mod.exportTranscripts()).rejects.toThrow();
-  });
-
-  it("dry-run with 0 sessions => empty result", async () => {
-    await bootstrapDb([]);
-    const mod = await import("../export-transcripts.js");
-    const res = await mod.exportTranscripts({ dryRun: true });
-    expect(res.totalSessions).toBe(0);
-    expect(res.written).toBe(0);
-    expect(res.skippedEmpty).toBe(0);
-    expect(res.skippedTooSmall).toBe(0);
-  });
-
-  it("dry-run emits sessions with >= 4 messages", async () => {
-    await bootstrapDb([
-      {
-        sessionId: "sess-1",
-        updatedAt: new Date().toISOString(),
-        cwdLast: null,
-        messages: [
-          { seq: 1, role: "user", messageJson: JSON.stringify({ content: "hi" }) },
-          { seq: 2, role: "assistant", messageJson: JSON.stringify({ content: "there" }) },
-          { seq: 3, role: "user", messageJson: JSON.stringify({ content: "again" }) },
-          { seq: 4, role: "assistant", messageJson: JSON.stringify({ content: "bye" }) },
-        ],
-      },
-    ]);
-    const mod = await import("../export-transcripts.js");
-    const res = await mod.exportTranscripts({ dryRun: true });
-    expect(res.totalSessions).toBe(1);
-    expect(res.written).toBe(1);
-    expect(res.skippedEmpty).toBe(0);
-    expect(res.skippedTooSmall).toBe(0);
-  });
-
-  it("wet-run writes JSONL files", async () => {
-    await bootstrapDb([
-      {
-        sessionId: "sess-1",
-        updatedAt: new Date().toISOString(),
-        cwdLast: null,
-        messages: [
-          { seq: 1, role: "user", messageJson: JSON.stringify({ content: "hi" }) },
-          { seq: 2, role: "assistant", messageJson: JSON.stringify({ content: "there" }) },
-          { seq: 3, role: "user", messageJson: JSON.stringify({ content: "again" }) },
-          { seq: 4, role: "assistant", messageJson: JSON.stringify({ content: "bye" }) },
-        ],
-      },
-    ]);
-    const mod = await import("../export-transcripts.js");
-    const res = await mod.exportTranscripts({ dryRun: false });
-    expect(res.totalSessions).toBe(1);
-    expect(res.written).toBe(1);
-    expect(res.skippedEmpty).toBe(0);
-    expect(res.skippedTooSmall).toBe(0);
-  });
-
-  it("skips sessions past maxAgeDays", async () => {
-    const old = new Date(Date.now() - 100 * 86400_000).toISOString();
-    await bootstrapDb([
-      {
-        sessionId: "sess-old",
-        updatedAt: old,
-        cwdLast: null,
-        messages: [
-          { seq: 1, role: "user", messageJson: JSON.stringify({ content: "old1" }) },
-          { seq: 2, role: "assistant", messageJson: JSON.stringify({ content: "old resp1" }) },
-          { seq: 3, role: "user", messageJson: JSON.stringify({ content: "old2" }) },
-          { seq: 4, role: "assistant", messageJson: JSON.stringify({ content: "old resp2" }) },
-        ],
-      },
-    ]);
-    const mod = await import("../export-transcripts.js");
-    const res = await mod.exportTranscripts({ dryRun: true, maxAgeDays: 7 });
-    expect(res.totalSessions).toBe(0);
-    expect(res.written).toBe(0);
-  });
-
-  it("skips sessions with too few messages", async () => {
-    await bootstrapDb([
-      {
-        sessionId: "sess-small",
-        updatedAt: new Date().toISOString(),
-        cwdLast: null,
-        messages: [{ seq: 1, role: "user", messageJson: JSON.stringify({ content: "only" }) }],
-      },
-    ]);
-    const mod = await import("../export-transcripts.js");
-    // Default minMessages = 4
-    const res = await mod.exportTranscripts({ dryRun: true });
-    expect(res.totalSessions).toBe(1);
-    expect(res.written).toBe(0);
-    expect(res.skippedTooSmall).toBe(1);
-  });
-
-  it("skippedEmpty when messages table returns nothing for a matched session", async () => {
-    await bootstrapDb([
-      {
-        sessionId: "sess-empty",
-        updatedAt: new Date().toISOString(),
-        cwdLast: null,
-        messages: [],
-      },
-    ]);
-    const mod = await import("../export-transcripts.js");
-    const res = await mod.exportTranscripts({ dryRun: true, maxAgeDays: 30 });
-    expect(res.totalSessions).toBe(1);
-    expect(res.written).toBe(0);
-    expect(res.skippedEmpty).toBe(1);
-  });
-
-  it("bad JSON in message_json row — throws by default", async () => {
-    await bootstrapDb([
-      {
-        sessionId: "sess-bad",
-        updatedAt: new Date().toISOString(),
-        cwdLast: null,
-        messages: [{ seq: 1, role: "user", messageJson: "NOT_VALID_JSON" }],
-      },
-    ]);
-    const mod = await import("../export-transcripts.js");
-    // The function's inner callback in .map() wraps JSON.parse in try/catch
-    // and returns null on failure. With null row messages.length<minMessages
-    // so it falls through to skippedTooSmall. This is intentional per source.
-    const res = await mod.exportTranscripts({ dryRun: true, minMessages: 1 });
-    // minMessages=1, but the single row's parse fails → messages.length=0
-    // -> skippedEmpty not skippedTooSmall
-    expect(res.totalSessions).toBe(1);
-    expect(res.written).toBe(0);
-    expect(res.skippedEmpty).toBe(1);
-    expect(res.skippedTooSmall).toBe(0);
-  });
-});

package/src/ee/__tests__/pil-context-bridge.test.ts

@@ -1,59 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { pilContext, resetPilContextCircuit } from "../bridge.js";
-
-vi.mock("../client-mode.js", () => ({
-  getCachedEEClientMode: () => ({ mode: "thin", baseUrl: "https://stub", token: "x" }),
-}));
-vi.mock("../auth.js", () => ({ getCachedServerBaseUrl: () => "https://stub" }));
-
-const mockClient = vi.hoisted(() => ({ pilContext: vi.fn() }));
-vi.mock("../intercept.js", () => ({ getDefaultEEClient: () => mockClient }));
-
-describe("pilContext bridge wrapper", () => {
-  beforeEach(() => {
-    mockClient.pilContext.mockReset();
-    resetPilContextCircuit();
-  });
-
-  it("returns parsed response when client succeeds", async () => {
-    mockClient.pilContext.mockResolvedValueOnce({
-      taskType: "debug",
-      intentKind: "task",
-      outputStyle: "balanced",
-      confidence: 0.8,
-      domain: null,
-      gsd_phase: null,
-      gsd_route_source: "none",
-      t0_principles: [],
-      t1_rules: [],
-      t2_patterns: [],
-      retrieval_skipped_reason: null,
-      cache_hit: false,
-      inference_ms: 100,
-      schema_version: "1.0",
-    });
-    const result = await pilContext("test prompt");
-    expect(result?.taskType).toBe("debug");
-  });
-
-  it("returns null on schema reject", async () => {
-    mockClient.pilContext.mockResolvedValueOnce({ taskType: "debug" }); // missing required fields
-    const result = await pilContext("test");
-    expect(result).toBeNull();
-  });
-
-  it("returns null on client failure", async () => {
-    mockClient.pilContext.mockResolvedValueOnce(null);
-    const result = await pilContext("test");
-    expect(result).toBeNull();
-  });
-
-  it("circuit opens after 5 failures in 30s, short-circuits 6th call", async () => {
-    mockClient.pilContext.mockResolvedValue(null);
-    for (let i = 0; i < 5; i++) await pilContext("test");
-    mockClient.pilContext.mockClear();
-    const result = await pilContext("test");
-    expect(result).toBeNull();
-    expect(mockClient.pilContext).not.toHaveBeenCalled();
-  });
-});

package/src/ee/__tests__/pipeline.integration.test.ts

@@ -1,193 +0,0 @@
-/**
- * End-to-end pipeline integration test (ROUTE-12).
- *
- * Verifies all 5 events fire for a single tool invocation:
- *   PreToolUse (intercept) -> PostToolUse (posttool) -> Judge -> Feedback -> Touch
- *
- * Uses real modules + stub HTTP server — no vi.mock.
- * Anti-patterns avoided:
- *   - No HTTP call ordering by array index (fire-and-forget lands non-deterministically)
- *   - resetEEClientState() in beforeEach (circuit breaker + cache contamination)
- *   - resetHookState() in beforeEach (_lastWarningResponse contamination between tests)
- *   - No vi.mock — integration test uses real modules + stub
- */
-
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { type StubHandle, startStubEEServer } from "../../__test-stubs__/ee-server.js";
-import { executeEventHooks, resetHookState } from "../../hooks/index.js";
-import { createEEClient, resetEEClientState } from "../client.js";
-import { setDefaultEEClient } from "../intercept.js";
-import type { InterceptMatch } from "../types.js";
-
-const sampleMatch: InterceptMatch = {
-  principle_uuid: "P1",
-  confidence: 0.9,
-  why: "test match",
-  message: "warning: test principle",
-  embedding_model_version: "v1",
-  scope_label: "global",
-  last_matched_at: new Date().toISOString(),
-};
-
-describe("EE full pipeline integration (ROUTE-12)", () => {
-  let stub: StubHandle;
-
-  beforeEach(async () => {
-    resetEEClientState();
-    resetHookState();
-  });
-
-  afterEach(async () => {
-    if (stub) await stub.stop();
-    resetEEClientState();
-    resetHookState();
-  });
-
-  it("fires all 5 events for a single tool invocation (intercept -> posttool -> judge -> feedback -> touch)", async () => {
-    stub = await startStubEEServer({
-      intercept: () => ({
-        decision: "allow",
-        matches: [sampleMatch],
-      }),
-    });
-
-    const client = createEEClient({
-      baseUrl: `http://127.0.0.1:${stub.port}`,
-      timeoutMs: 2000,
-    });
-    setDefaultEEClient(client);
-
-    // Event 1: PreToolUse — fires intercept, stores warning in _lastWarningResponse
-    await executeEventHooks(
-      {
-        hook_event_name: "PreToolUse",
-        tool_name: "Edit",
-        tool_input: { path: "/tmp/x.ts" },
-        cwd: process.cwd(),
-      },
-      process.cwd(),
-    );
-
-    // Event 2: PostToolUse — fires posttool + (judge -> feedback + touch via judgeCtx)
-    await executeEventHooks(
-      {
-        hook_event_name: "PostToolUse",
-        tool_name: "Edit",
-        tool_input: { path: "/tmp/x.ts" },
-        tool_output: { result: "ok" },
-        cwd: process.cwd(),
-      },
-      process.cwd(),
-    );
-
-    // Allow fire-and-forget HTTP calls (feedback + touch) to settle
-    await new Promise((r) => setTimeout(r, 500));
-
-    // Assert all 5 pipeline stages fired
-    expect(stub.calls.intercept).toHaveLength(1); // Stage 1: PreToolUse
-    expect(stub.calls.posttool).toHaveLength(1); // Stage 2: PostToolUse
-    expect(stub.calls.feedback.length).toBeGreaterThanOrEqual(1); // Stage 3+4: Judge FOLLOWED -> Feedback
-    expect(stub.calls.touch.length).toBeGreaterThanOrEqual(1); // Stage 5: Touch (FOLLOWED path)
-
-    // Verify feedback classification
-    expect(stub.calls.feedback[0]).toMatchObject({
-      principle_uuid: "P1",
-      classification: "FOLLOWED",
-      tool_name: "Edit",
-    });
-  });
-
-  it("auto-judge classifies IRRELEVANT when no matches — feedback and touch not called", async () => {
-    stub = await startStubEEServer({
-      intercept: () => ({
-        decision: "allow",
-        matches: [], // empty matches => IRRELEVANT
-      }),
-    });
-
-    const client = createEEClient({
-      baseUrl: `http://127.0.0.1:${stub.port}`,
-      timeoutMs: 2000,
-    });
-    setDefaultEEClient(client);
-
-    await executeEventHooks(
-      {
-        hook_event_name: "PreToolUse",
-        tool_name: "Edit",
-        tool_input: { path: "/tmp/y.ts" },
-        cwd: process.cwd(),
-      },
-      process.cwd(),
-    );
-
-    await executeEventHooks(
-      {
-        hook_event_name: "PostToolUse",
-        tool_name: "Edit",
-        tool_input: { path: "/tmp/y.ts" },
-        tool_output: { result: "ok" },
-        cwd: process.cwd(),
-      },
-      process.cwd(),
-    );
-
-    await new Promise((r) => setTimeout(r, 150));
-
-    // intercept + posttool fire, but no feedback or touch (IRRELEVANT has no matches to report)
-    expect(stub.calls.intercept).toHaveLength(1);
-    expect(stub.calls.posttool).toHaveLength(1);
-    expect(stub.calls.feedback).toHaveLength(0); // IRRELEVANT: judge.ts line 33 — no feedback for empty matches
-    expect(stub.calls.touch).toHaveLength(0);
-  });
-
-  it("auto-judge classifies IGNORED when outcome fails — feedback called, touch not called", async () => {
-    stub = await startStubEEServer({
-      intercept: () => ({
-        decision: "allow",
-        matches: [sampleMatch],
-      }),
-    });
-
-    const client = createEEClient({
-      baseUrl: `http://127.0.0.1:${stub.port}`,
-      timeoutMs: 2000,
-    });
-    setDefaultEEClient(client);
-
-    // PreToolUse to populate _lastWarningResponse with matches
-    await executeEventHooks(
-      {
-        hook_event_name: "PreToolUse",
-        tool_name: "Bash",
-        tool_input: { command: "exit 1" },
-        cwd: process.cwd(),
-      },
-      process.cwd(),
-    );
-
-    // PostToolUseFailure — outcome.success=false => IGNORED classification
-    await executeEventHooks(
-      {
-        hook_event_name: "PostToolUseFailure",
-        tool_name: "Bash",
-        tool_input: { command: "exit 1" },
-        error: "exit code 1",
-        cwd: process.cwd(),
-      },
-      process.cwd(),
-    );
-
-    await new Promise((r) => setTimeout(r, 150));
-
-    expect(stub.calls.intercept).toHaveLength(1);
-    expect(stub.calls.posttool).toHaveLength(1);
-    expect(stub.calls.feedback).toHaveLength(1); // IGNORED: feedback fires
-    expect(stub.calls.touch).toHaveLength(0); // IGNORED: touch does NOT fire
-
-    expect(stub.calls.feedback[0]).toMatchObject({
-      principle_uuid: "P1",
-      classification: "IGNORED",
-    });
-  });
-});