agentxchain 2.41.0 → 2.43.0

package/package.json

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

package/scripts/release-bump.sh

@@ -56,6 +56,8 @@ ALLOWED_RELEASE_PATHS=(
   ".agentxchain-conformance/capabilities.json"
   "website-v2/docs/protocol-implementor-guide.mdx"
   ".planning/LAUNCH_EVIDENCE_REPORT.md"
+  "website-v2/static/llms.txt"
+  "website-v2/static/sitemap.xml"
   "cli/homebrew/agentxchain.rb"
   "cli/homebrew/README.md"
 )
@@ -168,6 +170,17 @@ if ! grep -qE "^# Launch Evidence Report — AgentXchain v${ESCAPED_VERSION}" "$
   SURFACE_ERRORS+=("LAUNCH_EVIDENCE_REPORT.md title does not carry v${TARGET_VERSION}")
 fi
 
+# 4h. llms.txt must list the current release notes route
+CURRENT_RELEASE_ROUTE="/docs/releases/${RELEASE_DOC_ID}"
+if ! grep -q "${CURRENT_RELEASE_ROUTE}" "${REPO_ROOT}/website-v2/static/llms.txt" 2>/dev/null; then
+  SURFACE_ERRORS+=("website-v2/static/llms.txt does not list '${CURRENT_RELEASE_ROUTE}'")
+fi
+
+# 4i. sitemap.xml must list the current release notes route
+if ! grep -q "${CURRENT_RELEASE_ROUTE}" "${REPO_ROOT}/website-v2/static/sitemap.xml" 2>/dev/null; then
+  SURFACE_ERRORS+=("website-v2/static/sitemap.xml does not list '${CURRENT_RELEASE_ROUTE}'")
+fi
+
 if [[ "${#SURFACE_ERRORS[@]}" -gt 0 ]]; then
   echo "FAIL: ${#SURFACE_ERRORS[@]} version-surface(s) not aligned to ${TARGET_VERSION}:" >&2
   printf '  - %s\n' "${SURFACE_ERRORS[@]}" >&2
@@ -176,7 +189,7 @@ if [[ "${#SURFACE_ERRORS[@]}" -gt 0 ]]; then
   echo "create release identity when governed surfaces are stale." >&2
   exit 1
 fi
-echo "  OK: all 7 governed version surfaces reference ${TARGET_VERSION}"
+echo "  OK: all 9 governed version surfaces reference ${TARGET_VERSION}"
 
 # 5. Auto-align Homebrew mirror to target version
 # The formula URL and README version/tarball are updated automatically.

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

