sela-core 1.0.6 → 1.0.8

package/dist/services/PRAutomationService.js

@@ -54,6 +54,8 @@ exports.handleBugDetected = handleBugDetected;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const child_process_1 = require("child_process");
+const WorkspaceSnapshotService_1 = require("./WorkspaceSnapshotService");
+const IsolatedDiff_1 = require("../utils/IsolatedDiff");
 // ═══════════════════════════════════════════════════════════════════
 // SHELL HELPERS
 // ═══════════════════════════════════════════════════════════════════
@@ -91,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);
@@ -122,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+)\//);
@@ -173,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" };
     }
@@ -188,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).
@@ -217,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 &&
@@ -229,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) {
@@ -283,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("");
@@ -299,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));
         }
@@ -327,7 +329,19 @@ function buildDefaultBody(heals, branchInfo, reportLink, decision) {
     lines.push(`Generated automatically by \`sela-core\`.`);
     return lines.join("\n");
 }
-async function execute(cfg, decision, heals, branchInfo, ctx) {
+/**
+ * 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
+ * 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. */
+workspace = WorkspaceSnapshotService_1.sharedWorkspaceSnapshot) {
     const result = {
         effective: decision.effective,
         prUrl: null,
@@ -335,34 +349,33 @@ async function execute(cfg, decision, heals, branchInfo, ctx) {
         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;
     }
-    // ── Stage all healed files (relative paths from event records) ────
-    const filesToStage = Array.from(new Set(heals.map((h) => h.sourceFile).filter((f) => f && f.length > 0)));
-    if (filesToStage.length === 0) {
-        result.errors.push("no files to stage");
-        console.warn(`[Sela PR] ⚠️  No file paths in HEALED events — skipping.`);
+    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.`);
         return result;
     }
-    // Render title — use first heal as representative
+    // Render title / body up front - needed by all branches below.
     const first = heals[0];
     const titleVars = {
         testName: first.testTitle ?? "automation",
@@ -381,108 +394,288 @@ async function execute(cfg, decision, heals, branchInfo, ctx) {
             reasoning: heals.map((h) => h.aiExplanation).join("\n\n"),
         })
         : buildDefaultBody(heals, branchInfo, reportLink, decision);
-    // ── directCommit ────────────────────────────────────────────────
     if (decision.effective === "directCommit") {
-        for (const f of filesToStage) {
-            const add = sh(`git add "${f}"`, ctx.cwd);
-            if (!add.ok)
-                result.errors.push(`git add ${f}: ${add.stderr}`);
-        }
-        const commit = sh(`git commit -m ${shellQuote(title)}`, ctx.cwd);
-        if (!commit.ok) {
-            result.errors.push(`git commit: ${commit.stderr}`);
-            console.warn(`[Sela PR] ⚠️  git commit failed: ${commit.stderr}`);
-            return result;
-        }
-        console.log(`[Sela PR] ✅ Direct commit on '${branchInfo.branch}': ${title}`);
-        const push = sh(`git push`, ctx.cwd);
-        if (!push.ok) {
-            result.errors.push(`git push: ${push.stderr}`);
-            console.warn(`[Sela PR] ⚠️  git push failed: ${push.stderr}`);
-            return result;
-        }
-        console.log(`[Sela PR] 🚀 Pushed to '${branchInfo.branch}'`);
-        return result;
+        return runCleanRoom({
+            mode: "directCommit",
+            cfg,
+            ctx,
+            mutatedSnaps,
+            title,
+            body,
+            branchInfo,
+            decision,
+            result,
+        });
     }
-    // ── pr / draftPR ────────────────────────────────────────────────
     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;
         }
-        const id = String(Date.now());
-        const branchName = render(cfg.branchNameTemplate, { id, timestamp: id });
-        const checkout = sh(`git checkout -b ${branchName}`, ctx.cwd);
-        if (!checkout.ok) {
-            result.errors.push(`git checkout: ${checkout.stderr}`);
-            console.warn(`[Sela PR] ⚠️  Could not create branch '${branchName}': ${checkout.stderr}`);
-            return result;
+        return runCleanRoom({
+            mode: decision.effective,
+            cfg,
+            ctx,
+            mutatedSnaps,
+            title,
+            body,
+            branchInfo,
+            decision,
+            result,
+        });
+    }
+    return result;
+}
+async function runCleanRoom(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.
+    let didRestoreOriginal = false;
+    let didStash = false;
+    let didSwitchToTarget = false;
+    let didCommit = false;
+    try {
+        // 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
+        //    worktree mirrors HEAD when we switch / branch off.
+        const stash = sh(`git stash push -u -m ${shellQuote(stashLabel)}`, ctx.cwd);
+        if (stash.ok) {
+            didStash = !/No local changes to save/i.test(stash.stdout);
+        }
+        else {
+            // Stash failures are non-fatal when the worktree was already clean.
+            console.debug?.(`[Sela PR] stash skipped: ${stash.stderr}`);
+        }
+        if (mode !== "directCommit") {
+            const checkout = sh(`git checkout -b ${targetBranch}`, ctx.cwd);
+            if (!checkout.ok) {
+                throw new Error(`git checkout -b ${targetBranch}: ${checkout.stderr}`);
+            }
+            didSwitchToTarget = true;
         }
-        for (const f of filesToStage) {
-            const add = sh(`git add "${f}"`, ctx.cwd);
+        // 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) {
+            const applied = applyMutationToClean(snap);
+            if (!applied.ok) {
+                throw new Error(`cannot apply Sela mutation to clean base of ${snap.relativePath}: ${applied.reason}`);
+            }
+            fs.writeFileSync(snap.absolutePath, applied.result, "utf8");
+        }
+        // 4. Stage, commit, push.
+        for (const snap of mutatedSnaps) {
+            const add = sh(`git add ${shellQuote(snap.relativePath)}`, ctx.cwd);
             if (!add.ok)
-                result.errors.push(`git add ${f}: ${add.stderr}`);
+                result.errors.push(`git add ${snap.relativePath}: ${add.stderr}`);
         }
+        configureGitIdentityForCI(ctx.cwd);
         const commit = sh(`git commit -m ${shellQuote(title)}`, ctx.cwd);
         if (!commit.ok) {
-            result.errors.push(`git commit: ${commit.stderr}`);
-            console.warn(`[Sela PR] ⚠️  git commit failed: ${commit.stderr}`);
-            return result;
+            throw new Error(`git commit: ${commit.stderr}`);
         }
-        const push = sh(`git push -u origin ${branchName}`, ctx.cwd);
+        didCommit = true;
+        console.log(`[Sela PR] ✅ Clean commit on '${targetBranch ?? "(unknown)"}': ${title}`);
+        const pushCmd = mode === "directCommit"
+            ? `git push`
+            : `git push -u origin ${shellQuote(targetBranch)}`;
+        const push = sh(pushCmd, ctx.cwd);
         if (!push.ok) {
-            result.errors.push(`git push: ${push.stderr}`);
-            console.warn(`[Sela PR] ⚠️  git push failed: ${push.stderr}`);
-            return result;
+            throw new Error(`git push: ${push.stderr}`);
         }
-        result.branchPushed = branchName;
-        // Write body to a temp file to avoid shell-escaping headaches
-        const bodyFile = path.join(ctx.cwd, `.sela-pr-body-${id}.md`);
-        fs.writeFileSync(bodyFile, body, "utf8");
-        const labelFlag = cfg.labels.length > 0
-            ? cfg.labels.map((l) => `--label ${shellQuote(l)}`).join(" ")
-            : "";
-        const draftFlag = decision.effective === "draftPR" ? "--draft" : "";
-        const baseFlag = branchInfo.branch ? `--base ${shellQuote(branchInfo.branch)}` : "";
-        const prCmd = `gh pr create ${draftFlag} ${baseFlag} ` +
-            `--title ${shellQuote(title)} ` +
-            `--body-file ${shellQuote(bodyFile)} ` +
-            `${labelFlag}`;
-        const pr = sh(prCmd, ctx.cwd);
+        if (mode !== "directCommit") {
+            result.branchPushed = targetBranch;
+        }
+        // 5. (PR modes only) open the PR.
+        if (mode === "pr" || mode === "draftPR") {
+            const prUrl = openPullRequest({
+                cfg,
+                ctx,
+                mode,
+                title,
+                body,
+                branchInfo,
+                id,
+                result,
+            });
+            if (prUrl)
+                result.prUrl = prUrl;
+        }
+    }
+    catch (err) {
+        result.errors.push(err?.message ?? String(err));
+        console.warn(`[Sela PR] ⚠️  Clean-room flow failed: ${err?.message ?? err}`);
+    }
+    finally {
+        // 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.
+        //      c) Defensively re-write contentBefore for tracked files in case
+        //         the stash was lost.
         try {
-            fs.unlinkSync(bodyFile);
+            if (didSwitchToTarget && originalBranch) {
+                const back = sh(`git checkout ${shellQuote(originalBranch)}`, ctx.cwd);
+                if (!back.ok) {
+                    console.warn(`[Sela PR] ⚠️  Could not switch back to '${originalBranch}': ${back.stderr}`);
+                }
+            }
+            if (didStash) {
+                const pop = sh(`git stash pop`, ctx.cwd);
+                if (!pop.ok) {
+                    console.warn(`[Sela PR] ⚠️  git stash pop failed: ${pop.stderr}`);
+                }
+            }
+            if (didRestoreOriginal) {
+                // Belt-and-braces - every tracked snapshot back to its dirty
+                // pre-Sela state. No-op if stash pop already did the job.
+                workspaceRestoreOriginal(mutatedSnaps);
+            }
         }
-        catch { /* ignore */ }
-        if (!pr.ok) {
-            result.errors.push(`gh pr create: ${pr.stderr}`);
-            console.warn(`[Sela PR] ⚠️  gh pr create failed: ${pr.stderr}`);
-            return result;
+        catch (restoreErr) {
+            console.warn(`[Sela PR] ⚠️  Workspace restoration error: ${restoreErr?.message ?? restoreErr}`);
         }
-        result.prUrl = pr.stdout.trim();
-        console.log(`[Sela PR] ✅ ${decision.effective === "draftPR" ? "Draft PR" : "PR"} opened: ${result.prUrl}`);
-        return result;
+    }
+    if (!didCommit && result.errors.length === 0) {
+        result.errors.push("clean-room flow did not produce a commit");
     }
     return result;
 }
+function openPullRequest(args) {
+    const { cfg, ctx, mode, title, body, branchInfo, id, result } = args;
+    const bodyFile = path.join(ctx.cwd, `.sela-pr-body-${id}.md`);
+    try {
+        fs.writeFileSync(bodyFile, body, "utf8");
+    }
+    catch (err) {
+        result.errors.push(`pr body write: ${err?.message ?? err}`);
+        return null;
+    }
+    const labelFlag = cfg.labels.length > 0
+        ? cfg.labels.map((l) => `--label ${shellQuote(l)}`).join(" ")
+        : "";
+    const draftFlag = mode === "draftPR" ? "--draft" : "";
+    const baseFlag = branchInfo.branch
+        ? `--base ${shellQuote(branchInfo.branch)}`
+        : "";
+    const prCmd = `gh pr create ${draftFlag} ${baseFlag} ` +
+        `--title ${shellQuote(title)} ` +
+        `--body-file ${shellQuote(bodyFile)} ` +
+        `${labelFlag}`;
+    const pr = sh(prCmd, ctx.cwd);
+    try {
+        fs.unlinkSync(bodyFile);
+    }
+    catch {
+        /* ignore */
+    }
+    if (!pr.ok) {
+        result.errors.push(`gh pr create: ${pr.stderr}`);
+        console.warn(`[Sela PR] ⚠️  gh pr create failed: ${pr.stderr}`);
+        return null;
+    }
+    const url = pr.stdout.trim();
+    console.log(`[Sela PR] ✅ ${mode === "draftPR" ? "Draft PR" : "PR"} opened: ${url}`);
+    return url;
+}
+// ═══════════════════════════════════════════════════════════════════
+// CLEAN-ROOM HELPERS
+// ═══════════════════════════════════════════════════════════════════
+function currentBranch(cwd) {
+    const r = sh("git rev-parse --abbrev-ref HEAD", cwd);
+    if (!r.ok)
+        return null;
+    const b = r.stdout.trim();
+    return b && b !== "HEAD" ? b : null;
+}
+function workspaceRestoreOriginal(snaps) {
+    for (const snap of snaps) {
+        try {
+            if (snap.createdBySela) {
+                if (fs.existsSync(snap.absolutePath))
+                    fs.unlinkSync(snap.absolutePath);
+                continue;
+            }
+            fs.writeFileSync(snap.absolutePath, snap.contentBefore, "utf8");
+        }
+        catch (err) {
+            console.warn(`[Sela PR] ⚠️  Could not restore ${snap.relativePath}: ${err?.message ?? err}`);
+        }
+    }
+}
+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.
+    if (snap.headContent === null) {
+        return { ok: true, result: after };
+    }
+    // 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
+    // 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);
+    if (blocks.length === 0) {
+        return { ok: true, result: snap.headContent };
+    }
+    return (0, IsolatedDiff_1.applyChangeBlocks)(snap.headContent, blocks);
+}
+/**
+ * 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
+ * overwrite an existing identity.
+ */
+function configureGitIdentityForCI(cwd) {
+    const isCI = process.env.CI === "true" ||
+        process.env.CI === "1" ||
+        !!process.env.GITHUB_ACTIONS ||
+        !!process.env.GITLAB_CI ||
+        !!process.env.JENKINS_URL;
+    if (!isCI)
+        return;
+    const email = sh("git config user.email", cwd);
+    if (!email.ok || email.stdout.trim().length === 0) {
+        sh(`git config user.email "sela-bot@anthropic.local"`, cwd);
+    }
+    const name = sh("git config user.name", cwd);
+    if (!name.ok || name.stdout.trim().length === 0) {
+        sh(`git config user.name "Sela Bot"`, cwd);
+    }
+}
 // ═══════════════════════════════════════════════════════════════════
 // BUG-DETECTED HANDLING
 // ═══════════════════════════════════════════════════════════════════
 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) {
@@ -515,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}`);
             }
@@ -527,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`;
@@ -551,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) {

package/dist/services/PendingPromptLedger.d.ts

@@ -0,0 +1,44 @@
+import type { WorkspaceSnapshotService } from "./WorkspaceSnapshotService";
+import type { HealedEvent } from "./HealReportService";
+export interface PendingPromptEntry {
+    absolutePath: string;
+    relativePath: string;
+    contentBefore: string;
+    contentAfter: string;
+    createdBySela: boolean;
+    /** 1-based line number for the vscode:// deeplink, or null when unknown. */
+    lineNumber: number | null;
+}
+/**
+ * Resolve the ledger directory for a given cwd. The directory is created
+ * lazily on the first write so we never clutter repos that aren't running
+ * Sela.
+ */
+export declare function ledgerDir(cwd: string): string;
+/**
+ * Persist this worker's mutated snapshots to a fresh JSON file under
+ * `<cwd>/.sela/pending-prompts/`. Idempotent within a single worker -
+ * subsequent calls in the same process append a NEW file (rare in
+ * practice but keeps the contract simple).
+ *
+ * Returns the absolute path of the written file, or `null` when there is
+ * nothing to persist (so callers can skip the prompt entirely in CI /
+ * empty-mutation runs).
+ */
+export declare function writePendingPromptsLedger(opts: {
+    cwd: string;
+    workspace: WorkspaceSnapshotService;
+    healedEvents: HealedEvent[];
+}): string | null;
+/**
+ * Drain every per-worker JSON file under the ledger directory and merge
+ * their entries into a single de-duplicated list (keyed by absolutePath).
+ * The most-recent contentAfter wins on collision - that's the disk truth.
+ *
+ * The directory is NOT deleted here so the reporter can inspect entries
+ * before calling `clearPendingPromptsLedger()`.
+ */
+export declare function readPendingPromptsLedger(cwd: string): PendingPromptEntry[];
+/** Remove the ledger directory and every file beneath it. Idempotent. */
+export declare function clearPendingPromptsLedger(cwd: string): void;
+//# sourceMappingURL=PendingPromptLedger.d.ts.map

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

@@ -0,0 +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"}