@stoneforge/smithy 1.0.3 → 1.2.0

package/dist/services/dispatch-daemon.js

@@ -18,10 +18,12 @@
  * @module
  */
 import { EventEmitter } from 'node:events';
-import { InboxStatus, createTimestamp, TaskStatus, asEntityId, asElementId } from '@stoneforge/core';
+import { InboxStatus, createTimestamp, TaskStatus, asEntityId, asElementId, PlanStatus, canAutoComplete } from '@stoneforge/core';
 import { loadTriagePrompt, loadRolePrompt } from '../prompts/index.js';
+import { createLogger } from '../utils/logger.js';
 import { getAgentMetadata } from './agent-registry.js';
 import { getOrchestratorTaskMeta, updateOrchestratorTaskMeta, appendTaskSessionHistory, } from '../types/task-meta.js';
+const logger = createLogger('dispatch-daemon');
 // ============================================================================
 // Constants
 // ============================================================================
@@ -95,32 +97,32 @@ export class DispatchDaemonImpl {
         try {
             const result = await this.sessionManager.reconcileOnStartup();
             if (result.reconciled > 0) {
-                console.log(`[dispatch-daemon] Reconciled ${result.reconciled} stale session(s)`);
+                logger.info(`Reconciled ${result.reconciled} stale session(s)`);
             }
             if (result.errors.length > 0) {
-                console.warn('[dispatch-daemon] Reconciliation errors:', result.errors);
+                logger.warn('Reconciliation errors:', result.errors);
             }
         }
         catch (error) {
-            console.error('[dispatch-daemon] Failed to reconcile on startup:', error);
+            logger.error('Failed to reconcile on startup:', error);
         }
         // Recover orphaned task assignments (workers with tasks but no session after restart)
         if (this.config.orphanRecoveryEnabled) {
             try {
                 const result = await this.recoverOrphanedAssignments();
                 if (result.processed > 0) {
-                    console.log(`[dispatch-daemon] Startup: recovered ${result.processed} orphaned task assignment(s)`);
+                    logger.info(`Startup: recovered ${result.processed} orphaned task assignment(s)`);
                 }
             }
             catch (error) {
-                console.error('[dispatch-daemon] Failed to recover orphaned assignments on startup:', error);
+                logger.error('Failed to recover orphaned assignments on startup:', error);
             }
         }
         // Start the main poll loop
         this.pollIntervalHandle = this.createPollInterval();
         // Run an initial poll cycle immediately
         this.currentPollCycle = this.runPollCycle().catch((error) => {
-            console.error('[dispatch-daemon] Initial poll cycle error:', error);
+            logger.error('Initial poll cycle error:', error);
         });
     }
     async stop() {
@@ -184,7 +186,7 @@ export class DispatchDaemonImpl {
                     taskStatus: [TaskStatus.OPEN, TaskStatus.IN_PROGRESS, TaskStatus.REVIEW],
                 });
                 if (workerTasks.length > 0) {
-                    console.log(`[dispatch-daemon] Worker ${worker.name} already has ${workerTasks.length} assigned task(s), skipping`);
+                    logger.debug(`Worker ${worker.name} already has ${workerTasks.length} assigned task(s), skipping`);
                     continue;
                 }
                 availableWorkers.push(worker);
@@ -201,7 +203,7 @@ export class DispatchDaemonImpl {
                     errors++;
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     errorMessages.push(`Worker ${worker.name}: ${errorMessage}`);
-                    console.error(`[dispatch-daemon] Error assigning task to worker ${worker.name}:`, error);
+                    logger.error(`Error assigning task to worker ${worker.name}:`, error);
                 }
             }
         }
