agentxchain 2.107.0 → 2.108.0

package/dashboard/app.js

@@ -25,7 +25,7 @@ import {
 } from './live-observer.js';
 
 const VIEWS = {
-  timeline: { fetch: ['state', 'continuity', 'history', 'audit', 'annotations', 'connectors', 'coordinatorAudit', 'coordinatorAnnotations'], render: renderTimeline },
+  timeline: { fetch: ['state', 'continuity', 'history', 'events', 'audit', 'annotations', 'connectors', 'coordinatorAudit', 'coordinatorAnnotations'], render: renderTimeline },
   delegations: { fetch: ['state', 'history'], render: renderDelegations },
   ledger: { fetch: ['state', 'ledger', 'coordinatorState', 'coordinatorLedger', 'repoDecisionsSummary'], render: renderLedger },
   hooks: { fetch: ['audit', 'annotations', 'coordinatorAudit', 'coordinatorAnnotations'], render: renderHooks },
@@ -62,6 +62,7 @@ const API_MAP = {
   runHistory: '/api/run-history',
   timeouts: '/api/timeouts',
   coordinatorTimeouts: '/api/coordinator/timeouts',
+  events: '/api/events?type=turn_conflicted&limit=10',
 };
 
 const viewState = {

package/dashboard/components/timeline.js

@@ -90,6 +90,11 @@ function formatTimestamp(iso) {
   }
 }
 
+function formatPercent(value) {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return null;
+  return `${Math.round(value * 100)}%`;
+}
+
 function statusBadge(status) {
   const colors = {
     running: 'var(--green)',
@@ -206,6 +211,99 @@ function renderDelegationReview(review) {
   return `<div class="turn-detail"><span class="detail-label">Delegation Review:</span> <span class="mono">${esc(review.parent_turn_id || 'unknown')}</span> with ${esc(resultCount)} result${resultCount === 1 ? '' : 's'}</div>`;
 }
 
+function collectConflictCards(state, events) {
+  const latestByTurn = new Map();
+
+  if (Array.isArray(events)) {
+    for (const event of [...events].reverse()) {
+      if (event?.event_type !== 'turn_conflicted') continue;
+      const turnId = event?.turn?.turn_id;
+      if (!turnId || latestByTurn.has(turnId)) continue;
+      latestByTurn.set(turnId, {
+        turn_id: turnId,
+        role_id: event?.turn?.role_id || 'unknown',
+        detected_at: event?.timestamp || null,
+        state_label: event?.status === 'blocked' ? 'conflict loop blocked run' : 'recent conflict',
+        detection_count: typeof event?.payload?.detection_count === 'number' ? event.payload.detection_count : null,
+        conflicting_files: Array.isArray(event?.payload?.conflicting_files) ? event.payload.conflicting_files : [],
+        accepted_since_turn_ids: Array.isArray(event?.payload?.accepted_since_turn_ids) ? event.payload.accepted_since_turn_ids : [],
+        overlap_ratio: typeof event?.payload?.overlap_ratio === 'number' ? event.payload.overlap_ratio : null,
+      });
+    }
+  }
+
+  const activeTurns = state?.active_turns ? Object.values(state.active_turns) : [];
+  for (const turn of activeTurns) {
+    if (turn?.status !== 'conflicted') continue;
+    if (latestByTurn.has(turn.turn_id)) {
+      const existing = latestByTurn.get(turn.turn_id);
+      latestByTurn.set(turn.turn_id, {
+        ...existing,
+        state_label: state?.blocked_reason?.category === 'conflict_loop' && state?.blocked_on?.includes(turn.turn_id)
+          ? 'conflict loop blocked run'
+          : 'active conflict',
+      });
+      continue;
+    }
+
+    const conflictError = turn?.conflict_state?.conflict_error || {};
+    latestByTurn.set(turn.turn_id, {
+      turn_id: turn.turn_id,
+      role_id: getRole(turn),
+      detected_at: turn?.conflict_state?.detected_at || null,
+      state_label: state?.blocked_reason?.category === 'conflict_loop' && state?.blocked_on?.includes(turn.turn_id)
+        ? 'conflict loop blocked run'
+        : 'active conflict',
+      detection_count: typeof turn?.conflict_state?.detection_count === 'number' ? turn.conflict_state.detection_count : null,
+      conflicting_files: Array.isArray(conflictError.conflicting_files) ? conflictError.conflicting_files : [],
+      accepted_since_turn_ids: Array.isArray(conflictError.accepted_since)
+        ? conflictError.accepted_since.map((entry) => entry?.turn_id).filter(Boolean)
+        : [],
+      overlap_ratio: typeof conflictError.overlap_ratio === 'number' ? conflictError.overlap_ratio : null,
+    });
+  }
+
+  return [...latestByTurn.values()].slice(0, 5);
+}
+
+function renderConflictPanel(state, events) {
+  const conflicts = collectConflictCards(state, events);
+  if (conflicts.length === 0) return '';
+
+  let html = `<div class="section"><h3>Conflicts</h3><div class="turn-list">`;
+  for (const conflict of conflicts) {
+    const detectedAt = formatTimestamp(conflict.detected_at);
+    const overlap = formatPercent(conflict.overlap_ratio);
+    html += `<div class="turn-card">
+      <div class="turn-header">
+        ${roleBadge(conflict.role_id)}
+        <span class="mono">${esc(conflict.turn_id)}</span>
+        ${statusBadge('conflicted')}
+      </div>
+      <div class="turn-detail"><span class="detail-label">Scope:</span> ${esc(conflict.state_label)}</div>`;
+
+    if (detectedAt) {
+      html += `<div class="turn-detail"><span class="detail-label">Detected:</span> ${esc(detectedAt)}</div>`;
+    }
+    if (conflict.conflicting_files.length > 0) {
+      html += `<div class="turn-detail"><span class="detail-label">Files:</span> <span class="mono">${conflict.conflicting_files.map((file) => esc(file)).join(', ')}</span></div>`;
+    }
+    if (conflict.accepted_since_turn_ids.length > 0) {
+      html += `<div class="turn-detail"><span class="detail-label">Accepted since:</span> <span class="mono">${conflict.accepted_since_turn_ids.map((turnId) => esc(turnId)).join(', ')}</span></div>`;
+    }
+    if (overlap) {
+      html += `<div class="turn-detail"><span class="detail-label">Overlap:</span> ${esc(overlap)}</div>`;
+    }
+    if (conflict.detection_count != null) {
+      html += `<div class="turn-detail"><span class="detail-label">Detection count:</span> ${esc(conflict.detection_count)}</div>`;
+    }
+
+    html += `</div>`;
+  }
+  html += `</div></div>`;
+  return html;
+}
+
 function renderContinuityPanel(continuity) {
   if (!continuity) return '';
 
@@ -306,7 +404,7 @@ function renderConnectorHealthPanel(connectorsPayload) {
 
 export { formatDuration, computeElapsed, formatTimestamp };
 
-export function render({ state, continuity, history, annotations, audit, connectors, coordinatorAudit = null, coordinatorAnnotations = null, liveMeta = null }) {
+export function render({ state, continuity, history, events = null, annotations, audit, connectors, coordinatorAudit = null, coordinatorAnnotations = null, liveMeta = null }) {
   if (!state) {
     return `<div class="placeholder"><h2>No Run</h2><p>No governed run found. Start one with <code class="mono">agentxchain init --governed</code></p></div>`;
   }
@@ -330,6 +428,7 @@ export function render({ state, continuity, history, annotations, audit, connect
 
   html += renderContinuityPanel(continuity);
   html += renderConnectorHealthPanel(connectors);
+  html += renderConflictPanel(state, events);
 
   // Active turns
   if (activeTurns.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxchain",
-  "version": "2.107.0",
+  "version": "2.108.0",
   "description": "CLI for AgentXchain — governed multi-agent software delivery",
   "type": "module",
   "bin": {

package/src/commands/events.js

@@ -61,6 +61,9 @@ function printEvent(evt) {
   const runId = evt.run_id ? evt.run_id.slice(0, 12) : '—';
   const phase = evt.phase || '—';
   const turnInfo = evt.turn?.role_id ? ` [${evt.turn.role_id}]` : '';
+  const conflictDetail = evt.event_type === 'turn_conflicted'
+    ? ` — ${formatConflictDetail(evt)}`
+    : '';
   const rejectionDetail = evt.event_type === 'turn_rejected' && evt.payload?.reason
     ? ` — ${evt.payload.reason}${evt.payload.failed_stage ? ` (${evt.payload.failed_stage})` : ''}`
     : '';
@@ -70,7 +73,34 @@ function printEvent(evt) {
   const gateFailedDetail = evt.event_type === 'gate_failed' && evt.payload?.from_phase
     ? ` ${evt.payload.from_phase} → ${evt.payload.to_phase || '?'}${evt.payload.reasons?.length ? ` — ${evt.payload.reasons[0]}` : ''}${evt.payload.gate_id ? ` (${evt.payload.gate_id})` : ''}`
     : '';
-  console.log(`${chalk.dim(ts)}  ${type}  ${chalk.cyan(runId)}  ${phase}${turnInfo}${rejectionDetail}${phaseTransitionDetail}${gateFailedDetail}`);
+  console.log(`${chalk.dim(ts)}  ${type}  ${chalk.cyan(runId)}  ${phase}${turnInfo}${conflictDetail}${rejectionDetail}${phaseTransitionDetail}${gateFailedDetail}`);
+}
+
+function formatConflictDetail(evt) {
+  const payload = evt.payload || {};
+  const fileSummary = summarizeList(payload.conflicting_files, 3) || 'unknown files';
+  const overlapRatio = typeof payload.overlap_ratio === 'number'
+    ? `${Math.round(payload.overlap_ratio * 100)}% overlap`
+    : null;
+  const detectionCount = Number.isInteger(payload.detection_count)
+    ? `detection ${payload.detection_count}`
+    : null;
+  const turnSummary = summarizeList(payload.accepted_since_turn_ids, 2);
+  const parts = [fileSummary, overlapRatio, detectionCount];
+  if (turnSummary) {
+    parts.push(`accepted since ${turnSummary}`);
+  }
+  if (evt.status === 'blocked') {
+    parts.push('run blocked');
+  }
+  return parts.filter(Boolean).join(' | ');
+}
+
+function summarizeList(items, limit) {
+  if (!Array.isArray(items) || items.length === 0) return '';
+  const shown = items.slice(0, limit).join(', ');
+  if (items.length <= limit) return shown;
+  return `${shown} +${items.length - limit} more`;
 }
 
 function colorEventType(type) {
@@ -81,12 +111,14 @@ function colorEventType(type) {
     turn_dispatched: chalk.blue,
     turn_accepted: chalk.green,
     turn_rejected: chalk.yellow,
+    turn_conflicted: chalk.redBright,
     phase_entered: chalk.magenta,
     escalation_raised: chalk.red.bold,
     escalation_resolved: chalk.green,
     gate_pending: chalk.yellow,
     gate_approved: chalk.green,
     gate_failed: chalk.red,
+    budget_exceeded_warn: chalk.yellowBright,
   };
   const colorFn = colors[type] || chalk.white;
   return colorFn(pad(type, 22));

package/src/lib/governed-state.js

@@ -2652,11 +2652,32 @@ function _acceptGovernedTurnLocked(root, config, opts) {
       },
     });
 
+    // DEC-RUN-LOOP-CONFLICT-002: Persist turn_conflicted as a durable run event
+    emitRunEvent(root, 'turn_conflicted', {
+      run_id: state.run_id,
+      phase: state.phase,
+      status: updatedState.status,
+      turn: { turn_id: currentTurn.turn_id, role_id: currentTurn.assigned_role },
+      payload: {
+        error_code: 'conflict',
+        detection_count: detectionCount,
+        conflicting_files: conflict.conflicting_files,
+        accepted_since_turn_ids: conflict.accepted_since.map(entry => entry.turn_id),
+        overlap_ratio: conflict.overlap_ratio,
+      },
+    });
+
     writeState(root, updatedState);
 
     // DEC-RHTR-SPEC: Record conflict_loop blocked outcome in cross-run history (non-fatal)
     if (updatedState.status === 'blocked') {
       recordRunHistory(root, updatedState, config, 'blocked');
+      // DEC-CONFLICT-NOTIFY-001: Emit run_blocked notification for conflict-loop exhaustion
+      emitBlockedNotification(root, config, updatedState, {
+        category: 'conflict_loop',
+        blockedOn: updatedState.blocked_on,
+        recovery: updatedState.blocked_reason?.recovery || null,
+      }, currentTurn);
     }
 
     return {

package/src/lib/report.js

@@ -119,6 +119,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 +171,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 +182,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 +225,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 +236,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':
@@ -480,14 +542,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;
@@ -2420,7 +2489,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>`);

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

@@ -340,6 +340,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 +392,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 +441,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 };
     }