@codyswann/lisa 4.10.7 → 4.10.9

package/dist/core/gate-context-owners.js

@@ -0,0 +1,174 @@
+/**
+ * Which gate produces a required status context, and under which caller chain.
+ *
+ * Split out of `core/gate-declaration-drift` because it answers a different
+ * question. This module knows the shipped registry, the merge moment and the
+ * caller-chain rules, and produces one map from context string to owning gate.
+ * The comparator consumes that map as a `ReadonlyMap<string, ContextOwner>`
+ * and knows none of it. Nothing here reaches an enforcing surface or reasons
+ * about a verdict, so the two vocabularies the comparator's note warns about —
+ * the verdict table and the sentences explaining it — stay together over
+ * there, undisturbed by this seam.
+ *
+ * The one rule that lives here rather than in the comparator: a retired label
+ * some OTHER gate has since adopted as its current label is not retired. That
+ * string is posted again, by a different job, so requiring it is not a
+ * permanent wait — and telling an operator to delete it would be this check
+ * inventing a defect. The guard is why the map is built from the WHOLE
+ * registry rather than one entry's field.
+ * @module core/gate-context-owners
+ */
+/** The moment a branch ruleset guards. */
+export const MERGE_MOMENT = "pull-request";
+/**
+ * The declaration state one resolved level names.
+ *
+ * Anything that is not one of the three levels is `not-declared`, because an
+ * unknown level is a typo rather than a claim.
+ * @param level - The resolved level
+ * @returns The declaration state
+ */
+function asDeclaration(level) {
+    return level === "required" || level === "optional" || level === "off"
+        ? level
+        : "not-declared";
+}
+/**
+ * Map every context a registry gate can produce to that gate.
+ *
+ * Built from the whole registry rather than from the declared gates, which is
+ * the difference between "protection requires a context whose gate nobody
+ * declared" and "protection requires a context Lisa knows nothing about". Those
+ * are different findings with different remedies, and a map built only from
+ * declarations could not tell them apart.
+ * @param options - Inputs
+ * @param options.registry - The shipped registry
+ * @param options.gates - The project's gates block
+ * @param options.workflowName - The workflow whose name prefixes a context
+ * @returns Context string to owning gate
+ */
+export function contextOwners(options) {
+    const { registry, gates, workflowName } = options;
+    const resolved = resolveMergeMoment(registry, gates);
+    const family = registry.momentFamily(MERGE_MOMENT);
+    const owners = Object.entries(registry.REGISTRY).map(([gateId, definition]) => {
+        const hit = resolved.get(gateId);
+        return [
+            `${prefixFor(registry, hit?.callerChain, workflowName)} / ${definition.label}`,
+            {
+                gateId,
+                declaration: asDeclaration(hit?.level),
+                legalAtMerge: definition.moments.includes(family),
+                retired: null,
+            },
+        ];
+    });
+    const awaited = [...resolved.values()].flatMap(hit => hit.mode === "await" && hit.awaits !== null
+        ? [
+            [
+                hit.awaits,
+                {
+                    gateId: hit.id,
+                    declaration: asDeclaration(hit.level),
+                    legalAtMerge: registry.REGISTRY[hit.id]?.moments.includes(family) === true,
+                    retired: null,
+                },
+            ],
+        ]
+        : []);
+    // Retired entries go FIRST so a later current-label or awaited entry always
+    // wins the key. The collision filter below already covers the reachable
+    // case; the ordering covers the one nobody thought of.
+    return new Map([
+        ...retiredOwners(registry, resolved, workflowName, family),
+        ...owners,
+        ...awaited,
+    ]);
+}
+/**
+ * The contexts the registry records as renamed away, keyed by their old name.
+ *
+ * Built from the whole registry — like the current-label map, and for the same
+ * reason. It is what separates "a required context nothing in Lisa produces"
+ * (which may be CodeRabbit, a Sonar status, a manual status, or a job the host
+ * repository's own CI defines, and is not a defect) from "a required context
+ * Lisa itself retired" (which no run can post, ever). Only the second is
+ * reportable, and only the second earns a removal remedy.
+ *
+ * A retired label some other gate has since adopted as its CURRENT label is
+ * skipped: that string is posted again, by a different job, so requiring it is
+ * not a permanent wait. Missing this would turn a legitimate requirement into
+ * a false "delete this" instruction.
+ * @param registry - The shipped registry
+ * @param resolved - The resolved merge moment, keyed by gate id
+ * @param workflowName - The caller chain that prefixes a run gate's context
+ * @param family - The merge moment's family
+ * @returns Retired context to owning gate
+ */
+function retiredOwners(registry, resolved, workflowName, family) {
+    const live = new Set(Object.values(registry.REGISTRY).map(definition => definition.label));
+    return Object.entries(registry.REGISTRY).flatMap(([gateId, definition]) => (definition.previousLabels ?? [])
+        .filter(label => !live.has(label))
+        .map((label) => [
+        `${workflowName} / ${label}`,
+        {
+            gateId,
+            declaration: asDeclaration(resolved.get(gateId)?.level),
+            legalAtMerge: definition.moments.includes(family),
+            retired: {
+                label,
+                replacement: `${workflowName} / ${definition.label}`,
+            },
+        },
+    ]));
+}
+/**
+ * The prefix one gate's context carries, honouring a per-declaration override.
+ *
+ * Three states, and the third is the one that matters. No override means the
+ * caller-wide name, unchanged — which is what keeps every existing declaration
+ * deriving exactly what it derived before this field existed. An override with
+ * a registry able to join it means that gate's own chain. An override with a
+ * registry too old to join it is refused outright, because the alternative is
+ * to derive the caller-wide name for a gate whose declaration has just said
+ * that name is wrong — a comparison that would report a clean match against a
+ * context nothing posts.
+ * @param registry - The shipped registry
+ * @param chain - The declared override, when there is one
+ * @param workflowName - The caller-wide chain
+ * @returns The prefix
+ * @throws {Error} When an override cannot be joined
+ */
+function prefixFor(registry, chain, workflowName) {
+    if (chain === null || chain === undefined)
+        return workflowName;
+    if (registry.callerPrefix === undefined) {
+        throw new Error(`a gate declares its own caller chain (${JSON.stringify(chain)}), but ` +
+            `the installed copy of Lisa's check registry is too old to derive a ` +
+            `context from one. Update Lisa, or remove the override; deriving the ` +
+            `default name here would report agreement about a check that never ` +
+            `reports.`);
+    }
+    return registry.callerPrefix(chain);
+}
+/**
+ * Resolve the merge moment, treating a refusal as "nothing resolved".
+ *
+ * A refusal is never swallowed by the caller: `readTemplateEnforcement` and the
+ * health check both report the declaration problems separately. What must not
+ * happen here is a throw that turns a comparison into no comparison at all.
+ * @param registry - The shipped registry
+ * @param gates - The project's gates block
+ * @returns Resolved gates keyed by id
+ */
+function resolveMergeMoment(registry, gates) {
+    try {
+        return new Map(registry
+            .resolveMoment({ gates, moment: MERGE_MOMENT, includeOff: true })
+            .map(entry => [entry.id, { ...entry }]));
+    }
+    catch {
+        return new Map();
+    }
+}
+//# sourceMappingURL=gate-context-owners.js.map

