@event4u/agent-config 14.10.0 → 14.12.0

package/src/scripts/_lib/host_listing_model.ts

@@ -0,0 +1,192 @@
+/**
+ * host_listing_model — which skill DESCRIPTIONS survive the host's listing budget.
+ *
+ * WHY THIS EXISTS. This package projects ~290 skills and the host does not
+ * deliver ~290 descriptions. Until now that was learned one bare catalogue entry
+ * at a time, from a single first-party observation
+ * (`agents/evidence/analysis/skill-catalogue-description-delivery.md`, 2026-08-08:
+ * five of eight sampled entries arrived bare while all 414 carried a description
+ * on disk). The mechanism behind it is documented upstream and was modelled
+ * nowhere in this tree — `grep -rn skillListingBudgetFraction src docs agents`
+ * returned zero hits before this file.
+ *
+ * THE MECHANISM, AS DOCUMENTED UPSTREAM (code.claude.com/docs/en/skills and
+ * anthropics/claude-code#64606, both read 2026-08-22). Claude Code lists every
+ * skill NAME, and keeps DESCRIPTIONS only up to a fraction of the context
+ * window — 1% by default, ≈8,000 characters on a 200k window — filling by
+ * invocation frequency and capping each entry at 1,536 characters. The fraction
+ * is consumer-settable as `skillListingBudgetFraction`.
+ *
+ * WHAT THIS FILE IS AND IS NOT. It is a pure function over a catalogue and a set
+ * of numbers. It is NOT a measurement of the host: every input above is upstream
+ * PROSE, and three further behaviours the prose leaves open had to be chosen
+ * here. Each such choice is returned in `assumptions`, by id, with the reason —
+ * so a caller that reports "skill X will arrive bare" can always say which part
+ * of that is documented and which part is this repo's guess. The single pinned
+ * observation disagrees with the model on two of eight entries, and
+ * `tests/scripts/host_listing_model.test.ts` asserts the disagreement rather
+ * than tuning it away.
+ *
+ * Pure — no I/O, no clock, no process state.
+ */
+
+/** One catalogue entry as the host is offered it. */
+export interface CatalogueEntry {
+    /** Skill (or wrapped-command) name, as the host lists it. */
+    name: string;
+    /** Length of the `description:` frontmatter value, in characters. */
+    descriptionChars: number;
+}
+
+/** A behaviour this model had to pin down that upstream states as prose. */
+export interface ModelAssumption {
+    id:
+        | 'budget-unit-is-chars'
+        | 'fill-order-is-invocation-frequency'
+        | 'names-are-never-dropped'
+        | 'stop-at-first-overflow'
+        | 'wrapper-overhead-unmodelled';
+    /** Always `upstream-prose` today. A value measured in this repo would not be an assumption. */
+    provenance: 'upstream-prose';
+    why: string;
+}
+
+export type FillOrder = 'usage' | 'alphabetical-fallback';
+
+export interface HostListingModelInput {
+    /** Host context window, in tokens (200_000 for the default Claude Code model). */
+    contextWindowTokens: number;
+    /** `skillListingBudgetFraction`. */
+    fraction?: number;
+    /** Per-entry description cap, in characters. */
+    perEntryCapChars?: number;
+    /** Characters per token used to turn the token-denominated budget into chars. */
+    charsPerToken?: number;
+    /** Per-entry wrapper cost (name, punctuation, newlines). Unmodelled upstream; default 0. */
+    perEntryOverheadChars?: number;
+    /** Names in invocation-frequency order, most-invoked first. Empty / omitted → fallback. */
+    usageOrder?: readonly string[];
+}
+
+export interface HostListingModelResult {
+    /** The description budget for this window, in characters. */
+    budgetChars: number;
+    /** Which order the fill actually used. */
+    fillOrder: FillOrder;
+    /** Names whose description is predicted to reach the model. */
+    surviving: string[];
+    /** Names predicted to arrive listed-but-bare. */
+    bare: string[];
+    /** Characters the surviving descriptions consume. */
+    spentChars: number;
+    /** Every behaviour pinned here that upstream leaves as prose. */
+    assumptions: readonly ModelAssumption[];
+}
+
+/** Documented Claude Code defaults, read 2026-08-22. Not measured in this repo. */
+export const CLAUDE_CODE_LISTING_DEFAULTS = {
+    fraction: 0.01,
+    perEntryCapChars: 1536,
+    charsPerToken: 4,
+    perEntryOverheadChars: 0,
+} as const;
+
+const ASSUMPTIONS: readonly ModelAssumption[] = [
+    {
+        id: 'budget-unit-is-chars',
+        provenance: 'upstream-prose',
+        why:
+            'The docs give the budget as a fraction of the context window (tokens) and then ' +
+            'illustrate it as "≈8,000 characters on 200k", which only reconciles at 4 chars ' +
+            'per token. That ratio is inferred from the illustration, never stated.',
+    },
+    {
+        id: 'fill-order-is-invocation-frequency',
+        provenance: 'upstream-prose',
+        why:
+            'Upstream says the budget fills by invocation frequency, but does not say what ' +
+            'orders entries when no invocation history exists. This model falls back to ' +
+            'alphabetical, which is this repo\'s choice and not upstream behaviour.',
+    },
+    {
+        id: 'names-are-never-dropped',
+        provenance: 'upstream-prose',
+        why:
+            'Claude Code lists every name and budgets only descriptions. Another host ' +
+            '(codex) drops whole entries instead, so this is a per-host property and is not ' +
+            'transferable to a second host without its own model.',
+    },
+    {
+        id: 'stop-at-first-overflow',
+        provenance: 'upstream-prose',
+        why:
+            'The docs describe filling a budget, not packing one. A shorter later entry ' +
+            'might in principle still fit after a longer one has overflowed; this model ' +
+            'stops at the first entry that does not fit rather than skipping past it.',
+    },
+    {
+        id: 'wrapper-overhead-unmodelled',
+        provenance: 'upstream-prose',
+        why:
+            'Each delivered entry also costs its name, separators and newlines. Upstream ' +
+            'quantifies none of that, so the default overhead here is 0 and the budget is ' +
+            'therefore an upper bound on how many descriptions survive.',
+    },
+];
+
+/**
+ * Predict which descriptions the host delivers.
+ *
+ * `usageOrder` names are placed first, in the given order; everything else
+ * follows alphabetically. Entries not present in the catalogue are ignored.
+ */
+export function modelListingBudget(
+    catalogue: readonly CatalogueEntry[],
+    input: HostListingModelInput,
+): HostListingModelResult {
+    const fraction = input.fraction ?? CLAUDE_CODE_LISTING_DEFAULTS.fraction;
+    const perEntryCap = input.perEntryCapChars ?? CLAUDE_CODE_LISTING_DEFAULTS.perEntryCapChars;
+    const charsPerToken = input.charsPerToken ?? CLAUDE_CODE_LISTING_DEFAULTS.charsPerToken;
+    const overhead = input.perEntryOverheadChars ?? CLAUDE_CODE_LISTING_DEFAULTS.perEntryOverheadChars;
+    const usageOrder = input.usageOrder ?? [];
+
+    const budgetChars = Math.floor(input.contextWindowTokens * fraction * charsPerToken);
+    const fillOrder: FillOrder = usageOrder.length > 0 ? 'usage' : 'alphabetical-fallback';
+
+    const byName = new Map(catalogue.map((e) => [e.name, e]));
+    const ordered: CatalogueEntry[] = [];
+    const seen = new Set<string>();
+    for (const name of usageOrder) {
+        const e = byName.get(name);
+        if (e && !seen.has(name)) {
+            ordered.push(e);
+            seen.add(name);
+        }
+    }
+    const rest = catalogue
+        .filter((e) => !seen.has(e.name))
+        .slice()
+        .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+    ordered.push(...rest);
+
+    const surviving: string[] = [];
+    const bare: string[] = [];
+    let spentChars = 0;
+    let overflowed = false;
+    for (const e of ordered) {
+        if (overflowed) {
+            bare.push(e.name);
+            continue;
+        }
+        const cost = Math.min(e.descriptionChars, perEntryCap) + overhead;
+        if (spentChars + cost <= budgetChars) {
+            surviving.push(e.name);
+            spentChars += cost;
+        } else {
+            overflowed = true;
+            bare.push(e.name);
+        }
+    }
+
+    return { budgetChars, fillOrder, surviving, bare, spentChars, assumptions: ASSUMPTIONS };
+}