@@ -79,6 +79,7 @@ export function validateStagedTurnResult(root, state, config, opts = {}) {
     const activeTurn = getActiveTurn(state) || state.current_turn;
     if (activeTurn) {
       const roleKey = activeTurn.assigned_role || activeTurn.role;
+      normContext.assignedRole = roleKey;
       const roleConfig = config?.roles?.[roleKey];
       if (roleConfig) {
         normContext.writeAuthority = roleConfig.write_authority;
@@ -562,6 +563,23 @@ export function normalizeTurnResult(tr, config, context = {}) {
   }
 
   const normalized = { ...tr };
+  const routing = config?.routing;
+  const phaseNames = routing ? Object.keys(routing) : [];
+  const currentPhase = context.phase;
+  const currentPhaseIndex = currentPhase ? phaseNames.indexOf(currentPhase) : -1;
+  const isKnownPhase = currentPhaseIndex >= 0;
+  const isTerminalPhase = isKnownPhase && currentPhaseIndex === phaseNames.length - 1;
+  const nextPhase = isKnownPhase && currentPhaseIndex + 1 < phaseNames.length
+    ? phaseNames[currentPhaseIndex + 1]
+    : null;
+  const allowedNextRoles = isKnownPhase ? (routing?.[currentPhase]?.allowed_next_roles || []) : [];
+  const assignedRole = context.assignedRole || normalized.role || null;
+  const isReviewOnly = context.writeAuthority === 'review_only';
+
+  const pickAllowedRoleFallback = () => {
+    if (allowedNextRoles.length === 0) return null;
+    return allowedNextRoles.find((role) => role !== assignedRole) || allowedNextRoles[0] || null;
+  };
 
   // ── Rule 0: infer missing status only when intent is unambiguous ──────
   if (!('status' in normalized)) {
@@ -604,7 +622,6 @@ export function normalizeTurnResult(tr, config, context = {}) {
   }
 
   // ── Rule 2: exit-gate-as-phase auto-correction ────────────────────────
-  const routing = config?.routing;
   const gates = config?.gates;
   if (
     typeof normalized.phase_transition_request === 'string' &&
@@ -643,33 +660,117 @@ export function normalizeTurnResult(tr, config, context = {}) {
     }
   }
 
-  // ── Rule 3: review_only terminal needs_human → run_completion_request ──
+  // ── Rule 3: review_only needs_human → lifecycle correction ──────────
+  // review_only roles cannot perform work that genuinely requires human
+  // intervention. If the model says "needs_human" with an affirmative,
+  // non-blocker reason, correct to the appropriate lifecycle signal:
+  // terminal phase → run_completion_request, non-terminal → phase_transition.
   if (
     context.writeAuthority === 'review_only' &&
     context.phase &&
     routing &&
     normalized.status === 'needs_human' &&
-    normalized.run_completion_request !== false
+    normalized.run_completion_request !== false &&
+    typeof normalized.needs_human_reason === 'string'
   ) {
-    const phaseNames = Object.keys(routing);
-    const isTerminal = phaseNames.indexOf(context.phase) === phaseNames.length - 1;
-    if (isTerminal && typeof normalized.needs_human_reason === 'string') {
-      const reason = normalized.needs_human_reason.toLowerCase();
-      const affirmativeSignals = /\b(approv|ship|release|sign.?off|no.?block|ready|pass|good|accept|green.?light)\b/i;
-      const blockerSignals = /\b(critical|security|fail|block|cannot|must.?fix|regression|vulnerab|reject|unsafe|broken)\b/i;
-      const isAffirmative = affirmativeSignals.test(reason);
-      const isBlocker = blockerSignals.test(reason);
-      if (isAffirmative && !isBlocker) {
+    const reason = normalized.needs_human_reason.toLowerCase();
+    const affirmativeSignals = /\b(approv|ship|release|sign.?off|no.?block|ready|pass|good|accept|green.?light|proceed|move.?forward|complet|done|lgtm|satisf|recommend)\b/i;
+    const blockerSignals = /\b(critical|security|fail|block|cannot|must.?fix|regression|vulnerab|reject|unsafe|broken)\b/i;
+    const isAffirmative = affirmativeSignals.test(reason);
+    const isBlocker = blockerSignals.test(reason);
+    if (isAffirmative && !isBlocker) {
+      if (isTerminalPhase) {
         corrections.push(
           `status: corrected review_only terminal "needs_human" to run_completion_request — reason indicated ship readiness ("${normalized.needs_human_reason.slice(0, 80)}"), not a genuine blocker`
         );
         normalized.status = 'completed';
         normalized.run_completion_request = true;
         delete normalized.needs_human_reason;
+      } else if (nextPhase) {
+        corrections.push(
+          `status: corrected review_only "needs_human" to phase_transition_request "${nextPhase}" — reason indicated forward progress ("${normalized.needs_human_reason.slice(0, 80)}"), not a genuine blocker`
+        );
+        normalized.status = 'completed';
+        normalized.phase_transition_request = nextPhase;
+        delete normalized.needs_human_reason;
+      }
+    }
+  }
+
+  // ── Rule 4: infer missing lifecycle signal for completed turns ────────
+  if (
+    isKnownPhase &&
+    isReviewOnly &&
+    normalized.status === 'completed' &&
+    normalized.run_completion_request == null &&
+    !normalized.phase_transition_request
+  ) {
+    if (isTerminalPhase) {
+      normalized.run_completion_request = true;
+      corrections.push(
+        `run_completion_request: inferred true for completed terminal phase "${currentPhase}"`
+      );
+    } else if (nextPhase) {
+      normalized.phase_transition_request = nextPhase;
+      corrections.push(
+        `phase_transition_request: inferred next phase "${nextPhase}" for completed phase "${currentPhase}"`
+      );
+    }
+  }
+
+  // ── Rule 5: correct invalid or non-forward lifecycle requests ─────────
+  if (
+    isKnownPhase &&
+    isReviewOnly &&
+    normalized.status === 'completed' &&
+    typeof normalized.phase_transition_request === 'string' &&
+    !normalized.run_completion_request
+  ) {
+    const requested = normalized.phase_transition_request;
+    const requestedIndex = phaseNames.indexOf(requested);
+    const invalidPhase = !(requested in (routing || {}));
+    const notForward = requestedIndex >= 0 && requestedIndex <= currentPhaseIndex;
+
+    if (invalidPhase || notForward) {
+      if (nextPhase) {
+        normalized.phase_transition_request = nextPhase;
+        corrections.push(
+          `phase_transition_request: corrected "${requested}" to forward phase "${nextPhase}"`
+        );
+      } else if (isTerminalPhase) {
+        normalized.phase_transition_request = null;
+        normalized.run_completion_request = true;
+        corrections.push(
+          `phase_transition_request: corrected terminal/non-forward "${requested}" to run_completion_request: true`
+        );
       }
     }
   }
 
+  // ── Rule 6: repair routing-illegal next-role signals only when safe ───
+  if (isReviewOnly && normalized.run_completion_request === true && !normalized.phase_transition_request) {
+    if (normalized.proposed_next_role !== 'human') {
+      normalized.proposed_next_role = 'human';
+      corrections.push('proposed_next_role: corrected to "human" for run completion');
+    }
+  } else if (
+    isKnownPhase &&
+    isReviewOnly &&
+    normalized.status === 'completed' &&
+    typeof normalized.proposed_next_role === 'string' &&
+    normalized.proposed_next_role !== 'human' &&
+    allowedNextRoles.length > 0 &&
+    !allowedNextRoles.includes(normalized.proposed_next_role)
+  ) {
+    const fallback = pickAllowedRoleFallback();
+    if (fallback) {
+      corrections.push(
+        `proposed_next_role: corrected "${normalized.proposed_next_role}" to allowed role "${fallback}"`
+      );
+      normalized.proposed_next_role = fallback;
+    }
+  }
+
   return { normalized, corrections };
 }