@weldr/runr 0.4.0 → 0.7.2

package/dist/journal/builder.js

@@ -337,7 +337,8 @@ async function extractChanges(runDir, base_sha, head_sha, warnings) {
             insertions: null,
             deletions: null,
             top_files: null,
-            diff_stat: null
+            diff_stat: null,
+            ignored_changes: null
         };
     }
     try {
@@ -373,6 +374,8 @@ async function extractChanges(runDir, base_sha, head_sha, warnings) {
             cwd: repoPath,
             encoding: 'utf-8'
         });
+        // Extract ignored changes from timeline
+        const ignoredChanges = await extractIgnoredChanges(runDir, warnings);
         return {
             base_sha,
             head_sha,
@@ -380,7 +383,8 @@ async function extractChanges(runDir, base_sha, head_sha, warnings) {
             insertions: totalInsertions,
             deletions: totalDeletions,
             top_files: topFiles.length > 0 ? topFiles : null,
-            diff_stat: diffStat.trim()
+            diff_stat: diffStat.trim(),
+            ignored_changes: ignoredChanges
         };
     }
     catch (err) {
@@ -392,10 +396,39 @@ async function extractChanges(runDir, base_sha, head_sha, warnings) {
             insertions: null,
             deletions: null,
             top_files: null,
-            diff_stat: null
+            diff_stat: null,
+            ignored_changes: null
         };
     }
 }
