@pugi/cli 0.1.0-beta.10 → 0.1.0-beta.100

package/dist/core/agents/adaptive-router.js

@@ -0,0 +1,330 @@
+/**
+ * Adaptive router — primitive #4 of the 9-layer RAG architecture gap
+ * analysis (docs/research/2026-05-31-9-layer-rag-architecture-.md).
+ *
+ * Picks the best source (RAG workspace / web fetch / code-intel / cache
+ * tier / agent persona / tool) for a given query by asking an LLM to
+ * rank candidates from a caller-supplied catalog. The router is pure
+ * logic — it never opens a network connection itself. The caller
+ * injects a `transport` callback that maps a prompt string to a model
+ * response string, which keeps Anvil-engine wiring (Hiroshi persona,
+ * auth, retry, telemetry) out of the primitive and makes tests
+ * deterministic.
+ *
+ * Failure model is fail-closed to a heuristic pick. Every malformed
+ * response, transport throw, schema violation, empty catalog, or
+ * unknown source id collapses to a deterministic ranking based on
+ * `kind` priority (cache > agent > everything-else, in catalog order).
+ * The caller inspects `usedFallback` plus `reason` and decides whether
+ * the degradation is acceptable for the active route. Routing is never
+ * load-bearing for correctness — the caller can always fall back to a
+ * monolithic default source.
+ *
+ * Composition with sibling primitives:
+ *  - #3 query-decomposer feeds an ordered SubQuery list. The engine
+ *    consumer will call `chooseRoute` once per SubQuery to pick the
+ *    per-step source. That binding lives in the engine wire-up PR, not
+ *    here.
+ *  - #5 pre-flight token estimator may pre-set `tierBudget` to gate
+ *    out 'expensive' sources before the LLM call is made.
+ *
+ * Out of scope (separate PRs):
+ *  - Engine wire-up that binds Hiroshi persona to `transport`.
+ *  - Source-catalog registry — caller supplies the catalog per call.
+ *  - Per-source cost telemetry (separate follow-up).
+ *  - Streaming partial-ranks during LLM emission.
+ */
+import { estimateTokens } from '../compact/token-counter.js';
+/** Whitelisted source kinds. New kinds require a corresponding catalog migration. */
+const SOURCE_KIND_VALUES = ['rag', 'web', 'code', 'cache', 'agent', 'tool'];
+const DEFAULT_MAX_FALLBACKS = 3;
+const DEFAULT_MAX_INPUT_TOKENS = 4000;
+/** Hard upper bound on pickIds we accept from the LLM. 1 primary + 3 fallbacks. */
+const HARD_MAX_PICKS = 4;
+/** Trim the user query before substitution. Keeps router prompt within sane bounds. */
+const PROMPT_QUERY_HARD_CAP_CHARS = 2000;
+/**
+ * Prompt template embedded as a constant so the primitive has zero
+ * filesystem dependencies. The `{contextHint}`, `{query}`, and
+ * `{candidates}` markers are substituted at call time. The instruction
+ * explicitly forbids markdown fences and prose around the JSON, which
+ * trims the most common parse failures observed with mid-tier models.
+ */
+export const ADAPTIVE_ROUTER_PROMPT_TEMPLATE = [
+    'You are an adaptive router for a software-engineering AI assistant.',
+    "Pick the best source(s) from the candidate list to answer the user's query.",
+    '',
+    'Return JSON only matching this schema:',
+    '{ "pickIds": ["source-id-1", "source-id-2", ...], "confidence": 0.85, "reasoning": "..." }',
+    '',
+    'Rules:',
+    '- Order pickIds best to worst (first = primary).',
+    '- Max 4 ids total (1 primary + up to 3 fallbacks).',
+    '- confidence in [0, 1].',
+    '- reasoning is one sentence under 200 chars.',
+    '- No prose around JSON. No markdown fences.',
+    '',
+    'CONTEXT: {contextHint}',
+    'QUERY: {query}',
+    '',
+    'CANDIDATES:',
+    '{candidates}',
+].join('\n');
+/**
+ * Pick the best source(s) for a query. Never throws.
+ *
+ * Every internal failure mode collapses to a heuristic fallback that
+ * still produces a usable `RouteDecision`. Caller inspects
+ * `usedFallback` and `reason` to decide whether to surface a warning or
+ * treat the routing as opaque.
+ */
+export async function chooseRoute(opts) {
+    const filtered = filterCatalog(opts.catalog, opts.tierBudget);
+    const maxFallbacks = clampMaxFallbacks(opts.maxFallbacks);
+    const maxInputTokens = clampMaxInputTokens(opts.maxInputTokens);
+    if (filtered.length === 0) {
+        return emptyCatalogFallback();
+    }
+    if (filtered.length === 1) {
+        // Single available source — no need to round-trip through the LLM.
+        const only = filtered[0];
+        if (!only)
+            return emptyCatalogFallback();
+        return {
+            primary: only,
+            fallbacks: [],
+            confidence: 1,
+            usedFallback: false,
+        };
+    }
+    const safeQuery = truncateToTokenBudget(opts.query.trim(), maxInputTokens);
+    const prompt = buildPrompt(safeQuery, opts.contextHint ?? 'unknown', filtered);
+    let raw;
+    try {
+        raw = await opts.transport(prompt);
+    }
+    catch {
+        return heuristicFallback(filtered, maxFallbacks, 'transport-error');
+    }
+    const parsed = parseAndValidate(raw, filtered);
+    if (!parsed.ok) {
+        return heuristicFallback(filtered, maxFallbacks, parsed.reason);
+    }
+    const ranked = parsed.sources;
+    const first = ranked[0];
+    if (!first) {
+        return heuristicFallback(filtered, maxFallbacks, 'empty-pick-ids');
+    }
+    const fallbacks = ranked.slice(1, 1 + maxFallbacks);
+    return {
+        primary: first,
+        fallbacks,
+        confidence: clampConfidence(parsed.confidence),
+        reasoning: parsed.reasoning,
+        usedFallback: false,
+    };
+}
+// -----------------------------------------------------------------------
+// Internals
+// -----------------------------------------------------------------------
+function filterCatalog(catalog, tierBudget) {
+    const out = [];
+    for (const source of catalog) {
+        if (!source.available)
+            continue;
+        if (tierBudget === 'cheap' && source.costHint === 'expensive')
+            continue;
+        out.push(source);
+    }
+    return out;
+}
+function buildPrompt(query, contextHint, sources) {
+    const trimmedQuery = query.length > PROMPT_QUERY_HARD_CAP_CHARS
+        ? query.slice(0, PROMPT_QUERY_HARD_CAP_CHARS)
+        : query;
+    const candidateLines = sources
+        .map((s) => `- ${s.id} (${s.kind}, ${s.costHint}, ${s.latencyHint}): ${s.description}`)
+        .join('\n');
+    return ADAPTIVE_ROUTER_PROMPT_TEMPLATE
+        .replace('{contextHint}', contextHint)
+        .replace('{query}', trimmedQuery)
+        .replace('{candidates}', candidateLines);
+}
+function parseAndValidate(raw, catalog) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stripFences(raw));
+    }
+    catch {
+        return { ok: false, reason: 'parse-failed' };
+    }
+    if (!isRecord(parsed)) {
+        return { ok: false, reason: 'schema-violation' };
+    }
+    const pickIdsRaw = parsed.pickIds;
+    if (!Array.isArray(pickIdsRaw)) {
+        return { ok: false, reason: 'schema-violation' };
+    }
+    if (pickIdsRaw.length === 0) {
+        return { ok: false, reason: 'empty-pick-ids' };
+    }
+    const byId = new Map(catalog.map((s) => [s.id, s]));
+    const seen = new Set();
+    const resolved = [];
+    for (const candidate of pickIdsRaw) {
+        if (typeof candidate !== 'string') {
+            return { ok: false, reason: 'schema-violation' };
+        }
+        if (seen.has(candidate)) {
+            return { ok: false, reason: 'duplicate-pick-id' };
+        }
+        const source = byId.get(candidate);
+        if (!source) {
+            return { ok: false, reason: 'unknown-source-id' };
+        }
+        seen.add(candidate);
+        resolved.push(source);
+        // Cap at the hard ceiling so a malicious / runaway LLM cannot make us allocate unbounded fallbacks.
+        if (resolved.length >= HARD_MAX_PICKS)
+            break;
+    }
+    const confidenceRaw = parsed.confidence;
+    // Confidence is intentionally lenient — we coerce non-numbers to 0.5
+    // and clamp the rest. Out-of-range is NOT a fallback trigger per the
+    // spec: pickIds is the load-bearing field.
+    const confidence = typeof confidenceRaw === 'number' && Number.isFinite(confidenceRaw)
+        ? confidenceRaw
+        : 0.5;
+    const reasoningRaw = parsed.reasoning;
+    const reasoning = typeof reasoningRaw === 'string' && reasoningRaw.trim().length > 0
+        ? reasoningRaw.trim()
+        : undefined;
+    return {
+        ok: true,
+        sources: resolved,
+        confidence,
+        ...(reasoning !== undefined ? { reasoning } : {}),
+    };
+}
+/**
+ * Heuristic ranking applied when the LLM call fails. Priority order:
+ *
+ *  1. `kind === 'cache'` first (always cheapest and safe to try).
+ *  2. `kind === 'agent'` next (persona has its own routing intelligence).
+ *  3. Everything else in the catalog's natural order.
+ *
+ * Within each bucket the catalog's natural order acts as a stable
+ * tiebreaker — the caller controls the priority by ordering the
+ * catalog deliberately.
+ */
+function heuristicFallback(catalog, maxFallbacks, reason) {
+    const ranked = heuristicRank(catalog);
+    const first = ranked[0];
+    // Defensive: caller guarantees catalog.length >= 1 by the time we
+    // get here (the `filtered.length === 0` short-circuit runs upstream),
+    // but the type checker needs the guard.
+    if (!first)
+        return emptyCatalogFallback();
+    const fallbacks = ranked.slice(1, 1 + maxFallbacks);
+    return {
+        primary: first,
+        fallbacks,
+        confidence: 0,
+        usedFallback: true,
+        reason,
+    };
+}
+function heuristicRank(catalog) {
+    const cache = [];
+    const agents = [];
+    const rest = [];
+    for (const source of catalog) {
+        if (source.kind === 'cache')
+            cache.push(source);
+        else if (source.kind === 'agent')
+            agents.push(source);
+        else
+            rest.push(source);
+    }
+    return [...cache, ...agents, ...rest];
+}
+/**
+ * Synthetic fallback used only when the filtered catalog is empty.
+ * The caller MUST treat `usedFallback === true` as a signal to skip
+ * the routed step — the `primary` here is a placeholder so the return
+ * type stays non-nullable.
+ */
+function emptyCatalogFallback() {
+    return {
+        primary: {
+            id: 'unknown',
+            kind: 'tool',
+            description: 'No source available for this query.',
+            costHint: 'cheap',
+            latencyHint: 'sub-second',
+            available: false,
+        },
+        fallbacks: [],
+        confidence: 0,
+        usedFallback: true,
+        reason: 'empty-catalog',
+    };
+}
+function clampMaxFallbacks(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        return DEFAULT_MAX_FALLBACKS;
+    }
+    return Math.floor(value);
+}
+function clampMaxInputTokens(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 1) {
+        return DEFAULT_MAX_INPUT_TOKENS;
+    }
+    return Math.floor(value);
+}
+function clampConfidence(value) {
+    if (!Number.isFinite(value))
+        return 0.5;
+    if (value < 0)
+        return 0;
+    if (value > 1)
+        return 1;
+    return value;
+}
+/**
+ * Truncate input to the token budget using the existing chars/4
+ * heuristic. We slice by characters proportional to the budget rather
+ * than binary-searching `estimateTokens`, because the heuristic is
+ * monotonic in length and an over-shoot is acceptable — the prompt also
+ * carries the static template overhead.
+ */
+function truncateToTokenBudget(text, maxTokens) {
+    const current = estimateTokens(text);
+    if (current <= maxTokens)
+        return text;
+    const ratio = maxTokens / current;
+    const targetLength = Math.max(1, Math.floor(text.length * ratio));
+    return text.slice(0, targetLength);
+}
+/**
+ * Tolerate the most common mid-tier-model deviation: wrapping JSON in
+ * a fenced code block. We strip a single leading and trailing fence
+ * marker when both are present; otherwise the raw text is returned
+ * unchanged and `JSON.parse` will reject it through the normal path.
+ */
+function stripFences(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith('```'))
+        return trimmed;
+    const firstNewline = trimmed.indexOf('\n');
+    if (firstNewline < 0)
+        return trimmed;
+    const closing = trimmed.lastIndexOf('```');
+    if (closing <= firstNewline)
+        return trimmed;
+    return trimmed.slice(firstNewline + 1, closing).trim();
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+//# sourceMappingURL=adaptive-router.js.map

