agentxchain 2.107.0 → 2.109.0

package/src/lib/report.js

@@ -11,6 +11,7 @@ import {
 } from './coordinator-next-actions.js';
 import { buildCoordinatorRepoStatusEntries } from './coordinator-repo-status-presentation.js';
 import { summarizeCoordinatorEvent } from './coordinator-event-narrative.js';
+import { extractGateActionDigest } from './gate-actions.js';
 
 export const GOVERNANCE_REPORT_VERSION = '0.1';
 
@@ -119,6 +120,34 @@ function yesNo(value) {
   return value ? 'yes' : 'no';
 }
 
+function normalizeConflictingFiles(conflict) {
+  if (!conflict || typeof conflict !== 'object' || Array.isArray(conflict)) return [];
+  if (Array.isArray(conflict.conflicting_files)) {
+    return conflict.conflicting_files.filter((entry) => typeof entry === 'string' && entry.length > 0);
+  }
+  if (Array.isArray(conflict.files)) {
+    return conflict.files.filter((entry) => typeof entry === 'string' && entry.length > 0);
+  }
+  return [];
+}
+
+function normalizeAcceptedSinceTurnIds(conflict) {
+  if (!conflict || typeof conflict !== 'object' || Array.isArray(conflict)) return [];
+  if (Array.isArray(conflict.accepted_since_turn_ids)) {
+    return conflict.accepted_since_turn_ids.filter((entry) => typeof entry === 'string' && entry.length > 0);
+  }
+  if (Array.isArray(conflict.accepted_since)) {
+    return conflict.accepted_since
+      .map((entry) => {
+        if (typeof entry === 'string') return entry;
+        if (entry && typeof entry === 'object' && typeof entry.turn_id === 'string') return entry.turn_id;
+        return null;
+      })
+      .filter(Boolean);
+  }
+  return [];
+}
+
 function summarizeBlockedOn(blockedOn) {
   if (!blockedOn) return 'none';
   if (typeof blockedOn === 'string') return blockedOn;
@@ -143,6 +172,9 @@ function renderGovernanceEventDetailText(lines, evt, indent) {
       if (evt.conflicting_files?.length > 0) {
         lines.push(`${indent}files: ${evt.conflicting_files.join(', ')}`);
       }
+      if (evt.accepted_since_turn_ids?.length > 0) {
+        lines.push(`${indent}accepted since: ${evt.accepted_since_turn_ids.join(', ')}`);
+      }
       if (evt.overlap_ratio != null) {
         lines.push(`${indent}overlap: ${(evt.overlap_ratio * 100).toFixed(0)}%`);
       }
@@ -151,8 +183,23 @@ function renderGovernanceEventDetailText(lines, evt, indent) {
       if (evt.conflicting_files?.length > 0) {
         lines.push(`${indent}files: ${evt.conflicting_files.join(', ')}`);
       }
+      if (evt.accepted_since_turn_ids?.length > 0) {
+        lines.push(`${indent}accepted since: ${evt.accepted_since_turn_ids.join(', ')}`);
+      }
+      if (evt.operator_reason) {
+        lines.push(`${indent}operator reason: ${evt.operator_reason}`);
+      }
       break;
     case 'conflict_resolution_selected':
+      if (evt.conflicting_files?.length > 0) {
+        lines.push(`${indent}files: ${evt.conflicting_files.join(', ')}`);
+      }
+      if (evt.accepted_since_turn_ids?.length > 0) {
+        lines.push(`${indent}accepted since: ${evt.accepted_since_turn_ids.join(', ')}`);
+      }
+      if (evt.overlap_ratio != null) {
+        lines.push(`${indent}overlap: ${(evt.overlap_ratio * 100).toFixed(0)}%`);
+      }
       if (evt.resolution_method) {
         lines.push(`${indent}resolution: ${evt.resolution_method}`);
       }
@@ -179,6 +226,9 @@ function renderGovernanceEventDetailMarkdown(lines, evt) {
       if (evt.conflicting_files?.length > 0) {
         lines.push(`  - Files: ${evt.conflicting_files.map((f) => `\`${f}\``).join(', ')}`);
       }
+      if (evt.accepted_since_turn_ids?.length > 0) {
+        lines.push(`  - Accepted since: ${evt.accepted_since_turn_ids.map((turnId) => `\`${turnId}\``).join(', ')}`);
+      }
       if (evt.overlap_ratio != null) {
         lines.push(`  - Overlap: ${(evt.overlap_ratio * 100).toFixed(0)}%`);
       }
@@ -187,8 +237,21 @@ function renderGovernanceEventDetailMarkdown(lines, evt) {
       if (evt.conflicting_files?.length > 0) {
         lines.push(`  - Files: ${evt.conflicting_files.map((f) => `\`${f}\``).join(', ')}`);
       }
+      if (evt.accepted_since_turn_ids?.length > 0) {
+        lines.push(`  - Accepted since: ${evt.accepted_since_turn_ids.map((turnId) => `\`${turnId}\``).join(', ')}`);
+      }
+      if (evt.operator_reason) lines.push(`  - Operator reason: ${evt.operator_reason}`);
       break;
     case 'conflict_resolution_selected':
+      if (evt.conflicting_files?.length > 0) {
+        lines.push(`  - Files: ${evt.conflicting_files.map((f) => `\`${f}\``).join(', ')}`);
+      }
+      if (evt.accepted_since_turn_ids?.length > 0) {
+        lines.push(`  - Accepted since: ${evt.accepted_since_turn_ids.map((turnId) => `\`${turnId}\``).join(', ')}`);
+      }
+      if (evt.overlap_ratio != null) {
+        lines.push(`  - Overlap: ${(evt.overlap_ratio * 100).toFixed(0)}%`);
+      }
       if (evt.resolution_method) lines.push(`  - Resolution: \`${evt.resolution_method}\``);
       break;
     case 'operator_escalated':
@@ -449,6 +512,11 @@ function extractGateFailureDigest(artifact) {
     }));
 }
 
