@webpieces/rules-config 0.3.359 → 0.3.361

package/src/main-sync-status.d.ts

@@ -19,6 +19,38 @@ export declare class MainSyncLock {
     pid: number;
     constructor(state: string, started: number, pid?: number);
 }
+/**
+ * Reads/writes the main-sync cache + lock and computes the slow "is my branch healthy vs origin/main?"
+ * status. `@provideSingleton` so it's injectable and drawn in the rules-config DI design.
+ */
+export declare class MainSyncStatusService {
+    mainSyncStatusPath(repoRoot: string): string;
+    mainSyncLockPath(repoRoot: string): string;
+    readMainSyncStatus(repoRoot: string): MainSyncStatus | null;
+    writeMainSyncStatus(repoRoot: string, status: MainSyncStatus): void;
+    readMainSyncLock(repoRoot: string): MainSyncLock | null;
+    writeMainSyncLock(repoRoot: string, lock: MainSyncLock): void;
+    isLockStale(lock: MainSyncLock, hangTimeoutMinutes: number, now?: number): boolean;
+    isRefreshInProgress(repoRoot: string, hangTimeoutMinutes: number, now?: number): boolean;
+    inProcessLock(now?: number, pid?: number): MainSyncLock;
+    finishedLock(started: number): MainSyncLock;
+    /**
+     * The SLOW path, run only inside the detached refresher. Computes every cached signal the
+     * feature-branch-guard needs. Never run on the hook's blocking path.
+     */
+    computeMainSyncStatus(repoRoot: string): MainSyncStatus;
+    squashRecoverySteps(currentBranch: string): string[];
+    stampCleanMainSyncStatus(repoRoot: string): void;
+    private ensureDir;
+    private isProcessAlive;
+    private capture;
+    private gitBranch;
+    private changedFiles;
+    private featureChangedFiles;
+    private detectMergedPr;
+    private detectOpenPr;
+    private benignStatus;
+}
 export declare function mainSyncStatusPath(repoRoot: string): string;
 export declare function mainSyncLockPath(repoRoot: string): string;
 export declare function readMainSyncStatus(repoRoot: string): MainSyncStatus | null;
