brain-dev 0.1.1 → 0.2.0

package/bin/lib/recovery.cjs

@@ -0,0 +1,468 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { readLock, isLockStale, clearStaleLock } = require('./lock.cjs');
+const { readLog } = require('./logger.cjs');
+const { readState, writeState } = require('./state.cjs');
+
+/**
+ * Analyze the JSONL execution log for a crashed phase.
+ * Finds the last successful checkpoint and what was in progress.
+ *
+ * @param {string} brainDir - Path to .brain/ directory
+ * @param {object} staleLock - The stale lock data (contains phase info)
+ * @returns {{ lastEvent: object|null, completedTasks: string[], inProgressTask: string|null, events: object[], phaseNumber: number }}
+ */
+function analyzeLog(brainDir, staleLock) {
+  const phaseNumber = staleLock?.phase || 0;
+  if (!phaseNumber) {
+    return { lastEvent: null, completedTasks: [], inProgressTask: null, events: [], phaseNumber: 0 };
+  }
+
+  const events = readLog(brainDir, phaseNumber);
+  if (events.length === 0) {
+    return { lastEvent: null, completedTasks: [], inProgressTask: null, events, phaseNumber };
+  }
+
+  const completedTasks = [];
+  let inProgressTask = null;
+  let lastEvent = null;
+
+  for (const event of events) {
+    lastEvent = event;
+
+    // A passed spot-check means that plan was completed successfully
+    if (event.type === 'spot-check' && event.passed && event.plan) {
+      completedTasks.push(event.plan);
+      if (inProgressTask === event.plan) {
+        inProgressTask = null;
+      }
+    }
+
+    // A spawn marks a task as in-progress
+    if (event.type === 'spawn' && event.agent === 'executor' && event.plan) {
+      inProgressTask = event.plan;
+    }
+
+    // A completed event also counts
+    if (event.type === 'complete' && event.plan) {
+      completedTasks.push(event.plan);
+      if (inProgressTask === event.plan) {
+        inProgressTask = null;
+      }
+    }
+  }
+
+  return { lastEvent, completedTasks, inProgressTask, events, phaseNumber };
+}
+
+/**
+ * Verify consistency between brain.json state and actual disk artifacts.
+ * Cross-references phase status with PLAN and SUMMARY files on disk.
+ *
+ * @param {string} brainDir - Path to .brain/ directory
+ * @param {object} state - Parsed brain.json state
+ * @returns {{ consistent: boolean, issues: Array<{ type: string, description: string, fix: string }> }}
+ */
+function verifyStateConsistency(brainDir, state) {
+  const issues = [];
+  const phase = state.phase || {};
+  const phaseNumber = phase.current || 0;
+
+  if (phaseNumber === 0) {
+    return { consistent: true, issues };
+  }
+
+  // Check: phases directory exists
+  const phasesDir = path.join(brainDir, 'phases');
+  if (!fs.existsSync(phasesDir)) {
+    if (phase.status === 'executing' || phase.status === 'planned') {
+      issues.push({
+        type: 'missing-dir',
+        description: `State says phase ${phaseNumber} is "${phase.status}" but phases/ directory does not exist`,
+        fix: 'Reset phase status to "initialized"'
+      });
+    }
+    return { consistent: issues.length === 0, issues };
+  }
+
+  // Find the current phase directory
+  const padded = String(phaseNumber).padStart(2, '0');
+  const phaseDirs = fs.readdirSync(phasesDir).filter(d => d.startsWith(padded + '-'));
+  const phaseDir = phaseDirs.length > 0 ? path.join(phasesDir, phaseDirs[0]) : null;
+
+  // Check: phase dir exists when status implies it should
+  if (!phaseDir && (phase.status === 'executing' || phase.status === 'planned')) {
+    issues.push({
+      type: 'missing-phase-dir',
+      description: `State says phase ${phaseNumber} is "${phase.status}" but no phase directory found`,
+      fix: 'Reset phase status to "initialized"'
+    });
+  }
+
+  if (phaseDir) {
+    // Check: PLAN files exist when status is "executing"
+    if (phase.status === 'executing') {
+      const planFiles = fs.existsSync(phaseDir)
+        ? fs.readdirSync(phaseDir).filter(f => f.startsWith('PLAN'))
+        : [];
+      if (planFiles.length === 0) {
+        issues.push({
+          type: 'missing-plans',
+          description: `Phase ${phaseNumber} is "executing" but no PLAN files found in ${phaseDirs[0]}`,
+          fix: 'Revert status to "planned" to re-generate execution plans'
+        });
+      }
+    }
+
+    // Check: SUMMARY file when status is "completed"
+    if (phase.status === 'completed') {
+      const summaryFiles = fs.existsSync(phaseDir)
+        ? fs.readdirSync(phaseDir).filter(f => f.toUpperCase().startsWith('SUMMARY'))
+        : [];
+      if (summaryFiles.length === 0) {
+        issues.push({
+          type: 'missing-summary',
+          description: `Phase ${phaseNumber} is "completed" but no SUMMARY file found`,
+          fix: 'Revert status to "executing" to regenerate summary'
+        });
+      }
+    }
+  }
+
+  // Check: phase list consistency
+  if (Array.isArray(phase.phases) && phaseNumber > phase.phases.length && phase.phases.length > 0) {
+    issues.push({
+      type: 'phase-overflow',
+      description: `Current phase ${phaseNumber} exceeds total phases defined (${phase.phases.length})`,
+      fix: 'Set current phase to last valid phase number'
+    });
+  }
+
+  // Check: status is a known value
+  const validStatuses = ['initialized', 'mapped', 'planned', 'executing', 'completed', 'paused', 'failed', 'partial'];
+  if (phase.status && !validStatuses.includes(phase.status)) {
+    issues.push({
+      type: 'invalid-status',
+      description: `Phase status "${phase.status}" is not a recognized value`,
+      fix: 'Reset to last known valid status'
+    });
+  }
+
+  return { consistent: issues.length === 0, issues };
+}
+
+/**
+ * Determine the appropriate recovery mode based on analysis results.
+ *
+ * @param {object} logAnalysis - Output from analyzeLog()
+ * @param {object} consistency - Output from verifyStateConsistency()
+ * @param {object} staleLock - The stale lock data
+ * @param {object} state - Current brain.json state
+ * @returns {{ mode: 'auto-resume'|'manual-review'|'rollback', reason: string, details: object }}
+ */
+function determineRecoveryMode(logAnalysis, consistency, staleLock, state) {
+  const autoRecover = state.workflow?.auto_recover === true;
+  const hasProgress = logAnalysis.completedTasks.length > 0;
+
+  // Rollback: no progress at all
+  if (!hasProgress && logAnalysis.events.length === 0) {
+    return {
+      mode: 'rollback',
+      reason: 'No execution progress found; nothing to resume',
+      details: { completedTasks: 0, events: 0 }
+    };
+  }
+
+  // Manual review: state is inconsistent
+  if (!consistency.consistent) {
+    return {
+      mode: 'manual-review',
+      reason: `State inconsistency detected: ${consistency.issues.length} issue(s)`,
+      details: { issues: consistency.issues }
+    };
+  }
+
+  // Manual review: auto_recover is disabled
+  if (!autoRecover) {
+    return {
+      mode: 'manual-review',
+      reason: 'Auto-recovery is disabled (workflow.auto_recover=false)',
+      details: { completedTasks: logAnalysis.completedTasks.length, inProgress: logAnalysis.inProgressTask }
+    };
+  }
+
+  // Auto-resume: consistent state + auto_recover + progress exists
+  if (consistency.consistent && autoRecover && hasProgress) {
+    return {
+      mode: 'auto-resume',
+      reason: `State is consistent with ${logAnalysis.completedTasks.length} completed task(s); auto-recovery enabled`,
+      details: { completedTasks: logAnalysis.completedTasks, inProgress: logAnalysis.inProgressTask }
+    };
+  }
+
+  // Fallback to manual review
+  return {
+    mode: 'manual-review',
+    reason: 'Recovery conditions partially met; manual review recommended',
+    details: { autoRecover, consistent: consistency.consistent, hasProgress }
+  };
+}
+
+/**
+ * Generate a human-readable recovery briefing report.
+ *
+ * @param {object} analysis - { logAnalysis, consistency, recoveryMode, staleLock, state }
+ * @returns {string} Markdown-formatted briefing
+ */
+function generateRecoveryBriefing(analysis) {
+  const { logAnalysis, consistency, recoveryMode, staleLock } = analysis;
+  const lines = [
+    '# Crash Recovery Briefing',
+    '',
+    '## Stale Lock',
+    `- PID: ${staleLock?.pid || 'unknown'}`,
+    `- Phase: ${staleLock?.phase || 'unknown'}`,
+    `- Operation: ${staleLock?.operation || 'unknown'}`,
+    `- Acquired: ${staleLock?.acquiredAt || 'unknown'}`,
+    `- Last heartbeat: ${staleLock?.heartbeat || 'unknown'}`,
+    ''
+  ];
+
+  lines.push('## Log Analysis');
+  lines.push(`- Phase: ${logAnalysis.phaseNumber}`);
+  lines.push(`- Total events: ${logAnalysis.events.length}`);
+  lines.push(`- Completed tasks: ${logAnalysis.completedTasks.length > 0 ? logAnalysis.completedTasks.join(', ') : 'none'}`);
+  lines.push(`- In-progress task: ${logAnalysis.inProgressTask || 'none'}`);
+  if (logAnalysis.lastEvent) {
+    lines.push(`- Last event: [${logAnalysis.lastEvent.type || '?'}] at ${logAnalysis.lastEvent.timestamp || '?'}`);
+  }
+  lines.push('');
+
+  lines.push('## State Consistency');
+  if (consistency.consistent) {
+    lines.push('- Status: consistent');
+  } else {
+    lines.push('- Status: INCONSISTENT');
+    for (const issue of consistency.issues) {
+      lines.push(`  - [${issue.type}] ${issue.description}`);
+      lines.push(`    Fix: ${issue.fix}`);
+    }
+  }
+  lines.push('');
+
+  lines.push('## Recovery Recommendation');
+  lines.push(`- Mode: ${recoveryMode.mode}`);
+  lines.push(`- Reason: ${recoveryMode.reason}`);
+  lines.push('');
+
+  if (recoveryMode.mode === 'auto-resume') {
+    lines.push('## Next Action');
+    lines.push('Run `brain recover --fix` to auto-resume from last checkpoint.');
+  } else if (recoveryMode.mode === 'rollback') {
+    lines.push('## Next Action');
+    lines.push('Run `brain recover --rollback` to revert to pre-execution state.');
+  } else {
+    lines.push('## Next Action');
+    lines.push('Review the issues above, then run:');
+    lines.push('- `brain recover --fix` to attempt auto-repair and resume');
+    lines.push('- `brain recover --rollback` to revert to pre-execution state');
+    lines.push('- `brain recover --dismiss` to clear the stale lock without recovery');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Auto-resume: repair state to last checkpoint and prepare for re-execution.
+ * Clears the stale lock and updates state to reflect recovered position.
+ *
+ * @param {string} brainDir - Path to .brain/ directory
+ * @param {object} logAnalysis - Output from analyzeLog()
+ * @param {object} state - Current brain.json state
+ * @returns {{ repaired: boolean, changes: string[], nextAction: string }}
+ */
+function autoResume(brainDir, logAnalysis, state) {
+  const changes = [];
+
+  // Clear the stale lock
+  clearStaleLock(brainDir);
+  changes.push('Cleared stale lock');
+
+  // Update phase status to indicate recovery
+  if (state.phase) {
+    if (state.phase.status === 'executing' && logAnalysis.inProgressTask) {
+      // There was work in progress - set to planned so execution can retry
+      state.phase.status = 'planned';
+      changes.push(`Reset phase status from "executing" to "planned"`);
+    } else if (state.phase.status === 'executing' && !logAnalysis.inProgressTask) {
+      // All tasks were completed or none in progress
+      state.phase.status = 'planned';
+      changes.push(`Reset phase status to "planned" for re-verification`);
+    }
+
+    // Record recovery in stuck tracking
+    state.phase.stuck_count = (state.phase.stuck_count || 0) + 1;
+    state.phase.last_stuck_at = new Date().toISOString();
+    changes.push(`Incremented stuck_count to ${state.phase.stuck_count}`);
+  }
+
+  // Write repaired state
+  writeState(brainDir, state);
+  changes.push('Wrote repaired state to brain.json and STATE.md');
+
+  const nextAction = logAnalysis.inProgressTask
+    ? `Re-execute from task "${logAnalysis.inProgressTask}" (${logAnalysis.completedTasks.length} task(s) already completed)`
+    : `Resume execution for phase ${logAnalysis.phaseNumber}`;
+
+  return { repaired: true, changes, nextAction };
+}
+
+/**
+ * Rollback: revert state to pre-execution and clear partial artifacts.
+ * Preserves logs for forensics but resets phase status.
+ *
+ * @param {string} brainDir - Path to .brain/ directory
+ * @param {object} staleLock - The stale lock data
+ * @param {object} state - Current brain.json state
+ * @returns {{ rolledBack: boolean, changes: string[] }}
+ */
+function rollback(brainDir, staleLock, state) {
+  const changes = [];
+
+  // Clear the stale lock
+  clearStaleLock(brainDir);
+  changes.push('Cleared stale lock');
+
+  // Reset phase status
+  if (state.phase) {
+    const previousStatus = state.phase.status;
+    state.phase.status = 'planned';
+    state.phase.execution_started_at = null;
+    changes.push(`Reset phase status from "${previousStatus}" to "planned"`);
+  }
+
+  // Clear auto mode if it was active
+  if (state.auto?.active) {
+    state.auto.active = false;
+    state.auto.current_step = null;
+    changes.push('Deactivated auto mode');
+  }
+
+  // Write rolled-back state
+  writeState(brainDir, state);
+  changes.push('Wrote rolled-back state to brain.json and STATE.md');
+
+  return { rolledBack: true, changes };
+}
+
+/**
+ * Master recovery entry point.
+ * Detects stale lock, analyzes state, determines recovery mode, and acts.
+ *
+ * @param {string} brainDir - Path to .brain/ directory
+ * @param {object} [opts] - Options
+ * @param {boolean} [opts.fix=false] - Attempt auto-resume
+ * @param {boolean} [opts.rollback=false] - Force rollback
+ * @param {boolean} [opts.dismiss=false] - Clear lock without recovery
+ * @returns {{ recovered: boolean, mode: string, briefing: string, nextAction: string|null, result: object|null }}
+ */
+function recover(brainDir, opts = {}) {
+  // Step 1: Read current state
+  const state = readState(brainDir);
+  if (!state) {
+    return {
+      recovered: false,
+      mode: 'none',
+      briefing: 'No brain.json found. Nothing to recover.',
+      nextAction: null,
+      result: null
+    };
+  }
+
+  // Step 2: Check for stale lock
+  const lock = readLock(brainDir);
+  let staleLock = null;
+
+  if (lock) {
+    const { stale, reason } = isLockStale(lock);
+    if (stale) {
+      staleLock = { ...lock, staleReason: reason };
+    } else {
+      return {
+        recovered: false,
+        mode: 'active',
+        briefing: `Lock is active (PID ${lock.pid}). No recovery needed.`,
+        nextAction: null,
+        result: null
+      };
+    }
+  }
+
+  // No lock at all — check if state looks like it needs recovery
+  if (!staleLock) {
+    // Check for signs of interrupted execution without a lock
+    if (state.phase?.status === 'executing' && !lock) {
+      staleLock = { phase: state.phase.current, operation: 'unknown', pid: null, staleReason: 'No lock file but state is "executing"' };
+    } else {
+      return {
+        recovered: false,
+        mode: 'clean',
+        briefing: 'No stale lock detected. System appears healthy.',
+        nextAction: null,
+        result: null
+      };
+    }
+  }
+
+  // Step 3: Dismiss mode — just clear the lock
+  if (opts.dismiss) {
+    clearStaleLock(brainDir);
+    return {
+      recovered: true,
+      mode: 'dismiss',
+      briefing: 'Stale lock cleared. No state changes made.',
+      nextAction: 'Run your next command normally.',
+      result: { dismissed: true }
+    };
+  }
+
+  // Step 4: Analyze
+  const logAnalysis = analyzeLog(brainDir, staleLock);
+  const consistency = verifyStateConsistency(brainDir, state);
+  const recoveryMode = determineRecoveryMode(logAnalysis, consistency, staleLock, state);
+
+  const analysis = { logAnalysis, consistency, recoveryMode, staleLock, state };
+  const briefing = generateRecoveryBriefing(analysis);
+
+  // Step 5: Act based on mode or user request
+  if (opts.rollback) {
+    const result = rollback(brainDir, staleLock, state);
+    return { recovered: true, mode: 'rollback', briefing, nextAction: 'State rolled back. Re-run planning or execution.', result };
+  }
+
+  if (opts.fix) {
+    const result = autoResume(brainDir, logAnalysis, state);
+    return { recovered: true, mode: 'auto-resume', briefing, nextAction: result.nextAction, result };
+  }
+
+  // Default: check mode — return briefing only
+  return {
+    recovered: false,
+    mode: recoveryMode.mode,
+    briefing,
+    nextAction: null,
+    result: { recommended: recoveryMode.mode, reason: recoveryMode.reason }
+  };
+}
+
+module.exports = {
+  analyzeLog,
+  verifyStateConsistency,
+  determineRecoveryMode,
+  generateRecoveryBriefing,
+  autoResume,
+  rollback,
+  recover
+};

package/bin/lib/security.cjs

@@ -70,7 +70,7 @@ function scanContent(content, filePath) {
       const finding = {
         name: pattern.name,
         pattern: pattern.regex.source,
-        match: match[0]
+        match: match[0].slice(0, 4) + '***REDACTED***'
       };
       if (filePath) {
         finding.file = filePath;
@@ -228,10 +228,24 @@ function scanFiles(rootDir, options = {}) {
   return { findings: allFindings, blockers, warnings };
 }
 
+/**
+ * Check if a file path resolves within the allowed root directory.
+ * Prevents path traversal attacks via ../../ etc.
+ * @param {string} filePath - Relative or absolute path to check
+ * @param {string} rootDir - Allowed root directory
+ * @returns {boolean} true if path is within root
+ */
+function isPathWithinRoot(filePath, rootDir) {
+  const resolved = path.resolve(rootDir, filePath);
+  const normalizedRoot = path.resolve(rootDir);
+  return resolved.startsWith(normalizedRoot + path.sep) || resolved === normalizedRoot;
+}
+
 module.exports = {
   PATTERNS,
   scanContent,
   parseGitignore,
   scanFiles,
-  isIgnored
+  isIgnored,
+  isPathWithinRoot
 };

package/bin/lib/state.cjs

@@ -4,7 +4,7 @@ const fs = require('node:fs');
 const path = require('node:path');
 
 const CURRENT_SCHEMA = 'brain/v1';
-const CURRENT_VERSION = '0.7.0';
+const CURRENT_VERSION = '0.8.0';
 
 /**
  * Atomic write: write to temp file, then rename.
@@ -13,12 +13,6 @@ const CURRENT_VERSION = '0.7.0';
  * @param {string} content - Content to write
  */
 function atomicWriteSync(filePath, content) {
-  // Guard: if target is a directory, remove it first
-  try {
-    if (fs.existsSync(filePath) && fs.statSync(filePath).isDirectory()) {
-      fs.rmSync(filePath, { recursive: true, force: true });
-    }
-  } catch { /* ignore stat errors */ }
   const dir = path.dirname(filePath);
   const tmpPath = path.join(dir, `.${path.basename(filePath)}.${process.pid}.tmp`);
   fs.writeFileSync(tmpPath, content, 'utf8');
@@ -160,6 +154,28 @@ function migrateState(data) {
     migrated.quick = { count: 0 };
   }
 
+  // v0.8.0 fields (auto mode, budget, stuck, recovery, dashboard, context)
+  if (!migrated.auto) {
+    migrated.auto = { active: false, started_at: null, current_step: null, phases_completed: 0, max_phases: null, error_count: 0, max_errors: 3, max_operations: 100, max_duration_minutes: 120, history: [] };
+  }
+  if (!migrated.budget) {
+    migrated.budget = { ceiling_usd: null, warn_at_pct: 80, mode: 'warn' };
+  }
+  if (!migrated.timeout) {
+    migrated.timeout = { soft: 20, idle: 5, hard: 45, max_retries: 1, enabled: true };
+  }
+  if (!migrated.dashboard) {
+    migrated.dashboard = { port: 3457, auto_open: true };
+  }
+  if (!migrated.context) {
+    migrated.context = { preinline: true, budgets: {}, condensed_summaries: true };
+  }
+  if (migrated.phase && !('execution_started_at' in migrated.phase)) {
+    migrated.phase.execution_started_at = null;
+    migrated.phase.stuck_count = 0;
+    migrated.phase.last_stuck_at = null;
+  }
+
   return migrated;
 }
 
@@ -184,6 +200,18 @@ function writeState(brainDir, state) {
   // Generate and write STATE.md atomically
   const mdPath = path.join(brainDir, 'STATE.md');
   atomicWriteSync(mdPath, generateStateMd(state));
+
+  // Heartbeat: update lock if one exists for this process
+  try {
+    const lockPath = path.join(brainDir, '.auto.lock');
+    if (fs.existsSync(lockPath)) {
+      const lockData = JSON.parse(fs.readFileSync(lockPath, 'utf8'));
+      if (lockData.pid === process.pid) {
+        lockData.heartbeat = new Date().toISOString();
+        atomicWriteSync(lockPath, JSON.stringify(lockData, null, 2));
+      }
+    }
+  } catch { /* heartbeat failure is non-fatal */ }
 }
 
 /**
@@ -246,6 +274,52 @@ function generateStateMd(state) {
   }
   lines.push('');
 
+  // Auto Mode section (v0.8.0)
+  const auto = state.auto;
+  if (auto && auto.active) {
+    lines.push('## Auto Mode');
+    lines.push(`- Active: ${auto.active}`);
+    if (auto.started_at) lines.push(`- Started: ${auto.started_at}`);
+    if (auto.current_step) lines.push(`- Current step: ${auto.current_step}`);
+    lines.push(`- Phases completed: ${auto.phases_completed}${auto.max_phases ? '/' + auto.max_phases : ''}`);
+    lines.push(`- Errors: ${auto.error_count}/${auto.max_errors}`);
+    lines.push('');
+  }
+
+  // Budget section (v0.8.0)
+  const budget = state.budget;
+  if (budget && budget.ceiling_usd !== null) {
+    lines.push('## Budget');
+    lines.push(`- Ceiling: $${budget.ceiling_usd}`);
+    lines.push(`- Warn at: ${budget.warn_at_pct}%`);
+    lines.push(`- Mode: ${budget.mode}`);
+    lines.push('');
+  }
+
+  // Timeout section (v0.8.0)
+  const timeout = state.timeout;
+  if (timeout && !timeout.enabled) {
+    lines.push('## Timeout');
+    lines.push('- Enabled: false');
+    lines.push('');
+  } else if (timeout && (timeout.soft !== 20 || timeout.idle !== 5 || timeout.hard !== 45)) {
+    lines.push('## Timeout');
+    lines.push(`- Soft: ${timeout.soft}min`);
+    lines.push(`- Idle: ${timeout.idle}min`);
+    lines.push(`- Hard: ${timeout.hard}min`);
+    lines.push(`- Max retries: ${timeout.max_retries}`);
+    lines.push('');
+  }
+
+  // Recovery section (v0.8.0)
+  if (phase.stuck_count > 0) {
+    lines.push('## Recovery');
+    lines.push(`- Stuck count: ${phase.stuck_count}`);
+    if (phase.last_stuck_at) lines.push(`- Last stuck at: ${phase.last_stuck_at}`);
+    if (phase.execution_started_at) lines.push(`- Execution started: ${phase.execution_started_at}`);
+    lines.push('');
+  }
+
   lines.push('## Blockers');
 
   if (Array.isArray(blockers) && blockers.length > 0) {
@@ -280,7 +354,10 @@ function createDefaultState(platform) {
       current: 0,
       status: 'initialized',
       total: 0,
-      phases: []
+      phases: [],
+      execution_started_at: null,
+      stuck_count: 0,
+      last_stuck_at: null
     },
     milestone: {
       current: 'v1.0',
@@ -331,6 +408,39 @@ function createDefaultState(platform) {
     },
     quick: {
       count: 0
+    },
+    auto: {
+      active: false,
+      started_at: null,
+      current_step: null,
+      phases_completed: 0,
+      max_phases: null,
+      error_count: 0,
+      max_errors: 3,
+      max_operations: 100,
+      max_duration_minutes: 120,
+      history: []
+    },
+    budget: {
+      ceiling_usd: null,
+      warn_at_pct: 80,
+      mode: 'warn'
+    },
+    timeout: {
+      soft: 20,
+      idle: 5,
+      hard: 45,
+      max_retries: 1,
+      enabled: true
+    },
+    dashboard: {
+      port: 3457,
+      auto_open: true
+    },
+    context: {
+      preinline: true,
+      budgets: {},
+      condensed_summaries: true
     }
   };
 }