agentxchain 2.92.0 → 2.94.0

package/src/lib/schemas/turn-result.schema.json

@@ -76,6 +76,16 @@
           "rationale": {
             "type": "string",
             "minLength": 1
+          },
+          "durability": {
+            "type": "string",
+            "enum": ["run", "repo"],
+            "description": "Decision persistence scope. 'run' (default) dies with the run; 'repo' persists across runs as a binding constraint."
+          },
+          "overrides": {
+            "type": "string",
+            "pattern": "^DEC-\\d+$",
+            "description": "ID of an active repo-durable decision this decision supersedes."
           }
         }
       }
@@ -258,6 +268,16 @@
             "items": { "type": "string", "minLength": 1 },
             "minItems": 1,
             "description": "What the delegate must achieve for this delegation to be considered complete."
+          },
+          "required_decision_ids": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "pattern": "^DEC-\\d+$"
+            },
+            "minItems": 1,
+            "uniqueItems": true,
+            "description": "Optional named decisions the delegated child must emit before the parent review turn may advance phase/run lifecycle."
           }
         }
       }

package/src/lib/turn-result-validator.js

@@ -263,6 +263,16 @@ function validateSchema(tr) {
     }
   }
 
+  if ('delegations' in tr) {
+    if (!Array.isArray(tr.delegations)) {
+      errors.push('delegations must be an array.');
+    } else {
+      for (let i = 0; i < tr.delegations.length; i++) {
+        errors.push(...validateDelegation(tr.delegations[i], i));
+      }
+    }
+  }
+
   errors.push(...collectUnfilledTemplatePlaceholderErrors(tr));
 
   return errors;
@@ -325,6 +335,8 @@ function checkPlaceholder(errors, fieldPath, value) {
   }
 }
 
+const VALID_DURABILITIES = ['run', 'repo'];
+
 function validateDecision(dec, index) {
   const errors = [];
   const prefix = `decisions[${index}]`;
@@ -344,6 +356,17 @@ function validateDecision(dec, index) {
   if (typeof dec.rationale !== 'string' || !dec.rationale.trim()) {
     errors.push(`${prefix}.rationale must be a non-empty string.`);
   }
+  if (dec.durability !== undefined && !VALID_DURABILITIES.includes(dec.durability)) {
+    errors.push(`${prefix}.durability must be one of: ${VALID_DURABILITIES.join(', ')}.`);
+  }
+  if (dec.overrides !== undefined) {
+    if (typeof dec.overrides !== 'string' || !/^DEC-\d+$/.test(dec.overrides)) {
+      errors.push(`${prefix}.overrides must match pattern DEC-NNN.`);
+    }
+    if (dec.overrides === dec.id) {
+      errors.push(`${prefix}.overrides cannot reference itself.`);
+    }
+  }
   return errors;
 }
 
@@ -369,6 +392,54 @@ function validateObjection(obj, index) {
   return errors;
 }
 
+function validateDelegation(del, index) {
+  const errors = [];
+  const prefix = `delegations[${index}]`;
+
+  if (del === null || typeof del !== 'object' || Array.isArray(del)) {
+    return [`${prefix} must be an object.`];
+  }
+  if (typeof del.id !== 'string' || !/^del-\d{3}$/.test(del.id)) {
+    errors.push(`${prefix}.id must match pattern del-NNN.`);
+  }
+  if (typeof del.to_role !== 'string' || !/^[a-z0-9_-]+$/.test(del.to_role)) {
+    errors.push(`${prefix}.to_role must match pattern ^[a-z0-9_-]+$.`);
+  }
+  if (typeof del.charter !== 'string' || !del.charter.trim()) {
+    errors.push(`${prefix}.charter must be a non-empty string.`);
+  }
+  if (!Array.isArray(del.acceptance_contract) || del.acceptance_contract.length === 0) {
+    errors.push(`${prefix}.acceptance_contract must be a non-empty array.`);
+  } else {
+    for (let i = 0; i < del.acceptance_contract.length; i++) {
+      if (typeof del.acceptance_contract[i] !== 'string' || !del.acceptance_contract[i].trim()) {
+        errors.push(`${prefix}.acceptance_contract[${i}] must be a non-empty string.`);
+      }
+    }
+  }
+  if (del.required_decision_ids !== undefined) {
+    if (!Array.isArray(del.required_decision_ids) || del.required_decision_ids.length === 0) {
+      errors.push(`${prefix}.required_decision_ids must be a non-empty array when provided.`);
+    } else {
+      const seen = new Set();
+      for (let i = 0; i < del.required_decision_ids.length; i++) {
+        const id = del.required_decision_ids[i];
+        if (typeof id !== 'string' || !/^DEC-\d+$/.test(id)) {
+          errors.push(`${prefix}.required_decision_ids[${i}] must match pattern DEC-NNN.`);
+          continue;
+        }
+        if (seen.has(id)) {
+          errors.push(`${prefix}.required_decision_ids contains duplicate "${id}".`);
+          continue;
+        }
+        seen.add(id);
+      }
+    }
+  }
+
+  return errors;
+}
+
 // ── Stage B: Assignment Validation ───────────────────────────────────────────
 
 function validateAssignment(tr, state) {
@@ -550,6 +621,7 @@ function validateProtocol(tr, state, config) {
 
   const role = config.roles?.[tr.role];
   const writeAuthority = role?.write_authority;
+  const activeTurn = getActiveTurn(state) || state?.current_turn || null;
 
   // Challenge requirement: review_only roles MUST raise at least one objection
   if (config.rules?.challenge_required !== false) {
@@ -615,7 +687,6 @@ function validateProtocol(tr, state, config) {
     }
 
     // No recursive delegation: if this turn is a delegation review, it cannot delegate further
-    const activeTurn = state?.active_turns ? Object.values(state.active_turns)[0] : null;
     if (activeTurn?.delegation_context) {
       errors.push('Delegation review turns cannot contain further delegations.');
     }
@@ -650,6 +721,26 @@ function validateProtocol(tr, state, config) {
     }
   }
 
+  if (activeTurn?.delegation_review) {
+    const unmetDecisionContracts = (activeTurn.delegation_review.results || [])
+      .filter((result) => Array.isArray(result?.missing_decision_ids) && result.missing_decision_ids.length > 0);
+    if (unmetDecisionContracts.length > 0) {
+      const detail = unmetDecisionContracts
+        .map((result) => `${result.delegation_id}: ${result.missing_decision_ids.join(', ')}`)
+        .join('; ');
+      if (tr.phase_transition_request) {
+        errors.push(
+          `Delegation review cannot request phase transition while required child decisions are missing: ${detail}.`
+        );
+      }
+      if (tr.run_completion_request) {
+        errors.push(
+          `Delegation review cannot request run completion while required child decisions are missing: ${detail}.`
+        );
+      }
+    }
+  }
+
   return { errors, warnings };
 }