agentxchain 2.89.0 → 2.90.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxchain",
-  "version": "2.89.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}`);
     }