hungry-ghost-hive 0.43.0 → 0.43.2

package/dist/cli/commands/manager/index.js

@@ -2,33 +2,24 @@
 import chalk from 'chalk';
 import { Command } from 'commander';
 import { createHash } from 'crypto';
-import { execa } from 'execa';
 import { join } from 'path';
-import { getCliRuntimeBuilder, resolveRuntimeModelForCli } from '../../../cli-runtimes/index.js';
 import { ClusterRuntime, fetchLocalClusterStatus } from '../../../cluster/runtime.js';
 import { loadConfig } from '../../../config/loader.js';
-import { syncFromProvider, syncStatusForStory, } from '../../../connectors/project-management/operations.js';
+import { syncFromProvider } from '../../../connectors/project-management/operations.js';
 import { queryAll, queryOne, withTransaction } from '../../../db/client.js';
 import { acquireLock } from '../../../db/lock.js';
-import { getAgentById, getAgentsByType, getAllAgents, updateAgent, } from '../../../db/queries/agents.js';
-import { createEscalation, getActiveEscalationsForAgent, getPendingEscalations, updateEscalation, } from '../../../db/queries/escalations.js';
+import { getAgentById, getAllAgents } from '../../../db/queries/agents.js';
+import { getPendingEscalations, updateEscalation } from '../../../db/queries/escalations.js';
 import { createLog } from '../../../db/queries/logs.js';
 import { getAllPendingMessages, markMessagesRead, } from '../../../db/queries/messages.js';
-import { backfillGithubPrNumbers, createPullRequest, getMergeQueue, getOpenPullRequestsByStory, getPullRequestsByStatus, updatePullRequest, } from '../../../db/queries/pull-requests.js';
-import { getRequirementsByStatus } from '../../../db/queries/requirements.js';
-import { getStoriesByStatus, getStoryById, updateStory } from '../../../db/queries/stories.js';
-import { getAllTeams } from '../../../db/queries/teams.js';
-import { getPullRequestComments, getPullRequestReviews } from '../../../git/github.js';
+import { backfillGithubPrNumbers } from '../../../db/queries/pull-requests.js';
+import { getStoryById } from '../../../db/queries/stories.js';
 import { Scheduler } from '../../../orchestrator/scheduler.js';
 import { AgentState } from '../../../state-detectors/types.js';
-import { captureTmuxPane, getHiveSessions, isManagerRunning, isTmuxSessionRunning, killTmuxSession, sendToTmuxSession, spawnTmuxSession, stopManager as stopManagerSession, } from '../../../tmux/manager.js';
+import { captureTmuxPane, getHiveSessions, isManagerRunning, isTmuxSessionRunning, killTmuxSession, stopManager as stopManagerSession, } from '../../../tmux/manager.js';
 import { autoMergeApprovedPRs } from '../../../utils/auto-merge.js';
-import { findHiveRoot as findHiveRootFromDir, getHivePaths } from '../../../utils/paths.js';
-import { fetchOpenGitHubPRs, getExistingPRIdentifiers, ghRepoSlug, } from '../../../utils/pr-sync.js';
-import { extractStoryIdFromBranch } from '../../../utils/story-id.js';
 import { withHiveContext, withHiveRoot } from '../../../utils/with-hive-context.js';
-import { generateTechLeadPrompt } from '../req.js';
-import { agentStates, createManagerNudgeEnvelope, detectAgentState, enforceBypassMode, forwardMessages, getAgentSafetyMode, handlePermissionPrompt, handlePlanApproval, nudgeAgent, submitManagerNudgeWithVerification, updateAgentStateTracking, } from './agent-monitoring.js';
+import { agentStates, detectAgentState, enforceBypassMode, forwardMessages, getAgentSafetyMode, handlePermissionPrompt, handlePlanApproval, nudgeAgent, updateAgentStateTracking, } from './agent-monitoring.js';
 import { spawnAuditorIfNeeded } from './auditor-lifecycle.js';
 import { autoAssignPlannedStories } from './auto-assignment.js';
 import { assessCompletionFromOutput } from './done-intelligence.js';
@@ -36,21 +27,21 @@ import { handleEscalationAndNudge } from './escalation-handler.js';
 import { checkFeatureSignOff } from './feature-sign-off.js';
 import { checkFeatureTestResult } from './feature-test-result.js';
 import { handleStalledPlanningHandoff } from './handoff-recovery.js';
-import { cleanupAgentsReferencingMergedStory } from './merged-story-cleanup.js';
+import { formatDuration, getMaxStuckNudgesPerStory, getScreenStaticInactivityThresholdMs, sendManagerNudge, verboseLog, verboseLogCtx, } from './manager-utils.js';
 import { shouldAutoResolveOrphanedManagerEscalation } from './orphaned-escalations.js';
-import { isTechLeadRestartOnCooldown } from './restart-cooldown.js';
-import { findSessionForAgent } from './session-resolution.js';
+import { closeStalePRs, reconcileAgentsOnMergedStories, recoverStaleReviewingPRs, syncMergedPRs, syncOpenPRs, } from './pr-sync-orchestrator.js';
+import { autoRejectCommentOnlyReviews, handleRejectedPRs, notifyQAOfQueuedPRs, } from './qa-review-handler.js';
 import { spinDownIdleAgents, spinDownMergedAgents } from './spin-down.js';
 import { findStaleSessionEscalations } from './stale-escalations.js';
+import { applyHumanInterventionStateOverride, clearHumanIntervention, isClassifierTimeoutReason, markClassifierTimeoutForHumanIntervention, markDoneFalseForHumanIntervention, screenStaticBySession, } from './stuck-story-helpers.js';
+import { autoProgressDoneStory, nudgeQAFailedStories, nudgeStuckStories, recoverUnassignedQAFailedStories, } from './stuck-story-processor.js';
+import { restartStaleTechLead } from './tech-lead-lifecycle.js';
 import { MANAGER_NUDGE_END_MARKER, MANAGER_NUDGE_START_MARKER, TMUX_CAPTURE_LINES, TMUX_CAPTURE_LINES_SHORT, } from './types.js';
+// Re-export functions that moved to submodules (preserves public API for tests/consumers)
+export { autoRejectCommentOnlyReviews } from './qa-review-handler.js';
+export { shouldDeferStuckReminderUntilStaticWindow, shouldTreatUnknownAsStuckWaiting, } from './stuck-story-helpers.js';
 const DONE_INFERENCE_CONFIDENCE_THRESHOLD = 0.82;
 const SCREEN_STATIC_AI_RECHECK_MS = 5 * 60 * 1000;