@@ -29,13 +61,6 @@ export declare function isLockStale(lock: MainSyncLock, hangTimeoutMinutes: numb
 export declare function isRefreshInProgress(repoRoot: string, hangTimeoutMinutes: number, now?: number): boolean;
 export declare function inProcessLock(now?: number, pid?: number): MainSyncLock;
 export declare function finishedLock(started: number): MainSyncLock;
-/**
- * The SLOW path, run only inside the detached refresher. Computes every cached signal the
- * feature-branch-guard needs: whether the branch is already merged (merged PR), whether a fork point
- * with origin/main still exists, and whether origin/main and this branch touched the SAME file since
- * the fork point (the deliberately-simple conflict heuristic — it over-blocks rather than miss a real
- * conflict). Never run on the hook's blocking path.
- */
 export declare function computeMainSyncStatus(repoRoot: string): MainSyncStatus;
 export declare function squashRecoverySteps(currentBranch: string): string[];
 export declare function stampCleanMainSyncStatus(repoRoot: string): void;

package/src/main-sync-status.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MainSyncLock = exports.MainSyncStatus = exports.DEFAULT_HANG_TIMEOUT_MINUTES = void 0;
+exports.MainSyncStatusService = exports.MainSyncLock = exports.MainSyncStatus = exports.DEFAULT_HANG_TIMEOUT_MINUTES = void 0;
 exports.mainSyncStatusPath = mainSyncStatusPath;
 exports.mainSyncLockPath = mainSyncLockPath;
 exports.readMainSyncStatus = readMainSyncStatus;
@@ -18,24 +18,21 @@ const tslib_1 = require("tslib");
 const child_process_1 = require("child_process");
 const fs = tslib_1.__importStar(require("fs"));
 const path = tslib_1.__importStar(require("path"));
+const di_1 = require("./di");
+const inversify_1 = require("inversify");
 const constants_1 = require("./constants");
 const to_error_1 = require("./to-error");
-// Shared "is my feature branch healthy relative to origin/main?" state. The SLOW signals (git fetch
-// + merge-base + same-file-overlap + a merged-PR lookup) are computed by the ai-hook-rules refresher
-// in a DETACHED background process so the PreToolUse hook never blocks on the network. The
-// feature-branch-guard then only READS this cached file (instant). pr-gate's merge flow also writes
-// it synchronously after a merge so the next edit is unblocked immediately. Lives here (the shared
-// dep of both packages) so neither depends on the other.
-// How long an `inprocess` refresher lock may sit before a new refresher assumes the prior run hung
-// and proceeds anyway. Overridable per-rule via FeatureBranchGuardConfig.hangTimeoutMinutes.
+// Shared "is my feature branch healthy relative to origin/main?" state. The SLOW signals (git fetch +
+// merge-base + same-file-overlap + a merged-PR lookup) are computed by the ai-hook-rules refresher in a
+// DETACHED background process; the feature-branch-guard only READS this cached file. pr-gate's merge
+// flow also writes it synchronously after a merge. Lives here (the shared dep of both).
+// How long an `inprocess` refresher lock may sit before a new refresher assumes the prior run hung.
 exports.DEFAULT_HANG_TIMEOUT_MINUTES = 5;
 const MAIN_SYNC_STATUS_FILE = 'main-sync-status.json';
 const MAIN_SYNC_LOCK_FILE = 'main-sync.lock.json';
 const LOCK_STATE_INPROCESS = 'inprocess';
 const LOCK_STATE_FINISHED = 'finished';
-// Data-only (per CLAUDE.md, classes for data). `forkPoint` is null exactly when `hasForkPoint` is
-// false (no merge-base with origin/main). `branchAlreadyMerged` flags that this feature branch was
-// already merged into main (a merged PR exists) — the "you're working on a finished branch" case.
+// Data-only (per CLAUDE.md, classes for data).
 class MainSyncStatus {
     branch;
     branchAlreadyMerged;
@@ -47,10 +44,7 @@ class MainSyncStatus {
     conflict;
     conflictFiles;
     timestamp;
-    // An OPEN (not merged) PR tracking this branch, if any — '' = none or not-yet-known. Set by the
-    // refresher (best-effort) and read by the feature-branch-guard so a mid-work conflict block can
-    // steer straight to the PR flow instead of the update-only flow (which would just fail-fast when a
-    // PR exists). Advisory only — the authoritative gate is wp-start-update's own fail-fast check.
+    // An OPEN (not merged) PR tracking this branch, if any — '' = none or not-yet-known. Advisory.
     // Kept OUT of the positional constructor (a defaulted field) so existing call sites don't churn.
     openPr = '';
     constructor(branch, branchAlreadyMerged, mergedPr, hasForkPoint, forkPoint, originMain, featureHead, conflict, conflictFiles, timestamp) {
@@ -67,10 +61,8 @@ class MainSyncStatus {
     }
 }
 exports.MainSyncStatus = MainSyncStatus;
-// Concurrency state machine for the detached refresher. `started` is epoch milliseconds. `pid` is
-// the refresher process's pid (0 = unknown, e.g. a lock written by an older version) — used so a
-// refresher that was KILLED before writing its finished lock (SIGKILL skips the finally) doesn't
-// wedge `inprocess` for the whole hangTimeout: if its pid is gone, the lock is reclaimable now.
+// Concurrency state machine for the detached refresher. `started` is epoch ms. `pid` is the refresher
+// process's pid (0 = unknown) — used so a KILLED refresher doesn't wedge `inprocess` for the timeout.
 class MainSyncLock {
     state;
     started;
@@ -82,237 +74,247 @@ class MainSyncLock {
     }
 }
 exports.MainSyncLock = MainSyncLock;
-function mainSyncStatusPath(repoRoot) {
-    return path.join(repoRoot, constants_1.WEBPIECES_TMP_DIR, MAIN_SYNC_STATUS_FILE);
-}
-function mainSyncLockPath(repoRoot) {
-    return path.join(repoRoot, constants_1.WEBPIECES_TMP_DIR, MAIN_SYNC_LOCK_FILE);
-}
-function ensureDir(filePath) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-}
-// Pure read — any error (missing file, malformed JSON) returns null so the guard fails OPEN
-// (never block an edit because the cache is unreadable).
-function readMainSyncStatus(repoRoot) {
-    // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
-    try {
-        const statusPath = mainSyncStatusPath(repoRoot);
-        if (!fs.existsSync(statusPath))
+/**
+ * Reads/writes the main-sync cache + lock and computes the slow "is my branch healthy vs origin/main?"
+ * status. `@provideSingleton` so it's injectable and drawn in the rules-config DI design.
+ */
+let MainSyncStatusService = class MainSyncStatusService {
+    mainSyncStatusPath(repoRoot) {
+        return path.join(repoRoot, constants_1.WEBPIECES_TMP_DIR, MAIN_SYNC_STATUS_FILE);
+    }
+    mainSyncLockPath(repoRoot) {
+        return path.join(repoRoot, constants_1.WEBPIECES_TMP_DIR, MAIN_SYNC_LOCK_FILE);
+    }
+    // Pure read — any error (missing file, malformed JSON) returns null so the guard fails OPEN.
+    readMainSyncStatus(repoRoot) {
+        // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
+        try {
+            const statusPath = this.mainSyncStatusPath(repoRoot);
+            if (!fs.existsSync(statusPath))
+                return null;
+            const raw = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
+            const status = new MainSyncStatus(raw.branch ?? '', raw.branchAlreadyMerged ?? false, raw.mergedPr ?? '', raw.hasForkPoint ?? true, raw.forkPoint ?? null, raw.originMain ?? '', raw.featureHead ?? '', raw.conflict ?? false, raw.conflictFiles ?? [], raw.timestamp ?? '');
+            status.openPr = raw.openPr ?? '';
+            return status;
+        }
+        catch (err) {
+            const error = (0, to_error_1.toError)(err);
+            void error;
             return null;
-        const raw = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
-        const status = new MainSyncStatus(raw.branch ?? '', raw.branchAlreadyMerged ?? false, raw.mergedPr ?? '', raw.hasForkPoint ?? true, raw.forkPoint ?? null, raw.originMain ?? '', raw.featureHead ?? '', raw.conflict ?? false, raw.conflictFiles ?? [], raw.timestamp ?? '');
-        status.openPr = raw.openPr ?? '';
-        return status;
+        }
     }
-    catch (err) {
-        const error = (0, to_error_1.toError)(err);
-        void error;
-        return null;
+    writeMainSyncStatus(repoRoot, status) {
+        const statusPath = this.mainSyncStatusPath(repoRoot);
+        this.ensureDir(statusPath);
+        fs.writeFileSync(statusPath, JSON.stringify(status, null, 2) + '\n');
     }
-}
-function writeMainSyncStatus(repoRoot, status) {
-    const statusPath = mainSyncStatusPath(repoRoot);
-    ensureDir(statusPath);
-    fs.writeFileSync(statusPath, JSON.stringify(status, null, 2) + '\n');
-}
-function readMainSyncLock(repoRoot) {
-    // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
-    try {
-        const lockPath = mainSyncLockPath(repoRoot);
-        if (!fs.existsSync(lockPath))
+    readMainSyncLock(repoRoot) {
+        // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
+        try {
+            const lockPath = this.mainSyncLockPath(repoRoot);
+            if (!fs.existsSync(lockPath))
+                return null;
+            const raw = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+            return new MainSyncLock(raw.state ?? LOCK_STATE_FINISHED, raw.started ?? 0, raw.pid ?? 0);
+        }
+        catch (err) {
+            const error = (0, to_error_1.toError)(err);
+            void error;
             return null;
-        const raw = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
-        return new MainSyncLock(raw.state ?? LOCK_STATE_FINISHED, raw.started ?? 0, raw.pid ?? 0);
+        }
     }
-    catch (err) {
-        const error = (0, to_error_1.toError)(err);
-        void error;
-        return null;
+    writeMainSyncLock(repoRoot, lock) {
+        const lockPath = this.mainSyncLockPath(repoRoot);
+        this.ensureDir(lockPath);
+        fs.writeFileSync(lockPath, JSON.stringify(lock, null, 2) + '\n');
     }
-}
-function writeMainSyncLock(repoRoot, lock) {
-    const lockPath = mainSyncLockPath(repoRoot);
-    ensureDir(lockPath);
-    fs.writeFileSync(lockPath, JSON.stringify(lock, null, 2) + '\n');
-}
-// A lock is stale (the prior refresher is assumed hung) once it has been `inprocess` longer than
-// hangTimeoutMinutes. `now` is injectable for tests; defaults to Date.now().
-function isLockStale(lock, hangTimeoutMinutes, now = Date.now()) {
-    return now - lock.started > hangTimeoutMinutes * 60 * 1000;
-}
-// Liveness probe: is `pid` still a running process? `process.kill(pid, 0)` sends no signal, it only
-// tests existence — ESRCH means the process is gone, EPERM means it exists but isn't ours (alive).
-// pid <= 0 means "unknown" (an old lock with no pid) → assume alive and fall back to staleness only.
-function isProcessAlive(pid) {
-    if (pid <= 0)
-        return true;
-    // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
-    try {
-        process.kill(pid, 0);
-        return true;
+    // A lock is stale (prior refresher assumed hung) once `inprocess` longer than hangTimeoutMinutes.
+    isLockStale(lock, hangTimeoutMinutes, now = Date.now()) {
+        return now - lock.started > hangTimeoutMinutes * 60 * 1000;
     }
-    catch (err) {
-        const error = (0, to_error_1.toError)(err);
-        // ESRCH = no such process (dead); anything else (e.g. EPERM = exists, not ours) = alive.
-        return !error.message.includes('ESRCH');
+    // True when another refresher is actively running and we should NOT start a second one.
+    isRefreshInProgress(repoRoot, hangTimeoutMinutes, now = Date.now()) {
+        const lock = this.readMainSyncLock(repoRoot);
+        if (!lock)
+            return false;
+        if (lock.state !== LOCK_STATE_INPROCESS)
+            return false;
+        if (this.isLockStale(lock, hangTimeoutMinutes, now))
+            return false;
+        return this.isProcessAlive(lock.pid);
     }
-}
-// True when another refresher is actively running and we should NOT start a second one. A finished
-// lock, a missing lock, a stale (hung) inprocess lock, OR an inprocess lock whose refresher pid is
-// already dead (it was killed before writing its finished lock) all return false — so a killed
-// refresher never wedges refreshes for the full hangTimeout.
-function isRefreshInProgress(repoRoot, hangTimeoutMinutes, now = Date.now()) {
-    const lock = readMainSyncLock(repoRoot);
-    if (!lock)
-        return false;
-    if (lock.state !== LOCK_STATE_INPROCESS)
-        return false;
-    if (isLockStale(lock, hangTimeoutMinutes, now))
-        return false;
-    return isProcessAlive(lock.pid);
-}
-function inProcessLock(now = Date.now(), pid = process.pid) {
-    return new MainSyncLock(LOCK_STATE_INPROCESS, now, pid);
-}
-function finishedLock(started) {
-    return new MainSyncLock(LOCK_STATE_FINISHED, started, 0);
-}
-// Run a command capturing trimmed stdout; ok=false on spawn failure or non-zero exit.
-function capture(repoRoot, cmd, args) {
-    const result = (0, child_process_1.spawnSync)(cmd, args, { cwd: repoRoot, encoding: 'utf8' });
-    if (result.status !== 0 || typeof result.stdout !== 'string')
-        return { ok: false, out: '' };
-    return { ok: true, out: result.stdout.trim() };
-}
-// The actual checked-out branch in repoRoot — cwd-correct so the cache's `branch` label always
-// matches what the feature-branch-guard compares against (its own `git rev-parse` in the workspace).
-function gitBranch(repoRoot) {
-    const result = capture(repoRoot, 'git', ['rev-parse', '--abbrev-ref', 'HEAD']);
-    return result.ok ? result.out : '';
-}
-function changedFiles(repoRoot, base, head) {
-    const result = capture(repoRoot, 'git', ['diff', '--name-only', base, head]);
-    if (!result.ok || result.out === '')
-        return [];
-    return result.out.split('\n').map((line) => line.trim()).filter((line) => line.length > 0);
-}
-// Every file this feature branch has touched since the fork point — committed AND still in the
-// working tree (staged / unstaged / untracked). The committed-only `git diff forkPoint..HEAD` was
-// BLIND to uncommitted edits: for most of an editing session the files you are actively changing are
-// not yet in HEAD, so the overlap with main's changes was empty and conflict=false even when
-// origin/main had already moved onto those same files. Unioning in the working-tree changes makes the
-// conflict visible WHILE editing, so the guard can force an early merge instead of a painful late one.
-function featureChangedFiles(repoRoot, forkPoint) {
-    const out = new Set();
-    const add = (args) => {
-        const r = capture(repoRoot, 'git', args);
-        if (!r.ok || r.out === '')
-            return;
-        for (const line of r.out.split('\n')) {
-            const f = line.trim();
-            if (f.length > 0)
-                out.add(f);
+    inProcessLock(now = Date.now(), pid = process.pid) {
+        return new MainSyncLock(LOCK_STATE_INPROCESS, now, pid);
+    }
+    finishedLock(started) {
+        return new MainSyncLock(LOCK_STATE_FINISHED, started, 0);
+    }
+    /**
+     * The SLOW path, run only inside the detached refresher. Computes every cached signal the
+     * feature-branch-guard needs. Never run on the hook's blocking path.
+     */
+    // webpieces-disable max-lines-new-methods -- one cohesive slow-path computation
+    computeMainSyncStatus(repoRoot) {
+        const branch = this.gitBranch(repoRoot);
+        const mergedPr = this.detectMergedPr(repoRoot, branch);
+        const openPr = this.detectOpenPr(repoRoot, branch);
+        // Best-effort network refresh; offline just means we evaluate against the last-fetched ref.
+        (0, child_process_1.spawnSync)('git', ['fetch', 'origin', 'main'], { cwd: repoRoot, stdio: 'ignore' });
+        const head = this.capture(repoRoot, 'git', ['rev-parse', 'HEAD']);
+        const originMain = this.capture(repoRoot, 'git', ['rev-parse', 'origin/main']);
+        const featureHead = head.ok ? head.out : '';
+        if (!head.ok || !originMain.ok) {
+            const status = this.benignStatus(branch, featureHead);
+            status.branchAlreadyMerged = mergedPr !== '';
+            status.mergedPr = mergedPr;
+            status.openPr = openPr;
+            return status;
         }
-    };
-    add(['diff', '--name-only', forkPoint, 'HEAD']); // committed since the fork point
-    add(['diff', '--name-only', 'HEAD']); // unstaged working-tree edits
-    add(['diff', '--name-only', '--cached', 'HEAD']); // staged edits
-    add(['ls-files', '--others', '--exclude-standard']); // untracked new files (respects .gitignore)
-    return [...out];
-}
-// Has this feature branch already been merged into main? Reliable signal: a MERGED PR exists for the
-// branch. Best-effort — if gh is missing/unauthenticated we just report not-merged (false).
-function detectMergedPr(repoRoot, branch) {
-    if (!branch || branch === 'main')
-        return '';
-    const result = capture(repoRoot, 'gh', ['pr', 'list', '--head', branch, '--state', 'merged', '--json', 'number', '--jq', '.[0].number']);
-    return result.ok ? result.out : '';
-}
-// An OPEN PR tracking this branch, if any. Best-effort — this is ADVISORY (it only lets the guard's
-// conflict block steer to the PR flow early), so an unreachable gh degrades to '' here. The HARD gate
-// that must never guess is wp-start-update's own openPrForBranch, which fails fast instead.
-function detectOpenPr(repoRoot, branch) {
-    if (!branch || branch === 'main')
-        return '';
-    const result = capture(repoRoot, 'gh', ['pr', 'list', '--head', branch, '--state', 'open', '--json', 'number', '--jq', '.[0].number']);
-    return result.ok ? result.out : '';
-}
-// A benign status that never blocks — used when origin/main can't be resolved (no remote yet,
-// offline before first fetch). hasForkPoint=true + conflict=false so the guard allows the edit.
-function benignStatus(branch, featureHead) {
-    return new MainSyncStatus(branch, false, '', true, null, '', featureHead, false, [], new Date().toISOString());
-}
-/**
- * The SLOW path, run only inside the detached refresher. Computes every cached signal the
- * feature-branch-guard needs: whether the branch is already merged (merged PR), whether a fork point
- * with origin/main still exists, and whether origin/main and this branch touched the SAME file since
- * the fork point (the deliberately-simple conflict heuristic — it over-blocks rather than miss a real
- * conflict). Never run on the hook's blocking path.
- */
-function computeMainSyncStatus(repoRoot) {
-    const branch = gitBranch(repoRoot);
-    const mergedPr = detectMergedPr(repoRoot, branch);
-    // Advisory: lets the guard's conflict block steer to the PR flow early when a PR is already open.
-    const openPr = detectOpenPr(repoRoot, branch);
-    // Best-effort network refresh; offline just means we evaluate against the last-fetched ref.
-    (0, child_process_1.spawnSync)('git', ['fetch', 'origin', 'main'], { cwd: repoRoot, stdio: 'ignore' });
-    const head = capture(repoRoot, 'git', ['rev-parse', 'HEAD']);
-    const originMain = capture(repoRoot, 'git', ['rev-parse', 'origin/main']);
-    const featureHead = head.ok ? head.out : '';
-    if (!head.ok || !originMain.ok) {
-        const status = benignStatus(branch, featureHead);
-        status.branchAlreadyMerged = mergedPr !== '';
-        status.mergedPr = mergedPr;
+        const forkPoint = this.capture(repoRoot, 'git', ['merge-base', 'origin/main', 'HEAD']);
+        if (!forkPoint.ok || forkPoint.out === '') {
+            const noFork = new MainSyncStatus(branch, mergedPr !== '', mergedPr, false, null, originMain.out, featureHead, false, [], new Date().toISOString());
+            noFork.openPr = openPr;
+            return noFork;
+        }
+        const featureFiles = new Set(this.featureChangedFiles(repoRoot, forkPoint.out));
+        const mainFiles = this.changedFiles(repoRoot, forkPoint.out, 'origin/main');
+        const conflictFiles = mainFiles.filter((file) => featureFiles.has(file));
+        const status = new MainSyncStatus(branch, mergedPr !== '', mergedPr, true, forkPoint.out, originMain.out, featureHead, conflictFiles.length > 0, conflictFiles, new Date().toISOString());
         status.openPr = openPr;
         return status;
     }
-    const forkPoint = capture(repoRoot, 'git', ['merge-base', 'origin/main', 'HEAD']);
-    if (!forkPoint.ok || forkPoint.out === '') {
-        // No common ancestor — main was merged into the branch. Force the human to squash.
-        const noFork = new MainSyncStatus(branch, mergedPr !== '', mergedPr, false, null, originMain.out, featureHead, false, [], new Date().toISOString());
-        noFork.openPr = openPr;
-        return noFork;
+    // The recovery steps when there is no fork point with origin/main (a bad merge of main into branch).
+    squashRecoverySteps(currentBranch) {
+        return [
+            '1. Fetch latest main:            git fetch origin main',
+            `2. New branch off origin/main:   git checkout -b ${currentBranch}-v2 origin/main`,
+            `3. Squash-merge old branch:      git merge --squash ${currentBranch}`,
+            `4. Commit the squash:            git add -A && git commit -m "Squashed from ${currentBranch}"`,
+            '5. If a PR exists:               open a NEW PR for the -v2 branch and close the old one.',
+        ];
     }
-    const featureFiles = new Set(featureChangedFiles(repoRoot, forkPoint.out));
-    const mainFiles = changedFiles(repoRoot, forkPoint.out, 'origin/main');
-    const conflictFiles = mainFiles.filter((file) => featureFiles.has(file));
-    const status = new MainSyncStatus(branch, mergedPr !== '', mergedPr, true, forkPoint.out, originMain.out, featureHead, conflictFiles.length > 0, conflictFiles, new Date().toISOString());
-    status.openPr = openPr;
-    return status;
-}
-// The recovery steps when there is no fork point with origin/main (someone merged main into the
-// branch, so a clean squash-merge is impossible). Shared so the feature-branch-guard and pr-gate's
-// findForkPoint check present the SAME instructions. The human must redo the work on a fresh branch —
-// deliberately painful so the bad merge gets noticed and reported.
-function squashRecoverySteps(currentBranch) {
-    // Branch off origin/main directly (never `git checkout main`) so these steps are correct on the
-    // primary repo AND inside a linked worktree, where main is checked out elsewhere and cannot be
-    // checked out again.
-    return [
-        '1. Fetch latest main:            git fetch origin main',
-        `2. New branch off origin/main:   git checkout -b ${currentBranch}-v2 origin/main`,
-        `3. Squash-merge old branch:      git merge --squash ${currentBranch}`,
-        `4. Commit the squash:            git add -A && git commit -m "Squashed from ${currentBranch}"`,
-        '5. If a PR exists:               open a NEW PR for the -v2 branch and close the old one.',
-    ];
-}
-// Synchronously stamp a clean "up to date with main" status — call right after a successful merge
-// (the branch now contains origin/main). Unblocks the next edit immediately without waiting for the
-// async refresher. Best-effort: a git failure is swallowed (the refresher will recompute later).
-function stampCleanMainSyncStatus(repoRoot) {
-    // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
-    try {
-        const branch = gitBranch(repoRoot);
-        const originMain = capture(repoRoot, 'git', ['rev-parse', 'origin/main']);
-        const featureHead = capture(repoRoot, 'git', ['rev-parse', 'HEAD']);
-        if (!originMain.ok || !featureHead.ok)
-            return;
-        const status = new MainSyncStatus(branch, false, '', true, originMain.out, originMain.out, featureHead.out, false, [], new Date().toISOString());
-        writeMainSyncStatus(repoRoot, status);
+    // Synchronously stamp a clean "up to date with main" status — call right after a successful merge.
+    stampCleanMainSyncStatus(repoRoot) {
+        // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
+        try {
+            const branch = this.gitBranch(repoRoot);
+            const originMain = this.capture(repoRoot, 'git', ['rev-parse', 'origin/main']);
+            const featureHead = this.capture(repoRoot, 'git', ['rev-parse', 'HEAD']);
+            if (!originMain.ok || !featureHead.ok)
+                return;
+            const status = new MainSyncStatus(branch, false, '', true, originMain.out, originMain.out, featureHead.out, false, [], new Date().toISOString());
+            this.writeMainSyncStatus(repoRoot, status);
+        }
+        catch (err) {
+            const error = (0, to_error_1.toError)(err);
+            void error;
+        }
     }
-    catch (err) {
-        const error = (0, to_error_1.toError)(err);
-        void error;
+    ensureDir(filePath) {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
     }
-}
+    // Liveness probe: is `pid` still a running process? pid <= 0 (unknown) → assume alive.
+    isProcessAlive(pid) {
+        if (pid <= 0)
+            return true;
+        // eslint-disable-next-line @webpieces/no-unmanaged-exceptions
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (err) {
+            const error = (0, to_error_1.toError)(err);
+            return !error.message.includes('ESRCH');
+        }
+    }
+    // Run a command capturing trimmed stdout; ok=false on spawn failure or non-zero exit.
+    capture(repoRoot, cmd, args) {
+        const result = (0, child_process_1.spawnSync)(cmd, args, { cwd: repoRoot, encoding: 'utf8' });
+        if (result.status !== 0 || typeof result.stdout !== 'string')
+            return { ok: false, out: '' };
+        return { ok: true, out: result.stdout.trim() };
+    }
+    // The actual checked-out branch in repoRoot — cwd-correct so the cache's `branch` label matches.
+    gitBranch(repoRoot) {
+        const result = this.capture(repoRoot, 'git', ['rev-parse', '--abbrev-ref', 'HEAD']);
+        return result.ok ? result.out : '';
+    }
+    changedFiles(repoRoot, base, head) {
+        const result = this.capture(repoRoot, 'git', ['diff', '--name-only', base, head]);
+        if (!result.ok || result.out === '')
+            return [];
+        return result.out.split('\n').map((line) => line.trim()).filter((line) => line.length > 0);
+    }
+    // Every file this feature branch has touched since the fork point — committed AND still in the
+    // working tree (staged / unstaged / untracked), so a conflict is visible WHILE editing.
+    featureChangedFiles(repoRoot, forkPoint) {
+        const out = new Set();
+        const add = (args) => {
+            const r = this.capture(repoRoot, 'git', args);
+            if (!r.ok || r.out === '')
+                return;
+            for (const line of r.out.split('\n')) {
+                const f = line.trim();
+                if (f.length > 0)
+                    out.add(f);
+            }
+        };
+        add(['diff', '--name-only', forkPoint, 'HEAD']); // committed since the fork point
+        add(['diff', '--name-only', 'HEAD']); // unstaged working-tree edits
+        add(['diff', '--name-only', '--cached', 'HEAD']); // staged edits
+        add(['ls-files', '--others', '--exclude-standard']); // untracked new files (respects .gitignore)
+        return [...out];
+    }
+    // Has this feature branch already been merged into main? Reliable signal: a MERGED PR exists.
+    detectMergedPr(repoRoot, branch) {
+        if (!branch || branch === 'main')
+            return '';
+        const result = this.capture(repoRoot, 'gh', ['pr', 'list', '--head', branch, '--state', 'merged', '--json', 'number', '--jq', '.[0].number']);
+        return result.ok ? result.out : '';
+    }
+    // An OPEN PR tracking this branch, if any. Best-effort/advisory.
+    detectOpenPr(repoRoot, branch) {
+        if (!branch || branch === 'main')
+            return '';
+        const result = this.capture(repoRoot, 'gh', ['pr', 'list', '--head', branch, '--state', 'open', '--json', 'number', '--jq', '.[0].number']);
+        return result.ok ? result.out : '';
+    }
+    // A benign status that never blocks — used when origin/main can't be resolved.
+    benignStatus(branch, featureHead) {
+        return new MainSyncStatus(branch, false, '', true, null, '', featureHead, false, [], new Date().toISOString());
+    }
+};
+exports.MainSyncStatusService = MainSyncStatusService;
+exports.MainSyncStatusService = MainSyncStatusService = tslib_1.__decorate([
+    (0, di_1.provideSingleton)(),
+    (0, inversify_1.injectable)()
+], MainSyncStatusService);
+// Temporary migration delegators to MainSyncStatusService — removed once consumers inject it.
+const mainSyncSvc = new MainSyncStatusService();
+// webpieces-disable no-function-outside-class -- temporary back-compat delegator to MainSyncStatusService; removed once consumers inject it
+function mainSyncStatusPath(repoRoot) { return mainSyncSvc.mainSyncStatusPath(repoRoot); }
+// webpieces-disable no-function-outside-class -- temporary back-compat delegator to MainSyncStatusService; removed once consumers inject it
+function mainSyncLockPath(repoRoot) { return mainSyncSvc.mainSyncLockPath(repoRoot); }
+// webpieces-disable no-function-outside-class -- temporary back-compat delegator to MainSyncStatusService; removed once consumers inject it
+function readMainSyncStatus(repoRoot) { return mainSyncSvc.readMainSyncStatus(repoRoot); }
+// webpieces-disable no-function-outside-class -- temporary back-compat delegator to MainSyncStatusService; removed once consumers inject it
+function writeMainSyncStatus(repoRoot, status) { mainSyncSvc.writeMainSyncStatus(repoRoot, status); }
+// webpieces-disable no-function-outside-class -- temporary back-compat delegator to MainSyncStatusService; removed once consumers inject it
+function readMainSyncLock(repoRoot) { return mainSyncSvc.readMainSyncLock(repoRoot); }
+// webpieces-disable no-function-outside-class -- temporary back-compat delegator to MainSyncStatusService; removed once consumers inject it
+function writeMainSyncLock(repoRoot, lock) { mainSyncSvc.writeMainSyncLock(repoRoot, lock); }
+// webpieces-disable no-function-outside-class -- temporary back-compat delegator to MainSyncStatusService; removed once consumers inject it
+function isLockStale(lock, hangTimeoutMinutes, now = Date.now()) { return mainSyncSvc.isLockStale(lock, hangTimeoutMinutes, now); }
+// webpieces-disable no-function-outside-class -- temporary back-compat delegator to MainSyncStatusService; removed once consumers inject it
+function isRefreshInProgress(repoRoot, hangTimeoutMinutes, now = Date.now()) { return mainSyncSvc.isRefreshInProgress(repoRoot, hangTimeoutMinutes, now); }
+// webpieces-disable no-function-outside-class -- temporary back-compat delegator to MainSyncStatusService; removed once consumers inject it
+function inProcessLock(now = Date.now(), pid = process.pid) { return mainSyncSvc.inProcessLock(now, pid); }
+// webpieces-disable no-function-outside-class -- temporary back-compat delegator to MainSyncStatusService; removed once consumers inject it
+function finishedLock(started) { return mainSyncSvc.finishedLock(started); }
+// webpieces-disable no-function-outside-class -- temporary back-compat delegator to MainSyncStatusService; removed once consumers inject it
+function computeMainSyncStatus(repoRoot) { return mainSyncSvc.computeMainSyncStatus(repoRoot); }
+// webpieces-disable no-function-outside-class -- temporary back-compat delegator to MainSyncStatusService; removed once consumers inject it
+function squashRecoverySteps(currentBranch) { return mainSyncSvc.squashRecoverySteps(currentBranch); }
+// webpieces-disable no-function-outside-class -- temporary back-compat delegator to MainSyncStatusService; removed once consumers inject it
+function stampCleanMainSyncStatus(repoRoot) { mainSyncSvc.stampCleanMainSyncStatus(repoRoot); }
 //# sourceMappingURL=main-sync-status.js.map