hungry-ghost-hive 0.43.0 → 0.43.2

package/src/cli/commands/manager/index.ts

@@ -3,49 +3,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 type { HiveConfig } from '../../../config/schema.js';
-import {
-  syncFromProvider,
-  syncStatusForStory,
-} from '../../../connectors/project-management/operations.js';
+import { syncFromProvider } from '../../../connectors/project-management/operations.js';
 import type { StoryRow } from '../../../db/client.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,
   type MessageRow,
 } 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 {
@@ -54,25 +29,14 @@ import {
   isManagerRunning,
   isTmuxSessionRunning,
   killTmuxSession,
-  sendToTmuxSession,
-  spawnTmuxSession,
   stopManager as stopManagerSession,
 } from '../../../tmux/manager.js';
 import type { WithLockFn } from '../../../utils/auto-merge.js';
 import { autoMergeApprovedPRs } from '../../../utils/auto-merge.js';
 import type { CLITool } from '../../../utils/cli-commands.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,
@@ -80,7 +44,6 @@ import {
   handlePermissionPrompt,
   handlePlanApproval,
   nudgeAgent,
-  submitManagerNudgeWithVerification,
   updateAgentStateTracking,
 } from './agent-monitoring.js';
 import { spawnAuditorIfNeeded } from './auditor-lifecycle.js';
@@ -90,12 +53,45 @@ 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,
+  type ScreenStaticTracking,
+} from './stuck-story-helpers.js';
+import {
+  autoProgressDoneStory,
+  nudgeQAFailedStories,
+  nudgeStuckStories,
+  recoverUnassignedQAFailedStories,
+} from './stuck-story-processor.js';
+import { restartStaleTechLead } from './tech-lead-lifecycle.js';
 import type { ManagerCheckContext } from './types.js';
 import {
   MANAGER_NUDGE_END_MARKER,
@@ -104,27 +100,15 @@ import {
   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';
-
-interface ClassifierTimeoutIntervention {
-  storyId: string;
-  reason: string;
-  createdAtMs: number;
-}
-
-interface ScreenStaticTracking {
-  fingerprint: string;
-  unchangedSinceMs: number;
-  lastAiAssessmentMs: number;
-}
-
 interface ScreenStaticStatus {
   changed: boolean;
   unchangedForMs: number;
@@ -146,19 +130,6 @@ interface SummaryLine {
   message: string;
 }
 
-interface UnknownStateStuckHeuristicSnapshot {
-  state: AgentState;
-  isWaiting: boolean;
-  sessionUnchangedForMs: number;
-  staticInactivityThresholdMs: number;
-}
-
-interface StuckReminderDeferralSnapshot {
-  state: AgentState;
-  sessionUnchangedForMs: number;
-  staticInactivityThresholdMs: number;
-}
-
 export function classifyNoActionSummary(snapshot: NoActionSummarySnapshot): SummaryLine {
   if (snapshot.pendingEscalations > 0) {
     return {
@@ -187,41 +158,6 @@ export function classifyNoActionSummary(snapshot: NoActionSummarySnapshot): Summ
   return { color: 'green', message: 'All agents productive' };
 }
 
-export function shouldTreatUnknownAsStuckWaiting(
-  snapshot: UnknownStateStuckHeuristicSnapshot
-): boolean {
-  const thresholdMs = Math.max(1, snapshot.staticInactivityThresholdMs);
-  return (
-    snapshot.state === AgentState.UNKNOWN &&
-    !snapshot.isWaiting &&
-    snapshot.sessionUnchangedForMs >= thresholdMs
-  );
-}
-
-export function shouldDeferStuckReminderUntilStaticWindow(
-  snapshot: StuckReminderDeferralSnapshot
-): boolean {
-  const thresholdMs = Math.max(1, snapshot.staticInactivityThresholdMs);
-  if (snapshot.state === AgentState.WORK_COMPLETE) {
-    return false;
-  }
-  return snapshot.sessionUnchangedForMs < thresholdMs;
-}
-
-const screenStaticBySession = new Map<string, ScreenStaticTracking>();
-const classifierTimeoutInterventionsBySession = new Map<string, ClassifierTimeoutIntervention>();
-const aiDoneFalseInterventionsBySession = new Map<string, ClassifierTimeoutIntervention>();
-const techLeadLastRestartByAgentId = new Map<string, number>();
-
-function verboseLog(verbose: boolean, message: string): void {
-  if (!verbose) return;
-  console.log(chalk.gray(`  [verbose] ${message}`));
-}
-
-function verboseLogCtx(ctx: Pick<ManagerCheckContext, 'verbose'>, message: string): void {
-  verboseLog(ctx.verbose, message);
-}
-
 function summarizeOutputForVerbose(output: string): string {
   const compact = output
     .split('\n')
@@ -233,19 +169,6 @@ function summarizeOutputForVerbose(output: string): string {
   return `${compact.slice(0, 177)}...`;
 }
 
-function shouldIncludeProgressUpdates(config: HiveConfig): boolean {
-  return config.integrations?.project_management?.provider !== 'none';
-}
-
-function formatDuration(ms: number): string {
-  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: string): string {
   return createHash('sha256').update(output).digest('hex');
 }
@@ -275,240 +198,6 @@ function stripManagerNudgeBlocks(output: string): string {
   return filtered.join('\n');
 }
 
-async function submitManagerNudge(
-  ctx: ManagerCheckContext,
-  sessionName: string,
-  nudgeId: string
-): Promise<void> {
-  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: ManagerCheckContext,
-  sessionName: string,
-  message: string
-): Promise<void> {
-  const envelope = createManagerNudgeEnvelope(message);
-  await sendToTmuxSession(sessionName, envelope.text);
-  await submitManagerNudge(ctx, sessionName, envelope.nudgeId);
-}
-
-function getScreenStaticInactivityThresholdMs(config?: HiveConfig): number {
-  return Math.max(
-    1,
-    config?.manager.screen_static_inactivity_threshold_ms ??
-      DEFAULT_SCREEN_STATIC_INACTIVITY_THRESHOLD_MS
-  );
-}
-
-function getMaxStuckNudgesPerStory(config?: HiveConfig): number {
-  return Math.max(
-    0,
-    config?.manager.max_stuck_nudges_per_story ?? DEFAULT_MAX_STUCK_NUDGES_PER_STORY
-  );
-}
-
-function isClassifierTimeoutReason(reason: string): boolean {
-  return /local classifier unavailable:.*timed out|command timed out/i.test(reason);
-}
-
-function formatClassifierTimeoutEscalationReason(storyId: string, reason: string): string {
-  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: ManagerCheckContext,
-  sessionName: string,
-  storyId: string | null,
-  stateResult: ReturnType<typeof detectAgentState>,
-  agentId: string | null = null
-): Promise<ReturnType<typeof detectAgentState>> {
-  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): candidate is ClassifierTimeoutIntervention =>
-        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: string): void {
-  classifierTimeoutInterventionsBySession.delete(sessionName);
-  aiDoneFalseInterventionsBySession.delete(sessionName);
-}
-
-async function markClassifierTimeoutForHumanIntervention(
-  ctx: ManagerCheckContext,
-  sessionName: string,
-  storyId: string,
-  reason: string,
-  agentId: string | null = null
-): Promise<void> {
-  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: string, reason: string): string {
-  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: ManagerCheckContext,
-  sessionName: string,
-  storyId: string,
-  reason: string,
-  agentId: string | null = null
-): Promise<void> {
-  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: string,
   output: string,
@@ -558,12 +247,6 @@ function markFullAiDetectionRun(sessionName: string, nowMs: number): void {
   tracking.lastAiAssessmentMs = nowMs;
 }
 
-function getSessionStaticUnchangedForMs(sessionName: string, nowMs: number): number {
-  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'
 );
@@ -1103,746 +786,114 @@ async function runAutoMerge(ctx: ManagerCheckContext): Promise<void> {
   }
 }
 
-async function syncMergedPRs(ctx: ManagerCheckContext): Promise<void> {
-  // 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: Array<{
-    mergedPRs: Array<{ number: number; headRefName: string; mergedAt: string }>;
-  }> = [];
-  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): id is string => Boolean(id))
-        )
-      );
-      if (candidateStoryIds.length === 0) continue;
-
-      const placeholders = candidateStoryIds.map(() => '?').join(',');
-      const updatableStories = queryAll<{ id: string }>(
-        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: Array<{ storyId: string; prNumber: number }> = [];
-
-      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 });
-      }
+// syncMergedPRs, reconcileAgentsOnMergedStories, syncOpenPRs, closeStalePRs,
+// recoverStaleReviewingPRs moved to ./pr-sync-orchestrator.ts
 
