muonroi-cli 1.2.3 → 1.3.1

package/src/council/types.ts

@@ -0,0 +1,286 @@
+import type { ModelMessage } from "ai";
+import type { ProcessMessageObserver } from "../orchestrator/agent-options.js";
+import type { StreamChunk } from "../types/index.js";
+import type { ModelRole } from "../utils/settings.js";
+
+// ── Clarification Phase ─────────────────────────────────────────────────────
+
+export interface CouncilQuestion {
+  questionId: string;
+  question: string;
+  context?: string;
+  suggestions?: string[];
+  isRequired: boolean;
+}
+
+export interface ClarifiedSpec {
+  problemStatement: string;
+  constraints: string[];
+  successCriteria: string[];
+  scope: string;
+  rawQA: Array<{ question: string; answer: string }>;
+  /** Maps dimension IDs to their resolution status. Used by Product Loop. */
+  resolved?: Record<string, "answered" | "unspecified" | "skipped">;
+}
+
+// ── Preflight ────────────────────────────────────────────────────────────────
+
+export interface CouncilPreflight {
+  preflightId: string;
+  problemStatement: string;
+  constraints: string[];
+  successCriteria: string[];
+  scope: string;
+  participants: Array<{ role: string; model: string }>;
+  researchNeeded: boolean;
+}
+
+// ── Debate Phase ─────────────────────────────────────────────────────────────
+
+export interface LeaderEvaluation {
+  allCriteriaMet: boolean;
+  criteriaStatus: Array<{ criterion: string; met: boolean; evidence: string }>;
+  unresolvedPoints: string[];
+  needsResearch: boolean;
+  researchQuery?: string;
+  shouldContinue: boolean;
+  reason: string;
+  /** Citations / total verifiable claims ratio (0.0–1.0). Computed by evaluateDebate after each round. */
+  evidenceDensity?: number;
+  /** Count of [REFUTED] tags + explicit concessions found in the exchange text. */
+  disagreementResolved?: number;
+  /**
+   * Leader-requested round extension. When set and `shouldContinue=true`, the
+   * debate loop bumps its max-rounds budget by this amount, capped at the
+   * absolute hard ceiling. Use sparingly — only when the debate is genuinely
+   * close to resolving the last unresolved point.
+   */
+  extendRounds?: number;
+}
+
+export interface DebateState {
+  spec: ClarifiedSpec;
+  exchangeLogs: Map<string, string[]>;
+  runningSummary: string;
+  roundCount: number;
+  researchFindings?: string;
+  active: CouncilParticipant[]; // mutated positions from debate rounds — NEW (Phase 14 CQ-02)
+  /** Evidence density from the final leader evaluation (0.0–1.0). Drives confidence badge. */
+  finalEvidenceDensity?: number;
+  /** Role-indexed per-round positions for follow-up citations. */
+  archive?: DebateArchiveEntry[];
+}
+
+/**
+ * Single position taken by a participant in one round. Used to answer
+ * "who said what" follow-ups after the debate ends.
+ *
+ * NOTE: stores an `excerpt` (head-truncated) instead of the full position
+ * text. The full content lives in `[Debate Transcript]`; the archive is a
+ * citation index only. Persisting full text here used to grow the
+ * `[Council Memory]` record to 70KB+ per session.
+ */
+export interface DebateArchiveEntry {
+  round: number;
+  role: ModelRole;
+  model: string;
+  stanceName?: string;
+  /** Head excerpt (~400 chars) for citation in follow-ups. */
+  excerpt: string;
+  /** Original full length so the digest can hint at how much was trimmed. */
+  length: number;
+  toolsUsed?: string[];
+}
+
+/**
+ * A debate stance is the lens a participant adopts for a SPECIFIC topic.
+ * Decoupled from {@link ModelRole} (which only picks a model slot from config).
+ * Leader LLM proposes stances per topic at planning time.
+ */
+export interface DebateStance {
+  /** Short label, e.g. "Comparative Analyst", "Cost Skeptic". */
+  name: string;
+  /** One-sentence lens, e.g. "How does the subject compare to alternatives?" */
+  lens: string;
+  /** Optional concrete focus, e.g. "Cite numbers with sources only". */
+  focus?: string;
+}
+
+export interface CouncilParticipant {
+  role: ModelRole;
+  model: string;
+  position: string;
+  /** Set after debate planning — leader-proposed stance for this topic. */
+  stance?: DebateStance;
+}
+
+// ── Planning Phase ───────────────────────────────────────────────────────────
+
+export interface ActionPlan {
+  steps: Array<{
+    description: string;
+    agent?: string;
+    priority: "high" | "medium" | "low";
+  }>;
+  estimatedComplexity: "trivial" | "moderate" | "complex";
+  prerequisites: string[];
+}
+
+// ── Council Outcome (extends existing for backward compat) ───────────────────
+
+/**
+ * Output shape proposed by the leader LLM per topic.
+ * Drives both the synthesis JSON schema and the human-readable Markdown sections.
+ */
+export interface OutputSection {
+  /** JSON key in the final outcome, e.g. "strengths", "actionItems". */
+  key: string;
+  /** Markdown heading rendered to the user, e.g. "Strengths". */
+  heading: string;
+  /** Hint to the synthesizer LLM about what belongs in this section. */
+  prompt: string;
+  /** "list" → array of strings; "text" → free-form string; "objectList" → array of objects. */
+  shape: "list" | "text" | "objectList";
+}
+
+export interface OutputShape {
+  /** Free-form label (e.g. "evaluation", "implementation_plan", "decision"). */
+  kind: string;
+  sections: OutputSection[];
+  /** Behavioural rules the synthesizer must obey. */
+  guardrails: string[];
+}
+
+export interface DebatePlan {
+  /** Leader's one-sentence read of what the user actually asked for. */
+  intentSummary: string;
+  /** Leader-proposed stances. Length usually 2-4. */
+  stances: DebateStance[];
+  /** Leader-proposed output schema for the synthesis step. */
+  outputShape: OutputShape;
+  /**
+   * Leader-proposed initial round budget (1–5). Defaults to 3 when the
+   * planner omits it. The debate loop may extend up to a hard ceiling when
+   * the leader evaluation requests `extendRounds`.
+   */
+  plannedRounds?: number;
+}
+
+export interface EnhancedCouncilOutcome {
+  /** Free-form (drives by leader plan). Common: decision, action_items, plan_update, evaluation, resolve_question. */
+  type: string;
+  summary: string;
+  /** Dynamic sections — keys mirror {@link OutputShape.sections}. */
+  sections?: Record<string, unknown>;
+  // Back-compat fields. Synthesizer fills whichever match the shape.
+  agreed?: string[];
+  tradeoffs?: string[];
+  recommendation?: string;
+  actionItems?: string[];
+  planUpdate?: string;
+  resolvedQuestion?: { question: string; answer: string };
+  plan?: ActionPlan;
+}
+
+// ── Config ───────────────────────────────────────────────────────────────────
+
+export interface CouncilConfig {
+  topic: string;
+  conversationContext: string;
+  leaderModelId: string;
+  participants: CouncilParticipant[];
+  /** Leader-proposed plan; if absent, debate falls back to role-only prompts. */
+  debatePlan?: DebatePlan;
+  signal?: AbortSignal;
+  observer?: ProcessMessageObserver;
+  skipClarification?: boolean;
+  userModelMessage?: ModelMessage;
+  /** When true, runDebate skips the research phase even if the leader requested it (user override). */
+  researchSkipOverride?: boolean;
+  /** When true, the working directory has no source code yet — research prompt prefers internet sources. */
+  internetFirst?: boolean;
+  /** When true, leader sub-tasks downshift to cheaper tier models on the same provider. */
+  costAware?: boolean;
+}
+
+// ── Persisted Council Memory ─────────────────────────────────────────────────
+
+/**
+ * JSON shape persisted as `[Council Memory] {...}` in the session messages.
+ * Loaded on follow-up turns so the agent can answer "who is the leader?",
+ * "what did the X role say?", and cite specific positions.
+ */
+export interface CouncilMemoryRecord {
+  topic: string;
+  spec: ClarifiedSpec;
+  debatePlan: DebatePlan;
+  leaderModel: string;
+  participants: Array<{ role: string; model: string; stance?: DebateStance }>;
+  finalPositions: Array<{ role: string; position: string }>;
+  /** Role-indexed per-round archive — enables citation by role/round on follow-ups. */
+  archive: DebateArchiveEntry[];
+  synthesis: string;
+  confidence: {
+    level: "high" | "medium" | "low";
+    evidenceDensity: number;
+    rounds: number;
+  };
+  stats: { calls: number; durationMs: number; phases: Array<{ name: string; durationMs: number }> };
+  timestamp: string;
+}
+
+// ── Stats ────────────────────────────────────────────────────────────────────
+
+export interface CouncilStats {
+  calls: number;
+  startMs: number;
+  phases: Array<{ name: string; durationMs: number }>;
+}
+
+// ── LLM abstraction ──────────────────────────────────────────────────────────
+
+export type ToolTraceEmitter = (traceText: string) => void;
+
+/**
+ * Token usage snapshot from a single model call.
+ * Optional side-channel for callers (e.g. sprint-runner) that need real token
+ * counts instead of chars/4 estimates for cap accounting.
+ */
+export interface CouncilCallUsage {
+  inputTokens: number;
+  outputTokens: number;
+  cachedInputTokens: number;
+}
+
+export type UsageCallback = (usage: CouncilCallUsage) => void;
+
+export interface CouncilLLM {
+  generate(
+    modelId: string,
+    system: string,
+    prompt: string,
+    maxTokens?: number,
+    onUsage?: UsageCallback,
+  ): Promise<string>;
+  research(
+    modelId: string,
+    topic: string,
+    conversationContext: string,
+    signal?: AbortSignal,
+    persistTrace?: ToolTraceEmitter,
+    options?: { internetFirst?: boolean },
+    onUsage?: UsageCallback,
+  ): Promise<string>;
+  debate(
+    modelId: string,
+    system: string,
+    prompt: string,
+    signal?: AbortSignal,
+    persistTrace?: ToolTraceEmitter,
+    options?: { enableVerificationTools?: boolean },
+    onUsage?: UsageCallback,
+  ): Promise<{ text: string; toolCalls: Array<{ toolName: string; result?: unknown }> }>;
+}
+
+export type QuestionResponder = (questionId: string) => Promise<string>;
+export type PreflightResponder = (preflightId: string) => Promise<boolean>;