package/dist/core/gate-context-owners.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate-context-owners.js","sourceRoot":"","sources":["../../src/core/gate-context-owners.ts"],"names":[],"mappings":"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"}

package/dist/core/gate-declaration-drift.d.ts

@@ -26,22 +26,34 @@
  *    "agreed and proved" from "agreed and unproved" would itself be a control
  *    reporting more than it measured, so the word this module uses is
  *    `matched` — the two surfaces agree — and never `enforced` or `proved`.
- * 3. **No remedy in this module can say "remove the context".** Third-party
- *    contexts are enforced by construction and declared by nobody; a
- *    comparator whose vocabulary contained a removal would eventually propose
- *    deleting one. The `DriftRemedy` union simply has no such member, so the
- *    guarantee holds for every caller rather than for the careful ones.
- * @module core/gate-declaration-drift
- */
-/**
- * What the settings file says about one gate at one moment.
+ * 3. **A remedy may say "remove the context" only where Lisa renamed the job
+ *    itself.** The original rule here was that no remedy could ever say it,
+ *    and the reason was sound: third-party contexts are enforced by
+ *    construction and declared by nobody, so a comparator free to propose a
+ *    removal would eventually propose deleting one. That reason does not cover
+ *    one case, and #3067 is what the gap costs. When the shipped registry
+ *    carries a `previousLabels` entry, Lisa is not inferring that nothing owns
+ *    a context — it is reading its OWN record that it renamed the job, which
+ *    is proof that this exact string can never be posted again. A required
+ *    context that never reports does not fail a pull request; GitHub waits for
+ *    it forever, so leaving that unsaid red-walls the repository silently.
  *
- * `off` and `not-declared` are deliberately separate. Collapsing them is what
- * let a declaration govern nothing: the CI façade read both as
- * `configured=false` and ran its built-in fallback, so `off` could not turn a
- * job off.
+ *    The narrowing is structural, not conventional. Exactly one verdict,
+ *    `enforced-context-retired`, maps to the single removal remedy, and that
+ *    verdict is reachable only from a `previousLabels` match. A context with
+ *    no owner at all is still `enforced-not-lisa-owned` with remedy `none`, so
+ *    the original guarantee holds unchanged for every third-party check.
+ *
+ * The ownership map this comparison reads — which gate produces a context
+ * string, under which caller chain, and whether the registry records that
+ * name as renamed away — is built in `core/gate-context-owners`. That is a
+ * different question from the one here: it knows the registry and the chain
+ * rules and nothing about verdicts, and this module knows the verdicts and
+ * reads the map through `ReadonlyMap<string, ContextOwner>` without knowing
+ * how it was derived. The seam is the one the signatures already drew.
+ * @module core/gate-declaration-drift
  */