+function extractGateActionEventDigest(artifact) {
+  const data = extractFileData(artifact, '.agentxchain/decision-ledger.jsonl');
+  return extractGateActionDigest(data);
+}
+
 const GOVERNANCE_EVENT_TYPES = new Set([
   'policy_escalation',
   'conflict_detected',
@@ -480,14 +548,21 @@ function extractGovernanceEventDigest(artifact, relPath = '.agentxchain/decision
           })) : [];
           break;
         case 'conflict_detected':
-          base.conflicting_files = Array.isArray(d.conflict?.files) ? d.conflict.files : [];
+          base.conflicting_files = normalizeConflictingFiles(d.conflict);
+          base.accepted_since_turn_ids = normalizeAcceptedSinceTurnIds(d.conflict);
           base.overlap_ratio = typeof d.conflict?.overlap_ratio === 'number' ? d.conflict.overlap_ratio : null;
           break;
         case 'conflict_rejected':
-          base.conflicting_files = Array.isArray(d.conflict?.files) ? d.conflict.files : [];
+          base.conflicting_files = normalizeConflictingFiles(d.conflict);
+          base.accepted_since_turn_ids = normalizeAcceptedSinceTurnIds(d.conflict);
+          base.overlap_ratio = typeof d.conflict?.overlap_ratio === 'number' ? d.conflict.overlap_ratio : null;
+          base.operator_reason = d.operator_reason || null;
           break;
         case 'conflict_resolution_selected':
-          base.resolution_method = d.conflict?.resolution || null;
+          base.conflicting_files = normalizeConflictingFiles(d.conflict);
+          base.accepted_since_turn_ids = normalizeAcceptedSinceTurnIds(d.conflict);
+          base.overlap_ratio = typeof d.conflict?.overlap_ratio === 'number' ? d.conflict.overlap_ratio : null;
+          base.resolution_method = d.resolution_chosen || d.conflict?.resolution || null;
           break;
         case 'operator_escalated':
           base.blocked_on = d.blocked_on || null;
