agent-relay 3.2.8 → 3.2.10

package/packages/sdk/src/workflows/listr-renderer.ts

@@ -0,0 +1,278 @@
+import chalk from 'chalk';
+import type { ListrTask } from 'listr2';
+import type { WorkflowEvent, WorkflowEventListener } from './runner.js';
+
+// Filter console.log while listr owns the terminal.
+// Blocks [broker] noise and [workflow HH:MM] timing lines, but lets the
+// observer URL and channel name through so users can track the run.
+function installOutputFilter(): () => void {
+  const orig = console.log.bind(console);
+  console.log = (...args: unknown[]) => {
+    const str = String(args[0] ?? '');
+    // Always show the observer URL and channel so users can follow the run
+    if (str.includes('Observer:') || str.includes('agentrelay.dev') || str.includes('Channel: wf-')) {
+      orig(...args);
+      return;
+    }
+    // Block [broker] lines and [workflow HH:MM] timing lines
+    if (/\[broker\]/.test(str) || /\[workflow\s+\d{2}:\d{2}\]/.test(str)) return;
+    orig(...args);
+  };
+  return () => {
+    console.log = orig;
+  };
+}
+
+interface RenderableTask {
+  title: string;
+  output: string;
+}
+
+interface StepHandle {
+  resolve: () => void;
+  reject: (error: Error) => void;
+  setOutput: (text: string) => void;
+  markSkipped: () => void;
+}
+
+export interface WorkflowRenderer {
+  /** Pass this to `.run({ onEvent })` in your TypeScript workflow. */
+  onEvent: WorkflowEventListener;
+  /** Start the listr renderer. Run this concurrently with your workflow. */
+  start: () => Promise<void>;
+  /** Restore console.log after the workflow finishes. */
+  unmount: () => void;
+}
+
+/**
+ * Creates a listr2-based renderer for TypeScript workflows.
+ *
+ * @example
+ * ```typescript
+ * import { workflow, createWorkflowRenderer } from '@agent-relay/sdk/workflows';
+ *
+ * const renderer = createWorkflowRenderer();
+ * const [result] = await Promise.all([
+ *   workflow('my-workflow').step(...).run({ onEvent: renderer.onEvent }),
+ *   renderer.start(),
+ * ]);
+ * renderer.unmount();
+ * ```
+ */
+export function createWorkflowRenderer(): WorkflowRenderer {
+  const stepHandles = new Map<string, StepHandle>();
+
+  let resolveWorkflow!: () => void;
+  let rejectWorkflow!: (error: Error) => void;
+  const workflowDone = new Promise<void>((resolve, reject) => {
+    resolveWorkflow = resolve;
+    rejectWorkflow = reject;
+  });
+  // Prevent unhandled rejection if run:failed fires before the header task
+  // reaches `await workflowDone`.
+  workflowDone.catch(() => {});
+
+  let setHeader: (text: string) => void = () => {};
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let listr: any = null;
+  const pendingAdds: ListrTask[] = [];
+
+  async function ensureListr(): Promise<any> {
+    if (listr) return listr;
+    const { Listr } = await import('listr2');
+    listr = new (Listr as any)(
+      [
+        {
+          title: chalk.dim('Workflow starting...'),
+          task: async (_ctx, task): Promise<void> => {
+            setHeader = (text: string): void => {
+              task.title = text;
+            };
+            await workflowDone;
+          },
+        } as ListrTask,
+      ],
+      {
+        concurrent: true,
+        renderer: process.stdout.isTTY ? 'default' : 'verbose',
+        rendererOptions: {
+          collapseErrors: false,
+          showErrorMessage: true,
+      },
+    },
+    );
+    for (const task of pendingAdds) listr.add(task);
+    pendingAdds.length = 0;
+    return listr;
+  }
+
+  const addTask = (task: ListrTask): void => {
+    if (listr) listr.add(task);
+    else pendingAdds.push(task);
+  };
+
+  const onEvent: WorkflowEventListener = (event: WorkflowEvent) => {
+    switch (event.type) {
+      case 'run:started': {
+        setHeader(chalk.dim(`[workflow] run ${event.runId.slice(0, 8)}...`));
+        break;
+      }
+
+      case 'step:started': {
+        let resolveStep!: () => void;
+        let rejectStep!: (error: Error) => void;
+        let taskRef: RenderableTask | null = null;
+        let skipped = false;
+
+        const done = new Promise<void>((resolve, reject) => {
+          resolveStep = resolve;
+          rejectStep = reject;
+        });
+        // Prevent unhandled rejection if the step fails before the listr
+        // task function has started and reached `await done`.
+        done.catch(() => {});
+
+        stepHandles.set(event.stepName, {
+          resolve: resolveStep,
+          reject: rejectStep,
+          setOutput: (text: string) => {
+            if (taskRef) taskRef.output = text;
+          },
+          markSkipped: () => {
+            skipped = true;
+            if (taskRef) taskRef.title = chalk.dim(`${event.stepName} (skipped)`);
+          },
+        });
+
+        addTask({
+          title: chalk.white(event.stepName),
+          task: async (_ctx, task): Promise<void> => {
+            taskRef = task as RenderableTask;
+            if (skipped) taskRef.title = chalk.dim(`${event.stepName} (skipped)`);
+            await done;
+          },
+          rendererOptions: { persistentOutput: true },
+        } as ListrTask);
+        break;
+      }
+
+      case 'step:owner-assigned': {
+        const handle = stepHandles.get(event.stepName);
+        if (handle) {
+          handle.setOutput(
+            chalk.dim(`> Owner: ${event.ownerName}`) +
+              (event.specialistName ? chalk.dim(` · specialist: ${event.specialistName}`) : ''),
+          );
+        }
+        break;
+      }
+
+      case 'step:retrying': {
+        stepHandles.get(event.stepName)?.setOutput(chalk.yellow(`Retrying (attempt ${event.attempt})`));
+        break;
+      }
+
+      case 'step:nudged': {
+        stepHandles.get(event.stepName)?.setOutput(chalk.dim(`> Nudge #${event.nudgeCount}`));
+        break;
+      }
+
+      case 'step:force-released': {
+        stepHandles.get(event.stepName)?.setOutput(chalk.yellow('> Force-released'));
+        break;
+      }
+
+      case 'step:review-completed': {
+        stepHandles
+          .get(event.stepName)
+          ?.setOutput(chalk.dim(`> Review: ${event.decision} by ${event.reviewerName}`));
+        break;
+      }
+
+      case 'step:owner-timeout': {
+        stepHandles
+          .get(event.stepName)
+          ?.setOutput(chalk.red(`> Owner ${event.ownerName} timed out`));
+        break;
+      }
+
+      case 'step:agent-report': {
+        const handle = stepHandles.get(event.stepName);
+        if (handle) {
+          const model = event.report.model ? `:${event.report.model}` : '';
+          handle.setOutput(chalk.dim(`> Report collected (${event.report.cli}${model})`));
+        }
+        break;
+      }
+
+      case 'step:completed': {
+        stepHandles.get(event.stepName)?.resolve();
+        break;
+      }
+
+      case 'step:skipped': {
+        const handle = stepHandles.get(event.stepName);
+        if (handle) {
+          handle.markSkipped();
+          handle.resolve();
+        } else {
+          // Step was skipped without ever being started (downstream of a failure).
+          addTask({
+            title: chalk.dim(`${event.stepName} (skipped)`),
+            task: async (): Promise<void> => {},
+            rendererOptions: { persistentOutput: true },
+          } as ListrTask);
+        }
+        break;
+      }
+
+      case 'step:failed': {
+        stepHandles.get(event.stepName)?.reject(new Error(event.error ?? 'Step failed'));
+        break;
+      }
+
+      case 'run:completed': {
+        setHeader(chalk.green('Workflow completed'));
+        resolveWorkflow();
+        break;
+      }
+
+      case 'run:failed': {
+        setHeader(chalk.red(`Workflow failed: ${event.error ?? 'unknown error'}`));
+        rejectWorkflow(new Error(event.error ?? 'Workflow failed'));
+        break;
+      }
+
+      case 'run:cancelled': {
+        setHeader(chalk.yellow('Workflow cancelled'));
+        resolveWorkflow();
+        break;
+      }
+
+      case 'broker:event':
+        break;
+
+      default: {
+        const _exhaustive: never = event;
+        void _exhaustive;
+      }
+    }
+  };
+
+  let restoreConsole: (() => void) | undefined;
+
+  return {
+    onEvent,
+    start: async () => {
+      restoreConsole = installOutputFilter();
+      const l = await ensureListr();
+      return l.run().catch(() => {
+        // Step failures are already represented in the workflow result.
+      });
+    },
+    unmount: () => {
+      restoreConsole?.();
+      restoreConsole = undefined;
+    },
+  };
+}