-const DEFAULT_SCREEN_STATIC_INACTIVITY_THRESHOLD_MS = 10 * 60 * 1000;
-const DEFAULT_MAX_STUCK_NUDGES_PER_STORY = 1;
-const REVIEWING_PR_VALIDATION_MIN_AGE_MS = 5 * 60 * 1000;
-const GH_PR_VIEW_TIMEOUT_MS = 30_000;
-const CLASSIFIER_TIMEOUT_REASON_PREFIX = 'Classifier timeout';
-const AI_DONE_FALSE_REASON_PREFIX = 'AI done=false escalation';
 export function classifyNoActionSummary(snapshot) {
     if (snapshot.pendingEscalations > 0) {
         return {
@@ -73,31 +64,6 @@ export function classifyNoActionSummary(snapshot) {
     }
     return { color: 'green', message: 'All agents productive' };
 }
-export function shouldTreatUnknownAsStuckWaiting(snapshot) {
-    const thresholdMs = Math.max(1, snapshot.staticInactivityThresholdMs);
-    return (snapshot.state === AgentState.UNKNOWN &&
-        !snapshot.isWaiting &&
-        snapshot.sessionUnchangedForMs >= thresholdMs);
-}
-export function shouldDeferStuckReminderUntilStaticWindow(snapshot) {
-    const thresholdMs = Math.max(1, snapshot.staticInactivityThresholdMs);
-    if (snapshot.state === AgentState.WORK_COMPLETE) {
-        return false;
-    }
-    return snapshot.sessionUnchangedForMs < thresholdMs;
-}
-const screenStaticBySession = new Map();
-const classifierTimeoutInterventionsBySession = new Map();
-const aiDoneFalseInterventionsBySession = new Map();
-const techLeadLastRestartByAgentId = new Map();
-function verboseLog(verbose, message) {
-    if (!verbose)
-        return;
-    console.log(chalk.gray(`  [verbose] ${message}`));
-}
-function verboseLogCtx(ctx, message) {
-    verboseLog(ctx.verbose, message);
-}
 function summarizeOutputForVerbose(output) {
     const compact = output
         .split('\n')
@@ -109,19 +75,6 @@ function summarizeOutputForVerbose(output) {
         return compact;
     return `${compact.slice(0, 177)}...`;
 }
-function shouldIncludeProgressUpdates(config) {
-    return config.integrations?.project_management?.provider !== 'none';
-}
-function formatDuration(ms) {
-    if (ms <= 0)
-        return 'now';
-    const totalSeconds = Math.ceil(ms / 1000);
-    const minutes = Math.floor(totalSeconds / 60);
-    const seconds = totalSeconds % 60;
-    if (minutes <= 0)
-        return `${seconds}s`;
-    return `${minutes}m ${seconds}s`;
-}
 function buildOutputFingerprint(output) {
     return createHash('sha256').update(output).digest('hex');
 }
@@ -146,160 +99,6 @@ function stripManagerNudgeBlocks(output) {
     }
     return filtered.join('\n');
 }
-async function submitManagerNudge(ctx, sessionName, nudgeId) {
-    console.log(chalk.gray(`  Nudge ${nudgeId}: double-checking Enter delivery after nudge (verification loop enabled)`));
-    const result = await submitManagerNudgeWithVerification(sessionName, nudgeId);
-    ctx.counters.nudgeEnterPresses = (ctx.counters.nudgeEnterPresses ?? 0) + result.enterPresses;
-    ctx.counters.nudgeEnterRetries = (ctx.counters.nudgeEnterRetries ?? 0) + result.retryEnters;
-    if (!result.confirmed) {
-        ctx.counters.nudgeSubmitUnconfirmed = (ctx.counters.nudgeSubmitUnconfirmed ?? 0) + 1;
-        console.log(chalk.yellow(`  Nudge ${nudgeId}: unable to confirm Enter delivery after ${result.checks} check(s), ${result.enterPresses} Enter keypress(es)`));
-        return;
-    }
-    console.log(chalk.gray(`  Nudge ${nudgeId}: Enter delivery confirmed after ${result.checks} check(s), ${result.enterPresses} Enter keypress(es)`));
-}
-async function sendManagerNudge(ctx, sessionName, message) {
-    const envelope = createManagerNudgeEnvelope(message);
-    await sendToTmuxSession(sessionName, envelope.text);
-    await submitManagerNudge(ctx, sessionName, envelope.nudgeId);
-}
-function getScreenStaticInactivityThresholdMs(config) {
-    return Math.max(1, config?.manager.screen_static_inactivity_threshold_ms ??
-        DEFAULT_SCREEN_STATIC_INACTIVITY_THRESHOLD_MS);
-}
-function getMaxStuckNudgesPerStory(config) {
-    return Math.max(0, config?.manager.max_stuck_nudges_per_story ?? DEFAULT_MAX_STUCK_NUDGES_PER_STORY);
-}
-function isClassifierTimeoutReason(reason) {
-    return /local classifier unavailable:.*timed out|command timed out/i.test(reason);
-}
-function formatClassifierTimeoutEscalationReason(storyId, reason) {
-    const singleLine = reason.replace(/\s+/g, ' ').trim();
-    const shortReason = singleLine.length > 240 ? `${singleLine.slice(0, 237)}...` : singleLine;
-    return `${CLASSIFIER_TIMEOUT_REASON_PREFIX}: manager completion classifier timed out for ${storyId}. Manual human intervention required. Detail: ${shortReason}`;
-}
-async function applyHumanInterventionStateOverride(ctx, sessionName, storyId, stateResult, agentId = null) {
-    const timeoutIntervention = classifierTimeoutInterventionsBySession.get(sessionName);
-    if (timeoutIntervention && (!storyId || storyId !== timeoutIntervention.storyId)) {
-        classifierTimeoutInterventionsBySession.delete(sessionName);
-    }
-    const doneFalseIntervention = aiDoneFalseInterventionsBySession.get(sessionName);
-    if (doneFalseIntervention && (!storyId || storyId !== doneFalseIntervention.storyId)) {
-        aiDoneFalseInterventionsBySession.delete(sessionName);
-    }
-    const transientIntervention = [timeoutIntervention, doneFalseIntervention]
-        .filter((candidate) => Boolean(candidate && storyId && candidate.storyId === storyId))
-        .sort((a, b) => b.createdAtMs - a.createdAtMs)[0] ?? null;
-    const persistedIntervention = storyId === null
-        ? null
-        : await ctx.withDb(async (db) => {
-            return ((agentId ? getActiveEscalationsForAgent(db.db, agentId) : []).find(escalation => escalation.story_id === storyId &&
-                (escalation.reason.startsWith(CLASSIFIER_TIMEOUT_REASON_PREFIX) ||
-                    escalation.reason.startsWith(AI_DONE_FALSE_REASON_PREFIX))) ??
-                getPendingEscalations(db.db).find(escalation => escalation.story_id === storyId &&
-                    (escalation.reason.startsWith(CLASSIFIER_TIMEOUT_REASON_PREFIX) ||
-                        escalation.reason.startsWith(AI_DONE_FALSE_REASON_PREFIX))) ??
-                null);
-        });
-    const interventionReason = transientIntervention?.reason || persistedIntervention?.reason || null;
-    if (!interventionReason) {
-        return stateResult;
-    }
-    return {
-        ...stateResult,
-        state: AgentState.ASKING_QUESTION,
-        needsHuman: true,
-        isWaiting: true,
-        reason: `Manual intervention required: ${interventionReason}`,
-    };
-}
-function clearHumanIntervention(sessionName) {
-    classifierTimeoutInterventionsBySession.delete(sessionName);
-    aiDoneFalseInterventionsBySession.delete(sessionName);
-}
-async function markClassifierTimeoutForHumanIntervention(ctx, sessionName, storyId, reason, agentId = null) {
-    const escalationReason = formatClassifierTimeoutEscalationReason(storyId, reason);
-    classifierTimeoutInterventionsBySession.set(sessionName, {
-        storyId,
-        reason: escalationReason,
-        createdAtMs: Date.now(),
-    });
-    await ctx.withDb(async (db) => {
-        const activeTimeoutEscalation = (agentId ? getActiveEscalationsForAgent(db.db, agentId) : []).some(escalation => escalation.reason.startsWith(CLASSIFIER_TIMEOUT_REASON_PREFIX));
-        if (!activeTimeoutEscalation) {
-            const escalation = createEscalation(db.db, {
-                storyId,
-                fromAgentId: agentId,
-                toAgentId: null,
-                reason: escalationReason,
-            });
-            createLog(db.db, {
-                agentId: 'manager',
-                storyId,
-                eventType: 'ESCALATION_CREATED',
-                status: 'error',
-                message: `${sessionName} requires human intervention: completion classifier timed out`,
-                metadata: {
-                    escalation_id: escalation.id,
-                    session_name: sessionName,
-                    escalation_type: 'classifier_timeout',
-                },
-            });
-            db.save();
-            ctx.counters.escalationsCreated++;
-            ctx.escalatedSessions.add(sessionName);
-        }
-    });
-    const tracked = agentStates.get(sessionName);
-    if (tracked) {
-        tracked.lastState = AgentState.ASKING_QUESTION;
-        tracked.lastStateChangeTime = Date.now();
-    }
-}
-function formatDoneFalseEscalationReason(storyId, reason) {
-    const singleLine = reason.replace(/\s+/g, ' ').trim();
-    const shortReason = singleLine.length > 240 ? `${singleLine.slice(0, 237)}...` : singleLine;
-    return `${AI_DONE_FALSE_REASON_PREFIX}: manager AI assessment returned done=false for ${storyId} after nudge limit reached. Manual human intervention required. Detail: ${shortReason}`;
-}
-async function markDoneFalseForHumanIntervention(ctx, sessionName, storyId, reason, agentId = null) {
-    const escalationReason = formatDoneFalseEscalationReason(storyId, reason);
-    aiDoneFalseInterventionsBySession.set(sessionName, {
-        storyId,
-        reason: escalationReason,
-        createdAtMs: Date.now(),
-    });
-    await ctx.withDb(async (db) => {
-        const hasActiveEscalation = (agentId ? getActiveEscalationsForAgent(db.db, agentId) : []).some(escalation => escalation.reason.startsWith(AI_DONE_FALSE_REASON_PREFIX));
-        if (!hasActiveEscalation) {
-            const escalation = createEscalation(db.db, {
-                storyId,
-                fromAgentId: agentId,
-                toAgentId: null,
-                reason: escalationReason,
-            });
-            createLog(db.db, {
-                agentId: 'manager',
-                storyId,
-                eventType: 'ESCALATION_CREATED',
-                status: 'error',
-                message: `${sessionName} requires human intervention: AI assessment reports blocked/incomplete after nudge limit`,
-                metadata: {
-                    escalation_id: escalation.id,
-                    session_name: sessionName,
-                    escalation_type: 'ai_done_false',
-                },
-            });
-            db.save();
-            ctx.counters.escalationsCreated++;
-            ctx.escalatedSessions.add(sessionName);
-        }
-    });
-    const tracked = agentStates.get(sessionName);
-    if (tracked) {
-        tracked.lastState = AgentState.ASKING_QUESTION;
-        tracked.lastStateChangeTime = Date.now();
-    }
-}
 function updateScreenStaticTracking(sessionName, output, nowMs, staticInactivityThresholdMs) {
     const fingerprint = buildOutputFingerprint(stripManagerNudgeBlocks(output));
     const existing = screenStaticBySession.get(sessionName);
@@ -339,12 +138,6 @@ function markFullAiDetectionRun(sessionName, nowMs) {
         return;
     tracking.lastAiAssessmentMs = nowMs;
 }
-function getSessionStaticUnchangedForMs(sessionName, nowMs) {
-    const tracking = screenStaticBySession.get(sessionName);
-    if (!tracking)
-        return 0;
-    return Math.max(0, nowMs - tracking.unchangedSinceMs);
-}
 export const managerCommand = new Command('manager').description('Micromanager daemon that keeps agents productive');
 // Start the manager daemon
 managerCommand
@@ -780,529 +573,8 @@ async function runAutoMerge(ctx) {
         console.log(chalk.green(`  Auto-merged ${autoMerged} approved PR(s)`));
     }
 }
-async function syncMergedPRs(ctx) {
-    // Phase 1: Read teams (brief lock)
-    const teamInfos = await ctx.withDb(async (db) => {
-        const { getAllTeams } = await import('../../../db/queries/teams.js');
-        return getAllTeams(db.db)
-            .filter(t => t.repo_path)
-            .map(t => ({
-            repoDir: `${ctx.root}/${t.repo_path}`,
-            slug: ghRepoSlug(t.repo_url),
-        }));
-    });
-    if (teamInfos.length === 0)
-        return;
-    // Phase 2: GitHub CLI calls (no lock)
-    const GITHUB_PR_LIST_LIMIT = 20;
-    const GH_CLI_TIMEOUT_MS = 30000;
-    const ghResults = [];
-    for (const team of teamInfos) {
-        try {
-            const args = [
-                'pr',
-                'list',
-                '--json',
-                'number,headRefName,mergedAt',
-                '--state',
-                'merged',
-                '--limit',
-                String(GITHUB_PR_LIST_LIMIT),
-            ];
-            if (team.slug)
-                args.push('-R', team.slug);
-            const result = await execa('gh', args, { cwd: team.repoDir, timeout: GH_CLI_TIMEOUT_MS });
-            ghResults.push({ mergedPRs: JSON.parse(result.stdout) });
-        }
-        catch {
-            ghResults.push({ mergedPRs: [] });
-        }
-    }
-    // Phase 3: DB reads + writes (brief lock)
-    const mergedSynced = await ctx.withDb(async (db) => {
-        let storiesUpdated = 0;
-        for (const ghResult of ghResults) {
-            const candidateStoryIds = Array.from(new Set(ghResult.mergedPRs
-                .map(pr => extractStoryIdFromBranch(pr.headRefName))
-                .filter((id) => Boolean(id))));
-            if (candidateStoryIds.length === 0)
-                continue;
-            const placeholders = candidateStoryIds.map(() => '?').join(',');
-            const updatableStories = queryAll(db.db, `SELECT id FROM stories WHERE status != 'merged' AND id IN (${placeholders})`, candidateStoryIds);
-            const updatableStoryIds = new Set(updatableStories.map(s => s.id));
-            const toUpdate = [];
-            for (const pr of ghResult.mergedPRs) {
-                const storyId = extractStoryIdFromBranch(pr.headRefName);
-                if (!storyId || !updatableStoryIds.has(storyId))
-                    continue;
-                updatableStoryIds.delete(storyId);
-                toUpdate.push({ storyId, prNumber: pr.number });
-            }
-            if (toUpdate.length > 0) {
-                await withTransaction(db.db, () => {
-                    for (const update of toUpdate) {
-                        updateStory(db.db, update.storyId, { status: 'merged', assignedAgentId: null });
-                        const cleanup = cleanupAgentsReferencingMergedStory(db.db, update.storyId);
-                        createLog(db.db, {
-                            agentId: 'manager',
-                            storyId: update.storyId,
-                            eventType: 'STORY_MERGED',
-                            message: `Story synced to merged from GitHub PR #${update.prNumber}`,
-                            metadata: {
-                                merged_agent_cleanup_cleared: cleanup.cleared,
-                                merged_agent_cleanup_reassigned: cleanup.reassigned,
-                            },
-                        });
-                    }
-                });
-                for (const update of toUpdate) {
-                    syncStatusForStory(ctx.root, db.db, update.storyId, 'merged');
-                }
-                storiesUpdated += toUpdate.length;
-            }
-        }
-        if (storiesUpdated > 0)
-            db.save();
-        return storiesUpdated;
-    });
-    verboseLogCtx(ctx, `syncMergedPRs: synced=${mergedSynced}`);
-    if (mergedSynced > 0) {
-        console.log(chalk.green(`  Synced ${mergedSynced} merged story(ies) from GitHub`));
-    }
-}
-async function reconcileAgentsOnMergedStories(ctx) {
-    const result = await ctx.withDb(async (db) => {
-        const mergedStoryIds = queryAll(db.db, `
-      SELECT DISTINCT s.id
-      FROM stories s
-      JOIN agents a ON a.current_story_id = s.id
-      WHERE s.status = 'merged'
-        AND a.status != 'terminated'
-      `).map(row => row.id);
-        if (mergedStoryIds.length === 0) {
-            return { storyCount: 0, cleared: 0, reassigned: 0 };
-        }
-        let cleared = 0;
-        let reassigned = 0;
-        for (const storyId of mergedStoryIds) {
-            const cleanup = cleanupAgentsReferencingMergedStory(db.db, storyId);
-            if (cleanup.cleared > 0) {
-                createLog(db.db, {
-                    agentId: 'manager',
-                    storyId,
-                    eventType: 'STORY_PROGRESS_UPDATE',
-                    message: `Reconciled stale merged-story agent assignments`,
-                    metadata: {
-                        story_id: storyId,
-                        cleared_agents: cleanup.cleared,
-                        reassigned_agents: cleanup.reassigned,
-                        recovery: 'merged_story_agent_reconcile',
-                    },
-                });
-            }
-            cleared += cleanup.cleared;
-            reassigned += cleanup.reassigned;
-        }
-        if (cleared > 0) {
-            db.save();
-        }
-        return { storyCount: mergedStoryIds.length, cleared, reassigned };
-    });
-    verboseLogCtx(ctx, `reconcileAgentsOnMergedStories: stories=${result.storyCount}, cleared=${result.cleared}, reassigned=${result.reassigned}`);
-    if (result.cleared > 0) {
-        console.log(chalk.yellow(`  Reconciled ${result.cleared} stale merged-story agent assignment(s) (${result.reassigned} reassigned, ${result.cleared - result.reassigned} idled)`));
-    }
-}
-async function syncOpenPRs(ctx) {
-    const maxAgeHours = ctx.config.merge_queue?.max_age_hours;
-    // Phase 1: Read teams + existing identifiers (brief lock)
-    const setupData = await ctx.withDb(async (db) => {
-        const { getAllTeams } = await import('../../../db/queries/teams.js');
-        const teams = getAllTeams(db.db);
-        const { existingBranches, existingPrNumbers } = getExistingPRIdentifiers(db.db, true);
-        return {
-            teams: teams
-                .filter(t => t.repo_path)
-                .map(t => ({
-                id: t.id,
-                repoDir: `${ctx.root}/${t.repo_path}`,
-                slug: ghRepoSlug(t.repo_url),
-            })),
-            existingBranches,
-            existingPrNumbers,
-        };
-    });
-    if (setupData.teams.length === 0)
-        return;
-    // Phase 2: GitHub CLI calls (no lock)
-    const teamPRs = new Map();
-    for (const team of setupData.teams) {
-        try {
-            const prs = await fetchOpenGitHubPRs(team.repoDir, team.slug);
-            teamPRs.set(team.id, prs);
-        }
-        catch {
-            // gh CLI might not be authenticated
-        }
-    }
-    // Phase 3: Import into DB (brief lock)
-    const syncedPRs = await ctx.withDb(async (db, scheduler) => {
-        // Re-read identifiers in case another process synced in the meantime
-        const { existingBranches, existingPrNumbers } = getExistingPRIdentifiers(db.db, true);
-        let totalSynced = 0;
-        for (const team of setupData.teams) {
-            const prs = teamPRs.get(team.id);
-            if (!prs)
-                continue;
-            for (const ghPR of prs) {
-                if (existingBranches.has(ghPR.headRefName) || existingPrNumbers.has(ghPR.number))
-                    continue;
-                // Age filtering
-                if (maxAgeHours !== undefined) {
-                    const ageHours = (Date.now() - new Date(ghPR.createdAt).getTime()) / (1000 * 60 * 60);
-                    if (ageHours > maxAgeHours) {
-                        createLog(db.db, {
-                            agentId: 'manager',
-                            eventType: 'PR_SYNC_SKIPPED',
-                            status: 'info',
-                            message: `Skipped syncing old PR #${ghPR.number} (${ghPR.headRefName}): created ${ageHours.toFixed(1)}h ago (max: ${maxAgeHours}h)`,
-                            metadata: {
-                                pr_number: ghPR.number,
-                                branch: ghPR.headRefName,
-                                age_hours: ageHours,
-                                max_age_hours: maxAgeHours,
-                                reason: 'too_old',
-                            },
-                        });
-                        continue;
-                    }
-                }
-                const storyId = extractStoryIdFromBranch(ghPR.headRefName);
-                if (storyId) {
-                    const storyRows = queryAll(db.db, `SELECT id, status FROM stories WHERE id = ? AND status != 'merged'`, [storyId]);
-                    if (storyRows.length === 0) {
-                        createLog(db.db, {
-                            agentId: 'manager',
-                            eventType: 'PR_SYNC_SKIPPED',
-                            status: 'info',
-                            message: `Skipped syncing PR #${ghPR.number} (${ghPR.headRefName}): story ${storyId} not found or already merged`,
-                            metadata: {
-                                pr_number: ghPR.number,
-                                branch: ghPR.headRefName,
-                                story_id: storyId,
-                                reason: 'inactive_story',
-                            },
-                        });
-                        continue;
-                    }
-                }
-                createPullRequest(db.db, {
-                    storyId,
-                    teamId: team.id,
-                    branchName: ghPR.headRefName,
-                    githubPrNumber: ghPR.number,
-                    githubPrUrl: ghPR.url,
-                    submittedBy: null,
-                });
-                existingBranches.add(ghPR.headRefName);
-                existingPrNumbers.add(ghPR.number);
-                totalSynced++;
-            }
-        }
-        if (totalSynced > 0) {
-            db.save();
-            await scheduler.checkMergeQueue();
-            db.save();
-        }
-        return totalSynced;
-    });
-    verboseLogCtx(ctx, `syncOpenPRs: synced=${syncedPRs}`);
-    if (syncedPRs > 0) {
-        console.log(chalk.yellow(`  Synced ${syncedPRs} GitHub PR(s) into merge queue`));
-    }
-}
-async function closeStalePRs(ctx) {
-    // Phase 1: Read teams + PR data (brief lock)
-    const { teamInfos, prsByStory } = await ctx.withDb(async (db) => {
-        const { getAllTeams } = await import('../../../db/queries/teams.js');
-        const teams = getAllTeams(db.db).filter(t => t.repo_path);
-        // Pre-fetch all non-closed PR data grouped by story
-        const allPRs = queryAll(db.db, `SELECT story_id, id, github_pr_number FROM pull_requests WHERE status NOT IN ('closed') ORDER BY created_at DESC`);
-        const prsByStory = new Map();
-        for (const pr of allPRs) {
-            if (!pr.story_id)
-                continue;
-            const existing = prsByStory.get(pr.story_id) || [];
-            existing.push({ id: pr.id, github_pr_number: pr.github_pr_number });
-            prsByStory.set(pr.story_id, existing);
-        }
-        return {
-            teamInfos: teams.map(t => ({
-                repoDir: `${ctx.root}/${t.repo_path}`,
-            })),
-            prsByStory,
-        };
-    });
-    if (teamInfos.length === 0)
-        return;
-    // Phase 2: GitHub CLI calls (no lock)
-    const GH_CLI_TIMEOUT_MS = 30000;
-    const baseBranch = ctx.config.github?.base_branch ?? 'main';
-    const closed = [];
-    for (const team of teamInfos) {
-        try {
-            const openGHPRs = await fetchOpenGitHubPRs(team.repoDir);
-            for (const ghPR of openGHPRs) {
-                // Skip PRs that don't target the configured base branch
-                if (ghPR.baseRefName !== baseBranch)
-                    continue;
-                const storyId = extractStoryIdFromBranch(ghPR.headRefName);
-                if (!storyId)
-                    continue;
-                const prsForStory = prsByStory.get(storyId);
-                if (!prsForStory || prsForStory.length === 0)
-                    continue;
-                const hasUnsyncedEntry = prsForStory.some(pr => pr.github_pr_number == null);
-                if (hasUnsyncedEntry)
-                    continue;
-                const isInQueue = prsForStory.some(pr => pr.github_pr_number === ghPR.number);
-                if (!isInQueue) {
-                    const supersededByPrNumber = prsForStory.find(pr => pr.github_pr_number !== null)?.github_pr_number ?? null;
-                    try {
-                        await execa('gh', ['pr', 'close', String(ghPR.number)], {
-                            cwd: team.repoDir,
-                            timeout: GH_CLI_TIMEOUT_MS,
-                        });
-                        closed.push({
-                            storyId,
-                            closedPrNumber: ghPR.number,
-                            branch: ghPR.headRefName,
-                            supersededByPrNumber,
-                        });
-                    }
-                    catch {
-                        // Non-fatal
-                    }
-                }
-            }
-        }
-        catch {
-            continue;
-        }
-    }
-    // Phase 3: Write logs (brief lock)
-    if (closed.length > 0) {
-        await ctx.withDb(async (db) => {
-            for (const info of closed) {
-                const supersededDesc = info.supersededByPrNumber !== null ? ` by PR #${info.supersededByPrNumber}` : '';
-                createLog(db.db, {
-                    agentId: 'manager',
-                    storyId: info.storyId,
-                    eventType: 'PR_CLOSED',
-                    message: `Auto-closed stale GitHub PR #${info.closedPrNumber} (${info.branch}) - superseded${supersededDesc}`,
-                    metadata: {
-                        github_pr_number: info.closedPrNumber,
-                        branch: info.branch,
-                        reason: 'stale',
-                        superseded_by_pr_number: info.supersededByPrNumber,
-                    },
-                });
-            }
-            db.save();
-        });
-        console.log(chalk.yellow(`  Closed ${closed.length} stale GitHub PR(s):`));
-        for (const info of closed) {
-            const supersededDesc = info.supersededByPrNumber !== null
-                ? ` (superseded by PR #${info.supersededByPrNumber})`
-                : '';
-            console.log(chalk.gray(`    PR #${info.closedPrNumber} [${info.storyId}] ${info.branch}${supersededDesc}`));
-        }
-    }
-    verboseLogCtx(ctx, `closeStalePRs: closed=${closed.length}`);
-}
-async function recoverStaleReviewingPRs(ctx) {
-    const now = Date.now();
-    // Phase 1: Read stale reviewing PRs and resolve repo metadata (brief lock)
-    const candidates = await ctx.withDb(async (db) => {
-        const reviewingPRs = getPullRequestsByStatus(db.db, 'reviewing').filter(pr => {
-            if (!pr.github_pr_number || !pr.team_id)
-                return false;
-            const updatedAtMs = Date.parse(pr.updated_at);
-            if (Number.isNaN(updatedAtMs))
-                return true;
-            return now - updatedAtMs >= REVIEWING_PR_VALIDATION_MIN_AGE_MS;
-        });
-        verboseLogCtx(ctx, `recoverStaleReviewingPRs: staleCandidates=${reviewingPRs.length}`);
-        if (reviewingPRs.length === 0) {
-            return [];
-        }
-        const { getAllTeams } = await import('../../../db/queries/teams.js');
-        const teams = getAllTeams(db.db);
-        const teamsById = new Map(teams.map(team => [team.id, team]));
-        const result = [];
-        for (const pr of reviewingPRs) {
-            const team = teamsById.get(pr.team_id);
-            if (!team?.repo_path)
-                continue;
-            result.push({
-                id: pr.id,
-                storyId: pr.story_id,
-                teamId: pr.team_id,
-                branchName: pr.branch_name,
-                githubPrNumber: pr.github_pr_number,
-                reviewedBy: pr.reviewed_by,
-                repoDir: `${ctx.root}/${team.repo_path}`,
-                repoSlug: ghRepoSlug(team.repo_url),
-            });
-        }
-        return result;
-    });
-    if (candidates.length === 0)
-        return;
-    // Phase 2: Check GitHub state for each stale reviewing PR (no lock)
-    const mergedResults = [];
-    const rejectedResults = [];
-    for (const candidate of candidates) {
-        try {
-            const args = ['pr', 'view', String(candidate.githubPrNumber), '--json', 'state,url'];
-            if (candidate.repoSlug)
-                args.push('-R', candidate.repoSlug);
-            const result = await execa('gh', args, {
-                cwd: candidate.repoDir,
-                timeout: GH_PR_VIEW_TIMEOUT_MS,
-            });
-            const parsed = JSON.parse(result.stdout);
-            const state = parsed.state?.toUpperCase();
-            const url = parsed.url || null;
-            if (state === 'OPEN') {
-                // PR is still open on GitHub but stale in 'reviewing' — the QA agent
-                // may have missed the original nudge. Re-nudge if QA agent is idle.
-                if (candidate.reviewedBy) {
-                    const qaAgent = ctx.agentsBySessionName.get(candidate.reviewedBy);
-                    if (qaAgent && qaAgent.status === 'idle') {
-                        const githubLine = candidate.repoSlug
-                            ? `\n# GitHub: https://github.com/${candidate.repoSlug}/pull/${candidate.githubPrNumber}`
-                            : '';
-                        await sendManagerNudge(ctx, candidate.reviewedBy, `# [REMINDER] You are assigned PR review ${candidate.id} (${candidate.storyId || 'no-story'}).${githubLine}
-# This PR has been waiting for review. Execute now:
-#   hive pr show ${candidate.id}
-#   hive pr approve ${candidate.id}
-# or reject:
-#   hive pr reject ${candidate.id} -r "reason"`);
-                        verboseLogCtx(ctx, `recoverStaleReviewingPRs: re-nudged idle QA ${candidate.reviewedBy} for stale pr=${candidate.id}`);
-                    }
-                }
-                continue;
-            }
-            if (state === 'MERGED') {
-                mergedResults.push({
-                    candidate,
-                    githubState: 'MERGED',
-                    githubUrl: url,
-                });
-                continue;
-            }
-            if (state) {
-                rejectedResults.push({
-                    candidate,
-                    githubState: state,
-                    githubUrl: url,
-                });
-            }
-        }
-        catch (err) {
-            verboseLogCtx(ctx, `recoverStaleReviewingPRs: skip pr=${candidate.id} github_check_failed=${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    if (mergedResults.length === 0 && rejectedResults.length === 0)
-        return;
-    const mergedStoryIds = [];
-    // Phase 3: Apply DB updates (brief lock)
-    await ctx.withDb(async (db) => {
-        for (const result of mergedResults) {
-            await withTransaction(db.db, () => {
-                const currentPR = queryOne(db.db, `SELECT status FROM pull_requests WHERE id = ?`, [result.candidate.id]);
-                if (!currentPR || currentPR.status !== 'reviewing')
-                    return;
-                updatePullRequest(db.db, result.candidate.id, {
-                    status: 'merged',
-                    reviewedBy: result.candidate.reviewedBy || 'manager',
-                });
-                createLog(db.db, {
-                    agentId: 'manager',
-                    storyId: result.candidate.storyId || undefined,
-                    eventType: 'PR_MERGED',
-                    message: `Auto-closed reviewing PR ${result.candidate.id}: GitHub PR #${result.candidate.githubPrNumber} is already merged`,
-                    metadata: {
-                        pr_id: result.candidate.id,
-                        github_pr_number: result.candidate.githubPrNumber,
-                        github_state: result.githubState,
-                        github_url: result.githubUrl,
-                    },
-                });
-                if (!result.candidate.storyId)
-                    return;
-                updateStory(db.db, result.candidate.storyId, { status: 'merged', assignedAgentId: null });
-                const cleanup = cleanupAgentsReferencingMergedStory(db.db, result.candidate.storyId);
-                createLog(db.db, {
-                    agentId: 'manager',
-                    storyId: result.candidate.storyId,
-                    eventType: 'STORY_MERGED',
-                    message: `Story auto-synced to merged (GitHub PR #${result.candidate.githubPrNumber} already merged)`,
-                    metadata: {
-                        pr_id: result.candidate.id,
-                        github_pr_number: result.candidate.githubPrNumber,
-                        github_url: result.githubUrl,
-                        merged_agent_cleanup_cleared: cleanup.cleared,
-                        merged_agent_cleanup_reassigned: cleanup.reassigned,
-                    },
-                });
-                mergedStoryIds.push(result.candidate.storyId);
-            }, () => db.save());
-        }
-        for (const result of rejectedResults) {
-            await withTransaction(db.db, () => {
-                const currentPR = queryOne(db.db, `SELECT status FROM pull_requests WHERE id = ?`, [result.candidate.id]);
-                if (!currentPR || currentPR.status !== 'reviewing')
-                    return;
-                const reason = `GitHub PR #${result.candidate.githubPrNumber} is ${result.githubState.toLowerCase()} on GitHub${result.githubUrl ? ` (${result.githubUrl})` : ''}. Reopen/create a new PR and resubmit.`;
-                updatePullRequest(db.db, result.candidate.id, {
-                    status: 'rejected',
-                    reviewedBy: result.candidate.reviewedBy || 'manager',
-                    reviewNotes: reason,
-                });
-                createLog(db.db, {
-                    agentId: 'manager',
-                    storyId: result.candidate.storyId || undefined,
-                    eventType: 'PR_REJECTED',
-                    status: 'warn',
-                    message: `Auto-rejected stale review ${result.candidate.id}: ${reason}`,
-                    metadata: {
-                        pr_id: result.candidate.id,
-                        github_pr_number: result.candidate.githubPrNumber,
-                        github_state: result.githubState,
-                        github_url: result.githubUrl,
-                        branch: result.candidate.branchName,
-                        team_id: result.candidate.teamId,
-                    },
-                });
-            }, () => db.save());
-        }
-    });
-    // Sync merged stories to PM provider outside lock
-    const uniqueMergedStoryIds = Array.from(new Set(mergedStoryIds));
-    for (const storyId of uniqueMergedStoryIds) {
-        await ctx.withDb(async (db) => {
-            await syncStatusForStory(ctx.root, db.db, storyId, 'merged');
-        });
-    }
-    if (mergedResults.length > 0) {
-        console.log(chalk.green(`  Auto-synced ${mergedResults.length} reviewing PR(s) that were already merged on GitHub`));
-    }
-    if (rejectedResults.length > 0) {
-        console.log(chalk.yellow(`  Auto-rejected ${rejectedResults.length} stale reviewing PR(s) with non-open GitHub PR state`));
-    }
-}
+// syncMergedPRs, reconcileAgentsOnMergedStories, syncOpenPRs, closeStalePRs,
+// recoverStaleReviewingPRs moved to ./pr-sync-orchestrator.ts
 async function syncJiraStatuses(ctx) {
     await ctx.withDb(async (db) => {
         const syncedStories = await syncFromProvider(ctx.root, db.db);
@@ -1609,656 +881,10 @@ async function batchMarkMessagesRead(ctx) {
         });
     }
 }
