chati-dev 3.2.5 → 3.3.1

package/src/autonomy/build-loop.js

@@ -25,6 +25,8 @@ import {
   CheckpointStatus,
   BuildStatus,
 } from './build-state.js';
+import { analyzeCause, buildRetryGuidance } from './cause-analyzer.js';
+import { shouldEscalate, getEscalationConfig, buildEscalationSummary } from './escalation.js';
 
 // ---------------------------------------------------------------------------
 // Build Loop
@@ -34,9 +36,10 @@ import {
  * @typedef {object} BuildLoopConfig
  * @property {string} projectDir - Project root directory
  * @property {string[]} taskIds - Task IDs to execute
- * @property {function(string): Promise<{success: boolean, output: string}>} executor - Task execution function
+ * @property {function(string, object?): Promise<{success: boolean, output: string}>} executor - Task execution function (taskId, options?)
  * @property {function(object): void} [onProgress] - Progress callback
  * @property {boolean} [resume=false] - Whether to resume from existing state
+ * @property {string} [model='sonnet'] - Current model tier for escalation
  */
 
 /**
@@ -64,7 +67,7 @@ import {
  * @returns {Promise<BuildLoopResult>}
  */
 export async function runBuildLoop(config) {
-  const { projectDir, taskIds, executor, onProgress, resume = false } = config;
+  const { projectDir, taskIds, executor, onProgress, resume = false, model = 'sonnet' } = config;
 
   // Load or create state
   let state = resume ? loadBuildState(projectDir) : null;
@@ -78,6 +81,10 @@ export async function runBuildLoop(config) {
 
   const startTime = Date.now();
 
+  // Per-task attempt history for cause analysis
+  /** @type {Map<string, Array<{category: string, output: string}>>} */
+  const attemptHistory = new Map();
+
   // Main loop
   while (true) {
     // Check global timeout
@@ -115,6 +122,54 @@ export async function runBuildLoop(config) {
       continue;
     }
 
+    // --- Escalation check (before execution) ---
+    const previousAttempts = attemptHistory.get(checkpoint.taskId) || [];
+    let executorOptions = {};
+
+    if (checkpoint.attempts > 0 && checkpoint.error) {
+      // Analyze the cause of the previous failure
+      const analysis = analyzeCause(checkpoint.error, previousAttempts);
+      const escalation = shouldEscalate(checkpoint, analysis);
+
+      if (escalation.escalate) {
+        const escalationConfig = getEscalationConfig(escalation.newLevel, model);
+
+        // Update checkpoint with escalation level
+        state = updateCheckpoint(state, checkpoint.taskId, {
+          escalationLevel: escalation.newLevel,
+        });
+
+        if (onProgress) {
+          onProgress({
+            type: 'escalation',
+            taskId: checkpoint.taskId,
+            level: escalation.newLevel,
+            summary: buildEscalationSummary(escalation.newLevel, escalation.reason),
+          });
+        }
+
+        // Pause for human intervention at MAX level
+        if (escalationConfig.shouldPause) {
+          state = updateCheckpoint(state, checkpoint.taskId, {
+            status: CheckpointStatus.FAILED,
+            error: `Escalation MAX — paused for human intervention: ${escalation.reason}`,
+          });
+          saveBuildState(projectDir, state);
+
+          if (onProgress) {
+            onProgress({ type: 'escalation_pause', taskId: checkpoint.taskId, reason: escalation.reason });
+          }
+          continue;
+        }
+
+        // Build executor options with escalation context
+        executorOptions.modelOverride = escalationConfig.model;
+        if (escalationConfig.contextBoost) {
+          executorOptions.retryGuidance = buildRetryGuidance(analysis, checkpoint.attempts + 1);
+        }
+      }
+    }
+
     // Mark task as in progress
     state = updateCheckpoint(state, checkpoint.taskId, {
       status: CheckpointStatus.IN_PROGRESS,
@@ -130,32 +185,64 @@ export async function runBuildLoop(config) {
 
     // Execute task
     try {
-      const result = await executor(checkpoint.taskId);
+      const result = await executor(checkpoint.taskId, executorOptions);
 
       if (result.success) {
         state = updateCheckpoint(state, checkpoint.taskId, {
           status: CheckpointStatus.COMPLETED,
           output: result.output?.slice(0, 1000) || 'Completed',
           error: null,
+          escalationLevel: undefined, // Reset on success
         });
 
         if (onProgress) {
           onProgress({ type: 'task_completed', taskId: checkpoint.taskId });
         }
       } else {
+        // --- Self-critique: analyze failure cause ---
+        const failureOutput = result.output || 'Task failed';
+        const analysis = analyzeCause(failureOutput, previousAttempts);
+
+        // Record attempt in history
+        if (!attemptHistory.has(checkpoint.taskId)) {
+          attemptHistory.set(checkpoint.taskId, []);
+        }
+        attemptHistory.get(checkpoint.taskId).push({
+          category: analysis.category,
+          output: failureOutput.slice(0, 500),
+        });
+
         state = updateCheckpoint(state, checkpoint.taskId, {
           status: CheckpointStatus.IN_PROGRESS, // Will retry
-          error: result.output?.slice(0, 500) || 'Task failed',
+          error: failureOutput.slice(0, 500),
         });
 
         if (onProgress) {
-          onProgress({ type: 'task_failed', taskId: checkpoint.taskId, attempt: checkpoint.attempts + 1, error: result.output });
+          onProgress({
+            type: 'task_failed',
+            taskId: checkpoint.taskId,
+            attempt: checkpoint.attempts + 1,
+            error: failureOutput,
+            causeAnalysis: analysis,
+          });
         }
       }
     } catch (err) {
+      const errorMsg = err.message?.slice(0, 500) || 'Execution error';
+
+      // Record exception in history for cause analysis
+      const analysis = analyzeCause(errorMsg, previousAttempts);
+      if (!attemptHistory.has(checkpoint.taskId)) {
+        attemptHistory.set(checkpoint.taskId, []);
+      }
+      attemptHistory.get(checkpoint.taskId).push({
+        category: analysis.category,
+        output: errorMsg,
+      });
+
       state = updateCheckpoint(state, checkpoint.taskId, {
         status: CheckpointStatus.IN_PROGRESS, // Will retry
-        error: err.message?.slice(0, 500) || 'Execution error',
+        error: errorMsg,
       });
     }
 

package/src/autonomy/build-state.js

@@ -18,6 +18,9 @@ import { join, dirname } from 'path';
 /** Maximum iterations per individual task before giving up */
 export const MAX_ITERATIONS_PER_TASK = 10;
 
+/** Maximum time per individual task before giving up (10 minutes) */
+export const MAX_TIME_PER_TASK_MS = 10 * 60 * 1000;
+
 /** Global timeout for an autonomous build session (30 minutes) */
 export const GLOBAL_TIMEOUT_MS = 30 * 60 * 1000;
 
@@ -58,6 +61,7 @@ export const CheckpointStatus = {
  * @property {string} taskId
  * @property {string} status - CheckpointStatus
  * @property {number} attempts - Number of execution attempts
+ * @property {string|null} firstAttempt - ISO timestamp of first attempt
  * @property {string|null} lastAttempt - ISO timestamp of last attempt
  * @property {string|null} output - Last output summary
  * @property {string|null} error - Last error message (if failed)
@@ -94,6 +98,7 @@ export function createBuildState(taskIds) {
       taskId,
       status: CheckpointStatus.PENDING,
       attempts: 0,
+      firstAttempt: null,
       lastAttempt: null,
       output: null,
       error: null,
@@ -157,6 +162,11 @@ export function updateCheckpoint(state, taskId, update) {
     throw new Error(`Task "${taskId}" not found in build state`);
   }
 
+  // Set firstAttempt on the first execution attempt
+  if (update.attempts !== undefined && update.attempts > 0 && !checkpoint.firstAttempt) {
+    checkpoint.firstAttempt = new Date().toISOString();
+  }
+
   Object.assign(checkpoint, update);
   state.lastCheckpoint = new Date().toISOString();
 
@@ -217,13 +227,21 @@ export function getNextPendingTask(state) {
 }
 
 /**
- * Check if a task has exceeded max iterations.
+ * Check if a task has exceeded max iterations or max time.
+ *
+ * Dual check: exhausted if attempts >= MAX_ITERATIONS_PER_TASK
+ * OR if elapsed time since first attempt >= MAX_TIME_PER_TASK_MS.
  *
  * @param {TaskCheckpoint} checkpoint
  * @returns {boolean}
  */
 export function isTaskExhausted(checkpoint) {
-  return checkpoint.attempts >= MAX_ITERATIONS_PER_TASK;
+  if (checkpoint.attempts >= MAX_ITERATIONS_PER_TASK) return true;
+  if (checkpoint.firstAttempt) {
+    const elapsed = Date.now() - new Date(checkpoint.firstAttempt).getTime();
+    if (elapsed >= MAX_TIME_PER_TASK_MS) return true;
+  }
+  return false;
 }
 
 /**

package/src/autonomy/cause-analyzer.js

@@ -0,0 +1,177 @@
+/**
+ * @fileoverview Cause analysis for failed build loop tasks.
+ *
+ * Analyzes agent output to classify failure categories, detect
+ * repetitive patterns, and generate retry guidance.
+ *
+ * Constitution Article XVII — Execution Mode Governance.
+ */
+
+// ---------------------------------------------------------------------------
+// Failure Categories
+// ---------------------------------------------------------------------------
+
+/**
+ * Categories of task failures.
+ * @enum {string}
+ */
+export const FAILURE_CATEGORIES = {
+  SYNTAX_ERROR: 'syntax_error',
+  TEST_FAILURE: 'test_failure',
+  LINT_VIOLATION: 'lint_violation',
+  TYPE_ERROR: 'type_error',
+  TIMEOUT: 'timeout',
+  SCOPE_VIOLATION: 'scope_violation',
+  DEPENDENCY: 'dependency',
+  RUNTIME_ERROR: 'runtime_error',
+  UNKNOWN: 'unknown',
+};
+
+/**
+ * Patterns for classifying failure output.
+ */
+const CATEGORY_PATTERNS = [
+  { regex: /SyntaxError|Unexpected token|parsing error|unterminated/i, category: FAILURE_CATEGORIES.SYNTAX_ERROR },
+  { regex: /test.*fail|assertion.*fail|expect.*receive|expected.*but got/i, category: FAILURE_CATEGORIES.TEST_FAILURE },
+  { regex: /lint.*error|eslint|prettier.*error|formatting/i, category: FAILURE_CATEGORIES.LINT_VIOLATION },
+  { regex: /TypeError|type.*mismatch|cannot read propert|is not a function/i, category: FAILURE_CATEGORIES.TYPE_ERROR },
+  { regex: /timeout|ETIMEDOUT|exceeded.*time|timed out/i, category: FAILURE_CATEGORIES.TIMEOUT },
+  { regex: /scope.*violation|cannot write|not allowed.*mode|Article XI/i, category: FAILURE_CATEGORIES.SCOPE_VIOLATION },
+  { regex: /Cannot find module|ENOENT|module not found|import.*failed|missing dependency/i, category: FAILURE_CATEGORIES.DEPENDENCY },
+  { regex: /ReferenceError|RangeError|Error:|runtime error|ENOMEM/i, category: FAILURE_CATEGORIES.RUNTIME_ERROR },
+];
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Analyze the cause of a task failure.
+ *
+ * @param {string} output - Agent output/error text
+ * @param {Array<{category: string, output: string}>} [previousAttempts=[]] - History of prior attempts
+ * @returns {{ category: string, rootCause: string, suggestion: string, isRepetitive: boolean }}
+ */
+export function analyzeCause(output, previousAttempts = []) {
+  const text = output || '';
+  const category = classifyOutput(text);
+  const rootCause = extractRootCause(text, category);
+  const suggestion = generateSuggestion(category, rootCause);
+  const isRepetitive = checkRepetitive(category, previousAttempts);
+
+  return { category, rootCause, suggestion, isRepetitive };
+}
+
+/**
+ * Build retry guidance for the next attempt based on cause analysis.
+ *
+ * @param {{ category: string, rootCause: string, suggestion: string, isRepetitive: boolean }} analysis
+ * @param {number} attempt - Current attempt number
+ * @returns {string} Guidance text for the agent
+ */
+export function buildRetryGuidance(analysis, attempt) {
+  const parts = [];
+
+  parts.push(`## Retry Guidance (Attempt ${attempt})`);
+  parts.push('');
+  parts.push(`**Previous failure**: ${analysis.category}`);
+
+  if (analysis.rootCause) {
+    parts.push(`**Root cause**: ${analysis.rootCause}`);
+  }
+
+  parts.push(`**Suggestion**: ${analysis.suggestion}`);
+
+  if (analysis.isRepetitive) {
+    parts.push('');
+    parts.push('**WARNING**: This is a REPETITIVE failure. The same category of error occurred in previous attempts.');
+    parts.push('You MUST try a fundamentally different approach — do not repeat the same fix.');
+  }
+
+  return parts.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Internal Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Classify output text into a failure category.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function classifyOutput(text) {
+  for (const { regex, category } of CATEGORY_PATTERNS) {
+    if (regex.test(text)) {
+      return category;
+    }
+  }
+  return FAILURE_CATEGORIES.UNKNOWN;
+}
+
+/**
+ * Extract a concise root cause from the output.
+ *
+ * @param {string} text
+ * @param {string} category
+ * @returns {string}
+ */
+function extractRootCause(text, category) {
+  if (!text) return 'No output available';
+
+  // Try to find the most informative error line
+  const lines = text.split('\n').filter(l => l.trim());
+
+  // Look for lines containing "Error:" or similar markers
+  const errorLine = lines.find(l =>
+    /error:|Error:|ERR!|FAIL|failed/i.test(l)
+  );
+
+  if (errorLine) {
+    return errorLine.trim().slice(0, 200);
+  }
+
+  // Fall back to last non-empty line (often the summary)
+  if (lines.length > 0) {
+    return lines[lines.length - 1].trim().slice(0, 200);
+  }
+
+  return `${category} detected (no specific error line found)`;
+}
+
+/**
+ * Generate a suggestion based on the failure category.
+ *
+ * @param {string} category
+ * @param {string} rootCause
+ * @returns {string}
+ */
+function generateSuggestion(category, rootCause) {
+  const suggestions = {
+    [FAILURE_CATEGORIES.SYNTAX_ERROR]: 'Check for missing brackets, semicolons, or malformed expressions. Review the exact line mentioned in the error.',
+    [FAILURE_CATEGORIES.TEST_FAILURE]: 'Review the failing test assertions. Ensure the implementation matches the expected behavior described in the test.',
+    [FAILURE_CATEGORIES.LINT_VIOLATION]: 'Fix formatting and style issues. Check import ordering, unused variables, and indentation.',
+    [FAILURE_CATEGORIES.TYPE_ERROR]: 'Verify that variable types match expected types. Check for null/undefined access and incorrect function signatures.',
+    [FAILURE_CATEGORIES.TIMEOUT]: 'The operation took too long. Consider optimizing the approach or breaking the task into smaller pieces.',
+    [FAILURE_CATEGORIES.SCOPE_VIOLATION]: 'The write operation is outside the allowed scope for the current mode. Only modify files within the permitted directories.',
+    [FAILURE_CATEGORIES.DEPENDENCY]: 'A required module or dependency is missing. Ensure all imports reference existing files and packages are installed.',
+    [FAILURE_CATEGORIES.RUNTIME_ERROR]: 'A runtime error occurred during execution. Check for logic errors, invalid operations, and edge cases.',
+    [FAILURE_CATEGORIES.UNKNOWN]: 'Review the full output to identify the issue. The error does not match known patterns.',
+  };
+
+  return suggestions[category] || suggestions[FAILURE_CATEGORIES.UNKNOWN];
+}
+
+/**
+ * Check if the same failure category appeared in previous attempts.
+ *
+ * @param {string} category
+ * @param {Array<{category: string}>} previousAttempts
+ * @returns {boolean}
+ */
+function checkRepetitive(category, previousAttempts) {
+  if (category === FAILURE_CATEGORIES.UNKNOWN) return false;
+  const sameCategory = previousAttempts.filter(a => a.category === category);
+  return sameCategory.length >= 2;
+}

package/src/autonomy/escalation.js

@@ -0,0 +1,214 @@
+/**
+ * @fileoverview Progressive escalation for build loop retries.
+ *
+ * When a task fails repeatedly, escalation progressively increases
+ * the resources (model tier, context enrichment) and ultimately
+ * pauses for human intervention.
+ *
+ * Constitution Article XVII — Execution Mode Governance.
+ */
+
+// ---------------------------------------------------------------------------
+// Escalation Levels
+// ---------------------------------------------------------------------------
+
+/**
+ * Escalation level definitions.
+ * @enum {number}
+ */
+export const ESCALATION_LEVELS = {
+  /** Standard — use configured model, no extra context. */
+  STANDARD: 0,
+  /** Enriched — same model, inject cause analysis + retry guidance. */
+  ENRICHED: 1,
+  /** Upgraded — escalate to higher-tier model (e.g. sonnet → opus). */
+  UPGRADED: 2,
+  /** Max — pause execution and request human intervention. */
+  MAX: 3,
+};
+
+/**
+ * Model upgrade map — maps current model tier to the next tier.
+ * Keys are logical tier names used in chati config.
+ */
+const MODEL_UPGRADE_MAP = {
+  haiku: 'sonnet',
+  sonnet: 'opus',
+  opus: 'opus', // opus is ceiling
+  // Gemini equivalents
+  flash: 'pro',
+  pro: 'pro',
+  // Codex equivalents
+  codex: 'codex',
+};
+
+/**
+ * Thresholds for automatic escalation.
+ */
+const ESCALATION_THRESHOLDS = {
+  /** Attempts before escalating from STANDARD to ENRICHED. */
+  ENRICHED_AFTER: 2,
+  /** Attempts before escalating from ENRICHED to UPGRADED. */
+  UPGRADED_AFTER: 4,
+  /** Attempts before escalating from UPGRADED to MAX. */
+  MAX_AFTER: 7,
+};
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Get the current escalation level for a task checkpoint.
+ *
+ * @param {{ attempts: number, escalationLevel?: number }} checkpoint
+ * @returns {number} Current escalation level (0-3)
+ */
+export function getEscalationLevel(checkpoint) {
+  if (!checkpoint) return ESCALATION_LEVELS.STANDARD;
+
+  // Explicit level takes precedence (set by previous escalation)
+  if (typeof checkpoint.escalationLevel === 'number') {
+    return checkpoint.escalationLevel;
+  }
+
+  // Derive from attempt count
+  const attempts = checkpoint.attempts || 0;
+
+  if (attempts >= ESCALATION_THRESHOLDS.MAX_AFTER) {
+    return ESCALATION_LEVELS.MAX;
+  }
+  if (attempts >= ESCALATION_THRESHOLDS.UPGRADED_AFTER) {
+    return ESCALATION_LEVELS.UPGRADED;
+  }
+  if (attempts >= ESCALATION_THRESHOLDS.ENRICHED_AFTER) {
+    return ESCALATION_LEVELS.ENRICHED;
+  }
+
+  return ESCALATION_LEVELS.STANDARD;
+}
+
+/**
+ * Determine whether escalation should occur based on checkpoint
+ * state and cause analysis.
+ *
+ * @param {{ attempts: number, escalationLevel?: number }} checkpoint
+ * @param {{ isRepetitive: boolean, category: string }} analysis - Cause analysis result
+ * @returns {{ escalate: boolean, newLevel: number, reason: string }}
+ */
+export function shouldEscalate(checkpoint, analysis) {
+  const currentLevel = getEscalationLevel(checkpoint);
+  const attempts = checkpoint?.attempts || 0;
+
+  // Already at max — no further escalation
+  if (currentLevel >= ESCALATION_LEVELS.MAX) {
+    return {
+      escalate: false,
+      newLevel: ESCALATION_LEVELS.MAX,
+      reason: 'Already at maximum escalation level',
+    };
+  }
+
+  // Repetitive failures trigger immediate escalation (+1 level)
+  if (analysis?.isRepetitive) {
+    const newLevel = Math.min(currentLevel + 1, ESCALATION_LEVELS.MAX);
+    return {
+      escalate: true,
+      newLevel,
+      reason: `Repetitive ${analysis.category} failure — escalating to level ${newLevel}`,
+    };
+  }
+
+  // Threshold-based escalation
+  let targetLevel = ESCALATION_LEVELS.STANDARD;
+  if (attempts >= ESCALATION_THRESHOLDS.MAX_AFTER) {
+    targetLevel = ESCALATION_LEVELS.MAX;
+  } else if (attempts >= ESCALATION_THRESHOLDS.UPGRADED_AFTER) {
+    targetLevel = ESCALATION_LEVELS.UPGRADED;
+  } else if (attempts >= ESCALATION_THRESHOLDS.ENRICHED_AFTER) {
+    targetLevel = ESCALATION_LEVELS.ENRICHED;
+  }
+
+  if (targetLevel > currentLevel) {
+    return {
+      escalate: true,
+      newLevel: targetLevel,
+      reason: `Attempt ${attempts} reached threshold for level ${targetLevel}`,
+    };
+  }
+
+  return {
+    escalate: false,
+    newLevel: currentLevel,
+    reason: 'No escalation needed',
+  };
+}
+
+/**
+ * Get configuration for a given escalation level.
+ *
+ * @param {number} level - Escalation level (0-3)
+ * @param {string} [currentModel='sonnet'] - Current model tier name
+ * @returns {{ model: string|null, contextBoost: boolean, shouldPause: boolean, description: string }}
+ */
+export function getEscalationConfig(level, currentModel = 'sonnet') {
+  switch (level) {
+    case ESCALATION_LEVELS.STANDARD:
+      return {
+        model: null, // no override
+        contextBoost: false,
+        shouldPause: false,
+        description: 'Standard execution — no escalation',
+      };
+
+    case ESCALATION_LEVELS.ENRICHED:
+      return {
+        model: null, // same model
+        contextBoost: true,
+        shouldPause: false,
+        description: 'Enriched context — cause analysis + retry guidance injected',
+      };
+
+    case ESCALATION_LEVELS.UPGRADED:
+      return {
+        model: MODEL_UPGRADE_MAP[currentModel] || currentModel,
+        contextBoost: true,
+        shouldPause: false,
+        description: `Model upgraded from ${currentModel} to ${MODEL_UPGRADE_MAP[currentModel] || currentModel}`,
+      };
+
+    case ESCALATION_LEVELS.MAX:
+      return {
+        model: MODEL_UPGRADE_MAP[currentModel] || currentModel,
+        contextBoost: true,
+        shouldPause: true,
+        description: 'Maximum escalation — pausing for human intervention',
+      };
+
+    default:
+      return {
+        model: null,
+        contextBoost: false,
+        shouldPause: false,
+        description: `Unknown escalation level: ${level}`,
+      };
+  }
+}
+
+/**
+ * Build a human-readable escalation summary.
+ *
+ * @param {number} level - Escalation level
+ * @param {string} reason - Escalation reason
+ * @returns {string}
+ */
+export function buildEscalationSummary(level, reason) {
+  const levelNames = ['STANDARD', 'ENRICHED', 'UPGRADED', 'MAX'];
+  const name = levelNames[level] || 'UNKNOWN';
+  return `[Escalation ${name}] ${reason}`;
+}
+
+/**
+ * Exported for testing — escalation thresholds.
+ */
+export { ESCALATION_THRESHOLDS };

package/src/autonomy/safety-net.js

@@ -28,6 +28,17 @@ const CRITICAL_RISK_KEYWORDS = [
   'database drop',
   'rm -rf',
   'delete all',
+  'credential',
+  'password',
+  'secret',
+  'token',
+  'privilege escalation',
+  'RCE',
+  'XSS',
+  'CSRF',
+  'SQL injection',
+  'command injection',
+  'backdoor',
 ];
 
 /**
@@ -111,13 +122,20 @@ export function getRecommendedAction(triggers) {
   }
 
   // Check for critical severity
-  const hasCritical = triggers.some(t => t.severity === 'critical');
+  const criticalTriggers = triggers.filter(t => t.severity === 'critical');
 
-  if (hasCritical) {
-    const criticalTriggers = triggers.filter(t => t.severity === 'critical');
+  if (criticalTriggers.length >= 2) {
+    return {
+      action: 'abort',
+      reason: `Multiple critical safety conditions: ${criticalTriggers.map(t => t.details).join('; ')}`,
+      resumable: false,
+    };
+  }
+
+  if (criticalTriggers.length === 1) {
     return {
       action: 'pause',
-      reason: `Critical safety conditions: ${criticalTriggers.map(t => t.details).join('; ')}`,
+      reason: `Critical safety condition: ${criticalTriggers[0].details}`,
       resumable: true,
     };
   }
@@ -308,7 +326,7 @@ export function buildSafetyReport(state) {
     message = 'All safety checks passed. Pipeline can continue.';
   } else {
     const action = getRecommendedAction(result.triggers);
-    status = action.action === 'pause' ? 'unsafe' : 'warning';
+    status = (action.action === 'pause' || action.action === 'abort') ? 'unsafe' : 'warning';
     message = action.reason;
   }