package/packages/sdk/src/workflows/run-summary-table.ts

@@ -0,0 +1,110 @@
+import type { CliSessionReport } from './cli-session-collector.js';
+import type { StepOutcome } from './trajectory.js';
+
+function formatCurrency(value: number | null | undefined): string {
+  return typeof value === 'number' ? `$${value.toFixed(2)}` : '--';
+}
+
+function formatTokens(report: CliSessionReport | undefined): string {
+  if (!report?.tokens) return '--';
+  const total = report.tokens.input + report.tokens.output + report.tokens.cacheRead;
+  return total.toLocaleString('en-US');
+}
+
+function formatDuration(durationMs: number | null | undefined): string {
+  if (typeof durationMs !== 'number' || !Number.isFinite(durationMs)) return '--';
+  if (durationMs < 1000) return `${durationMs}ms`;
+
+  const totalSeconds = Math.round(durationMs / 1000);
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+}
+
+function truncate(value: string, length: number): string {
+  if (value.length <= length) return value;
+  if (length <= 1) return value.slice(0, length);
+  return `${value.slice(0, length - 1)}…`;
+}
+
+function pad(value: string, width: number, align: 'left' | 'right' = 'left'): string {
+  return align === 'right' ? value.padStart(width, ' ') : value.padEnd(width, ' ');
+}
+
+function formatErrors(outcome: StepOutcome, report: CliSessionReport | undefined): string {
+  const count = report?.errors.length ?? 0;
+  if (count === 0) return outcome.status === 'failed' && outcome.error ? '1' : '--';
+  if (outcome.status === 'completed') return `${count} (fixed)`;
+  return String(count);
+}
+
+export function formatRunSummaryTable(
+  outcomes: StepOutcome[],
+  reports: Map<string, CliSessionReport>
+): string {
+  // Only show the Cost column when at least one report has reliable cost data
+  // (currently only OpenCode populates cost; Claude and Codex return null)
+  const hasCost = Array.from(reports.values()).some((r) => typeof r.cost === 'number' && r.cost > 0);
+
+  const headers = hasCost
+    ? ['Step', 'Status', 'Model', 'Cost', 'Tokens', 'Duration', 'Errors']
+    : ['Step', 'Status', 'Model', 'Tokens', 'Duration', 'Errors'];
+  const widths = hasCost
+    ? [20, 6, 16, 8, 10, 10, 10]
+    : [20, 6, 16, 10, 10, 10];
+  const lines: string[] = [];
+
+  lines.push(headers.map((h, i) => {
+    const align = i <= 2 ? 'left' : 'right';
+    return pad(h, widths[i], align);
+  }).join('  '));
+
+  let totalCost = 0;
+  let totalTokens = 0;
+  let totalDurationMs = 0;
+
+  for (const outcome of outcomes) {
+    const report = reports.get(outcome.name);
+    const reportDuration = report?.durationMs ?? outcome.durationMs;
+    const reportTokens = report?.tokens
+      ? report.tokens.input + report.tokens.output + report.tokens.cacheRead
+      : 0;
+
+    if (typeof report?.cost === 'number') totalCost += report.cost;
+    totalTokens += reportTokens;
+    if (typeof reportDuration === 'number') totalDurationMs += reportDuration;
+
+    const cols: string[] = [
+      pad(truncate(outcome.name, widths[0]), widths[0]),
+      pad(outcome.status === 'failed' ? 'FAIL' : outcome.status === 'completed' ? 'pass' : 'skip', widths[1]),
+      pad(truncate(report?.model ?? '--', widths[2]), widths[2]),
+    ];
+    if (hasCost) cols.push(pad(formatCurrency(report?.cost), widths[3], 'right'));
+    const tokenIdx = hasCost ? 4 : 3;
+    cols.push(pad(formatTokens(report), widths[tokenIdx], 'right'));
+    cols.push(pad(formatDuration(reportDuration), widths[tokenIdx + 1], 'right'));
+    cols.push(pad(formatErrors(outcome, report), widths[tokenIdx + 2], 'right'));
+
+    lines.push(cols.join('  '));
+
+    if (outcome.status === 'failed') {
+      const firstError = report?.errors[0];
+      if (firstError) {
+        lines.push(`  └─ Error [turn ${firstError.turn}] ${truncate(firstError.text, 120)}`);
+      }
+    }
+  }
+
+  const totalLabelWidth = widths[0] + widths[1] + widths[2] + 4;
+  lines.push('─'.repeat(lines[0].length));
+
+  const totalCols: string[] = [pad('Total', totalLabelWidth)];
+  if (hasCost) totalCols.push(pad(formatCurrency(totalCost), widths[3], 'right'));
+  const tokenIdx = hasCost ? 4 : 3;
+  totalCols.push(pad(totalTokens > 0 ? totalTokens.toLocaleString('en-US') : '--', widths[tokenIdx], 'right'));
+  totalCols.push(pad(formatDuration(totalDurationMs), widths[tokenIdx + 1], 'right'));
+  totalCols.push(pad('', widths[tokenIdx + 2], 'right'));
+  lines.push(totalCols.join('  '));
+
+  return lines.map((line) => `  ${line}`).join('\n');
+}