package/dist/core/agents/query-decomposer.js

@@ -0,0 +1,297 @@
+/**
+ * Query decomposer — primitive #3 of the 9-layer RAG architecture gap
+ * analysis (docs/research/2026-05-31-9-layer-rag-architecture-.md).
+ *
+ * Splits a user request into ordered atomic sub-queries the engine can
+ * route, plan, and execute step-by-step. This file is pure logic — it
+ * never opens a network connection itself. The caller injects a
+ * `transport` callback that maps a prompt string to a model response
+ * string, which keeps Anvil-engine wiring (Hiroshi persona, auth,
+ * retry, telemetry) out of the primitive and makes tests deterministic.
+ *
+ * Failure model is fail-closed to a single-step pass-through. Every
+ * malformed response, transport throw, schema violation, dependency
+ * cycle, or oversized step list collapses to:
+ *
+ *  { steps: [{ id: 'step-1', query, dependsOn: [], intent: 'unknown' }],
+ *    usedFallback: true, reason: '<why>' }
+ *
+ * The caller inspects `usedFallback` plus `reason` and decides whether
+ * the degradation is acceptable for the active route. Decomposition is
+ * never load-bearing for correctness — the engine can always treat the
+ * pass-through as the original query.
+ *
+ * Out of scope (separate PRs):
+ *  - Engine wire-up that binds Hiroshi persona to `transport`.
+ *  - Adaptive router (primitive #4) that consumes the step list.
+ *  - Cost telemetry for the decomposer call itself.
+ */
+import { estimateTokens } from '../compact/token-counter.js';
+/** Whitelisted intent categories. Anything outside collapses to 'unknown'. */
+const INTENT_VALUES = ['read', 'write', 'verify', 'plan', 'explain', 'unknown'];
+const DEFAULT_MAX_STEPS = 8;
+const DEFAULT_MAX_INPUT_TOKENS = 4000;
+const STEP_ID_PATTERN = /^step-\d+$/;
+/**
+ * Prompt template embedded as a constant so the primitive has zero
+ * filesystem dependencies. The `{query}` marker is substituted at call
+ * time. The instruction explicitly forbids markdown fences and prose
+ * around the JSON, which trims the most common parse failures observed
+ * with mid-tier models.
+ */
+export const DECOMPOSER_PROMPT_TEMPLATE = [
+    'You are a query decomposer for a software-engineering AI assistant.',
+    "Split the user's request into atomic ordered steps.",
+    '',
+    'Return JSON only, matching this exact schema:',
+    '{ "steps": [{ "id": "step-N", "query": "...", "dependsOn": ["step-M", ...], "intent": "read|write|verify|plan|explain|unknown" }] }',
+    '',
+    'Rules:',
+    '- Max 8 steps.',
+    '- Single-step queries return one step.',
+    '- "dependsOn" lists earlier step IDs this step needs. Empty if independent.',
+    '- "intent" is the top action verb category.',
+    '- No prose around the JSON. No markdown fences.',
+    '',
+    'USER QUERY:',
+    '{query}',
+].join('\n');
+/**
+ * Decompose a query into ordered atomic sub-queries.
+ *
+ * The function never throws. Every internal failure mode collapses to
+ * a single-step fallback result. Caller inspects `usedFallback` and
+ * `reason` to decide whether to surface a warning or treat the
+ * decomposition as opaque.
+ */
+export async function decomposeQuery(query, opts) {
+    const trimmed = query.trim();
+    if (trimmed.length === 0) {
+        return fallback(query, 'empty-query');
+    }
+    const maxSteps = clampMaxSteps(opts.maxSteps);
+    const maxInputTokens = clampMaxInputTokens(opts.maxInputTokens);
+    const safeQuery = truncateToTokenBudget(trimmed, maxInputTokens);
+    const prompt = DECOMPOSER_PROMPT_TEMPLATE.replace('{query}', safeQuery);
+    let raw;
+    try {
+        raw = await opts.transport(prompt);
+    }
+    catch {
+        return fallback(safeQuery, 'transport-error');
+    }
+    const parseResult = parseAndValidate(raw, maxSteps);
+    if (parseResult.ok) {
+        return { steps: parseResult.steps, usedFallback: false };
+    }
+    return fallback(safeQuery, parseResult.reason);
+}
+function parseAndValidate(raw, maxSteps) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stripFences(raw));
+    }
+    catch {
+        return { ok: false, reason: 'parse-failed' };
+    }
+    if (!isRecord(parsed)) {
+        return { ok: false, reason: 'schema-violation' };
+    }
+    const stepsRaw = parsed.steps;
+    if (!Array.isArray(stepsRaw)) {
+        return { ok: false, reason: 'schema-violation' };
+    }
+    if (stepsRaw.length === 0) {
+        return { ok: false, reason: 'empty-step-list' };
+    }
+    if (stepsRaw.length > maxSteps) {
+        return { ok: false, reason: 'exceeds-max-steps' };
+    }
+    const steps = [];
+    const seenIds = new Set();
+    for (const candidate of stepsRaw) {
+        const built = buildStep(candidate);
+        if (!built.ok) {
+            return { ok: false, reason: built.reason };
+        }
+        if (seenIds.has(built.step.id)) {
+            return { ok: false, reason: 'duplicate-id' };
+        }
+        seenIds.add(built.step.id);
+        steps.push(built.step);
+    }
+    for (const step of steps) {
+        for (const dep of step.dependsOn) {
+            if (!seenIds.has(dep)) {
+                return { ok: false, reason: 'unknown-dependency' };
+            }
+        }
+    }
+    if (hasCycle(steps)) {
+        return { ok: false, reason: 'dependency-cycle' };
+    }
+    return { ok: true, steps };
+}
+function buildStep(candidate) {
+    if (!isRecord(candidate)) {
+        return { ok: false, reason: 'schema-violation' };
+    }
+    const id = candidate.id;
+    const query = candidate.query;
+    const dependsOn = candidate.dependsOn;
+    const intent = candidate.intent;
+    if (typeof id !== 'string' || !STEP_ID_PATTERN.test(id)) {
+        return { ok: false, reason: 'schema-violation' };
+    }
+    if (typeof query !== 'string' || query.trim().length === 0) {
+        return { ok: false, reason: 'schema-violation' };
+    }
+    const depsList = [];
+    if (dependsOn !== undefined) {
+        if (!Array.isArray(dependsOn)) {
+            return { ok: false, reason: 'schema-violation' };
+        }
+        for (const dep of dependsOn) {
+            if (typeof dep !== 'string' || !STEP_ID_PATTERN.test(dep)) {
+                return { ok: false, reason: 'schema-violation' };
+            }
+            if (dep === id) {
+                // self-dependency is a degenerate cycle, surface explicitly
+                return { ok: false, reason: 'dependency-cycle' };
+            }
+            depsList.push(dep);
+        }
+    }
+    let intentValue;
+    if (intent === undefined) {
+        intentValue = 'unknown';
+    }
+    else if (typeof intent === 'string' && isIntent(intent)) {
+        intentValue = intent;
+    }
+    else {
+        return { ok: false, reason: 'schema-violation' };
+    }
+    return {
+        ok: true,
+        step: {
+            id,
+            query: query.trim(),
+            dependsOn: depsList,
+            intent: intentValue,
+        },
+    };
+}
+/**
+ * Cycle detection via iterative depth-first search with coloring.
+ * `WHITE` = unvisited, `GRAY` = on current stack, `BLACK` = fully
+ * explored. A back edge to a GRAY node is a cycle.
+ */
+function hasCycle(steps) {
+    const WHITE = 0;
+    const GRAY = 1;
+    const BLACK = 2;
+    const colors = new Map();
+    for (const step of steps)
+        colors.set(step.id, WHITE);
+    const byId = new Map(steps.map((s) => [s.id, s]));
+    for (const root of steps) {
+        if (colors.get(root.id) !== WHITE)
+            continue;
+        const stack = [{ id: root.id, depIdx: 0 }];
+        colors.set(root.id, GRAY);
+        while (stack.length > 0) {
+            const frame = stack[stack.length - 1];
+            if (!frame)
+                break;
+            const node = byId.get(frame.id);
+            if (!node) {
+                stack.pop();
+                continue;
+            }
+            if (frame.depIdx >= node.dependsOn.length) {
+                colors.set(node.id, BLACK);
+                stack.pop();
+                continue;
+            }
+            const next = node.dependsOn[frame.depIdx];
+            frame.depIdx += 1;
+            if (next === undefined)
+                continue;
+            const c = colors.get(next);
+            if (c === GRAY)
+                return true;
+            if (c === WHITE) {
+                colors.set(next, GRAY);
+                stack.push({ id: next, depIdx: 0 });
+            }
+        }
+    }
+    return false;
+}
+function fallback(query, reason) {
+    return {
+        steps: [
+            {
+                id: 'step-1',
+                query: query.trim(),
+                dependsOn: [],
+                intent: 'unknown',
+            },
+        ],
+        usedFallback: true,
+        reason,
+    };
+}
+function clampMaxSteps(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 1) {
+        return DEFAULT_MAX_STEPS;
+    }
+    return Math.floor(value);
+}
+function clampMaxInputTokens(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 1) {
+        return DEFAULT_MAX_INPUT_TOKENS;
+    }
+    return Math.floor(value);
+}
+/**
+ * Truncate input to the token budget using the existing chars/4
+ * heuristic. We slice by characters proportional to the budget rather
+ * than by binary-searching `estimateTokens`, because the heuristic is
+ * monotonic in length and an over-shoot is acceptable — the prompt
+ * also carries the static template overhead.
+ */
+function truncateToTokenBudget(text, maxTokens) {
+    const current = estimateTokens(text);
+    if (current <= maxTokens)
+        return text;
+    const ratio = maxTokens / current;
+    const targetLength = Math.max(1, Math.floor(text.length * ratio));
+    return text.slice(0, targetLength);
+}
+/**
+ * Tolerate the most common mid-tier-model deviation: wrapping JSON in
+ * a fenced code block. We strip a single leading and trailing fence
+ * marker when both are present; otherwise the raw text is returned
+ * unchanged and `JSON.parse` will reject it through the normal path.
+ */
+function stripFences(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.startsWith('```'))
+        return trimmed;
+    const firstNewline = trimmed.indexOf('\n');
+    if (firstNewline < 0)
+        return trimmed;
+    const closing = trimmed.lastIndexOf('```');
+    if (closing <= firstNewline)
+        return trimmed;
+    return trimmed.slice(firstNewline + 1, closing).trim();
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isIntent(value) {
+    return INTENT_VALUES.includes(value);
+}
+//# sourceMappingURL=query-decomposer.js.map