-export type DeclarationState = "required" | "optional" | "off" | "not-declared";
+import { type ContextOwner, type DeclarationState } from "./gate-context-owners.js";
 /** Which enforcing surface a comparison was made against. */
 export type DriftSurface = "ruleset-templates" | "live-ruleset";
 /**
@@ -62,13 +74,34 @@ export type DriftVerdict =
 /** Enforced, and a registry gate produces it, but nothing declares it. */
  | "enforced-undeclared"
 /** Enforced, and no registry gate produces it — a third-party check. */
- | "enforced-not-lisa-owned";
+ | "enforced-not-lisa-owned"
+/**
+ * Enforced, and Lisa's own registry records that it RENAMED the job posting
+ * it, so nothing will ever post this name again.
+ *
+ * Not a failure and not a gap — an absence. GitHub holds a required context
+ * that never reports at "Expected — Waiting for status to be reported"
+ * indefinitely: no red tick, no log, `mergeable: MERGEABLE` with
+ * `mergeStateStatus: BLOCKED`, and every pull request in the repository
+ * red-walled with nothing naming the cause.
+ */
+ | "enforced-context-retired";
 /**
  * What to do about one verdict.
  *
  * Deliberately closed, and deliberately without a removal. See the module note.
  */
-export type DriftRemedy = "none" | "declare-the-gate" | "enforce-the-context" | "resolve-the-contradiction" | "decide-which-surface-wins";
+export type DriftRemedy = "none" | "declare-the-gate" | "enforce-the-context" | "resolve-the-contradiction" | "decide-which-surface-wins"
+/**
+ * The one removal in the vocabulary, and reachable from exactly one verdict.
+ *
+ * See the module note: it is not "this context looks unowned, drop it". It
+ * is "Lisa's registry records that Lisa renamed this job, so this exact
+ * string cannot be posted by anything, ever". A context with no owner at all
+ * never reaches this remedy — it is `enforced-not-lisa-owned`, whose remedy
+ * is still `none`.
+ */
+ | "stop-requiring-the-retired-context";
 /** One required status context, and where the requirement was read from. */
 export interface EnforcedContext {
     /** The context string, exactly as the ruleset spells it. */
@@ -82,15 +115,6 @@ export interface EnforcedContext {
      */
     readonly source: string;
 }
-/** The gate a context belongs to, and what the settings file says about it. */
-export interface ContextOwner {
-    /** Registry gate id. */
-    readonly gateId: string;
-    /** The declaration at the merge moment. */
-    readonly declaration: DeclarationState;
-    /** Whether the registry permits declaring this gate at the merge moment. */
-    readonly legalAtMerge: boolean;
-}
 /** One context, its verdict, and the evidence behind it. */
 export interface DeclarationDriftEntry {
     /** The context string. */
@@ -122,64 +146,17 @@ export interface DeclarationDriftReport {
     readonly contradictions: number;
     /** Entries whose verdict is a gap the declaration surface could close. */
     readonly gaps: number;
-}
-/** The slice of the shipped registry this comparison reads. */
-export interface MergeContextRegistry {
-    readonly REGISTRY: Readonly<Record<string, {
-        readonly label: string;
-        readonly moments: readonly string[];
-    }>>;
-    readonly resolveMoment: (options: {
-        gates: Record<string, unknown>;
-        moment: string;
-        includeOff?: boolean;
-    }) => readonly {
-        readonly id: string;
-        readonly level: string;
-        readonly mode: string;
-        readonly awaits: string | null;
-        /**
-         * The chain this declaration overrode the caller-wide one with, raw.
-         *
-         * Optional because a consumer may hold an older copy of the shipped
-         * registry that predates the field. Absent reads as "no override", which
-         * is what every registry before it meant.
-         */
-        readonly callerChain?: readonly string[] | string | null;
-    }[];
-    readonly momentFamily: (moment: string) => string;
     /**
-     * Join one declaration's own chain into the prefix its context carries.
+     * Entries the enforcing surface requires and nothing can post.
      *
-     * Optional for the same reason, and its absence is NOT a licence to join the
-     * chain here: a second implementation of the joining rule is how a rename
-     * lands in one derivation and not the other. Where it is absent, an override
-     * cannot be honoured, and the comparison says so rather than deriving the
-     * caller-wide name as though nothing had been declared.
+     * Counted separately from `contradictions` and `gaps` because it is neither.
+     * A contradiction has two surfaces saying opposite things and a gap has one
+     * surface silent; this has one surface waiting on a name that no longer
+     * exists. Folding it into either bucket would give an operator the wrong
+     * remedy, and folding it into `gaps` would let it warn when it must fail.
      */
-    readonly callerPrefix?: (chain: readonly string[] | string) => string;
+    readonly unpostable: number;
 }
-/** The moment a branch ruleset guards. */
-export declare const MERGE_MOMENT = "pull-request";
-/**
- * Map every context a registry gate can produce to that gate.
- *
- * Built from the whole registry rather than from the declared gates, which is
- * the difference between "protection requires a context whose gate nobody
- * declared" and "protection requires a context Lisa knows nothing about". Those
- * are different findings with different remedies, and a map built only from
- * declarations could not tell them apart.
- * @param options - Inputs
- * @param options.registry - The shipped registry
- * @param options.gates - The project's gates block
- * @param options.workflowName - The workflow whose name prefixes a context
- * @returns Context string to owning gate
- */
-export declare function contextOwners(options: {
-    registry: MergeContextRegistry;
-    gates: Record<string, unknown>;
-    workflowName: string;
-}): ReadonlyMap<string, ContextOwner>;
 /**
  * The contexts a `required` declaration promises protection will require.
  * @param owners - Context to owning gate

package/dist/core/gate-declaration-drift.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gate-declaration-drift.d.ts","sourceRoot":"","sources":["../../src/core/gate-declaration-drift.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"gate-declaration-drift.d.ts","sourceRoot":"","sources":["../../src/core/gate-declaration-drift.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,gBAAgB,EAEtB,MAAM,0BAA0B,CAAC;AAElC,6DAA6D;AAC7D,MAAM,MAAM,YAAY,GAAG,mBAAmB,GAAG,cAAc,CAAC;AAEhE;;;;;GAKG;AACH,MAAM,MAAM,YAAY;AACtB,kEAAkE;AAChE,SAAS;AACX,yEAAyE;GACvE,uBAAuB;AACzB,uDAAuD;GACrD,4BAA4B;AAC9B,yEAAyE;GACvE,uBAAuB;AACzB,0EAA0E;GACxE,qBAAqB;AACvB,wEAAwE;GACtE,yBAAyB;AAC3B;;;;;;;;;GASG;GACD,0BAA0B,CAAC;AAE/B;;;;GAIG;AACH,MAAM,MAAM,WAAW,GACnB,MAAM,GACN,kBAAkB,GAClB,qBAAqB,GACrB,2BAA2B,GAC3B,2BAA2B;AAC7B;;;;;;;;GAQG;GACD,oCAAoC,CAAC;AAEzC,4EAA4E;AAC5E,MAAM,WAAW,eAAe;IAC9B,4DAA4D;IAC5D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,gCAAgC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,4DAA4D;AAC5D,MAAM,WAAW,qBAAqB;IACpC,0BAA0B;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,mBAAmB;IACnB,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,0DAA0D;IAC1D,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,0EAA0E;IAC1E,QAAQ,CAAC,WAAW,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC9C,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC,mDAAmD;IACnD,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IACpC,sCAAsC;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,0DAA0D;AAC1D,MAAM,WAAW,sBAAsB;IACrC,wDAAwD;IACxD,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAC;IAC/B,gDAAgD;IAChD,QAAQ,CAAC,OAAO,EAAE,SAAS,qBAAqB,EAAE,CAAC;IACnD,iEAAiE;IACjE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC;IACxD,kEAAkE;IAClE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;;;;OAQG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAyDD;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,GACxC,SAAS,MAAM,EAAE,CAcnB;AAsGD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE;IAChD,OAAO,EAAE,YAAY,CAAC;IACtB,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC1C,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAC;CACtC,GAAG,sBAAsB,CAoEzB"}

package/dist/core/gate-declaration-drift.js

@@ -26,15 +26,34 @@
  *    "agreed and proved" from "agreed and unproved" would itself be a control
  *    reporting more than it measured, so the word this module uses is
  *    `matched` — the two surfaces agree — and never `enforced` or `proved`.
- * 3. **No remedy in this module can say "remove the context".** Third-party
- *    contexts are enforced by construction and declared by nobody; a
- *    comparator whose vocabulary contained a removal would eventually propose
- *    deleting one. The `DriftRemedy` union simply has no such member, so the
- *    guarantee holds for every caller rather than for the careful ones.
+ * 3. **A remedy may say "remove the context" only where Lisa renamed the job
+ *    itself.** The original rule here was that no remedy could ever say it,
+ *    and the reason was sound: third-party contexts are enforced by
+ *    construction and declared by nobody, so a comparator free to propose a
+ *    removal would eventually propose deleting one. That reason does not cover
+ *    one case, and #3067 is what the gap costs. When the shipped registry
+ *    carries a `previousLabels` entry, Lisa is not inferring that nothing owns
+ *    a context — it is reading its OWN record that it renamed the job, which
+ *    is proof that this exact string can never be posted again. A required
+ *    context that never reports does not fail a pull request; GitHub waits for
+ *    it forever, so leaving that unsaid red-walls the repository silently.
+ *
+ *    The narrowing is structural, not conventional. Exactly one verdict,
+ *    `enforced-context-retired`, maps to the single removal remedy, and that
+ *    verdict is reachable only from a `previousLabels` match. A context with
+ *    no owner at all is still `enforced-not-lisa-owned` with remedy `none`, so
+ *    the original guarantee holds unchanged for every third-party check.
+ *
+ * The ownership map this comparison reads — which gate produces a context
+ * string, under which caller chain, and whether the registry records that
+ * name as renamed away — is built in `core/gate-context-owners`. That is a
+ * different question from the one here: it knows the registry and the chain
+ * rules and nothing about verdicts, and this module knows the verdicts and
+ * reads the map through `ReadonlyMap<string, ContextOwner>` without knowing
+ * how it was derived. The seam is the one the signatures already drew.
  * @module core/gate-declaration-drift
  */
-/** The moment a branch ruleset guards. */
-export const MERGE_MOMENT = "pull-request";
+import { MERGE_MOMENT, } from "./gate-context-owners.js";
 /** Every verdict, named once so no two mentions can drift apart. */
 const MATCHED = "matched";
 const DECLARED_NOT_ENFORCED = "declared-not-enforced";
@@ -42,6 +61,7 @@ const ENFORCED_DECLARED_OPTIONAL = "enforced-declared-optional";
 const ENFORCED_DECLARED_OFF = "enforced-declared-off";
 const ENFORCED_UNDECLARED = "enforced-undeclared";
 const ENFORCED_NOT_LISA_OWNED = "enforced-not-lisa-owned";
+const ENFORCED_CONTEXT_RETIRED = "enforced-context-retired";
 /** Verdicts where the two surfaces state opposite things. */
 const CONTRADICTIONS = new Set([
     DECLARED_NOT_ENFORCED,
@@ -52,6 +72,10 @@ const GAPS = new Set([
     ENFORCED_DECLARED_OPTIONAL,
     ENFORCED_UNDECLARED,
 ]);
+/** Verdicts where the surface requires a name nothing can post. */
+const UNPOSTABLE = new Set([
+    ENFORCED_CONTEXT_RETIRED,
+]);
 /** The remedy each verdict calls for. */
 const REMEDIES = {
     [MATCHED]: "none",
@@ -60,6 +84,7 @@ const REMEDIES = {
     [ENFORCED_DECLARED_OFF]: "resolve-the-contradiction",
     [ENFORCED_UNDECLARED]: "declare-the-gate",
     [ENFORCED_NOT_LISA_OWNED]: "none",
+    [ENFORCED_CONTEXT_RETIRED]: "stop-requiring-the-retired-context",
 };
 /** Every verdict, so a count of zero is still a stated zero. */
 const VERDICTS = Object.keys(REMEDIES);
@@ -76,111 +101,6 @@ const SURFACE_NAMES = {
 function sorted(values) {
     return [...values].sort((left, right) => left.localeCompare(right));
 }
-/**
- * The declaration state one resolved level names.
- *
- * Anything that is not one of the three levels is `not-declared`, because an
- * unknown level is a typo rather than a claim.
- * @param level - The resolved level
- * @returns The declaration state
- */
-function asDeclaration(level) {
-    return level === "required" || level === "optional" || level === "off"
-        ? level
-        : "not-declared";
-}
-/**
- * Map every context a registry gate can produce to that gate.
- *
- * Built from the whole registry rather than from the declared gates, which is
- * the difference between "protection requires a context whose gate nobody
- * declared" and "protection requires a context Lisa knows nothing about". Those
- * are different findings with different remedies, and a map built only from
- * declarations could not tell them apart.
- * @param options - Inputs
- * @param options.registry - The shipped registry
- * @param options.gates - The project's gates block
- * @param options.workflowName - The workflow whose name prefixes a context
- * @returns Context string to owning gate
- */
-export function contextOwners(options) {
-    const { registry, gates, workflowName } = options;
-    const resolved = resolveMergeMoment(registry, gates);
-    const family = registry.momentFamily(MERGE_MOMENT);
-    const owners = Object.entries(registry.REGISTRY).map(([gateId, definition]) => {
-        const hit = resolved.get(gateId);
-        return [
-            `${prefixFor(registry, hit?.callerChain, workflowName)} / ${definition.label}`,
-            {
-                gateId,
-                declaration: asDeclaration(hit?.level),
-                legalAtMerge: definition.moments.includes(family),
-            },
-        ];
-    });
-    const awaited = [...resolved.values()].flatMap(hit => hit.mode === "await" && hit.awaits !== null
-        ? [
-            [
-                hit.awaits,
-                {
-                    gateId: hit.id,
-                    declaration: asDeclaration(hit.level),
-                    legalAtMerge: registry.REGISTRY[hit.id]?.moments.includes(family) === true,
-                },
-            ],
-        ]
-        : []);
-    return new Map([...owners, ...awaited]);
-}
-/**
- * The prefix one gate's context carries, honouring a per-declaration override.
- *
- * Three states, and the third is the one that matters. No override means the
- * caller-wide name, unchanged — which is what keeps every existing declaration
- * deriving exactly what it derived before this field existed. An override with
- * a registry able to join it means that gate's own chain. An override with a
- * registry too old to join it is refused outright, because the alternative is
- * to derive the caller-wide name for a gate whose declaration has just said
- * that name is wrong — a comparison that would report a clean match against a
- * context nothing posts.
- * @param registry - The shipped registry
- * @param chain - The declared override, when there is one
- * @param workflowName - The caller-wide chain
- * @returns The prefix
- * @throws {Error} When an override cannot be joined
- */
-function prefixFor(registry, chain, workflowName) {
-    if (chain === null || chain === undefined)
-        return workflowName;
-    if (registry.callerPrefix === undefined) {
-        throw new Error(`a gate declares its own caller chain (${JSON.stringify(chain)}), but ` +
-            `the installed copy of Lisa's check registry is too old to derive a ` +
-            `context from one. Update Lisa, or remove the override; deriving the ` +
-            `default name here would report agreement about a check that never ` +
-            `reports.`);
-    }
-    return registry.callerPrefix(chain);
-}
-/**
- * Resolve the merge moment, treating a refusal as "nothing resolved".
- *
- * A refusal is never swallowed by the caller: `readTemplateEnforcement` and the
- * health check both report the declaration problems separately. What must not
- * happen here is a throw that turns a comparison into no comparison at all.
- * @param registry - The shipped registry
- * @param gates - The project's gates block
- * @returns Resolved gates keyed by id
- */
-function resolveMergeMoment(registry, gates) {
-    try {
-        return new Map(registry
-            .resolveMoment({ gates, moment: MERGE_MOMENT, includeOff: true })
-            .map(entry => [entry.id, { ...entry }]));
-    }
-    catch {
-        return new Map();
-    }
-}
 /**
  * The contexts a `required` declaration promises protection will require.
  * @param owners - Context to owning gate
@@ -188,9 +108,27 @@ function resolveMergeMoment(registry, gates) {
  */
 export function declaredRequiredContexts(owners) {
     return sorted([...owners.entries()]
-        .filter(([, owner]) => owner.declaration === "required")
+        // A retired label is never a promise. Its gate's declaration promises
+        // the CURRENT context, so listing the old name here would report a
+        // `declared-not-enforced` gap against a string no declaration asks for
+        // and tell the operator to start requiring a context nothing posts —
+        // the permanent-pending trap, created by the check meant to find it.
+        .filter(([, owner]) => owner.declaration === "required" && retirementOf(owner) === null)
         .map(([context]) => context));
 }
+/**
+ * The rename one owner is the losing half of, normalized to null.
+ * @param owner - The gate producing a context, when one does
+ * @returns The rename, or null
+ */
+function retirementOf(owner) {
+    // `?? null` rather than `!== null`, because an owner built before this field
+    // existed carries `undefined` — and `undefined !== null` is true, which would
+    // classify EVERY context as retired and tell an operator to delete their
+    // whole required list. Callers include fixtures and any consumer holding an
+    // older shape, so the normalization lives here rather than at each read.
+    return owner?.retired ?? null;
+}
 /**
  * The verdict for one enforced context.
  * @param owner - The gate producing it, when one does
@@ -199,6 +137,12 @@ export function declaredRequiredContexts(owners) {
 function verdictForEnforced(owner) {
     if (owner === undefined)
         return ENFORCED_NOT_LISA_OWNED;
+    // Ahead of every declaration branch, because the declaration cannot rescue
+    // it. The gate may be declared `required` and run on every pull request —
+    // it posts its CURRENT label, so this string still never reports. Reading
+    // the declaration first would classify the exact #3067 case as `matched`.
+    if (retirementOf(owner) !== null)
+        return ENFORCED_CONTEXT_RETIRED;
     if (owner.declaration === "required")
         return MATCHED;
     if (owner.declaration === "optional")
@@ -214,13 +158,21 @@ function verdictForEnforced(owner) {
  * @param options.surface - The enforcing surface
  * @param options.gateId - The owning gate, when there is one
  * @param options.sources - Where the requirement was read from
+ * @param options.rulesets - The rulesets requiring it, sorted
+ * @param options.retired - The rename it is the losing half of, or null
  * @returns One operator-readable sentence
  */
 // eslint-disable-next-line sonarjs/cognitive-complexity -- one branch per verdict keeps the wording auditable
 function detailFor(options) {
-    const { verdict, gateId, sources } = options;
+    const { verdict, gateId, sources, rulesets, retired } = options;
     const surface = SURFACE_NAMES[options.surface];
     const where = sources.length === 0 ? "" : ` (${sources.join(", ")})`;
+    if (verdict === ENFORCED_CONTEXT_RETIRED && retired !== null) {
+        const named = rulesets.length === 0
+            ? " The ruleset holding it was not named by the reader."
+            : ` The requirement lives in ${rulesets.length === 1 ? "ruleset" : "rulesets"} ${rulesets.map(name => `"${name}"`).join(", ")}, which Lisa may not manage — reported here, never edited automatically.`;
+        return `NOTHING WILL EVER POST THIS. Lisa's registry records that the gate "${String(gateId)}" was renamed from "${retired.label}", and ${surface} still requires the old name${where}. This is not a failing check — GitHub holds a required context that never reports at "Expected — Waiting for status to be reported" indefinitely, so every pull request in this repository is blocked with no red tick and no log to open. The gate posts "${retired.replacement}" now.${named} Remove the old context first, then require the new one: requiring the new one before the job posts it creates the same permanent wait in the other direction.`;
+    }
     if (verdict === MATCHED) {
         return `Declared required, and ${surface} requires it${where}. The two surfaces agree; that is not evidence the check proves its property.`;
     }
@@ -277,19 +229,22 @@ export function classifyDeclarationDrift(options) {
         const verdict = verdictForEnforced(owner);
         const found = grouped.get(context);
         const sources = sorted(new Set(found?.sources ?? []));
+        const rulesets = sorted(new Set(found?.rulesets ?? []));
         return {
             context,
             verdict,
             remedy: REMEDIES[verdict],
             gateId: owner?.gateId ?? null,
             declaration: owner?.declaration ?? null,
-            rulesets: sorted(new Set(found?.rulesets ?? [])),
+            rulesets,
             sources,
             detail: detailFor({
                 verdict,
                 surface,
                 gateId: owner?.gateId ?? null,
                 sources,
+                rulesets,
+                retired: retirementOf(owner),
             }),
         };
     });
@@ -310,6 +265,8 @@ export function classifyDeclarationDrift(options) {
                 surface,
                 gateId,
                 sources: [],
+                rulesets: [],
+                retired: null,
             }),
         };
     });
@@ -324,6 +281,7 @@ export function classifyDeclarationDrift(options) {
         contradictions: entries.filter(entry => CONTRADICTIONS.has(entry.verdict))
             .length,
         gaps: entries.filter(entry => GAPS.has(entry.verdict)).length,
+        unpostable: entries.filter(entry => UNPOSTABLE.has(entry.verdict)).length,
     };
 }
 //# sourceMappingURL=gate-declaration-drift.js.map