package/src/scripts/_lib/lean_projection_mode.ts

@@ -0,0 +1,44 @@
+/**
+ * `lean_projection.mode` — ONE definition of what the three modes mean.
+ *
+ * The projector (`condense.ts`) resolves the value with a real YAML parse; the
+ * delivery concern (`hooks/rule_inject_hook.ts`) resolves it with an
+ * indentation-shaped read, because a hook must never fail a tool call because a
+ * parser could not load. Two readers is unavoidable. Two *normalisations* is
+ * not, and would be the defect worth preventing: a projector that writes thin
+ * files while the concern believes the mode is off delivers pointers and no
+ * bodies, which is exactly the 36.2 % arm the delivery mode exists to replace.
+ *
+ * So each side supplies the raw string from its own reader and this module
+ * decides what it means. Anything unrecognised — absent key, typo, `null`,
+ * a non-string — is `eager-all`, today's shipped behaviour: a mode nobody can
+ * spell must never silently thin the standing corpus.
+ */
+
+/** The three projection shapes. `eager-all` is the shipped default. */
+export type LeanProjectionMode = 'eager-all' | 'thin' | 'delivery';
+
+export const DEFAULT_LEAN_PROJECTION_MODE: LeanProjectionMode = 'eager-all';
+
+/** Map a raw settings value onto a mode. Unrecognised → `eager-all`. */
+export function normalizeLeanProjectionMode(raw: unknown): LeanProjectionMode {
+    const v = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+    if (v === 'thin') return 'thin';
+    if (v === 'delivery') return 'delivery';
+    return DEFAULT_LEAN_PROJECTION_MODE;
+}
+
+/**
+ * True when the projector writes pointer stubs instead of bodies.
+ *
+ * `delivery` is a superset of `thin`: it writes the same thin files AND binds
+ * the concern that delivers the bodies back on a trigger.
+ */
+export function writesThinFiles(mode: LeanProjectionMode): boolean {
+    return mode === 'thin' || mode === 'delivery';
+}
+
+/** True only in the mode where a hook delivers rule bodies at runtime. */
+export function deliversBodies(mode: LeanProjectionMode): boolean {
+    return mode === 'delivery';
+}