-      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;
-      }
+async function syncJiraStatuses(ctx: ManagerCheckContext): Promise<void> {
+  await ctx.withDb(async db => {
+    const syncedStories = await syncFromProvider(ctx.root, db.db);
+    verboseLogCtx(ctx, `syncJiraStatuses: synced=${syncedStories}`);
+    if (syncedStories > 0) {
+      ctx.counters.jiraSynced = syncedStories;
+      console.log(chalk.cyan(`  Synced ${syncedStories} story status(es) from Jira`));
     }
-    if (storiesUpdated > 0) db.save();
-    return storiesUpdated;
+    // Always save after Jira sync — syncFromJira now also pushes unsynced stories TO Jira
+    db.save();
   });
-
-  verboseLogCtx(ctx, `syncMergedPRs: synced=${mergedSynced}`);
-  if (mergedSynced > 0) {
-    console.log(chalk.green(`  Synced ${mergedSynced} merged story(ies) from GitHub`));
-  }
 }
 
-async function reconcileAgentsOnMergedStories(ctx: ManagerCheckContext): Promise<void> {
-  const result = await ctx.withDb(async db => {
-    const mergedStoryIds = queryAll<{ id: string }>(
-      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 };
-    }
+async function prepareSessionData(ctx: ManagerCheckContext): Promise<void> {
+  await ctx.withDb(async db => {
+    // Pre-populate escalation dedup set
+    const existingEscalations = getPendingEscalations(db.db);
+    ctx.escalatedSessions = new Set(
+      existingEscalations.filter(e => e.from_agent_id).map(e => e.from_agent_id)
+    );
 
-    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',
-          },
-        });
+    // Batch fetch all agents and index by session name
+    const allAgents = getAllAgents(db.db);
+    const bySessionName = new Map<string, (typeof allAgents)[number]>();
+    for (const agent of allAgents) {
+      bySessionName.set(`hive-${agent.id}`, agent);
+      if (agent.tmux_session) {
+        bySessionName.set(agent.tmux_session, agent);
       }
-      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)`
-      )
+    ctx.agentsBySessionName = bySessionName;
+    verboseLogCtx(
+      ctx,
+      `prepareSessionData: escalations=${existingEscalations.length}, agentsIndexed=${bySessionName.size}`
     );
-  }
+  });
 }
 
-async function syncOpenPRs(ctx: ManagerCheckContext): Promise<void> {
-  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;
+async function resolveStaleEscalations(ctx: ManagerCheckContext): Promise<void> {
+  await ctx.withDb(async db => {
+    const staleAfterMs = Math.max(
+      1,
+      ctx.config.manager.nudge_cooldown_ms,
+      ctx.config.manager.stuck_threshold_ms
+    );
+    const pendingEscalations = getPendingEscalations(db.db);
+    verboseLogCtx(
+      ctx,
+      `resolveStaleEscalations: pending=${pendingEscalations.length}, staleAfterMs=${staleAfterMs}`
+    );
+    if (pendingEscalations.length === 0) return;
 
-  // Phase 2: GitHub CLI calls (no lock)
-  const teamPRs = new Map<string, import('../../../utils/pr-sync.js').GitHubPR[]>();
-  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
+    const uniqueAgents = new Map<string, ReturnType<typeof getAllAgents>[number]>();
+    for (const agent of ctx.agentsBySessionName.values()) {
+      uniqueAgents.set(agent.id, agent);
     }
-  }
 
-  // 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 staleEscalations = findStaleSessionEscalations({
+      pendingEscalations,
+      agents: [...uniqueAgents.values()],
+      liveSessionNames: new Set(ctx.hiveSessions.map(session => session.name)),
+      nowMs: Date.now(),
+      staleAfterMs,
+    });
 
-        const storyId = extractStoryIdFromBranch(ghPR.headRefName);
-        if (storyId) {
-          const storyRows = queryAll<{ id: string; status: string }>(
-            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;
+    if (staleEscalations.length === 0) return;
+    verboseLogCtx(ctx, `resolveStaleEscalations: stale=${staleEscalations.length}`);
+
+    withTransaction(
+      db.db,
+      () => {
+        for (const stale of staleEscalations) {
+          updateEscalation(db.db, stale.escalation.id, {
+            status: 'resolved',
+            resolution: `Manager auto-resolved stale escalation: ${stale.reason}`,
+          });
+          if (stale.escalation.from_agent_id) {
+            ctx.escalatedSessions.delete(stale.escalation.from_agent_id);
           }
+          ctx.counters.escalationsResolved++;
+          createLog(db.db, {
+            agentId: 'manager',
+            storyId: stale.escalation.story_id || undefined,
+            eventType: 'ESCALATION_RESOLVED',
+            message: `Auto-resolved stale escalation ${stale.escalation.id}`,
+            metadata: {
+              escalation_id: stale.escalation.id,
+              from_agent_id: stale.escalation.from_agent_id,
+              reason: stale.reason,
+            },
+          });
         }
-
-        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;
+      },
+      () => db.save()
+    );
+    console.log(chalk.yellow(`  Auto-cleared ${staleEscalations.length} stale escalation(s)`));
   });
-
-  verboseLogCtx(ctx, `syncOpenPRs: synced=${syncedPRs}`);
-  if (syncedPRs > 0) {
-    console.log(chalk.yellow(`  Synced ${syncedPRs} GitHub PR(s) into merge queue`));
-  }
 }
 
-async function closeStalePRs(ctx: ManagerCheckContext): Promise<void> {
-  // 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<{
-      story_id: string | null;
-      id: string;
-      github_pr_number: number | null;
-    }>(
-      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<string, Array<{ id: string; github_pr_number: number | null }>>();
-    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: import('../../../utils/pr-sync.js').ClosedPRInfo[] = [];
-
-  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}`);
-}
-
-interface ReviewingPRValidationCandidate {
-  id: string;
-  storyId: string | null;
-  teamId: string;
-  branchName: string;
-  githubPrNumber: number;
-  reviewedBy: string | null;
-  repoDir: string;
-  repoSlug: string | null;
-}
-
-interface ReviewingPRValidationResult {
-  candidate: ReviewingPRValidationCandidate;
-  githubState: string;
-  githubUrl: string | null;
-}
-
-async function recoverStaleReviewingPRs(ctx: ManagerCheckContext): Promise<void> {
-  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 [] as ReviewingPRValidationCandidate[];
-    }
-
-    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: ReviewingPRValidationCandidate[] = [];
-    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: ReviewingPRValidationResult[] = [];
-  const rejectedResults: ReviewingPRValidationResult[] = [];
-
-  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) as { state?: string; url?: string };
-      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: string[] = [];
-
-  // Phase 3: Apply DB updates (brief lock)
-  await ctx.withDb(async db => {
-    for (const result of mergedResults) {
-      await withTransaction(
-        db.db,
-        () => {
-          const currentPR = queryOne<{ status: string }>(
-            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<{ status: string }>(
-            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`
-      )
-    );
-  }
-}
-
-async function syncJiraStatuses(ctx: ManagerCheckContext): Promise<void> {
-  await ctx.withDb(async db => {
-    const syncedStories = await syncFromProvider(ctx.root, db.db);
-    verboseLogCtx(ctx, `syncJiraStatuses: synced=${syncedStories}`);
-    if (syncedStories > 0) {
-      ctx.counters.jiraSynced = syncedStories;
-      console.log(chalk.cyan(`  Synced ${syncedStories} story status(es) from Jira`));
-    }
-    // Always save after Jira sync — syncFromJira now also pushes unsynced stories TO Jira
-    db.save();
-  });
-}
-
-async function prepareSessionData(ctx: ManagerCheckContext): Promise<void> {
-  await ctx.withDb(async db => {
-    // Pre-populate escalation dedup set
-    const existingEscalations = getPendingEscalations(db.db);
-    ctx.escalatedSessions = new Set(
-      existingEscalations.filter(e => e.from_agent_id).map(e => e.from_agent_id)
-    );
-
-    // Batch fetch all agents and index by session name
-    const allAgents = getAllAgents(db.db);
-    const bySessionName = new Map<string, (typeof allAgents)[number]>();
-    for (const agent of allAgents) {
-      bySessionName.set(`hive-${agent.id}`, agent);
-      if (agent.tmux_session) {
-        bySessionName.set(agent.tmux_session, agent);
-      }
-    }
-    ctx.agentsBySessionName = bySessionName;
-    verboseLogCtx(
-      ctx,
-      `prepareSessionData: escalations=${existingEscalations.length}, agentsIndexed=${bySessionName.size}`
-    );
-  });
-}
-
-async function resolveStaleEscalations(ctx: ManagerCheckContext): Promise<void> {
-  await ctx.withDb(async db => {
-    const staleAfterMs = Math.max(
-      1,
-      ctx.config.manager.nudge_cooldown_ms,
-      ctx.config.manager.stuck_threshold_ms
-    );
-    const pendingEscalations = getPendingEscalations(db.db);
-    verboseLogCtx(
-      ctx,
-      `resolveStaleEscalations: pending=${pendingEscalations.length}, staleAfterMs=${staleAfterMs}`
-    );
-    if (pendingEscalations.length === 0) return;
-
-    const uniqueAgents = new Map<string, ReturnType<typeof getAllAgents>[number]>();
-    for (const agent of ctx.agentsBySessionName.values()) {
-      uniqueAgents.set(agent.id, agent);
-    }
-
-    const staleEscalations = findStaleSessionEscalations({
-      pendingEscalations,
-      agents: [...uniqueAgents.values()],
-      liveSessionNames: new Set(ctx.hiveSessions.map(session => session.name)),
-      nowMs: Date.now(),
-      staleAfterMs,
-    });
-
-    if (staleEscalations.length === 0) return;
-    verboseLogCtx(ctx, `resolveStaleEscalations: stale=${staleEscalations.length}`);
-
-    withTransaction(
-      db.db,
-      () => {
-        for (const stale of staleEscalations) {
-          updateEscalation(db.db, stale.escalation.id, {
-            status: 'resolved',
-            resolution: `Manager auto-resolved stale escalation: ${stale.reason}`,
-          });
-          if (stale.escalation.from_agent_id) {
-            ctx.escalatedSessions.delete(stale.escalation.from_agent_id);
-          }
-          ctx.counters.escalationsResolved++;
-          createLog(db.db, {
-            agentId: 'manager',
-            storyId: stale.escalation.story_id || undefined,
-            eventType: 'ESCALATION_RESOLVED',
-            message: `Auto-resolved stale escalation ${stale.escalation.id}`,
-            metadata: {
-              escalation_id: stale.escalation.id,
-              from_agent_id: stale.escalation.from_agent_id,
-              reason: stale.reason,
-            },
-          });
-        }
-      },
-      () => db.save()
-    );
-    console.log(chalk.yellow(`  Auto-cleared ${staleEscalations.length} stale escalation(s)`));
-  });
-}
-
-async function resolveOrphanedSessionEscalations(ctx: ManagerCheckContext): Promise<void> {
-  const resolvedCount = await ctx.withDb(async db => {
-    const pendingEscalations = getPendingEscalations(db.db);
-    verboseLogCtx(ctx, `resolveOrphanedSessionEscalations: pending=${pendingEscalations.length}`);
-    if (pendingEscalations.length === 0) {
-      return 0;
+async function resolveOrphanedSessionEscalations(ctx: ManagerCheckContext): Promise<void> {
+  const resolvedCount = await ctx.withDb(async db => {
+    const pendingEscalations = getPendingEscalations(db.db);
+    verboseLogCtx(ctx, `resolveOrphanedSessionEscalations: pending=${pendingEscalations.length}`);
+    if (pendingEscalations.length === 0) {
+      return 0;
     }
 
     const activeSessionNames = new Set(ctx.hiveSessions.map(session => session.name));
@@ -2170,981 +1221,42 @@ async function batchMarkMessagesRead(ctx: ManagerCheckContext): Promise<void> {
   }
 }
 
-async function notifyQAOfQueuedPRs(ctx: ManagerCheckContext): Promise<void> {
-  // 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: [] as typeof queued,
-        dispatched: [] as Array<{
-          prId: string;
-          qaName: string;
-          storyId: string | null;
-          githubPrUrl: string | null;
-        }>,
-      };
-    }
+// notifyQAOfQueuedPRs, autoRejectCommentOnlyReviews, handleRejectedPRs
+// moved to ./qa-review-handler.ts
 
-    const reviewingSessions = new Set(
-      openPRs
-        .filter(pr => pr.status === 'reviewing' && pr.reviewed_by)
-        .map(pr => pr.reviewed_by as string)
-    );
+// nudgeQAFailedStories, recoverUnassignedQAFailedStories, nudgeStuckStories,
+// autoProgressDoneStory, resolveStoryBranchName moved to ./stuck-story-processor.ts
 
-    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: Array<{
-      prId: string;
-      qaName: string;
-      storyId: string | null;
-      githubPrUrl: string | null;
-    }> = [];
-    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 };
+async function notifyUnassignedStories(ctx: ManagerCheckContext): Promise<void> {
+  // Phase 1: Read planned unassigned stories (brief lock)
+  const plannedCount = await ctx.withDb(async db => {
+    const plannedStories = queryAll<StoryRow>(
+      db.db,
+      "SELECT * FROM stories WHERE status = 'planned' AND assigned_agent_id IS NULL"
+    );
+    return plannedStories.length;
   });
 
-  if (queuedPRs.length === 0) return;
+  if (plannedCount === 0) return;
+  verboseLogCtx(ctx, `notifyUnassignedStories: plannedUnassigned=${plannedCount}`);
 
-  // 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"`
-    );
-  }
+  // Phase 2: Tmux captures and nudges (no lock needed)
+  const seniorSessions = ctx.hiveSessions.filter(s => s.name.includes('-senior-'));
+  verboseLogCtx(ctx, `notifyUnassignedStories: seniorSessions=${seniorSessions.length}`);
+  for (const senior of seniorSessions) {
+    const seniorAgent = ctx.agentsBySessionName.get(senior.name);
+    const seniorCliTool = (seniorAgent?.cli_tool || 'claude') as CLITool;
+    const output = await captureTmuxPane(senior.name, TMUX_CAPTURE_LINES_SHORT);
+    const stateResult = detectAgentState(output, seniorCliTool);
 
-  // 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(
+    if (
+      stateResult.isWaiting &&
+      !stateResult.needsHuman &&
+      stateResult.state !== AgentState.THINKING
+    ) {
+      verboseLogCtx(
         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: ManagerCheckContext): Promise<void> {
-  // 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) as Array<{
-      id: string;
-      storyId: string | null;
-      branchName: string;
-      githubPrNumber: number;
-      reviewedBy: string;
-      submittedBy: string | null;
-      teamId: string;
-      repoDir: string;
-    }>;
-  });
-
-  if (candidates.length === 0) return;
-
-  // Phase 2: Check GitHub for comments/reviews on each candidate (no lock)
-  const toReject: Array<{
-    candidate: (typeof candidates)[number];
-    reason: string;
-  }> = [];
-
-  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(
-          (): Array<{ author: string; state: string; body: string }> => []
-        ),
-        getPullRequestComments(candidate.repoDir, candidate.githubPrNumber).catch(
-          (): Array<{ author: string; body: string; createdAt: string }> => []
-        ),
-      ]);
-
-      // 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: string[] = [];
-        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: ManagerCheckContext): Promise<void> {
-  // 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: Array<{
-      id: string;
-      storyId: string | null;
-      branchName: string;
-      reviewNotes: string | null;
-      submittedBy: string | null;
-    }> = [];
-
-    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: ManagerCheckContext): Promise<void> {
-  // 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: Array<{ storyId: string; sessionName: string; cliTool: CLITool }> = [];
-    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') as CLITool,
-      });
-    }
-    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: ManagerCheckContext): Promise<void> {
-  const result = await ctx.withDb(async (db, scheduler) => {
-    const recoverableStories = queryAll<StoryRow>(
-      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: ManagerCheckContext): Promise<void> {
-  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<StoryRow>(
-      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: Array<{
-      story: StoryRow;
-      agent: ReturnType<typeof getAllAgents>[number];
-      sessionName: string;
-      cliTool: CLITool;
-    }> = [];
-
-    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') as CLITool,
-      });
-    }
-    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: ManagerCheckContext,
-  story: StoryRow,
-  agent: ReturnType<typeof getAllAgents>[number],
-  sessionName: string,
-  reason: string,
-  confidence: number
-): Promise<boolean> {
-  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' as const;
-    }
-
-    if (!branch) {
-      verboseLogCtx(ctx, `autoProgressDoneStory: story=${story.id} action=failed_no_branch`);
-      return 'no_branch' as const;
-    }
-
-    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' as const;
-  });
-
-  // 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: string,
-  story: StoryRow,
-  agent: ReturnType<typeof getAllAgents>[number],
-  log?: (message: string) => void
-): Promise<string | null> {
-  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;
-  }
-}
-
-async function notifyUnassignedStories(ctx: ManagerCheckContext): Promise<void> {
-  // Phase 1: Read planned unassigned stories (brief lock)
-  const plannedCount = await ctx.withDb(async db => {
-    const plannedStories = queryAll<StoryRow>(
-      db.db,
-      "SELECT * FROM stories WHERE status = 'planned' AND assigned_agent_id IS NULL"
-    );
-    return plannedStories.length;
-  });
-
-  if (plannedCount === 0) return;
-  verboseLogCtx(ctx, `notifyUnassignedStories: plannedUnassigned=${plannedCount}`);
-
-  // Phase 2: Tmux captures and nudges (no lock needed)
-  const seniorSessions = ctx.hiveSessions.filter(s => s.name.includes('-senior-'));
-  verboseLogCtx(ctx, `notifyUnassignedStories: seniorSessions=${seniorSessions.length}`);
-  for (const senior of seniorSessions) {
-    const seniorAgent = ctx.agentsBySessionName.get(senior.name);
-    const seniorCliTool = (seniorAgent?.cli_tool || 'claude') as CLITool;
-    const output = await captureTmuxPane(senior.name, TMUX_CAPTURE_LINES_SHORT);
-    const stateResult = detectAgentState(output, seniorCliTool);
-
-    if (
-      stateResult.isWaiting &&
-      !stateResult.needsHuman &&
-      stateResult.state !== AgentState.THINKING
-    ) {
-      verboseLogCtx(
-        ctx,
-        `notifyUnassignedStories: nudge ${senior.name} waiting=${stateResult.isWaiting} state=${stateResult.state}`
+        `notifyUnassignedStories: nudge ${senior.name} waiting=${stateResult.isWaiting} state=${stateResult.state}`
       );
       await sendManagerNudge(
         ctx,
@@ -3160,189 +1272,7 @@ async function notifyUnassignedStories(ctx: ManagerCheckContext): Promise<void>
   }
 }
 
-async function restartStaleTechLead(ctx: ManagerCheckContext): Promise<void> {
-  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') as CLITool,
-      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: ManagerCheckContext): Promise<void> {
   const {