@coralai/sps-cli 0.49.0 → 0.49.1

package/dist/engines/CloseoutEngine.js

@@ -1,648 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { resolveWorkflowTransport, resolveGitlabProjectId } from '../core/config.js';
-import { IntegrationQueue } from '../manager/integration-queue.js';
-import { buildPhasePrompt, INTEGRATION_PROMPT_FILE } from '../core/taskPrompts.js';
-import { branchPushed, branchCommitsAhead } from '../providers/outputParser.js';
-import { RuntimeStore } from '../core/runtimeStore.js';
-import { resolveWorktreePath } from '../core/paths.js';
-import { Logger } from '../core/logger.js';
-/**
- * CloseoutEngine handles the QA → Done pipeline.
- *
- * In the worker-owned two-phase model, QA means integration:
- * - the worker performs rebase / merge / conflict resolution
- * - SPS only checks evidence, starts or resumes the integration worker,
- *   and finalizes the task after the branch is merged.
- */
-export class CloseoutEngine {
-    ctx;
-    taskBackend;
-    repoBackend;
-    workerManager;
-    pipelineAdapter;
-    notifier;
-    log;
-    runtimeStore;
-    constructor(ctx, taskBackend, repoBackend, workerManager, pipelineAdapter, notifier) {
-        this.ctx = ctx;
-        this.taskBackend = taskBackend;
-        this.repoBackend = repoBackend;
-        this.workerManager = workerManager;
-        this.pipelineAdapter = pipelineAdapter;
-        this.notifier = notifier;
-        this.log = new Logger('qa', ctx.projectName, ctx.paths.logsDir);
-        this.runtimeStore = new RuntimeStore(ctx);
-    }
-    async tick() {
-        const actions = [];
-        const recommendedActions = [];
-        const result = {
-            project: this.ctx.projectName,
-            component: 'qa',
-            status: 'ok',
-            exitCode: 0,
-            actions,
-            recommendedActions,
-            details: {},
-        };
-        try {
-            const qaCards = await this.taskBackend.listByState(this.pipelineAdapter.states.review);
-            if (qaCards.length === 0) {
-                this.log.info('No QA cards to process');
-                result.details = { reason: 'no_qa_cards' };
-            }
-            else {
-                this.log.info(`Processing ${qaCards.length} QA card(s)`);
-                for (const card of qaCards) {
-                    // Skip cards with BLOCKED label
-                    if (card.labels.includes('BLOCKED')) {
-                        this.log.debug(`Skipping seq ${card.seq}: BLOCKED`);
-                        actions.push({
-                            action: 'skip',
-                            entity: `seq:${card.seq}`,
-                            result: 'skip',
-                            message: 'Card is BLOCKED',
-                        });
-                        continue;
-                    }
-                    try {
-                        await this.processQaCard(card, actions, recommendedActions);
-                    }
-                    catch (err) {
-                        const msg = err instanceof Error ? err.message : String(err);
-                        this.log.error(`Unexpected error processing seq ${card.seq}: ${msg}`);
-                        actions.push({
-                            action: 'closeout',
-                            entity: `seq:${card.seq}`,
-                            result: 'fail',
-                            message: `Unexpected error: ${msg}`,
-                        });
-                    }
-                }
-            }
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.error(`Closeout tick failed: ${msg}`);
-            result.status = 'fail';
-            result.exitCode = 1;
-            result.details = { error: msg };
-        }
-        // Always run worktree cleanup — independent of QA card processing
-        await this.cleanupWorktrees(actions);
-        if (actions.some((a) => a.result === 'fail') && result.status === 'ok') {
-            result.status = 'degraded';
-        }
-        return result;
-    }
-    // ─── Core Decision Tree ───────────────────────────────────────
-    async processQaCard(card, actions, recommendedActions) {
-        const seq = card.seq;
-        const state = this.runtimeStore.readState();
-        const runtime = this.runtimeStore.getTask(seq, state);
-        const branchName = runtime.lease?.branch ||
-            runtime.evidence?.branch ||
-            this.buildBranchName(card);
-        const worktree = runtime.lease?.worktree ||
-            runtime.evidence?.worktree ||
-            resolveWorktreePath(this.ctx.projectName, seq, this.ctx.config.WORKTREE_DIR);
-        if (!worktree || !existsSync(worktree)) {
-            await this.markNeedsFix(seq, 'QA task has no usable worktree');
-            actions.push({
-                action: 'mark-needs-fix',
-                entity: `seq:${seq}`,
-                result: 'ok',
-                message: 'No usable worktree for QA task',
-            });
-            return;
-        }
-        if (this.isMergedToBase(worktree, branchName)) {
-            this.log.info(`seq ${seq}: integration already complete, proceeding to release`);
-            await this.releaseAndDone(card, actions);
-            return;
-        }
-        const activeStatus = await this.inspectQaWorker(card, runtime.slotName, worktree, branchName, actions);
-        if (activeStatus === 'active' || activeStatus === 'waiting' || activeStatus === 'done') {
-            return;
-        }
-        if (activeStatus === 'failed') {
-            recommendedActions.push({
-                action: `Review QA task seq:${seq}`,
-                reason: 'Integration worker exited without merging the branch',
-                severity: 'warning',
-                autoExecutable: false,
-                requiresConfirmation: true,
-                safeToRetry: true,
-            });
-            return;
-        }
-        await this.startIntegrationWorker(card, runtime.slotName, worktree, branchName, actions);
-    }
-    async inspectQaWorker(card, slotName, worktree, branchName, actions) {
-        if (!slotName)
-            return 'idle';
-        const snapshots = this.workerManager.inspect({ taskId: String(card.seq) });
-        if (snapshots.length === 0)
-            return 'idle';
-        const snapshot = snapshots[0];
-        if (snapshot.state === 'idle')
-            return 'idle';
-        if (snapshot.state === 'waiting_input') {
-            this.log.info(`seq ${card.seq}: integration worker waiting for input — ${snapshot.pendingInput?.prompt || 'input required'}`);
-            actions.push({
-                action: 'qa-waiting',
-                entity: `seq:${card.seq}`,
-                result: 'skip',
-                message: 'Integration worker waiting_input',
-            });
-            return 'waiting';
-        }
-        if (snapshot.state === 'needs_confirmation') {
-            this.log.warn(`seq ${card.seq}: integration worker needs confirmation — ${snapshot.pendingInput?.prompt || 'confirmation required'}`);
-            actions.push({
-                action: 'qa-waiting',
-                entity: `seq:${card.seq}`,
-                result: 'skip',
-                message: 'Integration worker needs_confirmation',
-            });
-            return 'waiting';
-        }
-        if (snapshot.state === 'starting' || snapshot.state === 'running') {
-            actions.push({
-                action: 'qa-running',
-                entity: `seq:${card.seq}`,
-                result: 'skip',
-                message: `Integration worker ${snapshot.state}`,
-            });
-            return 'active';
-        }
-        if (snapshot.state === 'completed') {
-            if (this.isMergedToBase(worktree, branchName)) {
-                await this.releaseAndDone(card, actions);
-                return 'done';
-            }
-        }
-        // 'failed' or 'completed' without merge
-        await this.releaseQaSlot(card.seq, slotName);
-        await this.markNeedsFix(card.seq, `Integration worker ${snapshot.state} before merge completed`);
-        actions.push({
-            action: 'mark-needs-fix',
-            entity: `seq:${card.seq}`,
-            result: 'ok',
-            message: `Integration worker ${snapshot.state} before merge completed`,
-        });
-        return 'failed';
-    }
-    async startIntegrationWorker(card, _preferredSlot, worktree, branchName, actions) {
-        const seq = card.seq;
-        // Generate integration prompt in-memory (no disk file dependency)
-        const prompt = this.buildIntegrationPrompt(card, worktree, branchName);
-        const workflowTransport = resolveWorkflowTransport(this.ctx.config);
-        const logsDir = this.ctx.paths.logsDir;
-        const runRequest = {
-            taskId: String(card.seq),
-            cardId: String(card.seq),
-            project: this.ctx.projectName,
-            phase: 'integration',
-            prompt,
-            cwd: worktree,
-            branch: branchName,
-            targetBranch: this.ctx.mergeBranch,
-            tool: (this.pipelineAdapter.integrateStage?.agent || this.ctx.config.ACP_AGENT || this.ctx.config.WORKER_TOOL),
-            transport: 'acp-sdk',
-            outputFile: resolve(logsDir, `${this.ctx.projectName}-integration-${card.seq}-${Date.now()}.jsonl`),
-            completionStrategy: this.pipelineAdapter.integrateStage?.completion,
-        };
-        const response = await this.workerManager.run(runRequest);
-        if (!response.accepted) {
-            this.log.info(`seq ${seq}: WM rejected integration run: ${response.rejectReason ?? 'unknown'}`);
-            actions.push({
-                action: 'qa-launch',
-                entity: `seq:${seq}`,
-                result: 'skip',
-                message: `WM rejected: ${response.rejectReason ?? 'unknown'}`,
-            });
-            return;
-        }
-        // Queued in IntegrationQueue — no slot yet, will be spawned when active finishes
-        if (response.queued) {
-            this.log.info(`seq ${seq}: Queued for integration (position=${response.queuePosition})`);
-            // Update lease to merging even though no slot is assigned yet.
-            // This prevents Monitor from misinterpreting the card as stale.
-            this.runtimeStore.updateState('closeout-queue-integration', (draft) => {
-                if (draft.leases[seq]) {
-                    draft.leases[seq].phase = 'merging';
-                    draft.leases[seq].lastTransitionAt = new Date().toISOString();
-                }
-            });
-            actions.push({
-                action: 'qa-launch',
-                entity: `seq:${seq}`,
-                result: 'ok',
-                message: `Queued for integration (position=${response.queuePosition})`,
-            });
-            return;
-        }
-        // PM claim (best-effort, non-blocking)
-        const slotName = response.slot;
-        try {
-            await this.taskBackend.claim(seq, slotName);
-        }
-        catch (err) {
-            this.log.warn(`seq ${seq}: PM claim for QA worker failed: ${err instanceof Error ? err.message : err}`);
-        }
-        // Update local runtime projections with the slot WM allocated
-        this.runtimeStore.updateState('closeout-launch-integration', (draft) => {
-            draft.activeCards[seq] = {
-                seq: parseInt(seq, 10),
-                state: this.pipelineAdapter.states.review,
-                worker: slotName,
-                mrUrl: draft.activeCards[seq]?.mrUrl || null,
-                conflictDomains: draft.activeCards[seq]?.conflictDomains || [],
-                startedAt: draft.activeCards[seq]?.startedAt || new Date().toISOString(),
-                retryCount: draft.activeCards[seq]?.retryCount ?? draft.leases[seq]?.retryCount ?? 0,
-            };
-            draft.leases[seq] = {
-                seq: parseInt(seq, 10),
-                pmStateObserved: this.pipelineAdapter.states.review,
-                phase: 'merging',
-                slot: slotName,
-                branch: branchName,
-                worktree,
-                sessionId: response.sessionId || null,
-                runId: null,
-                claimedAt: new Date().toISOString(),
-                retryCount: draft.leases[seq]?.retryCount ?? 0,
-                lastTransitionAt: new Date().toISOString(),
-            };
-        });
-        actions.push({
-            action: 'qa-launch',
-            entity: `seq:${seq}`,
-            result: 'ok',
-            message: `Started integration worker on ${slotName}`,
-        });
-        this.logEvent('qa-launch', seq, 'ok', { worker: slotName });
-    }
-    // ─── Resource Release (01 §10.3.3) ─────────────────────────────
-    /**
-     * Release resources after successful merge. Each step failure MUST NOT
-     * block subsequent steps — log and continue.
-     *
-     * Order:
-     *   1. Move card to Done
-     *   2. Release claim in PM
-     *   3. Release worker slot in state.json (→ idle)
-     *   4. Stop worker session
-     *   5. Mark worktree for cleanup
-     */
-    async releaseAndDone(card, actions) {
-        const seq = card.seq;
-        const errors = [];
-        // Step 0: Clean auxiliary labels (NEEDS-FIX, STALE-RUNTIME, etc.)
-        // These may have been set by EventHandler during transient failures
-        // but the card is now successfully merged — labels should not persist.
-        for (const label of this.pipelineAdapter.auxiliaryLabels) {
-            if (card.labels.includes(label)) {
-                try {
-                    await this.taskBackend.removeLabel(seq, label);
-                    this.log.ok(`seq ${seq}: Removed residual label "${label}"`);
-                }
-                catch { /* best effort */ }
-            }
-        }
-        // Step 1: Move card to Done
-        try {
-            await this.taskBackend.move(seq, this.pipelineAdapter.states.done);
-            this.log.ok(`seq ${seq}: Moved to ${this.pipelineAdapter.states.done}`);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.error(`seq ${seq}: Failed to move to Done: ${msg}`);
-            errors.push(`move-done: ${msg}`);
-        }
-        // Step 2: Release claim
-        try {
-            await this.taskBackend.releaseClaim(seq);
-            this.log.ok(`seq ${seq}: Claim released`);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.error(`seq ${seq}: Failed to release claim: ${msg}`);
-            errors.push(`release-claim: ${msg}`);
-        }
-        // Step 3: Release worker slot in state.json
-        const state = this.runtimeStore.readState();
-        const runtime = this.runtimeStore.getTask(seq, state);
-        const slotEntry = runtime.slotName && runtime.slot ? [runtime.slotName, runtime.slot] : null;
-        if (slotEntry) {
-            const [slotName] = slotEntry;
-            try {
-                this.runtimeStore.updateState('closeout-release', (draft) => {
-                    this.runtimeStore.releaseTaskProjection(draft, seq, { dropLease: true });
-                });
-                this.log.ok(`seq ${seq}: Worker slot ${slotName} released`);
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                this.log.error(`seq ${seq}: Failed to release slot: ${msg}`);
-                errors.push(`release-slot: ${msg}`);
-            }
-        }
-        else {
-            // No active slot found — already released (idempotency)
-            // Still clean up activeCards entry if present
-            if (state.activeCards[seq] || state.leases[seq]) {
-                try {
-                    this.runtimeStore.updateState('closeout-release', (draft) => {
-                        this.runtimeStore.releaseTaskProjection(draft, seq, { dropLease: true });
-                    });
-                }
-                catch {
-                    // non-fatal
-                }
-            }
-            this.log.debug(`seq ${seq}: No active worker slot found (already released)`);
-        }
-        // Step 4: Silently stop the worker process if still running.
-        // DO NOT use workerManager.cancel() — it emits run.failed events which
-        // trigger NEEDS-FIX labels and error notifications. The task is already
-        // Done; we just need to kill the orphan process without side effects.
-        try {
-            const snapshots = this.workerManager.inspect({ taskId: seq });
-            for (const snap of snapshots) {
-                if (snap.pid && snap.pid > 0) {
-                    try {
-                        process.kill(snap.pid, 'SIGTERM');
-                    }
-                    catch { /* already dead */ }
-                }
-            }
-            this.log.ok(`seq ${seq}: Worker process cleaned up`);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.debug(`seq ${seq}: Worker cleanup: ${msg}`);
-        }
-        // Step 4b: Clear completed task from IntegrationQueue to unblock waiting tasks.
-        // The WM cancel above only cleans up spawned workers. If this task was the
-        // active entry in the queue (detected as already-merged before WM spawned),
-        // the queue is never advanced. Dequeue explicitly so waiting tasks proceed.
-        try {
-            const iq = new IntegrationQueue(this.ctx.paths.stateFile, this.ctx.config.MAX_CONCURRENT_WORKERS);
-            const active = iq.getActive(this.ctx.projectName, this.ctx.mergeBranch);
-            if (active && active.taskId === seq) {
-                iq.dequeueNext(this.ctx.projectName, this.ctx.mergeBranch);
-                this.log.ok(`seq ${seq}: Integration queue advanced`);
-            }
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.warn(`seq ${seq}: Failed to advance integration queue: ${msg}`);
-        }
-        // Step 5: Mark worktree for cleanup (actual removal runs at end of tick)
-        try {
-            const freshState = this.runtimeStore.readState();
-            const branchName = this.buildBranchName(card);
-            const worktreePath = runtime.lease?.worktree ||
-                runtime.evidence?.worktree ||
-                resolveWorktreePath(this.ctx.projectName, seq, this.ctx.config.WORKTREE_DIR);
-            const cleanup = freshState.worktreeCleanup ?? [];
-            const alreadyMarked = cleanup.some((e) => e.branch === branchName);
-            if (!alreadyMarked) {
-                cleanup.push({ branch: branchName, worktreePath, markedAt: new Date().toISOString() });
-                this.runtimeStore.updateState('closeout-worktree-mark', (draft) => {
-                    draft.worktreeCleanup = cleanup;
-                });
-            }
-            this.log.ok(`seq ${seq}: Worktree marked for cleanup`);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.error(`seq ${seq}: Failed to mark worktree for cleanup: ${msg}`);
-            errors.push(`worktree-mark: ${msg}`);
-        }
-        // Notify
-        if (errors.length === 0) {
-            await this.notifySafe(`✅ [${this.ctx.projectName}] seq:${seq} merged and released successfully`);
-        }
-        else {
-            await this.notifySafe(`⚠️ [${this.ctx.projectName}] seq:${seq} merged but release had errors: ${errors.join('; ')}`);
-        }
-        // Record action
-        const actionResult = errors.length === 0 ? 'ok' : 'fail';
-        actions.push({
-            action: 'closeout',
-            entity: `seq:${seq}`,
-            result: actionResult,
-            message: errors.length === 0
-                ? 'Merged → Done, resources released'
-                : `Merged → Done with errors: ${errors.join('; ')}`,
-        });
-        this.logEvent('closeout', seq, actionResult, errors.length > 0 ? { errors } : undefined);
-    }
-    // ─── Worktree Cleanup ──────────────────────────────────────────
-    /**
-     * Process the worktreeCleanup queue: remove worktree directories and
-     * delete local branches that have been merged.
-     *
-     * Each entry is processed independently — one failure does not block others.
-     */
-    async cleanupWorktrees(actions) {
-        const state = this.runtimeStore.readState();
-        const queue = state.worktreeCleanup ?? [];
-        if (queue.length === 0)
-            return;
-        // Only clean up entries marked at least 30 seconds ago.
-        // Entries marked in the current tick may still have worker processes
-        // shutting down (SIGTERM grace period). Defer to next tick.
-        const now = Date.now();
-        const ready = queue.filter(e => now - new Date(e.markedAt).getTime() >= 30_000);
-        const deferred = queue.filter(e => now - new Date(e.markedAt).getTime() < 30_000);
-        if (ready.length === 0) {
-            if (deferred.length > 0) {
-                this.log.debug(`${deferred.length} worktree(s) deferred — waiting for worker shutdown`);
-            }
-            return;
-        }
-        this.log.info(`Cleaning up ${ready.length} worktree(s)`);
-        const remaining = [...deferred];
-        for (const entry of ready) {
-            try {
-                await this.repoBackend.removeWorktree(this.ctx.paths.repoDir, entry.worktreePath, entry.branch);
-                this.log.ok(`Cleaned up worktree: ${entry.branch}`);
-                actions.push({
-                    action: 'worktree-cleanup',
-                    entity: entry.branch,
-                    result: 'ok',
-                    message: `Removed worktree ${entry.worktreePath}`,
-                });
-                this.logEvent('worktree-cleanup', entry.branch, 'ok');
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                this.log.warn(`Failed to clean up worktree ${entry.branch}: ${msg}`);
-                remaining.push(entry); // retry next tick
-                actions.push({
-                    action: 'worktree-cleanup',
-                    entity: entry.branch,
-                    result: 'fail',
-                    message: `Cleanup failed: ${msg}`,
-                });
-            }
-        }
-        // Update state with remaining entries
-        this.runtimeStore.updateState('closeout-worktree-cleanup', (freshState) => {
-            freshState.worktreeCleanup = remaining;
-        });
-    }
-    // ─── Helpers ───────────────────────────────────────────────────
-    buildBranchName(card) {
-        const slug = card.name
-            .toLowerCase()
-            .replace(/[^a-z0-9]+/g, '-')
-            .replace(/^-|-$/g, '')
-            .slice(0, 40);
-        return `feature/${card.seq}-${slug}`;
-    }
-    async markNeedsFix(seq, reason) {
-        await this.addLabelSafe(seq, 'NEEDS-FIX');
-        await this.commentSafe(seq, `NEEDS-FIX: ${reason}`);
-        await this.notifySafe(`⚠️ [${this.ctx.projectName}] seq:${seq} marked NEEDS-FIX: ${reason}`);
-    }
-    async addLabelSafe(seq, label) {
-        try {
-            await this.taskBackend.addLabel(seq, label);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.error(`Failed to add label ${label} to seq ${seq}: ${msg}`);
-        }
-    }
-    async commentSafe(seq, text) {
-        try {
-            await this.taskBackend.comment(seq, text);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.error(`Failed to comment on seq ${seq}: ${msg}`);
-        }
-    }
-    async notifySafe(message) {
-        if (!this.notifier)
-            return;
-        try {
-            await this.notifier.send(message);
-        }
-        catch {
-            // Notification failures are never fatal
-        }
-    }
-    logEvent(action, seq, result, meta) {
-        this.log.event({
-            component: 'qa',
-            action,
-            entity: `seq:${seq}`,
-            result,
-            meta,
-        });
-    }
-    /**
-     * Generate integration prompt in-memory. Archive to .sps/ for debugging.
-     * Independent of ExecutionEngine — each phase generates its own prompt.
-     */
-    buildIntegrationPrompt(card, worktree, branchName) {
-        // Load project rules from worktree
-        let projectRules = '';
-        const claudeMdPath = resolve(worktree, 'CLAUDE.md');
-        const agentsMdPath = resolve(worktree, 'AGENTS.md');
-        if (existsSync(claudeMdPath)) {
-            projectRules = readFileSync(claudeMdPath, 'utf-8').trim();
-        }
-        if (existsSync(agentsMdPath)) {
-            const agentsRules = readFileSync(agentsMdPath, 'utf-8').trim();
-            projectRules = projectRules ? `${projectRules}\n\n${agentsRules}` : agentsRules;
-        }
-        const prompt = buildPhasePrompt({
-            taskSeq: card.seq,
-            taskTitle: card.name,
-            taskDescription: card.desc || '(no description)',
-            cardId: card.id,
-            worktreePath: worktree,
-            branchName,
-            targetBranch: this.ctx.mergeBranch,
-            mergeMode: this.ctx.mrMode,
-            gitlabProjectId: resolveGitlabProjectId(this.ctx.config),
-            projectRules: projectRules || undefined,
-            phase: 'integration',
-        });
-        // Archive to .sps/ for debugging (non-blocking)
-        try {
-            const spsDir = resolve(worktree, '.sps');
-            if (!existsSync(spsDir))
-                mkdirSync(spsDir, { recursive: true });
-            writeFileSync(resolve(spsDir, INTEGRATION_PROMPT_FILE), prompt);
-        }
-        catch { /* archive failure should never block integration */ }
-        return prompt;
-    }
-    /**
-     * Check if the feature branch has been merged into the base branch.
-     *
-     * Guard against false positives: a freshly created branch with no work
-     * is trivially an ancestor of origin/base. Only return true if:
-     *   - Branch was pushed to remote, OR
-     *   - Branch has local commits ahead of base
-     * This matches CompletionJudge's artifact check logic.
-     */
-    isMergedToBase(worktree, branchName) {
-        try {
-            execFileSync('git', ['-C', worktree, 'fetch', 'origin', this.ctx.mergeBranch], { stdio: 'ignore' });
-        }
-        catch {
-            // Best effort. A stale fetch is still usable for local containment checks.
-        }
-        try {
-            execFileSync('git', ['-C', worktree, 'merge-base', '--is-ancestor', branchName, `origin/${this.ctx.mergeBranch}`], { stdio: 'ignore' });
-        }
-        catch {
-            return false;
-        }
-        // is-ancestor passed — but is it a real merge or an empty branch?
-        const pushed = branchPushed(worktree, branchName);
-        const localAhead = branchCommitsAhead(worktree, branchName, this.ctx.mergeBranch);
-        if (pushed || localAhead > 0) {
-            return true;
-        }
-        // Empty branch sitting at base commit — not a real merge
-        this.log.debug(`seq branch ${branchName}: ancestor of ${this.ctx.mergeBranch} but no artifacts — not a real merge`);
-        return false;
-    }
-    async releaseQaSlot(seq, slotName) {
-        try {
-            await this.workerManager.cancel({ taskId: seq, project: this.ctx.projectName, reason: 'anomaly' });
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.warn(`seq ${seq}: WM cancel in releaseQaSlot failed: ${msg}`);
-        }
-        this.runtimeStore.updateState('closeout-release-qa-slot', (draft) => {
-            this.runtimeStore.releaseTaskProjection(draft, seq, {
-                dropLease: false,
-                phase: 'merging',
-                keepWorktree: true,
-                pmStateObserved: this.pipelineAdapter.states.review,
-            });
-        });
-        try {
-            await this.taskBackend.releaseClaim(seq);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.warn(`seq ${seq}: Failed to release QA claim for ${slotName}: ${msg}`);
-        }
-    }
-}
-//# sourceMappingURL=CloseoutEngine.js.map