@@ -209,7 +211,7 @@ export class DispatchDaemonImpl {
             errors++;
             const errorMessage = error instanceof Error ? error.message : String(error);
             errorMessages.push(errorMessage);
-            console.error('[dispatch-daemon] Error in pollWorkerAvailability:', error);
+            logger.error('Error in pollWorkerAvailability:', error);
         }
         const result = {
             pollType: 'worker-availability',
@@ -294,7 +296,7 @@ export class DispatchDaemonImpl {
             errors++;
             const errorMessage = error instanceof Error ? error.message : String(error);
             errorMessages.push(errorMessage);
-            console.error('[dispatch-daemon] Error in pollInboxes:', error);
+            logger.error('Error in pollInboxes:', error);
         }
         const result = {
             pollType: 'inbox',
@@ -322,6 +324,8 @@ export class DispatchDaemonImpl {
             if (!this.stewardScheduler.isRunning()) {
                 // Start the scheduler if it's not running
                 await this.stewardScheduler.start();
+                const registered = await this.stewardScheduler.registerAllStewards();
+                logger.info(`Steward scheduler started, registered ${registered} steward(s)`);
                 processed++;
             }
             // Get stats to report on activity
@@ -332,7 +336,7 @@ export class DispatchDaemonImpl {
             errors++;
             const errorMessage = error instanceof Error ? error.message : String(error);
             errorMessages.push(errorMessage);
-            console.error('[dispatch-daemon] Error in pollStewardTriggers:', error);
+            logger.error('Error in pollStewardTriggers:', error);
         }
         const result = {
             pollType: 'steward-trigger',
@@ -441,7 +445,7 @@ export class DispatchDaemonImpl {
             errors++;
             const errorMessage = error instanceof Error ? error.message : String(error);
             errorMessages.push(errorMessage);
-            console.error('[dispatch-daemon] Error in pollWorkflowTasks:', error);
+            logger.error('Error in pollWorkflowTasks:', error);
         }
         const result = {
             pollType: 'workflow-task',
@@ -479,17 +483,41 @@ export class DispatchDaemonImpl {
                 });
                 if (workerTasks.length === 0)
                     continue;
-                // 4. Recover the first orphaned task
+                // 4. Check if the task is stuck in a resume loop
                 const taskAssignment = workerTasks[0];
-                try {
-                    await this.recoverOrphanedTask(worker, taskAssignment.task, taskAssignment.orchestratorMeta);
-                    processed++;
+                const resumeCount = taskAssignment.orchestratorMeta?.resumeCount ?? 0;
+                const maxResumes = this.config.maxResumeAttemptsBeforeRecovery;
+                if (maxResumes > 0 && resumeCount >= maxResumes) {
+                    // Task has been resumed too many times without status change —
+                    // spawn a recovery steward instead of resuming the worker again
+                    try {
+                        await this.spawnRecoveryStewardForTask(worker, taskAssignment.task, taskAssignment.orchestratorMeta);
+                        processed++;
+                        logger.info(`[dispatch-daemon] Spawning recovery steward for stuck task ${taskAssignment.task.id} after ${resumeCount} resume attempts`);
+                    }
+                    catch (error) {
+                        errors++;
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        errorMessages.push(`Recovery steward for ${worker.name}: ${errorMessage}`);
+                        logger.error(`Error spawning recovery steward for worker ${worker.name}:`, error);
+                    }
                 }
-                catch (error) {
-                    errors++;
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    errorMessages.push(`Worker ${worker.name}: ${errorMessage}`);
-                    console.error(`[dispatch-daemon] Error recovering orphaned task for worker ${worker.name}:`, error);
+                else {
+                    // Normal recovery: increment resume count and re-spawn the worker
+                    try {
+                        // Increment resumeCount before recovering so the counter is persisted
+                        await this.api.update(taskAssignment.task.id, {
+                            metadata: updateOrchestratorTaskMeta(taskAssignment.task.metadata, { resumeCount: resumeCount + 1 }),
+                        });
+                        await this.recoverOrphanedTask(worker, taskAssignment.task, taskAssignment.orchestratorMeta);
+                        processed++;
+                    }
+                    catch (error) {
+                        errors++;
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        errorMessages.push(`Worker ${worker.name}: ${errorMessage}`);
+                        logger.error(`Error recovering orphaned task for worker ${worker.name}:`, error);
+                    }
                 }
             }
             // --- Phase 2: Recover orphaned merge steward assignments ---
@@ -522,18 +550,18 @@ export class DispatchDaemonImpl {
                     errors++;
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     errorMessages.push(`Merge steward ${steward.name}: ${errorMessage}`);
-                    console.error(`[dispatch-daemon] Error recovering orphaned steward task for ${steward.name}:`, error);
+                    logger.error(`Error recovering orphaned steward task for ${steward.name}:`, error);
                 }
             }
             if (processed > 0) {
-                console.log(`[dispatch-daemon] Recovered ${processed} orphaned task assignment(s)`);
+                logger.info(`Recovered ${processed} orphaned task assignment(s)`);
             }
         }
         catch (error) {
             errors++;
             const errorMessage = error instanceof Error ? error.message : String(error);
             errorMessages.push(errorMessage);
-            console.error('[dispatch-daemon] Error in recoverOrphanedAssignments:', error);
+            logger.error('Error in recoverOrphanedAssignments:', error);
         }
         const result = {
             pollType: 'orphan-recovery',
@@ -578,7 +606,7 @@ export class DispatchDaemonImpl {
                     // Safety valve: skip if already reconciled 3+ times (prevents infinite loops)
                     const currentCount = orchestratorMeta.reconciliationCount ?? 0;
                     if (currentCount >= 3) {
-                        console.warn(`[dispatch-daemon] Task ${task.id} has been reconciled ${currentCount} times, skipping (safety valve)`);
+                        logger.warn(`Task ${task.id} has been reconciled ${currentCount} times, skipping (safety valve)`);
                         continue;
                     }
                     // Move back to REVIEW with incremented reconciliation count.
@@ -595,24 +623,24 @@ export class DispatchDaemonImpl {
                         }),
                     });
                     processed++;
-                    console.log(`[dispatch-daemon] Reconciled closed-but-unmerged task ${task.id} (mergeStatus=${orchestratorMeta.mergeStatus}, attempt=${currentCount + 1})`);
+                    logger.info(`Reconciled closed-but-unmerged task ${task.id} (mergeStatus=${orchestratorMeta.mergeStatus}, attempt=${currentCount + 1})`);
                 }
                 catch (error) {
                     errors++;
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     errorMessages.push(`Task ${assignment.taskId}: ${errorMessage}`);
-                    console.error(`[dispatch-daemon] Error reconciling task ${assignment.taskId}:`, error);
+                    logger.error(`Error reconciling task ${assignment.taskId}:`, error);
                 }
             }
             if (processed > 0) {
-                console.log(`[dispatch-daemon] Reconciled ${processed} closed-but-unmerged task(s)`);
+                logger.info(`Reconciled ${processed} closed-but-unmerged task(s)`);
             }
         }
         catch (error) {
             errors++;
             const errorMessage = error instanceof Error ? error.message : String(error);
             errorMessages.push(errorMessage);
-            console.error('[dispatch-daemon] Error in reconcileClosedUnmergedTasks:', error);
+            logger.error('Error in reconcileClosedUnmergedTasks:', error);
         }
         const result = {
             pollType: 'closed-unmerged-reconciliation',
@@ -665,7 +693,7 @@ export class DispatchDaemonImpl {
                     // Safety valve: skip if already recovered 3+ times
                     const currentCount = orchestratorMeta.stuckMergeRecoveryCount ?? 0;
                     if (currentCount >= 3) {
-                        console.warn(`[dispatch-daemon] Task ${task.id} has been recovered from stuck merge ${currentCount} times, skipping (safety valve)`);
+                        logger.warn(`Task ${task.id} has been recovered from stuck merge ${currentCount} times, skipping (safety valve)`);
                         continue;
                     }
                     // Reset mergeStatus to 'pending' for fresh steward pickup
@@ -689,24 +717,24 @@ export class DispatchDaemonImpl {
                         // Ignore worktree cleanup errors
                     }
                     processed++;
-                    console.log(`[dispatch-daemon] Recovered stuck merge task ${task.id} (mergeStatus=${orchestratorMeta.mergeStatus}, attempt=${currentCount + 1})`);
+                    logger.info(`Recovered stuck merge task ${task.id} (mergeStatus=${orchestratorMeta.mergeStatus}, attempt=${currentCount + 1})`);
                 }
                 catch (error) {
                     errors++;
                     const errorMessage = error instanceof Error ? error.message : String(error);
                     errorMessages.push(`Task ${assignment.taskId}: ${errorMessage}`);
-                    console.error(`[dispatch-daemon] Error recovering stuck merge task ${assignment.taskId}:`, error);
+                    logger.error(`Error recovering stuck merge task ${assignment.taskId}:`, error);
                 }
             }
             if (processed > 0) {
-                console.log(`[dispatch-daemon] Recovered ${processed} stuck merge task(s)`);
+                logger.info(`Recovered ${processed} stuck merge task(s)`);
             }
         }
         catch (error) {
             errors++;
             const errorMessage = error instanceof Error ? error.message : String(error);
             errorMessages.push(errorMessage);
-            console.error('[dispatch-daemon] Error in recoverStuckMergeTasks:', error);
+            logger.error('Error in recoverStuckMergeTasks:', error);
         }
         const stuckResult = {
             pollType: 'stuck-merge-recovery',
@@ -719,6 +747,79 @@ export class DispatchDaemonImpl {
         this.emitter.emit('poll:complete', stuckResult);
         return stuckResult;
     }
+    /**
+     * Detects active plans where all non-tombstone tasks are closed
+     * and marks them as completed.
+     */
+    async pollPlanAutoComplete() {
+        const startedAt = new Date().toISOString();
+        const startTime = Date.now();
+        let processed = 0;
+        let errors = 0;
+        const errorMessages = [];
+        this.emitter.emit('poll:start', 'plan-auto-complete');
+        try {
+            // 1. List all active plans
+            const allPlans = await this.api.list({ type: 'plan' });
+            const activePlans = allPlans.filter((p) => p.status === PlanStatus.ACTIVE);
+            // 2. Check each active plan for auto-completion eligibility
+            for (const plan of activePlans) {
+                try {
+                    // Get tasks in this plan (excluding deleted/tombstone)
+                    const tasks = await this.api.getTasksInPlan(plan.id, { includeDeleted: false });
+                    // Build status counts
+                    const statusCounts = {
+                        [TaskStatus.OPEN]: 0,
+                        [TaskStatus.IN_PROGRESS]: 0,
+                        [TaskStatus.BLOCKED]: 0,
+                        [TaskStatus.CLOSED]: 0,
+                        [TaskStatus.DEFERRED]: 0,
+                        [TaskStatus.TOMBSTONE]: 0,
+                    };
+                    for (const task of tasks) {
+                        if (task.status in statusCounts) {
+                            statusCounts[task.status]++;
+                        }
+                    }
+                    // 3. Check if plan can be auto-completed (all non-tombstone tasks are CLOSED)
+                    if (canAutoComplete(statusCounts)) {
+                        const now = new Date().toISOString();
+                        await this.api.update(plan.id, {
+                            status: PlanStatus.COMPLETED,
+                            completedAt: now,
+                        });
+                        processed++;
+                        logger.info(`Auto-completed plan ${plan.id} ("${plan.title}")`);
+                    }
+                }
+                catch (error) {
+                    errors++;
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    errorMessages.push(`Plan ${plan.id}: ${errorMessage}`);
+                    logger.error(`Error checking plan ${plan.id} for auto-completion:`, error);
+                }
+            }
+            if (processed > 0) {
+                logger.info(`Auto-completed ${processed} plan(s)`);
+            }
+        }
+        catch (error) {
+            errors++;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            errorMessages.push(errorMessage);
+            logger.error('Error in pollPlanAutoComplete:', error);
+        }
+        const result = {
+            pollType: 'plan-auto-complete',
+            startedAt,
+            durationMs: Date.now() - startTime,
+            processed,
+            errors,
+            errorMessages: errorMessages.length > 0 ? errorMessages : undefined,
+        };
+        this.emitter.emit('poll:complete', result);
+        return result;
+    }
     // ----------------------------------------
     // Configuration
     // ----------------------------------------
@@ -754,7 +855,7 @@ export class DispatchDaemonImpl {
                 await this.currentPollCycle;
             }
             catch (error) {
-                console.error('[dispatch-daemon] Poll cycle error:', error);
+                logger.error('Poll cycle error:', error);
             }
         }, this.config.pollIntervalMs);
     }
