@coralai/sps-cli 0.23.21 → 0.24.0

package/dist/manager/worker-manager-impl.js

@@ -0,0 +1,648 @@
+/**
+ * WorkerManagerImpl — concrete implementation of the WorkerManager interface.
+ *
+ * Wraps ProcessSupervisor, CompletionJudge, ResourceLimiter into the
+ * unified ACP interface. PM operations are delegated to SPSEventHandler
+ * via the event system (Phase 3 refactor).
+ *
+ * Phase 4: recover() fully implemented with decision matrix from doc-09 §11.3.
+ */
+import { execFileSync } from 'node:child_process';
+import { readState, writeState, createIdleWorkerSlot } from '../core/state.js';
+import { IntegrationQueue } from './integration-queue.js';
+// ─── Timeout Defaults ──────────────────────────────────────────
+const DEFAULT_TIMEOUTS = {
+    startupSec: 60, // 60s for worker to start
+    developmentSec: 4 * 3600, // 4h for development
+    integrationSec: 3600, // 1h for integration
+    inputWaitSec: 1800, // 30min waiting for input
+    forceMultiplier: 1.5, // Hard kill at 1.5x timeout
+};
+// ─── Implementation ────────────────────────────────────────────
+export class WorkerManagerImpl {
+    supervisor;
+    completionJudge;
+    resourceLimiter;
+    agentRuntime;
+    stateFile;
+    maxWorkers;
+    integrationQueue;
+    eventHandlers = [];
+    taskSlotMap = new Map();
+    timeouts = new Map();
+    constructor(deps) {
+        this.supervisor = deps.supervisor;
+        this.completionJudge = deps.completionJudge;
+        this.resourceLimiter = deps.resourceLimiter;
+        this.agentRuntime = deps.agentRuntime;
+        this.stateFile = deps.stateFile;
+        this.maxWorkers = deps.maxWorkers;
+        this.integrationQueue = deps.integrationQueue ?? new IntegrationQueue(deps.stateFile, deps.maxWorkers);
+    }
+    // ─── run / resume ────────────────────────────────────────────
+    async run(request) {
+        return this.acquireAndSpawn({
+            taskId: request.taskId, cardId: request.cardId, project: request.project,
+            phase: request.phase, prompt: request.prompt, cwd: request.cwd,
+            branch: request.branch, targetBranch: request.targetBranch,
+            tool: request.tool, transport: request.transport,
+            outputFile: request.outputFile, maxRetries: request.maxRetries ?? 0,
+            customTimeoutSec: request.timeoutSec,
+        }, 'wm-run');
+    }
+    async resume(request) {
+        return this.acquireAndSpawn({
+            taskId: request.taskId, cardId: request.cardId, project: request.project,
+            phase: request.phase, prompt: request.prompt, cwd: request.cwd,
+            branch: request.branch, targetBranch: request.targetBranch,
+            tool: request.tool, transport: request.transport,
+            outputFile: request.outputFile, maxRetries: 0,
+            resumeSessionId: request.sessionId,
+        }, 'wm-resume');
+    }
+    // ─── cancel ──────────────────────────────────────────────────
+    async cancel(request) {
+        const { taskId, project, reason } = request;
+        // ── Check if the task is queued (not yet spawned) ───────────
+        const queuePos = this.integrationQueue.getPosition(taskId);
+        if (queuePos > 0) {
+            // Task is in waiting list — remove without killing any worker
+            this.integrationQueue.remove(taskId);
+            this.emitEvent({
+                type: 'run.failed', taskId, cardId: taskId, project,
+                phase: 'integration', slot: '', workerId: '',
+                timestamp: new Date().toISOString(), state: 'failed',
+                error: `Cancelled from queue (position=${queuePos}): ${reason}`,
+            });
+            this.log(`Removed queued task ${taskId} from integration queue (reason=${reason})`);
+            return;
+        }
+        const slot = this.taskSlotMap.get(taskId);
+        if (!slot) {
+            this.log(`Cancel: task ${taskId} not found`);
+            return;
+        }
+        // Determine phase from lease to know if we need to advance queue
+        const lease = this.rd().leases[taskId];
+        const isIntegration = lease
+            ? (lease.pmStateObserved === 'QA' || lease.phase === 'merging' || lease.phase === 'resolving_conflict')
+            : queuePos === 0;
+        this.clearTimeoutForTask(taskId);
+        const workerId = `${project}:${slot}:${taskId}`;
+        await this.supervisor.kill(workerId);
+        this.releaseSlotInState(slot, taskId);
+        this.resourceLimiter.release();
+        this.taskSlotMap.delete(taskId);
+        this.emitEvent({
+            type: 'run.failed', taskId, cardId: taskId, project,
+            phase: isIntegration ? 'integration' : 'development', slot, workerId,
+            timestamp: new Date().toISOString(), state: 'failed',
+            error: `Cancelled: ${reason}`,
+        });
+        this.log(`Cancelled worker ${workerId} (reason=${reason})`);
+        // ── If active integration worker was cancelled, advance queue ─
+        if (isIntegration) {
+            const targetBranch = lease?.branch ?? 'main';
+            // Find the actual targetBranch from the queue active entry
+            const state = this.rd();
+            let actualTarget = targetBranch;
+            for (const [key, q] of Object.entries(state.integrationQueues)) {
+                if (q.active?.taskId === taskId) {
+                    actualTarget = key.split(':').slice(1).join(':');
+                    break;
+                }
+            }
+            await this.advanceIntegrationQueue(project, actualTarget);
+        }
+    }
+    // ─── inspect ─────────────────────────────────────────────────
+    inspect(query) {
+        const state = this.rd();
+        const snapshots = [];
+        for (const [slotName, worker] of Object.entries(state.workers)) {
+            if (query.slot && query.slot !== slotName)
+                continue;
+            if (query.taskId && worker.seq !== null && String(worker.seq) !== query.taskId)
+                continue;
+            const seq = worker.seq !== null ? String(worker.seq) : null;
+            const activeCard = seq ? state.activeCards[seq] ?? null : null;
+            const lease = seq ? state.leases[seq] ?? null : null;
+            snapshots.push({
+                slot: slotName, taskId: seq,
+                cardId: activeCard ? String(activeCard.seq) : seq,
+                project: query.project ?? '',
+                state: this.mapWorkerState(worker),
+                phase: lease ? (lease.phase === 'merging' || lease.phase === 'resolving_conflict' ? 'integration' : 'development') : null,
+                pid: worker.pid ?? null, sessionId: worker.sessionId ?? null,
+                cwd: worker.worktree, branch: worker.branch,
+                startedAt: worker.claimedAt,
+                updatedAt: worker.lastHeartbeat ?? worker.claimedAt ?? new Date().toISOString(),
+                outputTail: null, pendingInput: null,
+            });
+        }
+        return snapshots;
+    }
+    onEvent(handler) { this.eventHandlers.push(handler); }
+    // ─── sendInput / confirm ─────────────────────────────────────
+    async sendInput(request) {
+        const slot = this.requirePtySlot(request.taskId, 'sendInput');
+        await this.agentRuntime.resumeRun(slot, request.input);
+        this.log(`Sent input to task ${request.taskId} in ${slot}`);
+    }
+    async confirm(request) {
+        const slot = this.requirePtySlot(request.taskId, 'confirm');
+        const input = request.action === 'confirm' ? (request.message ?? 'yes') : (request.message ?? 'no');
+        await this.agentRuntime.resumeRun(slot, input);
+        this.log(`Confirmed (${request.action}) task ${request.taskId} in ${slot}`);
+    }
+    // ─── recover (Phase 4 — full decision matrix from doc-09 §11.3) ──
+    async recover(contexts) {
+        const result = {
+            scanned: 0, alive: 0, completed: 0, failed: 0,
+            released: 0, rebuilt: 0, queueRebuilt: 0, events: [],
+        };
+        // Phase 1+2: Scan leases and apply per-task decision matrix
+        for (const ctx of contexts) {
+            const state = readState(ctx.stateFile, this.maxWorkers);
+            for (const [seq, lease] of Object.entries(state.leases)) {
+                if (lease.phase === 'released' || lease.phase === 'suspended')
+                    continue;
+                result.scanned++;
+                const slot = lease.slot;
+                const worker = slot ? state.workers[slot] ?? null : null;
+                const pid = worker?.pid ?? null;
+                const isAlive = pid ? this.isPidAlive(pid) : false;
+                const evidence = state.worktreeEvidence[seq] ?? null;
+                const pmState = lease.pmStateObserved;
+                // R8/R9: PM manually completed or reverted — release immediately
+                if (pmState === 'Done' || pmState === 'Backlog' || pmState === 'Todo') {
+                    if (slot)
+                        this.releaseSlotInState(slot, seq);
+                    result.released++;
+                    this.log(`Recovery R8/R9: task ${seq} PM state=${pmState}, released`);
+                    continue;
+                }
+                // R1: Worker still running — re-attach orphan PID monitoring
+                if (isAlive && pid && slot) {
+                    this.recoverAliveWorker(ctx, seq, lease, slot, pid);
+                    result.alive++;
+                    continue;
+                }
+                // Dead worker — check git evidence for decision
+                const event = this.judgeDeadWorker(ctx, seq, lease, slot, evidence);
+                if (event) {
+                    result.events.push(event);
+                    if (event.type === 'run.completed')
+                        result.completed++;
+                    else
+                        result.failed++;
+                }
+                else {
+                    // Released (R7: worktree missing or fallback)
+                    result.released++;
+                }
+            }
+            // Phase 3: Rebuild integration queues from merging/resolving leases
+            this.rebuildIntegrationQueue(ctx, state, result);
+        }
+        // Phase 4: Emit collected events so SPSEventHandler processes them
+        for (const event of result.events) {
+            this.emitEvent(event);
+        }
+        if (result.scanned > 0) {
+            this.log(`Recovery complete: scanned=${result.scanned} alive=${result.alive} ` +
+                `completed=${result.completed} failed=${result.failed} ` +
+                `released=${result.released} rebuilt=${result.rebuilt} queueRebuilt=${result.queueRebuilt}`);
+        }
+        return result;
+    }
+    // ─── Private: Unified acquire + spawn flow ───────────────────
+    async acquireAndSpawn(ctx, label) {
+        const { taskId, cardId, project, phase, prompt, cwd, branch, targetBranch, tool, transport, outputFile, maxRetries, resumeSessionId } = ctx;
+        if (this.taskSlotMap.has(taskId)) {
+            this.log(`Duplicate task ${taskId}, already in slot ${this.taskSlotMap.get(taskId)}`);
+            return this.reject('duplicate_task');
+        }
+        // ── Integration queue gate ──────────────────────────────────
+        if (phase === 'integration') {
+            const entry = {
+                taskId, cardId, project, prompt, cwd, branch, targetBranch,
+                tool, transport, outputFile, enqueuedAt: new Date().toISOString(),
+            };
+            const active = this.integrationQueue.getActive(project, targetBranch);
+            if (active) {
+                const { position } = this.integrationQueue.enqueue(entry);
+                this.log(`Integration task ${taskId} queued at position ${position} (active=${active.taskId})`);
+                return { accepted: true, queued: true, queuePosition: position, slot: null, workerId: null };
+            }
+            // No active — register as active before spawning
+            this.integrationQueue.enqueue(entry);
+        }
+        if (!this.resourceLimiter.tryAcquire()) {
+            this.log(`Resource exhausted for task ${taskId}`);
+            // If we just registered as active in the queue, roll back
+            if (phase === 'integration') {
+                this.integrationQueue.dequeueNext(project, targetBranch);
+            }
+            return this.reject('resource_exhausted');
+        }
+        const state = this.rd();
+        const slot = this.findIdleSlot(state);
+        if (!slot) {
+            this.resourceLimiter.release();
+            if (phase === 'integration') {
+                this.integrationQueue.dequeueNext(project, targetBranch);
+            }
+            this.log(`No idle slot for task ${taskId}`);
+            return this.reject('resource_exhausted');
+        }
+        await this.resourceLimiter.enforceStagger();
+        const nowIso = new Date().toISOString();
+        this.claimSlot(state, slot, { seq: taskId, cardId, project, phase, branch, cwd, tool, transport, outputFile, nowIso, targetBranch });
+        this.wr(state, label);
+        this.taskSlotMap.set(taskId, slot);
+        const workerId = `${project}:${slot}:${taskId}`;
+        let pid = null;
+        let sessionId;
+        try {
+            if (transport === 'proc') {
+                const handle = this.supervisor.spawn({
+                    id: workerId, project, seq: taskId, slot, worktree: cwd, branch,
+                    prompt, outputFile, tool, resumeSessionId,
+                    onExit: (exitCode) => this.handleExit({
+                        workerId, taskId, cardId, project, phase, slot, branch, cwd,
+                        targetBranch, outputFile, tool, transport, exitCode, maxRetries,
+                    }),
+                });
+                pid = handle.pid;
+                sessionId = handle.sessionId ?? undefined;
+            }
+            else if (transport === 'pty') {
+                if (!this.agentRuntime) {
+                    throw new Error('PTY transport requires agentRuntime');
+                }
+                const session = resumeSessionId
+                    ? await this.agentRuntime.resumeRun(slot, prompt)
+                    : await this.agentRuntime.startRun(slot, prompt, tool, cwd);
+                sessionId = session.sessionId;
+                pid = session.pid ?? null;
+            }
+        }
+        catch (err) {
+            this.log(`Spawn failed for ${taskId}: ${err instanceof Error ? err.message : String(err)}`);
+            this.resourceLimiter.release();
+            this.releaseSlotInState(slot, taskId);
+            this.taskSlotMap.delete(taskId);
+            if (phase === 'integration') {
+                this.integrationQueue.remove(taskId);
+                await this.advanceIntegrationQueue(project, targetBranch);
+            }
+            this.emitEvent({
+                type: 'run.failed', taskId, cardId, project, phase, slot, workerId,
+                timestamp: new Date().toISOString(), state: 'failed',
+                error: `Spawn failed: ${err instanceof Error ? err.message : String(err)}`,
+            });
+            return this.reject('spawn_failed');
+        }
+        this.log(`Launched ${transport}/${tool} worker ${workerId} in ${slot} (pid=${pid})`);
+        this.startTimeout(taskId, phase, project, slot, ctx.customTimeoutSec);
+        return { accepted: true, slot, workerId, pid: pid ?? undefined, sessionId };
+    }
+    // ─── Private: Exit Handler ───────────────────────────────────
+    async handleExit(ctx) {
+        const { workerId, taskId, cardId, project, phase, slot, branch, cwd, targetBranch, outputFile, tool, transport, exitCode, maxRetries } = ctx;
+        this.clearTimeoutForTask(taskId);
+        this.log(`Worker ${workerId} exited with code ${exitCode}`);
+        const completion = this.completionJudge.judge({
+            worktree: cwd, branch, baseBranch: targetBranch, outputFile, exitCode, phase,
+        });
+        this.log(`CompletionJudge for ${workerId}: ${completion.status} (${completion.reason})`);
+        const isComplete = completion.status === 'completed';
+        // Emit event — SPSEventHandler handles PM operations, slot release, notifications
+        this.emitEvent({
+            type: isComplete ? 'run.completed' : 'run.failed',
+            taskId, cardId, project, phase, slot, workerId,
+            timestamp: new Date().toISOString(),
+            state: isComplete ? 'completed' : 'failed',
+            exitCode, completionResult: completion,
+        });
+        // Release supervisor handle and resource limiter slot
+        this.supervisor.remove(workerId);
+        this.resourceLimiter.release();
+        this.taskSlotMap.delete(taskId);
+        // ── Auto-dequeue next integration task ──────────────────────
+        if (phase === 'integration') {
+            await this.advanceIntegrationQueue(project, targetBranch);
+        }
+    }
+    /**
+     * Try to spawn the next queued integration task.
+     * On spawn failure, skip and try the next entry — never deadlock.
+     */
+    async advanceIntegrationQueue(project, targetBranch) {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const next = this.integrationQueue.dequeueNext(project, targetBranch);
+            if (!next) {
+                this.log(`Integration queue empty for ${project}:${targetBranch}`);
+                return;
+            }
+            this.log(`Auto-dequeuing integration task ${next.taskId} for ${project}:${targetBranch}`);
+            // Skip entries with empty prompt (recovery stubs — SPS must re-prepare)
+            if (!next.prompt) {
+                this.log(`Skipping ${next.taskId}: empty prompt (needs SPS re-preparation)`);
+                this.emitEvent({
+                    type: 'run.failed', taskId: next.taskId, cardId: next.cardId, project,
+                    phase: 'integration', slot: '', workerId: '',
+                    timestamp: new Date().toISOString(), state: 'failed',
+                    error: 'Empty prompt — needs SPS re-preparation after recovery',
+                });
+                continue;
+            }
+            try {
+                const resp = await this.acquireAndSpawn({
+                    taskId: next.taskId, cardId: next.cardId, project,
+                    phase: 'integration', prompt: next.prompt, cwd: next.cwd,
+                    branch: next.branch, targetBranch: next.targetBranch,
+                    tool: next.tool, transport: next.transport,
+                    outputFile: next.outputFile, maxRetries: 0,
+                }, 'wm-iq-dequeue');
+                if (resp.accepted && !resp.queued) {
+                    this.log(`Integration task ${next.taskId} spawned after dequeue`);
+                    return;
+                }
+                // If accepted but re-queued, something odd — keep going
+                this.log(`Integration task ${next.taskId} could not spawn (accepted=${resp.accepted}), trying next`);
+            }
+            catch (err) {
+                this.log(`Failed to spawn dequeued task ${next.taskId}: ${err instanceof Error ? err.message : String(err)}`);
+                // Emit failure event so SPS knows this task was dropped
+                this.emitEvent({
+                    type: 'run.failed', taskId: next.taskId, cardId: next.cardId, project,
+                    phase: 'integration', slot: '', workerId: '',
+                    timestamp: new Date().toISOString(), state: 'failed',
+                    error: `Dequeue spawn failed: ${err instanceof Error ? err.message : String(err)}`,
+                });
+                // Continue to next entry — never deadlock
+            }
+        }
+    }
+    // ─── Private: Recovery Helpers ────────────────────────────────
+    /**
+     * R1: Worker PID is still alive — re-attach orphan monitoring.
+     */
+    recoverAliveWorker(ctx, seq, lease, slot, pid) {
+        const workerId = `${ctx.project}:${slot}:${seq}`;
+        const phase = (lease.phase === 'merging' || lease.phase === 'resolving_conflict')
+            ? 'integration' : 'development';
+        this.resourceLimiter.tryAcquire();
+        this.supervisor.monitorOrphanPid(workerId, pid, {
+            id: workerId, transport: 'proc', pid,
+            outputFile: null, project: ctx.project, seq, slot,
+            branch: lease.branch ?? '', worktree: lease.worktree ?? '',
+            tool: 'claude', exitCode: null, sessionId: lease.sessionId ?? null,
+            runId: lease.runId ?? null, sessionState: null, remoteStatus: null,
+            lastEventAt: null,
+            startedAt: lease.claimedAt ?? new Date().toISOString(),
+            exitedAt: null,
+        }, (exitCode) => this.handleExit({
+            workerId, taskId: seq, cardId: seq, project: ctx.project,
+            phase, slot, branch: lease.branch ?? '',
+            cwd: lease.worktree ?? '', targetBranch: ctx.baseBranch,
+            outputFile: '', tool: 'claude', transport: 'proc',
+            exitCode, maxRetries: 0,
+        }));
+        this.taskSlotMap.set(seq, slot);
+        this.log(`Recovery R1: task ${seq} alive (pid=${pid}), re-attached monitor`);
+    }
+    /**
+     * Decision matrix for dead workers (R2-R7).
+     * Returns a WorkerEvent for completed/failed, or null if slot was released.
+     */
+    judgeDeadWorker(ctx, seq, lease, slot, evidence) {
+        const phase = (lease.phase === 'merging' || lease.phase === 'resolving_conflict')
+            ? 'integration' : 'development';
+        const workerId = `${ctx.project}:${slot ?? 'unknown'}:${seq}`;
+        // R2: Branch merged into base — task complete
+        if (evidence?.mergedToBase) {
+            this.log(`Recovery R2: task ${seq} branch merged to base`);
+            return this.makeRecoveryEvent('run.completed', seq, ctx, slot ?? '', phase, workerId, 'already_merged');
+        }
+        // R3: Pushed with commits ahead — development complete
+        if (evidence?.pushed && evidence.aheadOfBase > 0) {
+            this.log(`Recovery R3: task ${seq} pushed with ${evidence.aheadOfBase} commits ahead`);
+            return this.makeRecoveryEvent('run.completed', seq, ctx, slot ?? '', phase, workerId, 'branch_pushed');
+        }
+        // R4: Local commits unpushed — rescue push, then fail for restart
+        if (!evidence?.pushed && evidence && evidence.aheadOfBase > 0) {
+            if (lease.worktree && lease.branch) {
+                const rescued = this.rescuePush(lease.worktree, lease.branch);
+                if (rescued)
+                    this.log(`Recovery R4: rescued push for task ${seq}`);
+            }
+            return this.makeRecoveryEvent('run.failed', seq, ctx, slot ?? '', phase, workerId, 'needs_restart');
+        }
+        // R5: Dirty state (rebase/merge/conflict) — rescue push, then fail
+        if (evidence && ['rebase', 'merge', 'conflict'].includes(evidence.gitStatus)) {
+            if (lease.worktree && lease.branch) {
+                const rescued = this.rescuePush(lease.worktree, lease.branch);
+                if (rescued)
+                    this.log(`Recovery R5: rescued push for task ${seq} (dirty=${evidence.gitStatus})`);
+            }
+            return this.makeRecoveryEvent('run.failed', seq, ctx, slot ?? '', phase, workerId, 'needs_restart');
+        }
+        // R7: Worktree missing — release slot, SPS re-prepares
+        if (evidence && !evidence.worktreeExists) {
+            if (slot)
+                this.releaseSlotInState(slot, seq);
+            this.log(`Recovery R7: task ${seq} worktree missing, released`);
+            return null;
+        }
+        // R6: No changes (fallback) — failed with no artifacts
+        this.log(`Recovery R6: task ${seq} no artifacts found`);
+        return this.makeRecoveryEvent('run.failed', seq, ctx, slot ?? '', phase, workerId, 'no_artifacts');
+    }
+    /**
+     * Rebuild integration queue from leases in merging/resolving_conflict phase.
+     */
+    rebuildIntegrationQueue(ctx, state, result) {
+        const qaLeases = Object.entries(state.leases)
+            .filter(([, l]) => l.phase === 'merging' || l.phase === 'resolving_conflict')
+            .sort(([, a], [, b]) => (a.lastTransitionAt ?? '').localeCompare(b.lastTransitionAt ?? ''));
+        for (const [seq, lease] of qaLeases) {
+            this.integrationQueue.enqueue({
+                taskId: seq, cardId: seq, project: ctx.project,
+                prompt: '', // Prompt will be regenerated by SPS
+                cwd: lease.worktree ?? '', branch: lease.branch ?? '',
+                targetBranch: ctx.baseBranch, tool: 'claude', transport: 'proc',
+                outputFile: '', enqueuedAt: lease.lastTransitionAt,
+            });
+            result.queueRebuilt++;
+        }
+        if (qaLeases.length > 0) {
+            this.log(`Recovery: rebuilt ${qaLeases.length} integration queue entries for ${ctx.project}`);
+        }
+    }
+    /**
+     * Create a WorkerEvent for recovery results.
+     */
+    makeRecoveryEvent(type, seq, ctx, slot, phase, workerId, reason) {
+        return {
+            type, taskId: seq, cardId: seq, project: ctx.project,
+            phase, slot, workerId,
+            timestamp: new Date().toISOString(),
+            state: type === 'run.completed' ? 'completed' : 'failed',
+            completionResult: {
+                status: type === 'run.completed' ? 'completed' : 'failed',
+                reason,
+            },
+        };
+    }
+    /**
+     * Try to push unpushed commits from a worktree as a rescue operation.
+     */
+    rescuePush(worktree, branch) {
+        try {
+            execFileSync('git', ['-C', worktree, 'push', 'origin', branch], {
+                timeout: 30_000,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            return true;
+        }
+        catch {
+            this.log(`Rescue push failed for ${branch} in ${worktree}`);
+            return false;
+        }
+    }
+    /**
+     * Check if a process is still alive by sending signal 0.
+     */
+    isPidAlive(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ─── Private: State Helpers ──────────────────────────────────
+    rd() { return readState(this.stateFile, this.maxWorkers); }
+    wr(state, by) { writeState(this.stateFile, state, by); }
+    findIdleSlot(state) {
+        return Object.entries(state.workers).find(([, w]) => w.status === 'idle')?.[0] ?? null;
+    }
+    claimSlot(state, slot, ctx) {
+        const seqNum = parseInt(ctx.seq, 10) || 0;
+        state.workers[slot] = {
+            ...createIdleWorkerSlot(), status: 'active', seq: seqNum,
+            branch: ctx.branch, worktree: ctx.cwd, claimedAt: ctx.nowIso, lastHeartbeat: ctx.nowIso,
+            mode: ctx.transport === 'pty' ? 'pty' : 'print', transport: ctx.transport, agent: ctx.tool,
+            outputFile: ctx.transport === 'proc' ? ctx.outputFile : null,
+        };
+        state.activeCards[ctx.seq] = {
+            seq: seqNum, state: 'Inprogress', worker: slot, mrUrl: null,
+            conflictDomains: [], startedAt: ctx.nowIso, retryCount: 0,
+        };
+        state.leases[ctx.seq] = {
+            seq: seqNum, pmStateObserved: ctx.phase === 'integration' ? 'QA' : 'Inprogress',
+            phase: 'coding', slot, branch: ctx.branch, worktree: ctx.cwd,
+            sessionId: null, runId: null, claimedAt: ctx.nowIso, retryCount: 0,
+            lastTransitionAt: ctx.nowIso,
+        };
+    }
+    releaseSlotInState(slot, taskId) {
+        const state = this.rd();
+        state.workers[slot] = createIdleWorkerSlot();
+        delete state.activeCards[taskId];
+        delete state.leases[taskId];
+        this.wr(state, 'wm-release');
+    }
+    mapWorkerState(w) {
+        if (w.status === 'idle')
+            return 'idle';
+        if (w.status === 'active') {
+            if (w.remoteStatus === 'waiting_input')
+                return 'waiting_input';
+            if (w.remoteStatus === 'needs_confirmation' || w.sessionState === 'needs_confirmation')
+                return 'needs_confirmation';
+            if (w.remoteStatus === 'completed')
+                return 'completed';
+            if (w.remoteStatus === 'failed')
+                return 'failed';
+            return 'running';
+        }
+        if (w.status === 'releasing')
+            return 'completed';
+        return 'running';
+    }
+    requirePtySlot(taskId, op) {
+        const slot = this.taskSlotMap.get(taskId);
+        if (!slot)
+            throw new Error(`Task ${taskId} not found`);
+        if (!this.agentRuntime)
+            throw new Error(`${op} requires PTY transport (agentRuntime not available)`);
+        const state = this.rd();
+        const w = state.workers[slot];
+        if (!w || (w.transport !== 'pty' && w.mode !== 'pty')) {
+            throw new Error(`${op} unsupported for transport=${w?.transport ?? 'unknown'}`);
+        }
+        return slot;
+    }
+    // ─── Private: Timeout Management ─────────────────────────────
+    startTimeout(taskId, phase, project, slot, customTimeoutSec) {
+        const baseSec = customTimeoutSec ?? (phase === 'integration' ? DEFAULT_TIMEOUTS.integrationSec : DEFAULT_TIMEOUTS.developmentSec);
+        const hardSec = Math.ceil(baseSec * DEFAULT_TIMEOUTS.forceMultiplier);
+        const workerId = `${project}:${slot}:${taskId}`;
+        const softTimer = setTimeout(() => {
+            this.emitEvent({
+                type: 'status.update', taskId, cardId: taskId, project, phase, slot,
+                workerId, timestamp: new Date().toISOString(), state: 'running',
+                error: `Timeout: exceeded ${baseSec}s`,
+            });
+            this.log(`Soft timeout for ${taskId} after ${baseSec}s`);
+            // Hard timeout — force kill (wrapped in try-catch to prevent unhandled rejection)
+            const hardTimer = setTimeout(async () => {
+                try {
+                    this.log(`Hard timeout for ${taskId} after ${hardSec}s — force killing`);
+                    await this.cancel({ taskId, project, reason: 'timeout' });
+                }
+                catch (err) {
+                    this.log(`Hard timeout cancel failed for ${taskId}: ${err instanceof Error ? err.message : err}`);
+                }
+            }, (hardSec - baseSec) * 1000);
+            hardTimer.unref();
+            this.timeouts.set(`${taskId}:hard`, hardTimer);
+        }, baseSec * 1000);
+        softTimer.unref();
+        this.timeouts.set(taskId, softTimer);
+    }
+    clearTimeoutForTask(taskId) {
+        const soft = this.timeouts.get(taskId);
+        const hard = this.timeouts.get(`${taskId}:hard`);
+        if (soft) {
+            clearTimeout(soft);
+            this.timeouts.delete(taskId);
+        }
+        if (hard) {
+            clearTimeout(hard);
+            this.timeouts.delete(`${taskId}:hard`);
+        }
+    }
+    // ─── Private: Event + Response Helpers ───────────────────────
+    emitEvent(event) {
+        for (const handler of this.eventHandlers) {
+            try {
+                handler(event);
+            }
+            catch (err) {
+                this.log(`Event handler error: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    reject(reason) {
+        return { accepted: false, slot: null, workerId: null, rejectReason: reason };
+    }
+    log(msg) { process.stderr.write(`[worker-manager] ${msg}\n`); }
+}
+//# sourceMappingURL=worker-manager-impl.js.map