@weldr/runr 0.4.0 → 0.7.2

package/dist/commands/resume.js

@@ -7,6 +7,8 @@ import { runSupervisorLoop } from '../supervisor/runner.js';
 import { prepareForResume } from '../supervisor/state-machine.js';
 import { captureFingerprint, compareFingerprints } from '../env/fingerprint.js';
 import { recreateWorktree } from '../repo/worktree.js';
+import { git } from '../repo/git.js';
+import { getRunsRoot } from '../store/runs-root.js';
 /**
  * Format effective configuration for display at resume.
  */
@@ -42,16 +44,335 @@ function readTaskArtifact(runDir) {
     }
     return fs.readFileSync(taskPath, 'utf-8');
 }
+/**
+ * Extract ignored changes summary from timeline events.
+ */
+function getIgnoredChangesSummary(runId, repo) {
+    const runsRoot = getRunsRoot(repo);
+    const timelinePath = path.join(runsRoot, runId, 'timeline.jsonl');
+    if (!fs.existsSync(timelinePath)) {
+        return null;
+    }
+    try {
+        const lines = fs.readFileSync(timelinePath, 'utf-8').split('\n').filter(l => l.trim());
+        const ignoredEvents = lines
+            .map(line => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter(e => e && e.type === 'ignored_changes');
+        if (ignoredEvents.length === 0) {
+            return null;
+        }
+        const lastEvent = ignoredEvents[ignoredEvents.length - 1];
+        const payload = lastEvent.payload;
+        if (payload.ignored_count === 0) {
+            return null;
+        }
+        return {
+            count: payload.ignored_count,
+            sample: payload.ignored_sample
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Build resume plan by discovering last checkpoint and computing deltas.
+ * @internal - Exported for testing only, not part of public API
+ */
+export async function _buildResumePlan(options) {
+    const { state, repoPath, runStore, config } = options;
+    // Find last checkpoint
+    // PRIORITY 1: Try sidecar metadata first (fast, reliable)
+    // PRIORITY 2: Fallback to git log parsing (legacy support)
+    let checkpointSha = null;
+    let lastCheckpointMilestoneIndex = -1;
+    let checkpointSource = 'none';
+    // Try sidecar metadata first
+    try {
+        const { findLatestCheckpointBySidecar } = await import('../store/checkpoint-metadata.js');
+        const sidecarResult = await findLatestCheckpointBySidecar(repoPath, state.run_id);
+        if (sidecarResult) {
+            checkpointSha = sidecarResult.sha;
+            lastCheckpointMilestoneIndex = sidecarResult.milestoneIndex;
+            checkpointSource = 'sidecar';
+        }
+    }
+    catch (error) {
+        // Sidecar read failed, fall through to git log parsing
+    }
+    // Fallback to git log if sidecar not found
+    if (checkpointSha === null) {
+        // First: try new format with run_id
+        try {
+            const runSpecificPrefix = `chore(runr): checkpoint ${state.run_id} milestone `;
+            const result = await git([
+                'log',
+                '-z',
+                '--grep', runSpecificPrefix,
+                '--fixed-strings',
+                '-n', '1',
+                '--pretty=format:%H%x00%s'
+            ], repoPath);
+            if (result.stdout.trim()) {
+                const parts = result.stdout.trim().split('\0');
+                checkpointSha = parts[0] || null;
+                const commitMessage = parts[1] || '';
+                // Extract milestone index from commit message
+                // Format: "chore(runr): checkpoint <run_id> milestone <N>"
+                const match = commitMessage.match(/milestone (\d+)/);
+                if (match) {
+                    lastCheckpointMilestoneIndex = parseInt(match[1], 10);
+                    checkpointSource = 'git_log_run_specific';
+                }
+            }
+        }
+        catch {
+            // Run-specific checkpoint not found
+        }
+        // Fallback: try legacy format (without run_id)
+        if (checkpointSha === null) {
+            try {
+                const legacyPrefix = 'chore(agent): checkpoint milestone ';
+                const result = await git([
+                    'log',
+                    '-z',
+                    '--grep', legacyPrefix,
+                    '--fixed-strings',
+                    '-n', '1',
+                    '--pretty=format:%H%x00%s'
+                ], repoPath);
+                if (result.stdout.trim()) {
+                    const parts = result.stdout.trim().split('\0');
+                    checkpointSha = parts[0] || null;
+                    const commitMessage = parts[1] || '';
+                    // Extract milestone index from commit message
+                    // Format: "chore(agent): checkpoint milestone <N>"
+                    const match = commitMessage.match(/checkpoint milestone (\d+)/);
+                    if (match) {
+                        lastCheckpointMilestoneIndex = parseInt(match[1], 10);
+                        checkpointSource = 'git_log_legacy';
+                    }
+                }
+            }
+            catch {
+                // No checkpoint found at all, start from beginning
+            }
+        }
+    } // End of git log fallback
+    // Emit event showing which checkpoint source was selected
+    if (checkpointSha) {
+        runStore.appendEvent({
+            type: 'resume_checkpoint_selected',
+            source: 'resume',
+            payload: {
+                source: checkpointSource,
+                sha: checkpointSha,
+                milestone_index: lastCheckpointMilestoneIndex
+            }
+        });
+    }
+    const resumeFromMilestoneIndex = lastCheckpointMilestoneIndex + 1;
+    const remainingMilestones = Math.max(0, state.milestones.length - resumeFromMilestoneIndex);
+    // Compute delta
+    let diffstat;
+    let lockfilesChanged = false;
+    if (checkpointSha) {
+        try {
+            const diffStatResult = await git(['diff', '--stat', `${checkpointSha}..HEAD`], repoPath);
+            diffstat = diffStatResult.stdout.trim() || undefined;
+            const diffNamesResult = await git(['diff', '--name-only', `${checkpointSha}..HEAD`], repoPath);
+            const changedFiles = diffNamesResult.stdout.trim().split('\n').filter(f => f);
+            lockfilesChanged = changedFiles.some(f => f === 'package-lock.json' ||
+                f === 'pnpm-lock.yaml' ||
+                f === 'yarn.lock');
+        }
+        catch {
+            // Diff failed, skip deltas
+        }
+    }
+    const ignoredSummary = getIgnoredChangesSummary(state.run_id, state.repo_path);
+    return {
+        runId: state.run_id,
+        checkpointSha,
+        lastCheckpointMilestoneIndex,
+        resumeFromMilestoneIndex,
+        remainingMilestones,
+        checkpointSource,
+        delta: {
+            diffstat,
+            lockfilesChanged,
+            ignoredNoiseCount: ignoredSummary?.count ?? 0,
+            ignoredNoiseSample: ignoredSummary?.sample ?? []
+        }
+    };
+}
+/**
+ * Assert working tree is clean (REFUSE policy).
+ * If autoStash=true, creates stash and returns info.
+ */
+async function assertCleanWorkingTree(repoPath, options = {}) {
+    try {
+        const statusResult = await git(['status', '--porcelain'], repoPath);
+        const dirtyFiles = statusResult.stdout.trim().split('\n').filter(f => f.trim());
+        if (dirtyFiles.length === 0) {
+            return null; // Clean, no stash needed
+        }
+        // Dirty working tree detected
+        if (options.autoStash) {
+            // Create stash with deterministic message
+            const timestamp = new Date().toISOString();
+            const stashMessage = `runr-autostash-${options.runId || 'unknown'}-${timestamp}`;
+            await git(['stash', 'push', '-u', '-m', stashMessage], repoPath);
+            // Get stash ref (should be stash@{0} after push)
+            const stashRef = 'stash@{0}';
+            console.log(`Auto-stashed ${dirtyFiles.length} uncommitted change${dirtyFiles.length === 1 ? '' : 's'}`);
+            console.log(`  Stash ref: ${stashRef}`);
+            console.log(`  Message: ${stashMessage}`);
+            console.log(`  To restore: git stash pop ${stashRef}`);
+            return {
+                stashRef,
+                stashMessage,
+                fileCount: dirtyFiles.length
+            };
+        }
+        // Not auto-stashing, refuse with error
+        const sampleFiles = dirtyFiles.slice(0, 5).map(f => f.trim());
+        const hasMore = dirtyFiles.length > 5;
+        let errorMessage = `Working tree has ${dirtyFiles.length} uncommitted change${dirtyFiles.length === 1 ? '' : 's'}:\n`;
+        errorMessage += sampleFiles.join('\n');
+        if (hasMore) {
+            errorMessage += `\n... and ${dirtyFiles.length - 5} more`;
+        }
+        errorMessage += '\n\nRun `git stash && runr resume` to stash changes before resuming.';
+        errorMessage += '\nOr use `runr resume --auto-stash` to stash automatically.';
+        throw new Error(errorMessage);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('Working tree has')) {
+            throw error;
+        }
+        // Git command failed, assume clean
+        return null;
+    }
+}
+/**
+ * Get working tree status (non-throwing version for plan mode).
+ */
+async function getWorkingTreeStatus(repoPath) {
+    try {
+        const statusResult = await git(['status', '--porcelain'], repoPath);
+        const dirtyFiles = statusResult.stdout.trim().split('\n').filter(f => f.trim());
+        return {
+            clean: dirtyFiles.length === 0,
+            dirtyPaths: dirtyFiles.slice(0, 10), // Sample up to 10
+            dirtyCount: dirtyFiles.length
+        };
+    }
+    catch {
+        // Git command failed, assume clean
+        return {
+            clean: true,
+            dirtyPaths: [],
+            dirtyCount: 0
+        };
+    }
+}
+/**
+ * Format resume plan as JSON.
+ */
+async function formatResumePlanJson(plan, state, effectiveRepoPath, checkpointSource) {
+    const repoStatus = await getWorkingTreeStatus(effectiveRepoPath);
+    const warnings = [];
+    if (!plan.delta.diffstat && plan.checkpointSha) {
+        warnings.push('Could not compute diffstat');
+    }
+    return {
+        schema_version: 1,
+        run_id: plan.runId,
+        repo_path: state.repo_path,
+        effective_repo_path: effectiveRepoPath,
+        checkpoint: {
+            sha: plan.checkpointSha,
+            milestone_index: plan.lastCheckpointMilestoneIndex,
+            source: checkpointSource
+        },
+        resume: {
+            from_milestone_index: plan.resumeFromMilestoneIndex,
+            phase: 'IMPLEMENT', // Resume always goes to IMPLEMENT
+            remaining_milestones: plan.remainingMilestones
+        },
+        repo_state: {
+            working_tree_clean: repoStatus.clean,
+            dirty_paths_sample: repoStatus.dirtyPaths,
+            dirty_count: repoStatus.dirtyCount
+        },
+        delta: {
+            diffstat: plan.delta.diffstat,
+            lockfiles_changed: plan.delta.lockfilesChanged,
+            ignored_noise_count: plan.delta.ignoredNoiseCount,
+            ignored_noise_sample: plan.delta.ignoredNoiseSample
+        },
+        warnings
+    };
+}
+/**
+ * Format resume plan for display.
+ */
+function formatResumePlan(plan) {
+    const lines = [];
+    lines.push(`Resume plan:`);
+    lines.push(`  Checkpoint: ${plan.checkpointSha?.slice(0, 8) ?? 'none'} (milestone ${plan.lastCheckpointMilestoneIndex})`);
+    lines.push(`  Resume from: milestone ${plan.resumeFromMilestoneIndex}`);
+    lines.push(`  Remaining: ${plan.remainingMilestones} milestone${plan.remainingMilestones === 1 ? '' : 's'}`);
+    if (plan.delta.lockfilesChanged) {
+        lines.push(`  Delta: lockfiles changed`);
+    }
+    if (plan.delta.ignoredNoiseCount > 0) {
+        const sample = plan.delta.ignoredNoiseSample.slice(0, 3).join(', ');
+        lines.push(`  Ignored: ${plan.delta.ignoredNoiseCount} files (${sample}${plan.delta.ignoredNoiseSample.length > 3 ? ', ...' : ''})`);
+    }
+    return lines.join('\n');
+}
 export async function resumeCommand(options) {
-    // Log effective configuration for transparency
-    console.log(formatResumeConfig(options));
+    // Early flag validation
+    // --json implies --plan
+    if (options.json) {
+        options.plan = true;
+    }
+    // --auto-stash is incompatible with --plan (plan is read-only)
+    if (options.autoStash && options.plan) {
+        console.error('Error: --auto-stash cannot be used with --plan (plan mode is read-only)');
+        process.exitCode = 1;
+        return;
+    }
+    // Log effective configuration for transparency (skip in JSON mode)
+    if (!options.json) {
+        console.log(formatResumeConfig(options));
+    }
     const runStore = RunStore.init(options.runId, options.repo);
     let state;
     try {
         state = runStore.readState();
     }
     catch {
-        throw new Error(`Run state not found for ${options.runId}`);
+        if (options.json) {
+            console.error(JSON.stringify({
+                error: 'run_not_found',
+                message: `Run state not found for ${options.runId}`
+            }, null, 2));
+        }
+        else {
+            throw new Error(`Run state not found for ${options.runId}`);
+        }
+        process.exitCode = 1;
+        return;
     }
     const { config: configSnapshot, worktree: worktreeInfo } = readConfigSnapshot(runStore.path);
     const config = configSnapshot ??
@@ -121,9 +442,106 @@ export async function resumeCommand(options) {
             console.warn('\nWARNING: Forcing resume despite environment mismatch (--force)\n');
         }
     }
+    // INSERTION 1: Dirty tree check (REFUSE policy)
+    // Skip in plan mode - plan is read-only
+    let stashInfo = null;
+    if (!options.plan) {
+        stashInfo = await assertCleanWorkingTree(effectiveRepoPath, {
+            autoStash: options.autoStash,
+            runId: options.runId
+        });
+    }
+    // INSERTION 2: Build and print resume plan
+    const plan = await _buildResumePlan({
+        state,
+        repoPath: effectiveRepoPath,
+        runStore,
+        config
+    });
+    // If --plan mode, output plan and exit
+    if (options.plan) {
+        if (options.json) {
+            const planJson = await formatResumePlanJson(plan, state, effectiveRepoPath, plan.checkpointSource);
+            console.log(JSON.stringify(planJson, null, 2));
+        }
+        else {
+            console.log(formatResumePlan(plan));
+        }
+        return;
+    }
+    // Not in plan mode - print plan in text format
+    console.log(formatResumePlan(plan));
     // Use shared helper to prepare state for resume
     const updated = prepareForResume(state, { resumeToken: options.runId });
+    // Override milestone_index and phase from plan (fixes FINALIZE bug)
+    const previousMilestoneIndex = state.milestone_index;
+    updated.milestone_index = plan.resumeFromMilestoneIndex;
+    updated.phase = plan.resumeFromMilestoneIndex >= state.milestones.length ? 'FINALIZE' : 'IMPLEMENT';
+    // Detect milestone index drift
+    if (previousMilestoneIndex !== plan.resumeFromMilestoneIndex) {
+        // Determine drift reason
+        let reason;
+        if (previousMilestoneIndex <= plan.lastCheckpointMilestoneIndex) {
+            reason = 'already_checkpointed';
+        }
+        else if (previousMilestoneIndex < plan.resumeFromMilestoneIndex) {
+            reason = 'state_behind_checkpoint';
+        }
+        else {
+            reason = 'state_ahead_of_checkpoint';
+        }
+        // Emit correction event
+        runStore.appendEvent({
+            type: 'milestone_index_corrected',
+            source: 'resume',
+            payload: {
+                previous: previousMilestoneIndex,
+                corrected_to: plan.resumeFromMilestoneIndex,
+                last_checkpoint_milestone_index: plan.lastCheckpointMilestoneIndex,
+                checkpoint_sha: plan.checkpointSha ?? null,
+                checkpoint_source: plan.checkpointSource,
+                reason
+            }
+        });
+        // User-facing message
+        if (reason === 'already_checkpointed') {
+            console.log(`✓ Checkpoint found at milestone ${plan.lastCheckpointMilestoneIndex}. Resuming from milestone ${plan.resumeFromMilestoneIndex}.`);
+        }
+        else {
+            console.warn('Resume warning:');
+            console.warn(`  State milestone_index=${previousMilestoneIndex} but last checkpoint is milestone ${plan.lastCheckpointMilestoneIndex}.`);
+            console.warn(`  Resuming from milestone ${plan.resumeFromMilestoneIndex} (checkpoint is ground truth).`);
+        }
+    }
     runStore.writeState(updated);
+    // INSERTION 3: Resume provenance event
+    runStore.appendEvent({
+        type: 'resume',
+        source: 'cli',
+        payload: {
+            checkpoint_sha: plan.checkpointSha,
+            last_checkpoint_milestone_index: plan.lastCheckpointMilestoneIndex,
+            resume_from_milestone_index: plan.resumeFromMilestoneIndex,
+            remaining_milestones: plan.remainingMilestones,
+            delta: {
+                lockfiles_changed: plan.delta.lockfilesChanged,
+                ignored_noise_count: plan.delta.ignoredNoiseCount,
+                ignored_noise_sample: plan.delta.ignoredNoiseSample
+            }
+        }
+    });
+    // Record auto-stash if it happened
+    if (stashInfo) {
+        runStore.appendEvent({
+            type: 'auto_stash_created',
+            source: 'cli',
+            payload: {
+                stash_ref: stashInfo.stashRef,
+                stash_message: stashInfo.stashMessage,
+                file_count: stashInfo.fileCount
+            }
+        });
+    }
     runStore.appendEvent({
         type: 'run_resumed',
         source: 'cli',

package/dist/commands/run.js

@@ -13,6 +13,10 @@ import { runDoctorChecks } from './doctor.js';
 import { captureFingerprint } from '../env/fingerprint.js';
 import { loadTaskMetadata } from '../tasks/task-metadata.js';
 import { getActiveRuns, checkAllowlistOverlaps, formatAllowlistWarning } from '../supervisor/collision.js';
+import { updateActiveState, clearActiveState } from './hooks.js';
+import { printStopFooter } from '../output/stop-footer.js';
+import { computeBrain } from '../ux/brain.js';
+import { resolveRepoState } from '../ux/state.js';
 function makeRunId() {
     const now = new Date();
     const parts = [
@@ -194,6 +198,15 @@ export async function runCommand(options) {
     const taskText = taskMetadata.body;
     const ownsRaw = taskMetadata.owns_raw;
     const ownsNormalized = taskMetadata.owns_normalized;
+    // Merge task-local allowlist_add with config allowlist (additive only)
+    const effectiveAllowlist = [
+        ...config.scope.allowlist,
+        ...taskMetadata.allowlist_add
+    ];
+    // Log if task has local scope additions
+    if (taskMetadata.allowlist_add.length > 0 && !options.json) {
+        console.log(`Task-local scope additions: ${taskMetadata.allowlist_add.join(', ')}`);
+    }
     // Auto-inject git excludes for agent artifacts BEFORE any git status checks.
     // This prevents .agent/ and .agent-worktrees/ from appearing as dirty on fresh repos.
     ensureRepoInfoExclude(repoPath, [
@@ -233,7 +246,7 @@ export async function runCommand(options) {
     if (!options.forceParallel) {
         const activeRuns = getActiveRuns(repoPath);
         if (activeRuns.length > 0) {
-            const overlaps = checkAllowlistOverlaps(config.scope.allowlist, activeRuns);
+            const overlaps = checkAllowlistOverlaps(effectiveAllowlist, activeRuns);
             if (overlaps.length > 0) {
                 console.warn('');
                 console.warn(formatAllowlistWarning(overlaps));
@@ -244,7 +257,7 @@ export async function runCommand(options) {
     let freshTargetRoot = null;
     if (options.freshTarget) {
         try {
-            freshTargetRoot = await freshenTargetRoot(repoPath, config.scope.allowlist);
+            freshTargetRoot = await freshenTargetRoot(repoPath, effectiveAllowlist);
             console.log(`Fresh target: cleaned ${freshTargetRoot}`);
         }
         catch (error) {
@@ -410,7 +423,7 @@ export async function runCommand(options) {
                     raw: ownsRaw,
                     normalized: ownsNormalized
                 },
-                allowlist: config.scope.allowlist,
+                allowlist: effectiveAllowlist,
                 denylist: config.scope.denylist
             });
             state.current_branch = preflight.repo_context.current_branch;
@@ -468,7 +481,7 @@ export async function runCommand(options) {
             raw: ownsRaw,
             normalized: ownsNormalized
         },
-        allowlist: config.scope.allowlist,
+        allowlist: effectiveAllowlist,
         denylist: config.scope.denylist
     });
     state.current_branch = preflight.repo_context.current_branch;
@@ -518,6 +531,11 @@ export async function runCommand(options) {
     }
     if (runStore) {
         runStore.writeSummary('# Summary\n\nRun initialized. Supervisor loop not yet executed.');
+        // Update sentinel file to indicate run is active
+        updateActiveState(options.repo, {
+            run_id: runId,
+            status: 'RUNNING'
+        });
         await runSupervisorLoop({
             runStore,
             repoPath: effectiveRepoPath,
@@ -531,6 +549,47 @@ export async function runCommand(options) {
             forceParallel: options.forceParallel,
             ownedPaths: ownsNormalized
         });
+        // Update sentinel file based on final run state
+        const finalState = runStore.readState();
+        if (finalState.stop_reason === 'complete') {
+            // Run finished successfully
+            clearActiveState(options.repo);
+        }
+        else if (finalState.stop_reason) {
+            // Run stopped with an error
+            updateActiveState(options.repo, {
+                run_id: runId,
+                status: 'STOPPED',
+                stop_reason: finalState.stop_reason
+            });
+            // Print stop footer with next steps (unless JSON mode)
+            if (!options.json) {
+                // Extract review loop data from timeline if available
+                let reviewLoopData;
+                if (finalState.stop_reason === 'review_loop_detected') {
+                    // Find the review_loop_detected event in the timeline
+                    const events = runStore.readTimeline();
+                    const reviewLoopEvent = events.find((e) => e.type === 'review_loop_detected');
+                    if (reviewLoopEvent?.payload) {
+                        const payload = reviewLoopEvent.payload;
+                        reviewLoopData = {
+                            reviewRound: payload.review_rounds,
+                            maxReviewRounds: payload.max_review_rounds,
+                            reviewerRequests: payload.reviewer_requests,
+                            commandsToSatisfy: payload.commands_to_satisfy
+                        };
+                    }
+                }
+                // Compute brain actions for consistent UX across front door, continue, and stop-footer
+                const repoState = await resolveRepoState(options.repo);
+                const brainOutput = computeBrain({
+                    state: repoState,
+                    stopDiagnosis: null, // Diagnosis not available yet at stop time
+                    stopExplainer: null,
+                });
+                printStopFooter(finalState, reviewLoopData, brainOutput.actions);
+            }
+        }
     }
     if (!options.json) {
         console.log(summaryLine);

package/dist/commands/status.js

@@ -3,6 +3,46 @@ import path from 'node:path';
 import { RunStore } from '../store/run-store.js';
 import { getRunsRoot } from '../store/runs-root.js';
 import { getActiveRuns, getCollisionRisk } from '../supervisor/collision.js';
+/**
+ * Extract ignored changes summary from timeline events.
+ * Returns null if no ignored changes found.
+ */
+function getIgnoredChangesSummary(runId, repo) {
+    const runsRoot = getRunsRoot(repo);
+    const timelinePath = path.join(runsRoot, runId, 'timeline.jsonl');
+    if (!fs.existsSync(timelinePath)) {
+        return null;
+    }
+    try {
+        const lines = fs.readFileSync(timelinePath, 'utf-8').split('\n').filter(l => l.trim());
+        const ignoredEvents = lines
+            .map(line => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter(e => e && e.type === 'ignored_changes');
+        if (ignoredEvents.length === 0) {
+            return null;
+        }
+        // Take the last ignored_changes event (most recent)
+        const lastEvent = ignoredEvents[ignoredEvents.length - 1];
+        const payload = lastEvent.payload;
+        if (payload.ignored_count === 0) {
+            return null;
+        }
+        return {
+            count: payload.ignored_count,
+            sample: payload.ignored_sample
+        };
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Get status of a single run.
  */
@@ -10,6 +50,13 @@ export async function statusCommand(options) {
     const runStore = RunStore.init(options.runId, options.repo);
     const state = runStore.readState();
     console.log(JSON.stringify(state, null, 2));
+    // Show ignored tool noise summary for trust/forensics
+    const ignoredSummary = getIgnoredChangesSummary(options.runId, options.repo);
+    if (ignoredSummary) {
+        const { count, sample } = ignoredSummary;
+        const samplePaths = sample.slice(0, 3).join(', ');
+        console.log(`\nIgnored tool noise: ${count} file${count === 1 ? '' : 's'} (sample: ${samplePaths}${sample.length > 3 ? ', ...' : ''})`);
+    }
 }
 /**
  * Get status of all runs in the repo.