@@ -768,11 +869,14 @@ export class DispatchDaemonImpl {
             stewardTriggerPollEnabled: config?.stewardTriggerPollEnabled ?? true,
             workflowTaskPollEnabled: config?.workflowTaskPollEnabled ?? true,
             orphanRecoveryEnabled: config?.orphanRecoveryEnabled ?? true,
+            planAutoCompleteEnabled: config?.planAutoCompleteEnabled ?? true,
             closedUnmergedReconciliationEnabled: config?.closedUnmergedReconciliationEnabled ?? true,
             closedUnmergedGracePeriodMs: config?.closedUnmergedGracePeriodMs ?? 120_000,
             stuckMergeRecoveryEnabled: config?.stuckMergeRecoveryEnabled ?? true,
             stuckMergeRecoveryGracePeriodMs: config?.stuckMergeRecoveryGracePeriodMs ?? 600_000,
+            maxResumeAttemptsBeforeRecovery: config?.maxResumeAttemptsBeforeRecovery ?? 3,
             maxSessionDurationMs: config?.maxSessionDurationMs ?? 0,
+            maxStewardSessionDurationMs: config?.maxStewardSessionDurationMs ?? 30 * 60 * 1000,
             onSessionStarted: config?.onSessionStarted,
             projectRoot: config?.projectRoot ?? process.cwd(),
             directorInboxForwardingEnabled: config?.directorInboxForwardingEnabled ?? true,
@@ -820,6 +924,10 @@ export class DispatchDaemonImpl {
             if (this.config.stuckMergeRecoveryEnabled) {
                 await this.recoverStuckMergeTasks();
             }
+            // Auto-complete plans where all tasks are closed
+            if (this.config.planAutoCompleteEnabled) {
+                await this.pollPlanAutoComplete();
+            }
         }
         finally {
             this.polling = false;
@@ -828,9 +936,16 @@ export class DispatchDaemonImpl {
     /**
      * Terminates sessions that have exceeded the configured max duration.
      * Prevents stuck workers from blocking their slot indefinitely.
+     *
+     * Applies two thresholds:
+     * - `maxSessionDurationMs` — general limit for all sessions (0 = disabled)
+     * - `maxStewardSessionDurationMs` — stricter limit for steward sessions
+     *   (default 30 minutes), which are expected to be short-lived
      */
     async reapStaleSessions() {
-        if (this.config.maxSessionDurationMs <= 0)
+        const hasGeneralLimit = this.config.maxSessionDurationMs > 0;
+        const hasStewardLimit = this.config.maxStewardSessionDurationMs > 0;
+        if (!hasGeneralLimit && !hasStewardLimit)
             return;
         const running = this.sessionManager.listSessions({ status: 'running' });
         const now = Date.now();
@@ -839,7 +954,24 @@ export class DispatchDaemonImpl {
                 ? session.createdAt
                 : new Date(session.createdAt).getTime();
             const age = now - createdAt;
-            if (age > this.config.maxSessionDurationMs) {
+            // Apply steward-specific limit
+            if (hasStewardLimit && session.agentRole === 'steward' && age > this.config.maxStewardSessionDurationMs) {
+                try {
+                    await this.sessionManager.stopSession(session.id, {
+                        graceful: false,
+                        reason: `Steward session exceeded max duration (${Math.round(age / 1000)}s, limit: ${Math.round(this.config.maxStewardSessionDurationMs / 1000)}s)`,
+                    });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    if (!message.includes('not found')) {
+                        logger.warn(`Failed to reap steward session ${session.id}:`, error);
+                    }
+                }
+                continue;
+            }
+            // Apply general limit
+            if (hasGeneralLimit && age > this.config.maxSessionDurationMs) {
                 try {
                     await this.sessionManager.stopSession(session.id, {
                         graceful: false,
@@ -849,7 +981,7 @@ export class DispatchDaemonImpl {
                 catch (error) {
                     const message = error instanceof Error ? error.message : String(error);
                     if (!message.includes('not found')) {
-                        console.warn(`[dispatch-daemon] Failed to reap session ${session.id}:`, error);
+                        logger.warn(`Failed to reap session ${session.id}:`, error);
                     }
                 }
             }
@@ -918,11 +1050,11 @@ export class DispatchDaemonImpl {
                     this.config.onSessionStarted(session, events, workerId, `[resumed session for task ${task.id}]`);
                 }
                 this.emitter.emit('agent:spawned', workerId, worktreePath);
-                console.log(`[dispatch-daemon] Resumed session for orphaned task ${task.id} on worker ${worker.name}`);
+                logger.info(`Resumed session for orphaned task ${task.id} on worker ${worker.name}`);
                 return;
             }
             catch (error) {
-                console.warn(`[dispatch-daemon] Failed to resume session ${previousSessionId} for worker ${worker.name}, falling back to fresh spawn:`, error);
+                logger.warn(`Failed to resume session ${previousSessionId} for worker ${worker.name}, falling back to fresh spawn:`, error);
             }
         }
         // 3. Fall back to fresh spawn
@@ -950,7 +1082,7 @@ export class DispatchDaemonImpl {
             this.config.onSessionStarted(session, events, workerId, initialPrompt);
         }
         this.emitter.emit('agent:spawned', workerId, worktreePath);
-        console.log(`[dispatch-daemon] Spawned fresh session for orphaned task ${task.id} on worker ${worker.name}`);
+        logger.info(`Spawned fresh session for orphaned task ${task.id} on worker ${worker.name}`);
     }
     /**
      * Recovers a single orphaned merge steward task by resuming or re-spawning.
@@ -964,7 +1096,7 @@ export class DispatchDaemonImpl {
         if (worktreePath) {
             const exists = await this.worktreeManager.worktreeExists(worktreePath);
             if (!exists) {
-                console.warn(`[dispatch-daemon] Worktree ${worktreePath} no longer exists for steward task ${task.id}, using project root`);
+                logger.warn(`Worktree ${worktreePath} no longer exists for steward task ${task.id}, using project root`);
                 worktreePath = undefined;
             }
         }
@@ -1002,16 +1134,16 @@ export class DispatchDaemonImpl {
                     this.config.onSessionStarted(session, events, stewardId, `[resumed steward session for task ${task.id}]`);
                 }
                 this.emitter.emit('agent:spawned', stewardId, worktreePath);
-                console.log(`[dispatch-daemon] Resumed steward session for orphaned task ${task.id} on ${steward.name}`);
+                logger.info(`Resumed steward session for orphaned task ${task.id} on ${steward.name}`);
                 return;
             }
             catch (error) {
-                console.warn(`[dispatch-daemon] Failed to resume steward session ${previousSessionId} for ${steward.name}, falling back to fresh spawn:`, error);
+                logger.warn(`Failed to resume steward session ${previousSessionId} for ${steward.name}, falling back to fresh spawn:`, error);
             }
         }
         // 3. Fall back to fresh spawn (spawnMergeStewardForTask handles metadata update AND session history)
         await this.spawnMergeStewardForTask(steward, task);
-        console.log(`[dispatch-daemon] Spawned fresh steward session for orphaned task ${task.id} on ${steward.name}`);
+        logger.info(`Spawned fresh steward session for orphaned task ${task.id} on ${steward.name}`);
     }
     /**
      * Assigns the highest priority unassigned task to a worker.
@@ -1041,7 +1173,7 @@ export class DispatchDaemonImpl {
                 };
                 const poolCheck = await this.poolService.canSpawn(spawnRequest);
                 if (!poolCheck.canSpawn) {
-                    console.log(`[dispatch-daemon] Pool capacity reached for worker ${worker.name}: ${poolCheck.reason}`);
+                    logger.debug(`Pool capacity reached for worker ${worker.name}: ${poolCheck.reason}`);
                     return false;
                 }
             }
@@ -1193,7 +1325,7 @@ export class DispatchDaemonImpl {
      *
      * @param task - The task being reviewed
      * @param stewardId - The steward's entity ID
-     * @param stewardFocus - The steward's focus area (merge or health)
+     * @param stewardFocus - The steward's focus area (merge, docs, or custom)
      * @param syncResult - Optional result from pre-spawn branch sync
      */
     async buildStewardPrompt(task, stewardId, stewardFocus = 'merge', syncResult) {
@@ -1285,7 +1417,7 @@ export class DispatchDaemonImpl {
             };
             const poolCheck = await this.poolService.canSpawn(spawnRequest);
             if (!poolCheck.canSpawn) {
-                console.log(`[dispatch-daemon] Pool capacity reached for steward ${steward.name}: ${poolCheck.reason}`);
+                logger.debug(`Pool capacity reached for steward ${steward.name}: ${poolCheck.reason}`);
                 return;
             }
         }
@@ -1297,7 +1429,7 @@ export class DispatchDaemonImpl {
         if (worktreePath) {
             const exists = await this.worktreeManager.worktreeExists(worktreePath);
             if (!exists) {
-                console.warn(`[dispatch-daemon] Worktree ${worktreePath} no longer exists for task ${task.id}, creating fresh worktree`);
+                logger.warn(`Worktree ${worktreePath} no longer exists for task ${task.id}, creating fresh worktree`);
                 const sourceBranch = orchestratorMeta?.branch;
                 if (sourceBranch) {
                     try {
@@ -1308,7 +1440,7 @@ export class DispatchDaemonImpl {
                         worktreePath = result.path;
                     }
                     catch (e) {
-                        console.error(`[dispatch-daemon] Failed to create steward worktree: ${e}`);
+                        logger.error(`Failed to create steward worktree: ${e}`);
                         worktreePath = undefined;
                     }
                 }
@@ -1330,7 +1462,7 @@ export class DispatchDaemonImpl {
         // This ensures `git diff origin/master..HEAD` shows only the task's changes
         let syncResult;
         if (worktreePath) {
-            console.log(`[dispatch-daemon] Syncing task ${task.id} branch before steward spawn...`);
+            logger.debug(`Syncing task ${task.id} branch before steward spawn...`);
             syncResult = await this.syncTaskBranch(task);
             // Store sync result in task metadata for audit trail
             await this.api.update(task.id, {
@@ -1388,7 +1520,203 @@ export class DispatchDaemonImpl {
             await this.poolService.onAgentSpawned(stewardId);
         }
         this.emitter.emit('agent:spawned', stewardId, worktreePath);
-        console.log(`[dispatch-daemon] Spawned merge steward ${steward.name} for task ${task.id}`);
+        logger.info(`Spawned merge steward ${steward.name} for task ${task.id}`);
+    }
+    /**
+     * Spawns a recovery steward for a task stuck in a resume loop.
+     *
+     * When a worker session exits without calling `sf task complete` or
+     * `sf task handoff`, the orphan recovery loop resumes it. After
+     * maxResumeAttemptsBeforeRecovery consecutive resumes without a status
+     * change, this method is called instead to:
+     * 1. Unassign the worker from the task
+     * 2. Find an available recovery steward (or any available steward)
+     * 3. Spawn a recovery steward session with full task context
+     *
+     * @param worker - The worker that was assigned to the stuck task
+     * @param task - The stuck task
+     * @param taskMeta - The task's orchestrator metadata
+     */
+    async spawnRecoveryStewardForTask(worker, task, taskMeta) {
+        const workerId = asEntityId(worker.id);
+        // 1. Find an available recovery steward
+        const stewards = await this.agentRegistry.listAgents({
+            role: 'steward',
+            stewardFocus: 'recovery',
+        });
+        // Find a steward without an active session
+        let recoverySteward;
+        for (const steward of stewards) {
+            const session = this.sessionManager.getActiveSession(asEntityId(steward.id));
+            if (!session) {
+                recoverySteward = steward;
+                break;
+            }
+        }
+        if (!recoverySteward) {
+            // No recovery steward available — emit a notification and leave the task as-is
+            this.emitter.emit('daemon:notification', {
+                type: 'warning',
+                title: 'Recovery steward unavailable',
+                message: `Task ${task.id} is stuck after ${taskMeta?.resumeCount ?? 0} resume attempts, but no recovery steward is available. The task will not be resumed again until a recovery steward is available.`,
+            });
+            logger.warn(`No available recovery steward for stuck task ${task.id}. ` +
+                `Task has been resumed ${taskMeta?.resumeCount ?? 0} times without status change.`);
+            return;
+        }
+        const stewardId = asEntityId(recoverySteward.id);
+        // 2. Check pool capacity before spawning
+        const stewardMeta = getAgentMetadata(recoverySteward);
+        if (this.poolService && stewardMeta) {
+            const spawnRequest = {
+                role: 'steward',
+                stewardFocus: stewardMeta.stewardFocus,
+                agentId: stewardId,
+            };
+            const poolCheck = await this.poolService.canSpawn(spawnRequest);
+            if (!poolCheck.canSpawn) {
+                logger.debug(`Pool capacity reached for recovery steward ${recoverySteward.name}: ${poolCheck.reason}`);
+                return;
+            }
+        }
+        // 3. Resolve worktree — reuse the worker's existing worktree
+        let worktreePath = taskMeta?.worktree ?? taskMeta?.handoffWorktree;
+        const branch = taskMeta?.branch ?? taskMeta?.handoffBranch;
+        if (worktreePath) {
+            const exists = await this.worktreeManager.worktreeExists(worktreePath);
+            if (!exists) {
+                logger.warn(`Worktree ${worktreePath} no longer exists for stuck task ${task.id}`);
+                // Try to create a read-only worktree for the steward
+                if (branch) {
+                    try {
+                        const result = await this.worktreeManager.createReadOnlyWorktree({
+                            agentName: stewardId,
+                            purpose: `recovery-${task.id}`,
+                        });
+                        worktreePath = result.path;
+                    }
+                    catch (e) {
+                        logger.error(`Failed to create recovery steward worktree: ${e}`);
+                        worktreePath = undefined;
+                    }
+                }
+                else {
+                    worktreePath = undefined;
+                }
+            }
+        }
+        // Guard: never spawn a steward without a worktree
+        if (!worktreePath) {
+            this.emitter.emit('daemon:notification', {
+                type: 'warning',
+                title: 'Recovery steward skipped',
+                message: `Cannot spawn recovery steward for task ${task.id}: worktree missing and no branch info available to create a new one.`,
+            });
+            return;
+        }
+        // 4. Unassign the worker from the task
+        await this.api.update(task.id, {
+            assignee: undefined,
+            metadata: updateOrchestratorTaskMeta(task.metadata, {
+                assignedAgent: stewardId,
+            }),
+        });
+        // 5. Build the recovery steward prompt
+        const initialPrompt = await this.buildRecoveryStewardPrompt(task, stewardId, taskMeta);
+        // 6. Start the recovery steward session
+        const { session, events } = await this.sessionManager.startSession(stewardId, {
+            workingDirectory: worktreePath,
+            worktree: worktreePath,
+            initialPrompt,
+            interactive: false, // Stewards use headless mode
+        });
+        // 7. Record steward assignment and session history on the task
+        const taskAfterUpdate = await this.api.get(task.id);
+        const sessionHistoryEntry = {
+            sessionId: session.id,
+            providerSessionId: session.providerSessionId,
+            agentId: stewardId,
+            agentName: recoverySteward.name,
+            agentRole: 'steward',
+            startedAt: createTimestamp(),
+        };
+        const metadataWithHistory = appendTaskSessionHistory(taskAfterUpdate?.metadata, sessionHistoryEntry);
+        const finalMetadata = updateOrchestratorTaskMeta(metadataWithHistory, {
+            assignedAgent: stewardId,
+            sessionId: session.providerSessionId ?? session.id,
+        });
+        await this.api.update(task.id, {
+            assignee: stewardId,
+            metadata: finalMetadata,
+        });
+        // 8. Callbacks and notifications
+        if (this.config.onSessionStarted) {
+            this.config.onSessionStarted(session, events, stewardId, initialPrompt);
+        }
+        if (this.poolService) {
+            await this.poolService.onAgentSpawned(stewardId);
+        }
+        this.emitter.emit('agent:spawned', stewardId, worktreePath);
+    }
+    /**
+     * Builds the initial prompt for a recovery steward session.
+     * Includes the steward-recovery role prompt followed by task context,
+     * session history, and resume count information.
+     *
+     * @param task - The stuck task
+     * @param stewardId - The recovery steward's entity ID
+     * @param taskMeta - The task's orchestrator metadata
+     */
+    async buildRecoveryStewardPrompt(task, stewardId, taskMeta) {
+        const parts = [];
+        // Load the recovery steward role prompt
+        const roleResult = loadRolePrompt('steward', 'recovery', { projectRoot: this.config.projectRoot });
+        if (roleResult) {
+            parts.push('Please read and internalize the following operating instructions. These define your role and how you should behave:', '', roleResult.prompt, '', '---', '');
+        }
+        // Get the director ID for context
+        const director = await this.agentRegistry.getDirector();
+        const directorId = director?.id ?? 'unknown';
+        const branch = taskMeta?.branch ?? taskMeta?.handoffBranch;
+        const worktree = taskMeta?.worktree ?? taskMeta?.handoffWorktree;
+        const resumeCount = taskMeta?.resumeCount ?? 0;
+        parts.push('## Recovery Assignment', '', `**Steward ID:** ${stewardId}`, `**Director ID:** ${directorId}`, `**Task ID:** ${task.id}`, `**Title:** ${task.title}`, `**Status:** ${task.status}`);
+        if (branch) {
+            parts.push(`**Branch:** ${branch}`);
+        }
+        if (worktree) {
+            parts.push(`**Worktree:** ${worktree}`);
+        }
+        if (task.priority !== undefined) {
+            parts.push(`**Priority:** ${task.priority}`);
+        }
+        parts.push('', '## Recovery Context', '', `This task has been resumed **${resumeCount} times** without a status change.`, 'The previous worker session exited without calling `sf task complete` or `sf task handoff`.', 'This indicates the worker may have crashed, lost context, or encountered an unrecoverable error.', '');
+        // Include session history if available
+        if (taskMeta?.sessionHistory && taskMeta.sessionHistory.length > 0) {
+            parts.push('### Session History', '');
+            for (const entry of taskMeta.sessionHistory) {
+                const ended = entry.endedAt ? ` → ${entry.endedAt}` : ' (may still be running)';
+                parts.push(`- **${entry.agentRole}** ${entry.agentName} (${entry.sessionId}): ${entry.startedAt}${ended}`);
+            }
+            parts.push('');
+        }
+        // Fetch and include the description content
+        if (task.descriptionRef) {
+            try {
+                const doc = await this.api.get(asElementId(task.descriptionRef));
+                if (doc?.content) {
+                    parts.push('### Task Description', doc.content);
+                }
+            }
+            catch {
+                parts.push(`**Description Document:** ${task.descriptionRef}`);
+            }
+        }
+        // Include acceptance criteria if any
+        if (task.acceptanceCriteria) {
+            parts.push('', '### Acceptance Criteria', task.acceptanceCriteria);
+        }
+        return parts.join('\n');
     }
     /**
      * Processes an inbox item for an agent.
@@ -1540,7 +1868,7 @@ export class DispatchDaemonImpl {
                 processed += channelItems.length;
             }
             catch (error) {
-                console.error(`[dispatch-daemon] Failed to spawn triage session for agent ${agent.name}:`, error);
+                logger.error(`Failed to spawn triage session for agent ${agent.name}:`, error);
             }
             // Only one triage session per poll cycle per agent — remaining channels
             // will be picked up in subsequent cycles
@@ -1629,7 +1957,7 @@ export class DispatchDaemonImpl {
                 this.inboxService.markAsReadBatch(items.map((item) => item.id));
             }
             catch (error) {
-                console.warn('[dispatch-daemon] Failed to mark triage items as read:', error);
+                logger.warn('Failed to mark triage items as read:', error);
             }
             try {
                 await this.worktreeManager.removeWorktree(worktreeResult.path);
@@ -1665,7 +1993,7 @@ export class DispatchDaemonImpl {
                     }
                 }
                 catch (error) {
-                    console.warn(`[dispatch-daemon] Failed to fetch content for message ${message.id}:`, error);
+                    logger.warn(`Failed to fetch content for message ${message.id}:`, error);
                 }
             }
             formattedMessages.push(`--- Inbox Item ID: ${inboxItemId} | Message ID: ${message.id} | From: ${senderId} | At: ${timestamp} ---`, content, '');
@@ -1692,7 +2020,7 @@ export class DispatchDaemonImpl {
                 }
             }
             catch (error) {
-                console.warn(`[dispatch-daemon] Failed to fetch content for forwarded message ${message.id}:`, error);
+                logger.warn(`Failed to fetch content for forwarded message ${message.id}:`, error);
             }
         }
         return content; // No prefix — messageSession() handles the [Message from ...] prefix
@@ -1768,7 +2096,7 @@ export class DispatchDaemonImpl {
                 timeout: 120_000,
             });
             // Merge succeeded
-            console.log(`[dispatch-daemon] Synced task ${task.id} branch with ${remoteBranch}`);
+            logger.debug(`Synced task ${task.id} branch with ${remoteBranch}`);
             return {
                 success: true,
                 message: `Branch synced with ${remoteBranch}`,
@@ -1791,7 +2119,7 @@ export class DispatchDaemonImpl {
                     conflicts.push(match[2]);
                 }
                 if (conflicts.length > 0) {
-                    console.log(`[dispatch-daemon] Merge conflicts detected for task ${task.id}: ${conflicts.join(', ')}`);
+                    logger.debug(`Merge conflicts detected for task ${task.id}: ${conflicts.join(', ')}`);
                     return {
                         success: false,
                         conflicts,