@@ -917,6 +992,7 @@ function buildRunSubject(artifact) {
   const decisions = extractDecisionDigest(artifact);
   const approvalPolicyEvents = extractApprovalPolicyDigest(artifact);
   const gateFailures = extractGateFailureDigest(artifact);
+  const gateActions = extractGateActionEventDigest(artifact);
   const timeoutEvents = extractTimeoutEventDigest(artifact);
   const hookSummary = extractHookSummary(artifact);
   const timing = computeTiming(artifact, turns);
@@ -965,6 +1041,7 @@ function buildRunSubject(artifact) {
       approval_policy_events: approvalPolicyEvents,
       governance_events: governanceEvents,
       gate_failures: gateFailures,
+      gate_actions: gateActions,
       timeout_events: timeoutEvents,
       delegation_summary: delegationSummary,
       hook_summary: hookSummary,
@@ -1362,6 +1439,18 @@ export function formatGovernanceReportText(report) {
       }
     }
 
+    if (run.gate_actions && run.gate_actions.length > 0) {
+      lines.push('', 'Gate Actions:');
+      for (const action of run.gate_actions) {
+        const label = action.action_label || action.command || `action ${action.action_index || '?'}`;
+        const exit = action.exit_code == null ? 'n/a' : String(action.exit_code);
+        lines.push(`  - ${action.gate_id || 'unknown'} | ${action.gate_type || 'unknown'} | action ${action.action_index || '?'} | ${action.status} | ${label} | exit: ${exit} | at: ${action.timestamp || 'n/a'}`);
+        if (action.stderr_tail) {
+          lines.push(`      stderr: ${action.stderr_tail}`);
+        }
+      }
+    }
+
     if (run.approval_policy_events && run.approval_policy_events.length > 0) {
       lines.push('', 'Approval Policy:');
       for (const evt of run.approval_policy_events) {
@@ -1920,6 +2009,18 @@ export function formatGovernanceReportMarkdown(report) {
       }
     }
 
+    if (run.gate_actions && run.gate_actions.length > 0) {
+      lines.push('', '## Gate Actions', '');
+      for (const action of run.gate_actions) {
+        const label = action.action_label || action.command || `action ${action.action_index || '?'}`;
+        const exit = action.exit_code == null ? 'n/a' : String(action.exit_code);
+        lines.push(`- \`${action.gate_id || 'unknown'}\` (${action.gate_type || 'unknown'}) action ${action.action_index || '?'} — **${action.status}** at \`${action.timestamp || 'n/a'}\`: ${label} (exit \`${exit}\`)`);
+        if (action.stderr_tail) {
+          lines.push(`  - stderr: ${action.stderr_tail}`);
+        }
+      }
+    }
+
     if (run.approval_policy_events && run.approval_policy_events.length > 0) {
       lines.push('', '## Approval Policy', '');
       for (const evt of run.approval_policy_events) {
@@ -2420,7 +2521,19 @@ function renderHtmlGovEventDetail(evt) {
       break;
     case 'conflict_detected':
       if (evt.conflicting_files?.length > 0) parts.push(`<li>Files: ${evt.conflicting_files.map((f) => `<code>${esc(f)}</code>`).join(', ')}</li>`);
+      if (evt.accepted_since_turn_ids?.length > 0) parts.push(`<li>Accepted since: ${evt.accepted_since_turn_ids.map((turnId) => `<code>${esc(turnId)}</code>`).join(', ')}</li>`);
+      if (evt.overlap_ratio != null) parts.push(`<li>Overlap: ${(evt.overlap_ratio * 100).toFixed(0)}%</li>`);
+      break;
+    case 'conflict_rejected':
+      if (evt.conflicting_files?.length > 0) parts.push(`<li>Files: ${evt.conflicting_files.map((f) => `<code>${esc(f)}</code>`).join(', ')}</li>`);
+      if (evt.accepted_since_turn_ids?.length > 0) parts.push(`<li>Accepted since: ${evt.accepted_since_turn_ids.map((turnId) => `<code>${esc(turnId)}</code>`).join(', ')}</li>`);
+      if (evt.operator_reason) parts.push(`<li>Operator reason: ${esc(evt.operator_reason)}</li>`);
+      break;
+    case 'conflict_resolution_selected':
+      if (evt.conflicting_files?.length > 0) parts.push(`<li>Files: ${evt.conflicting_files.map((f) => `<code>${esc(f)}</code>`).join(', ')}</li>`);
+      if (evt.accepted_since_turn_ids?.length > 0) parts.push(`<li>Accepted since: ${evt.accepted_since_turn_ids.map((turnId) => `<code>${esc(turnId)}</code>`).join(', ')}</li>`);
       if (evt.overlap_ratio != null) parts.push(`<li>Overlap: ${(evt.overlap_ratio * 100).toFixed(0)}%</li>`);
+      if (evt.resolution_method) parts.push(`<li>Resolution: <code>${esc(evt.resolution_method)}</code></li>`);
       break;
     case 'operator_escalated':
       if (evt.reason) parts.push(`<li>Reason: ${esc(evt.reason)}</li>`);
@@ -2605,6 +2718,21 @@ function renderRunHtml(report) {
     sections.push(`<div class="section">${htmlSection('Gate Failures', gfHtml)}</div>`);
   }
 
+  if (run.gate_actions && run.gate_actions.length > 0) {
+    let gaHtml = '<ul>';
+    for (const action of run.gate_actions) {
+      const label = action.action_label || action.command || `action ${action.action_index || '?'}`;
+      const exit = action.exit_code == null ? 'n/a' : String(action.exit_code);
+      gaHtml += `<li><code>${esc(action.gate_id || 'unknown')}</code> (${esc(action.gate_type || 'unknown')}) action ${esc(String(action.action_index || '?'))} — <strong>${esc(action.status)}</strong> at <code>${esc(action.timestamp || 'n/a')}</code>: ${esc(label)} (exit <code>${esc(exit)}</code>)`;
+      if (action.stderr_tail) {
+        gaHtml += `<br><code>${esc(action.stderr_tail)}</code>`;
+      }
+      gaHtml += '</li>';
+    }
+    gaHtml += '</ul>';
+    sections.push(`<div class="section">${htmlSection('Gate Actions', gaHtml)}</div>`);
+  }
+
   // Approval Policy
   if (run.approval_policy_events && run.approval_policy_events.length > 0) {
     let apHtml = '<ul>';

package/src/lib/run-events.js

@@ -17,6 +17,7 @@ export const VALID_RUN_EVENTS = [
   'turn_dispatched',
   'turn_accepted',
   'turn_rejected',
+  'turn_conflicted',
   'run_blocked',
   'run_completed',
   'escalation_raised',

package/src/lib/run-loop.js

@@ -35,6 +35,7 @@ import {
 import { runAdmissionControl } from './admission-control.js';
 import { mkdirSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
+import { evaluateApprovalSlaReminders } from './notification-runner.js';
 
 const DEFAULT_MAX_TURNS = 50;
 
@@ -340,6 +341,26 @@ async function executeParallelTurns(root, config, state, maxConcurrent, callback
       const acceptResult = acceptTurn(root, config, { turnId: turn.turn_id });
       if (!acceptResult.ok) {
         errors.push(`acceptTurn(${roleId}): ${acceptResult.error}`);
+
+        // Conflict-aware handling (DEC-RUN-LOOP-CONFLICT-001)
+        if (acceptResult.error_code === 'conflict') {
+          history.push({
+            role: roleId, turn_id: turn.turn_id, accepted: false,
+            error_code: 'conflict', accept_error: acceptResult.error,
+            conflict: acceptResult.conflict,
+          });
+          emit({
+            type: 'turn_conflicted', turn, role: roleId,
+            error_code: 'conflict', conflict: acceptResult.conflict,
+            state: acceptResult.state,
+          });
+          if (acceptResult.state?.status === 'blocked') {
+            emit({ type: 'blocked', state: acceptResult.state });
+            return { terminal: true, ok: false, stop_reason: 'conflict_loop', history, acceptedCount };
+          }
+          continue;
+        }
+
         // Record failure but try other turns
         history.push({ role: roleId, turn_id: turn.turn_id, accepted: false, accept_error: acceptResult.error });
         continue;
@@ -372,8 +393,10 @@ async function executeParallelTurns(root, config, state, maxConcurrent, callback
   if (acceptedCount === 0 && history.length > 0) {
     const allFailed = history.every(h => !h.accepted);
     if (allFailed) {
-      errors.push('All parallel turns failed acceptance — stalled');
-      return { terminal: true, ok: false, stop_reason: 'blocked', history, acceptedCount };
+      const allConflicts = history.every(h => h.error_code === 'conflict');
+      const stopReason = allConflicts ? 'conflict_stall' : 'blocked';
+      errors.push(`All parallel turns failed acceptance — ${stopReason}`);
+      return { terminal: true, ok: false, stop_reason: stopReason, history, acceptedCount };
     }
   }
 
@@ -419,6 +442,29 @@ async function dispatchAndProcess(root, config, turn, assignState, callbacks, em
     const acceptResult = acceptTurn(root, config);
     if (!acceptResult.ok) {
       errors.push(`acceptTurn(${roleId}): ${acceptResult.error}`);
+
+      // Conflict-aware handling (DEC-RUN-LOOP-CONFLICT-001)
+      if (acceptResult.error_code === 'conflict') {
+        history.push({
+          role: roleId, turn_id: turn.turn_id, accepted: false,
+          error_code: 'conflict', accept_error: acceptResult.error,
+          conflict: acceptResult.conflict,
+        });
+        emit({
+          type: 'turn_conflicted', turn, role: roleId,
+          error_code: 'conflict', conflict: acceptResult.conflict,
+          state: acceptResult.state,
+        });
+        // If the resulting state is blocked (conflict_loop), terminate
+        if (acceptResult.state?.status === 'blocked') {
+          emit({ type: 'blocked', state: acceptResult.state });
+          return { terminal: true, ok: false, stop_reason: 'conflict_loop', history };
+        }
+        // Otherwise the turn is conflicted but the run is still active — let the
+        // main loop re-enter and try another role or handle the paused state
+        return { terminal: false, accepted: false, history };
+      }
+
       return { terminal: true, ok: false, stop_reason: 'blocked', history };
     }
 
@@ -450,6 +496,8 @@ async function dispatchAndProcess(root, config, turn, assignState, callbacks, em
  * Handle a paused state by checking for pending gates and calling approveGate.
  */
 async function handleGatePause(root, config, state, callbacks, emit) {
+  evaluateApprovalSlaReminders(root, config, state);
+
   if (state.pending_phase_transition) {
     emit({ type: 'gate_paused', gateType: 'phase_transition', state });
     let approved;