@codyswann/lisa 4.15.1 → 4.17.0

package/dist/opencode/plugin-templates/parity-safety-net.sh

@@ -61,12 +61,20 @@
 # can match — including one whose target sits in the SAME quoted run as the
 # prose, which the #3106 scoping deliberately does not reach. Upstream exempts
 # those through an engine-only DISPLAY_COMMANDS list that a grep hook cannot
-# replicate. The same text-scan limit means the rm guard treats
+# replicate. WHAT TO DO WHEN YOU HIT IT (issue #3191): do not reword the prose.
+# When the destructive text is a commit message, an issue body or a results
+# table, the string IS the deliverable and there is no narrower spelling that
+# still says what it must say. Write the text to a file with the Write tool and
+# pass it BY PATH — `gh issue comment --body-file <file>`, `git commit -F
+# <file>` — because these guards scan the COMMAND and never the file. block()
+# prints this at the wall so the operator is told rather than left to find it.
+# The same text-scan limit means the rm guard treats
 # a substitution-wrapped catastrophic delete as verdict-neutral (issue #1982): an
 # executable `echo "$(rm -rf /)"` is blocked, but so are inert twins the shell
 # would never expand — a single-quoted `echo '$(rm -rf /)'` or an escaped
 # `echo "\$(rm -rf /)"` — because the scan has no quote-context awareness. That
-# over-block stays inside this accepted class. Workaround: quote-break the string
+# over-block stays inside this accepted class. Workaround: the write-to-a-file
+# and pass-by-path form above, or quote-break the string,
 # or use the gh-writer heredoc form, whose payload is stripped before the guards
 # run — spelled with a QUOTE-PAIR delimiter (`<<'EOF'`). That exact spelling is
 # what the SAFE path recognises; `<<"EOF"` and `<<\EOF` do not reach it, and
@@ -115,15 +123,58 @@ if [ -z "$command_str" ]; then
   exit 0
 fi
 
+# Guidance printed under an ordinary destructive-guard refusal.
+#
+# It teaches the remedy at the wall, the way block_heredoc() does (gardener
+# #1789, extended by issue #3191). It used to end in "narrow the command so it
+# no longer matches the guard", which is advice the accepted prose class CANNOT
+# follow: when the destructive text is a commit message, an issue body or a
+# results table, the string IS the deliverable and there is no narrower spelling
+# that still says what it must say. An operator acts on a printed remedy, so a
+# remedy that cannot be performed is worse than none — it spends the detour and
+# teaches that the refusal was a formality. The remedy that does work is the
+# sibling heredoc one, one surface over: write the text with the Write tool,
+# then pass it BY PATH. The guards scan the COMMAND and never the file, so the
+# path form carries the text through intact.
+#
+# Both branches are printed on every ordinary refusal, deliberately: this guard
+# is a text scan and CANNOT tell which one applies, so naming both and letting
+# the reader pick is the only honest shape. Deciding for them is what the
+# engine-only DISPLAY_COMMANDS list does, and the header explains why a grep
+# hook cannot have one.
+DESTRUCTIVE_GUIDANCE="$(
+  cat <<'EOF'
+This command matched a destructive-operation guard. The guard is a text scan,
+not a shell engine, so it cannot tell a destructive command you are RUNNING
+from the same text quoted as CONTENT you are writing. Take the branch that
+describes yours:
+
+- The destructive text is only QUOTED CONTENT — a commit message, an issue or
+  PR body, a report, a results table, a note. Do not try to reword it; the
+  string is the deliverable and no narrower spelling still says what it must.
+  Write the text to a file with the Write tool and pass it BY PATH instead:
+  `gh issue comment --body-file <file>`, `gh pr create --body-file <file>`,
+  `git commit -F <file>`, or read the file back with the Read tool. This guard
+  scans the command, never the file, so the path form goes through intact.
+
+- You genuinely intend to run the destructive operation. Ask the user to
+  confirm, then run it manually outside the agent.
+EOF
+)"
+
 # block() prints the reason to stderr (surfaced to the model) and exits 2 so the
 # Bash tool call is denied. $1 = human-readable reason for the block.