package/src/daemon/scheduler.ts

@@ -1,3 +1,4 @@
+import { getDefaultEEClient } from "../ee/intercept.js";
 import {
   cronMatchesDate,
   getScheduleDaemonStatus,
@@ -9,7 +10,6 @@ import {
   startDetachedHeadlessRun,
   writeScheduleDaemonPid,
 } from "../tools/schedule";
-import { getDefaultEEClient } from "../ee/intercept.js";
 
 export class SchedulerDaemon {
   private readonly schedules = new ScheduleManager();

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

@@ -0,0 +1,223 @@
+/**
+ * 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__/pil-context-bridge.test.ts

@@ -0,0 +1,59 @@
+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

@@ -14,9 +14,9 @@
 
 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 { executeEventHooks, resetHookState } from "../../hooks/index.js";
 import type { InterceptMatch } from "../types.js";
 
 const sampleMatch: InterceptMatch = {
@@ -84,10 +84,10 @@ describe("EE full pipeline integration (ROUTE-12)", () => {
     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)
+    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({
@@ -183,7 +183,7 @@ describe("EE full pipeline integration (ROUTE-12)", () => {
     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.touch).toHaveLength(0); // IGNORED: touch does NOT fire
 
     expect(stub.calls.feedback[0]).toMatchObject({
       principle_uuid: "P1",