wiggum-cli 0.15.0 → 0.17.0

package/dist/tui/screens/RunScreen.js

@@ -21,9 +21,11 @@ import { Confirm } from '../components/Confirm.js';
 import { Select } from '../components/Select.js';
 import { AppShell } from '../components/AppShell.js';
 import { RunCompletionSummary } from '../components/RunCompletionSummary.js';
+import { ActivityFeed } from '../components/ActivityFeed.js';
 import { colors, theme } from '../theme.js';
-import { readLoopStatus, parseImplementationPlan, getGitBranch, formatNumber, getLoopLogPath, } from '../utils/loop-status.js';
+import { readLoopStatus, parseImplementationPlan, getGitBranch, formatNumber, getLoopLogPath, parseLoopLog, parsePhaseChanges, } from '../utils/loop-status.js';
 import { buildEnhancedRunSummary } from '../utils/build-run-summary.js';
+import { getCurrentCommitHash } from '../utils/git-summary.js';
 import { writeRunSummaryFile } from '../../utils/summary-file.js';
 import { loadConfigWithDefaults } from '../../utils/config.js';
 import { logger } from '../../utils/logger.js';
@@ -91,7 +93,7 @@ export function RunScreen({ header, featureName, projectRoot, sessionState, moni
         }
         catch (err) {
             logger.error(`Failed to read initial loop status: ${err instanceof Error ? err.message : String(err)}`);
-            return { running: false, iteration: 0, maxIterations: 0, phase: 'unknown', tokensInput: 0, tokensOutput: 0 };
+            return { running: false, iteration: 0, maxIterations: 0, phase: 'unknown', tokensInput: 0, tokensOutput: 0, cacheCreate: 0, cacheRead: 0 };
         }
     });
     const [tasks, setTasks] = useState({
@@ -99,6 +101,7 @@ export function RunScreen({ header, featureName, projectRoot, sessionState, moni
         tasksPending: 0,
         e2eDone: 0,
         e2ePending: 0,
+        planExists: false,
     });
     const [branch, setBranch] = useState('-');
     const [error, setError] = useState(null);
@@ -106,6 +109,9 @@ export function RunScreen({ header, featureName, projectRoot, sessionState, moni
     const [showConfirm, setShowConfirm] = useState(false);
     const [completionSummary, setCompletionSummary] = useState(null);
     const [actionRequest, setActionRequest] = useState(null);
+    const [activityEvents, setActivityEvents] = useState([]);
+    const [latestCommit, setLatestCommit] = useState(null);
+    const [baselineCommit, setBaselineCommit] = useState(null);
     const childRef = useRef(null);
     const stopRequestedRef = useRef(false);
     const isMountedRef = useRef(true);
@@ -117,6 +123,28 @@ export function RunScreen({ header, featureName, projectRoot, sessionState, moni
     const maxIterationsRef = useRef(0);
     const maxE2eAttemptsRef = useRef(0);
     const handledActionIdRef = useRef(null);
+    const lastLogLineCountRef = useRef(0);
+    const lastKnownPhasesRef = useRef(undefined);
+    const lastActivityTimeRef = useRef(Date.now());
+    const lastCommitForEventRef = useRef(null);
+    // Read baseline commit once on mount
+    useEffect(() => {
+        const baselinePath = `/tmp/ralph-loop-${featureName}.baseline`;
+        try {
+            if (existsSync(baselinePath)) {
+                const hash = readFileSync(baselinePath, 'utf-8').trim();
+                if (hash)
+                    setBaselineCommit(hash);
+            }
+        }
+        catch {
+            // Baseline file is optional — ignore read errors
+        }
+        // Also capture current HEAD as initial latestCommit
+        const head = getCurrentCommitHash(projectRoot);
+        if (head)
+            setLatestCommit(head);
+    }, [featureName, projectRoot]);
     useInput((input, key) => {
         // If showing completion summary, Enter or Esc dismisses
         if (completionSummary) {
@@ -156,6 +184,50 @@ export function RunScreen({ header, featureName, projectRoot, sessionState, moni
         if (!isMountedRef.current)
             return;
         setBranch(getGitBranch(projectRoot));
+        // Update latest commit hash
+        const head = getCurrentCommitHash(projectRoot);
+        if (head && isMountedRef.current)
+            setLatestCommit(head);
+        // Collect new activity events from log and phase changes
+        const logPath = getLoopLogPath(featureName);
+        const allLogEvents = parseLoopLog(logPath);
+        // Detect log file truncation/rotation and reset tracking
+        if (allLogEvents.length < lastLogLineCountRef.current) {
+            lastLogLineCountRef.current = 0;
+        }
+        const newLogEvents = allLogEvents.slice(lastLogLineCountRef.current);
+        lastLogLineCountRef.current = allLogEvents.length;
+        const { events: phaseEvents, currentPhases } = parsePhaseChanges(featureName, lastKnownPhasesRef.current);
+        if (currentPhases) {
+            lastKnownPhasesRef.current = currentPhases;
+        }
+        // Emit a commit activity event when HEAD changes
+        if (head && head !== lastCommitForEventRef.current && lastCommitForEventRef.current !== null) {
+            newLogEvents.push({
+                timestamp: Date.now(),
+                message: `New commit: ${head.slice(0, 7)}`,
+                status: 'success',
+            });
+        }
+        lastCommitForEventRef.current = head ?? null;
+        const MAX_STORED_EVENTS = 100;
+        const newEvents = [...newLogEvents, ...phaseEvents];
+        if (newEvents.length > 0 && isMountedRef.current) {
+            lastActivityTimeRef.current = Date.now();
+            setActivityEvents((prev) => [...prev, ...newEvents].slice(-MAX_STORED_EVENTS));
+        }
+        else if (nextStatus.running &&
+            nextStatus.phase !== 'Idle' &&
+            Date.now() - lastActivityTimeRef.current > 30_000 &&
+            isMountedRef.current) {
+            // Inject a synthetic "session in progress" event when stale
+            // Update lastActivityTimeRef so this doesn't fire every poll cycle
+            lastActivityTimeRef.current = Date.now();
+            setActivityEvents((prev) => [
+                ...prev,
+                { timestamp: Date.now(), message: `${nextStatus.phase} session in progress...`, status: 'in-progress' },
+            ].slice(-MAX_STORED_EVENTS));
+        }
         // Check for pending action request (loop waiting for user input)
         const request = readActionRequest(featureName);
         if (!isMountedRef.current)
@@ -183,6 +255,9 @@ export function RunScreen({ header, featureName, projectRoot, sessionState, moni
             const tasksDone = nextTasks.tasksDone + nextTasks.e2eDone;
             const tasksTotal = tasksDone + nextTasks.tasksPending + nextTasks.e2ePending;
             const errorTail = exitCode !== 0 ? readLogTail(logPath, ERROR_TAIL_LINES) || undefined : undefined;
+            // Use feat/<feature> as the branch name for summary. getGitBranch() returns
+            // "main" after squash-merge + worktree cleanup, which breaks PR/issue detection.
+            const summaryBranch = `feat/${featureName}`;
             const basicSummary = {
                 feature: featureName,
                 iterations: nextStatus.iteration,
@@ -191,15 +266,17 @@ export function RunScreen({ header, featureName, projectRoot, sessionState, moni
                 tasksTotal,
                 tokensInput: nextStatus.tokensInput,
                 tokensOutput: nextStatus.tokensOutput,
+                cacheCreate: nextStatus.cacheCreate,
+                cacheRead: nextStatus.cacheRead,
                 exitCode,
                 exitCodeInferred: true,
-                branch: getGitBranch(projectRoot),
+                branch: summaryBranch,
                 logPath,
                 errorTail,
             };
             let enhancedSummary;
             try {
-                enhancedSummary = buildEnhancedRunSummary(basicSummary, projectRoot, featureName);
+                enhancedSummary = buildEnhancedRunSummary(basicSummary, projectRoot, featureName, baselineCommit);
             }
             catch (err) {
                 logger.error(`Failed to build enhanced summary for ${featureName}: ${err instanceof Error ? err.message : String(err)}`);
@@ -211,7 +288,7 @@ export function RunScreen({ header, featureName, projectRoot, sessionState, moni
                 logger.error(`Failed to persist summary file for ${featureName}: ${err instanceof Error ? err.message : String(err)}`);
             });
         }
-    }, [featureName, projectRoot, monitorOnly]);
+    }, [featureName, projectRoot, monitorOnly, baselineCommit]);
     // Keep a stable ref to the latest refreshStatus so the spawn effect
     // can schedule polls without re-running when refreshStatus changes.
     const refreshStatusRef = useRef(refreshStatus);
@@ -376,6 +453,10 @@ export function RunScreen({ header, featureName, projectRoot, sessionState, moni
                             closeSync(logFd);
                             logFdClosed = true;
                         }
+                        if (!isMountedRef.current)
+                            return;
+                        // Wait for bash to flush state files (.phases, .tokens, .final)
+                        await new Promise((r) => setTimeout(r, 200));
                         if (!isMountedRef.current)
                             return;
                         let latestStatus;
@@ -386,8 +467,8 @@ export function RunScreen({ header, featureName, projectRoot, sessionState, moni
                         }
                         catch (err) {
                             logger.error(`Failed to read final run status for ${featureName}: ${err instanceof Error ? err.message : String(err)}`);
-                            latestStatus = { running: false, iteration: 0, maxIterations: config.loop.maxIterations, phase: 'unknown', tokensInput: 0, tokensOutput: 0 };
-                            latestTasks = { tasksDone: 0, tasksPending: 0, e2eDone: 0, e2ePending: 0 };
+                            latestStatus = { running: false, iteration: 0, maxIterations: config.loop.maxIterations, phase: 'unknown', tokensInput: 0, tokensOutput: 0, cacheCreate: 0, cacheRead: 0 };
+                            latestTasks = { tasksDone: 0, tasksPending: 0, e2eDone: 0, e2ePending: 0, planExists: false };
                         }
                         const tasksDone = latestTasks.tasksDone + latestTasks.e2eDone;
                         const tasksTotal = tasksDone + latestTasks.tasksPending + latestTasks.e2ePending;
@@ -401,15 +482,17 @@ export function RunScreen({ header, featureName, projectRoot, sessionState, moni
                             tasksTotal,
                             tokensInput: latestStatus.tokensInput,
                             tokensOutput: latestStatus.tokensOutput,
+                            cacheCreate: latestStatus.cacheCreate,
+                            cacheRead: latestStatus.cacheRead,
                             exitCode,
-                            branch: getGitBranch(projectRoot),
+                            branch: `feat/${featureName}`,
                             logPath,
                             errorTail,
                         };
                         // Build enhanced summary with phases, git stats, PR/issue metadata
                         let enhancedSummary;
                         try {
-                            enhancedSummary = buildEnhancedRunSummary(basicSummary, projectRoot, featureName);
+                            enhancedSummary = buildEnhancedRunSummary(basicSummary, projectRoot, featureName, baselineCommit);
                         }
                         catch (err) {
                             logger.error(`Failed to build enhanced summary for ${featureName}: ${err instanceof Error ? err.message : String(err)}`);
@@ -456,7 +539,7 @@ export function RunScreen({ header, featureName, projectRoot, sessionState, moni
     const percentTasks = totalTasks > 0 ? Math.round((tasks.tasksDone / totalTasks) * 100) : 0;
     const percentE2e = totalE2e > 0 ? Math.round((tasks.e2eDone / totalE2e) * 100) : 0;
     const percentAll = totalAll > 0 ? Math.round((doneAll / totalAll) * 100) : 0;
-    const totalTokens = status.tokensInput + status.tokensOutput;
+    const totalTokens = status.tokensInput + status.tokensOutput + status.cacheCreate + status.cacheRead;
     const phaseLine = isStarting ? 'Starting...' : status.phase;
     const isRunning = !completionSummary && !error;
     // Tips text
@@ -507,5 +590,7 @@ export function RunScreen({ header, featureName, projectRoot, sessionState, moni
             action: 'Run Loop',
             phase: phaseLine,
             path: featureName,
-        }, children: completionSummary ? (_jsx(RunCompletionSummary, { summary: completionSummary })) : (!error && (_jsxs(_Fragment, { children: [_jsxs(Box, { marginTop: 1, flexDirection: "row", children: [_jsx(Text, { children: "Phase: " }), _jsx(Text, { color: colors.yellow, children: phaseLine }), _jsx(Text, { dimColor: true, children: theme.statusLine.separator }), _jsx(Text, { children: "Iter: " }), _jsx(Text, { color: colors.green, children: status.iteration }), _jsxs(Text, { dimColor: true, children: ["/", status.maxIterations || maxIterationsRef.current || '-'] }), _jsx(Text, { dimColor: true, children: theme.statusLine.separator }), _jsx(Text, { children: "Branch: " }), _jsx(Text, { color: colors.blue, children: branch })] }), _jsxs(Box, { marginTop: 1, flexDirection: "row", children: [_jsx(Text, { children: "Tokens: " }), _jsx(Text, { color: colors.pink, children: formatNumber(totalTokens) }), _jsxs(Text, { dimColor: true, children: [" (in:", formatNumber(status.tokensInput), " out:", formatNumber(status.tokensOutput), ")"] }), _jsx(Text, { dimColor: true, children: theme.statusLine.separator }), _jsxs(Text, { dimColor: true, children: ["Elapsed: ", formatDuration(startTimeRef.current)] })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", alignItems: "center", gap: 1, children: [_jsx(Text, { bold: true, children: "Implementation:" }), _jsx(ProgressBar, { percent: percentTasks }), _jsxs(Text, { children: [percentTasks, "%"] }), _jsxs(Text, { color: colors.green, children: ['\u2713', " ", tasks.tasksDone] }), _jsxs(Text, { color: colors.yellow, children: ['\u25cb', " ", tasks.tasksPending] })] }), totalE2e > 0 && (_jsxs(Box, { flexDirection: "row", alignItems: "center", gap: 1, children: [_jsx(Text, { bold: true, children: "E2E Tests:" }), _jsx(ProgressBar, { percent: percentE2e }), _jsxs(Text, { children: [percentE2e, "%"] }), _jsxs(Text, { color: colors.green, children: ['\u2713', " ", tasks.e2eDone] }), _jsxs(Text, { color: colors.yellow, children: ['\u25cb', " ", tasks.e2ePending] })] })), _jsxs(Box, { flexDirection: "row", alignItems: "center", gap: 1, marginTop: 1, children: [_jsx(Text, { bold: true, children: "Overall:" }), _jsx(ProgressBar, { percent: percentAll }), _jsxs(Text, { children: [percentAll, "%"] }), _jsxs(Text, { color: colors.green, children: ['\u2713', " ", doneAll] }), _jsxs(Text, { color: colors.yellow, children: ['\u25cb', " ", totalAll - doneAll] })] })] })] }))) }));
+        }, children: completionSummary ? (_jsx(RunCompletionSummary, { summary: completionSummary })) : (!error && (_jsxs(_Fragment, { children: [_jsxs(Box, { marginTop: 1, flexDirection: "row", children: [_jsx(Text, { children: "Phase: " }), _jsx(Text, { color: colors.yellow, children: phaseLine }), _jsx(Text, { dimColor: true, children: theme.statusLine.separator }), _jsx(Text, { children: "Iter: " }), _jsx(Text, { color: colors.green, children: status.iteration }), _jsxs(Text, { dimColor: true, children: ["/", status.maxIterations || maxIterationsRef.current || '-'] }), _jsx(Text, { dimColor: true, children: theme.statusLine.separator }), _jsx(Text, { children: "Branch: " }), _jsx(Text, { color: colors.blue, children: branch })] }), _jsxs(Box, { marginTop: 1, flexDirection: "row", children: [_jsx(Text, { children: "Tokens: " }), _jsx(Text, { color: colors.pink, children: formatNumber(totalTokens) }), _jsxs(Text, { dimColor: true, children: [" (in:", formatNumber(status.tokensInput), " out:", formatNumber(status.tokensOutput), " cache:", formatNumber(status.cacheRead), ")"] }), _jsx(Text, { dimColor: true, children: theme.statusLine.separator }), _jsxs(Text, { dimColor: true, children: ["Elapsed: ", formatDuration(startTimeRef.current)] })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", alignItems: "center", gap: 1, children: [_jsx(Text, { bold: true, children: "Implementation:" }), _jsx(ProgressBar, { percent: percentTasks }), _jsxs(Text, { children: [percentTasks, "%"] }), _jsxs(Text, { color: colors.green, children: ['\u2713', " ", tasks.tasksDone] }), _jsxs(Text, { color: colors.yellow, children: ['\u25cb', " ", tasks.tasksPending] })] }), totalE2e > 0 && (_jsxs(Box, { flexDirection: "row", alignItems: "center", gap: 1, children: [_jsx(Text, { bold: true, children: "E2E Tests:" }), _jsx(ProgressBar, { percent: percentE2e }), _jsxs(Text, { children: [percentE2e, "%"] }), _jsxs(Text, { color: colors.green, children: ['\u2713', " ", tasks.e2eDone] }), _jsxs(Text, { color: colors.yellow, children: ['\u25cb', " ", tasks.e2ePending] })] })), _jsxs(Box, { flexDirection: "row", alignItems: "center", gap: 1, marginTop: 1, children: [_jsx(Text, { bold: true, children: "Overall:" }), _jsx(ProgressBar, { percent: percentAll }), _jsxs(Text, { children: [percentAll, "%"] }), _jsxs(Text, { color: colors.green, children: ['\u2713', " ", doneAll] }), _jsxs(Text, { color: colors.yellow, children: ['\u25cb', " ", totalAll - doneAll] })] })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Activity" }), _jsx(ActivityFeed, { events: activityEvents, latestCommit: baselineCommit && latestCommit && baselineCommit !== latestCommit
+                                ? `${baselineCommit} \u2192 ${latestCommit}`
+                                : latestCommit || undefined })] })] }))) }));
 }

package/dist/tui/utils/build-run-summary.d.ts

@@ -21,4 +21,4 @@ import type { RunSummary } from '../screens/RunScreen.js';
  * which blocks the event loop. Callers should wrap in try-catch to handle
  * failures gracefully.
  */
-export declare function buildEnhancedRunSummary(basicSummary: RunSummary, projectRoot: string, feature: string): RunSummary;
+export declare function buildEnhancedRunSummary(basicSummary: RunSummary, projectRoot: string, feature: string, baselineOverride?: string | null): RunSummary;

package/dist/tui/utils/build-run-summary.js

@@ -3,86 +3,10 @@
  */
 import { existsSync, readFileSync } from 'node:fs';
 import { logger } from '../../utils/logger.js';
-import { getCurrentCommitHash, getDiffStats } from './git-summary.js';
+import { execFileSync } from 'node:child_process';
+import { getCurrentCommitHash, getDiffStats, getCommitList } from './git-summary.js';
 import { getPrForBranch, getLinkedIssue } from './pr-summary.js';
-/**
- * Phase ID to human-readable label mapping
- */
-const PHASE_LABELS = {
-    planning: 'Planning',
-    implementation: 'Implementation',
-    e2e_testing: 'E2E Testing',
-    verification: 'Verification',
-    pr_review: 'PR & Review',
-};
-const VALID_PHASE_STATUSES = new Set(['success', 'skipped', 'failed']);
-/**
- * Parse phase information from the phases file written by feature-loop.sh.
- *
- * Format: phase_id|status|start_timestamp|end_timestamp
- * The parser handles duplicate phase entries defensively (last status wins,
- * durations aggregate), though feature-loop.sh normally writes one final
- * line per phase.
- *
- * @param phasesFilePath - Path to the phases file
- * @returns Array of phase info objects
- */
-function parsePhases(phasesFilePath) {
-    if (!existsSync(phasesFilePath)) {
-        logger.debug(`Phases file not found: ${phasesFilePath}`);
-        return [];
-    }
-    try {
-        const content = readFileSync(phasesFilePath, 'utf-8').trim();
-        if (!content) {
-            return [];
-        }
-        const lines = content.split('\n');
-        const phaseMap = new Map();
-        for (const line of lines) {
-            const parts = line.split('|');
-            if (parts.length < 4) {
-                logger.warn(`Skipping malformed phase line: ${line}`);
-                continue;
-            }
-            const [id, status, startStr, endStr] = parts;
-            // Validate status
-            if (!VALID_PHASE_STATUSES.has(status)) {
-                logger.warn(`Unknown phase status "${status}" for phase "${id}", treating as failed`);
-            }
-            const validatedStatus = VALID_PHASE_STATUSES.has(status)
-                ? status
-                : 'failed';
-            // Parse timestamps
-            const startTime = parseInt(startStr, 10) || 0;
-            const endTime = parseInt(endStr, 10) || 0;
-            // Calculate duration (end - start) in milliseconds
-            const durationMs = endTime > 0 && startTime > 0 ? (endTime - startTime) * 1000 : undefined;
-            // Get or create phase entry
-            let phase = phaseMap.get(id);
-            if (!phase) {
-                phase = {
-                    id,
-                    label: PHASE_LABELS[id] || id,
-                    status: validatedStatus,
-                    durationMs: 0,
-                };
-                phaseMap.set(id, phase);
-            }
-            // Update status (last status wins)
-            phase.status = validatedStatus;
-            // Aggregate duration
-            if (durationMs !== undefined) {
-                phase.durationMs = (phase.durationMs || 0) + durationMs;
-            }
-        }
-        return Array.from(phaseMap.values());
-    }
-    catch (err) {
-        logger.warn(`Failed to parse phases file: ${err instanceof Error ? err.message : String(err)}`);
-        return [];
-    }
-}
+import { parsePhases } from './loop-status.js';
 /**
  * Read baseline commit hash from the baseline file.
  *
@@ -127,7 +51,7 @@ function readBaselineCommit(baselineFilePath) {
  * which blocks the event loop. Callers should wrap in try-catch to handle
  * failures gracefully.
  */
-export function buildEnhancedRunSummary(basicSummary, projectRoot, feature) {
+export function buildEnhancedRunSummary(basicSummary, projectRoot, feature, baselineOverride) {
     const phasesFilePath = `/tmp/ralph-loop-${feature}.phases`;
     const baselineFilePath = `/tmp/ralph-loop-${feature}.baseline`;
     // Parse phases and set implementation iterations from actual loop count
@@ -153,15 +77,20 @@ export function buildEnhancedRunSummary(basicSummary, projectRoot, feature) {
         completed: basicSummary.tasksDone,
         total: basicSummary.tasksTotal,
     };
-    // Git changes and commits
-    const baselineCommit = readBaselineCommit(baselineFilePath);
+    // Git changes and commits — use override if provided (avoids re-reading a cleaned-up file)
+    const baselineCommit = baselineOverride !== undefined
+        ? (baselineOverride ? baselineOverride.substring(0, 7) : null)
+        : readBaselineCommit(baselineFilePath);
     const currentCommit = getCurrentCommitHash(projectRoot);
     let changes = { available: false };
     let commits = { available: false };
     if (baselineCommit && currentCommit) {
+        // Get commit log between baseline and current
+        const commitLog = getCommitList(projectRoot, baselineCommit, currentCommit);
         commits = {
             fromHash: baselineCommit,
             toHash: currentCommit,
+            commitList: commitLog?.map((c) => ({ hash: c.hash, title: c.title })),
             mergeType: 'none', // TODO: Detect merge type from git history
             available: true,
         };
@@ -202,13 +131,19 @@ export function buildEnhancedRunSummary(basicSummary, projectRoot, feature) {
                     available: true,
                     created: true,
                 };
-                // Try to get linked issue, passing prInfo to avoid redundant gh call
-                const issueInfo = getLinkedIssue(projectRoot, basicSummary.branch, prInfo);
+                // Try to get linked issue, passing prInfo and feature name for fallback detection
+                const issueInfo = getLinkedIssue(projectRoot, basicSummary.branch, prInfo, feature);
                 if (issueInfo) {
+                    // When PR is merged with "Closes #N", GitHub auto-closes the issue.
+                    // The summary may be built before GitHub processes the webhook, so
+                    // infer closure from PR state to avoid showing stale "OPEN" status.
+                    const inferredState = prInfo.state === 'MERGED' && issueInfo.state === 'OPEN'
+                        ? 'CLOSED'
+                        : issueInfo.state;
                     issue = {
                         number: issueInfo.number,
                         url: issueInfo.url,
-                        status: issueInfo.state,
+                        status: inferredState,
                         available: true,
                         linked: true,
                     };
@@ -216,6 +151,30 @@ export function buildEnhancedRunSummary(basicSummary, projectRoot, feature) {
                 else {
                     issue = { available: true, linked: false };
                 }
+                // Enrich commits from PR when squash-merge detected (1 local commit + merged PR)
+                if (prInfo.state === 'MERGED' &&
+                    commits.available &&
+                    commits.commitList &&
+                    commits.commitList.length <= 1) {
+                    try {
+                        const prCommitsOutput = execFileSync('gh', ['pr', 'view', String(prInfo.number), '--json', 'commits'], { cwd: projectRoot, encoding: 'utf-8', timeout: 10_000 }).trim();
+                        const prCommitsData = JSON.parse(prCommitsOutput);
+                        const prCommits = prCommitsData.commits;
+                        if (Array.isArray(prCommits) && prCommits.length > 1) {
+                            commits = {
+                                ...commits,
+                                commitList: prCommits.map((c) => ({
+                                    hash: c.oid?.substring(0, 7) ?? '',
+                                    title: c.messageHeadline ?? '',
+                                })),
+                                mergeType: 'squash',
+                            };
+                        }
+                    }
+                    catch (err) {
+                        logger.debug(`Failed to fetch PR commits: ${err instanceof Error ? err.message : String(err)}`);
+                    }
+                }
             }
             else {
                 pr = { available: true, created: false };

package/dist/tui/utils/clear-screen.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Clear the terminal screen to prevent stale PTY scroll buffer artifacts.
+ *
+ * When Ink re-renders significantly shorter output (e.g. after dismissing a
+ * 25-row IssuePicker), the old content remains in the PTY scroll buffer,
+ * causing visual duplication of the banner and other content. This sends
+ * ANSI escape sequences to clear the entire screen and reset the cursor.
+ *
+ * This is an intentional mix of imperative stdout writes with Ink's
+ * declarative rendering — Ink has no API to flush the PTY scroll buffer.
+ * Call this *before* state updates that shrink the rendered output so
+ * Ink's next render paints onto a clean screen.
+ */
+export declare function clearScreen(stdout: NodeJS.WriteStream): void;

package/dist/tui/utils/clear-screen.js

@@ -0,0 +1,16 @@
+/**
+ * Clear the terminal screen to prevent stale PTY scroll buffer artifacts.
+ *
+ * When Ink re-renders significantly shorter output (e.g. after dismissing a
+ * 25-row IssuePicker), the old content remains in the PTY scroll buffer,
+ * causing visual duplication of the banner and other content. This sends
+ * ANSI escape sequences to clear the entire screen and reset the cursor.
+ *
+ * This is an intentional mix of imperative stdout writes with Ink's
+ * declarative rendering — Ink has no API to flush the PTY scroll buffer.
+ * Call this *before* state updates that shrink the rendered output so
+ * Ink's next render paints onto a clean screen.
+ */
+export function clearScreen(stdout) {
+    stdout.write('\x1b[2J\x1b[H');
+}

package/dist/tui/utils/git-summary.d.ts

@@ -1,6 +1,10 @@
 /**
  * Git utilities for enhanced run summary.
  */
+export interface CommitLogEntry {
+    hash: string;
+    title: string;
+}
 export interface FileDiffStat {
     path: string;
     added: number;
@@ -22,3 +26,12 @@ export declare function getCurrentCommitHash(projectRoot: string): string | null
  * @returns Array of file diff stats, or null if not available
  */
 export declare function getDiffStats(projectRoot: string, fromHash: string, toHash: string): FileDiffStat[] | null;
+/**
+ * Get the list of commits between two refs.
+ *
+ * @param projectRoot - Root directory of the git repository
+ * @param fromHash - Starting commit hash (exclusive)
+ * @param toHash - Ending commit hash (inclusive)
+ * @returns Array of commit entries, or null if not available
+ */
+export declare function getCommitList(projectRoot: string, fromHash: string, toHash: string): CommitLogEntry[] | null;

package/dist/tui/utils/git-summary.js

@@ -61,3 +61,33 @@ export function getDiffStats(projectRoot, fromHash, toHash) {
         return null;
     }
 }
+/**
+ * Get the list of commits between two refs.
+ *
+ * @param projectRoot - Root directory of the git repository
+ * @param fromHash - Starting commit hash (exclusive)
+ * @param toHash - Ending commit hash (inclusive)
+ * @returns Array of commit entries, or null if not available
+ */
+export function getCommitList(projectRoot, fromHash, toHash) {
+    try {
+        const output = execFileSync('git', ['log', '--oneline', `${fromHash}..${toHash}`], {
+            cwd: projectRoot,
+            encoding: 'utf-8',
+            timeout: 10_000,
+        }).trim();
+        if (!output) {
+            return [];
+        }
+        return output.split('\n').map((line) => {
+            const spaceIdx = line.indexOf(' ');
+            if (spaceIdx === -1)
+                return { hash: line, title: '' };
+            return { hash: line.substring(0, spaceIdx), title: line.substring(spaceIdx + 1) };
+        });
+    }
+    catch (err) {
+        logger.warn(`getCommitList failed: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}

package/dist/tui/utils/loop-status.d.ts

@@ -1,6 +1,13 @@
 /**
  * Loop status helpers for the TUI run/monitor screens.
  */
+/**
+ * Find the implementation plan file, checking main project and git worktrees.
+ *
+ * Shared between loop-status.ts and monitor.ts to avoid duplicating the
+ * worktree search logic.
+ */
+export declare function findImplementationPlan(projectRoot: string, specsRelPath: string, feature: string): string | null;
 export interface LoopStatus {
     running: boolean;
     phase: string;
@@ -8,13 +15,38 @@ export interface LoopStatus {
     maxIterations: number;
     tokensInput: number;
     tokensOutput: number;
+    cacheCreate: number;
+    cacheRead: number;
+    tokensUpdatedAt?: number;
 }
 export interface TaskCounts {
     tasksDone: number;
     tasksPending: number;
     e2eDone: number;
     e2ePending: number;
+    planExists: boolean;
+}
+/**
+ * Phase execution status and timing.
+ * Shared between RunScreen and loop-status utilities.
+ */
+export interface PhaseInfo {
+    /** Unique phase identifier (e.g., 'planning', 'implementation') */
+    id: string;
+    /** Human-readable phase label */
+    label: string;
+    /** Phase completion status */
+    status: 'success' | 'skipped' | 'failed' | 'started';
+    /** Duration in milliseconds, if available */
+    durationMs?: number;
+    /** Number of iterations in this phase (e.g., for implementation) */
+    iterations?: number;
 }
+/**
+ * Phase ID to human-readable label mapping.
+ * Matches the phase IDs written by feature-loop.sh.
+ */
+export declare const PHASE_LABELS: Record<string, string>;
 /**
  * Return the conventional log file path for a feature loop.
  */
@@ -27,6 +59,14 @@ export declare function getLoopLogPath(feature: string): string;
  * concurrent loops are rare, but callers should be aware of the limitation.
  */
 export declare function detectPhase(feature: string): string;
+/**
+ * Read the current phase from the `.phases` file written by feature-loop.sh.
+ * Returns the human-readable label of the active phase, or null if unavailable.
+ *
+ * The file format is: phase_id|status|start_timestamp|end_timestamp
+ * A line with status "started" and no end timestamp indicates the active phase.
+ */
+export declare function readCurrentPhase(feature: string): string | null;
 /**
  * Read loop status from temp files written by feature-loop.sh.
  *
@@ -54,3 +94,57 @@ export declare function getGitBranch(projectRoot: string): string;
  * Format number with K/M suffix.
  */
 export declare function formatNumber(num: number): string;
+/**
+ * Format epoch milliseconds as a relative time string (e.g., "30s ago", "2m ago", "1h ago").
+ */
+export declare function formatRelativeTime(timestampMs: number): string;
+/**
+ * A structured activity event derived from loop log or phase changes.
+ */
+export interface ActivityEvent {
+    /** Epoch milliseconds when the event occurred */
+    timestamp: number;
+    /** Human-readable description of the event */
+    message: string;
+    /** Inferred status based on event content */
+    status: 'success' | 'error' | 'in-progress';
+}
+/**
+ * Returns true if a log line should be excluded from the activity feed.
+ */
+export declare function shouldSkipLine(line: string): boolean;
+/**
+ * Parse the loop log file into structured activity events.
+ *
+ * Filters out noise lines (separators, markdown headers, interactive prompts,
+ * config lines) and strips markdown formatting from remaining messages.
+ *
+ * @param logPath - Absolute path to the loop log file.
+ * @param since - Optional epoch ms cutoff; only return events at or after this time.
+ */
+export declare function parseLoopLog(logPath: string, since?: number): ActivityEvent[];
+/**
+ * Detect phase changes by comparing current phases file to a known previous state,
+ * and emit activity events for newly completed or started phases.
+ *
+ * @param feature - Feature name (used to locate the phases file).
+ * @param lastKnownPhases - Phase array from the previous poll cycle.
+ */
+export declare function parsePhaseChanges(feature: string, lastKnownPhases?: PhaseInfo[]): {
+    events: ActivityEvent[];
+    currentPhases?: PhaseInfo[];
+};
+/**
+ * Parse phase information from the phases file written by feature-loop.sh.
+ *
+ * Format: phase_id|status|start_timestamp|end_timestamp
+ * Accepts both 3-field lines (started: phase_id|started|timestamp) and
+ * 4-field lines (completed: phase_id|status|start_ts|end_ts).
+ *
+ * The parser handles duplicate phase entries defensively (last status wins,
+ * durations aggregate), though feature-loop.sh normally writes one final
+ * line per phase.
+ *
+ * Used by build-run-summary.ts for completion summaries.
+ */
+export declare function parsePhases(phasesFilePath: string): PhaseInfo[];