package/src/scripts/_lib/mcp_bridge.ts

@@ -0,0 +1,199 @@
+/**
+ * mcp_bridge — `.mcp.json` registration and the skill-tier projection lever.
+ *
+ * Extracted from `install.ts` by Phase 2.2 of `road-to-skill-delivery-over-mcp`,
+ * for a mechanical reason worth stating: `check_source_size_budget` is a ratchet
+ * over every line in a file above 1,500, `install.ts` is 5,466 of them, and the
+ * gate's own message says a new violation is fixed and never baselined away. So
+ * the feature lives here and `install.ts` keeps one-line call sites.
+ *
+ * Everything here is a pure function of its arguments or of the file system.
+ * `ensureMcpBridge` is the one exception and takes its writer by injection —
+ * `merge_json_file` lives in `install.ts` (eight other bridges use it) and
+ * importing it back would make the cycle.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+/** `install.ts`'s deploy tuple: [written, skipped, status, paths]. */
+export type DeployTuple = [number, number, string, string[]];
+
+/** The `merge_json_file` signature this module is handed. */
+export type MergeJsonFile = (
+    p: string,
+    new_data: Record<string, unknown>,
+    force: boolean,
+    label: string,
+) => Record<string, unknown>[];
+
+/**
+ * The project-scope MCP server entry Claude Code reads from `.mcp.json`.
+ *
+ * Shape is fixed by `docs/getting-started-local-stdio.md` — the documented
+ * end-user path — so a consumer who followed the docs and a consumer who ran the
+ * installer end up with the same entry rather than two that drift.
+ */
+export const MCP_SERVER_KEY = 'agent-config';
+export const MCP_BRIDGE_ENTRY = {
+    mcpServers: {
+        [MCP_SERVER_KEY]: {
+            command: 'npx',
+            args: ['-y', '@event4u/agent-config', 'mcp-server'],
+        },
+    },
+};
+
+/**
+ * `.mcp.json` — the project-scope MCP config Claude Code reads.
+ *
+ * WHY THE INSTALLER OWNS THIS FILE AND `mcp_render` DOES NOT. `mcp_render`
+ * projects the consumer's OWN root `mcp.json` onto per-tool configs by
+ * overwriting them (`write_target`), which is correct for a file the renderer
+ * generates in full and wrong for one the consumer also edits: a render would
+ * delete both this entry and any server they added by hand. `merge_json_file`
+ * writes only our key, records it as an RFC-6901 pointer in
+ * `agents/installed-tools.lock`, and lets uninstall subtract exactly that key.
+ * `mcp:check` validates the file without ever writing it.
+ *
+ * Default ON for `claude-code`, because `rules/missing-skill-recovery.md` makes
+ * `suggest_skill_for_task` an Iron Law for every consumer and a rule that is
+ * unfulfillable by default is a defect, not a feature. Opting out is the same
+ * lever as every other bridge — deselect the tool (`--tools`), which is the gate
+ * the caller applies; `.agent-tools.yml` is deliberately NOT that lever, it is a
+ * maintainer-side projection-generator allowlist the installer cannot see and
+ * whose tool ids differ from `_VALID_TOOLS`.
+ */
+export function makeEnsureMcpBridge(
+    mergeJsonFile: MergeJsonFile,
+): (projectRoot: string, force: boolean) => Record<string, unknown>[] {
+    return (projectRoot, force) =>
+        mergeJsonFile(path.join(projectRoot, '.mcp.json'), MCP_BRIDGE_ENTRY, force, '.mcp.json');
+}
+
+/**
+ * The three projection modes.
+ *
+ * `legacy-all` ships everything and stays the default. `scoped` narrows to the
+ * active packs. `tiered` narrows to the skills predicted to reach the model WITH
+ * their description, on the theory that a skill the host lists bare is better
+ * served by the MCP recovery tool than by a catalogue entry nobody can read.
+ *
+ * `tiered` is OPT-IN and stays opt-in until the roadmap's Phase 4.4 decides on
+ * evidence — which it did, at `measured-null`. The reason is stated rather than
+ * implied: the split usually comes from an ALPHABETICAL fallback order
+ * (`agents/runtime/metrics/skill-usage.jsonl` is absent on most machines), and
+ * the one real host observation this repo has disagrees with that fallback on
+ * four of eight sampled entries. Defaulting to `tiered` would hide skills on a
+ * prediction the tree itself can show to be wrong — strictly worse than the
+ * bare-but-listed defect it fixes (roadmap risk 4).
+ */
+export type ProjectionMode = 'scoped' | 'legacy-all' | 'tiered';
+
+/** Resolve a raw `projection.mode` value. Anything unrecognised is `legacy-all`. */
+export function projectionModeOf(raw: unknown): ProjectionMode {
+    return raw === 'scoped' ? 'scoped' : raw === 'tiered' ? 'tiered' : 'legacy-all';
+}
+
+/**
+ * Tier B skill names, or `null` when no split exists on this machine.
+ *
+ * `null` is load-bearing: it means "nobody computed a split here", and a
+ * `tiered` install that finds it must ship the FULL surface rather than prune on
+ * an empty set — pruning on absence would delete the entire catalogue. A
+ * malformed file is `null` for the same reason.
+ */
+export function resolveTierB(packageRoot: string): ReadonlySet<string> | null {
+    const p = path.join(packageRoot, 'agents', 'runtime', 'state', 'skill-tiers.json');
+    if (!fs.existsSync(p)) return null;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(p, 'utf-8')) as { tier_b?: unknown };
+        if (!Array.isArray(parsed.tier_b)) return null;
+        return new Set(parsed.tier_b.filter((n): n is string => typeof n === 'string'));
+    } catch {
+        return null;
+    }
+}
+
+/** Predicate for `_prune_modules_by`: is this SKILL.md a Tier B skill? */
+export function tierBPrunePredicate(
+    tierB: ReadonlySet<string>,
+): (mdPath: string) => boolean {
+    return (mdPath) => tierB.has(path.basename(path.dirname(mdPath)));
+}
+
+/**
+ * The consumer-side alternative to tiering, surfaced as a recommendation only.
+ *
+ * Claude Code's listing budget is settable: `skillListingBudgetFraction` raises
+ * the fraction of the context window spent on skill DESCRIPTIONS, restoring them
+ * at a measured token price instead of withholding skills from the catalogue.
+ * That is the other lever, and for many consumers the better one — a description
+ * they can read beats a tool call they have to make.
+ *
+ * Returns `null` unless a tier split exists AND Tier B is non-empty: with no
+ * split there is nothing to recommend against, and an empty Tier B means the
+ * host already describes everything. This NEVER writes the consumer's
+ * `settings.json` — the setting is theirs, the token cost is theirs, and an
+ * installer that edited a host's own config to buy itself context would be
+ * taking that decision in their name.
+ */
+export function tierBAdvisory(packageRoot: string): string | null {
+    const tierB = resolveTierB(packageRoot);
+    if (tierB === null || tierB.size === 0) return null;
+    return (
+        `ℹ️  ${tierB.size} skill(s) are predicted to reach the model WITHOUT their ` +
+        'description on a default 200k window.\n' +
+        '   Two levers, neither applied for you:\n' +
+        '   • raise `skillListingBudgetFraction` in your Claude Code settings — ' +
+        'restores descriptions at a token cost (100% delivery of this catalogue ' +
+        'measures ~13,003 tok)\n' +
+        '   • or set `projection.mode: tiered` to withhold them from the catalogue ' +
+        'and reach them via the MCP server instead (opt-in, still unproven — see ' +
+        'docs/mcp-server.md)'
+    );
+}
+
+export interface TieredPruneOutcome {
+    deployResults: Record<string, DeployTuple>;
+    /** One line for the caller to print, or `null` when QUIET. */
+    message: string | null;
+    /** `warn` when no split exists, `info` when a prune happened. */
+    level: 'warn' | 'info';
+}
+
+/**
+ * Apply the Tier-B prune to a completed deploy.
+ *
+ * Takes `pruneBy` rather than importing it, so the prune mechanics stay in one
+ * place and this module does not become a second implementation of them.
+ */
+export function applyTieredPrune(
+    deployResults: Record<string, DeployTuple>,
+    packageRoot: string,
+    pruneBy: (
+        dr: Record<string, DeployTuple>,
+        isPruned: (mdPath: string) => boolean,
+    ) => [number, Record<string, DeployTuple>],
+): TieredPruneOutcome {
+    const tierB = resolveTierB(packageRoot);
+    if (tierB === null || tierB.size === 0) {
+        return {
+            deployResults,
+            level: 'warn',
+            message:
+                'projection.mode: tiered but no skill-tier split exists ' +
+                '(agents/runtime/state/skill-tiers.json) — shipping the full surface. ' +
+                'Compute one with `./scripts-run src/scripts/compute_skill_tiers` first.',
+        };
+    }
+    const [pruned, adjusted] = pruneBy(deployResults, tierBPrunePredicate(tierB));
+    return {
+        deployResults: adjusted,
+        level: 'info',
+        message:
+            `🧹 Tiered install: pruned ${pruned} Tier-B skill artefact(s) — still ` +
+            "reachable via the MCP server's suggest_skill_for_task / read_skill. " +
+            'Set projection.mode: legacy-all to restore the full surface.',
+    };
+}