package/packages/sdk/src/workflows/runner.ts

@@ -19,6 +19,7 @@ import {
 import type { Dirent, WriteStream } from 'node:fs';
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import path from 'node:path';
+import chalk from 'chalk';
 
 import { parse as parseYaml } from 'yaml';
 import { stripAnsi as stripAnsiFn } from '../pty.js';
@@ -32,7 +33,9 @@ import {
   CustomStepsParseError,
   CustomStepResolutionError,
 } from './custom-steps.js';
+import { collectCliSession, type CliSessionReport } from './cli-session-collector.js';
 import { InMemoryWorkflowDb } from './memory-db.js';
+import { formatRunSummaryTable } from './run-summary-table.js';
 import type {
   AgentCli,
   AgentDefinition,
@@ -157,6 +160,7 @@ export type WorkflowEvent =
       decision: 'approved' | 'rejected';
     }
   | { type: 'step:owner-timeout'; runId: string; stepName: string; ownerName: string }
+  | { type: 'step:agent-report'; runId: string; stepName: string; report: CliSessionReport }
   | { type: 'step:failed'; runId: string; stepName: string; error: string; exitCode?: number; exitSignal?: string }
   | { type: 'step:skipped'; runId: string; stepName: string }
   | { type: 'step:retrying'; runId: string; stepName: string; attempt: number }
@@ -360,6 +364,8 @@ export class WorkflowRunner {
   private resolvedPaths = new Map<string, string>();
   /** Tracks agent names currently assigned as reviewers (ref-counted to handle concurrent usage). */
   private readonly activeReviewers = new Map<string, number>();
+  /** Structured CLI session reports captured during the current run, keyed by step name. */
+  private readonly agentReports = new Map<string, CliSessionReport>();
 
   constructor(options: WorkflowRunnerOptions = {}) {
     this.db = options.db ?? new InMemoryWorkflowDb();
@@ -454,6 +460,13 @@ export class WorkflowRunner {
     return resolved;
   }
 
+  private resolveEffectiveCwd(step: WorkflowStep, agentDef?: AgentDefinition): string {
+    if (step.cwd) {
+      return path.resolve(this.cwd, step.cwd);
+    }
+    return this.resolveStepWorkdir(step) ?? (agentDef ? this.resolveAgentCwd(agentDef) : this.cwd);
+  }
+
   private static readonly EVIDENCE_IGNORED_DIRS = new Set([
     '.git',
     '.agent-relay',
@@ -990,7 +1003,7 @@ export class WorkflowRunner {
       mins > 0
         ? `${String(mins).padStart(2, '0')}:${String(secs).padStart(2, '0')}`
         : `00:${String(secs).padStart(2, '0')}`;
-    console.log(`[workflow ${ts}] ${msg}`);
+    console.log(`${chalk.dim.cyan('[workflow')} ${chalk.dim.cyan(ts)}${chalk.dim.cyan(']')} ${msg}`);
   }
 
   // ── Relaycast auto-provisioning ────────────────────────────────────────
@@ -1993,6 +2006,7 @@ export class WorkflowRunner {
     this.runStartTime = Date.now();
     this.runtimeStepAgents.clear();
     this.stepCompletionEvidence.clear();
+    this.agentReports.clear();
 
     this.log(`Starting workflow "${workflow.name}" (${workflow.steps.length} steps)`);
 
@@ -2235,7 +2249,7 @@ export class WorkflowRunner {
 
         // Wire broker stderr to console for observability
         this.unsubBrokerStderr = this.relay.onBrokerStderr((line: string) => {
-          console.log(`[broker] ${line}`);
+          console.log(`${chalk.dim.yellow('[broker]')} ${line}`);
         });
 
         if (!relaycastDisabled) {
@@ -2771,7 +2785,7 @@ export class WorkflowRunner {
       });
 
       // Resolve step workdir (named path reference) for deterministic steps
-      const stepCwd = this.resolveStepWorkdir(step) ?? this.cwd;
+      const stepCwd = this.resolveEffectiveCwd(step);
       this.beginStepEvidence(step.name, [stepCwd], state.row.startedAt);
 
       try {
@@ -3245,6 +3259,9 @@ export class WorkflowRunner {
     let lastExitCode: number | undefined;
     let lastExitSignal: string | undefined;
     let lastCompletionReason: WorkflowStepCompletionReason | undefined;
+    let lastAttemptStartedAt: number | undefined;
+    let lastEffectiveAgentDef: AgentDefinition | undefined;
+    let lastEffectiveCwd: string | undefined;
 
     // OWNER_DECISION: INCOMPLETE_RETRY is enforced here at the attempt-loop level so every
     // interactive execution path shares the same contract:
@@ -3276,6 +3293,7 @@ export class WorkflowRunner {
       }
 
       try {
+        lastAttemptStartedAt = Date.now();
         // Mark step as running
         state.row.status = 'running';
         state.row.error = undefined;
@@ -3334,7 +3352,10 @@ export class WorkflowRunner {
         }
 
         // Apply step-level workdir override to agent definitions if present
-        const applyStepWorkdir = (def: AgentDefinition): AgentDefinition => {
+        const applyStepCwd = (def: AgentDefinition): AgentDefinition => {
+          if (step.cwd) {
+            return { ...def, cwd: step.cwd, workdir: undefined };
+          }
           if (step.workdir) {
             const stepWorkdir = this.resolveStepWorkdir(step);
             if (stepWorkdir) {
@@ -3343,9 +3364,11 @@ export class WorkflowRunner {
           }
           return def;
         };
-        const effectiveSpecialist = applyStepWorkdir(specialistDef);
-        const effectiveOwner = applyStepWorkdir(ownerDef);
-        const effectiveReviewer = reviewDef ? applyStepWorkdir(reviewDef) : undefined;
+        const effectiveSpecialist = applyStepCwd(specialistDef);
+        const effectiveOwner = applyStepCwd(ownerDef);
+        const effectiveReviewer = reviewDef ? applyStepCwd(reviewDef) : undefined;
+        lastEffectiveAgentDef = effectiveSpecialist;
+        lastEffectiveCwd = this.resolveAgentCwd(effectiveSpecialist);
         this.beginStepEvidence(
           step.name,
           [
@@ -3518,6 +3541,15 @@ export class WorkflowRunner {
           }
         }
 
+        await this.captureAgentReport(
+          runId,
+          step.name,
+          lastEffectiveAgentDef,
+          lastEffectiveCwd,
+          lastAttemptStartedAt,
+          Date.now()
+        );
+
         // Mark completed
         state.row.status = 'completed';
         state.row.output = combinedOutput;
@@ -3570,6 +3602,14 @@ export class WorkflowRunner {
       typeof step.verification === 'object' && 'value' in step.verification
         ? String(step.verification.value)
         : undefined;
+    await this.captureAgentReport(
+      runId,
+      step.name,
+      lastEffectiveAgentDef,
+      lastEffectiveCwd,
+      lastAttemptStartedAt,
+      Date.now()
+    );
     await this.trajectory?.stepFailed(step, lastError ?? 'Unknown error', maxRetries + 1, maxRetries, {
       agent: agentName,
       nonInteractive,
@@ -4856,7 +4896,7 @@ export class WorkflowRunner {
       const { stdout: output, exitCode, exitSignal } = await new Promise<{ stdout: string; exitCode?: number; exitSignal?: string }>((resolve, reject) => {
         const child = cpSpawn(cmd, args, {
           stdio: ['ignore', 'pipe', 'pipe'],
-          cwd: this.resolveAgentCwd(agentDef),
+          cwd: this.resolveEffectiveCwd(step, agentDef),
           env: this.getRelayEnv() ?? { ...process.env },
         });
 
@@ -5728,6 +5768,35 @@ export class WorkflowRunner {
     this.finalizeStepEvidence(state.row.stepName, 'failed', state.row.completedAt, completionReason);
   }
 
+  private async captureAgentReport(
+    runId: string,
+    stepName: string,
+    agentDef: AgentDefinition | undefined,
+    cwd: string | undefined,
+    startedAt: number | undefined,
+    completedAt: number
+  ): Promise<void> {
+    if (!agentDef || !cwd || !startedAt) return;
+
+    try {
+      const report = await collectCliSession({
+        cli: agentDef.cli,
+        cwd,
+        startedAt,
+        completedAt,
+      });
+      if (!report) return;
+
+      this.agentReports.set(stepName, report);
+      this.emit({ type: 'step:agent-report', runId, stepName, report });
+      await this.persistAgentReport(runId, stepName, report);
+    } catch (error) {
+      this.log(
+        `[${stepName}] CLI session collection failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+
   private async markDownstreamSkipped(
     failedStepName: string,
     allSteps: WorkflowStep[],
@@ -6003,26 +6072,33 @@ export class WorkflowRunner {
     const skipped = outcomes.filter((o) => o.status === 'skipped');
 
     console.log('');
-    console.log('━'.repeat(70));
-    console.log(`  Workflow "${workflowName}" — ${failed.length === 0 ? 'COMPLETED' : 'FAILED'}`);
-    console.log(`  ${completed.length} passed, ${failed.length} failed, ${skipped.length} skipped`);
-    console.log('━'.repeat(70));
-
-    for (const outcome of outcomes) {
-      const icon = outcome.status === 'completed' ? '✓' : outcome.status === 'failed' ? '✗' : '⊘';
-      const retryNote = outcome.attempts > 1 ? ` (${outcome.attempts} attempts)` : '';
-      console.log(`  ${icon} ${outcome.name} [${outcome.agent}]${retryNote}`);
-
-      if (outcome.error) {
-        console.log(`    Error: ${outcome.error}`);
-      }
+    console.log(chalk.dim('━'.repeat(70)));
+    console.log(`  Workflow "${workflowName}" — ${failed.length === 0 ? chalk.green('COMPLETED') : chalk.red('FAILED')}`);
+    console.log(
+      `  ${chalk.green(`${completed.length} passed`)}, ${chalk.red(`${failed.length} failed`)}, ${chalk.dim(`${skipped.length} skipped`)}`
+    );
+    console.log(chalk.dim('━'.repeat(70)));
+
+    if (this.agentReports.size > 0) {
+      console.log(formatRunSummaryTable(outcomes, this.agentReports));
+    } else {
+      for (const outcome of outcomes) {
+        const icon =
+          outcome.status === 'completed' ? chalk.green('✓') : outcome.status === 'failed' ? chalk.red('✗') : chalk.dim('⊘');
+        const retryNote = outcome.attempts > 1 ? ` (${outcome.attempts} attempts)` : '';
+        console.log(`  ${icon} ${outcome.name} [${outcome.agent}]${retryNote}`);
+
+        if (outcome.error) {
+          console.log(`    Error: ${outcome.error}`);
+        }
 
-      // Extract last meaningful lines from raw PTY output
-      if (outcome.output) {
-        const excerpt = this.extractOutputExcerpt(outcome.output);
-        if (excerpt) {
-          for (const line of excerpt.split('\n')) {
-            console.log(`    ${line}`);
+        // Extract last meaningful lines from raw PTY output
+        if (outcome.output) {
+          const excerpt = this.extractOutputExcerpt(outcome.output);
+          if (excerpt) {
+            for (const line of excerpt.split('\n')) {
+              console.log(`    ${line}`);
+            }
           }
         }
       }
@@ -6032,9 +6108,10 @@ export class WorkflowRunner {
     const outputDir = this.getStepOutputDir(runId);
     const logsDir = path.join(this.cwd, '.agent-relay', 'team', 'worker-logs');
     console.log('');
+    console.log(`  Run ID:      ${runId}`);
     console.log(`  Step output: ${outputDir}`);
     console.log(`  Agent logs:  ${logsDir}`);
-    console.log('━'.repeat(70));
+    console.log(chalk.dim('━'.repeat(70)));
     console.log('');
   }
 
@@ -6095,6 +6172,12 @@ export class WorkflowRunner {
     const stepsWithVerification = new Set(steps?.filter((s) => s.verification).map((s) => s.name) ?? []);
     const outcomes: StepOutcome[] = [];
     for (const [name, state] of stepStates) {
+      const startedAtMs = state.row.startedAt ? Date.parse(state.row.startedAt) : Number.NaN;
+      const completedAtMs = state.row.completedAt ? Date.parse(state.row.completedAt) : Number.NaN;
+      const durationMs =
+        Number.isFinite(startedAtMs) && Number.isFinite(completedAtMs)
+          ? Math.max(0, completedAtMs - startedAtMs)
+          : undefined;
       outcomes.push({
         name,
         agent: state.row.agentName ?? 'deterministic',
@@ -6108,6 +6191,7 @@ export class WorkflowRunner {
         output: state.row.output,
         error: state.row.error,
         verificationPassed: state.row.status === 'completed' && stepsWithVerification.has(name),
+        durationMs,
         completionMode: state.row.completionReason
           ? this.buildStepCompletionDecision(name, state.row.completionReason)?.mode
           : undefined,
@@ -6290,6 +6374,16 @@ export class WorkflowRunner {
     this.postToChannel(`**[${stepName}] Output:**\n\`\`\`\n${preview}\n\`\`\``, { stepName });
   }
 
+  private async persistAgentReport(runId: string, stepName: string, report: CliSessionReport): Promise<void> {
+    const reportPath = path.join(this.getStepOutputDir(runId), `${stepName}.report.json`);
+    try {
+      mkdirSync(this.getStepOutputDir(runId), { recursive: true });
+      await writeFile(reportPath, JSON.stringify(report, null, 2), 'utf8');
+    } catch {
+      // Non-critical
+    }
+  }
+
   /** Scan .agent-relay/step-outputs/ for the most recent run directory containing the needed steps. */
   private findMostRecentRunWithSteps(stepNames: Set<string>): string | undefined {
     try {