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

package/src/node-types/agent-execute.ts

@@ -177,14 +177,16 @@ export async function weaverAgentExecute(
 
   auditEmit('run-start', { task: task.instruction });
 
+  const filesCreated: string[] = [];
+  const filesModified: string[] = [];
+  const stepLog: LocalStepLogEntry[] = [];
+  const checks: Record<string, string> = {};
+  const taskStart = Date.now();
+
   try {
     const provider = await createProvider(pInfo, projectDir);
     const executor = createWeaverExecutor(projectDir);
 
-    const filesModified: string[] = [];
-    const stepLog: LocalStepLogEntry[] = [];
-    const taskStart = Date.now();
-
     // Route tool events through renderer + track state
     const onToolEvent = (event: ToolEvent) => {
       renderer.onToolEvent(event);
@@ -195,8 +197,22 @@ export async function weaverAgentExecute(
           status: event.isError ? 'error' : 'ok',
           detail: event.isError ? (event.result ?? '').slice(0, 200) : event.name,
         });
-        if ((event.name === 'patch_file' || event.name === 'write_file') && !event.isError && event.args?.file) {
-          filesModified.push(event.args.file as string);
+
+        // Track file changes
+        if (!event.isError && event.args?.file) {
+          if (event.name === 'write_file') filesCreated.push(event.args.file as string);
+          if (event.name === 'patch_file') filesModified.push(event.args.file as string);
+        }
+
+        // Capture automated check results from tool output
+        if (event.name === 'run_shell' && event.result) {
+          const output = event.result;
+          if (event.args?.command && String(event.args.command).includes('tsc')) {
+            checks.tsc = event.isError ? output.slice(0, 500) : 'pass';
+          }
+          if (event.args?.command && (String(event.args.command).includes('vitest') || String(event.args.command).includes('npm test'))) {
+            checks.tests = event.isError ? output.slice(0, 500) : 'pass';
+          }
         }
       }
     };
@@ -227,84 +243,93 @@ export async function weaverAgentExecute(
       outputTokens: usage.completionTokens,
     });
 
