sela-core 1.0.8 → 1.0.9

package/dist/services/HealingAdvisory.d.ts

@@ -4,7 +4,15 @@ export declare enum AdvisoryCode {
     CROSS_FILE_MUTATION = "CROSS_FILE_MUTATION",
     MANUAL_REVIEW_TEMPLATE_COMPLEX = "MANUAL_REVIEW_TEMPLATE_COMPLEX",
     MANUAL_REVIEW_CONDITIONAL_RETURN = "MANUAL_REVIEW_CONDITIONAL_RETURN",
-    POST_MUTATION_TYPE_ERROR = "POST_MUTATION_TYPE_ERROR"
+    POST_MUTATION_TYPE_ERROR = "POST_MUTATION_TYPE_ERROR",
+    /**
+     * A definition-site string constant was healed to a valid PUBLIC selector
+     * string (e.g. `role=button[name="…"]`) because the constant is consumed by
+     * `.locator(VAR)` and cannot hold a semantic locator. The AI's preferred
+     * semantic method form (e.g. `getByRole(...)`) is suggested as a cleaner,
+     * optional refactor.
+     */
+    SEMANTIC_UPGRADE_SUGGESTED = "SEMANTIC_UPGRADE_SUGGESTED"
 }
 export interface Advisory {
     code: AdvisoryCode;

package/dist/services/HealingAdvisory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HealingAdvisory.d.ts","sourceRoot":"","sources":["../../src/services/HealingAdvisory.ts"],"names":[],"mappings":"AAQA,oBAAY,YAAY;IACtB,oBAAoB,yBAAyB;IAC7C,oBAAoB,yBAAyB;IAC7C,mBAAmB,wBAAwB;IAC3C,8BAA8B,mCAAmC;IACjE,gCAAgC,qCAAqC;IACrE,wBAAwB,6BAA6B;CACtD;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,YAAY,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAAkB;IAE/B,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAI9B,KAAK,IAAI,IAAI;IAab,IAAI,MAAM,IAAI,MAAM,CAEnB;CACF"}
+{"version":3,"file":"HealingAdvisory.d.ts","sourceRoot":"","sources":["../../src/services/HealingAdvisory.ts"],"names":[],"mappings":"AAQA,oBAAY,YAAY;IACtB,oBAAoB,yBAAyB;IAC7C,oBAAoB,yBAAyB;IAC7C,mBAAmB,wBAAwB;IAC3C,8BAA8B,mCAAmC;IACjE,gCAAgC,qCAAqC;IACrE,wBAAwB,6BAA6B;IACrD;;;;;;OAMG;IACH,0BAA0B,+BAA+B;CAC1D;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,YAAY,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAAkB;IAE/B,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAI9B,KAAK,IAAI,IAAI;IAab,IAAI,MAAM,IAAI,MAAM,CAEnB;CACF"}

package/dist/services/HealingAdvisory.js

@@ -16,6 +16,14 @@ var AdvisoryCode;
     AdvisoryCode["MANUAL_REVIEW_TEMPLATE_COMPLEX"] = "MANUAL_REVIEW_TEMPLATE_COMPLEX";
     AdvisoryCode["MANUAL_REVIEW_CONDITIONAL_RETURN"] = "MANUAL_REVIEW_CONDITIONAL_RETURN";
     AdvisoryCode["POST_MUTATION_TYPE_ERROR"] = "POST_MUTATION_TYPE_ERROR";
+    /**
+     * A definition-site string constant was healed to a valid PUBLIC selector
+     * string (e.g. `role=button[name="…"]`) because the constant is consumed by
+     * `.locator(VAR)` and cannot hold a semantic locator. The AI's preferred
+     * semantic method form (e.g. `getByRole(...)`) is suggested as a cleaner,
+     * optional refactor.
+     */
+    AdvisoryCode["SEMANTIC_UPGRADE_SUGGESTED"] = "SEMANTIC_UPGRADE_SUGGESTED";
 })(AdvisoryCode || (exports.AdvisoryCode = AdvisoryCode = {}));
 class AdvisoryBuffer {
     items = [];

package/dist/services/InitializerUpdater.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InitializerUpdater.d.ts","sourceRoot":"","sources":["../../src/services/InitializerUpdater.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,UAAU,EAAiB,MAAM,UAAU,CAAC;AAc3D,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED,qBAAa,kBAAkB;IAC7B;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CACV,SAAS,EAAE,IAAI,EACf,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,MAAM,GACf,iBAAiB,GAAG,IAAI;CAsC5B"}
+{"version":3,"file":"InitializerUpdater.d.ts","sourceRoot":"","sources":["../../src/services/InitializerUpdater.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,UAAU,EAAiB,MAAM,UAAU,CAAC;AAe3D,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED,qBAAa,kBAAkB;IAC7B;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CACV,SAAS,EAAE,IAAI,EACf,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,MAAM,GACf,iBAAiB,GAAG,IAAI;CAkD5B"}

package/dist/services/InitializerUpdater.js

@@ -5,6 +5,7 @@ const ts_morph_1 = require("ts-morph");
 const TemplateDiffService_js_1 = require("./TemplateDiffService.js");
 const DryRunGuard_1 = require("../config/DryRunGuard");
 const WorkspaceSnapshotService_1 = require("./WorkspaceSnapshotService");
+const SelectorSanitizer_1 = require("./SelectorSanitizer");
 class InitializerUpdater {
     /**
      * Mutate a StringLiteral or NoSubstitutionTemplateLiteral node to
@@ -14,6 +15,15 @@ class InitializerUpdater {
      * mutation throws (caller should fall through to existing strategies).
      */
     static apply(valueNode, sourceFile, newValue) {
+        // ABSOLUTE GUARD: never serialise a Playwright internal engine selector
+        // into a string-literal definition. `.locator()` strings cannot express
+        // a semantic locator (getByRole/…), so writing `internal:role=…` here is
+        // the bug that leaks engine internals into user source. Refuse → the
+        // caller escalates to a semantic-guard (no regex fallback corruption).
+        if ((0, SelectorSanitizer_1.isInternalEngineSelector)(newValue)) {
+            console.warn(`[InitializerUpdater] ⛔ refusing to write internal engine selector into source: "${newValue.slice(0, 64)}"`);
+            return null;
+        }
         try {
             if (ts_morph_1.Node.isStringLiteral(valueNode)) {
                 valueNode.setLiteralValue(newValue);

package/dist/services/InteractiveReview.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InteractiveReview.d.ts","sourceRoot":"","sources":["../../src/services/InteractiveReview.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,uEAAuE;IACvE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,6EAA6E;IAC7E,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CA0B3D"}
+{"version":3,"file":"InteractiveReview.d.ts","sourceRoot":"","sources":["../../src/services/InteractiveReview.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,uEAAuE;IACvE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,6EAA6E;IAC7E,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAChC;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CA6B3D"}

package/dist/services/InteractiveReview.js

@@ -67,7 +67,10 @@ function printHealReview(deps) {
         return;
     log("");
     if (entries.length > 0) {
-        log(chalk_1.default.bold.bgCyan.black(` [Sela] Local DX Review - ${entries.length} fix${entries.length === 1 ? "" : "es"} applied to disk `));
+        // Count actual healed selectors (a file can hold several), not files.
+        const fileCount = entries.length;
+        const fixCount = entries.reduce((n, e) => n + (e.healCount ?? 1), 0);
+        log(chalk_1.default.bold.bgCyan.black(` [Sela] Local DX Review - ${fixCount} fix${fixCount === 1 ? "" : "es"} applied across ${fileCount} file${fileCount === 1 ? "" : "s"} `));
         for (const entry of entries) {
             renderEntry(entry, log);
         }

package/dist/services/MutationApplier.d.ts

@@ -0,0 +1,55 @@
+import { AnchorKey, SourceSpan } from "./AnchorResolver";
+/**
+ * A single edit. `replace` edits carry an `anchor` and are RE-RESOLVED at
+ * apply-time (span recomputed from the fresh parse). `insert` edits (forks)
+ * carry a literal `span` computed against the same content being applied.
+ */
+export interface AnchoredEdit {
+    kind: "replace" | "insert";
+    replacement: string;
+    /** Replace target — re-resolved via resolveAnchor at apply time. */
+    anchor?: AnchorKey;
+    /** Literal span for inserts (and as a fallback for anchorless replaces). */
+    span?: SourceSpan;
+    /**
+     * Require the replacement to be a Locator-returning expression. Defaults to
+     * true for `replace`. Set false for inserts / non-locator edits.
+     */
+    requireLocator?: boolean;
+}
+export interface FileBatch {
+    filePath: string;
+    edits: AnchoredEdit[];
+}
+export type ApplyStatus = "applied" | "rolled-back" | "no-op" | "skipped";
+export interface ApplyOutcome {
+    filePath: string;
+    status: ApplyStatus;
+    reason: string;
+    written: boolean;
+    /** Content after the run — the new content when applied, else the original. */
+    finalContent: string;
+    /** Edits that could not be applied (stale anchor, type-incompat, …). */
+    skipped: Array<{
+        reason: string;
+    }>;
+}
+export interface ApplyOptions {
+    /** When false, compute + gate but never touch disk. Default true. */
+    write?: boolean;
+    /** Honour SELA_DRY_RUN by leaving disk untouched. Default true. */
+    respectDryRun?: boolean;
+}
+export declare class MutationApplier {
+    /** Apply many batches; each file is processed independently. */
+    static applyBatches(batches: FileBatch[], opts?: ApplyOptions): ApplyOutcome[];
+    static applyFileBatch(batch: FileBatch, opts?: ApplyOptions): ApplyOutcome;
+}
+/**
+ * Cheap return-type pre-check. The replacement must be an expression whose
+ * OUTERMOST call is a Locator-returning Playwright method (locator / getBy* /
+ * frameLocator / nth / first / last / filter / and / or). Rejects actions
+ * (.click()), string queries (.title(), .textContent()), bare literals, etc.
+ */
+export declare function isLocatorReturningExpr(text: string): boolean;
+//# sourceMappingURL=MutationApplier.d.ts.map

package/dist/services/MutationApplier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MutationApplier.d.ts","sourceRoot":"","sources":["../../src/services/MutationApplier.ts"],"names":[],"mappings":"AA2BA,OAAO,EACL,SAAS,EAET,UAAU,EACX,MAAM,kBAAkB,CAAC;AAS1B;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,SAAS,GAAG,QAAQ,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,oEAAoE;IACpE,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,4EAA4E;IAC5E,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,YAAY,EAAE,CAAC;CACvB;AAED,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,aAAa,GAAG,OAAO,GAAG,SAAS,CAAC;AAE1E,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,+EAA+E;IAC/E,YAAY,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACxE,OAAO,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,YAAY;IAC3B,qEAAqE;IACrE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,mEAAmE;IACnE,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAeD,qBAAa,eAAe;IAC1B,gEAAgE;IAChE,MAAM,CAAC,YAAY,CACjB,OAAO,EAAE,SAAS,EAAE,EACpB,IAAI,GAAE,YAAiB,GACtB,YAAY,EAAE;IAIjB,MAAM,CAAC,cAAc,CACnB,KAAK,EAAE,SAAS,EAChB,IAAI,GAAE,YAAiB,GACtB,YAAY;CA6JhB;AA2CD;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAkB5D"}

package/dist/services/MutationApplier.js

@@ -0,0 +1,322 @@
+"use strict";
+// src/services/MutationApplier.ts
+//
+// Ticket #2 — Stage 4: Write-Discipline & the Drain Loop.
+//
+// Applies MutationPlans to disk under three hard contracts:
+//
+//   1. ZERO LAYOUT NOISE (§4.1) — surgical string splice over the EXACT node
+//      span [getStart(), getEnd()). getStart() excludes leading trivia, so
+//      comments / indentation / Prettier layout outside the span are byte-
+//      identical. We never call sourceFile.formatText() / ts.Printer.
+//
+//   2. TYPE-SAFETY GATE + ROLLBACK (§4.3) — after splicing in memory we
+//      re-parse and baseline-diff the diagnostics. A mutation that introduces
+//      a NEW real error (syntax break, non-Locator return) is rolled back and
+//      the file is left byte-for-byte untouched. A cheap Locator-shape pre-
+//      check rejects obviously wrong return types before the splice.
+//
+//   3. BATCH APPLICATION (§3.3) — mutations are grouped by file, anchors are
+//      RE-RESOLVED against the fresh parse (never trusting flag-time offsets),
+//      edits applied highest-offset-first, then the file is written atomically
+//      (temp + rename).
+//
+// Stage 1 (resolveAnchor) provides line-shift-immune relocation; Stage-1
+// applyEdits provides the reverse-offset splice + overlap guard.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MutationApplier = void 0;
+exports.isLocatorReturningExpr = isLocatorReturningExpr;
+const fs = __importStar(require("fs"));
+const ts_morph_1 = require("ts-morph");
+const AnchorResolver_1 = require("./AnchorResolver");
+const DecisionEngine_1 = require("./DecisionEngine");
+const TraceBackEngine_1 = require("./TraceBackEngine");
+const SelectorSanitizer_1 = require("./SelectorSanitizer");
+// Diagnostic codes that are pure "missing types" noise in an in-memory parse
+// without node_modules — identical allowlist to ASTSourceUpdater's validator.
+// Syntax/binder errors (codes 1000–1999) are NEVER allowlisted.
+const NOISE_CODES = new Set([
+    2304, 2339, 2345, 2554, 2571, 2580, 2503, 7006, 7016, 7031, 18004,
+]);
+const LOCATOR_RETURNING_CATEGORIES = new Set(["selector", "frame", "modifier"]);
+// ═══════════════════════════════════════════════════════════════════
+// MutationApplier
+// ═══════════════════════════════════════════════════════════════════
+class MutationApplier {
+    /** Apply many batches; each file is processed independently. */
+    static applyBatches(batches, opts = {}) {
+        return batches.map((b) => MutationApplier.applyFileBatch(b, opts));
+    }
+    static applyFileBatch(batch, opts = {}) {
+        const write = opts.write ?? true;
+        const respectDryRun = opts.respectDryRun ?? true;
+        const dryRun = respectDryRun && process.env.SELA_DRY_RUN === "1";
+        const { filePath } = batch;
+        const skipped = [];
+        let original;
+        try {
+            original = fs.readFileSync(filePath, "utf8");
+        }
+        catch (e) {
+            return {
+                filePath,
+                status: "skipped",
+                reason: `cannot read file: ${e.message}`,
+                written: false,
+                finalContent: "",
+                skipped,
+            };
+        }
+        // Fresh parse — the single source of truth for span resolution.
+        const project = newGateProject();
+        const sf = project.createSourceFile(filePath, original, { overwrite: true });
+        const baseline = realDiagnosticCounts(sf);
+        // ── Resolve each edit to a concrete span ─────────────────────────
+        const concrete = [];
+        for (const e of batch.edits) {
+            let replacement = e.replacement;
+            // ABSOLUTE GUARD: translate any internal engine selector to its public
+            // method form before writing; refuse if it cannot be translated. No
+            // `internal:role=…` string ever reaches the developer's source.
+            if (e.kind === "replace") {
+                const san = (0, SelectorSanitizer_1.sanitizeLocatorExpression)(replacement);
+                if (!san.safe) {
+                    skipped.push({
+                        reason: `internal-engine-selector: cannot translate "${truncate(replacement)}" to a public Playwright method`,
+                    });
+                    continue;
+                }
+                replacement = san.text;
+            }
+            const requireLocator = e.requireLocator ?? e.kind === "replace";
+            if (requireLocator && !isLocatorReturningExpr(replacement)) {
+                skipped.push({
+                    reason: `type-incompat: replacement is not a Locator expression ("${truncate(replacement)}")`,
+                });
+                continue;
+            }
+            if (e.kind === "replace" && e.anchor) {
+                const r = (0, AnchorResolver_1.resolveAnchor)(sf, e.anchor);
+                if (r.status !== "resolved") {
+                    skipped.push({
+                        reason: `anchor ${r.status}: ${"reason" in r ? r.reason : ""}`,
+                    });
+                    continue;
+                }
+                concrete.push({
+                    kind: "replace",
+                    span: { start: r.node.getStart(), end: r.node.getEnd() },
+                    replacement,
+                });
+            }
+            else if (e.span) {
+                concrete.push({
+                    kind: e.kind,
+                    span: e.span,
+                    replacement,
+                });
+            }
+            else {
+                skipped.push({ reason: "edit has neither anchor nor span" });
+            }
+        }
+        if (concrete.length === 0) {
+            return {
+                filePath,
+                status: "no-op",
+                reason: "no applicable edits after resolution",
+                written: false,
+                finalContent: original,
+                skipped,
+            };
+        }
+        // ── Splice (reverse-offset; overlap-guarded) ─────────────────────
+        let newContent;
+        try {
+            newContent = (0, DecisionEngine_1.applyEdits)(original, concrete);
+        }
+        catch (e) {
+            return {
+                filePath,
+                status: "rolled-back",
+                reason: `splice failed: ${e.message}`,
+                written: false,
+                finalContent: original,
+                skipped,
+            };
+        }
+        if (newContent === original) {
+            return {
+                filePath,
+                status: "no-op",
+                reason: "edits produced identical content",
+                written: false,
+                finalContent: original,
+                skipped,
+            };
+        }
+        // ── Type-safety gate: baseline-diff diagnostics ──────────────────
+        const afterSf = project.createSourceFile(filePath, newContent, {
+            overwrite: true,
+        });
+        const after = realDiagnosticCounts(afterSf);
+        const regression = diagnosticRegression(baseline, after);
+        if (regression) {
+            return {
+                filePath,
+                status: "rolled-back",
+                reason: `type-safety gate: mutation introduced a new error (${regression}) — file left untouched`,
+                written: false,
+                finalContent: original,
+                skipped,
+            };
+        }
+        // ── Atomic write ─────────────────────────────────────────────────
+        if (write && !dryRun) {
+            try {
+                atomicWrite(filePath, newContent);
+            }
+            catch (e) {
+                return {
+                    filePath,
+                    status: "rolled-back",
+                    reason: `atomic write failed: ${e.message}`,
+                    written: false,
+                    finalContent: original,
+                    skipped,
+                };
+            }
+        }
+        return {
+            filePath,
+            status: "applied",
+            reason: `${concrete.length} edit(s) applied${dryRun ? " (dry-run, not written)" : ""}`,
+            written: write && !dryRun,
+            finalContent: newContent,
+            skipped,
+        };
+    }
+}
+exports.MutationApplier = MutationApplier;
+// ═══════════════════════════════════════════════════════════════════
+// TYPE-SAFETY HELPERS
+// ═══════════════════════════════════════════════════════════════════
+function newGateProject() {
+    return new ts_morph_1.Project({
+        useInMemoryFileSystem: true,
+        compilerOptions: {
+            allowJs: true,
+            noEmit: true,
+            skipLibCheck: true,
+            noResolve: true,
+        },
+    });
+}
+/** Map of real (non-noise) diagnostic code → count. */
+function realDiagnosticCounts(sf) {
+    const counts = new Map();
+    for (const d of sf.getPreEmitDiagnostics()) {
+        if (d.getCategory() !== 1 /* Error */)
+            continue;
+        const code = d.getCode();
+        if (NOISE_CODES.has(code))
+            continue;
+        counts.set(code, (counts.get(code) ?? 0) + 1);
+    }
+    return counts;
+}
+/** Returns a description of the first NEW/elevated error, or null. */
+function diagnosticRegression(baseline, after) {
+    for (const [code, n] of after) {
+        if (n > (baseline.get(code) ?? 0)) {
+            return `TS${code}`;
+        }
+    }
+    return null;
+}
+/**
+ * Cheap return-type pre-check. The replacement must be an expression whose
+ * OUTERMOST call is a Locator-returning Playwright method (locator / getBy* /
+ * frameLocator / nth / first / last / filter / and / or). Rejects actions
+ * (.click()), string queries (.title(), .textContent()), bare literals, etc.
+ */
+function isLocatorReturningExpr(text) {
+    const project = newGateProject();
+    let sf;
+    try {
+        sf = project.createSourceFile("_probe.ts", `const __x = ${text};`, {
+            overwrite: true,
+        });
+    }
+    catch {
+        return false;
+    }
+    const decl = sf.getVariableDeclaration("__x");
+    const init = decl?.getInitializer();
+    if (!init)
+        return false;
+    // Outermost expression must be a call whose method is Locator-returning.
+    if (!ts_morph_1.Node.isCallExpression(init))
+        return false;
+    const callee = init.getExpression();
+    if (!ts_morph_1.Node.isPropertyAccessExpression(callee))
+        return false;
+    return LOCATOR_RETURNING_CATEGORIES.has((0, TraceBackEngine_1.categorizeMethod)(callee.getName()));
+}
+// ═══════════════════════════════════════════════════════════════════
+// ATOMIC WRITE
+// ═══════════════════════════════════════════════════════════════════
+function atomicWrite(filePath, content) {
+    const tmp = `${filePath}.sela-tmp-${process.pid}`;
+    fs.writeFileSync(tmp, content, "utf8");
+    try {
+        fs.renameSync(tmp, filePath); // atomic on POSIX; replace-on-Windows
+    }
+    catch {
+        // Windows can reject rename-over-existing in rare cases — fall back to a
+        // direct write, then best-effort remove the temp file.
+        fs.writeFileSync(filePath, content, "utf8");
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch {
+            /* best effort */
+        }
+    }
+}
+function truncate(s, n = 48) {
+    return s.length > n ? `${s.slice(0, n)}…` : s;
+}

package/dist/services/PendingPromptLedger.d.ts

@@ -8,6 +8,13 @@ export interface PendingPromptEntry {
     createdBySela: boolean;
     /** 1-based line number for the vscode:// deeplink, or null when unknown. */
     lineNumber: number | null;
+    /**
+     * Number of healed selectors that landed in THIS file. A single file can
+     * absorb several heals in one run (e.g. two locators in the same spec), so
+     * the DX banner counts fixes from this field rather than from the entry
+     * (= file) count. Older ledgers without the field are treated as 1.
+     */
+    healCount: number;
 }
 /**
  * Resolve the ledger directory for a given cwd. The directory is created

package/dist/services/PendingPromptLedger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PendingPromptLedger.d.ts","sourceRoot":"","sources":["../../src/services/PendingPromptLedger.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAEV,wBAAwB,EACzB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,OAAO,CAAC;IACvB,4EAA4E;IAC5E,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAID;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,wBAAwB,CAAC;IACpC,YAAY,EAAE,WAAW,EAAE,CAAC;CAC7B,GAAG,MAAM,GAAG,IAAI,CAehB;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAyB1E;AAED,yEAAyE;AACzE,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAI3D"}
+{"version":3,"file":"PendingPromptLedger.d.ts","sourceRoot":"","sources":["../../src/services/PendingPromptLedger.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAEV,wBAAwB,EACzB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,OAAO,CAAC;IACvB,4EAA4E;IAC5E,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAC;CACnB;AAID;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,wBAAwB,CAAC;IACpC,YAAY,EAAE,WAAW,EAAE,CAAC;CAC7B,GAAG,MAAM,GAAG,IAAI,CAehB;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAyB1E;AAED,yEAAyE;AACzE,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAI3D"}

package/dist/services/PendingPromptLedger.js

@@ -143,8 +143,33 @@ function snapshotToEntry(snap, heals, cwd) {
         contentAfter: snap.contentAfter ?? "",
         createdBySela: snap.createdBySela,
         lineNumber: findLineNumberForSnapshot(snap, heals, cwd),
+        healCount: countHealsForSnapshot(snap, heals, cwd),
     };
 }
+/**
+ * Count how many heals mutated `snap`. A heal's mutation target is its
+ * `definitionSite.file` when the write crossed into a const/variable
+ * declaration, otherwise its `sourceFile`. Resolved to absolute form so a
+ * relative event path matches the snapshot's absolute path.
+ *
+ * Falls back to 1 when no heal resolves to the file - the snapshot only
+ * exists because Sela wrote to it, so the file represents at least one fix.
+ */
+function countHealsForSnapshot(snap, heals, cwd) {
+    const normSnap = path.normalize(snap.absolutePath);
+    let n = 0;
+    for (const heal of heals) {
+        const target = heal.definitionSite?.file ?? heal.sourceFile;
+        if (!target)
+            continue;
+        const abs = path.isAbsolute(target)
+            ? path.normalize(target)
+            : path.normalize(path.resolve(cwd, target));
+        if (abs === normSnap)
+            n++;
+    }
+    return n > 0 ? n : 1;
+}
 /**
  * Resolve a 1-based line number for the vscode:// deeplink. Priority:
  *   1. `definitionSite.line` for a heal whose `definitionSite.file`