@synergenius/flow-weaver-pack-weaver 0.9.159 → 0.9.164

package/src/bot/swarm-controller.ts

@@ -27,7 +27,7 @@ import { InstanceManager } from './instance-manager.js';
 import { ProfileStore } from './profile-store.js';
 import type { BotProfile, BotInstance, OrchestratorInput, OrchestratorDecision, ProfileBehavior } from './profile-types.js';
 import { buildDefaultBehavior, adjustBehaviorForComplexity } from './behavior-defaults.js';
-import type { Task, RunSummary } from './task-types.js';
+import type { Task, RunProgress } from './task-types.js';
 import type { WorkflowResult } from './types.js';
 
 // ---------------------------------------------------------------------------
@@ -49,12 +49,9 @@ export interface SwarmState {
 
   budgets: SwarmBudgets;
 
-  autoRetry: boolean;
-  maxAttemptsDefault: number;
-
   // Stats
   tasksCompleted: number;
-  tasksFailed: number;
+  runsIncomplete: number;
   totalTokensUsed: number;
   totalCost: number;
 }
@@ -65,8 +62,6 @@ export interface SwarmConfig {
   sessionBudgetCost?: number;
   workspaceBudgetTokens?: number;
   workspaceBudgetCost?: number;
-  autoRetry?: boolean;
-  maxAttemptsDefault?: number;
 }
 
 export interface SwarmStartConfig {
@@ -80,7 +75,7 @@ export interface SwarmStartConfig {
 // ---------------------------------------------------------------------------
 
 const DISPATCH_LOOP_SLEEP_MS = 2000;
-const TASK_TIMEOUT_MS = 12 * 60 * 1000; // 12 minutes (> AI_CALL_TIMEOUT 10min, so AI times out first)
+// No TASK_TIMEOUT_MS — AI call timeout (10min) in the worker is the only boundary.
 const SWARM_STATE_FILE = 'swarm.json';
 
 // ---------------------------------------------------------------------------
@@ -277,8 +272,6 @@ export class SwarmController {
     if (config.sessionBudgetCost !== undefined) this.state.budgets.session.limitCost = config.sessionBudgetCost;
     if (config.workspaceBudgetTokens !== undefined) this.state.budgets.workspace.limitTokens = config.workspaceBudgetTokens;
     if (config.workspaceBudgetCost !== undefined) this.state.budgets.workspace.limitCost = config.workspaceBudgetCost;
-    if (config.autoRetry !== undefined) this.state.autoRetry = config.autoRetry;
-    if (config.maxAttemptsDefault !== undefined) this.state.maxAttemptsDefault = config.maxAttemptsDefault;
     this._persist();
   }
 
@@ -295,20 +288,13 @@ export class SwarmController {
       }
     }
 
-    // Reset in-progress tasks
+    // Reset in-progress tasks back to open
     const tasks = await this.taskStore.list({ status: 'in-progress' });
     for (const task of tasks) {
-      if (this.state.autoRetry && task.attempt < task.maxAttempts) {
-        await this.taskStore.update(task.id, {
-          status: 'pending',
-          currentBotId: undefined,
-        });
-      } else {
-        await this.taskStore.update(task.id, {
-          status: 'open',
-          currentBotId: undefined,
-        });
-      }
+      await this.taskStore.update(task.id, {
+        status: 'open',
+        activeRunId: undefined,
+      });
     }
 
     // Reset swarm status to idle
@@ -321,6 +307,66 @@ export class SwarmController {
   // Token/cost recording
   // -----------------------------------------------------------------------
 
+  private _buildBasicRunProgress(
+    runId: string, workerId: string, profileId: string,
+    result: { success?: boolean; summary?: string },
+    tokensUsed: number, costUsed: number, durationMs: number,
+  ): RunProgress {
+    // Determine outcome: zero-work runs (0 tokens, short duration) are stalled, not contributed
+    let outcome: 'completed' | 'contributed' | 'stalled' | 'crashed';
+    if (result.success) {
+      outcome = 'completed';
+    } else if (tokensUsed === 0 && durationMs < 10_000) {
+      // Ran for less than 10s with no AI tokens — something failed before work started
+      outcome = 'stalled';
+    } else {
+      outcome = 'contributed';
+    }
+
+    return {
+      runId,
+      botId: workerId,
+      profileId,
+      outcome,
+      filesCreated: [],
+      filesModified: [],
+      summary: result.summary || (outcome === 'completed' ? 'Completed' : outcome === 'stalled' ? 'Stalled (no AI work)' : 'Contributed'),
+      tokensUsed,
+      cost: costUsed,
+      durationMs,
+      endedAt: new Date().toISOString(),
+    };
+  }
+
+  private async _checkAcceptance(task: Task): Promise<import('./task-types.js').AcceptanceResult> {
+    const criteria = task.acceptance;
+    if (!criteria || !criteria.checks.length) {
+      return { met: true, results: [], checkedAt: new Date().toISOString() };
+    }
+
+    const { execSync } = await import('node:child_process');
+    const results: Array<{ name: string; pass: boolean; detail?: string }> = [];
+
+    for (const check of criteria.checks) {
+      try {
+        execSync(check.command, {
+          cwd: this.projectDir,
+          encoding: 'utf-8',
+          timeout: 60_000,
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        results.push({ name: check.name, pass: true });
+      } catch (err: unknown) {
+        const e = err as { stdout?: string; stderr?: string; message?: string };
+        const detail = (e.stdout ?? e.stderr ?? e.message ?? '').slice(0, 500);
+        results.push({ name: check.name, pass: false, detail });
+      }
+    }
+
+    const met = results.every(r => r.pass);
+    return { met, results, checkedAt: new Date().toISOString() };
+  }
+
   recordTokenUsage(workerId: string, _taskId: string, tokensUsed: number, cost: number): void {
     // Update worker in InstanceManager
     try {
@@ -419,7 +465,7 @@ export class SwarmController {
       }
 
       // Route unassigned tasks: top-level → orchestrator, subtasks → developer (fallback)
-      const unassignedTasks = await this.taskStore.list({ status: ['open', 'pending'] });
+      const unassignedTasks = await this.taskStore.list({ status: 'open' });
       for (const t of unassignedTasks) {
         if (!t.assignedProfile && !t.isParent) {
           // Top-level tasks (no parent) go to orchestrator for decomposition.
@@ -430,17 +476,26 @@ export class SwarmController {
         }
       }
 
-      // Collect pending tasks (and all tasks for dependency checks)
-      const pendingTasks = await this.taskStore.list({ status: ['open', 'pending'] });
+      // Collect open tasks (and all tasks for dependency checks)
+      const pendingTasks = await this.taskStore.list({ status: 'open' });
       const allTasks = await this.taskStore.list();
       const routableTasks = pendingTasks.filter((t) => {
         // Skip parent tasks
         if (t.isParent) return false;
-        // Skip tasks that have exhausted retries
-        if (t.attempt >= t.maxAttempts) return false;
-        // Skip tasks over per-task budget
-        if (t.budgetTokens !== undefined && t.tokensUsed >= t.budgetTokens) return false;
-        if (t.budgetCost !== undefined && t.costUsed >= t.budgetCost) return false;
+        // Skip tasks with exhausted budget
+        if (t.context.budgetExhausted) return false;
+        // Skip tasks in rapid-loop cooldown: if last run ended recently AND was zero-work,
+        // apply exponential backoff based on stagnation count
+        if (t.context.runHistory.length > 0) {
+          const lastRun = t.context.runHistory[t.context.runHistory.length - 1];
+          if ('endedAt' in lastRun && lastRun.endedAt) {
+            const secsSinceLastRun = (Date.now() - new Date(lastRun.endedAt).getTime()) / 1000;
+            const stag = t.context.stagnationCount;
+            // Exponential backoff: 10s, 20s, 40s, 80s, 160s... based on stagnation
+            const cooldownSecs = stag > 0 ? Math.min(10 * Math.pow(2, stag - 1), 300) : 0;
+            if (secsSinceLastRun < cooldownSecs) return false;
+          }
+        }
         // Skip tasks whose dependencies are not all done
         if (t.dependsOn && t.dependsOn.length > 0) {
           const allDepsDone = t.dependsOn.every((depId) => {
@@ -453,7 +508,7 @@ export class SwarmController {
               );
               return true;
             }
-            return dep.status === 'done';
+            return dep.status === 'done' || dep.status === 'cancelled';
           });
           if (!allDepsDone) return false;
         }
@@ -484,9 +539,9 @@ export class SwarmController {
           complexity: t.complexity ?? 'moderate',
           assignedProfile: t.assignedProfile,
           context: {
-            runSummaries: t.context.runSummaries.map((rs) => ({
-              outcome: rs.outcome,
-              botId: rs.botId,
+            runHistory: t.context.runHistory.map((rp) => ({
+              outcome: rp.outcome,
+              botId: rp.botId,
             })),
           },
         })),
@@ -550,7 +605,7 @@ export class SwarmController {
           // Mark worker as executing with the task's profileId
           const runId = RunStore.newId();
           this.instanceManager.markExecuting(assignment.instanceId, assignment.taskId, runId, assignment.profileId);
-          await this.taskStore.update(assignment.taskId, { currentRunId: runId });
+          await this.taskStore.update(assignment.taskId, { activeRunId: runId });
 
           // Sync state for dashboard
           this._syncInstancesState();
@@ -644,9 +699,8 @@ export class SwarmController {
         mode: task.context.files.length > 0 ? 'modify' : 'create',
         targets: task.context.files.length > 0 ? task.context.files : undefined,
         options: { autoApprove: true },
-        attempt: task.attempt,
-        lastError: task.context.lastError,
-        runSummaries: task.context.runSummaries,
+        runHistory: task.context.runHistory,
+        stagnationCount: task.context.stagnationCount,
       });
 
       // Build behavior config from profile preferences, adjusted for task complexity.
@@ -664,20 +718,16 @@ export class SwarmController {
       const workflowPath = path.isAbsolute(bot.filePath)
         ? bot.filePath
         : path.resolve(this.projectDir, bot.filePath);
-      const timeoutPromise = new Promise<never>((_, reject) =>
-        setTimeout(() => reject(new Error('Task execution timeout (10min)')), TASK_TIMEOUT_MS),
-      );
-      result = await Promise.race([
-        runWorkflow(workflowPath, {
-          runId,
-          taskId,
-          botId: workerId,
-          config: { provider: 'auto' },
-          params: { taskJson, projectDir: this.projectDir, behaviorJson },
-          eventLog: runEventLog,
-        }),
-        timeoutPromise,
-      ]);
+      // No swarm-level timeout race — the AI call timeout (10min) in the worker
+      // is the only boundary. This prevents orphaned runs from timeout races.
+      result = await runWorkflow(workflowPath, {
+        runId,
+        taskId,
+        botId: workerId,
+        config: { provider: 'auto' },
+        params: { taskJson, projectDir: this.projectDir, behaviorJson },
+        eventLog: runEventLog,
+      });
 
       runEventLog.done();
     } catch (err) {
@@ -690,26 +740,64 @@ export class SwarmController {
 
     const durationMs = Date.now() - startTime;
 
-    // Extract run summary
+    // Extract RunProgress from the workflow context if available (built by agent-execute),
+    // otherwise build a basic one from the WorkflowResult.
     const tokensUsed = Math.max(0, (result.cost?.totalInputTokens ?? 0) + (result.cost?.totalOutputTokens ?? 0));
     const costUsed = Math.max(0, result.cost?.totalCost ?? 0);
 
-    const runSummary: RunSummary = {
-      runId,
-      botId: workerId,
-      outcome: result.success ? 'success' : 'failed',
-      summary: result.summary || (result.success ? 'Completed' : 'Failed'),
-      report: result.report,
-      filesModified: [],
-      error: result.success ? undefined : (result.summary || 'Unknown error'),
-      durationMs,
-      tokensUsed,
-      cost: costUsed,
-    };
+    let runProgress: RunProgress;
+    const ctxRunProgress = result.runProgressJson;
+    if (ctxRunProgress) {
+      try {
+        const parsed = JSON.parse(ctxRunProgress);
+        runProgress = {
+          runId,
+          botId: workerId,
+          profileId: profile.id,
+          outcome: parsed.outcome ?? (result.success ? 'completed' : 'contributed'),
+          filesCreated: parsed.filesCreated ?? [],
+          filesModified: parsed.filesModified ?? [],
+          summary: parsed.summary ?? result.summary ?? '',
+          remainingWork: parsed.remainingWork,
+          blockers: parsed.blockers,
+          checks: parsed.checks,
+          tokensUsed: parsed.tokensUsed ?? tokensUsed,
+          cost: parsed.cost ?? costUsed,
+          durationMs: parsed.durationMs ?? durationMs,
+          endedAt: new Date().toISOString(),
+        };
+      } catch {
+        // JSON parse failed — fall back to basic
+        runProgress = this._buildBasicRunProgress(runId, workerId, profile.id, result, tokensUsed, costUsed, durationMs);
+      }
+    } else {
+      runProgress = this._buildBasicRunProgress(runId, workerId, profile.id, result, tokensUsed, costUsed, durationMs);
+    }
+
+    // Determine release status based on convergent model:
+    // - completed + no acceptance → done
+    // - completed + has acceptance → run acceptance check, done if met, open if not
+    // - contributed/stalled/crashed → open (task stays available for next run)
+    const task = await this.taskStore.get(taskId);
+    let releaseStatus: 'done' | 'open' = 'open';
+
+    if (runProgress.outcome === 'completed') {
+      if (!task?.acceptance) {
+        releaseStatus = 'done';
+      } else {
+        // Run deterministic acceptance check
+        const acceptResult = await this._checkAcceptance(task);
+        if (acceptResult.met) {
+          releaseStatus = 'done';
+        }
+        // Store the result on the task regardless
+        if (task) {
+          await this.taskStore.update(taskId, { lastAcceptanceCheck: acceptResult } as Record<string, unknown>);
+        }
+      }
+    }
 
-    // Release task
-    const releaseStatus = result.success ? 'done' : 'open';
-    await this.taskStore.release(taskId, releaseStatus, runSummary);
+    await this.taskStore.release(taskId, releaseStatus, runProgress);
 
     // Record token usage
     this.recordTokenUsage(workerId, taskId, tokensUsed, costUsed);
@@ -718,7 +806,7 @@ export class SwarmController {
     if (result.success) {
       this.state.tasksCompleted += 1;
     } else {
-      this.state.tasksFailed += 1;
+      this.state.runsIncomplete += 1;
     }
 
     // Mark worker as idle (clears profile association)
@@ -728,9 +816,9 @@ export class SwarmController {
 
     // Emit swarm-level task event
     this.eventLog.emit({
-      type: result.success ? 'task-done' : 'task-failed',
+      type: result.success ? 'task-done' : 'task-run-incomplete',
       timestamp: Date.now(),
-      data: { botId: workerId, taskId, outcome: runSummary.outcome },
+      data: { botId: workerId, taskId, outcome: runProgress.outcome },
     });
 
     // Emit hierarchy-scoped event so sibling tasks can see what happened
@@ -739,13 +827,13 @@ export class SwarmController {
       if (task?.parentId) {
         this.hierarchyEventLog.emit({
           parentId: task.parentId,
-          type: result.success ? 'task-completed' : 'task-run-failed',
+          type: result.success ? 'task-completed' : 'task-run-incomplete',
           taskId,
           data: {
-            summary: runSummary.summary,
-            filesModified: runSummary.filesModified,
+            summary: runProgress.summary,
+            filesModified: runProgress.filesModified,
             botId: workerId,
-            attempt: task.attempt,
+            runCount: task.context.runHistory.length,
           },
         });
       }
@@ -851,10 +939,8 @@ export class SwarmController {
         workspace: { limitTokens: 0, usedTokens: 0, limitCost: 0, usedCost: 0 },
         session: { limitTokens: 0, usedTokens: 0, limitCost: 0, usedCost: 0 },
       },
-      autoRetry: true,
-      maxAttemptsDefault: 3,
       tasksCompleted: 0,
-      tasksFailed: 0,
+      runsIncomplete: 0,
       totalTokensUsed: 0,
       totalCost: 0,
     };

package/src/bot/task-prompt-builder.ts

@@ -6,25 +6,22 @@
  *   {description}
  *   ### Notes
  *   ### Relevant Files
- *   ### Previous Attempts  (last 3 full, older condensed)
- *   ### Last Error
+ *   ### Previous Runs  (context decay: last run + acceptance check)
  *   ### Parent Context     (title + description + sibling status)
  *
  * Truncation cascade when over budget:
- *   1. Older summaries → one-liners only
+ *   1. Older runs → one-liners only
  *   2. File list → only files from last 2 runs
  *   3. Parent context → title only
  *   4. Notes → first 500 chars
  */
 
-import type { Task, RunSummary } from './task-types.js';
+import type { Task, RunProgress } from './task-types.js';
 import type { ProfilePreferences } from './profile-types.js';
 
 const MAX_CONTEXT_TOKENS = 4000;
 const CHARS_PER_TOKEN = 4; // rough estimate
 const MAX_CONTEXT_CHARS = MAX_CONTEXT_TOKENS * CHARS_PER_TOKEN;
-const FULL_SUMMARY_COUNT = 3;
-
 export function buildTaskPrompt(
   task: Task,
   parentTask?: Task | null,
@@ -67,28 +64,49 @@ function buildFull(
     sections.push(`### Relevant Files\n${task.context.files.join('\n')}`);
   }
 
-  // Run summaries: last 3 in full, older condensed
-  const summaries = task.context.runSummaries;
-  if (summaries.length > 0) {
-    const lines: string[] = [];
-    const recentStart = Math.max(0, summaries.length - FULL_SUMMARY_COUNT);
+  // --- Context decay: workspace is the source of truth, not history ---
+  // Workers see: last acceptance check, last run's remainingWork/blockers,
+  // stagnation count, and a directive to read the workspace.
 
-    // Condensed older summaries
-    for (let i = 0; i < recentStart; i++) {
-      lines.push(condenseSummary(summaries[i]!));
-    }
+  // 2.3.2: Last acceptance check result
+  if (task.lastAcceptanceCheck) {
+    const ac = task.lastAcceptanceCheck;
+    const checkLines = ac.results
+      .map(r => `- ${r.name}: ${r.pass ? 'PASS' : 'FAIL'}${r.detail ? ` (${r.detail.slice(0, 100)})` : ''}`)
+      .join('\n');
+    sections.push(`### Acceptance Check (${ac.met ? 'ALL PASS' : 'ISSUES FOUND'})\n${checkLines}`);
+  }
 
-    // Full recent summaries
-    for (let i = recentStart; i < summaries.length; i++) {
-      lines.push(fullSummary(summaries[i]!));
-    }
+  // 2.3.3: Continue from last run's remaining work
+  const lastRun = task.context.runHistory.length > 0
+    ? task.context.runHistory[task.context.runHistory.length - 1]
+    : undefined;
+  if (lastRun && 'remainingWork' in lastRun && lastRun.remainingWork) {
+    sections.push(`### Continue From\n${lastRun.remainingWork}`);
+  }
+
+  // 2.3.4: Blockers from last stalled run
+  if (lastRun && 'blockers' in lastRun && Array.isArray(lastRun.blockers) && lastRun.blockers.length > 0) {
+    sections.push(`### Previous Run Blocked By\n${(lastRun.blockers as string[]).map((b: string) => `- ${b}`).join('\n')}`);
+  }
+
+  // Last run summary (one run only, not full history)
+  if (lastRun && 'summary' in lastRun) {
+    sections.push(`### Last Run\nOutcome: ${lastRun.outcome} | ${lastRun.summary}`);
+  }
 
-    sections.push(`### Previous Attempts\n${lines.join('\n')}`);
+  // Run count + stagnation
+  if (task.context.runHistory.length > 0) {
+    let meta = `Total runs: ${task.context.runHistory.length}`;
+    if (task.context.stagnationCount > 0) {
+      meta += ` | Stagnation: ${task.context.stagnationCount} run(s) with no new changes — try a different approach`;
+    }
+    sections.push(`### Run History\n${meta}`);
   }
 
-  // Last error
-  if (task.context.lastError) {
-    sections.push(`### Last Error\n${task.context.lastError}`);
+  // Directive: read the workspace, don't rely on stale context
+  if (task.context.runHistory.length > 0) {
+    sections.push(`### Important\nRead the workspace to understand current state. Do not assume previous run summaries are accurate — files may have changed since then.`);
   }
 
   // Execution preferences
@@ -119,9 +137,9 @@ function truncatePrompt(
   siblingTasks?: Task[],
   preferences?: ProfilePreferences,
 ): string {
-  // Level 1: All summaries condensed to one-liners
+  // Level 1: All runs condensed to one-liners
   let result = buildWithTruncation(task, parentTask, siblingTasks, {
-    allSummariesCondensed: true,
+    allRunsCondensed: true,
     filesFromRecentRunsOnly: false,
     parentTitleOnly: false,
     notesCapped: false,
@@ -130,7 +148,7 @@ function truncatePrompt(
 
   // Level 2: File list → only files from last 2 runs
   result = buildWithTruncation(task, parentTask, siblingTasks, {
-    allSummariesCondensed: true,
+    allRunsCondensed: true,
     filesFromRecentRunsOnly: true,
     parentTitleOnly: false,
     notesCapped: false,
@@ -139,7 +157,7 @@ function truncatePrompt(
 
   // Level 3: Parent context → title only
   result = buildWithTruncation(task, parentTask, siblingTasks, {
-    allSummariesCondensed: true,
+    allRunsCondensed: true,
     filesFromRecentRunsOnly: true,
     parentTitleOnly: true,
     notesCapped: false,
@@ -148,7 +166,7 @@ function truncatePrompt(
 
   // Level 4: Notes → first 500 chars
   result = buildWithTruncation(task, parentTask, siblingTasks, {
-    allSummariesCondensed: true,
+    allRunsCondensed: true,
     filesFromRecentRunsOnly: true,
     parentTitleOnly: true,
     notesCapped: true,
@@ -163,7 +181,7 @@ function truncatePrompt(
 }
 
 interface TruncationFlags {
-  allSummariesCondensed: boolean;
+  allRunsCondensed: boolean;
   filesFromRecentRunsOnly: boolean;
   parentTitleOnly: boolean;
   notesCapped: boolean;
@@ -193,8 +211,13 @@ function buildWithTruncation(
   // Files (potentially only from recent runs)
   if (flags.filesFromRecentRunsOnly) {
     const recentFiles = new Set<string>();
-    for (const s of task.context.runSummaries.slice(-2)) {
-      for (const f of s.filesModified) recentFiles.add(f);
+    for (const rp of task.context.runHistory.slice(-2)) {
+      if ('filesModified' in rp) {
+        for (const f of rp.filesModified) recentFiles.add(f);
+      }
+      if ('filesCreated' in rp) {
+        for (const f of (rp as RunProgress).filesCreated) recentFiles.add(f);
+      }
     }
     if (recentFiles.size > 0) {
       sections.push(`### Relevant Files\n${[...recentFiles].join('\n')}`);
@@ -203,31 +226,39 @@ function buildWithTruncation(
     sections.push(`### Relevant Files\n${task.context.files.join('\n')}`);
   }
 
-  // All summaries condensed
-  if (task.context.runSummaries.length > 0) {
-    if (flags.allSummariesCondensed) {
-      const lines = task.context.runSummaries.map((s) => condenseSummary(s));
-      sections.push(`### Previous Attempts\n${lines.join('\n')}`);
-    } else {
-      // This path isn't used in truncation, but included for completeness
-      const lines: string[] = [];
-      const recentStart = Math.max(0, task.context.runSummaries.length - FULL_SUMMARY_COUNT);
-      for (let i = 0; i < recentStart; i++) {
-        lines.push(condenseSummary(task.context.runSummaries[i]!));
-      }
-      for (let i = recentStart; i < task.context.runSummaries.length; i++) {
-        lines.push(fullSummary(task.context.runSummaries[i]!));
-      }
-      sections.push(`### Previous Attempts\n${lines.join('\n')}`);
+  // Context decay: last acceptance check + last run only
+  if (task.lastAcceptanceCheck) {
+    const ac = task.lastAcceptanceCheck;
+    const checkLines = ac.results
+      .map(r => `- ${r.name}: ${r.pass ? 'PASS' : 'FAIL'}`)
+      .join('\n');
+    sections.push(`### Acceptance Check (${ac.met ? 'ALL PASS' : 'ISSUES FOUND'})\n${checkLines}`);
+  }
+
+  const lastRunT = task.context.runHistory.length > 0
+    ? task.context.runHistory[task.context.runHistory.length - 1]
+    : undefined;
+  if (lastRunT && 'remainingWork' in lastRunT && lastRunT.remainingWork) {
+    sections.push(`### Continue From\n${lastRunT.remainingWork}`);
+  }
+  if (lastRunT && 'blockers' in lastRunT && Array.isArray(lastRunT.blockers) && lastRunT.blockers.length > 0) {
+    sections.push(`### Previous Run Blocked By\n${(lastRunT.blockers as string[]).map((b: string) => `- ${b}`).join('\n')}`);
+  }
+  if (lastRunT && 'summary' in lastRunT) {
+    sections.push(`### Last Run\nOutcome: ${lastRunT.outcome} | ${lastRunT.summary}`);
+  }
+
+  if (task.context.runHistory.length > 0) {
+    let meta = `Total runs: ${task.context.runHistory.length}`;
+    if (task.context.stagnationCount > 0) {
+      meta += ` | Stagnation: ${task.context.stagnationCount} — try a different approach`;
     }
+    sections.push(`### Run History\n${meta}`);
   }
 
-  // Last error (truncated in aggressive mode)
-  if (task.context.lastError) {
-    const errorText = flags.notesCapped
-      ? task.context.lastError.slice(0, 300)
-      : task.context.lastError;
-    sections.push(`### Last Error\n${errorText}`);
+  // Directive: read the workspace, don't rely on stale context
+  if (task.context.runHistory.length > 0) {
+    sections.push(`### Important\nRead the workspace to understand current state. Do not assume previous run summaries are accurate — files may have changed since then.`);
   }
 
   // Execution preferences
@@ -256,27 +287,11 @@ function buildWithTruncation(
 // Formatting helpers
 // ---------------------------------------------------------------------------
 
-function condenseSummary(s: RunSummary): string {
-  return `- Run ${s.runId.slice(0, 8)} (${s.botId}): ${s.outcome} — ${s.summary.slice(0, 80)} (${Math.round(s.durationMs / 1000)}s, ${s.tokensUsed} tok)`;
-}
-
-function fullSummary(s: RunSummary): string {
-  const lines: string[] = [];
-  lines.push(`\n**Run ${s.runId.slice(0, 8)} (${s.botId}) — ${s.outcome}**`);
-  lines.push(s.summary);
-  if (s.filesModified.length > 0) lines.push(`Files: ${s.filesModified.join(', ')}`);
-  if (s.error) lines.push(`Error: ${s.error}`);
-  lines.push(
-    `Duration: ${Math.round(s.durationMs / 1000)}s · Tokens: ${s.tokensUsed} · Cost: $${s.cost.toFixed(3)}`,
-  );
-  return lines.join('\n');
-}
-
 function buildParentSection(
   parentTask: Task,
   siblingTasks?: Task[],
 ): string {
-  let section = `### Parent Context\nPart of: "${parentTask.title}" — ${parentTask.description}`;
+  let section = `### Parent Context\nPart of: "${parentTask.title}" \u2014 ${parentTask.description}`;
   if (siblingTasks && siblingTasks.length > 0) {
     const siblingLines = siblingTasks
       .map(
@@ -309,7 +324,7 @@ function statusIcon(status: string): string {
   switch (status) {
     case 'done':
       return '\u2705';
-    case 'failed':
+    case 'cancelled':
       return '\u274C';
     case 'in-progress':
       return '\u25CF';