+/**
+ * Extract ignored changes summary from timeline events
+ */
+async function extractIgnoredChanges(runDir, warnings) {
+    try {
+        const timelinePath = path.join(runDir, 'timeline.jsonl');
+        if (!fs.existsSync(timelinePath)) {
+            return null;
+        }
+        const events = await readTimelineEvents(timelinePath);
+        const ignoredEvents = events.filter(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;
+        return {
+            count: payload.ignored_count,
+            sample: payload.ignored_sample,
+            ignore_check_status: payload.ignore_check_status
+        };
+    }
+    catch (err) {
+        warnings.push(`Failed to extract ignored changes: ${err.message}`);
+        return null;
+    }
+}
 /**
  * Extract next action from stop.json or derive
  */

package/dist/journal/renderer.js

@@ -163,6 +163,25 @@ function renderChanges(journal) {
         lines.push(journal.changes.diff_stat);
         lines.push('```');
     }
+    // Render ignored changes (tool pollution)
+    if (journal.changes.ignored_changes) {
+        const { count, sample, ignore_check_status } = journal.changes.ignored_changes;
+        if (ignore_check_status === 'failed') {
+            lines.push('\n> **Warning:** Git ignore-check failed; guard ran in strict mode.');
+        }
+        if (count > 0) {
+            lines.push(`\n**Ignored Tool Noise:** ${count} file${count === 1 ? '' : 's'} (filtered from guard checks)`);
+            if (sample.length > 0) {
+                lines.push('\nSample (first 20):');
+                for (const file of sample.slice(0, 20)) {
+                    lines.push(`- \`${file}\``);
+                }
+                if (count > sample.length) {
+                    lines.push(`\n_...and ${count - sample.length} more_`);
+                }
+            }
+        }
+    }
     return lines.join('\n');
 }
 function renderNextAction(nextAction) {

package/dist/orchestrator/artifacts.js

@@ -353,10 +353,12 @@ export function generateOrchestrationMarkdown(state, summary) {
  * Order is critical:
  * 1. summary.json
  * 2. orchestration.md
- * 3. complete.json OR stop.json (LAST - signals terminal)
+ * 3. receipt.json and receipt.md
+ * 4. complete.json OR stop.json (LAST - signals terminal)
  */
 export function writeTerminalArtifacts(state, repoPath) {
     const handoffsDir = getHandoffsDir(repoPath, state.orchestrator_id);
+    const orchDir = getOrchestrationDir(repoPath, state.orchestrator_id);
     fs.mkdirSync(handoffsDir, { recursive: true });
     const isComplete = state.status === 'complete';
     // 1. Write summary.json
@@ -365,7 +367,20 @@ export function writeTerminalArtifacts(state, repoPath) {
     // 2. Write orchestration.md
     const markdown = generateOrchestrationMarkdown(state, summary);
     fs.writeFileSync(path.join(handoffsDir, 'orchestration.md'), markdown);
-    // 3. Write complete.json OR stop.json (LAST)
+    // 3. Write receipt artifacts (manager dashboard)
+    try {
+        // Dynamic import to avoid circular dependency
+        import('./receipt.js').then(({ buildReceipt, writeReceipt }) => {
+            const receipt = buildReceipt(state, repoPath);
+            writeReceipt(receipt, repoPath);
+        }).catch(() => {
+            // Ignore receipt generation errors - not critical
+        });
+    }
+    catch {
+        // Ignore receipt generation errors - not critical
+    }
+    // 4. Write complete.json OR stop.json (LAST)
     if (isComplete) {
         const completeArtifact = buildWaitResult(state, repoPath);
         fs.writeFileSync(path.join(handoffsDir, 'complete.json'), JSON.stringify(completeArtifact, null, 2));

package/dist/orchestrator/receipt.js

@@ -0,0 +1,304 @@
+/**
+ * Orchestration Receipt Generator.
+ *
+ * Produces "manager dashboard" artifacts that summarize an orchestration:
+ * - receipt.json: Machine-readable summary with task outcomes, interventions, and issues
+ * - receipt.md: Human-readable markdown summary
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { getOrchestrationDir, findOrchestrationDir } from './artifacts.js';
+import { loadOrchestratorState, findLatestOrchestrationId } from './state-machine.js';
+import { getRunsRoot } from '../store/runs-root.js';
+export const RECEIPT_SCHEMA_VERSION = '1';
+/**
+ * Suggested fixes for common stop reasons.
+ */
+const STOP_REASON_FIXES = {
+    'review_loop_detected': 'Check reviewer expectations match verifier output',
+    'max_ticks_reached': 'Consider increasing --max-ticks or breaking into smaller tasks',
+    'time_budget_exceeded': 'Consider increasing --time or simplifying the task',
+    'verification_failed': 'Review verification commands and fix failing tests',
+    'user_stop': 'Task was stopped by user request',
+    'collision_detected': 'Ensure tasks have non-overlapping ownership declarations'
+};
+/**
+ * Get suggested fix for a stop reason.
+ */
+function getSuggestedFix(reason) {
+    return STOP_REASON_FIXES[reason] ?? 'Review run logs for details';
+}
+/**
+ * Find intervention receipt for a run.
+ */
+function findIntervention(repoPath, runId) {
+    const runsRoot = getRunsRoot(repoPath);
+    const runDir = path.join(runsRoot, runId);
+    const interventionsDir = path.join(runDir, 'interventions');
+    if (!fs.existsSync(interventionsDir)) {
+        return undefined;
+    }
+    // Find any intervention receipt
+    try {
+        const entries = fs.readdirSync(interventionsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const receiptPath = path.join(interventionsDir, entry.name, 'intervention-receipt.json');
+                if (fs.existsSync(receiptPath)) {
+                    try {
+                        const receipt = JSON.parse(fs.readFileSync(receiptPath, 'utf-8'));
+                        return {
+                            receipt_path: path.relative(repoPath, receiptPath),
+                            reason: receipt.reason ?? 'unknown'
+                        };
+                    }
+                    catch {
+                        return {
+                            receipt_path: path.relative(repoPath, receiptPath),
+                            reason: 'unknown'
+                        };
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return undefined;
+}
+/**
+ * Read run state to get checkpoint SHA and milestones.
+ */
+function getRunDetails(repoPath, runId) {
+    const runsRoot = getRunsRoot(repoPath);
+    const stateFile = path.join(runsRoot, runId, 'state.json');
+    if (!fs.existsSync(stateFile)) {
+        return { milestones: 0 };
+    }
+    try {
+        const state = JSON.parse(fs.readFileSync(stateFile, 'utf-8'));
+        return {
+            checkpointSha: state.checkpoint_commit_sha,
+            milestones: state.completed_milestones ?? 0
+        };
+    }
+    catch {
+        return { milestones: 0 };
+    }
+}
+/**
+ * Build receipt task entry from track step.
+ */
+function buildReceiptTask(repoPath, step, track) {
+    const runId = step.run_id;
+    const result = step.result;
+    // Determine status
+    let status = 'pending';
+    if (result) {
+        status = result.status === 'complete' ? 'finished' : 'stopped';
+    }
+    // Get run details
+    const details = runId ? getRunDetails(repoPath, runId) : { milestones: 0 };
+    // Find intervention
+    const intervention = runId ? findIntervention(repoPath, runId) : undefined;
+    return {
+        task_path: step.task_path,
+        run_id: runId,
+        status,
+        stop_reason: result?.stop_reason,
+        milestones_completed: details.milestones,
+        checkpoint_sha: details.checkpointSha,
+        duration_ms: result?.elapsed_ms ?? 0,
+        intervention
+    };
+}
+/**
+ * Aggregate stop reasons across all tasks.
+ */
+function aggregateStopReasons(tasks) {
+    const counts = new Map();
+    for (const task of tasks) {
+        if (task.stop_reason) {
+            counts.set(task.stop_reason, (counts.get(task.stop_reason) ?? 0) + 1);
+        }
+    }
+    // Sort by count descending
+    return [...counts.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .map(([reason, count]) => ({
+        reason,
+        count,
+        suggested_fix: getSuggestedFix(reason)
+    }));
+}
+/**
+ * Build receipt from orchestrator state.
+ */
+export function buildReceipt(state, repoPath) {
+    const startTime = new Date(state.started_at).getTime();
+    const endTime = state.ended_at ? new Date(state.ended_at).getTime() : Date.now();
+    // Build task list
+    const tasks = [];
+    for (const track of state.tracks) {
+        for (const step of track.steps) {
+            tasks.push(buildReceiptTask(repoPath, step, track));
+        }
+    }
+    // Count outcomes
+    const tasksCompleted = tasks.filter(t => t.status === 'finished').length;
+    const tasksStopped = tasks.filter(t => t.status === 'stopped').length;
+    const tasksPending = tasks.filter(t => t.status === 'pending').length;
+    const interventionsCount = tasks.filter(t => t.intervention).length;
+    const totalCheckpoints = tasks.filter(t => t.checkpoint_sha).length;
+    // Aggregate stop reasons
+    const topStopReasons = aggregateStopReasons(tasks);
+    return {
+        schema_version: RECEIPT_SCHEMA_VERSION,
+        orchestration_id: state.orchestrator_id,
+        started_at: state.started_at,
+        completed_at: state.ended_at,
+        duration_ms: endTime - startTime,
+        summary: {
+            tasks_total: tasks.length,
+            tasks_completed: tasksCompleted,
+            tasks_stopped: tasksStopped,
+            tasks_pending: tasksPending,
+            interventions_count: interventionsCount,
+            total_checkpoints: totalCheckpoints
+        },
+        tasks,
+        top_stop_reasons: topStopReasons
+    };
+}
+/**
+ * Format duration in human-readable form.
+ */
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) {
+        return `${hours}h ${minutes % 60}m`;
+    }
+    if (minutes > 0) {
+        return `${minutes}m ${seconds % 60}s`;
+    }
+    return `${seconds}s`;
+}
+/**
+ * Generate markdown receipt from JSON receipt.
+ */
+export function generateReceiptMarkdown(receipt) {
+    const lines = [];
+    // Header
+    lines.push(`# Orchestration Receipt: ${receipt.orchestration_id}`);
+    lines.push('');
+    // Summary table
+    lines.push('## Summary');
+    lines.push('');
+    lines.push('| Metric | Value |');
+    lines.push('|--------|-------|');
+    lines.push(`| Duration | ${formatDuration(receipt.duration_ms)} |`);
+    lines.push(`| Tasks | ${receipt.summary.tasks_completed}/${receipt.summary.tasks_total} completed |`);
+    lines.push(`| Checkpoints | ${receipt.summary.total_checkpoints} |`);
+    lines.push(`| Interventions | ${receipt.summary.interventions_count} |`);
+    lines.push('');
+    // Tasks section
+    lines.push('## Tasks');
+    lines.push('');
+    for (const task of receipt.tasks) {
+        const statusIcon = task.status === 'finished' ? '✓' : task.status === 'stopped' ? '⚠' : '○';
+        const taskName = path.basename(task.task_path);
+        lines.push(`### ${statusIcon} ${taskName}`);
+        if (task.run_id) {
+            lines.push(`- Run: ${task.run_id}`);
+        }
+        lines.push(`- Status: ${task.status}${task.stop_reason ? ` (${task.stop_reason})` : ''}`);
+        if (task.checkpoint_sha) {
+            lines.push(`- Checkpoint: ${task.checkpoint_sha.slice(0, 7)}`);
+        }
+        if (task.intervention) {
+            lines.push(`- Intervention: ${task.intervention.reason}`);
+        }
+        lines.push('');
+    }
+    // Top issues
+    if (receipt.top_stop_reasons.length > 0) {
+        lines.push('## Top Issues');
+        lines.push('');
+        for (let i = 0; i < receipt.top_stop_reasons.length; i++) {
+            const entry = receipt.top_stop_reasons[i];
+            lines.push(`${i + 1}. **${entry.reason}** (${entry.count} occurrence${entry.count > 1 ? 's' : ''})`);
+            lines.push(`   - Suggested: ${entry.suggested_fix}`);
+        }
+        lines.push('');
+    }
+    // Next steps
+    if (receipt.summary.tasks_stopped > 0) {
+        lines.push('## Next Steps');
+        lines.push('');
+        const stoppedTasks = receipt.tasks.filter(t => t.status === 'stopped');
+        for (const task of stoppedTasks) {
+            lines.push(`- Review stopped task: ${path.basename(task.task_path)}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Write receipt artifacts to orchestration directory.
+ */
+export function writeReceipt(receipt, repoPath) {
+    const orchDir = getOrchestrationDir(repoPath, receipt.orchestration_id);
+    fs.mkdirSync(orchDir, { recursive: true });
+    const jsonPath = path.join(orchDir, 'receipt.json');
+    const mdPath = path.join(orchDir, 'receipt.md');
+    fs.writeFileSync(jsonPath, JSON.stringify(receipt, null, 2));
+    fs.writeFileSync(mdPath, generateReceiptMarkdown(receipt));
+    return { json: jsonPath, md: mdPath };
+}
+/**
+ * Load existing receipt if available.
+ */
+export function loadReceipt(repoPath, orchestratorId) {
+    const orchDir = findOrchestrationDir(repoPath, orchestratorId);
+    if (!orchDir) {
+        return null;
+    }
+    const receiptPath = path.join(orchDir, 'receipt.json');
+    if (!fs.existsSync(receiptPath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(receiptPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Generate or load receipt for an orchestration.
+ */
+export function getReceipt(repoPath, orchestratorId) {
+    // Resolve "latest"
+    let resolvedId = orchestratorId;
+    if (orchestratorId === 'latest') {
+        const latest = findLatestOrchestrationId(repoPath);
+        if (!latest) {
+            return null;
+        }
+        resolvedId = latest;
+    }
+    // Try to load existing receipt
+    const existing = loadReceipt(repoPath, resolvedId);
+    if (existing) {
+        return existing;
+    }
+    // Generate from state
+    const state = loadOrchestratorState(resolvedId, repoPath);
+    if (!state) {
+        return null;
+    }
+    return buildReceipt(state, repoPath);
+}

package/dist/output/stop-footer.js

@@ -0,0 +1,185 @@
+/**
+ * Stop Footer - Consistent "Next Steps" block for stopped runs.
+ *
+ * Shows exactly 3 actions derived from the brain module for consistency
+ * across front door, continue command, and stop footer.
+ *
+ * For review_loop_detected, also shows:
+ * - Reviewer requested items
+ * - Commands to satisfy
+ * - Suggested intervention command
+ */
+const SEPARATOR = '─'.repeat(50);
+/**
+ * Get context line based on stop reason.
+ */
+function getContextLine(ctx) {
+    switch (ctx.stopReason) {
+        case 'review_loop_detected':
+            if (ctx.lastError) {
+                // Extract first 2 items from error message if it contains a list
+                const match = ctx.lastError.match(/(?:Unmet|Failed|Missing):\s*(.+)/i);
+                if (match) {
+                    const items = match[1].split(/[,;]/).slice(0, 2).map(s => s.trim());
+                    return `Unmet: ${items.join(', ')}`;
+                }
+                return `Unmet: ${ctx.lastError.slice(0, 60)}...`;
+            }
+            return 'Unmet: review requirements not satisfied';
+        case 'verification_failed':
+            if (ctx.lastError) {
+                const cmdMatch = ctx.lastError.match(/command.*failed|failed.*command/i);
+                if (cmdMatch) {
+                    return `Failed: ${ctx.lastError.slice(0, 60)}`;
+                }
+                return `Failed: verification check`;
+            }
+            return 'Failed: verification check';
+        case 'scope_violation':
+            if (ctx.lastError) {
+                // Extract file paths from error
+                const files = ctx.lastError.match(/[\w./\-_]+\.\w+/g);
+                if (files && files.length > 0) {
+                    return `Files: ${files.slice(0, 2).join(', ')}`;
+                }
+            }
+            return 'Files: scope boundary exceeded';
+        case 'stalled_timeout':
+        case 'worker_call_timeout':
+            return `Stalled at: ${ctx.phase || 'unknown phase'}`;
+        case 'guard_fail':
+        case 'preflight_failed':
+            if (ctx.lastError) {
+                const guardMatch = ctx.lastError.match(/guard.*failed|failed.*guard/i);
+                if (guardMatch) {
+                    return `Guard: ${ctx.lastError.slice(0, 50)}`;
+                }
+            }
+            return 'Guard: preflight check failed';
+        default:
+            // No context line for other reasons
+            return null;
+    }
+}
+/**
+ * Build next steps commands.
+ */
+export function buildNextSteps(runId, stopReason) {
+    return {
+        resume: `runr resume ${runId}`,
+        intervene: `runr intervene ${runId} --reason ${stopReason || 'manual'} --note "..."`,
+        audit: `runr runs audit --run ${runId}`
+    };
+}
+/**
+ * Format stop footer for console output.
+ * If brainActions are provided, uses them for consistent UX across all entry points.
+ * Otherwise falls back to default 3 commands (resume, intervene, audit).
+ */
+export function formatStopFooter(ctx, brainActions) {
+    const lines = [];
+    lines.push(SEPARATOR);
+    // Header with optional round info
+    if (ctx.stopReason === 'review_loop_detected' && ctx.reviewRound && ctx.maxReviewRounds) {
+        lines.push(`STOPPED: ${ctx.stopReason} (round ${ctx.reviewRound}/${ctx.maxReviewRounds})`);
+    }
+    else {
+        lines.push(`STOPPED: ${ctx.stopReason}`);
+    }
+    lines.push('');
+    // Last checkpoint line
+    if (ctx.checkpointSha) {
+        lines.push(`Last checkpoint: ${ctx.checkpointSha.slice(0, 7)} (milestone ${ctx.milestoneIndex + 1}/${ctx.milestonesTotal})`);
+    }
+    else {
+        lines.push(`No checkpoint (milestone ${ctx.milestoneIndex + 1}/${ctx.milestonesTotal})`);
+    }
+    // Enhanced output for review_loop_detected
+    if (ctx.stopReason === 'review_loop_detected') {
+        // Show reviewer requests if available
+        if (ctx.reviewerRequests && ctx.reviewerRequests.length > 0) {
+            lines.push('');
+            lines.push('Reviewer requested:');
+            ctx.reviewerRequests.slice(0, 3).forEach((req, i) => {
+                lines.push(`  ${i + 1}. ${req}`);
+            });
+            if (ctx.reviewerRequests.length > 3) {
+                lines.push(`  ... and ${ctx.reviewerRequests.length - 3} more`);
+            }
+        }
+        // Show commands to satisfy if available
+        if (ctx.commandsToSatisfy && ctx.commandsToSatisfy.length > 0) {
+            lines.push('');
+            lines.push('Commands to satisfy:');
+            for (const cmd of ctx.commandsToSatisfy) {
+                lines.push(`  ${cmd}`);
+            }
+        }
+        // Show suggested intervention
+        lines.push('');
+        lines.push('Suggested intervention:');
+        if (ctx.commandsToSatisfy && ctx.commandsToSatisfy.length > 0) {
+            const cmdArgs = ctx.commandsToSatisfy.map(c => `--cmd "${c}"`).join(' ');
+            lines.push(`  runr intervene ${ctx.runId} --reason review_loop \\`);
+            lines.push(`    --note "Fixed review requests" ${cmdArgs}`);
+        }
+        else {
+            lines.push(`  runr intervene ${ctx.runId} --reason review_loop \\`);
+            lines.push(`    --note "Fixed review requests" --cmd "npm run build""`);
+        }
+    }
+    else {
+        // Context line based on stop reason (for non-review_loop cases)
+        const contextLine = getContextLine(ctx);
+        if (contextLine) {
+            lines.push(contextLine);
+        }
+    }
+    lines.push('');
+    lines.push('Next steps:');
+    if (brainActions && brainActions.length >= 3) {
+        // Use brain-computed actions for consistency across UX
+        for (const action of brainActions.slice(0, 3)) {
+            lines.push(`  ${action.command}`);
+        }
+    }
+    else {
+        // Fallback to default commands
+        const steps = buildNextSteps(ctx.runId, ctx.stopReason);
+        lines.push(`  ${steps.resume}`);
+        lines.push(`  ${steps.intervene}`);
+        lines.push(`  ${steps.audit}`);
+    }
+    lines.push(SEPARATOR);
+    return lines.join('\n');
+}
+/**
+ * Build stop context from run state.
+ * Extended version accepts optional review loop data.
+ */
+export function buildStopContext(state, reviewLoopData) {
+    return {
+        runId: state.run_id,
+        stopReason: state.stop_reason || 'unknown',
+        checkpointSha: state.checkpoint_commit_sha,
+        milestoneIndex: state.milestone_index,
+        milestonesTotal: state.milestones.length,
+        lastError: state.last_error,
+        phase: state.phase,
+        // Extended review loop fields
+        reviewRound: reviewLoopData?.reviewRound ?? state.review_rounds,
+        maxReviewRounds: reviewLoopData?.maxReviewRounds,
+        reviewerRequests: reviewLoopData?.reviewerRequests,
+        commandsToSatisfy: reviewLoopData?.commandsToSatisfy
+    };
+}
+/**
+ * Print stop footer to console.
+ * If reviewLoopData is provided, includes enhanced diagnostics.
+ * If brainActions is provided, uses them for consistent UX (from brain module).
+ */
+export function printStopFooter(state, reviewLoopData, brainActions) {
+    const ctx = buildStopContext(state, reviewLoopData);
+    console.log('');
+    console.log(formatStopFooter(ctx, brainActions));
+}