-async function notifyQAOfQueuedPRs(ctx) {
-    // Phase 1: Read PR queue and assign reviews (brief lock)
-    const { queuedPRs, dispatched } = await ctx.withDb(async (db) => {
-        const openPRs = getMergeQueue(db.db);
-        verboseLogCtx(ctx, `notifyQAOfQueuedPRs: open=${openPRs.length}`);
-        const queued = openPRs.filter(pr => pr.status === 'queued');
-        const reviewing = openPRs.filter(pr => pr.status === 'reviewing');
-        ctx.counters.queuedPRCount = queued.length;
-        ctx.counters.reviewingPRCount = reviewing.length;
-        verboseLogCtx(ctx, `notifyQAOfQueuedPRs: queued=${queued.length}`);
-        if (queued.length === 0) {
-            return {
-                queuedPRs: [],
-                dispatched: [],
-            };
-        }
-        const reviewingSessions = new Set(openPRs
-            .filter(pr => pr.status === 'reviewing' && pr.reviewed_by)
-            .map(pr => pr.reviewed_by));
-        const idleQASessions = ctx.hiveSessions.filter(session => {
-            if (!session.name.includes('-qa-'))
-                return false;
-            if (reviewingSessions.has(session.name))
-                return false;
-            const agent = ctx.agentsBySessionName.get(session.name);
-            return Boolean(agent && agent.status === 'idle');
-        });
-        verboseLogCtx(ctx, `notifyQAOfQueuedPRs: idleQA=${idleQASessions.length}`);
-        const dispatchedList = [];
-        let dispatchCount = 0;
-        for (const qa of idleQASessions) {
-            const nextPR = queued[dispatchCount];
-            if (!nextPR)
-                break;
-            await withTransaction(db.db, () => {
-                updatePullRequest(db.db, nextPR.id, {
-                    status: 'reviewing',
-                    reviewedBy: qa.name,
-                });
-                createLog(db.db, {
-                    agentId: qa.name,
-                    storyId: nextPR.story_id || undefined,
-                    eventType: 'PR_REVIEW_STARTED',
-                    message: `Manager assigned PR review: ${nextPR.id}`,
-                    metadata: { pr_id: nextPR.id, branch: nextPR.branch_name },
-                });
-            }, () => db.save());
-            dispatchedList.push({
-                prId: nextPR.id,
-                qaName: qa.name,
-                storyId: nextPR.story_id,
-                githubPrUrl: nextPR.github_pr_url,
-            });
-            dispatchCount++;
-            verboseLogCtx(ctx, `notifyQAOfQueuedPRs: assigned pr=${nextPR.id} -> ${qa.name}`);
-        }
-        return { queuedPRs: queued, dispatched: dispatchedList };
-    });
-    if (queuedPRs.length === 0)
-        return;
-    // Phase 2: Send tmux nudges (no lock needed)
-    for (const d of dispatched) {
-        const githubLine = d.githubPrUrl ? `\n# GitHub: ${d.githubPrUrl}` : '';
-        await sendManagerNudge(ctx, d.qaName, `# You are assigned PR review ${d.prId} (${d.storyId || 'no-story'}).${githubLine}
-# Execute now:
-#   hive pr show ${d.prId}
-#   hive pr approve ${d.prId}
-# (If manual merge is required in this repo, use --no-merge.)
-# or reject:
-#   hive pr reject ${d.prId} -r "reason"`);
-    }
-    // Fallback nudge if PRs are still queued but all QA sessions are busy/unavailable.
-    if (dispatched.length === 0) {
-        verboseLogCtx(ctx, 'notifyQAOfQueuedPRs: no idle QA, sent queue nudge fallback');
-        const qaSessions = ctx.hiveSessions.filter(s => s.name.includes('-qa-'));
-        for (const qa of qaSessions) {
-            await sendManagerNudge(ctx, qa.name, `# ${queuedPRs.length} PR(s) waiting in queue. Run: hive pr queue`);
-        }
-    }
-}
-/**
- * Auto-reject PRs where the QA agent posted review comments/feedback on GitHub
- * but never formally approved or rejected via `hive pr approve/reject`.
- *
- * Detection: PR is in 'reviewing' status, the assigned QA agent is idle,
- * and there are GitHub comments or CHANGES_REQUESTED reviews on the PR.
- *
- * Action: Auto-reject the PR with the QA's feedback as the rejection reason,
- * which triggers the standard qa_failed flow back to the developer agent.
- */
-export async function autoRejectCommentOnlyReviews(ctx) {
-    // Phase 1: Identify reviewing PRs with idle QA agents (brief lock)
-    const candidates = await ctx.withDb(async (db) => {
-        const reviewingPRs = getPullRequestsByStatus(db.db, 'reviewing').filter(pr => pr.github_pr_number && pr.team_id && pr.reviewed_by);
-        verboseLogCtx(ctx, `autoRejectCommentOnlyReviews: reviewingWithQA=${reviewingPRs.length}`);
-        if (reviewingPRs.length === 0)
-            return [];
-        // Only consider PRs whose QA agent is idle (finished reviewing but didn't approve/reject)
-        const idlePRs = reviewingPRs.filter(pr => {
-            const qaAgent = ctx.agentsBySessionName.get(pr.reviewed_by);
-            if (!qaAgent)
-                return false;
-            // Check if the QA agent is idle or if their session shows idle state
-            const qaState = agentStates.get(pr.reviewed_by);
-            return qaAgent.status === 'idle' || qaState?.lastState === AgentState.IDLE_AT_PROMPT;
-        });
-        verboseLogCtx(ctx, `autoRejectCommentOnlyReviews: idleQACandidates=${idlePRs.length}`);
-        if (idlePRs.length === 0)
-            return [];
-        const { getAllTeams } = await import('../../../db/queries/teams.js');
-        const teams = getAllTeams(db.db);
-        const teamsById = new Map(teams.map(team => [team.id, team]));
-        return idlePRs
-            .map(pr => {
-            const team = teamsById.get(pr.team_id);
-            if (!team?.repo_path)
-                return null;
-            return {
-                id: pr.id,
-                storyId: pr.story_id,
-                teamId: pr.team_id,
-                branchName: pr.branch_name,
-                githubPrNumber: pr.github_pr_number,
-                reviewedBy: pr.reviewed_by,
-                submittedBy: pr.submitted_by,
-                repoDir: `${ctx.root}/${team.repo_path}`,
-            };
-        })
-            .filter(Boolean);
-    });
-    if (candidates.length === 0)
-        return;
-    // Phase 2: Check GitHub for comments/reviews on each candidate (no lock)
-    const toReject = [];
-    for (const candidate of candidates) {
-        try {
-            // Fetch both reviews and comments from GitHub
-            const [reviews, comments] = await Promise.all([
-                getPullRequestReviews(candidate.repoDir, candidate.githubPrNumber).catch(() => []),
-                getPullRequestComments(candidate.repoDir, candidate.githubPrNumber).catch(() => []),
-            ]);
-            // If there's a formal APPROVED review, skip (QA approved via GitHub directly)
-            const hasApproval = reviews.some(r => r.state === 'APPROVED');
-            if (hasApproval) {
-                verboseLogCtx(ctx, `autoRejectCommentOnlyReviews: pr=${candidate.id} has GitHub approval, skipping`);
-                continue;
-            }
-            // Check for CHANGES_REQUESTED reviews
-            const changesRequested = reviews.filter(r => r.state === 'CHANGES_REQUESTED');
-            // Check for substantive issue comments (filter out bot noise and very short comments)
-            const substantiveComments = comments.filter(c => {
-                if (c.body.length < 20)
-                    return false;
-                // Skip known bot comments (Ellipsis, etc.)
-                if (c.body.includes('Looks good to me') && c.body.length < 100)
-                    return false;
-                return true;
-            });
-            // If there are review feedback items, auto-reject
-            if (changesRequested.length > 0 || substantiveComments.length > 0) {
-                // Build rejection reason from the feedback
-                const feedbackParts = [];
-                for (const review of changesRequested) {
-                    if (review.body)
-                        feedbackParts.push(review.body);
-                }
-                for (const comment of substantiveComments) {
-                    feedbackParts.push(comment.body);
-                }
-                const reason = feedbackParts.length > 0
-                    ? feedbackParts.join('\n---\n').slice(0, 2000)
-                    : 'QA posted review feedback on GitHub without formal approval. See PR comments.';
-                toReject.push({ candidate, reason });
-                verboseLogCtx(ctx, `autoRejectCommentOnlyReviews: pr=${candidate.id} has ${changesRequested.length} changes_requested + ${substantiveComments.length} comments, will auto-reject`);
-            }
-        }
-        catch (err) {
-            verboseLogCtx(ctx, `autoRejectCommentOnlyReviews: skip pr=${candidate.id} github_check_failed=${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    if (toReject.length === 0)
-        return;
-    // Phase 3: Reject PRs in DB (brief lock)
-    await ctx.withDb(async (db) => {
-        for (const { candidate, reason } of toReject) {
-            await withTransaction(db.db, () => {
-                updatePullRequest(db.db, candidate.id, {
-                    status: 'rejected',
-                    reviewNotes: reason,
-                });
-                if (candidate.storyId) {
-                    updateStory(db.db, candidate.storyId, { status: 'qa_failed' });
-                }
-                createLog(db.db, {
-                    agentId: 'manager',
-                    eventType: 'PR_REJECTED',
-                    message: `Auto-rejected PR ${candidate.id}: QA posted review comments without formal approve/reject`,
-                    storyId: candidate.storyId || undefined,
-                    metadata: { pr_id: candidate.id, auto_rejected: true },
-                });
-            }, () => db.save());
-            console.log(chalk.yellow(`  Auto-rejected PR ${candidate.id} (story: ${candidate.storyId || '-'}): QA left review comments without approving`));
-        }
-    });
-    // Phase 4: Notify developer agents via tmux (no lock)
-    for (const { candidate, reason } of toReject) {
-        if (candidate.submittedBy) {
-            const devSession = ctx.hiveSessions.find(s => s.name === candidate.submittedBy);
-            if (devSession) {
-                await sendManagerNudge(ctx, devSession.name, `# ⚠️ PR AUTO-REJECTED - QA REVIEW FEEDBACK ⚠️
-# Story: ${candidate.storyId || 'Unknown'}
-# QA agent (${candidate.reviewedBy}) posted review feedback without formally approving.
-# Feedback:
-# ${reason.split('\n').slice(0, 10).join('\n# ')}
-#
-# Fix the issues and resubmit: hive pr submit -b ${candidate.branchName} -s ${candidate.storyId || 'STORY-ID'} --from ${devSession.name}`);
-            }
-        }
-    }
-}
-async function handleRejectedPRs(ctx) {
-    // Phase 1: Read rejected PRs and update DB (brief lock)
-    const rejectedPRData = await ctx.withDb(async (db) => {
-        const rejectedPRs = getPullRequestsByStatus(db.db, 'rejected');
-        verboseLogCtx(ctx, `handleRejectedPRs: rejected=${rejectedPRs.length}`);
-        if (rejectedPRs.length === 0)
-            return [];
-        const prData = [];
-        for (const pr of rejectedPRs) {
-            if (pr.story_id) {
-                const storyId = pr.story_id;
-                await withTransaction(db.db, () => {
-                    updateStory(db.db, storyId, { status: 'qa_failed' });
-                    createLog(db.db, {
-                        agentId: 'manager',
-                        eventType: 'STORY_QA_FAILED',
-                        message: `Story ${storyId} QA failed: ${pr.review_notes || 'See review comments'}`,
-                        storyId: storyId,
-                    });
-                }, () => db.save());
-                // Sync status change to Jira
-                await syncStatusForStory(ctx.root, db.db, storyId, 'qa_failed');
-            }
-            // Mark as closed to prevent re-notification spam
-            await withTransaction(db.db, () => {
-                updatePullRequest(db.db, pr.id, { status: 'closed' });
-            }, () => db.save());
-            prData.push({
-                id: pr.id,
-                storyId: pr.story_id,
-                branchName: pr.branch_name,
-                reviewNotes: pr.review_notes,
-                submittedBy: pr.submitted_by,
-            });
-        }
-        return prData;
-    });
-    if (rejectedPRData.length === 0)
-        return;
-    // Phase 2: Send tmux notifications (no lock needed)
-    let rejectionNotified = 0;
-    for (const pr of rejectedPRData) {
-        if (pr.submittedBy) {
-            const devSession = ctx.hiveSessions.find(s => s.name === pr.submittedBy);
-            if (devSession) {
-                verboseLogCtx(ctx, `handleRejectedPRs: notifying ${devSession.name} for pr=${pr.id}, story=${pr.storyId || '-'}`);
-                await sendManagerNudge(ctx, devSession.name, `# ⚠️ PR REJECTED - ACTION REQUIRED ⚠️
-# Story: ${pr.storyId || 'Unknown'}
-# Reason: ${pr.reviewNotes || 'See review comments'}
-#
-# You MUST fix this issue before doing anything else.
-# Fix the issues and resubmit: hive pr submit -b ${pr.branchName} -s ${pr.storyId || 'STORY-ID'} --from ${devSession.name}`);
-                rejectionNotified++;
-            }
-        }
-    }
-    console.log(chalk.yellow(`  Notified ${rejectionNotified} developer(s) of PR rejection(s)`));
-}
-async function nudgeQAFailedStories(ctx) {
-    // Phase 1: Read QA-failed stories and agents (brief lock)
-    const candidates = await ctx.withDb(async (db) => {
-        const qaFailedStories = getStoriesByStatus(db.db, 'qa_failed').filter(story => !['merged', 'completed'].includes(story.status));
-        verboseLogCtx(ctx, `nudgeQAFailedStories: candidates=${qaFailedStories.length}`);
-        const result = [];
-        for (const story of qaFailedStories) {
-            if (!story.assigned_agent_id) {
-                verboseLogCtx(ctx, `nudgeQAFailedStories: story=${story.id} skip=no_assigned_agent`);
-                continue;
-            }
-            const agent = getAgentById(db.db, story.assigned_agent_id);
-            if (!agent || agent.status !== 'working') {
-                verboseLogCtx(ctx, `nudgeQAFailedStories: story=${story.id} skip=agent_not_working status=${agent?.status || 'missing'}`);
-                continue;
-            }
-            const agentSession = findSessionForAgent(ctx.hiveSessions, agent);
-            if (!agentSession) {
-                verboseLogCtx(ctx, `nudgeQAFailedStories: story=${story.id} skip=no_session`);
-                continue;
-            }
-            result.push({
-                storyId: story.id,
-                sessionName: agentSession.name,
-                cliTool: (agent.cli_tool || 'claude'),
-            });
-        }
-        return result;
-    });
-    // Phase 2: Tmux captures and nudges (no lock needed)
-    for (const candidate of candidates) {
-        const output = await captureTmuxPane(candidate.sessionName, TMUX_CAPTURE_LINES_SHORT);
-        const stateResult = detectAgentState(output, candidate.cliTool);
-        if (stateResult.isWaiting &&
-            !stateResult.needsHuman &&
-            stateResult.state !== AgentState.THINKING) {
-            verboseLogCtx(ctx, `nudgeQAFailedStories: story=${candidate.storyId} nudge session=${candidate.sessionName} state=${stateResult.state}`);
-            await sendManagerNudge(ctx, candidate.sessionName, `# REMINDER: Story ${candidate.storyId} failed QA review!
-# You must fix the issues and resubmit the PR.
-# Check the QA feedback and address all concerns.
-hive pr queue`);
-        }
-        else {
-            verboseLogCtx(ctx, `nudgeQAFailedStories: story=${candidate.storyId} skip=not_ready waiting=${stateResult.isWaiting} needsHuman=${stateResult.needsHuman} state=${stateResult.state}`);
-        }
-    }
-}
-async function recoverUnassignedQAFailedStories(ctx) {
-    const result = await ctx.withDb(async (db, scheduler) => {
-        const recoverableStories = queryAll(db.db, `
-      SELECT * FROM stories
-      WHERE status = 'qa_failed'
-        AND assigned_agent_id IS NULL
-    `);
-        if (recoverableStories.length === 0)
-            return null;
-        verboseLogCtx(ctx, `recoverUnassignedQAFailedStories: recovered=${recoverableStories.length}`);
-        await withTransaction(db.db, () => {
-            for (const story of recoverableStories) {
-                updateStory(db.db, story.id, { status: 'planned', assignedAgentId: null });
-                createLog(db.db, {
-                    agentId: 'manager',
-                    storyId: story.id,
-                    eventType: 'ORPHANED_STORY_RECOVERED',
-                    message: `Recovered QA-failed story ${story.id} (unassigned) back to planned`,
-                    metadata: { from_status: 'qa_failed', to_status: 'planned' },
-                });
-            }
-        }, () => db.save());
-        for (const story of recoverableStories) {
-            await syncStatusForStory(ctx.root, db.db, story.id, 'planned');
-        }
-        // Proactively re-assign recovered work so it does not stall until manual `hive assign`.
-        const assignmentResult = await scheduler.assignStories();
-        verboseLogCtx(ctx, `recoverUnassignedQAFailedStories.assignStories: assigned=${assignmentResult.assigned}, errors=${assignmentResult.errors.length}`);
-        db.save();
-        if (assignmentResult.assigned > 0) {
-            await scheduler.flushJiraQueue();
-            db.save();
-        }
-        return { recoverableCount: recoverableStories.length, assignmentResult };
-    });
-    if (result) {
-        console.log(chalk.yellow(`  Recovered ${result.recoverableCount} QA-failed unassigned story(ies), assigned ${result.assignmentResult.assigned}`));
-        if (result.assignmentResult.errors.length > 0) {
-            console.log(chalk.yellow(`  Assignment errors during QA-failed recovery: ${result.assignmentResult.errors.length}`));
-        }
-    }
-}
-async function nudgeStuckStories(ctx) {
-    const stuckThresholdMs = Math.max(1, ctx.config.manager.stuck_threshold_ms);
-    const staticInactivityThresholdMs = getScreenStaticInactivityThresholdMs(ctx.config);
-    const maxStuckNudgesPerStory = getMaxStuckNudgesPerStory(ctx.config);
-    const waitingNudgeCooldownMs = Math.max(ctx.config.manager.nudge_cooldown_ms, staticInactivityThresholdMs);
-    const staleUpdatedAt = new Date(Date.now() - stuckThresholdMs).toISOString();
-    // Phase 1: Read stuck stories and agents (brief lock)
-    const candidates = await ctx.withDb(async (db) => {
-        const stuckStories = queryAll(db.db, `SELECT * FROM stories
-       WHERE status = 'in_progress'
-       AND updated_at < ?`, [staleUpdatedAt]).filter(story => !['merged', 'completed'].includes(story.status));
-        verboseLogCtx(ctx, `nudgeStuckStories: candidates=${stuckStories.length}, staleBefore=${staleUpdatedAt}, thresholdMs=${stuckThresholdMs}`);
-        const result = [];
-        for (const story of stuckStories) {
-            verboseLogCtx(ctx, `nudgeStuckStories: evaluating story=${story.id}`);
-            if (!story.assigned_agent_id) {
-                verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} skip=no_assigned_agent`);
-                continue;
-            }
-            const agent = getAgentById(db.db, story.assigned_agent_id);
-            if (!agent) {
-                verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} skip=missing_agent`);
-                continue;
-            }
-            const agentSession = findSessionForAgent(ctx.hiveSessions, agent);
-            if (!agentSession) {
-                verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} skip=no_agent_session`);
-                continue;
-            }
-            result.push({
-                story,
-                agent,
-                sessionName: agentSession.name,
-                cliTool: (agent.cli_tool || 'claude'),
-            });
-        }
-        return result;
-    });
-    // Phase 2: Tmux captures, AI classifier, nudges (no lock held)
-    for (const candidate of candidates) {
-        const { story, agent, sessionName, cliTool } = candidate;
-        const now = Date.now();
-        verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} session=${sessionName} cli=${cliTool}`);
-        const trackedState = agentStates.get(sessionName);
-        if (trackedState &&
-            [
-                AgentState.ASKING_QUESTION,
-                AgentState.AWAITING_SELECTION,
-                AgentState.PLAN_APPROVAL,
-                AgentState.PERMISSION_REQUIRED,
-                AgentState.USER_DECLINED,
-            ].includes(trackedState.lastState)) {
-            verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} skip=waiting_for_human state=${trackedState.lastState}`);
-            continue;
-        }
-        if (trackedState && now - trackedState.lastNudgeTime < waitingNudgeCooldownMs) {
-            verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} skip=nudge_to_ai_window remainingMs=${waitingNudgeCooldownMs - (now - trackedState.lastNudgeTime)}`);
-            continue;
-        }
-        const output = await captureTmuxPane(sessionName, TMUX_CAPTURE_LINES_SHORT);
-        const stateResult = detectAgentState(output, cliTool);
-        verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} detected state=${stateResult.state}, waiting=${stateResult.isWaiting}, needsHuman=${stateResult.needsHuman}`);
-        if (stateResult.needsHuman) {
-            verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} skip=needs_human`);
-            continue;
-        }
-        const sessionUnchangedForMs = getSessionStaticUnchangedForMs(sessionName, now);
-        const unknownLooksStuck = shouldTreatUnknownAsStuckWaiting({
-            state: stateResult.state,
-            isWaiting: stateResult.isWaiting,
-            sessionUnchangedForMs,
-            staticInactivityThresholdMs,
-        });
-        if (stateResult.state === AgentState.THINKING) {
-            if (trackedState && (trackedState.storyStuckNudgeCount || 0) > 0) {
-                trackedState.storyStuckNudgeCount = 0;
-            }
-            clearHumanIntervention(sessionName);
-            verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} skip=thinking state=${stateResult.state}`);
-            continue;
-        }
-        if (!stateResult.isWaiting && !unknownLooksStuck) {
-            if (trackedState && (trackedState.storyStuckNudgeCount || 0) > 0) {
-                trackedState.storyStuckNudgeCount = 0;
-            }
-            clearHumanIntervention(sessionName);
-            verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} skip=not_waiting state=${stateResult.state}`);
-            continue;
-        }
-        if (unknownLooksStuck) {
-            verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} action=unknown_state_stuck_heuristic unchangedMs=${sessionUnchangedForMs}`);
-        }
-        if (shouldDeferStuckReminderUntilStaticWindow({
-            state: stateResult.state,
-            sessionUnchangedForMs,
-            staticInactivityThresholdMs,
-        })) {
-            verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} skip=done_inference_static_window remainingMs=${staticInactivityThresholdMs - sessionUnchangedForMs}`);
-            continue;
-        }
-        else {
-            const completionAssessment = await assessCompletionFromOutput(ctx.config, sessionName, story.id, output);
-            const aiSaysDone = completionAssessment.done &&
-                completionAssessment.confidence >= DONE_INFERENCE_CONFIDENCE_THRESHOLD;
-            verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} doneInference done=${completionAssessment.done}, confidence=${completionAssessment.confidence.toFixed(2)}, aiSaysDone=${aiSaysDone}, reason=${completionAssessment.reason}`);
-            if (isClassifierTimeoutReason(completionAssessment.reason)) {
-                await markClassifierTimeoutForHumanIntervention(ctx, sessionName, story.id, completionAssessment.reason, agent.id);
-                verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} action=classifier_timeout_escalation session=${sessionName}`);
-                continue;
-            }
-            clearHumanIntervention(sessionName);
-            if (aiSaysDone) {
-                const progressed = await autoProgressDoneStory(ctx, story, agent, sessionName, completionAssessment.reason, completionAssessment.confidence);
-                if (progressed) {
-                    ctx.counters.autoProgressed++;
-                    verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} action=auto_progressed`);
-                    continue;
-                }
-                verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} auto_progress_failed`);
-            }
-            else {
-                const stuckNudgesSent = trackedState?.storyStuckNudgeCount || 0;
-                if (stuckNudgesSent >= maxStuckNudgesPerStory) {
-                    await markDoneFalseForHumanIntervention(ctx, sessionName, story.id, completionAssessment.reason, agent.id);
-                    verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} action=done_false_escalation session=${sessionName}`);
-                    continue;
-                }
-            }
-        }
-        const stuckNudgesSent = trackedState?.storyStuckNudgeCount || 0;
-        if (stuckNudgesSent >= maxStuckNudgesPerStory) {
-            verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} skip=stuck_nudge_limit reached=${stuckNudgesSent}/${maxStuckNudgesPerStory}`);
-            continue;
-        }
-        if (stateResult.state === AgentState.WORK_COMPLETE) {
-            verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} action=mandatory_completion_signal session=${sessionName}`);
-            const completionSignalLines = [
-                `# MANDATORY COMPLETION SIGNAL: execute now for ${story.id}`,
-                `hive pr submit -b $(git rev-parse --abbrev-ref HEAD) -s ${story.id} --from ${sessionName}`,
-                `hive my-stories complete ${story.id}`,
-            ];
-            if (shouldIncludeProgressUpdates(ctx.config)) {
-                completionSignalLines.push(`hive progress ${story.id} -m "PR submitted to merge queue" --from ${sessionName} --done`);
-            }
-            else {
-                completionSignalLines.push('# project_management.provider is none; skip hive progress in this workspace.');
-            }
-            completionSignalLines.push('# Do not stop at a summary. Completion requires the commands above.');
-            await sendManagerNudge(ctx, sessionName, completionSignalLines.join('\n'));
-            ctx.counters.nudged++;
-            if (trackedState) {
-                trackedState.lastNudgeTime = now;
-                trackedState.storyStuckNudgeCount = (trackedState.storyStuckNudgeCount || 0) + 1;
-            }
-            else {
-                agentStates.set(sessionName, {
-                    lastState: stateResult.state,
-                    lastStateChangeTime: now,
-                    lastNudgeTime: now,
-                    storyStuckNudgeCount: 1,
-                });
-            }
-            continue;
-        }
-        verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} action=stuck_reminder session=${sessionName}`);
-        await sendManagerNudge(ctx, sessionName, `# REMINDER: Story ${story.id} has been in progress for a while.
-# If stuck, escalate to your Senior or Tech Lead.
-# If done, submit your PR: hive pr submit -b $(git rev-parse --abbrev-ref HEAD) -s ${story.id} --from ${sessionName}
-# Then mark complete: hive my-stories complete ${story.id}`);
-        ctx.counters.nudged++;
-        if (trackedState) {
-            trackedState.lastNudgeTime = now;
-            trackedState.storyStuckNudgeCount = (trackedState.storyStuckNudgeCount || 0) + 1;
-        }
-        else {
-            agentStates.set(sessionName, {
-                lastState: stateResult.state,
-                lastStateChangeTime: now,
-                lastNudgeTime: now,
-                storyStuckNudgeCount: 1,
-            });
-        }
-    }
-}
-async function autoProgressDoneStory(ctx, story, agent, sessionName, reason, confidence) {
-    verboseLogCtx(ctx, `autoProgressDoneStory: story=${story.id}, session=${sessionName}, confidence=${confidence.toFixed(2)}`);
-    // Resolve branch name outside lock (involves git operations)
-    const branch = await resolveStoryBranchName(ctx.root, story, agent, msg => verboseLogCtx(ctx, `resolveStoryBranchName: story=${story.id} ${msg}`));
-    // DB operations under brief lock
-    const action = await ctx.withDb(async (db, scheduler) => {
-        const openPRs = getOpenPullRequestsByStory(db.db, story.id);
-        verboseLogCtx(ctx, `autoProgressDoneStory: story=${story.id}, openPRs=${openPRs.length}`);
-        if (openPRs.length > 0) {
-            if (story.status !== 'pr_submitted') {
-                updateStory(db.db, story.id, { status: 'pr_submitted' });
-                createLog(db.db, {
-                    agentId: 'manager',
-                    storyId: story.id,
-                    eventType: 'STORY_PROGRESS_UPDATE',
-                    message: `Auto-progressed ${story.id} to pr_submitted (existing PR detected)`,
-                    metadata: {
-                        session_name: sessionName,
-                        recovery: 'done_inference_existing_pr',
-                        reason,
-                        confidence,
-                        open_pr_count: openPRs.length,
-                    },
-                });
-                db.save();
-                await syncStatusForStory(ctx.root, db.db, story.id, 'pr_submitted');
-                verboseLogCtx(ctx, `autoProgressDoneStory: story=${story.id} status moved to pr_submitted`);
-            }
-            return 'existing_pr';
-        }
-        if (!branch) {
-            verboseLogCtx(ctx, `autoProgressDoneStory: story=${story.id} action=failed_no_branch`);
-            return 'no_branch';
-        }
-        await withTransaction(db.db, () => {
-            updateStory(db.db, story.id, { status: 'pr_submitted', branchName: branch });
-            createPullRequest(db.db, {
-                storyId: story.id,
-                teamId: story.team_id || null,
-                branchName: branch,
-                submittedBy: sessionName,
-            });
-            createLog(db.db, {
-                agentId: 'manager',
-                storyId: story.id,
-                eventType: 'PR_SUBMITTED',
-                message: `Auto-submitted PR for ${story.id} after AI completion inference`,
-                metadata: {
-                    session_name: sessionName,
-                    recovery: 'done_inference_auto_submit',
-                    reason,
-                    confidence,
-                    branch,
-                },
-            });
-        }, () => db.save());
-        await syncStatusForStory(ctx.root, db.db, story.id, 'pr_submitted');
-        await scheduler.checkMergeQueue();
-        db.save();
-        verboseLogCtx(ctx, `autoProgressDoneStory: story=${story.id} action=auto_submitted branch=${branch}`);
-        return 'auto_submitted';
-    });
-    // Tmux notifications (no lock needed)
-    if (action === 'existing_pr') {
-        await sendManagerNudge(ctx, sessionName, `# AUTO-PROGRESS: Manager inferred ${story.id} is complete (confidence ${confidence.toFixed(2)}), detected existing PR, and moved story to PR-submitted state.`);
-        verboseLogCtx(ctx, `autoProgressDoneStory: story=${story.id} action=existing_pr_progressed`);
-        return true;
-    }
-    if (action === 'no_branch') {
-        return false;
-    }
-    await sendManagerNudge(ctx, sessionName, `# AUTO-PROGRESS: Manager inferred ${story.id} is complete (confidence ${confidence.toFixed(2)}), auto-submitted branch ${branch} to merge queue.`);
-    return true;
-}
-async function resolveStoryBranchName(root, story, agent, log) {
-    if (story.branch_name && story.branch_name.trim().length > 0) {
-        log?.(`source=story.branch_name value=${story.branch_name.trim()}`);
-        return story.branch_name.trim();
-    }
-    if (!agent.worktree_path) {
-        log?.('source=worktree skip=no_worktree_path');
-        return null;
-    }
-    const worktreeDir = join(root, agent.worktree_path);
-    try {
-        const result = await execa('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: worktreeDir });
-        const branch = result.stdout.trim();
-        if (!branch || branch === 'HEAD') {
-            log?.(`source=git_rev_parse invalid_branch=${branch || '(empty)'}`);
-            return null;
-        }
-        log?.(`source=git_rev_parse value=${branch}`);
-        return branch;
-    }
-    catch {
-        log?.(`source=git_rev_parse failed cwd=${worktreeDir}`);
-        return null;
-    }
-}
+// notifyQAOfQueuedPRs, autoRejectCommentOnlyReviews, handleRejectedPRs
+// moved to ./qa-review-handler.ts
+// nudgeQAFailedStories, recoverUnassignedQAFailedStories, nudgeStuckStories,
+// autoProgressDoneStory, resolveStoryBranchName moved to ./stuck-story-processor.ts
 async function notifyUnassignedStories(ctx) {
     // Phase 1: Read planned unassigned stories (brief lock)
     const plannedCount = await ctx.withDb(async (db) => {
@@ -2287,129 +913,7 @@ async function notifyUnassignedStories(ctx) {
         }
     }
 }
-async function restartStaleTechLead(ctx) {
-    const maxAgeHours = ctx.config.manager.tech_lead_max_age_hours;
-    const maxAgeMs = maxAgeHours * 60 * 60 * 1000;
-    const now = Date.now();
-    // Phase 1: Read tech lead agents (brief lock)
-    const techLeads = await ctx.withDb(async (db) => {
-        const leads = getAgentsByType(db.db, 'tech_lead');
-        verboseLogCtx(ctx, `restartStaleTechLead: found ${leads.length} tech lead agent(s)`);
-        return leads.map(tl => ({
-            id: tl.id,
-            tmuxSession: tl.tmux_session,
-            cliTool: (tl.cli_tool || 'claude'),
-            createdAt: tl.created_at,
-        }));
-    });
-    // Phase 2: Check sessions and restart (tmux I/O outside lock, DB writes under brief lock)
-    for (const techLead of techLeads) {
-        if (!techLead.tmuxSession) {
-            verboseLogCtx(ctx, `restartStaleTechLead: techLead=${techLead.id} skip=no_tmux_session`);
-            continue;
-        }
-        const sessionRunning = await isTmuxSessionRunning(techLead.tmuxSession);
-        if (!sessionRunning) {
-            verboseLogCtx(ctx, `restartStaleTechLead: techLead=${techLead.id} skip=session_not_running session=${techLead.tmuxSession}`);
-            continue;
-        }
-        const createdAt = new Date(techLead.createdAt).getTime();
-        const ageMs = now - createdAt;
-        const ageHours = ageMs / (60 * 60 * 1000);
-        verboseLogCtx(ctx, `restartStaleTechLead: techLead=${techLead.id} age=${ageHours.toFixed(2)}h threshold=${maxAgeHours}h`);
-        if (ageMs < maxAgeMs) {
-            verboseLogCtx(ctx, `restartStaleTechLead: techLead=${techLead.id} skip=not_stale remainingMs=${maxAgeMs - ageMs}`);
-            continue;
-        }
-        const cooldown = isTechLeadRestartOnCooldown(techLeadLastRestartByAgentId.get(techLead.id), now, maxAgeHours);
-        if (cooldown.onCooldown) {
-            verboseLogCtx(ctx, `restartStaleTechLead: techLead=${techLead.id} skip=cooldown cooldownHours=${cooldown.cooldownHours} remainingMs=${cooldown.remainingMs}`);
-            continue;
-        }
-        const output = await captureTmuxPane(techLead.tmuxSession, TMUX_CAPTURE_LINES_SHORT);
-        const stateResult = detectAgentState(output, techLead.cliTool);
-        verboseLogCtx(ctx, `restartStaleTechLead: techLead=${techLead.id} state=${stateResult.state} waiting=${stateResult.isWaiting} needsHuman=${stateResult.needsHuman}`);
-        if (!stateResult.isWaiting ||
-            stateResult.needsHuman ||
-            stateResult.state === AgentState.THINKING) {
-            verboseLogCtx(ctx, `restartStaleTechLead: techLead=${techLead.id} skip=not_safe_state state=${stateResult.state}`);
-            continue;
-        }
-        verboseLogCtx(ctx, `restartStaleTechLead: techLead=${techLead.id} action=restarting session=${techLead.tmuxSession}`);
-        // Kill the existing session (tmux I/O, no lock)
-        await killTmuxSession(techLead.tmuxSession);
-        // Spawn a new session with the same configuration (tmux I/O, no lock)
-        const hiveRoot = findHiveRootFromDir(ctx.root);
-        if (!hiveRoot) {
-            verboseLogCtx(ctx, `restartStaleTechLead: techLead=${techLead.id} error=hive_root_not_found`);
-            continue;
-        }
-        const paths = getHivePaths(hiveRoot);
-        const config = loadConfig(paths.hiveDir);
-        const agentConfig = config.models.tech_lead;
-        const cliTool = agentConfig.cli_tool;
-        const safetyMode = agentConfig.safety_mode;
-        const model = resolveRuntimeModelForCli(agentConfig.model, cliTool);
-        const runtimeBuilder = getCliRuntimeBuilder(cliTool);
-        const commandArgs = runtimeBuilder.buildSpawnCommand(model, safetyMode);
-        // Look up active requirement and teams to provide context to the restarted tech lead
-        const initialPrompt = await ctx.withDb(async (db) => {
-            const planningReqs = getRequirementsByStatus(db.db, 'planning');
-            const inProgressReqs = getRequirementsByStatus(db.db, 'in_progress');
-            const activeReq = planningReqs[0] ?? inProgressReqs[0] ?? null;
-            const teams = getAllTeams(db.db);
-            if (activeReq) {
-                return generateTechLeadPrompt(activeReq.id, activeReq.title, activeReq.description, teams, activeReq.godmode === 1, activeReq.target_branch || 'main');
-            }
-            return `You are the Tech Lead of Hive, an AI development team orchestrator.
-
-You have been restarted to refresh your context. No active requirement is currently being planned.
-
-## Next Steps
-
-1. Check the current status of the Hive workspace:
-\`\`\`bash
-hive status
-\`\`\`
-
-2. Check your inbox for messages from developers:
-\`\`\`bash
-hive msg inbox hive-tech-lead
-\`\`\`
-
-3. If there are pending requirements, begin planning them. If all work is complete, monitor for new requirements.`;
-        });
-        await spawnTmuxSession({
-            sessionName: techLead.tmuxSession,
-            workDir: ctx.root,
-            commandArgs,
-            initialPrompt,
-        });
-        // DB writes under brief lock
-        await ctx.withDb(async (db) => {
-            createLog(db.db, {
-                agentId: 'manager',
-                eventType: 'AGENT_SPAWNED',
-                status: 'info',
-                message: `Tech lead ${techLead.id} restarted for context freshness (age: ${ageHours.toFixed(1)}h)`,
-                metadata: {
-                    agent_id: techLead.id,
-                    tmux_session: techLead.tmuxSession,
-                    age_hours: ageHours,
-                    threshold_hours: maxAgeHours,
-                    restart_reason: 'context_freshness',
-                },
-            });
-            updateAgent(db.db, techLead.id, {
-                status: 'working',
-                createdAt: new Date().toISOString(),
-            });
-            db.save();
-        });
-        techLeadLastRestartByAgentId.set(techLead.id, now);
-        console.log(chalk.green(`  Tech lead ${techLead.id} restarted for context freshness (age: ${ageHours.toFixed(1)}h)`));
-    }
-}
+// restartStaleTechLead moved to ./tech-lead-lifecycle.ts
 async function printSummary(ctx) {
     const { escalationsCreated, escalationsResolved, nudged, nudgeEnterPresses, nudgeEnterRetries, nudgeSubmitUnconfirmed, autoProgressed, messagesForwarded, queuedPRCount, reviewingPRCount, handoffPromoted, handoffAutoAssigned, plannedAutoAssigned, jiraSynced, featureTestsSpawned, auditorsSpawned, } = ctx.counters;
     const summary = [];