@jungjaehoon/mama-os 0.9.2 → 0.9.3

package/dist/multi-agent/ultrawork.js

@@ -5,22 +5,65 @@
  * Manages autonomous multi-step work sessions that combine
  * delegation and task continuation for extended workflows.
  *
- * UltraWork sessions allow a Tier 1 lead agent to autonomously
- * orchestrate work by delegating tasks, continuing incomplete
- * responses, and coordinating with other agents.
+ * Supports two modes:
+ * 1. **Phased Loop** (Ralph Loop, default): Plan -> Build -> Retrospective
+ *    - File-based state persist for crash recovery
+ *    - Council integration at plan and retrospective phases
+ *    - Structured task execution from plan
+ * 2. **Freeform Loop** (legacy): Lead agent freely delegates and continues
  *
  * Constraints:
  * - max_duration (default 30 min)
  * - max_steps (default 20)
  * - Lead agent must be Tier 1 with can_delegate
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UltraWorkManager = void 0;
 const tool_permission_manager_js_1 = require("./tool-permission-manager.js");
 const delegation_manager_js_1 = require("./delegation-manager.js");
 const task_continuation_js_1 = require("./task-continuation.js");
+const ultrawork_state_js_1 = require("./ultrawork-state.js");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
 /** Default timeout for executeCallback (5 minutes) */
 const DEFAULT_EXECUTE_TIMEOUT = 300000;
+/** Default stall threshold — if response is too short, likely stalled */
+const STALL_MIN_LENGTH = 20;
+/** Max consecutive stalls before forcing a re-prompt */
+const MAX_CONSECUTIVE_STALLS = 2;
 /**
  * Default trigger keywords for UltraWork
  */