-    // Post-agent validation gate: don't trust the AI's self-assessment
-    const uniqueFiles = [...new Set(filesModified)];
-    let validationPassed = result.success;
-    if (uniqueFiles.length > 0) {
-      try {
-        const { weaverValidateGate } = await import('./validate-gate.js');
-        const gateCtx: WeaverContext = { ...context, filesModified: JSON.stringify(uniqueFiles) };
-        const gateResult = weaverValidateGate(JSON.stringify(gateCtx));
-        const gateData = JSON.parse(gateResult.ctx) as WeaverContext;
-        if (!gateData.allValid) {
-          validationPassed = false;
-          renderer.warn('Post-agent validation found errors — task marked as failed');
-        }
-        context.validationResultJson = gateData.validationResultJson;
-      } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[agent-execute] validate-gate unavailable, skipping:', err); }
+    const uniqueCreated = [...new Set(filesCreated)];
+    const uniqueModified = [...new Set(filesModified)];
+    const durationMs = Date.now() - taskStart;
+
+    // --- Determine outcome ---
+    // Extract remainingWork and blockers from AI's last text message
+    const lastMsg = result.messages?.filter((m: { role: string }) => m.role === 'assistant').pop();
+    const lastText = typeof lastMsg?.content === 'string' ? lastMsg.content : '';
+
+    let remainingWork: string | undefined;
+    let blockers: string[] | undefined;
+
+    // Check for explicit BLOCKED/NEEDS_CONTEXT signals
+    const blockedMatch = lastText.match(/(?:BLOCKED|NEEDS_CONTEXT)[:\s]*(.+?)(?:\n|$)/i);
+    if (blockedMatch) {
+      blockers = [blockedMatch[1].trim()];
     }
 
-    // Step-log error-rate gate: don't trust the AI's success claim
-    // when the majority of its tool calls failed.
-    if (validationPassed && stepLog.length >= 4) {
-      const errorCount = stepLog.filter(s => s.status === 'error').length;
-      const errorRate = errorCount / stepLog.length;
-      if (errorRate > 0.5) {
-        validationPassed = false;
-        renderer.warn(
-          `Step error rate too high (${errorCount}/${stepLog.length} = ${Math.round(errorRate * 100)}%) — task marked as failed`,
-        );
-      }
+    // Check for remaining work mentions
+    const remainingMatch = lastText.match(/(?:remaining|still need|todo|left to do)[:\s]*(.+?)(?:\n\n|$)/i);
+    if (remainingMatch && !blockers) {
+      remainingWork = remainingMatch[1].trim().slice(0, 500);
     }
 
-    // Deliverable-based gate: if the task description specifies expected files
-    // (via FILES: or "You may ONLY create/modify:"), verify they exist on disk.
-    if (validationPassed && task.instruction) {
-      const filesMatch = task.instruction.match(/FILES?:\s*([^\n]+)/i)
-        ?? task.instruction.match(/ONLY create(?:\/modify)?[^:]*:\s*([^\n]+)/i);
-      if (filesMatch) {
-        const expectedFiles = filesMatch[1]
-          .split(/[,;]/)
-          .map((f: string) => f.trim().replace(/`/g, ''))
-          .filter((f: string) => f && f.includes('/'));
-        const { existsSync } = await import('node:fs');
-        const { resolve } = await import('node:path');
-        const missing = expectedFiles.filter((f: string) => !existsSync(resolve(projectDir, f)));
-        if (missing.length > 0) {
-          validationPassed = false;
-          renderer.warn(`Expected files not found: ${missing.join(', ')} — task marked as failed`);
-        }
-      }
+    // Determine outcome based on convergent model
+    let outcome: 'contributed' | 'completed' | 'stalled' | 'crashed';
+    if (blockers && blockers.length > 0) {
+      outcome = 'stalled';
+    } else if (result.success && result.toolCallCount > 0 && !remainingWork) {
+      outcome = 'completed';
+    } else {
+      // Made progress (files changed) or at least tried (tool calls > 0)
+      outcome = 'contributed';
     }
 
+    // Build RunProgress — this is what gets stored on the task
+    const runProgressJson = JSON.stringify({
+      outcome,
+      filesCreated: uniqueCreated,
+      filesModified: uniqueModified,
+      summary: result.summary || `${outcome}: ${result.toolCallCount} tool calls`,
+      remainingWork,
+      blockers,
+      checks: Object.keys(checks).length > 0 ? checks : undefined,
+      tokensUsed: usage.promptTokens + usage.completionTokens,
+      cost: estimatedCost,
+      durationMs,
+    });
+
+    // Legacy context fields for backward compat with workflow nodes that read them
     context.resultJson = JSON.stringify({
-      success: validationPassed,
+      success: outcome === 'completed',
       summary: result.summary,
       toolCallCount: result.toolCallCount,
+      outcome,
       usage: { inputTokens: usage.promptTokens, outputTokens: usage.completionTokens, estimatedCost },
     });
-    context.filesModified = JSON.stringify(uniqueFiles);
+    context.filesModified = JSON.stringify([...uniqueCreated, ...uniqueModified]);
     context.stepLogJson = JSON.stringify(stepLog);
-    context.allValid = validationPassed;
+    context.allValid = outcome === 'completed';
+    // Attach RunProgress as a dedicated context field for the swarm controller
+    (context as unknown as Record<string, unknown>).runProgressJson = runProgressJson;
 
     auditEmit('run-complete', {
-      success: validationPassed,
+      success: outcome === 'completed',
+      outcome,
       toolCalls: result.toolCallCount,
-      filesModified: uniqueFiles.length,
+      filesCreated: uniqueCreated.length,
+      filesModified: uniqueModified.length,
       tokens: { in: usage.promptTokens, out: usage.completionTokens },
       estimatedCost,
     });
 
-    renderer.taskEnd(validationPassed, {
+    renderer.taskEnd(outcome === 'completed', {
       toolCalls: result.toolCallCount,
       inputTokens: usage.promptTokens,
       outputTokens: usage.completionTokens,
       estimatedCost,
-      filesModified: uniqueFiles.length,
-      elapsed: Date.now() - taskStart,
+      filesModified: uniqueCreated.length + uniqueModified.length,
+      elapsed: durationMs,
     });
 
-    return { onSuccess: validationPassed, onFailure: !validationPassed, ctx: JSON.stringify(context) };
+    return {
+      onSuccess: outcome === 'completed',
+      onFailure: outcome !== 'completed',
+      ctx: JSON.stringify(context),
+    };
   } catch (err: unknown) {
     const msg = err instanceof Error ? err.message : String(err);
     let errorDetail = msg;
@@ -312,10 +337,22 @@ export async function weaverAgentExecute(
     if (guidance) errorDetail = `${msg}\n  Hint: ${guidance}`;
     renderer.error('Agent error', errorDetail);
 
-    context.resultJson = JSON.stringify({ success: false, error: msg });
-    context.filesModified = '[]';
-    context.stepLogJson = '[]';
+    // Crashed — infrastructure failure
+    const crashProgress = JSON.stringify({
+      outcome: 'crashed',
+      filesCreated: [...new Set(filesCreated)],
+      filesModified: [...new Set(filesModified)],
+      summary: `Crashed: ${msg.slice(0, 200)}`,
+      tokensUsed: 0,
+      cost: 0,
+      durationMs: Date.now() - taskStart,
+    });
+
+    context.resultJson = JSON.stringify({ success: false, error: msg, outcome: 'crashed' });
+    context.filesModified = JSON.stringify([...new Set([...filesCreated, ...filesModified])]);
+    context.stepLogJson = JSON.stringify(stepLog);
     context.allValid = false;
+    (context as unknown as Record<string, unknown>).runProgressJson = crashProgress;
 
     return { onSuccess: false, onFailure: true, ctx: JSON.stringify(context) };
   }

package/src/node-types/plan-task.ts

@@ -214,15 +214,15 @@ Rules:
 2. Use patch_file for modifications, write_file only for new files.
 3. Verify your work by running tests or tsc when appropriate.`;
 
-  // Append retry context when this is a retry attempt (attempt > 0)
-  const attempt = task.attempt ?? 0;
-  if (attempt > 0) {
-    const retryParts: string[] = ['\n\n--- RETRY CONTEXT (attempt ' + (attempt + 1) + ') ---'];
-    if (task.lastError) {
-      retryParts.push('Previous attempt failed with error: ' + task.lastError);
-    }
-    const summaries: Array<{ outcome?: string; filesModified?: string[]; summary?: string }> = task.runSummaries ?? [];
+  // Append retry context when this is a convergent re-run (runHistory has prior entries)
+  const runCount = task.runHistory?.length ?? 0;
+  if (runCount > 0) {
+    const retryParts: string[] = ['\n\n--- RETRY CONTEXT (run ' + (runCount + 1) + ') ---'];
+    const summaries: Array<{ outcome?: string; filesModified?: string[]; summary?: string; error?: string }> = task.runHistory ?? [];
     const lastSummary = summaries.length > 0 ? summaries[summaries.length - 1] : undefined;
+    if (lastSummary?.error) {
+      retryParts.push('Previous attempt failed with error: ' + lastSummary.error);
+    }
     if (lastSummary) {
       if (lastSummary.outcome) retryParts.push('Last outcome: ' + lastSummary.outcome);
       if (lastSummary.summary) retryParts.push('Last summary: ' + lastSummary.summary);

package/src/ui/bot-panel.tsx

@@ -32,7 +32,7 @@ interface InstanceInfo {
   tokensUsed: number;
   cost: number;
   tasksCompleted: number;
-  tasksFailed: number;
+  runsIncomplete: number;
 }
 
 interface SwarmStatus {
@@ -40,7 +40,7 @@ interface SwarmStatus {
   instances: Record<string, InstanceInfo>;
   maxConcurrent: number;
   tasksCompleted: number;
-  tasksFailed: number;
+  runsIncomplete: number;
   totalTokensUsed: number;
   totalCost: number;
   startedAt?: string;
@@ -237,7 +237,7 @@ function BotPanel() {
     ),
     React.createElement(Flex, { variant: 'column-center-center-nowrap-1' },
       React.createElement(Typography, { variant: 'smallCaption-thick', color: 'color-text-high' },
-        String(swarm?.tasksFailed ?? 0),
+        String(swarm?.runsIncomplete ?? 0),
       ),
       React.createElement(Typography, { variant: 'smallCaption-regular', color: 'color-text-subtle' }, 'Failed'),
     ),

package/src/ui/chat-task-result.tsx

@@ -18,18 +18,15 @@ const { Flex, Typography, StatusIcon, Button } = require('@fw/plugin-ui-kit');
 interface TaskData {
   id: string;
   title: string;
-  status: 'open' | 'pending' | 'in-progress' | 'blocked' | 'done' | 'cancelled';
+  status: 'open' | 'in-progress' | 'done' | 'cancelled';
   isParent: boolean;
-  currentBotId?: string;
   assignedProfile?: string;
-  attempt?: number;
-  maxAttempts?: number;
 }
 
 interface SubtaskData {
   id: string;
   title: string;
-  status: 'open' | 'pending' | 'in-progress' | 'blocked' | 'done' | 'cancelled';
+  status: 'open' | 'in-progress' | 'done' | 'cancelled';
 }
 
 interface ChatTaskResultProps {
@@ -62,8 +59,6 @@ type StatusKind = 'running' | 'completed' | 'failed' | 'pending';
 function statusToIcon(status: TaskData['status']): StatusKind {
   switch (status) {
     case 'open':
-    case 'pending':
-    case 'blocked':
       return 'pending';
     case 'in-progress':
       return 'running';
@@ -79,9 +74,7 @@ function statusToIcon(status: TaskData['status']): StatusKind {
 function statusLabel(status: TaskData['status']): string {
   switch (status) {
     case 'open': return 'Open';
-    case 'pending': return 'Queued';
     case 'in-progress': return 'Running';
-    case 'blocked': return 'Blocked';
     case 'done': return 'Done';
     case 'cancelled': return 'Cancelled';
     default: return status;
@@ -159,11 +152,9 @@ function ChatTaskResult(props: ChatTaskResultProps | null) {
   const hasSubtasks = task.isParent && totalCount > 0;
 
   // Bot info
-  const botLabel = task.currentBotId
-    ? `Bot: ${task.currentBotId}`
-    : task.assignedProfile
-      ? `Profile: ${task.assignedProfile}`
-      : null;
+  const botLabel = task.assignedProfile
+    ? `Profile: ${task.assignedProfile}`
+    : null;
 
   const handleOpenDashboard = useCallback(() => {
     openWorkspace({

package/src/ui/swarm-controls.tsx

@@ -24,7 +24,7 @@ interface SwarmStatus {
   instances: Record<string, InstanceInfo>;
   maxConcurrent: number;
   tasksCompleted: number;
-  tasksFailed: number;
+  runsIncomplete: number;
   totalTokensUsed: number;
   totalCost: number;
   startedAt?: string;
@@ -205,10 +205,10 @@ function SwarmControls({ swarmStatus, onRefresh }: SwarmControlsProps) {
         variant: 'caption-regular',
         color: 'color-text-subtle',
       }, `${swarmStatus.tasksCompleted} done`),
-      swarmStatus && swarmStatus.tasksFailed > 0 && React.createElement(Typography, {
+      swarmStatus && swarmStatus.runsIncomplete > 0 && React.createElement(Typography, {
         variant: 'caption-regular',
         color: 'color-status-negative',
-      }, `${swarmStatus.tasksFailed} failed`),
+      }, `${swarmStatus.runsIncomplete} incomplete`),
     ),
 
     // Right: action buttons

package/src/ui/swarm-dashboard.tsx

@@ -51,7 +51,7 @@ interface InstanceInfo {
   tokensUsed: number;
   cost: number;
   tasksCompleted: number;
-  tasksFailed: number;
+  runsIncomplete: number;
 }
 
 interface SwarmBudgetLayer {
@@ -66,7 +66,7 @@ interface SwarmStatus {
   instances: Record<string, InstanceInfo>;
   maxConcurrent: number;
   tasksCompleted: number;
-  tasksFailed: number;
+  runsIncomplete: number;
   totalTokensUsed: number;
   totalCost: number;
   budgets?: {
@@ -77,7 +77,7 @@ interface SwarmStatus {
   packVersion?: string;
 }
 
-type TaskStatus = 'open' | 'pending' | 'in-progress' | 'blocked' | 'done' | 'cancelled';
+type TaskStatus = 'open' | 'in-progress' | 'done' | 'cancelled';
 
 interface PoolTask {
   id: string;

package/src/ui/task-detail-view.tsx

@@ -24,23 +24,27 @@ import type { HistoricalRun } from './trace-to-timeline';
 // Types
 // ---------------------------------------------------------------------------
 
-type TaskStatus = 'open' | 'pending' | 'in-progress' | 'blocked' | 'done' | 'cancelled';
+type TaskStatus = 'open' | 'in-progress' | 'done' | 'cancelled';
 
 interface TaskContext {
   files: string[];
   notes: string;
-  runSummaries: Array<{
+  runHistory: Array<{
     runId: string;
     botId: string;
+    profileId: string;
     outcome: string;
     summary: string;
+    filesCreated: string[];
     filesModified: string[];
-    error?: string;
+    remainingWork?: string;
+    checks?: Record<string, string>;
     durationMs: number;
     tokensUsed: number;
     cost: number;
+    endedAt: string;
   }>;
-  lastError?: string;
+  stagnationCount: number;
 }
 
 interface Task {
@@ -52,13 +56,8 @@ interface Task {
   isParent: boolean;
   parentId?: string;
   dependsOn: string[];
-  currentBotId?: string;
-  currentRunId?: string;
+  activeRunId?: string;
   context: TaskContext;
-  runs: string[];
-  attempt: number;
-  maxAttempts: number;
-  budgetTokens?: number;
   budgetCost?: number;
   tokensUsed: number;
   costUsed: number;
@@ -75,7 +74,6 @@ interface Subtask {
   status: TaskStatus;
   priority: number;
   assignedProfile?: string;
-  attempt: number;
 }
 
 interface TaskDetailViewProps {
@@ -90,19 +88,15 @@ interface TaskDetailViewProps {
 
 const statusToIcon: Record<TaskStatus, string> = {
   'open': 'pending',
-  'pending': 'pending',
   'in-progress': 'running',
   'done': 'completed',
-  'blocked': 'pending',
   'cancelled': 'failed',
 };
 
 const statusToLabel: Record<TaskStatus, string> = {
   'open': 'Open',
-  'pending': 'Queued',
   'in-progress': 'Running',
   'done': 'Done',
-  'blocked': 'Blocked',
   'cancelled': 'Cancelled',
 };
 
@@ -191,10 +185,6 @@ function SubtaskRowItem({ sub, onBack }: { sub: Subtask; onBack: () => void }) {
     sub.assignedProfile && React.createElement(Chip, {
       label: sub.assignedProfile, size: 'small', color: 'color-status-info',
     }),
-    React.createElement(Typography, {
-      variant: 'caption-regular',
-      color: 'color-text-subtle',
-    }, `#${sub.attempt}`),
   );
 }
 
@@ -223,9 +213,9 @@ function TaskDetailView({ taskId, onBack, onEdit }: TaskDetailViewProps) {
       const t = (data.task ?? data) as Task;
       setTask(t);
 
-      // Populate run history from task's runSummaries (RunStore may be empty for swarm tasks)
+      // Populate run history from task's runHistory (RunStore may be empty for swarm tasks)
       const rs = (t as unknown as Record<string, unknown>).context as Record<string, unknown> | undefined;
-      const summaries = rs?.runSummaries as Array<Record<string, unknown>> | undefined;
+      const summaries = rs?.runHistory as Array<Record<string, unknown>> | undefined;
       if (summaries?.length) {
         setHistory(prev => {
           if (prev.length > 0) return prev; // Don't overwrite if RunStore data exists
@@ -307,14 +297,14 @@ function TaskDetailView({ taskId, onBack, onEdit }: TaskDetailViewProps) {
     report: liveReport,
   } = useStreamTimeline(stream.events, stream.isDone);
 
-  const currentRunId = task?.currentRunId;
-  const isLive = task?.status === 'in-progress' && !!currentRunId;
+  const activeRunId = task?.activeRunId;
+  const isLive = task?.status === 'in-progress' && !!activeRunId;
 
   useEffect(() => {
-    if (!isLive || !currentRunId) return;
-    stream.start(packId, 'fw_weaver_events', currentRunId);
+    if (!isLive || !activeRunId) return;
+    stream.start(packId, 'fw_weaver_events', activeRunId);
     return () => stream.stop();
-  }, [isLive, currentRunId, packId]);
+  }, [isLive, activeRunId, packId]);
 
   // ── Detail tab state ──
   const [detailTab, setDetailTab] = useState('runs');
@@ -573,7 +563,6 @@ function TaskDetailView({ taskId, onBack, onEdit }: TaskDetailViewProps) {
           color: task.status === 'done' ? 'color-status-positive'
             : task.status === 'cancelled' ? 'color-status-negative'
             : task.status === 'in-progress' ? 'color-status-info'
-            : task.status === 'blocked' ? 'color-status-caution'
             : 'color-brand-alt',
         }),
 
@@ -583,10 +572,10 @@ function TaskDetailView({ taskId, onBack, onEdit }: TaskDetailViewProps) {
           label: `P${task.priority}`, size: 'small', color: task.priority >= 3 ? 'color-status-caution' : 'color-status-info',
         }),
 
-        task.maxAttempts != null && task.maxAttempts > 1 && React.createElement(Typography, {
+        (task.context?.runHistory?.length ?? 0) > 0 && React.createElement(Typography, {
           variant: 'smallCaption-regular',
           color: 'color-text-subtle',
-        }, `${task.runs?.length ?? 0}/${task.maxAttempts} runs`),
+        }, `${task.context.runHistory.length} run${task.context.runHistory.length !== 1 ? 's' : ''}`),
       ),
 
       // Description
@@ -628,7 +617,7 @@ function TaskDetailView({ taskId, onBack, onEdit }: TaskDetailViewProps) {
       React.createElement(Flex, { variant: 'column-stretch-start-nowrap-8', style: { padding: '12px 16px' } },
 
         // ── Runs tab ──
-        detailTab === 'runs' && (hasRuns || (task.runs?.length ?? 0) > 0)
+        detailTab === 'runs' && (hasRuns || (task.context?.runHistory?.length ?? 0) > 0)
           ? React.createElement(Flex, { variant: 'column-stretch-start-nowrap-8' },
               // Historical runs
               ...runItems.map(({ run, runTimeline }: { run: HistoricalRun; runTimeline: Array<Record<string, unknown>> }) => {
@@ -696,14 +685,14 @@ function TaskDetailView({ taskId, onBack, onEdit }: TaskDetailViewProps) {
           React.createElement(Flex, { variant: 'column-stretch-start-nowrap-8' },
             React.createElement(Typography, { variant: 'caption-thick', color: 'color-text-medium' }, 'Status'),
             React.createElement(Flex, { variant: 'row-center-start-nowrap-6' },
-              (task.status === 'open' && (task.attempt ?? 0) > 0) && React.createElement(Button, {
+              (task.status === 'open' && (task.context?.runHistory?.length ?? 0) > 0) && React.createElement(Button, {
                 size: 'xs', variant: 'fill', color: 'primary',
                 onClick: handleRetry,
                 loading: actionLoading === 'retry',
                 disabled: !!actionLoading,
               }, 'Retry Task'),
 
-              (task.status === 'open' || task.status === 'pending' || task.status === 'in-progress' || task.status === 'blocked') && React.createElement(Button, {
+              (task.status === 'open' || task.status === 'in-progress') && React.createElement(Button, {
                 size: 'xs', variant: 'outlined', color: 'danger',
                 onClick: handleCancel,
                 loading: actionLoading === 'cancel',
@@ -822,24 +811,12 @@ function TaskDetailView({ taskId, onBack, onEdit }: TaskDetailViewProps) {
             }, task.context.notes),
           ),
 
-          // Last error
-          task.context?.lastError && React.createElement(Flex, {
-            variant: 'column-stretch-start-nowrap-4',
-          },
-            React.createElement(Typography, { variant: 'caption-thick', color: 'color-status-negative' }, 'Last Error'),
-            React.createElement(Typography, {
-              variant: 'smallCaption-regular',
-              color: 'color-text-high',
-              style: { fontFamily: 'var(--font-mono, monospace)', whiteSpace: 'pre-wrap' },
-            }, task.context.lastError),
-          ),
-
-          // Run summaries (accumulated context)
-          (task.context?.runSummaries?.length ?? 0) > 0 && React.createElement(Flex, {
+          // Run history (accumulated context)
+          (task.context?.runHistory?.length ?? 0) > 0 && React.createElement(Flex, {
             variant: 'column-stretch-start-nowrap-6',
           },
-            React.createElement(Typography, { variant: 'caption-thick', color: 'color-text-medium' }, 'Run Summaries'),
-            ...(task.context?.runSummaries ?? []).map((rs: Record<string, unknown>, i: number) =>
+            React.createElement(Typography, { variant: 'caption-thick', color: 'color-text-medium' }, 'Run History'),
+            ...(task.context?.runHistory ?? []).map((rs: Record<string, unknown>, i: number) =>
               React.createElement(Card, {
                 key: `rs-${i}`,
                 variant: 'bordered',
@@ -862,9 +839,9 @@ function TaskDetailView({ taskId, onBack, onEdit }: TaskDetailViewProps) {
                   variant: 'smallCaption-regular', color: 'color-text-subtle',
                   style: { fontFamily: 'var(--font-mono, monospace)' },
                 }, `Files: ${(rs.filesModified as string[]).join(', ')}`),
-                rs.error && React.createElement(Typography, {
-                  variant: 'smallCaption-regular', color: 'color-status-negative',
-                }, `Error: ${rs.error}`),
+                rs.remainingWork && React.createElement(Typography, {
+                  variant: 'smallCaption-regular', color: 'color-status-caution',
+                }, `Remaining: ${rs.remainingWork}`),
               ),
             ),
           ),
@@ -876,7 +853,7 @@ function TaskDetailView({ taskId, onBack, onEdit }: TaskDetailViewProps) {
             React.createElement(Typography, { variant: 'caption-thick', color: 'color-text-medium' }, 'Budget'),
             React.createElement(Flex, { variant: 'row-center-start-nowrap-16' },
               React.createElement(Typography, { variant: 'smallCaption-regular', color: 'color-text-high' },
-                `Tokens: ${task.tokensUsed?.toLocaleString() ?? 0}${task.budgetTokens ? ` / ${task.budgetTokens.toLocaleString()}` : ''}`),
+                `Tokens: ${task.tokensUsed?.toLocaleString() ?? 0}`),
               React.createElement(Typography, { variant: 'smallCaption-regular', color: 'color-text-high' },
                 `Cost: $${(task.costUsed ?? 0).toFixed(3)}${task.budgetCost ? ` / $${task.budgetCost.toFixed(2)}` : ''}`),
             ),