sela-core 1.0.7 → 1.0.9

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/PRAutomationService.d.ts

@@ -37,14 +37,14 @@ export interface ExecutionResult {
  * Clean-Room execution lifecycle.
  *
  * The legacy flow committed the developer's whole dirty working tree onto
- * the PR branch — polluting reviewers with `test.only`, commented debug
+ * the PR branch - polluting reviewers with `test.only`, commented debug
  * blocks, etc. This refactor isolates Sela's specific AST changes onto an
  * ephemeral branch, leaves the developer's local workspace byte-identical
  * to its pre-Sela state, and is wrapped in a try/finally that restores
  * the workspace even on mid-flight crashes.
  */
 export declare function execute(cfg: ResolvedPRAutomation, decision: StrategyDecision, heals: HealedEvent[], branchInfo: BranchInfo, ctx: ExecuteContext, 
-/** Injectable for tests — defaults to the module singleton. */
+/** Injectable for tests - defaults to the module singleton. */
 workspace?: WorkspaceSnapshotService): Promise<ExecutionResult>;
 export declare function handleBugDetected(action: BugAction, events: ProtectedEvent[], branchInfo: BranchInfo, ctx: ExecuteContext): Promise<void>;
 //# sourceMappingURL=PRAutomationService.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"PRAutomationService.d.ts","sourceRoot":"","sources":["../../src/services/PRAutomationService.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EACV,oBAAoB,EACpB,UAAU,EACV,SAAS,EACV,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EACV,WAAW,EACX,cAAc,EACf,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGL,KAAK,wBAAwB,EAC9B,MAAM,4BAA4B,CAAC;AAUpC,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,UAAU,CAAC;IACtB,UAAU,EAAE,UAAU,CAAC;IACvB,eAAe,EAAE,kBAAkB,GAAG,gBAAgB,GAAG,aAAa,GAAG,IAAI,CAAC;IAC9E;;;;OAIG;IACH,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,6EAA6E;IAC7E,oBAAoB,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1C;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AA2ED,wBAAgB,YAAY,CAAC,GAAG,GAAE,MAAsB,GAAG,UAAU,CA8EpE;AAMD,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,oBAAoB,EACzB,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,KAAK,EAAE,WAAW,EAAE,GACnB,gBAAgB,CAgElB;AAMD,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAEzC;AAuFD,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,UAAU,CAAC;IACtB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;;;;GASG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,oBAAoB,EACzB,QAAQ,EAAE,gBAAgB,EAC1B,KAAK,EAAE,WAAW,EAAE,EACpB,UAAU,EAAE,UAAU,EACtB,GAAG,EAAE,cAAc;AACnB,+DAA+D;AAC/D,SAAS,GAAE,wBAAkD,GAC5D,OAAO,CAAC,eAAe,CAAC,CAkG1B;AA4SD,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,cAAc,EAAE,EACxB,UAAU,EAAE,UAAU,EACtB,GAAG,EAAE,cAAc,GAClB,OAAO,CAAC,IAAI,CAAC,CA0Ff"}
+{"version":3,"file":"PRAutomationService.d.ts","sourceRoot":"","sources":["../../src/services/PRAutomationService.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EACV,oBAAoB,EACpB,UAAU,EACV,SAAS,EACV,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,EAGL,KAAK,wBAAwB,EAC9B,MAAM,4BAA4B,CAAC;AAOpC,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,MAAM,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,UAAU,CAAC;IACtB,UAAU,EAAE,UAAU,CAAC;IACvB,eAAe,EAAE,kBAAkB,GAAG,gBAAgB,GAAG,aAAa,GAAG,IAAI,CAAC;IAC9E;;;;OAIG;IACH,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,6EAA6E;IAC7E,oBAAoB,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1C;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAiFD,wBAAgB,YAAY,CAAC,GAAG,GAAE,MAAsB,GAAG,UAAU,CA+EpE;AAMD,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,oBAAoB,EACzB,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,KAAK,EAAE,WAAW,EAAE,GACnB,gBAAgB,CAgElB;AAMD,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAEzC;AA6FD,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,UAAU,CAAC;IACtB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;;;;;GASG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,oBAAoB,EACzB,QAAQ,EAAE,gBAAgB,EAC1B,KAAK,EAAE,WAAW,EAAE,EACpB,UAAU,EAAE,UAAU,EACtB,GAAG,EAAE,cAAc;AACnB,+DAA+D;AAC/D,SAAS,GAAE,wBAAkD,GAC5D,OAAO,CAAC,eAAe,CAAC,CAkG1B;AAwTD,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,cAAc,EAAE,EACxB,UAAU,EAAE,UAAU,EACtB,GAAG,EAAE,cAAc,GAClB,OAAO,CAAC,IAAI,CAAC,CA4Gf"}

package/dist/services/PRAutomationService.js

@@ -93,7 +93,7 @@ function isSelaHealBranch(branch) {
  * Resolve the repo's default integration branch.
  *   1. origin/HEAD symbolic-ref (set by `git clone`).
  *   2. First existing local ref among: main, master, develop, dev.
- * Returns null if none found — caller must handle that.
+ * Returns null if none found - caller must handle that.
  */
 function findDefaultBranch(cwd) {
     const headRef = sh("git symbolic-ref refs/remotes/origin/HEAD", cwd);
@@ -124,7 +124,7 @@ function detectBranch(cwd = process.cwd()) {
     const ghRefName = process.env.GITHUB_REF_NAME; // current branch on push, or "<n>/merge" on PR
     const ghEventName = process.env.GITHUB_EVENT_NAME;
     const ghRef = process.env.GITHUB_REF; // "refs/pull/123/merge"
-    // Prefer HEAD_REF on PRs — REF_NAME is the synthetic merge ref.
+    // Prefer HEAD_REF on PRs - REF_NAME is the synthetic merge ref.
     if (ghHeadRef && ghHeadRef.length > 0 && !isSelaHealBranch(ghHeadRef)) {
         const prNumber = (() => {
             const m = ghRef?.match(/refs\/pull\/(\d+)\//);
@@ -175,11 +175,11 @@ function detectBranch(cwd = process.cwd()) {
     if (isSelaHealBranch(localBranch)) {
         const fallback = findDefaultBranch(cwd);
         if (fallback) {
-            console.warn(`[Sela PR] ⚠️  HEAD is on '${localBranch}' (sela patch branch) — ` +
+            console.warn(`[Sela PR] ⚠️  HEAD is on '${localBranch}' (sela patch branch) - ` +
                 `using '${fallback}' as PR base instead.`);
             return { branch: fallback, isPR: false, prNumber: null, source: "git" };
         }
-        console.warn(`[Sela PR] ⚠️  HEAD is on '${localBranch}' and no default branch found — ` +
+        console.warn(`[Sela PR] ⚠️  HEAD is on '${localBranch}' and no default branch found - ` +
             `skipping PR automation to avoid self-targeting.`);
         return { branch: null, isPR: false, prNumber: null, source: "none" };
     }
@@ -190,7 +190,7 @@ function detectBranch(cwd = process.cwd()) {
 // ═══════════════════════════════════════════════════════════════════
 function decideEffectiveStrategy(cfg, branch, heals) {
     // Compute MIN across only the heals that reported a finite numeric
-    // confidence. When *no* heal carried one, the result is `undefined` —
+    // confidence. When *no* heal carried one, the result is `undefined` -
     // surfaced as "n/a" in reports rather than synthesised as 100% (which
     // would silently mask the absence of evidence) or 0% (which would
     // incorrectly force a downgrade for every clean run on Sonnet).
@@ -219,7 +219,7 @@ function decideEffectiveStrategy(cfg, branch, heals) {
             downgradeReason: "PROTECTED_BRANCH",
         };
     }
-    // Rule 2: low AI confidence — only triggers when the measured min is
+    // Rule 2: low AI confidence - only triggers when the measured min is
     // actually below the threshold. Missing confidence is "unknown", not
     // "zero", so we do NOT downgrade purely on absence.
     if (cfg.reviewThresholds.minConfidenceForDirectCommit > 0 &&
@@ -231,7 +231,7 @@ function decideEffectiveStrategy(cfg, branch, heals) {
             downgradeReason: "LOW_CONFIDENCE",
         };
     }
-    // Rule 3: low auditor score — same "absence ≠ zero" rule as Rule 2.
+    // Rule 3: low auditor score - same "absence ≠ zero" rule as Rule 2.
     if (cfg.reviewThresholds.minAuditorScoreForDirectCommit > 0 &&
         typeof minAud === "number" &&
         minAud < cfg.reviewThresholds.minAuditorScoreForDirectCommit) {
@@ -285,7 +285,7 @@ function stripDiffPreamble(raw) {
 }
 function buildDefaultBody(heals, branchInfo, reportLink, decision) {
     const lines = [];
-    lines.push(`# 🤖 Sela Insights — Automation Suite Healed!`);
+    lines.push(`# 🤖 Sela Insights - Automation Suite Healed!`);
     lines.push("");
     lines.push(`Sela kept your pipeline running by healing ${heals.length} broken locator(s).`);
     lines.push("");
@@ -301,12 +301,12 @@ function buildDefaultBody(heals, branchInfo, reportLink, decision) {
     lines.push(`## 💻 Per-Heal Diff`);
     for (const h of heals) {
         const lineRef = h.newLineNumber ?? h.sourceLine;
-        lines.push(`### \`${h.sourceFile}:${lineRef}\` — ${h.testTitle ?? "(no test title)"}`);
+        lines.push(`### \`${h.sourceFile}:${lineRef}\` - ${h.testTitle ?? "(no test title)"}`);
         lines.push("");
         lines.push("```diff");
         if (h.gitUnifiedDiff && h.gitUnifiedDiff.trim().length > 0) {
             // Emit the real git diff verbatim. This natively handles cross-file
-            // healing, multi-line edits, and template-literal changes — none of
+            // healing, multi-line edits, and template-literal changes - none of
             // which the legacy single-line -/+ pair could represent.
             lines.push(stripDiffPreamble(h.gitUnifiedDiff));
         }
@@ -333,14 +333,14 @@ function buildDefaultBody(heals, branchInfo, reportLink, decision) {
  * Clean-Room execution lifecycle.
  *
  * The legacy flow committed the developer's whole dirty working tree onto
- * the PR branch — polluting reviewers with `test.only`, commented debug
+ * the PR branch - polluting reviewers with `test.only`, commented debug
  * blocks, etc. This refactor isolates Sela's specific AST changes onto an
  * ephemeral branch, leaves the developer's local workspace byte-identical
  * to its pre-Sela state, and is wrapped in a try/finally that restores
  * the workspace even on mid-flight crashes.
  */
 async function execute(cfg, decision, heals, branchInfo, ctx, 
-/** Injectable for tests — defaults to the module singleton. */
+/** Injectable for tests - defaults to the module singleton. */
 workspace = WorkspaceSnapshotService_1.sharedWorkspaceSnapshot) {
     const result = {
         effective: decision.effective,
@@ -349,33 +349,33 @@ workspace = WorkspaceSnapshotService_1.sharedWorkspaceSnapshot) {
         errors: [],
     };
     if (decision.effective === "readOnly") {
-        console.log(`[Sela PR] 🛡️  readOnly — no git operations performed.`);
+        console.log(`[Sela PR] 🛡️  readOnly - no git operations performed.`);
         if (ctx.reportHtmlPath) {
             console.log(`[Sela PR]    Report artifact: ${ctx.reportHtmlPath}`);
         }
         return result;
     }
     if (heals.length === 0) {
-        console.log(`[Sela PR] No HEALED events — skipping git operations.`);
+        console.log(`[Sela PR] No HEALED events - skipping git operations.`);
         return result;
     }
     if (!gitAvailable(ctx.cwd)) {
         result.errors.push("git CLI not available");
-        console.warn(`[Sela PR] ⚠️  git CLI not available — skipping.`);
+        console.warn(`[Sela PR] ⚠️  git CLI not available - skipping.`);
         return result;
     }
     if (isDetachedHead(ctx.cwd)) {
         result.errors.push("detached HEAD");
-        console.warn(`[Sela PR] ⚠️  Detached HEAD — skipping git operations.`);
+        console.warn(`[Sela PR] ⚠️  Detached HEAD - skipping git operations.`);
         return result;
     }
     const mutatedSnaps = workspace.getMutatedSnapshots();
     if (mutatedSnaps.length === 0) {
         result.errors.push("no mutated files tracked");
-        console.warn(`[Sela PR] ⚠️  WorkspaceSnapshotService reports no mutated files — skipping.`);
+        console.warn(`[Sela PR] ⚠️  WorkspaceSnapshotService reports no mutated files - skipping.`);
         return result;
     }
-    // Render title / body up front — needed by all branches below.
+    // Render title / body up front - needed by all branches below.
     const first = heals[0];
     const titleVars = {
         testName: first.testTitle ?? "automation",
@@ -410,7 +410,7 @@ workspace = WorkspaceSnapshotService_1.sharedWorkspaceSnapshot) {
     if (decision.effective === "pr" || decision.effective === "draftPR") {
         if (!ghAvailable(ctx.cwd)) {
             result.errors.push("gh CLI not available");
-            console.warn(`[Sela PR] ⚠️  gh CLI not installed — cannot open PR. Run \`gh auth login\` after install.`);
+            console.warn(`[Sela PR] ⚠️  gh CLI not installed - cannot open PR. Run \`gh auth login\` after install.`);
             return result;
         }
         return runCleanRoom({
@@ -428,25 +428,25 @@ workspace = WorkspaceSnapshotService_1.sharedWorkspaceSnapshot) {
     return result;
 }
 async function runCleanRoom(args) {
-    const { mode, cfg, ctx, mutatedSnaps, title, body, branchInfo, decision, result } = args;
+    const { mode, cfg, ctx, mutatedSnaps, title, body, branchInfo, decision, result, } = args;
     const id = String(Date.now());
     const stashLabel = `sela:clean-room-${id}`;
     const originalBranch = currentBranch(ctx.cwd);
     const targetBranch = mode === "directCommit"
         ? originalBranch
         : render(cfg.branchNameTemplate, { id, timestamp: id });
-    // Lifecycle state — used by the finally{} restoration block.
+    // Lifecycle state - used by the finally{} restoration block.
     let didRestoreOriginal = false;
     let didStash = false;
     let didSwitchToTarget = false;
     let didCommit = false;
     try {
-        // 1. State Checkpoint — rewind developer's mutated files to pre-Sela
+        // 1. State Checkpoint - rewind developer's mutated files to pre-Sela
         //    state on disk. Other dirty files (unrelated to Sela) stay where
         //    they are; the subsequent stash will sweep them up.
         workspaceRestoreOriginal(mutatedSnaps);
         didRestoreOriginal = true;
-        // 2. Branch Isolation — stash everything (tracked + untracked) so the
+        // 2. Branch Isolation - stash everything (tracked + untracked) so the
         //    worktree mirrors HEAD when we switch / branch off.
         const stash = sh(`git stash push -u -m ${shellQuote(stashLabel)}`, ctx.cwd);
         if (stash.ok) {
@@ -463,7 +463,7 @@ async function runCleanRoom(args) {
             }
             didSwitchToTarget = true;
         }
-        // 3. Targeted Hunk Patching — apply ONLY Sela's blocks to each file's
+        // 3. Targeted Hunk Patching - apply ONLY Sela's blocks to each file's
         //    clean HEAD content. Refuses to write if dirty edits collide with
         //    Sela's mutation site (block not found / not unique).
         for (const snap of mutatedSnaps) {
@@ -517,7 +517,7 @@ async function runCleanRoom(args) {
         console.warn(`[Sela PR] ⚠️  Clean-room flow failed: ${err?.message ?? err}`);
     }
     finally {
-        // 6. Workspace Restoration — ALWAYS attempt, even on mid-flight crash.
+        // 6. Workspace Restoration - ALWAYS attempt, even on mid-flight crash.
         //    Order matters:
         //      a) Switch back to the developer's original branch (if we left it).
         //      b) Pop the stash to restore the dirty pre-Sela working tree.
@@ -537,7 +537,7 @@ async function runCleanRoom(args) {
                 }
             }
             if (didRestoreOriginal) {
-                // Belt-and-braces — every tracked snapshot back to its dirty
+                // Belt-and-braces - every tracked snapshot back to its dirty
                 // pre-Sela state. No-op if stash pop already did the job.
                 workspaceRestoreOriginal(mutatedSnaps);
             }
@@ -565,7 +565,9 @@ function openPullRequest(args) {
         ? cfg.labels.map((l) => `--label ${shellQuote(l)}`).join(" ")
         : "";
     const draftFlag = mode === "draftPR" ? "--draft" : "";
-    const baseFlag = branchInfo.branch ? `--base ${shellQuote(branchInfo.branch)}` : "";
+    const baseFlag = branchInfo.branch
+        ? `--base ${shellQuote(branchInfo.branch)}`
+        : "";
     const prCmd = `gh pr create ${draftFlag} ${baseFlag} ` +
         `--title ${shellQuote(title)} ` +
         `--body-file ${shellQuote(bodyFile)} ` +
@@ -614,16 +616,16 @@ function workspaceRestoreOriginal(snaps) {
 function applyMutationToClean(snap) {
     const after = snap.contentAfter ?? "";
     // File didn't exist on HEAD (created by Sela or untracked). Write the
-    // post-mutation content directly — there's no clean base to merge into.
+    // post-mutation content directly - there's no clean base to merge into.
     if (snap.headContent === null) {
         return { ok: true, result: after };
     }
-    // No dirty edits — `headContent === contentBefore`, so the mutation
+    // No dirty edits - `headContent === contentBefore`, so the mutation
     // applies cleanly as a 1:1 string equivalence.
     if (snap.headContent === snap.contentBefore) {
         return { ok: true, result: after };
     }
-    // Dirty edits present — extract Sela's specific change blocks and
+    // Dirty edits present - extract Sela's specific change blocks and
     // re-apply them against the clean HEAD content via unique substring
     // replacement. Fails loudly when the dirty edits overlap Sela's site.
     const blocks = (0, IsolatedDiff_1.extractChangeBlocks)(snap.contentBefore, after);
@@ -636,7 +638,7 @@ function applyMutationToClean(snap) {
  * CI adapters (GitHub Actions, GitLab, Jenkins) often run with no global
  * git identity. `git commit` then fails with `Please tell me who you are`,
  * tanking the whole heal pipeline. Plant a sela bot identity for THIS
- * commit only when no `user.email` / `user.name` is configured — never
+ * commit only when no `user.email` / `user.name` is configured - never
  * overwrite an existing identity.
  */
 function configureGitIdentityForCI(cwd) {
@@ -662,18 +664,18 @@ function configureGitIdentityForCI(cwd) {
 async function handleBugDetected(action, events, branchInfo, ctx) {
     if (events.length === 0)
         return;
-    console.warn(`\n[Sela Protection] ⚠️  ${events.length} potential regression(s) detected — auto-fix blocked.`);
+    console.warn(`\n[Sela Protection] ⚠️  ${events.length} potential regression(s) detected - auto-fix blocked.`);
     for (const e of events) {
-        console.warn(`  • ${e.sourceFile}:${e.sourceLine} — ${e.reason} (auditor: ${e.auditor?.verdict ?? "n/a"})`);
+        console.warn(`  • ${e.sourceFile}:${e.sourceLine} - ${e.reason} (auditor: ${e.auditor?.verdict ?? "n/a"})`);
     }
     if (action === "failCI") {
-        console.warn(`[Sela Protection] 🔴 onBugDetected='failCI' — setting process.exitCode = 1`);
+        console.warn(`[Sela Protection] 🔴 onBugDetected='failCI' - setting process.exitCode = 1`);
         process.exitCode = 1;
         return;
     }
     if (action === "createIssue") {
         if (!ghAvailable(ctx.cwd)) {
-            console.warn(`[Sela Protection] ⚠️  gh CLI unavailable — cannot create issue.`);
+            console.warn(`[Sela Protection] ⚠️  gh CLI unavailable - cannot create issue.`);
             return;
         }
         for (const e of events) {
@@ -706,7 +708,9 @@ async function handleBugDetected(action, events, branchInfo, ctx) {
             try {
                 fs.unlinkSync(bodyFile);
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
             if (!r.ok) {
                 console.warn(`[Sela Protection] ⚠️  gh issue create failed: ${r.stderr}`);
             }
@@ -718,11 +722,11 @@ async function handleBugDetected(action, events, branchInfo, ctx) {
     }
     if (action === "labelOnly") {
         if (!ghAvailable(ctx.cwd)) {
-            console.warn(`[Sela Protection] ⚠️  gh CLI unavailable — cannot label PR.`);
+            console.warn(`[Sela Protection] ⚠️  gh CLI unavailable - cannot label PR.`);
             return;
         }
         if (!branchInfo.isPR || !branchInfo.prNumber) {
-            console.warn(`[Sela Protection] ⚠️  Not running on a PR — labelOnly skipped.`);
+            console.warn(`[Sela Protection] ⚠️  Not running on a PR - labelOnly skipped.`);
             return;
         }
         const labelCmd = `gh pr edit ${branchInfo.prNumber} --add-label sela-bug-detected`;
@@ -742,7 +746,7 @@ async function handleBugDetected(action, events, branchInfo, ctx) {
     }
 }
 // ═══════════════════════════════════════════════════════════════════
-// SHELL QUOTING — cross-platform (POSIX single-quote escape;
+// SHELL QUOTING - cross-platform (POSIX single-quote escape;
 // on Windows execSync uses cmd.exe which handles double-quotes natively).
 // ═══════════════════════════════════════════════════════════════════
 function shellQuote(s) {