@event4u/agent-config 14.13.0 → 14.14.1

package/src/scripts/_lib/outcome_vocabularies.ts

@@ -13,7 +13,7 @@
  * |---|---|---|---|
  * | phase | one audit-log line — a `/work` PHASE | here, consumed by `orchestration_record` | 4 |
  * | step  | one work-engine STEP | `work_engine/delivery_state.ts` (template tree) | 3 |
- * | run   | one command or gate RUN | here, consumed by `outcome_envelope` | 6 |
+ * | run   | one command or gate RUN | here, consumed by `outcome_envelope` | 7 |  code-comment-allow report-comment -- one row of a pre-existing three-row table documenting the three vocabularies; the digit changed from 6 to 7 with the vocabulary, and the table is the registry's whole point
  *
  * All three are declared in code AND emitted today. `skipped` and `error` are
  * not aspirational: `envelopeOutcome` in `orchestration_record.ts` returns
@@ -33,16 +33,42 @@
  * `partial`. So: separate vocabularies, one registry, mappings only where
  * execution actually crosses.
  *
- * **Mappings are not written for symmetry.** Exactly one crossing exists
- * (`DispatchOutcome` -> phase, in `orchestration_record.ts`). A total
- * phase<->step<->run mapping would be nine relations of which one is real, and
- * the eight invented ones would read as contract.
+ * **Mappings are not written for symmetry.** Two crossings exist, and both are
+ * places where execution actually translates: `DispatchOutcome` -> phase in
+ * `orchestration_record.ts`, and `LadderAction` -> run in
+ * `continuation_ladder.ts` (added 2026-09-03 with the seventh run state, so the
+ * state has a producer rather than being a word nothing emits). A total
+ * phase<->step<->run mapping would be nine relations of which two are real, and
+ * the seven invented ones would read as contract.
  *
  * `revisit-if`: a producer needs a value its vocabulary cannot express, or a
  * second real crossing appears, or producer analysis shows two of the three
  * subjects share identical terminal semantics with a lossless mapping — at
  * which point unifying those two becomes the cheaper answer.
  *
+ * **The run vocabulary grew to seven on 2026-09-03** — exactly the first branch
+ * of the reopening condition above: the continuation ladder needed a word for a
+ * run whose plan premise moved, and had none. AI council (anthropic/claude-sonnet-4-5 +
+ * openai/codex-default, three rounds, blind chairman) resolved it unanimously
+ * as option (a), extend rather than overload `blocked` with a reason field. The
+ * seats attached the same prerequisites, discharged here: a versioned value
+ * domain ({@link RUN_TERMINAL_VOCABULARY_VERSION}), a tolerant read
+ * ({@link readRunTerminalState}), a declared downgrade
+ * ({@link RUN_TERMINAL_STATE_DOWNGRADE}) and the rollback trigger below.
+ *
+ * **Rollback trigger, stated rather than instrumented.** Withdraw
+ * `premise-invalidated` — remove it from {@link RUN_TERMINAL_STATES} and let the
+ * ladder rung report its declared downgrade `blocked` instead — on EITHER of:
+ * (1) any consumer is observed failing (a throw, a refused write, a dropped
+ * record) on encountering the value, or (2) `readRunTerminalState` returns
+ * `null` for a persisted value in normal operation, which would mean a writer
+ * emitted something this registry does not know. Both are single-occurrence
+ * triggers, not rates: the downgrade mapping already exists, so withdrawal
+ * costs one commit and no migration, and there is no reason to tolerate a
+ * budget of failures before paying that. No telemetry is built for this and
+ * none is claimed — condition (1) surfaces as a failing run and (2) as a null
+ * where a value was written.
+ *
  * Type-only + literal arrays. No `node:` import, so any surface may read it.
  */
 
@@ -82,9 +108,99 @@ export const RUN_TERMINAL_STATES = [
     'approval-required',
     'exhausted',
     'stagnated',
+    /**
+     * The plan premise this run was built on no longer holds — the situational
+     * -awareness fingerprint the run engaged under (`origin/main` plus every open
+     * PR head) was re-observed and differs.
+     *
+     * Added by `road-to-wired-instruments` Phase 2 under the AI-council decision
+     * of 2026-09-03 (option (a), unanimous). It is NOT `blocked` with a reason
+     * field: premise invalidation is operationally distinct from a missing
+     * precondition and from an exhausted budget, and folding it into either loses
+     * both aggregation by state and type-enforced exhaustive handling. The
+     * remedy differs too — re-probe and re-plan, where `blocked` says obtain the
+     * missing thing and `exhausted` says the budget was too small.
+     */
+    'premise-invalidated',
 ] as const;
 export type RunTerminalState = (typeof RUN_TERMINAL_STATES)[number];
 