+#
+# $2 = optional guidance REPLACING $DESTRUCTIVE_GUIDANCE. block_heredoc() passes
+# its own, because the two remedies are mutually exclusive by construction
+# (issue #1958 F6): a heredoc payload IS executable shell, so the quoted-content
+# branch is exactly the misdirection that finding removed, and the file-based
+# execution advice is exactly what an ordinary prose refusal must not be given.
 block() {
   cat >&2 <<EOF
 Blocked by safety-net: $1
 
-This command matched a destructive-operation guard. If it is genuinely safe and
-intentional, ask the user to confirm, then run it manually outside the agent, or
-narrow the command so it no longer matches the guard.
+${2:-$DESTRUCTIVE_GUIDANCE}
 EOF
   exit 2
 }
@@ -199,20 +250,22 @@ EOF
 # depends on the command shape (issue #1958): `git commit -m "$(cat <<EOF …)"`
 # attempts get the commit -F text; every other heredoc denial gets the
 # file-based execution guidance instead — the commit text is misleading there.
+# Both are passed as block()'s SECOND argument, which REPLACES the ordinary
+# destructive guidance rather than appending to it (issue #3191): that guidance
+# offers a quoted-content branch, and a heredoc payload is executable shell, so
+# printing it here would reintroduce the misdirection #1958 F6 removed.
 # The git-commit detection inlines the GIT_GLOBAL_OPTS shape (defined later in
 # this file, after the heredoc dispatch runs) so `git -C <path> commit` and
 # `git -c k=v commit` spellings are still recognized.
 block_heredoc() {
   if scan -E "$command_str" \
     '(^|[^[:alnum:]_-])git[[:space:]]+(-[^;&|[:space:]]+([[:space:]]+[^-;&|[:space:]][^;&|[:space:]]*)?[[:space:]]+)*commit([^[:alnum:]_-]|$)'; then
-    block "$1
-Heredoc commit invocations are blocked (the payload is executable shell).
+    block "$1" "Heredoc commit invocations are blocked (the payload is executable shell).
 Fix: write the commit message to a file and run \`git commit -F <file>\`.
 Every commit must also carry a Co-authored-by trailer for a supported agent
 (Claude/Codex/OpenCode) — the commit-msg hook enforces this."
   fi
-  block "$1
-Heredoc payloads are blocked here (the payload is executable shell).
+  block "$1" "Heredoc payloads are blocked here (the payload is executable shell).
 Fix: write the payload to a file with the Write tool, then execute that file
 directly (for example \`python3 <file>\` or \`bash <file>\`)."
 }

package/dist/strategies/package-lisa.d.ts

@@ -1,5 +1,6 @@
 import type { FileOperationResult, ProjectType } from "../core/config.js";
 import type { ICopyStrategy, StrategyContext } from "./strategy.interface.js";
+import { type OverrideFloorAudit } from "../core/override-floors.js";
 /**
  * @file package-lisa.ts
  * @description Package.lisa.json strategy for governance-driven package.json management
@@ -24,6 +25,34 @@ import type { ICopyStrategy, StrategyContext } from "./strategy.interface.js";
  * Child types override parent values in each section.
  * @module strategies
  */
+/** Which of the two apply paths an override-floor audit simulated. */
+export type ApplyPathLabel = "postinstall" | "full apply";
+/** One apply path's answer: an audit, or the reason there is none. */
+export interface OverrideFloorPathAudit {
+    /** Apply path simulated. */
+    readonly applyPath: ApplyPathLabel;
+    /** What the path inspected and found, or null when it could not run. */
+    readonly audit: OverrideFloorAudit | null;
+    /** Why the path could not run, or null when it did. */
+    readonly error: string | null;
+}
+/** Everything one override-floor audit of a project looked at. */
+export interface OverrideFloorAuditReport {
+    /**
+     * Literal (non-`$name`) entries across the resolved template's
+     * `force.overrides` and `force.resolutions` — the floors Lisa would write.
+     *
+     * Zero is the inert case, not a clean one: it means template resolution
+     * produced nothing to compare against, so the audit below cannot have
+     * verified anything. Callers must not read an empty conflict list as a pass
+     * without reading this first.
+     */
+    readonly lisaFloors: number;
+    /** Project types the apply itself would detect here. */
+    readonly detectedTypes: readonly ProjectType[];
+    /** One entry per apply path. */
+    readonly paths: readonly OverrideFloorPathAudit[];
+}
 /**
  * Package.lisa.json strategy: Manage package.json via separate template files
  * - Loads templates from all applicable types in inheritance chain
@@ -58,6 +87,36 @@ export declare class PackageLisaStrategy implements ICopyStrategy {
      * @returns Package document that apply would persist
      */
     planPackageJson(projectJson: Record<string, unknown>, detectedTypes: readonly ProjectType[], lisaDir: string, securityPinsOnly?: boolean): Promise<Record<string, unknown>>;
+    /**
+     * Report every `$name` override that would resolve BELOW a Lisa floor, before
+     * an apply refuses over it.
+     * @remarks
+     * Deliberately re-runs the apply's own resolution — the same type detection,
+     * the same template inheritance chain, the same force/preserve/adopt phases —
+     * rather than re-deriving the answer from `package.lisa.json` and the host
+     * manifest side by side. A second implementation of "what would the merged
+     * manifest look like" is a second thing to keep in step with this file, and
+     * the whole value of the report is that it agrees with the refusal.
+     *
+     * BOTH apply paths are simulated. The postinstall path applies a template
+     * restricted to security pins and pulls in the direct dependencies backing
+     * them, so it can accept a manifest the unrestricted path refuses and vice
+     * versa. Reporting only one leaves an operator refused by the other with a
+     * doctor line that said nothing.
+     * @param projectDir - Host project directory containing package.json
+     * @param lisaDir - Installed Lisa package root
+     * @returns What was inspected on each path, and every conflict found
+     */
+    auditOverrideFloors(projectDir: string, lisaDir: string): Promise<OverrideFloorAuditReport>;
+    /**
+     * Simulate one apply path and audit the manifest it would produce.
+     * @param projectJson - Parsed host package.json
+     * @param merged - Fully resolved template for the detected types
+     * @param applyPath - Which path to simulate
+     * @returns The path's audit, or the reason it could not be produced
+     * @private
+     */
+    private auditOneApplyPath;
     /**
      * Apply package-lisa strategy: Load templates from inheritance chain, apply to package.json
      * @remarks

package/dist/strategies/package-lisa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package-lisa.d.ts","sourceRoot":"","sources":["../../src/strategies/package-lisa.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE1E,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AA8B9E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;GAMG;AACH,qBAAa,mBAAoB,YAAW,aAAa;IAUrD,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IATtC,QAAQ,CAAC,IAAI,EAAG,cAAc,CAAU;IAExC;;;;;OAKG;gBAEgB,mBAAmB,GAAE,MAAM,MAA0B;IAGxE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAkB;IAC/C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAmB;IACjD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAc;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAc;IACvC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAmB;IACjD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAc;IACvC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAA0C;IAC5E,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAGhC;IAEF;;;;;;;OAOG;IACG,eAAe,CACnB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,aAAa,EAAE,SAAS,WAAW,EAAE,EACrC,OAAO,EAAE,MAAM,EACf,gBAAgB,UAAQ,GACvB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAmBnC;;;;;;;;;;;;;OAaG;IACG,KAAK,CACT,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,mBAAmB,CAAC;IA+D/B;;;;;;;;;OASG;YACW,iBAAiB;IAmB/B;;;;;;;;;OASG;YACW,iBAAiB;IAwC/B;;;;;;;;OAQG;YACW,gBAAgB;IAkC9B;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,OAAO,CAAC,sBAAsB;IAsB9B;;;;;;;;;OASG;IACH,OAAO,CAAC,wBAAwB;IAsChC;;;;;;OAMG;YACW,kBAAkB;IA0DhC;;;;;;OAMG;YACW,+BAA+B;IAkB7C;;;;;;OAMG;YACW,wBAAwB;IAgBtC;;;;;;OAMG;YACW,8BAA8B;IAmB5C;;;;;;OAMG;YACW,gBAAgB;IAW9B;;;;;;;;;OASG;YACW,qBAAqB;IA0CnC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,mBAAmB;IAgB3B;;;;;;;;OAQG;IACH,OAAO,CAAC,cAAc;IAgBtB;;;;;;;OAOG;IACH,OAAO,CAAC,kBAAkB;IAmB1B;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,aAAa;IAkDrB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,mBAAmB;IAwB3B;;;;;;;OAOG;IACH,OAAO,CAAC,kBAAkB;IAsB1B;;;;;;;;OAQG;IACH,OAAO,CAAC,iBAAiB;CA2B1B"}
+{"version":3,"file":"package-lisa.d.ts","sourceRoot":"","sources":["../../src/strategies/package-lisa.ts"],"names":[],"mappings":"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"}

package/dist/strategies/package-lisa.js

@@ -8,32 +8,9 @@ import { PROJECT_TYPE_HIERARCHY, PROJECT_TYPE_ORDER } from "../core/config.js";
 import { ensureParentDir } from "../utils/file-operations.js";
 import { readJson, writeJson, deepMerge, readJsonOrNull, } from "../utils/json-utils.js";
 import { JsonMergeError } from "../errors/index.js";
+import { asRecord, auditSelfReferenceRewrites, collectDirectDependencyNames, describeSelfReferenceRemedy, DIRECT_DEPENDENCY_SECTIONS, OVERRIDE_SECTIONS, } from "../core/override-floors.js";
 import { LISA_PACKAGE_NAME } from "../core/self-apply.js";
 import { getPackageVersion } from "../cli/version.js";
-/**
- * @file package-lisa.ts
- * @description Package.lisa.json strategy for governance-driven package.json management
- *
- * Implements a two-file approach to package.json governance:
- * - Source: package.lisa.json files in type directories (all/, typescript/, expo/, etc.)
- * - Destination: project's package.json
- *
- * Behavior is defined in package.lisa.json:
- * - force: Lisa's values completely replace project's values
- * - adopt: Lisa reclaims a key still holding a value Lisa itself wrote
- * - defaults: Project's values preserved; Lisa's used only if missing
- * - merge: Arrays concatenated and deduplicated
- * - remove: Retired keys deleted from their section
- *
- * A governed script CI invokes is shipped as a pair — `lint:lisa` forced, and
- * `lint` merely defaulted to invoke it — so the host owns the composition point
- * and anything chained onto it survives an apply. See the reserved-base section
- * of `wiki/documentation/specs/package-lisa-json.md`.
- *
- * Inheritance chain: all → typescript → specific types (expo, nestjs, cdk, npm-package)
- * Child types override parent values in each section.
- * @module strategies
- */
 /**
  * Package.lisa.json strategy: Manage package.json via separate template files
  * - Loads templates from all applicable types in inheritance chain
@@ -78,6 +55,66 @@ export class PackageLisaStrategy {
         assertManifestIsInstallable(result.packageJson, this.PACKAGE_JSON);
         return result.packageJson;
     }
+    /**
+     * Report every `$name` override that would resolve BELOW a Lisa floor, before
+     * an apply refuses over it.
+     * @remarks
+     * Deliberately re-runs the apply's own resolution — the same type detection,
+     * the same template inheritance chain, the same force/preserve/adopt phases —
+     * rather than re-deriving the answer from `package.lisa.json` and the host
+     * manifest side by side. A second implementation of "what would the merged
+     * manifest look like" is a second thing to keep in step with this file, and
+     * the whole value of the report is that it agrees with the refusal.
+     *
+     * BOTH apply paths are simulated. The postinstall path applies a template
+     * restricted to security pins and pulls in the direct dependencies backing
+     * them, so it can accept a manifest the unrestricted path refuses and vice
+     * versa. Reporting only one leaves an operator refused by the other with a
+     * doctor line that said nothing.
+     * @param projectDir - Host project directory containing package.json
+     * @param lisaDir - Installed Lisa package root
+     * @returns What was inspected on each path, and every conflict found
+     */
+    async auditOverrideFloors(projectDir, lisaDir) {
+        const projectJson = (await readJsonOrNull(path.join(projectDir, this.PACKAGE_JSON))) ?? {};
+        const detectedTypes = await this.detectProjectTypes(projectDir);
+        const merged = await this.loadAndMergeTemplates(lisaDir, detectedTypes);
+        return {
+            lisaFloors: countTemplateFloors(merged),
+            detectedTypes,
+            paths: [
+                this.auditOneApplyPath(projectJson, merged, "postinstall"),
+                this.auditOneApplyPath(projectJson, merged, "full apply"),
+            ],
+        };
+    }
+    /**
+     * Simulate one apply path and audit the manifest it would produce.
+     * @param projectJson - Parsed host package.json
+     * @param merged - Fully resolved template for the detected types
+     * @param applyPath - Which path to simulate
+     * @returns The path's audit, or the reason it could not be produced
+     * @private
+     */
+    auditOneApplyPath(projectJson, merged, applyPath) {
+        const restricted = applyPath === "postinstall" || projectJson.name === LISA_PACKAGE_NAME;
+        const effective = restricted ? this.restrictToSecurityPins(merged) : merged;
+        try {
+            const forced = this.applyTemplate(projectJson, effective, this.PACKAGE_JSON, restricted);
+            return {
+                applyPath,
+                audit: auditSelfReferenceRewrites(forced.packageJson),
+                error: null,
+            };
+        }
+        catch (error) {
+            return {
+                applyPath,
+                audit: null,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
     /**
      * Apply package-lisa strategy: Load templates from inheritance chain, apply to package.json
      * @remarks
@@ -928,15 +965,6 @@ function describeUnrunGates(after, template) {
         ];
     });
 }
-/** package.json sections whose keys are treated as direct dependencies. */
-const DIRECT_DEPENDENCY_SECTIONS = [
-    "dependencies",
-    "devDependencies",
-    "optionalDependencies",
-    "peerDependencies",
-];
-/** package.json sections that carry npm-style version overrides. */
-const OVERRIDE_SECTIONS = ["overrides", "resolutions"];
 /**
  * Every section whose forced values are a version FLOOR rather than an
  * assignment, and which therefore may never be merged downwards.
@@ -1206,85 +1234,55 @@ function rangeFloor(range) {
  * @returns Planned package.json plus operator-visible notes.
  */
 function planSelfReferencingOverrideNormalization(pkg, fileName) {
-    const directDeps = collectDirectDependencyNames(pkg);
-    if (directDeps.size === 0) {
+    const audit = auditSelfReferenceRewrites(pkg);
+    const refused = audit.conflicts[0];
+    if (refused !== undefined) {
+        throw new JsonMergeError(fileName, formatSelfReferenceRefusal(refused));
+    }
+    if (audit.rewritable.length === 0) {
         return { packageJson: pkg, notes: [] };
     }
-    const directRanges = collectDirectDependencyRanges(pkg);
-    const rewritePlan = OVERRIDE_SECTIONS.reduce((acc, section) => {
-        const entries = pkg[section];
-        if (entries === null ||
-            typeof entries !== "object" ||
-            Array.isArray(entries)) {
-            return acc;
-        }
-        const pairs = Object.entries(entries);
-        const sectionRewrites = pairs.flatMap(([name, value]) => {
-            if (!needsSelfReferenceRewrite(directDeps, name, value)) {
-                return [];
-            }
-            const directRange = directRanges.get(name);
-            if (directRange === undefined) {
-                return [];
-            }
-            const literalRange = value;
-            assertSelfReferenceRewriteDoesNotWiden(fileName, section, name, literalRange, directRange);
-            return [{ section, name, literalRange, directRange }];
-        });
-        if (sectionRewrites.length === 0) {
-            return acc;
+    const sections = OVERRIDE_SECTIONS.flatMap(section => {
+        const rewrites = audit.rewritable.filter(rewrite => rewrite.section === section);
+        if (rewrites.length === 0) {
+            return [];
         }
-        const normalized = Object.fromEntries(pairs.map(([name, value]) => sectionRewrites.some(rewrite => rewrite.name === name)
+        const normalized = Object.fromEntries(Object.entries(asRecord(pkg[section])).map(([name, value]) => rewrites.some(rewrite => rewrite.name === name)
             ? [name, `$${name}`]
             : [name, value]));
-        return {
-            sections: { ...acc.sections, [section]: normalized },
-            rewrites: [...acc.rewrites, ...sectionRewrites],
-        };
-    }, { sections: {}, rewrites: [] });
-    const packageJson = Object.keys(rewritePlan.sections).length > 0
-        ? { ...pkg, ...rewritePlan.sections }
-        : pkg;
+        return [[section, normalized]];
+    });
     return {
-        packageJson,
-        notes: rewritePlan.rewrites.map(formatSelfReferenceRewriteNote),
+        packageJson: { ...pkg, ...Object.fromEntries(sections) },
+        notes: audit.rewritable.map(formatSelfReferenceRewriteNote),
     };
 }
 /**
- * Decide whether an override/resolution entry needs npm `$name` normalization.
- * @param directDeps - Direct dependency names in the merged package
- * @param name - Override/resolution key
- * @param value - Override/resolution value
- * @returns True when the entry is a literal direct-dependency collision
- */
-function needsSelfReferenceRewrite(directDeps, name, value) {
-    return (directDeps.has(name) &&
-        typeof value === "string" &&
-        value.length > 0 &&
-        !value.startsWith("$"));
-}
-/**
- * Refuse a `$name` rewrite unless the direct dependency range is no wider.
- * @param fileName - Basename used in error messages
- * @param section - Override section carrying the entry
- * @param name - Package name being rewritten
- * @param literalRange - Literal override/resolution range to replace
- * @param directRange - Direct dependency range `$name` would resolve to
- * @throws JsonMergeError when the rewrite is unprovable or widening
+ * Explain a refused `$name` rewrite, ending with a remedy Lisa has TESTED.
+ * @remarks
+ * The old message ended "Pin the direct dependency to <the override> or choose
+ * a direct range that is no wider" — advice naming no concrete range which, for
+ * a bounded floor, is not satisfiable by the obvious reading of it. An operator
+ * who follows a refusal's own instructions and is refused a second time
+ * concludes the guard is broken rather than the range wrong
+ * (CodySwannGT/lisa#3191), which is how a correct security control gets routed
+ * around. The replacement names ONE range and has run it back through the same
+ * predicate that produced the refusal.
+ * @param conflict - The conflict that stopped the apply
+ * @returns Human-readable refusal naming both ranges and the verified raise
  */
-function assertSelfReferenceRewriteDoesNotWiden(fileName, section, name, literalRange, directRange) {
-    if (!semver.validRange(literalRange) || !semver.validRange(directRange)) {
-        throw new JsonMergeError(fileName, `${section}.${name} cannot be rewritten to "$${name}" because Lisa ` +
-            `cannot prove the direct dependency range ${JSON.stringify(directRange)} ` +
-            `is no wider than the literal override ${JSON.stringify(literalRange)}.`);
-    }
-    if (!semver.subset(directRange, literalRange)) {
-        throw new JsonMergeError(fileName, `${section}.${name} would widen if rewritten to "$${name}": the literal ` +
-            `override ${JSON.stringify(literalRange)} would resolve to direct ` +
-            `dependency range ${JSON.stringify(directRange)}. Pin the direct ` +
-            `dependency to ${JSON.stringify(literalRange)} or choose a direct range ` +
-            `that is no wider than the override.`);
+function formatSelfReferenceRefusal(conflict) {
+    const remedy = describeSelfReferenceRemedy(conflict);
+    if (conflict.verdict === "unprovable") {
+        return (`${conflict.section}.${conflict.name} cannot be rewritten to ` +
+            `"$${conflict.name}" because Lisa cannot prove the direct dependency ` +
+            `range ${JSON.stringify(conflict.directRange)} is no wider than the ` +
+            `literal override ${JSON.stringify(conflict.floorRange)}. ${remedy}`);
     }
+    return (`${conflict.section}.${conflict.name} would widen if rewritten to ` +
+        `"$${conflict.name}": the literal override ` +
+        `${JSON.stringify(conflict.floorRange)} would resolve to direct ` +
+        `dependency range ${JSON.stringify(conflict.directRange)}. ${remedy}`);
 }
 /**
  * Format the operator-visible explanation for a safe `$name` rewrite.
@@ -1293,21 +1291,10 @@ function assertSelfReferenceRewriteDoesNotWiden(fileName, section, name, literal
  */
 function formatSelfReferenceRewriteNote(rewrite) {
     return (`Normalized ${rewrite.section}.${rewrite.name}: replaced literal ` +
-        `${JSON.stringify(rewrite.literalRange)} with "$${rewrite.name}" ` +
+        `${JSON.stringify(rewrite.floorRange)} with "$${rewrite.name}" ` +
         `resolving to direct dependency range ` +
         `${JSON.stringify(rewrite.directRange)}.`);
 }
-/**
- * Narrow an unknown value to a plain object record, returning {} otherwise.
- * @param value - Candidate value
- * @returns The value as a record, or an empty record when it is not a plain object
- */
-function asRecord(value) {
-    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-        return value;
-    }
-    return {};
-}
 /**
  * Recursively collect every `$name` reference found in a single JSON value. npm
  * overrides/resolutions use a `"$name"` string value to mean "resolve to the
@@ -1351,23 +1338,6 @@ function collectLiteralOverrideNames(sections) {
             : []);
     }));
 }
-/**
- * Collect the names of every direct dependency declared across a package.json's
- * dependency sections.
- * @param pkg - Merged package.json object
- * @returns Set of direct dependency names
- */
-function collectDirectDependencyNames(pkg) {
-    return new Set(DIRECT_DEPENDENCY_SECTIONS.flatMap(section => Object.keys(asRecord(pkg[section]))));
-}
-/**
- * Collect direct dependency ranges by package name.
- * @param pkg - Merged package.json object
- * @returns Package name to string range map
- */
-function collectDirectDependencyRanges(pkg) {
-    return new Map(DIRECT_DEPENDENCY_SECTIONS.flatMap(section => Object.entries(asRecord(pkg[section])).flatMap(([name, value]) => typeof value === "string" ? [[name, value]] : [])));
-}
 /**
  * Fail the apply when the merged package.json carries a `$name` self-reference
  * in overrides/resolutions without the backing direct dependency. Writing such
@@ -1452,4 +1422,16 @@ function assertManifestIsInstallable(pkg, fileName) {
     assertNoDanglingDollarRefs(pkg, fileName);
 }
 /* eslint-enable max-lines -- Re-enable after comprehensive package merge strategy */
+/**
+ * Count the literal version floors a resolved template would write.
+ *
+ * A `$name` entry is not counted: it carries no floor of its own, so it can
+ * never be the thing a host range resolves below.
+ * @param template - Fully resolved package.lisa.json template
+ * @returns Number of literal entries across force.overrides and force.resolutions
+ */
+function countTemplateFloors(template) {
+    return OVERRIDE_SECTIONS.reduce((total, section) => total +
+        Object.values(asRecord(template.force[section])).filter(value => typeof value === "string" && !value.startsWith("$")).length, 0);
+}
 //# sourceMappingURL=package-lisa.js.map