package/dist/core/agents/registry.js

@@ -7,10 +7,10 @@
  * that mapping lives — keep it tight and explicit so persona drift never
  * leaks back into the dispatch surface.
  *
- * M1 closed set (ADR-0056 Sprint α5.1): 9 roles, all mapped to Tier 1
+ * M1 closed set : 9 roles, all mapped to Tier 1
  * Engineering Core or Tier 2 Specialist personas from THE_TEN. Tier 1
  * Missing Functions (Growth/Legal/Security/Sales/Support) are deferred
- * to α7.5; Sigma is intentionally absent because it is an OES Enterprise
+ * to ; Sigma is intentionally absent because it is an OES Enterprise
  * persona via Anvil triple-review proxy, not a Cyber-Zoo brand persona.
  */
 import { THE_TEN, getPersona } from '@pugi/personas';
@@ -30,7 +30,7 @@ function requirePersona(slug) {
 /**
  * CLI-only role-to-persona mapping. Roles are dispatcher-facing strings;
  * personas come from the brand-canonical THE_TEN. Vera (qa) intentionally
- * dual-roles as verifier + reviewer per ADR-0056 — the cabinet's review
+ * dual-roles as verifier + reviewer per  — the cabinet's review
  * pipeline already merges the two surfaces.
  */
 export const SUBAGENT_REGISTRY = [