clementine-agent 1.0.0

package/dist/agent/orchestrator.js

@@ -0,0 +1,790 @@
+/**
+ * Clementine TypeScript — Plan Orchestrator.
+ *
+ * Decomposes a task into steps, runs independent steps in parallel
+ * via concurrent query() calls, then synthesizes a final response.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import pino from 'pino';
+import { PLAN_STATE_DIR } from '../config.js';
+const logger = pino({ name: 'clementine.orchestrator' });
+const MAX_STEPS = 10;
+const MAX_CONCURRENT_STEPS = 3;
+const RESULT_TRUNCATE_CHARS = 4000;
+const LONG_PLAN_WARNING_MS = 30 * 60 * 1000; // 30 minutes
+const ALLOWED_MODELS = ['haiku', 'sonnet'];
+const PLANNER_PROMPT = `You are a task planner for an AI assistant. Decompose the following request into executable steps.
+
+**Planning Principles:**
+- Each step runs in a FRESH CONTEXT (separate sub-agent) — no context rot, peak quality
+- Steps should be ATOMIC — completable in one focused session, not vague or open-ended
+- MAXIMIZE PARALLELISM — independent steps run concurrently in separate contexts
+- Follow Research → Execute → Verify — research steps feed into execution steps, verification confirms delivery
+- Size for quality: each step should complete within 15-50 tool calls, not sprawl indefinitely
+
+Output ONLY valid JSON matching this schema (no markdown fences, no prose):
+
+{
+  "steps": [
+    {
+      "id": "step-1",
+      "description": "Short human-readable label",
+      "prompt": "Detailed, self-contained instructions for the sub-agent. Be specific — the agent has no prior conversation context. Include tool names to use, what to look for, and what output to produce. End with a clear deliverable: 'Deliver: ...'",
+      "dependsOn": [],
+      "maxTurns": 15,
+      "model": "sonnet"
+    }
+  ],
+  "synthesisPrompt": "Instructions for combining all step results into a final response"
+}
+
+Rules:
+- MAXIMIZE PARALLELISM: if steps don't need each other's output, give them no dependencies
+- Each step prompt must be SELF-CONTAINED — the sub-agent has memory/vault access but no prior conversation context
+- Each step must end with a clear deliverable statement ("Deliver: the list of...", "Deliver: a draft email...")
+- Set maxTurns based on complexity: simple lookup = 5, moderate task = 15, complex work = 30-50
+- Set model based on step complexity: "haiku" for simple lookups/formatting, "sonnet" for reasoning/writing/analysis
+- Keep step count between 2-8. Simple tasks = fewer steps. Complex tasks = more.
+- If the task has a verification component, include it as a final dependent step
+- The synthesis step combines everything — it should produce a coherent final message for the user
+
+Available tools for sub-agents: Outlook (inbox, search, draft, send, calendar), memory (read/write/search), vault (notes, tasks), Bash, WebSearch, WebFetch, discord_channel_send, github_prs, rss_fetch, browser_screenshot, and file tools.
+
+<user_request>
+`;
+const PLANNER_PROMPT_SUFFIX = `
+</user_request>`;
+/**
+ * Compute execution waves from a dependency graph via topological sort.
+ * Steps with empty dependsOn = wave 0. Steps whose deps are all in wave N = wave N+1.
+ */
+export function computeWaves(steps) {
+    const stepMap = new Map(steps.map(s => [s.id, s]));
+    const waveOf = new Map();
+    const visiting = new Set(); // shared across all roots for cycle detection
+    function getWave(id) {
+        if (waveOf.has(id))
+            return waveOf.get(id);
+        if (visiting.has(id))
+            throw new Error(`Circular dependency detected involving step ${id}`);
+        visiting.add(id);
+        const step = stepMap.get(id);
+        if (!step || step.dependsOn.length === 0) {
+            visiting.delete(id);
+            waveOf.set(id, 0);
+            return 0;
+        }
+        let maxDepWave = 0;
+        for (const depId of step.dependsOn) {
+            if (!stepMap.has(depId))
+                continue; // unknown deps stripped during validation
+            maxDepWave = Math.max(maxDepWave, getWave(depId) + 1);
+        }
+        visiting.delete(id);
+        waveOf.set(id, maxDepWave);
+        return maxDepWave;
+    }
+    for (const step of steps) {
+        getWave(step.id);
+    }
+    // Group into waves
+    const maxWave = Math.max(0, ...waveOf.values());
+    const waves = Array.from({ length: maxWave + 1 }, () => []);
+    for (const step of steps) {
+        waves[waveOf.get(step.id) ?? 0].push(step);
+    }
+    return waves.filter(w => w.length > 0);
+}
+/**
+ * Run promises with a concurrency limit.
+ */
+export async function settledWithLimit(tasks, limit) {
+    const results = new Array(tasks.length);
+    let idx = 0;
+    async function worker() {
+        while (idx < tasks.length) {
+            const i = idx++;
+            try {
+                results[i] = { status: 'fulfilled', value: await tasks[i]() };
+            }
+            catch (reason) {
+                results[i] = { status: 'rejected', reason };
+            }
+        }
+    }
+    const workers = Array.from({ length: Math.min(limit, tasks.length) }, () => worker());
+    await Promise.all(workers);
+    return results;
+}
+export class PlanOrchestrator {
+    assistant;
+    stepStatuses = new Map();
+    stepStartTimes = new Map();
+    startTime = 0;
+    stateId;
+    agentProfiles = new Map();
+    constructor(assistant) {
+        this.assistant = assistant;
+        this.stateId = `plan-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+    }
+    // ── State persistence ────────────────────────────────────────────────
+    saveState(state) {
+        try {
+            if (!existsSync(PLAN_STATE_DIR))
+                mkdirSync(PLAN_STATE_DIR, { recursive: true });
+            state.updatedAt = new Date().toISOString();
+            writeFileSync(`${PLAN_STATE_DIR}/${state.id}.json`, JSON.stringify(state, null, 2));
+        }
+        catch (err) {
+            logger.debug({ err }, 'Failed to save plan state (non-fatal)');
+        }
+    }
+    cleanupState() {
+        try {
+            const filePath = `${PLAN_STATE_DIR}/${this.stateId}.json`;
+            if (existsSync(filePath))
+                unlinkSync(filePath);
+        }
+        catch { /* non-fatal */ }
+    }
+    /** Load a previously interrupted plan state (for future resumability). */
+    static loadState(stateId) {
+        try {
+            const filePath = `${PLAN_STATE_DIR}/${stateId}.json`;
+            if (!existsSync(filePath))
+                return null;
+            return JSON.parse(readFileSync(filePath, 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Main entry: plan → approve → execute → synthesize → return final response.
+     */
+    async run(taskDescription, onProgress, onApproval, availableAgents) {
+        // Reset instance state for reuse safety
+        this.stepStatuses.clear();
+        this.stepStartTimes.clear();
+        this.agentProfiles.clear();
+        this.startTime = Date.now();
+        // Index available agents for delegation lookups
+        if (availableAgents) {
+            for (const agent of availableAgents) {
+                this.agentProfiles.set(agent.slug, agent);
+            }
+        }
+        const safeProgress = async (updates) => {
+            try {
+                await onProgress?.(updates);
+            }
+            catch (err) {
+                logger.warn({ err }, 'Progress callback error (non-fatal)');
+            }
+        };
+        // 1. Generate plan (with revision loop)
+        const MAX_REVISIONS = 3;
+        let revisionCount = 0;
+        let effectiveTask = taskDescription;
+        let plan;
+        let waves;
+        // Plan → approval → (optional revision) loop
+        planLoop: while (true) {
+            try {
+                plan = await this.generatePlan(effectiveTask, availableAgents);
+            }
+            catch (err) {
+                logger.warn({ err }, 'Plan generation failed — running as single step');
+                return this.runSingleStep(taskDescription);
+            }
+            // Enforce max steps
+            if (plan.steps.length > MAX_STEPS) {
+                plan.steps = plan.steps.slice(0, MAX_STEPS);
+            }
+            if (plan.steps.length === 0) {
+                logger.warn('Plan has no valid steps — running as single step');
+                return this.runSingleStep(taskDescription);
+            }
+            logger.info({ goal: effectiveTask, stepCount: plan.steps.length, steps: plan.steps.map(s => s.id), revision: revisionCount }, 'Plan generated');
+            // 2. Initialize statuses
+            this.stepStatuses.clear();
+            for (const step of plan.steps) {
+                this.stepStatuses.set(step.id, {
+                    stepId: step.id,
+                    status: 'waiting',
+                    description: step.description,
+                });
+            }
+            await safeProgress(this.getAllUpdates());
+            // 3. Compute waves
+            try {
+                waves = computeWaves(plan.steps);
+            }
+            catch (err) {
+                logger.error({ err }, 'Dependency graph error');
+                return this.runSingleStep(taskDescription);
+            }
+            // 3b. Approval gate — show plan before executing
+            if (onApproval) {
+                const planSummary = waves
+                    .map((wave, wi) => wave.map(s => `  [Wave ${wi + 1}] ${s.id}: ${s.description}`).join('\n'))
+                    .join('\n');
+                const result = await onApproval(planSummary, plan.steps);
+                if (result === false) {
+                    logger.info({ goal: taskDescription }, 'Plan cancelled by user');
+                    return 'Plan cancelled.';
+                }
+                if (typeof result === 'string') {
+                    // Revision feedback — regenerate the plan
+                    revisionCount++;
+                    if (revisionCount > MAX_REVISIONS) {
+                        logger.warn({ goal: taskDescription, revisions: revisionCount }, 'Max plan revisions reached');
+                        return 'Plan cancelled — too many revisions.';
+                    }
+                    logger.info({ goal: taskDescription, revision: revisionCount, feedback: result }, 'Plan revision requested');
+                    effectiveTask = `${taskDescription}\n\n[Revision ${revisionCount}] The user reviewed the previous plan and asked for changes:\n${result}`;
+                    continue planLoop;
+                }
+            }
+            break; // Approved — proceed to execution
+        }
+        // 4. Execute waves — with state persistence for resumability
+        const results = new Map();
+        let longPlanWarned = false;
+        // Wave summaries for cross-step learning: compact findings from completed waves
+        // injected into ALL subsequent steps (not just dependents)
+        let waveSummaryContext = '';
+        const state = {
+            id: this.stateId,
+            goal: taskDescription,
+            status: 'executing',
+            startedAt: new Date(this.startTime).toISOString(),
+            updatedAt: new Date().toISOString(),
+            plan: plan,
+            totalWaves: waves.length,
+            wavesCompleted: 0,
+            results: {},
+            errors: [],
+            retries: {},
+        };
+        this.saveState(state);
+        for (const wave of waves) {
+            // Mark running
+            for (const step of wave) {
+                this.stepStatuses.set(step.id, {
+                    stepId: step.id,
+                    status: 'running',
+                    description: step.description,
+                });
+                this.stepStartTimes.set(step.id, Date.now());
+            }
+            await safeProgress(this.getAllUpdates());
+            // Run wave steps with concurrency limit
+            const settled = await settledWithLimit(wave.map((step) => async () => {
+                const prompt = this.buildStepPrompt(step, results, waveSummaryContext);
+                const delegateProfile = step.delegateTo ? this.agentProfiles.get(step.delegateTo) : undefined;
+                if (step.delegateTo) {
+                    logger.info({ stepId: step.id, delegateTo: step.delegateTo }, 'Delegating step to specialist agent');
+                }
+                const result = await this.assistant.runPlanStep(step.id, prompt, {
+                    tier: step.tier ?? 2,
+                    maxTurns: step.maxTurns ?? 15,
+                    model: step.model,
+                    delegateProfile,
+                });
+                return { stepId: step.id, result };
+            }), MAX_CONCURRENT_STEPS);
+            // Collect results
+            for (let i = 0; i < wave.length; i++) {
+                const step = wave[i];
+                const outcome = settled[i];
+                const elapsed = Date.now() - (this.stepStartTimes.get(step.id) ?? this.startTime);
+                if (outcome.status === 'fulfilled') {
+                    const resultText = outcome.value.result || '[No output produced]';
+                    if (!outcome.value.result) {
+                        logger.warn({ stepId: step.id }, 'Plan step produced empty output');
+                    }
+                    results.set(step.id, resultText);
+                    this.stepStatuses.set(step.id, {
+                        stepId: step.id,
+                        status: 'done',
+                        description: step.description,
+                        durationMs: elapsed,
+                        resultPreview: resultText.slice(0, 100),
+                    });
+                }
+                else {
+                    const errMsg = `[FAILED: ${outcome.reason}]`;
+                    results.set(step.id, errMsg);
+                    this.stepStatuses.set(step.id, {
+                        stepId: step.id,
+                        status: 'failed',
+                        description: step.description,
+                        durationMs: elapsed,
+                        resultPreview: errMsg.slice(0, 100),
+                    });
+                    logger.error({ stepId: step.id, err: outcome.reason }, 'Plan step failed');
+                }
+            }
+            await safeProgress(this.getAllUpdates());
+            // Inter-wave spot-check with severity levels: critical issues trigger repair
+            const spotCheckIssues = this.spotCheckWaveResults(wave, results);
+            if (spotCheckIssues.length > 0) {
+                logger.warn({ issues: spotCheckIssues }, 'Spot-check found issues in wave results');
+                for (const issue of spotCheckIssues) {
+                    if (issue.severity === 'critical' && this.hasDependents(issue.stepId, plan.steps)) {
+                        // Critical issue on a step with dependents — attempt repair
+                        const retryCount = state.retries[issue.stepId] ?? 0;
+                        if (retryCount < 1) {
+                            const decision = await this.getRepairDecision(issue, results.get(issue.stepId) ?? '');
+                            if (decision === 'retry') {
+                                logger.info({ stepId: issue.stepId, attempt: retryCount + 1 }, 'Retrying failed step');
+                                state.retries[issue.stepId] = retryCount + 1;
+                                const step = wave.find(s => s.id === issue.stepId);
+                                try {
+                                    const retryPrompt = `[RETRY — Previous attempt failed: ${issue.issue}]\n\n` +
+                                        this.buildStepPrompt(step, results, waveSummaryContext);
+                                    const retryResult = await this.assistant.runPlanStep(step.id, retryPrompt, {
+                                        tier: step.tier ?? 2,
+                                        maxTurns: step.maxTurns ?? 15,
+                                        model: step.model,
+                                    });
+                                    results.set(step.id, retryResult || '[No output on retry]');
+                                    this.stepStatuses.set(step.id, {
+                                        stepId: step.id,
+                                        status: retryResult ? 'done' : 'failed',
+                                        description: step.description,
+                                        durationMs: Date.now() - (this.stepStartTimes.get(step.id) ?? this.startTime),
+                                        resultPreview: (retryResult || '[No output on retry]').slice(0, 100),
+                                    });
+                                    logger.info({ stepId: step.id, success: !!retryResult }, 'Step retry completed');
+                                }
+                                catch (err) {
+                                    logger.warn({ stepId: step.id, err }, 'Step retry also failed');
+                                }
+                            }
+                            else if (decision === 'abort') {
+                                logger.warn({ stepId: issue.stepId }, 'Repair decision: abort plan');
+                                state.status = 'failed';
+                                this.saveState(state);
+                                return `Plan aborted — step "${this.stepStatuses.get(issue.stepId)?.description ?? issue.stepId}" failed critically and could not be repaired.`;
+                            }
+                            // 'skip' falls through — annotate and continue
+                        }
+                    }
+                    // Annotate results so the synthesis step knows about issues
+                    const existing = results.get(issue.stepId) ?? '';
+                    results.set(issue.stepId, existing + `\n\n[SPOT-CHECK ${issue.severity.toUpperCase()}: ${issue.issue}]`);
+                }
+            }
+            // ── Cross-step learning: build wave summary ─────────────────
+            // Compact summary of this wave's findings, injected into ALL subsequent steps
+            const waveFindings = [];
+            for (const step of wave) {
+                const status = this.stepStatuses.get(step.id);
+                if (status?.status === 'done') {
+                    const result = results.get(step.id) ?? '';
+                    // Extract first substantive sentence (skip headers, blank lines)
+                    const lines = result.split('\n').filter(l => l.trim() && !l.startsWith('#') && !l.startsWith('['));
+                    const summary = lines[0]?.slice(0, 150) ?? '';
+                    if (summary) {
+                        waveFindings.push(`- ${step.description}: ${summary}`);
+                    }
+                }
+                else if (status?.status === 'failed') {
+                    waveFindings.push(`- ${step.description}: FAILED`);
+                }
+            }
+            if (waveFindings.length > 0) {
+                waveSummaryContext += (waveSummaryContext ? '\n' : '') + waveFindings.join('\n');
+                // Cap total wave summary to prevent prompt bloat
+                if (waveSummaryContext.length > 1500) {
+                    waveSummaryContext = waveSummaryContext.slice(-1500);
+                }
+            }
+            // Persist state after each wave for resumability
+            state.wavesCompleted++;
+            state.results = Object.fromEntries(results);
+            for (const step of wave) {
+                const s = this.stepStatuses.get(step.id);
+                if (s?.status === 'failed') {
+                    state.errors.push({ stepId: step.id, error: s.resultPreview ?? 'unknown' });
+                }
+            }
+            this.saveState(state);
+            // Long-running warning
+            if (!longPlanWarned && Date.now() - this.startTime > LONG_PLAN_WARNING_MS) {
+                logger.warn({ elapsed: Date.now() - this.startTime }, 'Plan has been running for 30+ minutes');
+                longPlanWarned = true;
+            }
+        }
+        // 5. Synthesis
+        const synthesisStepId = '__synthesis__';
+        this.stepStatuses.set(synthesisStepId, {
+            stepId: synthesisStepId,
+            status: 'running',
+            description: 'Synthesize final response',
+        });
+        this.stepStartTimes.set(synthesisStepId, Date.now());
+        await safeProgress(this.getAllUpdates());
+        const synthesisPrompt = this.buildSynthesisPrompt(plan, results);
+        let finalResult;
+        try {
+            finalResult = await this.assistant.runPlanStep(synthesisStepId, synthesisPrompt, {
+                tier: 2,
+                maxTurns: 5,
+                disableTools: true,
+            });
+        }
+        catch (err) {
+            logger.error({ err }, 'Synthesis step failed');
+            // Fallback: concatenate results
+            finalResult = Array.from(results.entries())
+                .map(([id, r]) => `**${this.stepStatuses.get(id)?.description ?? id}:**\n${r}`)
+                .join('\n\n');
+        }
+        const synthElapsed = Date.now() - (this.stepStartTimes.get(synthesisStepId) ?? this.startTime);
+        this.stepStatuses.set(synthesisStepId, {
+            stepId: synthesisStepId,
+            status: 'done',
+            description: 'Synthesize final response',
+            durationMs: synthElapsed,
+        });
+        await safeProgress(this.getAllUpdates());
+        const totalMs = Date.now() - this.startTime;
+        logger.info({ totalMs, steps: plan.steps.length }, 'Plan execution complete');
+        // Mark state as complete and clean up
+        state.status = 'complete';
+        this.saveState(state);
+        // Clean up state file on successful completion (it served its purpose)
+        this.cleanupState();
+        // 6. Post-synthesis reflection (async, non-blocking)
+        this.runReflection(taskDescription, finalResult).catch(err => {
+            logger.debug({ err }, 'Post-plan reflection failed (non-fatal)');
+        });
+        return finalResult;
+    }
+    /**
+     * Goal-backward verification pass using Haiku after plan synthesis.
+     * Verifies outcomes rather than just rating quality:
+     * - Did each step produce a real result?
+     * - Is the synthesized output substantive (not restating the question)?
+     * - Are there gaps between request and output?
+     */
+    async runReflection(taskDescription, output) {
+        if (!output || output.length < 50)
+            return;
+        // Build a step results summary for the verifier
+        const stepSummary = [...this.stepStatuses.entries()]
+            .filter(([id]) => id !== '__synthesis__')
+            .map(([_id, s]) => `- ${s.description}: ${s.status}${s.status === 'failed' ? ' FAILED' : ''}`)
+            .join('\n');
+        const reflectionPrompt = `Verify the outcome of this orchestrated plan using goal-backward verification.\n\n` +
+            `**Original request:** ${taskDescription.slice(0, 400)}\n\n` +
+            `**Step results:**\n${stepSummary}\n\n` +
+            `**Final output (first 1000 chars):** ${output.slice(0, 1000)}\n\n` +
+            `Verify:\n` +
+            `1. COMPLETENESS: Does the output address ALL parts of the original request? (not just the easy parts)\n` +
+            `2. SUBSTANCE: Is each claim backed by data/evidence? (not vague summaries or restating the question)\n` +
+            `3. WIRED: Are the step results actually connected in the synthesis? (not just concatenated)\n` +
+            `4. GAPS: What specific parts of the request were missed or under-addressed?\n\n` +
+            `Respond with ONLY a JSON object (no markdown):\n` +
+            `{"completeness": true/false, "substance": true/false, "wired": true/false, ` +
+            `"quality": 1-10, "gaps": "specific gaps or 'none'", "improvement": "one concrete thing to do differently"}`;
+        try {
+            const result = await this.assistant.runPlanStep('plan-reflection', reflectionPrompt, {
+                tier: 1,
+                maxTurns: 1,
+                model: 'haiku',
+                disableTools: true,
+            });
+            const jsonMatch = result.match(/\{[\s\S]*?\}/);
+            if (jsonMatch) {
+                const reflection = JSON.parse(jsonMatch[0]);
+                logger.info({
+                    quality: reflection.quality,
+                    completeness: reflection.completeness,
+                    substance: reflection.substance,
+                    wired: reflection.wired,
+                    gaps: reflection.gaps?.slice(0, 100),
+                    improvement: reflection.improvement?.slice(0, 100),
+                }, 'Plan reflection completed');
+            }
+        }
+        catch {
+            // Non-fatal — reflection is best-effort
+        }
+    }
+    /**
+     * Get formatted progress lines for display.
+     */
+    getProgressLines() {
+        const lines = [];
+        const entries = [...this.stepStatuses.values()];
+        const total = entries.length;
+        for (let i = 0; i < entries.length; i++) {
+            const u = entries[i];
+            const num = `[${i + 1}/${total}]`;
+            const elapsed = this.stepStartTimes.has(u.stepId)
+                ? Math.round((Date.now() - this.stepStartTimes.get(u.stepId)) / 1000)
+                : 0;
+            switch (u.status) {
+                case 'done':
+                    lines.push(`${num} ${u.description} \u2713 (${Math.round((u.durationMs ?? 0) / 1000)}s)`);
+                    break;
+                case 'running':
+                    lines.push(`${num} ${u.description} \u23f3 running... (${elapsed}s)`);
+                    break;
+                case 'failed':
+                    lines.push(`${num} ${u.description} \u2717 failed (${Math.round((u.durationMs ?? 0) / 1000)}s)`);
+                    break;
+                case 'waiting':
+                    lines.push(`${num} ${u.description} \u25cb waiting`);
+                    break;
+            }
+        }
+        return lines;
+    }
+    /**
+     * Inter-wave spot-check: verify that step results contain substance.
+     * Catches empty outputs, error-only results, and placeholder/stub responses
+     * before downstream waves try to build on them.
+     */
+    spotCheckWaveResults(wave, results) {
+        const issues = [];
+        for (const step of wave) {
+            const result = results.get(step.id) ?? '';
+            const status = this.stepStatuses.get(step.id);
+            // Skip already-failed steps
+            if (status?.status === 'failed')
+                continue;
+            // Check 1: Empty or near-empty output — critical (nothing to build on)
+            if (result.length < 20) {
+                issues.push({ stepId: step.id, issue: `Output is empty or trivial (${result.length} chars)`, severity: 'critical' });
+                continue;
+            }
+            // Check 2: Output is just an error message — critical
+            if (result.startsWith('[FAILED:') || result.startsWith('Error:') || result.startsWith('Something went wrong')) {
+                issues.push({ stepId: step.id, issue: 'Output appears to be an error, not a result', severity: 'critical' });
+                continue;
+            }
+            // Check 3: Stub detection — warning (might have partial content)
+            const stubPatterns = [
+                /^I('ll| will) (start|begin|look into|investigate|check)/i,
+                /^Let me (start|begin|look into|investigate|check)/i,
+                /^(Sure|OK|Alright),? (I'll|let me)/i,
+            ];
+            const firstLine = result.split('\n')[0];
+            if (stubPatterns.some(p => p.test(firstLine)) && result.length < 200) {
+                issues.push({ stepId: step.id, issue: 'Output appears to be a stub/placeholder (restates intent without delivering results)', severity: 'warning' });
+            }
+        }
+        return issues;
+    }
+    /** Check if a step has downstream dependents in the plan. */
+    hasDependents(stepId, steps) {
+        return steps.some(s => s.dependsOn.includes(stepId));
+    }
+    /** Fast Haiku call to decide how to repair a failed critical step. */
+    async getRepairDecision(issue, result) {
+        try {
+            const prompt = `A plan step failed during orchestration. Decide the best recovery action.\n\n` +
+                `Step: ${this.stepStatuses.get(issue.stepId)?.description ?? issue.stepId}\n` +
+                `Issue: ${issue.issue}\n` +
+                `Output (first 300 chars): ${result.slice(0, 300)}\n\n` +
+                `Options:\n` +
+                `- "retry": Try the step again with the error context appended (good if the failure seems transient or fixable)\n` +
+                `- "skip": Skip this step and let downstream steps work around the missing data (good if the step is non-essential)\n` +
+                `- "abort": Cancel the entire plan (good if this step is critical and can't be worked around)\n\n` +
+                `Respond with ONLY one word: retry, skip, or abort`;
+            const decision = await this.assistant.runPlanStep('repair-decision', prompt, {
+                tier: 1,
+                maxTurns: 1,
+                model: 'haiku',
+                disableTools: true,
+            });
+            const cleaned = decision.trim().toLowerCase();
+            if (cleaned.includes('retry'))
+                return 'retry';
+            if (cleaned.includes('abort'))
+                return 'abort';
+            return 'skip';
+        }
+        catch {
+            // If the decision call itself fails, default to skip
+            return 'skip';
+        }
+    }
+    // ── Private helpers ──────────────────────────────────────────────────
+    async generatePlan(task, availableAgents) {
+        // If team agents are available, inject their capabilities into the planner prompt
+        let agentContext = '';
+        if (availableAgents && availableAgents.length > 0) {
+            const agentLines = availableAgents.map(a => {
+                const tools = a.team?.allowedTools?.slice(0, 10).join(', ') || 'all tools';
+                return `- **${a.slug}**: ${a.description || a.name} (model: ${a.model || 'sonnet'}, tools: ${tools})`;
+            });
+            agentContext = `\n\n**Available Team Agents (delegate specialized steps to them via "delegateTo"):**\n${agentLines.join('\n')}\n` +
+                `If a step matches an agent's specialty, add "delegateTo": "agent-slug" to that step. ` +
+                `The delegated agent will run the step with their own personality, tools, and expertise.\n`;
+        }
+        const plannerResult = await this.assistant.runPlanStep('planner', PLANNER_PROMPT + agentContext + task + PLANNER_PROMPT_SUFFIX, { tier: 2, maxTurns: 1, model: 'sonnet', disableTools: true });
+        // Parse JSON from the planner response
+        const parsed = this.parseJsonFromResponse(plannerResult);
+        if (!parsed?.steps || !Array.isArray(parsed.steps) || parsed.steps.length === 0) {
+            throw new Error('Planner returned invalid plan structure');
+        }
+        // Validate and normalize steps
+        const seenIds = new Set();
+        const validStepIds = new Set(parsed.steps.map((s, i) => s.id || `step-${i + 1}`));
+        const steps = [];
+        for (let i = 0; i < parsed.steps.length; i++) {
+            const s = parsed.steps[i];
+            const id = s.id || `step-${i + 1}`;
+            // Skip duplicate IDs
+            if (seenIds.has(id)) {
+                logger.warn({ id }, 'Duplicate step ID — skipping');
+                continue;
+            }
+            seenIds.add(id);
+            // Skip empty prompts
+            const prompt = (s.prompt || '').trim();
+            if (!prompt) {
+                logger.warn({ id }, 'Step has empty prompt — skipping');
+                continue;
+            }
+            // Clean dependencies: remove self-refs and unknown refs
+            const deps = Array.isArray(s.dependsOn)
+                ? s.dependsOn.filter((d) => d !== id && validStepIds.has(d))
+                : [];
+            // Validate model
+            const model = ALLOWED_MODELS.includes(s.model) ? s.model : undefined;
+            // Validate delegateTo — must be one of the available agents
+            const delegateTo = (typeof s.delegateTo === 'string' && availableAgents?.some(a => a.slug === s.delegateTo))
+                ? s.delegateTo
+                : undefined;
+            steps.push({
+                id,
+                description: (s.description || `Step ${i + 1}`).slice(0, 80),
+                prompt,
+                dependsOn: deps,
+                maxTurns: Math.min(Math.max(s.maxTurns ?? 15, 1), 50),
+                tier: Math.min(s.tier ?? 2, 2), // Never exceed tier 2 from planner
+                model,
+                delegateTo,
+            });
+        }
+        if (steps.length === 0) {
+            throw new Error('No valid steps after validation');
+        }
+        return {
+            goal: task,
+            steps,
+            synthesisPrompt: parsed.synthesisPrompt || 'Combine all step results into a coherent response for the user.',
+        };
+    }
+    parseJsonFromResponse(text) {
+        // Try direct parse first
+        try {
+            return JSON.parse(text);
+        }
+        catch { /* fall through */ }
+        // Try extracting from markdown code fences
+        const fenceMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+        if (fenceMatch) {
+            try {
+                return JSON.parse(fenceMatch[1]);
+            }
+            catch { /* fall through */ }
+        }
+        // Try finding the last balanced { ... } block containing "steps"
+        const lastBrace = text.lastIndexOf('}');
+        if (lastBrace !== -1) {
+            // Walk backward to find the matching opening brace
+            let depth = 0;
+            for (let i = lastBrace; i >= 0; i--) {
+                if (text[i] === '}')
+                    depth++;
+                if (text[i] === '{')
+                    depth--;
+                if (depth === 0) {
+                    const candidate = text.slice(i, lastBrace + 1);
+                    try {
+                        const parsed = JSON.parse(candidate);
+                        if (parsed?.steps)
+                            return parsed;
+                    }
+                    catch { /* continue searching */ }
+                    break;
+                }
+            }
+        }
+        return null;
+    }
+    buildStepPrompt(step, priorResults, waveSummaryContext) {
+        const parts = [];
+        // Cross-step learning: inject compact summary from ALL prior waves
+        // so this step benefits from earlier findings even without explicit dependencies
+        if (waveSummaryContext) {
+            parts.push('## Context from prior work\n' + waveSummaryContext);
+        }
+        // Inject prior step results for dependencies
+        if (step.dependsOn.length > 0) {
+            const depResults = [];
+            for (const depId of step.dependsOn) {
+                const result = priorResults.get(depId);
+                if (result) {
+                    const desc = this.stepStatuses.get(depId)?.description ?? depId;
+                    const isFailed = result.startsWith('[FAILED:');
+                    const truncated = result.length > RESULT_TRUNCATE_CHARS
+                        ? result.slice(0, RESULT_TRUNCATE_CHARS) + '\n...[truncated]'
+                        : result;
+                    if (isFailed) {
+                        depResults.push(`### ${depId}: ${desc} (FAILED)\n${truncated}\n\n*This dependency failed — work around the missing data or note the gap.*`);
+                    }
+                    else {
+                        depResults.push(`### ${depId}: ${desc}\n${truncated}`);
+                    }
+                }
+            }
+            if (depResults.length > 0) {
+                parts.push('## Results from prior steps:\n' + depResults.join('\n\n'));
+            }
+        }
+        parts.push('## Your task:\n' + step.prompt);
+        // Agentic communication guidance for sub-agents
+        parts.push(`## Communication Style
+Work through this task narrating your reasoning:
+- After reading/searching, say what you found and what it means before acting.
+- If something fails or is unexpected, explain what happened and what you'll try instead.
+- End with a clear deliverable — the concrete output, not a promise to produce one.`);
+        return parts.join('\n\n');
+    }
+    buildSynthesisPrompt(plan, results) {
+        const parts = [
+            `## Original request:\n${plan.goal}`,
+            '',
+            '## Step results:',
+        ];
+        for (const step of plan.steps) {
+            const result = results.get(step.id) ?? '[no result]';
+            const truncated = result.length > RESULT_TRUNCATE_CHARS
+                ? result.slice(0, RESULT_TRUNCATE_CHARS) + '\n...[truncated]'
+                : result;
+            parts.push(`### ${step.id}: ${step.description}\n${truncated}`);
+        }
+        parts.push('', `## Instructions:\n${plan.synthesisPrompt}`);
+        parts.push('\nWrite a coherent final response for the user. Be concise and conversational — this is going to a Discord DM.');
+        return parts.join('\n');
+    }
+    async runSingleStep(task) {
+        return this.assistant.runPlanStep('fallback', task, {
+            tier: 2,
+            maxTurns: 25,
+        });
+    }
+    getAllUpdates() {
+        return [...this.stepStatuses.values()];
+    }
+}
+//# sourceMappingURL=orchestrator.js.map