@@ -37,6 +80,7 @@ const DEFAULT_TRIGGER_KEYWORDS = [
 class UltraWorkManager {
     config;
     permissionManager;
+    stateManager = null;
     /** Active sessions per channel */
     sessions = new Map();
     /** Session counter for unique IDs */
@@ -44,6 +88,9 @@ class UltraWorkManager {
     constructor(config, permissionManager) {
         this.config = config;
         this.permissionManager = permissionManager ?? new tool_permission_manager_js_1.ToolPermissionManager();
+        if (config.persist_state !== false) {
+            this.stateManager = new ultrawork_state_js_1.UltraWorkStateManager(path.join(os.homedir(), '.mama', 'workspace', 'ultrawork'));
+        }
     }
     /**
      * Check if a message contains UltraWork trigger keywords.
@@ -58,7 +105,7 @@ class UltraWorkManager {
     /**
      * Start a new UltraWork session.
      */
-    async startSession(channelId, leadAgentId, task, agents, executeCallback, notifyCallback) {
+    async startSession(channelId, leadAgentId, task, agents, executeCallback, notifyCallback, responseInterceptor) {
         // Validate lead agent
         const leadAgent = agents.find((a) => a.id === leadAgentId);
         if (!leadAgent) {
@@ -84,13 +131,18 @@ class UltraWorkManager {
             steps: [],
         };
         this.sessions.set(channelId, session);
+        // Persist session state
+        if (this.stateManager) {
+            await this.stateManager.createSession(session.id, task, agents.filter((a) => a.enabled !== false).map((a) => a.id));
+        }
+        const modeLabel = this.config.phased_loop !== false ? 'Phased (Plan->Build->Retro)' : 'Freeform';
         await notifyCallback(`**UltraWork Session Started** (${session.id})\n` +
             `Lead: **${leadAgent.display_name}**\n` +
+            `Mode: ${modeLabel}\n` +
             `Task: ${task.substring(0, 200)}${task.length > 200 ? '...' : ''}\n` +
             `Limits: ${session.maxSteps} steps, ${Math.round(session.maxDuration / 60000)} min`);
         // Run the autonomous loop in detached context (non-blocking)
-        // This prevents blocking the Discord message handler for up to 30 minutes
-        this.runSessionLoop(session, agents, executeCallback, notifyCallback).catch((err) => {
+        this.runSessionLoop(session, agents, executeCallback, notifyCallback, responseInterceptor).catch((err) => {
             console.error(`[UltraWork] Session ${session.id} loop error:`, err);
             session.active = false;
             this.sessions.delete(session.channelId);
@@ -145,15 +197,20 @@ class UltraWorkManager {
     updateConfig(config) {
         this.config = config;
     }
+    /**
+     * Get the state manager (for testing).
+     */
+    getStateManager() {
+        return this.stateManager;
+    }
+    /**
+     * Override state manager (for testing with temp dirs).
+     */
+    setStateManager(sm) {
+        this.stateManager = sm;
+    }
     /**
      * Execute callback with timeout protection.
-     * Prevents long-running agent responses from blocking indefinitely.
-     *
-     * @param executeCallback - The callback to execute
-     * @param agentId - Agent ID for error messages
-     * @param prompt - Prompt to send to agent
-     * @param timeoutMs - Timeout in milliseconds (default: 5 minutes)
-     * @returns Promise that rejects on timeout
      */
     async executeWithTimeout(executeCallback, agentId, prompt, timeoutMs = DEFAULT_EXECUTE_TIMEOUT) {
         let timeoutHandle;
@@ -167,29 +224,424 @@ class UltraWorkManager {
         return result;
     }
     /**
-     * Run the autonomous session loop.
-     * Lead agent works on the task, delegating and continuing as needed.
+     * Run the autonomous session loop — dispatches to phased or freeform mode.
      */
-    async runSessionLoop(session, agents, executeCallback, notifyCallback) {
+    async runSessionLoop(session, agents, executeCallback, notifyCallback, responseInterceptor) {
+        if (this.config.phased_loop !== false) {
+            await this.runPhasedLoop(session, agents, executeCallback, notifyCallback, responseInterceptor);
+        }
+        else {
+            await this.runFreeformLoop(session, agents, executeCallback, notifyCallback, responseInterceptor);
+        }
+    }
+    // ============================================================================
+    // Phase 1: Planning
+    // ============================================================================
+    async runPlanningPhase(session, agents, executeCallback, notifyCallback, responseInterceptor) {
+        await notifyCallback(`**Phase 1: Planning** - Creating implementation plan...`);
+        session.currentStep++;
+        const planPrompt = this.buildPlanningPrompt(session.task, agents);
+        const planResult = await this.executeWithTimeout(executeCallback, session.leadAgentId, planPrompt);
+        session.steps.push({
+            stepNumber: session.currentStep,
+            agentId: session.leadAgentId,
+            action: 'planning',
+            responseSummary: planResult.response.substring(0, 200),
+            isDelegation: false,
+            duration: planResult.duration ?? 0,
+            timestamp: Date.now(),
+        });
+        // Council check — if Conductor outputs council_plan, interceptor will handle it
+        let councilResult = null;
+        if (responseInterceptor) {
+            const intercepted = await responseInterceptor(planResult.response, session.channelId);
+            if (intercepted?.type === 'council') {
+                councilResult = intercepted.result;
+                await notifyCallback(councilResult);
+                session.currentStep++;
+                session.steps.push({
+                    stepNumber: session.currentStep,
+                    agentId: session.leadAgentId,
+                    action: 'council_execution',
+                    responseSummary: councilResult.substring(0, 200),
+                    isDelegation: false,
+                    duration: 0,
+                    timestamp: Date.now(),
+                });
+            }
+        }
+        // Synthesize final plan (with council input if available)
+        let finalPlan;
+        if (councilResult) {
+            session.currentStep++;
+            const synthesisPrompt = `Based on the council discussion:\n---\n${councilResult}\n---\n\n` +
+                `Create the final IMPLEMENTATION_PLAN. Format:\n## Tasks\n1. [task description] - assigned to: [agent_id]\n2. ...\n\n` +
+                `Include acceptance criteria for each task. End with "PLAN_COMPLETE".`;
+            const synthesis = await this.executeWithTimeout(executeCallback, session.leadAgentId, synthesisPrompt);
+            finalPlan = synthesis.response;
+            session.steps.push({
+                stepNumber: session.currentStep,
+                agentId: session.leadAgentId,
+                action: 'plan_synthesis',
+                responseSummary: finalPlan.substring(0, 200),
+                isDelegation: false,
+                duration: synthesis.duration ?? 0,
+                timestamp: Date.now(),
+            });
+        }
+        else {
+            finalPlan = planResult.response;
+        }
+        // Persist plan
+        if (this.stateManager) {
+            await this.stateManager.savePlan(session.id, finalPlan);
+        }
+        return finalPlan;
+    }
+    // ============================================================================
+    // Phase 2: Building
+    // ============================================================================
+    async runBuildingPhase(session, plan, agents, executeCallback, notifyCallback, responseInterceptor) {
+        await notifyCallback(`**Phase 2: Building** - Executing plan...`);
+        const delegationManager = new delegation_manager_js_1.DelegationManager(agents, this.permissionManager);
+        const continuationEnforcer = new task_continuation_js_1.TaskContinuationEnforcer({
+            enabled: true,
+            max_retries: 3,
+        });
+        let consecutiveStalls = 0;
+        let currentPrompt = this.buildBuildingPrompt(plan, agents);
+        let currentAgentId = session.leadAgentId;
+        while (this.shouldContinue(session)) {
+            session.currentStep++;
+            const stepStart = Date.now();
+            try {
+                const result = await this.executeWithTimeout(executeCallback, currentAgentId, currentPrompt);
+                const stepDuration = Date.now() - stepStart;
+                // Stall detection
+                if (result.response.trim().length < STALL_MIN_LENGTH) {
+                    consecutiveStalls++;
+                    if (consecutiveStalls >= MAX_CONSECUTIVE_STALLS) {
+                        consecutiveStalls = 0;
+                        await notifyCallback(`Agent ${currentAgentId} appears stalled (${MAX_CONSECUTIVE_STALLS} short responses). Re-prompting...`);
+                        currentPrompt =
+                            `Your previous responses were too brief. The task is NOT complete yet.\n\n` +
+                                `Original plan:\n${plan.substring(0, 1000)}\n\n` +
+                                `Please continue executing the plan. When ALL tasks are done, respond with "BUILD_COMPLETE".`;
+                        currentAgentId = session.leadAgentId;
+                        session.steps.push({
+                            stepNumber: session.currentStep,
+                            agentId: currentAgentId,
+                            action: 'stall_detected',
+                            responseSummary: `Stalled: "${result.response.trim().substring(0, 100)}"`,
+                            isDelegation: false,
+                            duration: stepDuration,
+                            timestamp: Date.now(),
+                        });
+                        continue;
+                    }
+                }
+                else {
+                    consecutiveStalls = 0;
+                }
+                // Council/workflow interceptor
+                if (responseInterceptor) {
+                    const intercepted = await responseInterceptor(result.response, session.channelId);
+                    if (intercepted) {
+                        session.steps.push({
+                            stepNumber: session.currentStep,
+                            agentId: currentAgentId,
+                            action: intercepted.type === 'council' ? 'council_execution' : 'workflow_execution',
+                            responseSummary: intercepted.result.substring(0, 200),
+                            isDelegation: false,
+                            duration: Date.now() - stepStart,
+                            timestamp: Date.now(),
+                        });
+                        await notifyCallback(intercepted.result);
+                        currentPrompt =
+                            `The ${intercepted.type} plan completed. Results:\n---\n${intercepted.result.substring(0, 1000)}\n---\n` +
+                                `Continue executing the plan. When ALL tasks are done, respond with "BUILD_COMPLETE".`;
+                        currentAgentId = session.leadAgentId;
+                        continue;
+                    }
+                }
+                // Delegation check
+                const delegationRequest = delegationManager.parseDelegation(currentAgentId, result.response);
+                if (delegationRequest) {
+                    session.steps.push({
+                        stepNumber: session.currentStep,
+                        agentId: currentAgentId,
+                        action: 'delegation',
+                        responseSummary: delegationRequest.originalContent.substring(0, 200),
+                        isDelegation: true,
+                        duration: stepDuration,
+                        timestamp: Date.now(),
+                    });
+                    const delegationResult = await delegationManager.executeDelegation(delegationRequest, executeCallback, notifyCallback);
+                    if (delegationResult.success && delegationResult.response) {
+                        session.currentStep++;
+                        session.steps.push({
+                            stepNumber: session.currentStep,
+                            agentId: delegationRequest.toAgentId,
+                            action: 'delegated_task',
+                            responseSummary: delegationResult.response.substring(0, 200),
+                            isDelegation: false,
+                            duration: delegationResult.duration ?? 0,
+                            timestamp: Date.now(),
+                        });
+                        // Persist step
+                        if (this.stateManager) {
+                            await this.stateManager.recordStep(session.id, {
+                                stepNumber: session.currentStep,
+                                agentId: delegationRequest.toAgentId,
+                                action: 'delegated_task',
+                                responseSummary: delegationResult.response.substring(0, 200),
+                                isDelegation: false,
+                                duration: delegationResult.duration ?? 0,
+                                timestamp: Date.now(),
+                            });
+                        }
+                        currentPrompt = this.buildContinuationAfterDelegation(delegationRequest.toAgentId, delegationResult.response);
+                        currentAgentId = session.leadAgentId;
+                    }
+                    else {
+                        currentPrompt = `Delegation to ${delegationRequest.toAgentId} failed: ${delegationResult.error}. Please continue the task yourself.`;
+                        currentAgentId = session.leadAgentId;
+                    }
+                }
+                else {
+                    // No delegation — record step, check build completion
+                    session.steps.push({
+                        stepNumber: session.currentStep,
+                        agentId: currentAgentId,
+                        action: 'direct_work',
+                        responseSummary: result.response.substring(0, 200),
+                        isDelegation: false,
+                        duration: stepDuration,
+                        timestamp: Date.now(),
+                    });
+                    // Persist step
+                    if (this.stateManager) {
+                        await this.stateManager.recordStep(session.id, {
+                            stepNumber: session.currentStep,
+                            agentId: currentAgentId,
+                            action: 'direct_work',
+                            responseSummary: result.response.substring(0, 200),
+                            isDelegation: false,
+                            duration: stepDuration,
+                            timestamp: Date.now(),
+                        });
+                    }
+                    // Build-phase completion check
+                    if (this.isBuildComplete(result.response)) {
+                        return; // Move to retrospective
+                    }
+                    // Fallback: use continuation enforcer for "DONE" compat
+                    const continuation = continuationEnforcer.analyzeResponse(currentAgentId, session.channelId, result.response);
+                    if (continuation.isComplete) {
+                        return; // Move to retrospective
+                    }
+                    if (continuation.maxRetriesReached) {
+                        return; // Move to retrospective anyway
+                    }
+                    currentPrompt = continuationEnforcer.buildContinuationPrompt(result.response);
+                    currentAgentId = session.leadAgentId;
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                session.steps.push({
+                    stepNumber: session.currentStep,
+                    agentId: currentAgentId,
+                    action: 'error',
+                    responseSummary: errorMessage.substring(0, 200),
+                    isDelegation: false,
+                    duration: Date.now() - stepStart,
+                    timestamp: Date.now(),
+                });
+                currentPrompt = `An error occurred: ${errorMessage}. Please assess the situation and decide how to continue.`;
+                currentAgentId = session.leadAgentId;
+            }
+        }
+    }
+    // ============================================================================
+    // Phase 3: Retrospective
+    // ============================================================================
+    async runRetrospectivePhase(session, planFromPhase1, _agents, executeCallback, notifyCallback, responseInterceptor) {
+        await notifyCallback(`**Phase 3: Retrospective** - Reviewing results...`);
+        const steps = this.stateManager
+            ? await this.stateManager.loadProgress(session.id)
+            : session.steps;
+        const plan = this.stateManager
+            ? ((await this.stateManager.loadPlan(session.id)) ?? planFromPhase1)
+            : planFromPhase1;
+        session.currentStep++;
+        const retroPrompt = this.buildRetrospectivePrompt(plan, steps);
+        const retroResult = await this.executeWithTimeout(executeCallback, session.leadAgentId, retroPrompt);
+        session.steps.push({
+            stepNumber: session.currentStep,
+            agentId: session.leadAgentId,
+            action: 'retrospective',
+            responseSummary: retroResult.response.substring(0, 200),
+            isDelegation: false,
+            duration: retroResult.duration ?? 0,
+            timestamp: Date.now(),
+        });
+        // Council check
+        if (responseInterceptor) {
+            const intercepted = await responseInterceptor(retroResult.response, session.channelId);
+            if (intercepted?.type === 'council') {
+                await notifyCallback(intercepted.result);
+                session.currentStep++;
+                session.steps.push({
+                    stepNumber: session.currentStep,
+                    agentId: session.leadAgentId,
+                    action: 'council_execution',
+                    responseSummary: intercepted.result.substring(0, 200),
+                    isDelegation: false,
+                    duration: 0,
+                    timestamp: Date.now(),
+                });
+            }
+        }
+        const isComplete = this.isRetroComplete(retroResult.response);
+        // Persist retrospective
+        if (this.stateManager) {
+            await this.stateManager.saveRetrospective(session.id, retroResult.response);
+        }
+        return { complete: isComplete, retro: retroResult.response };
+    }
+    // ============================================================================
+    // Phased Loop (Ralph Loop): Plan -> Build -> Retrospective
+    // ============================================================================
+    async runPhasedLoop(session, agents, executeCallback, notifyCallback, responseInterceptor) {
+        // Phase 1: Planning + Council
+        if (this.stateManager) {
+            await this.stateManager.updatePhase(session.id, 'planning');
+        }
+        const plan = await this.runPlanningPhase(session, agents, executeCallback, notifyCallback, responseInterceptor);
+        if (!this.shouldContinue(session)) {
+            this.endSession(session, notifyCallback);
+            return;
+        }
+        // Phase 2: Building
+        if (this.stateManager) {
+            await this.stateManager.updatePhase(session.id, 'building');
+        }
+        await this.runBuildingPhase(session, plan, agents, executeCallback, notifyCallback, responseInterceptor);
+        if (!this.shouldContinue(session)) {
+            this.endSession(session, notifyCallback);
+            return;
+        }
+        // Phase 3: Retrospective + Council
+        if (this.stateManager) {
+            await this.stateManager.updatePhase(session.id, 'retrospective');
+        }
+        const { complete } = await this.runRetrospectivePhase(session, plan, agents, executeCallback, notifyCallback, responseInterceptor);
+        if (!complete && this.shouldContinue(session)) {
+            // Incomplete → re-enter Build phase (max 1 retry)
+            await notifyCallback(`Retrospective found incomplete items. Re-entering Build phase...`);
+            if (this.stateManager) {
+                await this.stateManager.updatePhase(session.id, 'building');
+            }
+            await this.runBuildingPhase(session, plan, agents, executeCallback, notifyCallback, responseInterceptor);
+            // Re-run retrospective after retry Build phase
+            if (!this.shouldContinue(session)) {
+                // Session cancelled or limits exceeded
+                session.active = false;
+                this.sessions.delete(session.channelId);
+                await notifyCallback(`**UltraWork Session Ended** — limits exceeded or cancelled`);
+                return;
+            }
+            if (this.stateManager) {
+                await this.stateManager.updatePhase(session.id, 'retrospective');
+            }
+            const retryRetro = await this.runRetrospectivePhase(session, plan, agents, executeCallback, notifyCallback, responseInterceptor);
+            if (!retryRetro.complete) {
+                // Still incomplete after retry — end session with warning
+                if (this.stateManager) {
+                    await this.stateManager.updatePhase(session.id, 'completed');
+                }
+                session.active = false;
+                this.sessions.delete(session.channelId);
+                await notifyCallback(`**UltraWork Session Complete** (${session.id}) — with incomplete items\n` +
+                    `Phases: Plan -> Build -> Retro -> Build (retry) -> Retro\n` +
+                    `Steps: ${session.currentStep} | Duration: ${Math.round((Date.now() - session.startTime) / 1000)}s`);
+                return;
+            }
+        }
+        // Complete
+        if (this.stateManager) {
+            await this.stateManager.updatePhase(session.id, 'completed');
+        }
+        session.active = false;
+        this.sessions.delete(session.channelId);
+        await notifyCallback(`**UltraWork Session Complete** (${session.id})\n` +
+            `Phases: Plan -> Build -> Retrospective\n` +
+            `Steps: ${session.currentStep} | Duration: ${Math.round((Date.now() - session.startTime) / 1000)}s`);
+    }
+    // ============================================================================
+    // Freeform Loop (Legacy)
+    // ============================================================================
+    async runFreeformLoop(session, agents, executeCallback, notifyCallback, responseInterceptor) {
         const delegationManager = new delegation_manager_js_1.DelegationManager(agents, this.permissionManager);
         const continuationEnforcer = new task_continuation_js_1.TaskContinuationEnforcer({
             enabled: true,
             max_retries: 3,
         });
-        // Initial prompt for lead agent
+        let consecutiveStalls = 0;
         let currentPrompt = this.buildInitialPrompt(session.task, agents);
         let currentAgentId = session.leadAgentId;
         while (this.shouldContinue(session)) {
             session.currentStep++;
             const stepStart = Date.now();
             try {
-                // Execute current agent's task with timeout protection
                 const result = await this.executeWithTimeout(executeCallback, currentAgentId, currentPrompt);
                 const stepDuration = Date.now() - stepStart;
-                // Check for delegation in response
+                // Stall detection
+                if (result.response.trim().length < STALL_MIN_LENGTH) {
+                    consecutiveStalls++;
+                    if (consecutiveStalls >= MAX_CONSECUTIVE_STALLS) {
+                        consecutiveStalls = 0;
+                        await notifyCallback(`Agent ${currentAgentId} appears stalled (${MAX_CONSECUTIVE_STALLS} short responses). Re-prompting...`);
+                        currentPrompt = `Your previous responses were too brief. The task is NOT complete yet.\n\nOriginal task: ${session.task}\n\nPlease take concrete action now. When fully done, respond with "DONE".`;
+                        currentAgentId = session.leadAgentId;
+                        session.steps.push({
+                            stepNumber: session.currentStep,
+                            agentId: currentAgentId,
+                            action: 'stall_detected',
+                            responseSummary: `Stalled: "${result.response.trim().substring(0, 100)}"`,
+                            isDelegation: false,
+                            duration: stepDuration,
+                            timestamp: Date.now(),
+                        });
+                        continue;
+                    }
+                }
+                else {
+                    consecutiveStalls = 0;
+                }
+                // Council/workflow interceptor
+                if (responseInterceptor) {
+                    const intercepted = await responseInterceptor(result.response, session.channelId);
+                    if (intercepted) {
+                        session.steps.push({
+                            stepNumber: session.currentStep,
+                            agentId: currentAgentId,
+                            action: intercepted.type === 'council' ? 'council_execution' : 'workflow_execution',
+                            responseSummary: intercepted.result.substring(0, 200),
+                            isDelegation: false,
+                            duration: Date.now() - stepStart,
+                            timestamp: Date.now(),
+                        });
+                        await notifyCallback(intercepted.result);
+                        currentPrompt = `The ${intercepted.type} plan completed. Results:\n---\n${intercepted.result.substring(0, 1000)}\n---\nContinue with the next step. When done, respond with "DONE".`;
+                        currentAgentId = session.leadAgentId;
+                        continue;
+                    }
+                }
+                // Delegation check
                 const delegationRequest = delegationManager.parseDelegation(currentAgentId, result.response);
                 if (delegationRequest) {
-                    // Record lead agent's step
                     session.steps.push({
                         stepNumber: session.currentStep,
                         agentId: currentAgentId,
@@ -199,10 +651,8 @@ class UltraWorkManager {
                         duration: stepDuration,
                         timestamp: Date.now(),
                     });
-                    // Execute delegation
                     const delegationResult = await delegationManager.executeDelegation(delegationRequest, executeCallback, notifyCallback);
                     if (delegationResult.success && delegationResult.response) {
-                        // Increment again: delegation response counts as a separate step from the lead's request
                         session.currentStep++;
                         session.steps.push({
                             stepNumber: session.currentStep,
@@ -213,18 +663,15 @@ class UltraWorkManager {
                             duration: delegationResult.duration ?? 0,
                             timestamp: Date.now(),
                         });
-                        // Continue with lead agent, incorporating delegation result
                         currentPrompt = this.buildContinuationAfterDelegation(delegationRequest.toAgentId, delegationResult.response);
                         currentAgentId = session.leadAgentId;
                     }
                     else {
-                        // Delegation failed, let lead agent continue
                         currentPrompt = `Delegation to ${delegationRequest.toAgentId} failed: ${delegationResult.error}. Please continue the task yourself.`;
                         currentAgentId = session.leadAgentId;
                     }
                 }
                 else {
-                    // No delegation - record step and check continuation
                     session.steps.push({
                         stepNumber: session.currentStep,
                         agentId: currentAgentId,
@@ -234,10 +681,8 @@ class UltraWorkManager {
                         duration: stepDuration,
                         timestamp: Date.now(),
                     });
-                    // Check if response is complete
                     const continuation = continuationEnforcer.analyzeResponse(currentAgentId, session.channelId, result.response);
                     if (continuation.isComplete) {
-                        // Task is done
                         session.active = false;
                         this.sessions.delete(session.channelId);
                         await notifyCallback(`**UltraWork Session Complete** (${session.id})\n` +
@@ -245,14 +690,12 @@ class UltraWorkManager {
                         break;
                     }
                     if (continuation.maxRetriesReached) {
-                        // Can't continue further
                         session.active = false;
                         this.sessions.delete(session.channelId);
                         await notifyCallback(`**UltraWork Session Stopped** (${session.id}): Max continuation retries reached.\n` +
                             `Steps: ${session.currentStep}`);
                         break;
                     }
-                    // Build continuation prompt
                     currentPrompt = continuationEnforcer.buildContinuationPrompt(result.response);
                     currentAgentId = session.leadAgentId;
                 }
@@ -268,23 +711,101 @@ class UltraWorkManager {
                     duration: Date.now() - stepStart,
                     timestamp: Date.now(),
                 });
-                // Try to recover by sending error context to lead
                 currentPrompt = `An error occurred: ${errorMessage}. Please assess the situation and decide how to continue.`;
                 currentAgentId = session.leadAgentId;
             }
         }
         // Session limits reached
         if (session.active) {
-            const reason = session.currentStep >= session.maxSteps ? 'max steps reached' : 'max duration reached';
-            session.active = false;
-            this.sessions.delete(session.channelId);
-            await notifyCallback(`**UltraWork Session Ended** (${session.id}): ${reason}.\n` +
-                `Steps: ${session.currentStep} | Duration: ${Math.round((Date.now() - session.startTime) / 1000)}s`);
+            this.endSession(session, notifyCallback);
         }
     }
-    /**
-     * Build the initial prompt for the lead agent.
-     */
+    // ============================================================================
+    // Prompt builders
+    // ============================================================================
+    buildPlanningPrompt(task, agents) {
+        const agentList = agents
+            .filter((a) => a.enabled !== false)
+            .map((a) => `- **${a.display_name}** (ID: ${a.id}, Tier ${a.tier ?? 1})`)
+            .join('\n');
+        return `**UltraWork — Phase 1: Planning**
+
+You are leading an autonomous work session. Before implementing, create a detailed plan.
+
+**Task:** ${task}
+
+**Available agents:**
+${agentList}
+
+**Instructions:**
+1. Analyze the task requirements
+2. If multiple perspectives would help, start a council discussion:
+   \`\`\`council_plan
+   {"name":"plan_review","topic":"Review implementation approach for: ${task.substring(0, 100)}","agents":["developer","reviewer"],"rounds":1}
+   \`\`\`
+3. After gathering input, create a structured plan:
+
+## Implementation Plan
+### Task 1: [description]
+- Assigned to: [agent_id]
+- Acceptance criteria: [what defines "done"]
+### Task 2: ...
+
+4. End with "PLAN_COMPLETE" when the plan is ready.`;
+    }
+    buildBuildingPrompt(plan, agents) {
+        const agentList = agents
+            .filter((a) => a.enabled !== false)
+            .map((a) => `- ${a.display_name} (ID: ${a.id})`)
+            .join('\n');
+        return `**UltraWork — Phase 2: Building**
+
+Execute the following plan. Delegate tasks to specialists.
+
+**Plan:**
+---
+${plan.substring(0, 3000)}
+---
+
+**Available agents:**
+${agentList}
+
+**Instructions:**
+- Execute tasks in order from the plan
+- Delegate using: DELEGATE::{agent_id}::{task description with acceptance criteria}
+- If a task fails or needs discussion, use council_plan for team input
+- After ALL tasks are done, respond with "BUILD_COMPLETE"
+- Do NOT skip any tasks from the plan`;
+    }
+    buildRetrospectivePrompt(plan, steps) {
+        const stepSummary = steps
+            .map((s) => `- Step ${s.stepNumber} [${s.action}] by ${s.agentId}: ${s.responseSummary.substring(0, 100)}`)
+            .join('\n');
+        return `**UltraWork — Phase 3: Retrospective**
+
+Review the completed work against the original plan.
+
+**Original Plan:**
+---
+${plan.substring(0, 2000)}
+---
+
+**Completed Steps:**
+${stepSummary || '(no steps recorded)'}
+
+**Instructions:**
+1. Compare completed work against the plan
+2. If team review would help, start a council discussion:
+   \`\`\`council_plan
+   {"name":"retrospective","topic":"Review completed work quality and identify gaps","agents":["developer","reviewer"],"rounds":1}
+   \`\`\`
+3. After council input, provide final assessment:
+   - What was completed successfully
+   - What needs additional work (if any)
+   - Lessons learned
+4. If ALL tasks are done satisfactorily: respond with "RETRO_COMPLETE"
+5. If tasks remain: respond with "RETRO_INCOMPLETE" and list remaining items`;
+    }
     buildInitialPrompt(task, agents) {
         const agentList = agents
             .filter((a) => a.enabled !== false)
@@ -307,9 +828,6 @@ ${agentList}
 - End your response with "DONE" when the overall task is complete
 - Stay focused on the task and be efficient`;
     }
-    /**
-     * Build continuation prompt after a delegation completes.
-     */
     buildContinuationAfterDelegation(delegatedAgentId, response) {
         const summary = response.length > 500 ? response.substring(0, 500) + '...' : response;
         return `Agent ${delegatedAgentId} completed the delegated task. Their response:
@@ -318,6 +836,34 @@ ${summary}
 ---
 Continue with the next step of the overall task. When everything is done, respond with "DONE".`;
     }
+    // ============================================================================
+    // Completion markers
+    // ============================================================================
+    isBuildComplete(response) {
+        return /\bBUILD_COMPLETE\b/i.test(response);
+    }
+    isRetroComplete(response) {
+        return /\bRETRO_COMPLETE\b/i.test(response);
+    }
+    // ============================================================================
+    // Helpers
+    // ============================================================================
+    async endSession(session, notifyCallback) {
+        let reason;
+        if (!session.active) {
+            reason = 'cancelled';
+        }
+        else if (session.currentStep >= session.maxSteps) {
+            reason = 'max steps reached';
+        }
+        else {
+            reason = 'max duration reached';
+        }
+        session.active = false;
+        this.sessions.delete(session.channelId);
+        await notifyCallback(`**UltraWork Session Ended** (${session.id}): ${reason}.\n` +
+            `Steps: ${session.currentStep} | Duration: ${Math.round((Date.now() - session.startTime) / 1000)}s`);
+    }
 }
 exports.UltraWorkManager = UltraWorkManager;
 //# sourceMappingURL=ultrawork.js.map