+/**
+ * Version of the RUN vocabulary's VALUE DOMAIN — bumped when a member is added
+ * or removed, never for prose.
+ *
+ * Distinct from any table version: `runtime_journal.JOURNAL_SCHEMA_VERSION`
+ * covers tables and columns and is unaffected by a widening of what one column
+ * may contain, so a value-domain change needs its own number or it travels
+ * unversioned. A persisted shape carrying a `RunTerminalState` stamps THIS
+ * number beside the value, so a reader can tell a value it does not know from a
+ * value that is corrupt.
+ *
+ * v1 — the six original states.
+ * v2 — adds `premise-invalidated` (2026-09-03).
+ */
+export const RUN_TERMINAL_VOCABULARY_VERSION = 2;
+
+/** The vocabulary version each member first appeared in. */
+export const RUN_TERMINAL_STATE_SINCE: Readonly<Record<RunTerminalState, number>> = {
+    success: 1,
+    'clean-no-op': 1,
+    blocked: 1,
+    'approval-required': 1,
+    exhausted: 1,
+    stagnated: 1,
+    'premise-invalidated': 2,
+};
+
+/**
+ * What a consumer pinned to an older vocabulary version reports instead.
+ *
+ * `premise-invalidated` -> `blocked`: of the six v1 states it is the only one
+ * that is honest for a reader that cannot represent it — the run stopped on an
+ * external condition it cannot resolve by iterating. Mapping it to `exhausted`
+ * would invite the wrong remedy (raise the budget), which is the exact
+ * confusion the contract's own `exhausted`/`stagnated` split exists to prevent.
+ *
+ * Every member introduced after v1 MUST have a row here; `outcome_vocabularies`
+ * contract tests assert that, so a future eighth value cannot ship undowngradable.
+ */
+export const RUN_TERMINAL_STATE_DOWNGRADE: Readonly<Partial<Record<RunTerminalState, RunTerminalState>>> = {
+    'premise-invalidated': 'blocked',
+};
+
+/**
+ * The state a consumer pinned at `toVersion` should report for `state`.
+ *
+ * Returns the state unchanged when it already existed at that version, the
+ * declared downgrade when it did not, and `null` for a string this vocabulary
+ * does not know at all — never a throw, because this is the function a reader
+ * of PERSISTED data calls, and persisted data outlives the code that wrote it.
+ */
+export function downgradeRunTerminalState(
+    state: string,
+    toVersion: number,
+): RunTerminalState | null {
+    if (!isRunTerminalState(state)) return null;
+    if ((RUN_TERMINAL_STATE_SINCE[state] ?? 1) <= toVersion) return state;
+    return RUN_TERMINAL_STATE_DOWNGRADE[state] ?? null;
+}
+
+/**
+ * Tolerant read of a persisted terminal state: a member returns itself,
+ * anything else returns `null`. Never throws.
+ *
+ * `null` rather than a fabricated fallback is the load-bearing choice. This
+ * vocabulary's own consumers already treat a null terminal state as "not
+ * recorded" (`repeated_failure` counts it under `unknown`), and that is exactly
+ * what an unrecognised value IS to a reader that cannot name it. Substituting
+ * `blocked` here would manufacture a measurement out of an absence — the
+ * downgrade above is for a value the reader KNOWS is newer, which is a
+ * different fact from a value it cannot place.
+ */
+export function readRunTerminalState(v: unknown): RunTerminalState | null {
+    return isRunTerminalState(v) ? v : null;
+}
+
 /**
  * The crossings that exist. One row, because one crossing is real.
  *
@@ -112,6 +228,20 @@ export const CROSS_DOMAIN_MAPPINGS = [
          */
         semantics_version: 2,
     },
+    {
+        source: 'LadderAction',
+        target: 'run',
+        at: 'src/scripts/_lib/continuation_ladder.ts',
+        fn: 'terminalStateFor',
+        /**
+         * Version 1, and the mapping is TOTAL over `LadderAction` by
+         * construction: `TERMINAL_STATE_BY_ACTION` is a `Record<LadderAction,
+         * RunTerminalState | null>`, so adding a rung without deciding its
+         * terminal state does not compile. `engage` maps to null because it is
+         * the one action that is not terminal.
+         */
+        semantics_version: 1,
+    },
 ] as const;
 
 /** Is this string a phase outcome? The guard the audit-log consumer was missing. */

