agentxchain 2.88.0 → 2.90.0

package/dashboard/app.js

@@ -12,6 +12,7 @@ import { render as renderBlocked } from './components/blocked.js';
 import { render as renderGate } from './components/gate.js';
 import { render as renderInitiative } from './components/initiative.js';
 import { render as renderCrossRepo } from './components/cross-repo.js';
+import { render as renderDelegations } from './components/delegations.js';
 import { render as renderBlockers } from './components/blockers.js';
 import { render as renderArtifacts } from './components/artifacts.js';
 import { render as renderRunHistory } from './components/run-history.js';
@@ -20,6 +21,7 @@ import { render as renderCoordinatorTimeouts } from './components/coordinator-ti
 
 const VIEWS = {
   timeline: { fetch: ['state', 'continuity', 'history', 'audit', 'annotations', 'connectors', 'coordinatorAudit', 'coordinatorAnnotations'], render: renderTimeline },
+  delegations: { fetch: ['state', 'history'], render: renderDelegations },
   ledger: { fetch: ['state', 'ledger', 'coordinatorState', 'coordinatorLedger'], render: renderLedger },
   hooks: { fetch: ['audit', 'annotations', 'coordinatorAudit', 'coordinatorAnnotations'], render: renderHooks },
   blocked: { fetch: ['state', 'audit', 'coordinatorState', 'coordinatorAudit'], render: renderBlocked },

package/dashboard/components/delegations.js

@@ -0,0 +1,237 @@
+function esc(str) {
+  if (str == null) return '';
+  return String(str)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function badge(label, color = 'var(--text-dim)') {
+  return `<span class="badge" style="color:${color};border-color:${color}">${esc(label)}</span>`;
+}
+
+function statusColor(status) {
+  const colors = {
+    pending: 'var(--text-dim)',
+    active: 'var(--yellow)',
+    completed: 'var(--green)',
+    failed: 'var(--red)',
+    review_pending: 'var(--yellow)',
+    reviewed: 'var(--accent)',
+    unknown: 'var(--text-dim)',
+  };
+  return colors[status] || 'var(--text-dim)';
+}
+
+function summarizeReview(results) {
+  const counts = { completed: 0, failed: 0, other: 0 };
+  for (const result of results || []) {
+    if (result?.status === 'completed') counts.completed += 1;
+    else if (result?.status === 'failed') counts.failed += 1;
+    else counts.other += 1;
+  }
+  return counts;
+}
+
+function normalizeDelegationChain(parentEntry, state, history) {
+  const issued = Array.isArray(parentEntry?.delegations_issued) ? parentEntry.delegations_issued : [];
+  const pendingQueue = Array.isArray(state?.delegation_queue)
+    ? state.delegation_queue.filter((entry) => entry.parent_turn_id === parentEntry.turn_id)
+    : [];
+  const pendingReview = state?.pending_delegation_review?.parent_turn_id === parentEntry.turn_id
+    ? state.pending_delegation_review
+    : null;
+  const reviewEntry = Array.isArray(history)
+    ? history.find((entry) => entry?.delegation_review?.parent_turn_id === parentEntry.turn_id)
+    : null;
+
+  const delegations = issued.map((item) => {
+    const queueEntry = pendingQueue.find((entry) => entry.delegation_id === item.id) || null;
+    const reviewResult = Array.isArray(pendingReview?.delegation_results)
+      ? pendingReview.delegation_results.find((entry) => entry.delegation_id === item.id)
+      : null;
+    const reviewHistoryResult = Array.isArray(reviewEntry?.delegation_review?.results)
+      ? reviewEntry.delegation_review.results.find((entry) => entry.delegation_id === item.id)
+      : null;
+    const childTurn = Array.isArray(history)
+      ? history.find((entry) => entry?.delegation_context?.delegation_id === item.id)
+      : null;
+
+    return {
+      delegation_id: item.id,
+      to_role: item.to_role,
+      charter: item.charter,
+      acceptance_contract: Array.isArray(item.acceptance_contract) ? item.acceptance_contract : [],
+      status: queueEntry?.status
+        || reviewResult?.status
+        || reviewHistoryResult?.status
+        || childTurn?.status
+        || 'unknown',
+      child_turn_id: queueEntry?.child_turn_id
+        || reviewResult?.child_turn_id
+        || reviewHistoryResult?.child_turn_id
+        || childTurn?.turn_id
+        || null,
+      summary: reviewResult?.summary
+        || reviewHistoryResult?.summary
+        || childTurn?.summary
+        || null,
+      files_changed: reviewResult?.files_changed
+        || reviewHistoryResult?.files_changed
+        || childTurn?.files_changed
+        || [],
+    };
+  });
+
+  let chainStatus = 'unknown';
+  if (pendingReview) chainStatus = 'review_pending';
+  else if (pendingQueue.length > 0) chainStatus = delegations.some((entry) => entry.status === 'active') ? 'active' : 'pending';
+  else if (reviewEntry) chainStatus = 'reviewed';
+  else if (delegations.length > 0) chainStatus = delegations.every((entry) => entry.status === 'completed' || entry.status === 'failed') ? 'reviewed' : 'unknown';
+
+  return {
+    parent_turn_id: parentEntry.turn_id,
+    parent_role: parentEntry.role,
+    parent_summary: parentEntry.summary || '(no summary)',
+    accepted_at: parentEntry.accepted_at || null,
+    status: chainStatus,
+    delegations,
+    pending_review: pendingReview,
+    review_entry: reviewEntry,
+  };
+}
+
+function renderAcceptanceContract(items) {
+  if (!Array.isArray(items) || items.length === 0) {
+    return '<span class="turn-detail">No acceptance contract recorded.</span>';
+  }
+  return `<ul>${items.map((item) => `<li>${esc(item)}</li>`).join('')}</ul>`;
+}
+
+function renderChainCard(chain) {
+  const reviewResults = chain.pending_review?.delegation_results
+    || chain.review_entry?.delegation_review?.results
+    || [];
+  const reviewCounts = summarizeReview(reviewResults);
+
+  let html = `<div class="turn-card">
+    <div class="turn-header">
+      ${badge(chain.parent_role || 'unknown', '#fb923c')}
+      <span class="mono">${esc(chain.parent_turn_id)}</span>
+      ${badge(chain.status.replace(/_/g, ' '), statusColor(chain.status))}
+    </div>
+    <div class="turn-summary">${esc(chain.parent_summary)}</div>`;
+
+  if (chain.accepted_at) {
+    html += `<div class="turn-detail"><span class="detail-label">Accepted:</span> ${esc(chain.accepted_at)}</div>`;
+  }
+
+  html += `<div class="turn-detail"><span class="detail-label">Delegations:</span> ${esc(chain.delegations.length)}</div>`;
+
+  if (chain.delegations.length > 0) {
+    html += `<div class="turn-list">`;
+    for (const delegation of chain.delegations) {
+      html += `<div class="turn-card">
+        <div class="turn-header">
+          <span class="mono">${esc(delegation.delegation_id)}</span>
+          ${badge(delegation.to_role || 'unknown', '#38bdf8')}
+          ${badge(delegation.status, statusColor(delegation.status))}
+        </div>
+        <div class="turn-detail"><span class="detail-label">Charter:</span> ${esc(delegation.charter || '(none)')}</div>
+        <div class="turn-detail"><span class="detail-label">Acceptance Contract:</span>${renderAcceptanceContract(delegation.acceptance_contract)}</div>`;
+      if (delegation.child_turn_id) {
+        html += `<div class="turn-detail"><span class="detail-label">Child Turn:</span> <span class="mono">${esc(delegation.child_turn_id)}</span></div>`;
+      }
+      if (delegation.summary) {
+        html += `<div class="turn-detail"><span class="detail-label">Outcome:</span> ${esc(delegation.summary)}</div>`;
+      }
+      if (Array.isArray(delegation.files_changed) && delegation.files_changed.length > 0) {
+        html += `<div class="turn-detail"><span class="detail-label">Files:</span> <span class="mono">${delegation.files_changed.map((item) => esc(item)).join(', ')}</span></div>`;
+      }
+      html += `</div>`;
+    }
+    html += `</div>`;
+  }
+
+  if (chain.pending_review) {
+    html += `<div class="turn-detail"><span class="detail-label">Review Pending:</span> ${esc(chain.pending_review.parent_role)} is reviewing ${reviewResults.length} delegated result${reviewResults.length === 1 ? '' : 's'}.</div>`;
+  } else if (chain.review_entry) {
+    html += `<div class="turn-detail"><span class="detail-label">Review Turn:</span> <span class="mono">${esc(chain.review_entry.turn_id)}</span></div>`;
+  }
+
+  if (reviewResults.length > 0) {
+    html += `<div class="turn-detail"><span class="detail-label">Review Summary:</span> ${reviewCounts.completed} completed, ${reviewCounts.failed} failed</div>`;
+  }
+
+  html += `</div>`;
+  return html;
+}
+
+export function render({ state, history }) {
+  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>`;
+  }
+
+  const historyEntries = Array.isArray(history) ? history : [];
+  const parentTurns = historyEntries
+    .filter((entry) => Array.isArray(entry?.delegations_issued) && entry.delegations_issued.length > 0)
+    .reverse();
+  const chains = parentTurns.map((entry) => normalizeDelegationChain(entry, state, historyEntries));
+  const queue = Array.isArray(state.delegation_queue) ? state.delegation_queue : [];
+  const pendingReview = state.pending_delegation_review || null;
+
+  if (chains.length === 0 && queue.length === 0 && !pendingReview) {
+    return `<div class="placeholder"><h2>No Delegations</h2><p>This run has no delegation chains yet. Delegation state will appear here once a turn emits a <code class="mono">delegations</code> array.</p></div>`;
+  }
+
+  let html = `<div class="delegations-view">`;
+
+  html += `<div class="run-header">
+    <div class="run-meta">
+      <span class="mono run-id">${esc(state.run_id || 'unknown')}</span>
+      ${badge(state.status || 'unknown', statusColor(state.status || 'unknown'))}
+      <span class="phase-label">Phase: <strong>${esc(state.phase || 'unknown')}</strong></span>
+      <span class="turn-count">${chains.length} chain${chains.length === 1 ? '' : 's'} recorded</span>
+    </div>
+  </div>`;
+
+  if (queue.length > 0 || pendingReview) {
+    html += `<div class="section"><h3>Live Delegation State</h3><div class="turn-list">`;
+    if (queue.length > 0) {
+      html += `<div class="turn-card">
+        <div class="turn-header">
+          <span class="mono">delegation_queue</span>
+          ${badge(`${queue.length} item${queue.length === 1 ? '' : 's'}`, statusColor('pending'))}
+        </div>`;
+      for (const entry of queue) {
+        html += `<div class="turn-detail"><span class="detail-label">${esc(entry.delegation_id)}:</span> ${esc(entry.parent_role || 'unknown')} → ${esc(entry.to_role || 'unknown')} (${esc(entry.status || 'unknown')})</div>`;
+      }
+      html += `</div>`;
+    }
+    if (pendingReview) {
+      const counts = summarizeReview(pendingReview.delegation_results);
+      html += `<div class="turn-card">
+        <div class="turn-header">
+          <span class="mono">${esc(pendingReview.parent_turn_id)}</span>
+          ${badge('review pending', statusColor('review_pending'))}
+        </div>
+        <div class="turn-detail"><span class="detail-label">Parent Role:</span> ${esc(pendingReview.parent_role || 'unknown')}</div>
+        <div class="turn-detail"><span class="detail-label">Results:</span> ${counts.completed} completed, ${counts.failed} failed</div>
+      </div>`;
+    }
+    html += `</div></div>`;
+  }
+
+  html += `<div class="section"><h3>Delegation Chains</h3>`;
+  if (chains.length === 0) {
+    html += `<div class="placeholder compact"><p>No completed delegation chains recorded yet.</p></div>`;
+  } else {
+    html += `<div class="turn-list">${chains.map((chain) => renderChainCard(chain)).join('')}</div>`;
+  }
+  html += `</div>`;
+
+  html += `</div>`;
+  return html;
+}

package/dashboard/components/timeline.js

@@ -187,6 +187,23 @@ function renderTurnDetailPanel(turnId, annotations, audit, coordinatorAnnotation
   return html;
 }
 
+function renderDelegationIssued(entry) {
+  const issued = Array.isArray(entry?.delegations_issued) ? entry.delegations_issued : [];
+  if (issued.length === 0) return '';
+  return `<div class="turn-detail"><span class="detail-label">Delegated:</span> ${issued.map((item) => `${esc(item.id)} → ${esc(item.to_role)}`).join(', ')}</div>`;
+}
+
+function renderDelegationContext(context) {
+  if (!context) return '';
+  return `<div class="turn-detail"><span class="detail-label">Delegation:</span> <span class="mono">${esc(context.delegation_id)}</span> from ${esc(context.parent_role || 'unknown')} — ${esc(context.charter || '(no charter)')}</div>`;
+}
+
+function renderDelegationReview(review) {
+  if (!review) return '';
+  const resultCount = Array.isArray(review.results) ? review.results.length : 0;
+  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 renderContinuityPanel(continuity) {
   if (!continuity) return '';
 
@@ -323,6 +340,8 @@ export function render({ state, continuity, history, annotations, audit, connect
           <span class="turn-status">${esc(turn.status || 'assigned')}</span>
           ${elapsedStr ? `<span class="turn-timing">Elapsed: ${esc(elapsedStr)}</span>` : ''}
         </div>
+        ${renderDelegationContext(turn.delegation_context)}
+        ${renderDelegationReview(turn.delegation_review)}
       </div>`;
     }
     html += `</div></div>`;
@@ -355,6 +374,10 @@ export function render({ state, continuity, history, annotations, audit, connect
         html += `<div class="turn-summary">${esc(entry.summary)}</div>`;
       }
 
+      html += renderDelegationIssued(entry);
+      html += renderDelegationContext(entry.delegation_context);
+      html += renderDelegationReview(entry.delegation_review);
+
       if (files.length > 0) {
         html += `<div class="turn-detail"><span class="detail-label">Files:</span> <span class="mono">${files.map(f => esc(f)).join(', ')}</span></div>`;
       }

package/dashboard/index.html

@@ -377,6 +377,7 @@
     <a href="#initiative">Initiative</a>
     <a href="#cross-repo">Cross-Repo</a>
     <a href="#timeline" class="active">Timeline</a>
+    <a href="#delegations">Delegations</a>
     <a href="#ledger">Decisions</a>
     <a href="#hooks">Hooks</a>
     <a href="#blocked">Blocked</a>

package/package.json

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

package/src/lib/coordinator-acceptance.js

@@ -267,7 +267,7 @@ function evaluateBarrierEffects(workspacePath, state, config, repoId, workstream
         snapshotChanged = true;
       }
     }
-    if (barrier.type === 'interface_alignment') {
+    if (barrier.type === 'interface_alignment' || barrier.type === 'named_decisions') {
       const satisfiedRepos = getAlignedReposForBarrier(barrier, history);
       if (JSON.stringify(barrier.satisfied_repos || []) !== JSON.stringify(satisfiedRepos)) {
         barrier.satisfied_repos = satisfiedRepos;

package/src/lib/coordinator-barriers.js

@@ -41,7 +41,7 @@ export function getAcceptedReposForWorkstream(history, workstreamId, requiredRep
 
 export function getAlignedReposForBarrier(barrier, history) {
   const requiredRepos = Array.isArray(barrier.required_repos) ? barrier.required_repos : [];
-  const alignmentDecisionIds = barrier.alignment_decision_ids || {};
+  const alignmentDecisionIds = barrier.required_decision_ids_by_repo || barrier.alignment_decision_ids || {};
   const { repoDecisionIds } = collectAcceptedDecisionIds(history, barrier.workstream_id, requiredRepos);
   const alignedRepos = [];
 
@@ -105,6 +105,7 @@ export function computeBarrierStatus(barrier, history, config) {
       return computeOrderedRepoSequenceStatus(barrier, history, config);
 
     case 'interface_alignment':
+    case 'named_decisions':
       return computeInterfaceAlignmentStatus(barrier, history);
 
     case 'shared_human_gate':

package/src/lib/coordinator-config.js

@@ -11,6 +11,7 @@ const VALID_PHASE_NAME = /^[a-z][a-z0-9_-]*$/;
 const VALID_BARRIER_TYPES = new Set([
   'all_repos_accepted',
   'interface_alignment',
+  'named_decisions',
   'ordered_repo_sequence',
   'shared_human_gate',
 ]);
@@ -151,34 +152,30 @@ function validateWorkstreams(raw, repoIds, errors) {
       );
     }
 
-    validateInterfaceAlignment(workstreamId, workstream, errors);
+    validateDecisionRequirementBarrier(workstreamId, workstream, errors);
   }
 
   detectWorkstreamCycles(raw.workstreams, errors);
   return workstreamIds;
 }
 
-function validateInterfaceAlignment(workstreamId, workstream, errors) {
-  if (workstream.completion_barrier !== 'interface_alignment') {
-    return;
-  }
-
-  const alignment = workstream.interface_alignment;
-  if (!alignment || typeof alignment !== 'object' || Array.isArray(alignment)) {
+function validateDecisionIdsByRepo(workstreamId, workstream, errors, sectionName, errorPrefix) {
+  const section = workstream[sectionName];
+  if (!section || typeof section !== 'object' || Array.isArray(section)) {
     pushError(
       errors,
-      'workstream_interface_alignment_invalid',
-      `workstream "${workstreamId}" with completion_barrier "interface_alignment" must declare interface_alignment.decision_ids_by_repo`,
+      `${errorPrefix}_invalid`,
+      `workstream "${workstreamId}" with completion_barrier "${workstream.completion_barrier}" must declare ${sectionName}.decision_ids_by_repo`,
     );
     return;
   }
 
-  const byRepo = alignment.decision_ids_by_repo;
+  const byRepo = section.decision_ids_by_repo;
   if (!byRepo || typeof byRepo !== 'object' || Array.isArray(byRepo)) {
     pushError(
       errors,
-      'workstream_interface_alignment_decisions_invalid',
-      `workstream "${workstreamId}" interface_alignment.decision_ids_by_repo must be an object`,
+      `${errorPrefix}_decisions_invalid`,
+      `workstream "${workstreamId}" ${sectionName}.decision_ids_by_repo must be an object`,
     );
     return;
   }
@@ -190,8 +187,8 @@ function validateInterfaceAlignment(workstreamId, workstream, errors) {
     if (!(repoId in byRepo)) {
       pushError(
         errors,
-        'workstream_interface_alignment_repo_missing',
-        `workstream "${workstreamId}" must declare interface_alignment.decision_ids_by_repo["${repoId}"]`,
+        `${errorPrefix}_repo_missing`,
+        `workstream "${workstreamId}" must declare ${sectionName}.decision_ids_by_repo["${repoId}"]`,
       );
       continue;
     }
@@ -200,8 +197,8 @@ function validateInterfaceAlignment(workstreamId, workstream, errors) {
     if (!Array.isArray(decisionIds) || decisionIds.length === 0) {
       pushError(
         errors,
-        'workstream_interface_alignment_repo_invalid',
-        `workstream "${workstreamId}" interface_alignment.decision_ids_by_repo["${repoId}"] must be a non-empty array`,
+        `${errorPrefix}_repo_invalid`,
+        `workstream "${workstreamId}" ${sectionName}.decision_ids_by_repo["${repoId}"] must be a non-empty array`,
       );
       continue;
     }
@@ -211,16 +208,16 @@ function validateInterfaceAlignment(workstreamId, workstream, errors) {
       if (typeof decisionId !== 'string' || !/^DEC-\d+$/.test(decisionId)) {
         pushError(
           errors,
-          'workstream_interface_alignment_decision_invalid',
-          `workstream "${workstreamId}" interface_alignment decision "${decisionId}" for repo "${repoId}" must match DEC-NNN`,
+          `${errorPrefix}_decision_invalid`,
+          `workstream "${workstreamId}" ${sectionName} decision "${decisionId}" for repo "${repoId}" must match DEC-NNN`,
         );
         continue;
       }
       if (seen.has(decisionId)) {
         pushError(
           errors,
-          'workstream_interface_alignment_decision_duplicate',
-          `workstream "${workstreamId}" interface_alignment decision "${decisionId}" is duplicated for repo "${repoId}"`,
+          `${errorPrefix}_decision_duplicate`,
+          `workstream "${workstreamId}" ${sectionName} decision "${decisionId}" is duplicated for repo "${repoId}"`,
         );
         continue;
       }
@@ -232,13 +229,49 @@ function validateInterfaceAlignment(workstreamId, workstream, errors) {
     if (!repoIdSet.has(repoId)) {
       pushError(
         errors,
-        'workstream_interface_alignment_repo_unknown',
-        `workstream "${workstreamId}" interface_alignment references undeclared repo "${repoId}"`,
+        `${errorPrefix}_repo_unknown`,
+        `workstream "${workstreamId}" ${sectionName} references undeclared repo "${repoId}"`,
       );
     }
   }
 }
 
+function validateDecisionRequirementBarrier(workstreamId, workstream, errors) {
+  if (workstream.completion_barrier === 'interface_alignment') {
+    validateDecisionIdsByRepo(
+      workstreamId,
+      workstream,
+      errors,
+      'interface_alignment',
+      'workstream_interface_alignment',
+    );
+    return;
+  }
+
+  if (workstream.completion_barrier === 'named_decisions') {
+    validateDecisionIdsByRepo(
+      workstreamId,
+      workstream,
+      errors,
+      'named_decisions',
+      'workstream_named_decisions',
+    );
+  }
+}
+
+function normalizeDecisionIdsByRepo(section) {
+  return section?.decision_ids_by_repo
+    ? {
+        decision_ids_by_repo: Object.fromEntries(
+          Object.entries(section.decision_ids_by_repo).map(([repoId, decisionIds]) => [
+            repoId,
+            Array.isArray(decisionIds) ? [...new Set(decisionIds)] : [],
+          ]),
+        ),
+      }
+    : null;
+}
+
 function detectWorkstreamCycles(workstreams, errors) {
   const visiting = new Set();
   const visited = new Set();
@@ -451,16 +484,8 @@ export function normalizeCoordinatorConfig(raw) {
           entry_repo: workstream.entry_repo,
           depends_on: Array.isArray(workstream.depends_on) ? [...new Set(workstream.depends_on)] : [],
           completion_barrier: workstream.completion_barrier,
-          interface_alignment: workstream.interface_alignment?.decision_ids_by_repo
-            ? {
-                decision_ids_by_repo: Object.fromEntries(
-                  Object.entries(workstream.interface_alignment.decision_ids_by_repo).map(([repoId, decisionIds]) => [
-                    repoId,
-                    Array.isArray(decisionIds) ? [...new Set(decisionIds)] : [],
-                  ]),
-                ),
-              }
-            : null,
+          interface_alignment: normalizeDecisionIdsByRepo(workstream.interface_alignment),
+          named_decisions: normalizeDecisionIdsByRepo(workstream.named_decisions),
         },
       ]),
     ),

package/src/lib/coordinator-recovery.js

@@ -366,7 +366,7 @@ export function resyncFromRepoAuthority(workspacePath, state, config) {
         barriersChanged = true;
       }
     }
-    if (barrier.type === 'interface_alignment') {
+    if (barrier.type === 'interface_alignment' || barrier.type === 'named_decisions') {
       const satisfiedRepos = getAlignedReposForBarrier(barrier, fullHistory);
       if (JSON.stringify(barrier.satisfied_repos || []) !== JSON.stringify(satisfiedRepos)) {
         barrier.satisfied_repos = satisfiedRepos;

package/src/lib/coordinator-state.js

@@ -112,6 +112,9 @@ function bootstrapBarriers(config) {
       status: 'pending',
       required_repos: [...workstream.repos],
       satisfied_repos: [],
+      required_decision_ids_by_repo: workstream.named_decisions?.decision_ids_by_repo
+        || workstream.interface_alignment?.decision_ids_by_repo
+        || null,
       alignment_decision_ids: workstream.interface_alignment?.decision_ids_by_repo || null,
       created_at: new Date().toISOString(),
     };

package/src/lib/cross-repo-context.js

@@ -61,6 +61,7 @@ function collectActiveBarriers(barriers, workstreamIds, targetRepoId) {
       type: barrier.type || 'unknown',
       status: barrier.status,
       notes: barrier.notes || null,
+      required_decision_ids_by_repo: barrier.required_decision_ids_by_repo || barrier.alignment_decision_ids || null,
       alignment_decision_ids: barrier.alignment_decision_ids || null,
     }));
 }
@@ -78,13 +79,13 @@ function buildRequiredFollowups(workstreamId, dependencyIds, upstreamAcceptances
 
   for (const barrier of activeBarriers) {
     if (
-      barrier.type === 'interface_alignment'
-      && barrier.alignment_decision_ids
-      && Array.isArray(barrier.alignment_decision_ids[targetRepoId])
-      && barrier.alignment_decision_ids[targetRepoId].length > 0
+      (barrier.type === 'interface_alignment' || barrier.type === 'named_decisions')
+      && barrier.required_decision_ids_by_repo
+      && Array.isArray(barrier.required_decision_ids_by_repo[targetRepoId])
+      && barrier.required_decision_ids_by_repo[targetRepoId].length > 0
     ) {
       followups.push(
-        `Accept declared interface-alignment decisions for ${targetRepoId}: ${barrier.alignment_decision_ids[targetRepoId].join(', ')}.`,
+        `Accept declared decision requirements for ${targetRepoId}: ${barrier.required_decision_ids_by_repo[targetRepoId].join(', ')}.`,
       );
     }
 
@@ -146,12 +147,12 @@ function renderContextMarkdown(snapshot) {
     for (const barrier of snapshot.active_barriers) {
       let suffix = '';
       if (
-        barrier.type === 'interface_alignment'
-        && barrier.alignment_decision_ids
-        && Array.isArray(barrier.alignment_decision_ids[snapshot.target_repo_id])
-        && barrier.alignment_decision_ids[snapshot.target_repo_id].length > 0
+        (barrier.type === 'interface_alignment' || barrier.type === 'named_decisions')
+        && barrier.required_decision_ids_by_repo
+        && Array.isArray(barrier.required_decision_ids_by_repo[snapshot.target_repo_id])
+        && barrier.required_decision_ids_by_repo[snapshot.target_repo_id].length > 0
       ) {
-        suffix = ` Required decision IDs for ${snapshot.target_repo_id}: ${barrier.alignment_decision_ids[snapshot.target_repo_id].join(', ')}.`;
+        suffix = ` Required decision IDs for ${snapshot.target_repo_id}: ${barrier.required_decision_ids_by_repo[snapshot.target_repo_id].join(', ')}.`;
       }
       lines.push(`- ${barrier.barrier_id}: ${barrier.type} (${barrier.status})${suffix}`);
     }

package/src/lib/dispatch-bundle.js

@@ -244,6 +244,8 @@ function renderPrompt(role, roleId, turn, state, config, root) {
     lines.push('- Your artifact type should be `patch`.');
     if (runtimeType === 'api_proxy' || runtimeType === 'remote_agent') {
       lines.push('- **This runtime cannot write repo files directly.** When doing work, you MUST return proposed changes as structured JSON.');
+      lines.push('- For non-completion turns, set `artifact.type` to `patch`. Do NOT use `workspace` or `commit`.');
+      lines.push('- Use `artifact.type: "review"` only for completion-only final-phase turns that propose no file changes.');
       lines.push('- Include a `proposed_changes` array in your turn result with each file change (omit or set to `[]` on completion-only turns):');
       lines.push('  ```json');
       lines.push('  "proposed_changes": [');
@@ -396,6 +398,10 @@ function renderPrompt(role, roleId, turn, state, config, root) {
   if (role.write_authority === 'review_only') {
     lines.push('- `objections`: **must be non-empty** (challenge requirement for review_only roles)');
   }
+  if (role.write_authority === 'proposed' && (runtimeType === 'api_proxy' || runtimeType === 'remote_agent')) {
+    lines.push('- For `proposed` `api_proxy`/`remote_agent` turns with file changes, `artifact.type` must be `patch` and `proposed_changes` must be non-empty.');
+    lines.push('- Do NOT use `artifact.type: "workspace"` or `artifact.type: "commit"` on a `proposed` `api_proxy`/`remote_agent` turn.');
+  }
   // List valid phase names explicitly to prevent gate-name confusion
   const phaseNames = config.routing ? Object.keys(config.routing) : [];
   if (phaseNames.length > 0) {
@@ -1266,6 +1272,7 @@ function readLastHistoryEntry(root, warnings = []) {
 
 function buildTurnResultTemplate(state, turn, roleId, role) {
   const isReviewOnly = role.write_authority === 'review_only';
+  const isProposed = role.write_authority === 'proposed';
   return {
     schema_version: '1.0',
     run_id: state.run_id,
@@ -1306,13 +1313,24 @@ function buildTurnResultTemplate(state, turn, roleId, role) {
         : [{ command: '<exact command that was run>', exit_code: 0 }],
     },
     artifact: {
-      type: isReviewOnly ? 'review' : 'workspace',
-      ref: isReviewOnly ? null : 'git:dirty',
+      type: isReviewOnly ? 'review' : (isProposed ? 'patch' : 'workspace'),
+      ref: isReviewOnly ? null : (isProposed ? null : 'git:dirty'),
     },
     proposed_next_role: '<role_id that should act next>',
     phase_transition_request: null,
     run_completion_request: null,
     needs_human_reason: null,
+    ...(isProposed
+      ? {
+          proposed_changes: [
+            {
+              path: '<path/to/modified/file>',
+              action: 'create',
+              content: '<full file content>',
+            },
+          ],
+        }
+      : {}),
     cost: {
       input_tokens: 0,
       output_tokens: 0,

package/src/lib/export.js

@@ -166,6 +166,93 @@ function countDirectoryFiles(files, prefix) {
   return Object.keys(files).filter((path) => path.startsWith(`${prefix}/`)).length;
 }
 
+export function buildDelegationSummary(files) {
+  const historyData = files['.agentxchain/history.jsonl']?.data;
+  if (!Array.isArray(historyData)) {
+    return null;
+  }
+
+  // Index history entries by delegation-related fields
+  const parentTurns = new Map(); // parent_turn_id -> { role, delegations_issued }
+  const childTurns = new Map();  // delegation_id -> { child entry }
+  const reviewTurns = new Map(); // parent_turn_id -> { review entry }
+
+  for (const entry of historyData) {
+    if (entry.delegations_issued && Array.isArray(entry.delegations_issued)) {
+      parentTurns.set(entry.turn_id, {
+        role: entry.role,
+        delegations_issued: entry.delegations_issued,
+      });
+    }
+    if (entry.delegation_context) {
+      childTurns.set(entry.delegation_context.delegation_id, {
+        turn_id: entry.turn_id,
+        status: entry.status || 'completed',
+      });
+    }
+    if (entry.delegation_review) {
+      reviewTurns.set(entry.delegation_review.parent_turn_id, {
+        turn_id: entry.turn_id,
+        results: entry.delegation_review.results || [],
+      });
+    }
+  }
+
+  let totalDelegationsIssued = 0;
+  const delegationChains = [];
+
+  for (const [parentTurnId, parent] of parentTurns) {
+    totalDelegationsIssued += parent.delegations_issued.length;
+
+    const review = reviewTurns.get(parentTurnId);
+    const reviewResultsByDelegation = new Map();
+    if (review) {
+      for (const r of review.results) {
+        if (r.delegation_id) {
+          reviewResultsByDelegation.set(r.delegation_id, r);
+        }
+      }
+    }
+
+    const delegations = parent.delegations_issued.map((del) => {
+      const child = childTurns.get(del.id);
+      const reviewResult = reviewResultsByDelegation.get(del.id);
+      return {
+        delegation_id: del.id,
+        to_role: del.to_role,
+        charter: del.charter,
+        status: reviewResult?.status || child?.status || 'pending',
+        child_turn_id: child?.turn_id || null,
+      };
+    });
+
+    let outcome;
+    if (!review) {
+      outcome = 'pending';
+    } else {
+      const statuses = delegations.map((d) => d.status);
+      const allCompleted = statuses.every((s) => s === 'completed');
+      const allFailed = statuses.every((s) => s === 'failed');
+      if (allCompleted) outcome = 'completed';
+      else if (allFailed) outcome = 'failed';
+      else outcome = 'mixed';
+    }
+
+    delegationChains.push({
+      parent_turn_id: parentTurnId,
+      parent_role: parent.role,
+      delegations,
+      review_turn_id: review?.turn_id || null,
+      outcome,
+    });
+  }
+
+  return {
+    total_delegations_issued: totalDelegationsIssued,
+    delegation_chains: delegationChains,
+  };
+}
+
 function isGitRepo(root) {
   try {
     execSync('git rev-parse --is-inside-work-tree', {
@@ -317,6 +404,7 @@ export function buildRunExport(startDir = process.cwd()) {
         staging_artifact_files: countDirectoryFiles(files, '.agentxchain/staging'),
         intake_present: Object.keys(files).some((path) => path.startsWith('.agentxchain/intake/')),
         coordinator_present: Object.keys(files).some((path) => path.startsWith('.agentxchain/multirepo/')),
+        delegation_summary: buildDelegationSummary(files),
       },
       workspace: buildRunWorkspaceMetadata(root),
       files,

package/src/lib/governed-state.js

@@ -2628,6 +2628,35 @@ function _acceptGovernedTurnLocked(root, config, opts) {
     ...(currentTurn.started_at ? { started_at: currentTurn.started_at } : {}),
     accepted_at: now,
     ...(currentTurn.started_at ? { duration_ms: Math.max(0, new Date(now).getTime() - new Date(currentTurn.started_at).getTime()) } : {}),
+    ...(Array.isArray(turnResult.delegations) && turnResult.delegations.length > 0
+      ? {
+          delegations_issued: turnResult.delegations.map((delegation) => ({
+            id: delegation.id,
+            to_role: delegation.to_role,
+            charter: delegation.charter,
+            acceptance_contract: delegation.acceptance_contract,
+          })),
+        }
+      : {}),
+    ...(currentTurn.delegation_context
+      ? {
+          delegation_context: {
+            delegation_id: currentTurn.delegation_context.delegation_id,
+            parent_turn_id: currentTurn.delegation_context.parent_turn_id,
+            parent_role: currentTurn.delegation_context.parent_role,
+            charter: currentTurn.delegation_context.charter,
+            acceptance_contract: currentTurn.delegation_context.acceptance_contract,
+          },
+        }
+      : {}),
+    ...(currentTurn.delegation_review
+      ? {
+          delegation_review: {
+            parent_turn_id: currentTurn.delegation_review.parent_turn_id,
+            results: currentTurn.delegation_review.results,
+          },
+        }
+      : {}),
   };
   const nextHistoryEntries = [...historyEntries, historyEntry];
   // Build ledger entries for the journal

package/src/lib/report.js

@@ -1,8 +1,63 @@
 import { verifyExportArtifact } from './export-verifier.js';
+import { buildDelegationSummary } from './export.js';
 import { normalizeRunProvenance, summarizeRunProvenance } from './run-provenance.js';
 
 export const GOVERNANCE_REPORT_VERSION = '0.1';
 
+const VALID_DELEGATION_OUTCOMES = new Set(['completed', 'failed', 'mixed', 'pending']);
+
+function normalizeDelegationSummary(summary) {
+  if (!summary || typeof summary !== 'object' || Array.isArray(summary)) return null;
+  if (!Number.isInteger(summary.total_delegations_issued) || summary.total_delegations_issued < 0) return null;
+  if (!Array.isArray(summary.delegation_chains)) return null;
+
+  const chains = [];
+  for (const chain of summary.delegation_chains) {
+    if (!chain || typeof chain !== 'object' || Array.isArray(chain)) return null;
+    if (typeof chain.parent_turn_id !== 'string' || chain.parent_turn_id.length === 0) return null;
+    if (typeof chain.parent_role !== 'string' || chain.parent_role.length === 0) return null;
+    if (!Array.isArray(chain.delegations)) return null;
+    if (chain.review_turn_id !== null && (typeof chain.review_turn_id !== 'string' || chain.review_turn_id.length === 0)) return null;
+    if (!VALID_DELEGATION_OUTCOMES.has(chain.outcome)) return null;
+
+    const delegations = [];
+    for (const delegation of chain.delegations) {
+      if (!delegation || typeof delegation !== 'object' || Array.isArray(delegation)) return null;
+      if (typeof delegation.delegation_id !== 'string' || delegation.delegation_id.length === 0) return null;
+      if (typeof delegation.to_role !== 'string' || delegation.to_role.length === 0) return null;
+      if (typeof delegation.charter !== 'string') return null;
+      if (!['completed', 'failed', 'pending'].includes(delegation.status)) return null;
+      if (delegation.child_turn_id !== null && (typeof delegation.child_turn_id !== 'string' || delegation.child_turn_id.length === 0)) return null;
+      delegations.push({
+        delegation_id: delegation.delegation_id,
+        to_role: delegation.to_role,
+        charter: delegation.charter,
+        status: delegation.status,
+        child_turn_id: delegation.child_turn_id,
+      });
+    }
+
+    chains.push({
+      parent_turn_id: chain.parent_turn_id,
+      parent_role: chain.parent_role,
+      delegations,
+      review_turn_id: chain.review_turn_id,
+      outcome: chain.outcome,
+    });
+  }
+
+  return {
+    total_delegations_issued: summary.total_delegations_issued,
+    delegation_chains: chains,
+  };
+}
+
+function extractDelegationSummary(artifact) {
+  const fromSummary = normalizeDelegationSummary(artifact.summary?.delegation_summary);
+  if (fromSummary) return fromSummary;
+  return normalizeDelegationSummary(buildDelegationSummary(artifact.files || {}));
+}
+
 function yesNo(value) {
   return value ? 'yes' : 'no';
 }
@@ -846,6 +901,7 @@ function buildRunSubject(artifact) {
   const recoverySummary = extractRecoverySummary(artifact);
   const continuity = extractContinuityMetadata(artifact);
   const governanceEvents = extractGovernanceEventDigest(artifact);
+  const delegationSummary = extractDelegationSummary(artifact);
 
   return {
     kind: 'governed_run',
@@ -881,6 +937,7 @@ function buildRunSubject(artifact) {
       governance_events: governanceEvents,
       gate_failures: gateFailures,
       timeout_events: timeoutEvents,
+      delegation_summary: delegationSummary,
       hook_summary: hookSummary,
       gate_summary: gateSummary,
       intake_links: intakeLinks,
@@ -1174,6 +1231,17 @@ export function formatGovernanceReportText(report) {
       }
     }
 
+    if (run.delegation_summary?.delegation_chains?.length > 0) {
+      lines.push('', 'Delegation Summary:');
+      lines.push(`  Total delegations issued: ${run.delegation_summary.total_delegations_issued}`);
+      for (const chain of run.delegation_summary.delegation_chains) {
+        lines.push(`  - ${chain.parent_role} (${chain.parent_turn_id}) | outcome: ${chain.outcome} | review: ${chain.review_turn_id || 'pending'}`);
+        for (const delegation of chain.delegations) {
+          lines.push(`      ${delegation.delegation_id} -> ${delegation.to_role} | ${delegation.status} | child: ${delegation.child_turn_id || 'pending'} | ${delegation.charter}`);
+        }
+      }
+    }
+
     if (run.turns && run.turns.length > 0) {
       lines.push('', 'Turn Timeline:');
       for (let i = 0; i < run.turns.length; i++) {
@@ -1628,6 +1696,23 @@ export function formatGovernanceReportMarkdown(report) {
       }
     }
 
+    if (run.delegation_summary?.delegation_chains?.length > 0) {
+      lines.push('', '## Delegation Summary', '');
+      lines.push(`- Total delegations issued: ${run.delegation_summary.total_delegations_issued}`, '');
+      lines.push('| Parent Role | Parent Turn | Outcome | Review Turn | Delegation | Child Turn | Status | Charter |', '|-------------|-------------|---------|-------------|------------|------------|--------|---------|');
+      for (const chain of run.delegation_summary.delegation_chains) {
+        for (let i = 0; i < chain.delegations.length; i++) {
+          const delegation = chain.delegations[i];
+          const parentRole = i === 0 ? chain.parent_role : '';
+          const parentTurn = i === 0 ? `\`${chain.parent_turn_id}\`` : '';
+          const outcome = i === 0 ? `\`${chain.outcome}\`` : '';
+          const reviewTurn = i === 0 ? `\`${chain.review_turn_id || 'pending'}\`` : '';
+          const charter = delegation.charter.replace(/\|/g, '\\|');
+          lines.push(`| ${parentRole} | ${parentTurn} | ${outcome} | ${reviewTurn} | \`${delegation.delegation_id}\` → \`${delegation.to_role}\` | \`${delegation.child_turn_id || 'pending'}\` | \`${delegation.status}\` | ${charter} |`);
+        }
+      }
+    }
+
     if (run.turns && run.turns.length > 0) {
       lines.push('', '## Turn Timeline', '', '| # | Role | Phase | Summary | Files | Cost | Time |', '|---|------|-------|---------|-------|------|------|');
       for (let i = 0; i < run.turns.length; i++) {

package/src/lib/token-budget.js

@@ -18,6 +18,7 @@ const SEPARATOR = '\n\n---\n\n';
 const SYSTEM_PROMPT = [
   'You are acting as a governed agent in an AgentXchain protocol run.',
   'Your task and rules are described in the user message.',
+  'You MUST obey the write-authority-specific rules in the prompt exactly.',
   'You MUST respond with a valid JSON object matching the turn result schema provided in the prompt.',
   'Do NOT wrap the JSON in markdown code fences. Respond with raw JSON only.',
 ].join('\n');