package/src/scripts/_lib/review_independence.ts

@@ -27,6 +27,26 @@ const PROVIDER_FAMILY: Readonly<Record<string, string>> = {
 export type ReviewIndependence = 'cross-family' | 'same-family' | 'single-member' | 'unknown';
 export type AcceptanceStatus = 'accepted' | 'provisional';
 
+/**
+ * How the reviewer relates to the AUTHOR — a second axis, added 2026-08-23 by
+ * `road-to-review-independence` step 2.1.
+ *
+ * Model family and author relation are different questions, and the type carried only
+ * the first. **A cross-family pair that both read the implementer's envelope is not
+ * independent in the sense that matters here**: they disagree about the model, and they
+ * share the framing of what the change is for and what counts as done.
+ *
+ * - `fresh` — no implementation context. A separate dispatch that received the diff and
+ *   the scope, and not the author's envelope.
+ * - `same-session` — ran inside the author's session, with the implementation context in
+ *   scope. The common path today, and the one this axis exists to make visible.
+ * - `unknown` — not recorded. Treated as `same-session` for derivation, because an
+ *   unrecorded relation is not evidence of freshness and the safe direction on an
+ *   integrity field is the weaker claim (the same reasoning `unknown` already gets on
+ *   the family axis).
+ */
+export type ContextRelation = 'fresh' | 'same-session' | 'unknown';
+
 /**
  * How much INDEPENDENT evidence backs the verdict — deliberately orthogonal to
  * how much effort the reviewer spent.
@@ -54,30 +74,56 @@ export function reviewIndependence(memberNames: readonly string[]): ReviewIndepe
  * is not evidence of independence, and the safe direction on an integrity field
  * is the weaker claim.
  */
-export function acceptanceStatus(independence: ReviewIndependence): AcceptanceStatus {
-    return independence === 'cross-family' ? 'accepted' : 'provisional';
+export function acceptanceStatus(
+    independence: ReviewIndependence,
+    relation: ContextRelation = 'unknown',
+): AcceptanceStatus {
+    if (independence !== 'cross-family') return 'provisional';
+    // BOTH axes, and this is the whole point of step 2.1: a cross-family pair that both
+    // sat in the author's session shares the framing even though it disagrees about the
+    // model. `unknown` falls here too — an unrecorded relation is not evidence of
+    // freshness. The parameter defaults to `unknown` so every existing caller keeps
+    // compiling and gets the SAFER answer rather than the old one.
+    return relation === 'fresh' ? 'accepted' : 'provisional';
 }
 
-export function assuranceFor(independence: ReviewIndependence): Assurance {
-    if (independence === 'cross-family') return 'independent';
+export function assuranceFor(
+    independence: ReviewIndependence,
+    relation: ContextRelation = 'unknown',
+): Assurance {
     if (independence === 'unknown') return 'unreviewed';
+    // `independent` requires both axes, for the same reason `accepted` does.
+    if (independence === 'cross-family' && relation === 'fresh') return 'independent';
     return 'single-pass';
 }
 
 export interface IndependenceFields {
     readonly review_independence: ReviewIndependence;
+    /** The recorded second axis. Derived fields below follow from BOTH. */
+    readonly context_relation: ContextRelation;
     readonly acceptance_status: AcceptanceStatus;
     readonly assurance: Assurance;
     readonly reviewers: readonly string[];
 }
 
-/** The three fields plus the member set they were derived from. */
-export function independenceFields(memberNames: readonly string[]): IndependenceFields {
+/**
+ * The recorded axes plus the fields derived from them.
+ *
+ * `context_relation` defaults to `unknown` so an existing caller that names only its
+ * members keeps compiling — and gets `provisional` rather than the `accepted` it used to
+ * get. That direction is deliberate: a producer that has not said whether its reviewer
+ * was fresh has not earned the stronger claim.
+ */
+export function independenceFields(
+    memberNames: readonly string[],
+    relation: ContextRelation = 'unknown',
+): IndependenceFields {
     const independence = reviewIndependence(memberNames);
     return {
         review_independence: independence,
-        acceptance_status: acceptanceStatus(independence),
-        assurance: assuranceFor(independence),
+        context_relation: relation,
+        acceptance_status: acceptanceStatus(independence, relation),
+        assurance: assuranceFor(independence, relation),
         reviewers: [...memberNames],
     };
 }
@@ -97,13 +143,19 @@ export function independenceViolations(doc: Record<string, unknown>): string[] {
         out.push('review_independence is absent — an artifact that does not declare its independence reads as acceptance by default');
         return out;
     }
-    const expectedAccept = acceptanceStatus(indep as ReviewIndependence);
+    // The recorded relation, not a default: `independenceViolations` judges an artifact
+    // that already carries the fields, so reading `unknown` when the artifact says
+    // `fresh` would flag a correct producer.
+    const relRaw = doc['context_relation'];
+    const rel: ContextRelation =
+        relRaw === 'fresh' || relRaw === 'same-session' ? relRaw : 'unknown';
+    const expectedAccept = acceptanceStatus(indep as ReviewIndependence, rel);
     if (accept !== expectedAccept) {
         out.push(
             `acceptance_status is ${String(accept)} but review_independence ${String(indep)} derives ${expectedAccept}`,
         );
     }
-    const expectedAssur = assuranceFor(indep as ReviewIndependence);
+    const expectedAssur = assuranceFor(indep as ReviewIndependence, rel);
     if (assur !== undefined && assur !== expectedAssur) {
         out.push(`assurance is ${String(assur)} but review_independence ${String(indep)} derives ${expectedAssur}`);
     }