@coralai/sps-cli 0.15.12 → 0.16.0

package/dist/engines/MonitorEngine.js

@@ -4,13 +4,15 @@ import { Logger } from '../core/logger.js';
 /**
  * MonitorEngine performs anomaly detection and health checks.
  *
- * Checks (in order):
- *   1. Orphan slot cleanup (doc 12 §6.1)
- *   2. Stale runtime detection (01 §10.2.3)
- *   3. Timeout detection (01 §10.2.4)
- *   4. Waiting confirmation detection (doc 12 §3)
- *   5. BLOCKED condition check (01 §3.6.1)
- *   6. State alignment (07 §2.1)
+ * With ProcessSupervisor, completion detection and post-actions are handled
+ * by exit callbacks (CompletionJudge + PostActions). MonitorEngine focuses on:
+ *   1. Orphan slot cleanup (stale entries not tracked by Supervisor)
+ *   2. Stale runtime detection (Inprogress cards with no worker)
+ *   3. Timeout detection (INPROGRESS_TIMEOUT_HOURS)
+ *   4. Waiting confirmation detection (interactive mode only)
+ *   5. BLOCKED condition check
+ *   6. State alignment (Supervisor vs state.json sync)
+ *   7. Worker health (launch/idle timeouts for Supervisor-tracked workers)
  */
 export class MonitorEngine {
     ctx;
@@ -18,13 +20,15 @@ export class MonitorEngine {
     workerProvider;
     repoBackend;
     notifier;
+    supervisor;
     log;
-    constructor(ctx, taskBackend, workerProvider, repoBackend, notifier) {
+    constructor(ctx, taskBackend, workerProvider, repoBackend, notifier, supervisor) {
         this.ctx = ctx;
         this.taskBackend = taskBackend;
         this.workerProvider = workerProvider;
         this.repoBackend = repoBackend;
         this.notifier = notifier;
+        this.supervisor = supervisor;
         this.log = new Logger('monitor', ctx.projectName, ctx.paths.logsDir);
     }
     async tick() {
@@ -41,19 +45,12 @@ export class MonitorEngine {
             details: { checks },
         };
         try {
-            // 0. Worker health check (print-mode: launch timeout, idle timeout, auto-retry)
             await this.checkWorkerHealth(checks, actions);
-            // 1. Orphan slot cleanup
             await this.checkOrphanSlots(checks, actions);
-            // 2. Stale runtime detection
             await this.checkStaleRuntimes(checks, actions, recommendedActions);
-            // 3. Timeout detection
             await this.checkTimeouts(checks, actions, recommendedActions);
-            // 4. Waiting confirmation detection
             await this.checkWaitingConfirmation(checks, actions);
-            // 5. BLOCKED condition check
             await this.checkBlockedCards(checks);
-            // 6. State alignment
             await this.checkStateAlignment(checks, recommendedActions);
         }
         catch (err) {
@@ -63,59 +60,36 @@ export class MonitorEngine {
             result.exitCode = 1;
             result.details = { error: msg, checks };
         }
-        // Set degraded if any checks failed
         if (checks.some((c) => c.status === 'fail') && result.status === 'ok') {
             result.status = 'degraded';
         }
         return result;
     }
-    // ─── Check 1: Orphan Slot Cleanup (doc 12 §6.1) ───────────────
+    // ─── Check 1: Orphan Slot Cleanup ─────────────────────────────
     async checkOrphanSlots(checks, actions) {
         const state = readState(this.ctx.paths.stateFile, this.ctx.maxWorkers);
         let orphansFound = 0;
         for (const [slotName, slotState] of Object.entries(state.workers)) {
-            if (slotState.status !== 'active' || !slotState.tmuxSession)
+            if (slotState.status !== 'active')
                 continue;
-            // Print mode: check PID liveness directly instead of inspect()
-            if (slotState.mode === 'print' && slotState.pid) {
-                try {
-                    process.kill(slotState.pid, 0); // signal 0 = check alive
-                    continue; // PID alive → not orphan
-                }
-                catch {
-                    // PID dead — but did the worker actually complete its task?
-                    const completionStatus = await this.checkPrintWorkerCompletion(slotState);
-                    if (completionStatus === 'COMPLETED') {
-                        this.log.ok(`Orphan slot ${slotName}: print-mode pid ${slotState.pid} is dead but task COMPLETED, handling as completion`);
-                        const handled = await this.handleCompletedWorker(slotName, slotState, state, actions);
-                        if (handled)
-                            orphansFound++; // only count if slot was actually released
-                        continue;
-                    }
-                    // Not completed → fall through to orphan cleanup
-                    this.log.warn(`Orphan slot ${slotName}: print-mode pid ${slotState.pid} is dead (status=${completionStatus}), releasing`);
-                }
-            }
-            else if (slotState.mode === 'print' && !slotState.pid) {
-                // Print mode but no PID recorded — skip, launch may still be writing state
-                this.log.debug(`Skipping orphan check for ${slotName}: print mode, no PID yet`);
+            // Build the workerId that Supervisor would track
+            const seq = slotState.seq != null ? String(slotState.seq) : '';
+            const workerId = `${this.ctx.projectName}:${slotName}:${seq}`;
+            // If Supervisor is tracking this worker, it handles lifecycle — skip
+            if (this.supervisor.get(workerId))
                 continue;
+            // Supervisor doesn't know about this worker.
+            // PostActions exit callback may have already cleaned up state.
+            // Re-read state to check for race with exit callback.
+            const freshState = readState(this.ctx.paths.stateFile, this.ctx.maxWorkers);
+            const freshSlot = freshState.workers[slotName];
+            if (!freshSlot || freshSlot.status !== 'active')
+                continue;
+            // Still active with no Supervisor handle — truly orphaned / stale
+            this.log.warn(`Orphan slot ${slotName}: not tracked by Supervisor, marking STALE-RUNTIME and releasing`);
+            if (slotState.seq != null) {
+                await this.addLabelSafe(String(slotState.seq), 'STALE-RUNTIME');
             }
-            else {
-                // Tmux mode: use inspect()
-                try {
-                    const inspection = await this.workerProvider.inspect(slotState.tmuxSession);
-                    if (inspection.alive)
-                        continue; // alive → not orphan
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    this.log.warn(`Failed to inspect session ${slotState.tmuxSession}: ${msg}`);
-                    continue; // can't determine → skip
-                }
-                this.log.warn(`Orphan slot ${slotName}: session ${slotState.tmuxSession} is dead, releasing`);
-            }
-            // Orphan cleanup (shared for both modes)
             state.workers[slotName] = {
                 status: 'idle',
                 seq: null,
@@ -130,7 +104,6 @@ export class MonitorEngine {
                 outputFile: null,
                 exitCode: null,
             };
-            // Remove from active cards if present
             if (slotState.seq != null) {
                 delete state.activeCards[String(slotState.seq)];
             }
@@ -139,10 +112,9 @@ export class MonitorEngine {
                 action: 'orphan-cleanup',
                 entity: `slot:${slotName}`,
                 result: 'ok',
-                message: `Released orphan slot (${slotState.mode === 'print' ? `pid ${slotState.pid}` : `session ${slotState.tmuxSession}`} dead)`,
+                message: `Released orphan slot (not tracked by Supervisor)`,
             });
             this.logEvent('orphan-cleanup', slotName, 'ok', {
-                session: slotState.tmuxSession,
                 seq: slotState.seq,
             });
         }
@@ -163,12 +135,11 @@ export class MonitorEngine {
                 : 'No orphan slots detected',
         });
     }
-    // ─── Check 2: Stale Runtime Detection (01 §10.2.3) ────────────
+    // ─── Check 2: Stale Runtime Detection ─────────────────────────
     async checkStaleRuntimes(checks, actions, recommendedActions) {
         const inprogressCards = await this.taskBackend.listByState('Inprogress');
         let staleCount = 0;
         for (const card of inprogressCards) {
-            // Skip cards already marked
             if (card.labels.includes('STALE-RUNTIME'))
                 continue;
             const state = readState(this.ctx.paths.stateFile, this.ctx.maxWorkers);
@@ -180,81 +151,43 @@ export class MonitorEngine {
                 staleCount++;
                 continue;
             }
-            const [slotName, slotState] = slotEntry;
-            if (!slotState.tmuxSession)
+            const [, slotState] = slotEntry;
+            // Check if Supervisor is tracking this worker
+            const seq = slotState.seq != null ? String(slotState.seq) : '';
+            const workerId = `${this.ctx.projectName}:${slotEntry[0]}:${seq}`;
+            const handle = this.supervisor.get(workerId);
+            if (handle && handle.exitCode === null) {
+                // Supervisor tracking and worker still running — not stale
                 continue;
-            // Determine if worker is alive
-            let workerAlive;
-            if (slotState.mode === 'print') {
-                // Print mode: check PID liveness directly (no tmux session)
-                if (slotState.pid) {
-                    try {
-                        process.kill(slotState.pid, 0);
-                        workerAlive = true;
-                    }
-                    catch {
-                        workerAlive = false;
-                    }
-                }
-                else {
-                    continue; // No PID yet, skip
-                }
-            }
-            else {
-                // Interactive mode: use inspect()
-                try {
-                    const inspection = await this.workerProvider.inspect(slotState.tmuxSession);
-                    workerAlive = inspection.alive;
-                }
-                catch {
-                    continue; // Can't determine, skip
-                }
             }
-            if (!workerAlive) {
-                // Worker dead + card still Inprogress
-                // For print-mode workers, use full completion detection first
-                if (slotState.mode === 'print') {
-                    const completionStatus = await this.checkPrintWorkerCompletion(slotState);
-                    if (completionStatus === 'COMPLETED') {
-                        this.log.ok(`seq ${card.seq}: Worker dead but detectCompleted → COMPLETED`);
-                        const handled = await this.handleCompletedWorker(slotName, slotState, state, actions);
-                        if (handled) {
-                            try {
-                                writeState(this.ctx.paths.stateFile, state, 'monitor-stale-completed');
-                            }
-                            catch { /* logged */ }
-                        }
-                        staleCount++;
-                        continue;
-                    }
-                }
-                // Fall back to MR-only check
+            if (!handle) {
+                // Not tracked by Supervisor and no slot → stale
+                // Check for MR as a last resort
                 const branchName = slotState.branch || this.buildBranchName(card);
                 const mrStatus = await this.repoBackend.getMrStatus(branchName);
                 if (mrStatus.exists) {
-                    this.log.warn(`seq ${card.seq}: Worker dead but MR exists — stale runtime`);
+                    this.log.warn(`seq ${card.seq}: Worker not tracked, but MR exists — stale runtime`);
                     await this.handleStaleRuntime(card, actions, recommendedActions);
-                    staleCount++;
                 }
                 else {
-                    this.log.warn(`seq ${card.seq}: Worker dead, no MR found`);
+                    this.log.warn(`seq ${card.seq}: Worker not tracked, no MR found`);
                     await this.addLabelSafe(card.seq, 'STALE-RUNTIME');
                     actions.push({
                         action: 'mark-stale',
                         entity: `seq:${card.seq}`,
                         result: 'ok',
-                        message: 'Worker dead, no MR — needs manual review',
+                        message: 'Worker not tracked by Supervisor, no MR — needs manual review',
                     });
                     recommendedActions.push({
-                        action: `Review seq:${card.seq} — worker died without creating MR`,
-                        reason: 'Worker dead with no MR',
+                        action: `Review seq:${card.seq} — worker not tracked, no MR`,
+                        reason: 'Worker not tracked by Supervisor with no MR',
                         severity: 'warning',
                         autoExecutable: false,
                         requiresConfirmation: true,
                         safeToRetry: false,
                     });
-                    staleCount++;
                 }
+                staleCount++;
             }
         }
         checks.push({
@@ -269,7 +202,6 @@ export class MonitorEngine {
         const seq = card.seq;
         await this.addLabelSafe(seq, 'STALE-RUNTIME');
         if (this.ctx.config.MONITOR_AUTO_QA) {
-            // Auto-move to QA
             try {
                 await this.taskBackend.move(seq, 'QA');
                 this.log.ok(`seq ${seq}: Auto-moved to QA (MONITOR_AUTO_QA=true)`);
@@ -294,7 +226,6 @@ export class MonitorEngine {
             }
         }
         else {
-            // Notify, wait for human
             await this.notifySafe(`seq:${seq} has a stale runtime — worker session dead but MR may exist`, 'warning');
             recommendedActions.push({
                 action: `Move seq:${seq} to QA or investigate stale runtime`,
@@ -312,7 +243,7 @@ export class MonitorEngine {
             });
         }
     }
-    // ─── Check 3: Timeout Detection (01 §10.2.4) ──────────────────
+    // ─── Check 3: Timeout Detection ───────────────────────────────
     async checkTimeouts(checks, actions, recommendedActions) {
         const state = readState(this.ctx.paths.stateFile, this.ctx.maxWorkers);
         const timeoutHours = this.ctx.config.INPROGRESS_TIMEOUT_HOURS;
@@ -332,12 +263,10 @@ export class MonitorEngine {
                 if (slotState.lastHeartbeat) {
                     const hbTime = new Date(slotState.lastHeartbeat).getTime();
                     const hbAge = (now - hbTime) / (1000 * 60 * 60);
-                    // If heartbeat is recent (within timeout window), skip
                     if (hbAge < timeoutHours)
                         continue;
                 }
             }
-            // Timed out
             this.log.warn(`seq ${seq}: Timed out (${elapsedHours.toFixed(1)}h > ${timeoutHours}h threshold)`);
             await this.addLabelSafe(seq, 'STALE-RUNTIME');
             await this.notifySafe(`seq:${seq} has exceeded timeout (${elapsedHours.toFixed(1)}h)`, 'warning');
@@ -369,7 +298,7 @@ export class MonitorEngine {
                 : 'No timeouts detected',
         });
     }
-    // ─── Check 4: Waiting Confirmation Detection (doc 12 §3) ──────
+    // ─── Check 4: Waiting Confirmation Detection (interactive mode) ─
     async checkWaitingConfirmation(checks, actions) {
         const state = readState(this.ctx.paths.stateFile, this.ctx.maxWorkers);
         let waitingCount = 0;
@@ -385,10 +314,8 @@ export class MonitorEngine {
                     continue;
                 const seq = slotState.seq != null ? String(slotState.seq) : slotName;
                 if (!waitResult.destructive) {
-                    // Non-destructive prompt → auto-confirm
                     this.log.info(`seq ${seq}: Worker waiting for non-destructive confirmation, auto-confirming`);
                     try {
-                        // Send Enter/y to confirm
                         await this.workerProvider.sendFix(slotState.tmuxSession, 'y');
                         actions.push({
                             action: 'auto-confirm',
@@ -410,7 +337,6 @@ export class MonitorEngine {
                     }
                 }
                 else {
-                    // Destructive prompt → label + notify
                     this.log.warn(`seq ${seq}: Worker waiting for destructive confirmation: ${waitResult.prompt}`);
                     if (slotState.seq != null) {
                         await this.addLabelSafe(String(slotState.seq), 'WAITING-CONFIRMATION');
@@ -442,9 +368,8 @@ export class MonitorEngine {
                 : 'No workers waiting for confirmation',
         });
     }
-    // ─── Check 5: BLOCKED Condition Check (01 §3.6.1) ─────────────
+    // ─── Check 5: BLOCKED Condition Check ─────────────────────────
     async checkBlockedCards(checks) {
-        // Collect cards from all active states that might have BLOCKED label
         const states = ['Backlog', 'Todo', 'Inprogress', 'QA'];
         let blockedCount = 0;
         for (const cardState of states) {
@@ -469,42 +394,21 @@ export class MonitorEngine {
                 : 'No blocked cards',
         });
     }
-    // ─── Check 6: State Alignment (07 §2.1) ───────────────────────
+    // ─── Check 6: State Alignment (Supervisor vs state.json) ──────
     async checkStateAlignment(checks, recommendedActions) {
         const state = readState(this.ctx.paths.stateFile, this.ctx.maxWorkers);
         const discrepancies = [];
         for (const [slotName, slotState] of Object.entries(state.workers)) {
-            if (slotState.status !== 'active' || !slotState.tmuxSession)
+            if (slotState.status !== 'active')
                 continue;
-            let alive;
-            if (slotState.mode === 'print') {
-                // Print mode: check PID directly
-                if (!slotState.pid)
-                    continue; // No PID yet, skip
-                try {
-                    process.kill(slotState.pid, 0);
-                    alive = true;
-                }
-                catch {
-                    alive = false;
-                }
+            const seq = slotState.seq != null ? String(slotState.seq) : '';
+            const workerId = `${this.ctx.projectName}:${slotName}:${seq}`;
+            const handle = this.supervisor.get(workerId);
+            if (!handle) {
+                discrepancies.push(`${slotName}: state says active but Supervisor has no handle`);
             }
-            else {
-                // Interactive mode: check tmux session
-                try {
-                    const inspection = await this.workerProvider.inspect(slotState.tmuxSession);
-                    alive = inspection.alive;
-                }
-                catch {
-                    discrepancies.push(`${slotName}: could not inspect session ${slotState.tmuxSession}`);
-                    continue;
-                }
-            }
-            if (!alive) {
-                const desc = slotState.mode === 'print'
-                    ? `pid ${slotState.pid} is dead`
-                    : `session ${slotState.tmuxSession} is dead`;
-                discrepancies.push(`${slotName}: state says active but ${desc}`);
+            else if (handle.exitCode !== null) {
+                discrepancies.push(`${slotName}: state says active but Supervisor reports exited (code=${handle.exitCode})`);
             }
         }
         if (discrepancies.length > 0) {
@@ -525,53 +429,28 @@ export class MonitorEngine {
             status: discrepancies.length > 0 ? 'warn' : 'pass',
             message: discrepancies.length > 0
                 ? `${discrepancies.length} state alignment discrepancy(ies)`
-                : 'State aligned with runtime',
+                : 'State aligned with Supervisor',
         });
     }
-    // ─── Check 0: Worker Health (print-mode auto-recovery) ────────
+    // ─── Check 7: Worker Health (launch/idle timeouts) ────────────
     async checkWorkerHealth(checks, actions) {
         const state = readState(this.ctx.paths.stateFile, this.ctx.maxWorkers);
         let issues = 0;
         for (const [slotName, slotState] of Object.entries(state.workers)) {
             if (slotState.status !== 'active' || slotState.mode !== 'print')
                 continue;
-            if (!slotState.pid || !slotState.outputFile || !slotState.claimedAt)
+            if (!slotState.outputFile || !slotState.claimedAt)
                 continue;
-            // Check if PID is alive
-            let pidAlive;
-            try {
-                process.kill(slotState.pid, 0);
-                pidAlive = true;
-            }
-            catch {
-                pidAlive = false;
-            }
-            if (!pidAlive) {
-                // PID dead — but check if the worker actually completed its task first
-                const completionStatus = await this.checkPrintWorkerCompletion(slotState);
-                if (completionStatus === 'COMPLETED') {
-                    this.log.ok(`Worker health: ${slotName} pid ${slotState.pid} is dead but task COMPLETED`);
-                    const handled = await this.handleCompletedWorker(slotName, slotState, state, actions);
-                    if (handled) {
-                        try {
-                            writeState(this.ctx.paths.stateFile, state, 'monitor-health-completed');
-                        }
-                        catch { /* logged */ }
-                        continue; // worker finished successfully
-                    }
-                    // Move-to-Done failed — fall through to auto-retry
-                    this.log.warn(`Worker health: ${slotName} completed but move-to-Done failed, will auto-retry`);
-                }
-                // Not completed → auto-retry
-                const seq = slotState.seq != null ? String(slotState.seq) : null;
-                if (seq) {
-                    this.log.warn(`Worker health: ${slotName} pid ${slotState.pid} is dead (status=${completionStatus}), auto-retrying seq ${seq}`);
-                    await this.autoRetry(seq, slotName, state, actions, 'Worker process died');
-                    issues++;
-                }
+            const seq = slotState.seq != null ? String(slotState.seq) : '';
+            const workerId = `${this.ctx.projectName}:${slotName}:${seq}`;
+            const handle = this.supervisor.get(workerId);
+            // If Supervisor doesn't track it, orphan check handles it
+            if (!handle)
                 continue;
-            }
-            // PID alive — check output health
+            // If worker already exited, Supervisor exit callback handles it
+            if (handle.exitCode !== null)
+                continue;
+            // Worker is alive — check output health
             const nowMs = Date.now();
             const claimedMs = new Date(slotState.claimedAt).getTime();
             const elapsedS = (nowMs - claimedMs) / 1000;
@@ -588,28 +467,22 @@ export class MonitorEngine {
             const launchTimeout = this.ctx.config.WORKER_LAUNCH_TIMEOUT_S;
             const idleTimeout = this.ctx.config.WORKER_IDLE_TIMEOUT_M * 60 * 1000;
             // Launch timeout: process alive but no output after N seconds
-            if (outputSize === 0 && elapsedS > launchTimeout) {
-                const seq = slotState.seq != null ? String(slotState.seq) : null;
-                if (seq) {
-                    this.log.warn(`Worker health: ${slotName} has no output after ${Math.round(elapsedS)}s, killing and retrying seq ${seq}`);
-                    this.killWorker(slotState.pid);
-                    await this.autoRetry(seq, slotName, state, actions, `No output after ${Math.round(elapsedS)}s`);
-                    issues++;
-                }
+            if (outputSize === 0 && elapsedS > launchTimeout && seq) {
+                this.log.warn(`Worker health: ${slotName} has no output after ${Math.round(elapsedS)}s, killing and retrying seq ${seq}`);
+                await this.supervisor.kill(workerId);
+                await this.autoRetry(seq, slotName, state, actions, `No output after ${Math.round(elapsedS)}s`);
+                issues++;
                 continue;
             }
             // Idle timeout: process alive but no new output for N minutes
-            if (outputSize > 0 && outputMtimeMs > 0) {
+            if (outputSize > 0 && outputMtimeMs > 0 && seq) {
                 const idleSinceMs = nowMs - outputMtimeMs;
                 if (idleSinceMs > idleTimeout) {
-                    const seq = slotState.seq != null ? String(slotState.seq) : null;
-                    if (seq) {
-                        const idleMin = Math.round(idleSinceMs / 60000);
-                        this.log.warn(`Worker health: ${slotName} no output for ${idleMin}min, killing and retrying seq ${seq}`);
-                        this.killWorker(slotState.pid);
-                        await this.autoRetry(seq, slotName, state, actions, `No output for ${idleMin}min`);
-                        issues++;
-                    }
+                    const idleMin = Math.round(idleSinceMs / 60000);
+                    this.log.warn(`Worker health: ${slotName} no output for ${idleMin}min, killing and retrying seq ${seq}`);
+                    await this.supervisor.kill(workerId);
+                    await this.autoRetry(seq, slotName, state, actions, `No output for ${idleMin}min`);
+                    issues++;
                 }
             }
         }
@@ -621,21 +494,9 @@ export class MonitorEngine {
                 : 'All active workers healthy',
         });
     }
-    killWorker(pid) {
-        try {
-            process.kill(pid, 'SIGTERM');
-        }
-        catch { /* already dead */ }
-        // Give it a moment, then force kill
-        try {
-            process.kill(pid, 0); // check alive
-            process.kill(pid, 'SIGKILL');
-        }
-        catch { /* dead */ }
-    }
+    // ─── Auto-retry ───────────────────────────────────────────────
     async autoRetry(seq, slotName, state, actions, reason) {
         const restartLimit = this.ctx.config.WORKER_RESTART_LIMIT;
-        // Get retry count from activeCards
         const activeCard = state.activeCards[seq];
         const retryCount = activeCard?.retryCount ?? 0;
         // Release the slot
@@ -655,12 +516,10 @@ export class MonitorEngine {
         };
         delete state.activeCards[seq];
         if (retryCount < restartLimit) {
-            // Move back to Todo for re-launch on next tick
             try {
                 await this.taskBackend.move(seq, 'Todo');
                 await this.removeLabelSafe(seq, 'CLAIMED');
                 await this.removeLabelSafe(seq, 'STALE-RUNTIME');
-                // Track retry count — store in a fresh activeCards entry
                 state.activeCards[seq] = {
                     seq: parseInt(seq, 10),
                     state: 'Todo',
@@ -714,94 +573,7 @@ export class MonitorEngine {
             this.logEvent('retry-exhausted', seq, 'ok', { retryCount, reason });
         }
     }
-    async removeLabelSafe(seq, label) {
-        try {
-            await this.taskBackend.removeLabel(seq, label);
-        }
-        catch { /* best effort */ }
-    }
-    // ─── Completion-aware helpers for dead print-mode workers ─────
-    /**
-     * Check if a dead print-mode worker actually completed its task.
-     * Uses workerProvider.detectCompleted() with the slot's session/branch info.
-     */
-    async checkPrintWorkerCompletion(slotState) {
-        if (!slotState.tmuxSession)
-            return 'DEAD';
-        const branch = slotState.branch || '';
-        const logDir = this.ctx.paths.logsDir;
-        try {
-            return await this.workerProvider.detectCompleted(slotState.tmuxSession, logDir, branch);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.debug(`detectCompleted failed for ${slotState.tmuxSession}: ${msg}`);
-            return 'DEAD';
-        }
-    }
-    /**
-     * Handle a dead print-mode worker that has been confirmed as COMPLETED.
-     * Mutates state in-place (releases slot, updates activeCards).
-     * Does NOT call writeState — caller is responsible for flushing state.
-     */
-    /**
-     * Handle a dead print-mode worker confirmed as COMPLETED.
-     * Returns true if card moved to Done + slot released (state mutated).
-     * Returns false if move failed (state NOT mutated, caller should not count as handled).
-     */
-    async handleCompletedWorker(slotName, slotState, state, actions) {
-        const seq = slotState.seq != null ? String(slotState.seq) : null;
-        if (!seq)
-            return false;
-        // 1. Move card to Done FIRST — if this fails, don't touch state
-        const targetState = 'Done';
-        try {
-            await this.taskBackend.move(seq, targetState);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            this.log.error(`seq ${seq}: Failed to move to ${targetState}: ${msg}. Slot NOT released.`);
-            actions.push({
-                action: 'complete',
-                entity: `seq:${seq}`,
-                result: 'fail',
-                message: `Move to ${targetState} failed: ${msg}`,
-            });
-            return false;
-        }
-        // 2. Done confirmed — now release slot + cleanup (mutate state)
-        state.workers[slotName] = {
-            status: 'idle', seq: null, branch: null, worktree: null,
-            tmuxSession: null, claimedAt: null, lastHeartbeat: null,
-            mode: null, sessionId: null, pid: null, outputFile: null, exitCode: null,
-        };
-        delete state.activeCards[seq];
-        try {
-            await this.taskBackend.releaseClaim(seq);
-        }
-        catch { /* best effort */ }
-        // 3. Mark worktree for cleanup
-        const branch = slotState.branch || '';
-        const worktreePath = slotState.worktree || '';
-        if (branch && worktreePath) {
-            const cleanup = state.worktreeCleanup ?? [];
-            if (!cleanup.some((e) => e.branch === branch)) {
-                cleanup.push({ branch, worktreePath, markedAt: new Date().toISOString() });
-                state.worktreeCleanup = cleanup;
-            }
-        }
-        this.log.ok(`seq ${seq}: Worker completed (detected by monitor), moved to ${targetState}`);
-        await this.notifySafe(`seq:${seq} worker completed, moved to ${targetState}`, 'success');
-        actions.push({
-            action: 'complete',
-            entity: `seq:${seq}`,
-            result: 'ok',
-            message: `Worker completed (PID dead, artifacts verified) → ${targetState}`,
-        });
-        this.logEvent('complete', seq, 'ok', { detectedBy: 'monitor' });
-        return true;
-    }
-    // ─── Helpers ───────────────────────────────────────────────────
+    // ─── Helpers ──────────────────────────────────────────────────
     buildBranchName(card) {
         const slug = card.name
             .toLowerCase()
@@ -819,6 +591,12 @@ export class MonitorEngine {
             this.log.error(`Failed to add label ${label} to seq ${seq}: ${msg}`);
         }
     }
+    async removeLabelSafe(seq, label) {
+        try {
+            await this.taskBackend.removeLabel(seq, label);
+        }
+        catch { /* best effort */ }
+    }
     async notifySafe(message, level) {
         if (!this.notifier)
             return;