package/src/scripts/_lib/pathology_archive.ts

@@ -0,0 +1,393 @@
+/**
+ * The pathology archive — best-known intervention per `WHERE x WHY` failure
+ * cell, over closed vocabularies, backed by append-only attempt history.
+ *
+ * `road-to-governed-harness-evolution` step 4.4. A pure Pareto frontier orders
+ * candidates by their metric vectors and throws away the reason each candidate
+ * exists, so two candidates that fail for completely different reasons compete
+ * as if they were interchangeable. This module keeps the reason.
+ *
+ * ## What this is NOT
+ *
+ * It is not a second verdict beside `_lib/paired_verdict.ts`. Nothing here
+ * decides whether a candidate is better; the archive records WHY attempts
+ * failed and which intervention is currently RETAINED per cell. Promotion stays
+ * with `_lib/evaluation_vector.ts`'s `promotionVerdict`, which this module never
+ * calls and never reimplements.
+ *
+ * ## "Best" is a retained representative, not a quality claim
+ *
+ * The AI council of 2026-08-31 was explicit that "archive the best intervention
+ * per cell" names no operation until ranking, tie-break and replacement are all
+ * total. Two of the three candidate rules it enumerated need evidence systems
+ * that do not exist — lowest edit distance to a human gold standard (there is no
+ * gold standard) and highest measured failure-class coverage (there is no
+ * coverage metric). The third, recency, is trivially deterministic and is what
+ * ships. So the retained entry is a REPRESENTATIVE selected by recency, and this
+ * module says so in its type names rather than calling it "best" and implying a
+ * measurement nobody took.
+ *
+ * Because recency says nothing about quality, the attempt history is append-only
+ * and every ranking decision is stamped with `ranking_rule_version`. When a real
+ * quality metric arrives, representatives are RECOMPUTED from history rather
+ * than lost.
+ *
+ * ## Ordering is by sequence, never by timestamp
+ *
+ * `attempt_sequence` is assigned by the ingester, monotonically. Timestamps come
+ * from producer clocks: they collide, they arrive out of order, and they make a
+ * replacement rule that is not total. `observed_at` is retained for reporting
+ * and is never consulted for ordering.
+ */
+
+import { LADDER_RUNGS, type LadderRung } from './activation_ladder.js';
+
+/** `WHERE` — reused from the activation ladder, never re-invented. */
+export const PATHOLOGY_WHERE = LADDER_RUNGS;
+export type PathologyWhere = LadderRung;
+
+/**
+ * `WHY` — the closed failure-REASON vocabulary.
+ *
+ * Closed means: a versioned enum, exactly one value per attempt, and an addition
+ * requires a `classification_rule_version` bump plus migration. Free-form
+ * explanation belongs in `reason_detail` and never in this axis.
+ *
+ * The order IS the precedence order. When several reasons could apply, the
+ * earliest applicable value wins, so classification is deterministic rather than
+ * dependent on evaluation order. `reason_unknown` applies only when none of the
+ * first seven can be established — it is a real state, not a default.
+ *
+ * These are REASONS, deliberately not places. An earlier draft of this
+ * vocabulary used names like `projection_failed` and `delivery_failed`, which
+ * restate `WHERE` and collapse the very distinction the two axes exist to draw.
+ */
+export const PATHOLOGY_WHY = [
+    'precondition_unsatisfied',
+    'policy_blocked',
+    'dependency_unavailable',
+    'execution_failed',
+    'output_contract_violated',
+    'evidence_missing',
+    'human_rejected',
+    'reason_unknown',
+] as const;
+export type PathologyWhy = (typeof PATHOLOGY_WHY)[number];
+
+/** Bumped when the cell/query shape changes. */
+export const ARCHIVE_SCHEMA_VERSION = 1;
+/** Bumped when `PATHOLOGY_WHY` or its precedence changes. */
+export const CLASSIFICATION_RULE_VERSION = 1;
+/** Bumped when the ranking/tie-break/replacement rule changes. */
+export const RANKING_RULE_VERSION = 1;
+
+/**
+ * Dominance threshold for the search-collapse guard.
+ *
+ * STATED POLICY DEFAULT, not a measured optimum — and deliberately a NEW
+ * constant rather than a reuse.
+ *
+ * The step's own verify line carries a bare `0.6`, and the prior council warned
+ * that reusing it would be "a semantic change wearing a constant's clothes" IF
+ * it already meant textual similarity. Checked against the tree on 2026-08-31:
+ * it does not, because no such constant exists. `diversityCollapsed`
+ * (`_lib/harness_evolution_guards.ts:215`) is a DISTINCT-COUNT check with
+ * `minDistinct = 2` and no ratio at all, and the only near-duplicate constant is
+ * `NEAR_DUPLICATE_THRESHOLD = 70` in `_lib/curator_ops.ts:106` — an integer
+ * percentage on a different scale. So the collision the objection feared is not
+ * present, and the number below is free to be given its own meaning.
+ *
+ * Revisit-if: a run records a collapse the guard did not catch, or a warm-up
+ * period in which the floor below suppressed a real signal.
+ */
+export const PATHOLOGY_DOMINANCE_THRESHOLD = 0.6;
+/** Observation window: the latest N classifiable failed attempts. */
+export const PATHOLOGY_WINDOW_SIZE = 50;
+/** No verdict below this many classifiable attempts in the window. */
+export const PATHOLOGY_MIN_CLASSIFIABLE_ATTEMPTS = 20;
+
+export type ClassificationStatus = 'classified' | 'unclassifiable';
+export type ValidationStatus = 'valid' | 'invalid';
+
+/** One append-only attempt observation. Never mutated, never deleted. */
+export interface PathologyAttempt {
+    readonly attempt_id: string;
+    /** Monotonic, ingester-assigned. The ONLY ordering key. */
+    readonly attempt_sequence: number;
+    readonly candidate_id: string;
+    readonly intervention_ref: string;
+    readonly where: PathologyWhere;
+    readonly why: PathologyWhy;
+    readonly reason_detail: string;
+    readonly classification_status: ClassificationStatus;
+    readonly validation_status: ValidationStatus;
+    /** Reporting only. Never consulted for ordering. */
+    readonly observed_at: string;
+    readonly archive_schema_version: number;
+    readonly classification_rule_version: number;
+    readonly ranking_rule_version: number;
+    readonly cohort_id: string;
+    readonly cohort_version: number;
+}
+
+/** A versioned cell query result. The guard consumes THIS, never storage internals. */
+export interface PathologyCell {
+    readonly where: PathologyWhere;
+    readonly why: PathologyWhy;
+    readonly archive_schema_version: number;
+    readonly classification_rule_version: number;
+    readonly ranking_rule_version: number;
+    readonly cohort_id: string;
+    readonly cohort_version: number;
+    readonly attempt_count: number;
+    readonly classifiable_count: number;
+    readonly unclassifiable_count: number;
+    readonly first_observed_attempt_sequence: number;
+    readonly first_observed_at: string;
+    readonly last_observed_attempt_sequence: number;
+    readonly last_observed_at: string;
+    readonly retained_candidate_id: string | null;
+    readonly retained_intervention_ref: string | null;
+    readonly retained_attempt_id: string | null;
+    readonly retained_attempt_sequence: number | null;
+    readonly retained_observed_at: string | null;
+    readonly retained_ranking_rule: string;
+    readonly retained_ranking_key: string | null;
+    readonly retained_validation_status: ValidationStatus | null;
+}
+
+/** A versioned window query result. The guard's only legal input. */
+export interface PathologyWindowQuery {
+    readonly archive_schema_version: number;
+    readonly classification_rule_version: number;
+    readonly ranking_rule_version: number;
+    readonly window_size: number;
+    readonly unclassifiable_excluded: number;
+    readonly rows: readonly PathologyAttempt[];
+}
+
+export interface DominanceOptions {
+    readonly threshold?: number;
+    readonly windowSize?: number;
+    readonly minClassifiable?: number;
+}
+
+export const RETAINED_RANKING_RULE = 'recency-v1: attempt_sequence DESC, candidate_id ASC, attempt_id ASC';
+
+export function cellKey(where: PathologyWhere, why: PathologyWhy): string {
+    return `${where} ${why}`;
+}
+
+export class PathologyArchiveError extends Error {}
+
+/**
+ * Is `incoming` a better representative than `retained`?
+ *
+ * Total by construction: the tuple `(attempt_sequence DESC, candidate_id ASC,
+ * attempt_id ASC)` orders any two distinct attempts, and `attempt_id` is unique,
+ * so the comparison never falls through to "equal" for two different attempts.
+ * A rule whose tie-break is declared but unreachable is not total, which is the
+ * defect the council named in the timestamp-ordered alternative.
+ */
+export function replacesRetained(incoming: PathologyAttempt, retained: PathologyAttempt): boolean {
+    if (incoming.attempt_sequence !== retained.attempt_sequence) {
+        return incoming.attempt_sequence > retained.attempt_sequence;
+    }
+    if (incoming.candidate_id !== retained.candidate_id) {
+        return incoming.candidate_id < retained.candidate_id;
+    }
+    return incoming.attempt_id < retained.attempt_id;
+}
+
+/** Only a validated, classified attempt may become a representative. */
+function eligibleAsRepresentative(a: PathologyAttempt): boolean {
+    return a.classification_status === 'classified' && a.validation_status === 'valid';
+}
+
+/**
+ * Append-only, idempotent attempt store.
+ *
+ * Re-ingesting an existing `attempt_id` is a no-op: it cannot alter counts and
+ * cannot change a representative. Without that, a retry loop silently inflates
+ * the very frequency evidence the dominance guard reads.
+ */
+export class PathologyArchive {
+    private readonly byId = new Map<string, PathologyAttempt>();
+    private readonly order: PathologyAttempt[] = [];
+
+    /** @returns true when the attempt was new, false when it was a duplicate. */
+    ingest(a: PathologyAttempt): boolean {
+        if (!PATHOLOGY_WHERE.includes(a.where)) {
+            throw new PathologyArchiveError(`unknown WHERE '${a.where}'`);
+        }
+        if (!PATHOLOGY_WHY.includes(a.why)) {
+            throw new PathologyArchiveError(`unknown WHY '${a.why}'`);
+        }
+        if (this.byId.has(a.attempt_id)) return false;
+        this.byId.set(a.attempt_id, a);
+        this.order.push(a);
+        return true;
+    }
+
+    /** Every attempt, in ingest order. Callers must not mutate. */
+    attempts(): readonly PathologyAttempt[] {
+        return this.order;
+    }
+
+    /**
+     * The versioned window query the collapse guard consumes.
+     *
+     * The guard may not read `attempts()` directly: the council required it to
+     * consume "a versioned archive query rather than storage internals", so the
+     * version/cohort quad travels WITH the rows and a guard cannot silently mix
+     * two classification vocabularies. It returns attempts rather than cells
+     * because a last-N window is not reconstructible from aggregates — which is
+     * the same reason `cells()` alone is not the guard's input.
+     */
+    dominanceWindow(windowSize: number = PATHOLOGY_WINDOW_SIZE): PathologyWindowQuery {
+        const classifiable = this.order
+            .filter((a) => a.classification_status === 'classified')
+            .sort((a, b) => a.attempt_sequence - b.attempt_sequence);
+        const rows = classifiable.slice(-windowSize);
+        const head = rows[0] ?? this.order[0];
+        return {
+            archive_schema_version: head?.archive_schema_version ?? ARCHIVE_SCHEMA_VERSION,
+            classification_rule_version: head?.classification_rule_version ?? CLASSIFICATION_RULE_VERSION,
+            ranking_rule_version: head?.ranking_rule_version ?? RANKING_RULE_VERSION,
+            window_size: windowSize,
+            unclassifiable_excluded: this.order.length - classifiable.length,
+            rows,
+        };
+    }
+
+    /** The collapse verdict, read through the versioned query above. */
+    collapseVerdict(opts: DominanceOptions = {}): DominanceVerdict {
+        return dominanceVerdict(this.dominanceWindow(opts.windowSize ?? PATHOLOGY_WINDOW_SIZE), opts);
+    }
+
+    /**
+     * The versioned cell query. Cells are keyed on `WHERE x WHY` AND on the
+     * version/cohort quad — attempts recorded under a different classification
+     * rule describe a different vocabulary and must not be summed with these.
+     */
+    cells(): readonly PathologyCell[] {
+        const groups = new Map<string, PathologyAttempt[]>();
+        for (const a of this.order) {
+            const k = [
+                a.where,
+                a.why,
+                a.archive_schema_version,
+                a.classification_rule_version,
+                a.ranking_rule_version,
+                a.cohort_id,
+                a.cohort_version,
+            ].join(' ');
+            const bucket = groups.get(k);
+            if (bucket) bucket.push(a);
+            else groups.set(k, [a]);
+        }
+
+        const out: PathologyCell[] = [];
+        for (const bucket of groups.values()) {
+            const first = bucket.reduce((m, a) => (a.attempt_sequence < m.attempt_sequence ? a : m));
+            const last = bucket.reduce((m, a) => (a.attempt_sequence > m.attempt_sequence ? a : m));
+            let rep: PathologyAttempt | null = null;
+            for (const a of bucket) {
+                if (!eligibleAsRepresentative(a)) continue;
+                if (rep === null || replacesRetained(a, rep)) rep = a;
+            }
+            const head = bucket[0]!;
+            out.push({
+                where: head.where,
+                why: head.why,
+                archive_schema_version: head.archive_schema_version,
+                classification_rule_version: head.classification_rule_version,
+                ranking_rule_version: head.ranking_rule_version,
+                cohort_id: head.cohort_id,
+                cohort_version: head.cohort_version,
+                attempt_count: bucket.length,
+                classifiable_count: bucket.filter((a) => a.classification_status === 'classified').length,
+                unclassifiable_count: bucket.filter((a) => a.classification_status === 'unclassifiable').length,
+                first_observed_attempt_sequence: first.attempt_sequence,
+                first_observed_at: first.observed_at,
+                last_observed_attempt_sequence: last.attempt_sequence,
+                last_observed_at: last.observed_at,
+                retained_candidate_id: rep?.candidate_id ?? null,
+                retained_intervention_ref: rep?.intervention_ref ?? null,
+                retained_attempt_id: rep?.attempt_id ?? null,
+                retained_attempt_sequence: rep?.attempt_sequence ?? null,
+                retained_observed_at: rep?.observed_at ?? null,
+                retained_ranking_rule: RETAINED_RANKING_RULE,
+                retained_ranking_key: rep
+                    ? `${rep.attempt_sequence}|${rep.candidate_id}|${rep.attempt_id}`
+                    : null,
+                retained_validation_status: rep?.validation_status ?? null,
+            });
+        }
+        return out.sort((a, b) => (cellKey(a.where, a.why) < cellKey(b.where, b.why) ? -1 : 1));
+    }
+}
+
+export type DominanceVerdict =
+    | { readonly status: 'warming-up'; readonly classifiable_in_window: number; readonly floor: number }
+    | {
+          readonly status: 'ok' | 'collapsed';
+          readonly dominant_share: number;
+          readonly dominant_cell: string;
+          readonly classifiable_in_window: number;
+          readonly window_size: number;
+          readonly threshold: number;
+      };
+
+/**
+ * The search-collapse guard, reading the archive through `cells()`-shaped data.
+ *
+ * Why a share and not the occupancy the frontier already gives: retaining one
+ * winner per cell erases whether attempts were distributed 50/50 or 99.9/0.1 —
+ * identical occupancy, radically different evidence of collapse. The denominator
+ * is therefore CLASSIFIABLE ATTEMPTS in the window, not distinct cells.
+ *
+ * `warming-up` is a real state and NOT a pass. A guard that returned "ok" on
+ * three observations would be reporting a confidence it does not have; the floor
+ * exists so an empty archive cannot look healthy.
+ */
+export function dominanceVerdict(
+    query: PathologyWindowQuery,
+    opts: DominanceOptions = {},
+): DominanceVerdict {
+    const threshold = opts.threshold ?? PATHOLOGY_DOMINANCE_THRESHOLD;
+    const windowSize = query.window_size;
+    const floor = opts.minClassifiable ?? PATHOLOGY_MIN_CLASSIFIABLE_ATTEMPTS;
+
+    // The query has already excluded unclassifiable rows and applied the
+    // window; re-filtering here would let a caller pass raw storage and get a
+    // verdict, which is the coupling this signature exists to prevent.
+    const window = query.rows;
+
+    if (window.length < floor) {
+        return { status: 'warming-up', classifiable_in_window: window.length, floor };
+    }
+
+    const counts = new Map<string, number>();
+    for (const a of window) {
+        const k = cellKey(a.where, a.why);
+        counts.set(k, (counts.get(k) ?? 0) + 1);
+    }
+    let dominantCell = '';
+    let dominantCount = 0;
+    for (const [k, n] of [...counts.entries()].sort((x, y) => (x[0] < y[0] ? -1 : 1))) {
+        if (n > dominantCount) {
+            dominantCount = n;
+            dominantCell = k;
+        }
+    }
+    const share = dominantCount / window.length;
+    return {
+        status: share >= threshold ? 'collapsed' : 'ok',
+        dominant_share: share,
+        dominant_cell: dominantCell.replace(' ', ' x '),
+        classifiable_in_window: window.length,
+        window_size: windowSize,
+        threshold,
+    };
+}