agentxchain 2.154.3 → 2.154.7

package/package.json

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

package/src/commands/resume.js

@@ -44,6 +44,101 @@ import { summarizeRunProvenance } from '../lib/run-provenance.js';
 import { consumeNextApprovedIntent } from '../lib/intake.js';
 import { reconcileStaleTurns } from '../lib/stale-turn-watchdog.js';
 
+function hasStandingPendingExitGate(state, config) {
+  const phase = state?.phase;
+  const gateId = phase ? config?.routing?.[phase]?.exit_gate : null;
+  return Boolean(gateId && (state?.phase_gate_status || {})[gateId] === 'pending');
+}
+
+function getStandingPendingExitGate(state, config) {
+  const phase = state?.phase;
+  const gateId = phase ? config?.routing?.[phase]?.exit_gate : null;
+  if (!gateId || (state?.phase_gate_status || {})[gateId] !== 'pending') {
+    return null;
+  }
+  return config?.gates?.[gateId] || null;
+}
+
+function entrySatisfiesSyntheticGateVerification(gate, entry) {
+  if (!gate?.requires_verification_pass) return true;
+  const verificationStatus = entry?.verification?.status;
+  return verificationStatus === 'pass' || verificationStatus === 'attested_pass';
+}
+
+function turnContributedToHumanApprovalGateArtifacts(root, state, config, entry) {
+  // Returns true only when the accepted turn itself produced at least one of
+  // the phase exit gate's required_files AND all required_files are present
+  // on disk. This distinguishes a PM turn that finished phase work and
+  // escalated for final sign-off (BUG-52 third variant) from a generic
+  // escalation where the agent blocked BEFORE writing gate artifacts
+  // (schedule-daemon `needs_decision` fixture).
+  const phase = state?.phase;
+  const gateId = phase ? config?.routing?.[phase]?.exit_gate : null;
+  if (!gateId) return false;
+  const gate = config?.gates?.[gateId];
+  if (!gate || !Array.isArray(gate.requires_files) || gate.requires_files.length === 0) {
+    return false;
+  }
+  if (!gate.requires_human_approval) return false;
+  const filesChanged = Array.isArray(entry?.files_changed) ? entry.files_changed : [];
+  const required = gate.requires_files.filter((p) => typeof p === 'string' && p.trim());
+  if (required.length === 0) return false;
+  const changedSet = new Set(filesChanged.filter((p) => typeof p === 'string'));
+  const contributed = required.some((relPath) => changedSet.has(relPath));
+  if (!contributed) return false;
+  for (const relPath of required) {
+    if (!existsSync(join(root, relPath))) return false;
+  }
+  return true;
+}
+
+function latestCompletedTurnWantsPhaseContinuation(root, state, config) {
+  const turnId = state?.last_completed_turn_id || state?.blocked_reason?.turn_id || null;
+  if (!turnId) return false;
+  const historyPath = join(root, config?.files?.history || '.agentxchain/history.jsonl');
+  if (!existsSync(historyPath)) return false;
+  const lines = readFileSync(historyPath, 'utf8').trim().split('\n').filter(Boolean);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    let entry = null;
+    try {
+      entry = JSON.parse(lines[index]);
+    } catch {
+      continue;
+    }
+    if (entry?.turn_id !== turnId) continue;
+    if (entry.phase_transition_request) return true;
+    const standingGate = getStandingPendingExitGate(state, config);
+    const proposed = typeof entry.proposed_next_role === 'string' ? entry.proposed_next_role.trim() : '';
+    if (proposed && proposed !== 'human') {
+      return entrySatisfiesSyntheticGateVerification(standingGate, entry);
+    }
+    // Turn 205 extension (refines DEC-BUG52-UNBLOCK-STANDING-GATE-DISCRIMINATOR-001):
+    // The realistic BUG-52 third-variant PM shape sets `status: 'needs_human'`,
+    // `phase_transition_request: null`, and `proposed_next_role: 'human'` — the
+    // PM is escalating specifically for the phase exit gate's human-approval
+    // check and has already written the gate's required artifacts to disk.
+    // When the current phase's exit gate requires human approval, all of its
+    // `requires_files` are present on disk, and any gate-level verification
+    // predicate was satisfied by the accepted turn, an `unblock` on that
+    // escalation IS the final gate approval and must run the standing-gate
+    // reconcile.
+    //
+    // Distinguished from generic schedule-daemon `needs_decision` escalations
+    // (which block BEFORE the agent writes gate artifacts, so `requires_files`
+    // are not yet on disk) — those correctly continue to re-dispatch the
+    // in-phase role rather than force-advancing the phase.
+    if (
+      entry.status === 'needs_human'
+      && entrySatisfiesSyntheticGateVerification(standingGate, entry)
+      && turnContributedToHumanApprovalGateArtifacts(root, state, config, entry)
+    ) {
+      return true;
+    }
+    return false;
+  }
+  return false;
+}
+
 export async function resumeCommand(opts) {
   const context = loadProjectContext();
   if (!context) {
@@ -143,7 +238,23 @@ export async function resumeCommand(opts) {
   // patched defensively) once the schema citation + migration citation are
   // documented in code and the coverage matrix.
 
-  if (state.status === 'blocked' && activeCount > 0 && resumeVia === 'operator_unblock') {
+  // BUG-52 third variant (Turn 203/204): operator_unblock must run the
+  // standing-gate reconcile path regardless of `activeCount`, but only when the
+  // current phase actually has a standing pending exit gate and the blocked
+  // turn was trying to continue into a non-human phase role. The tester's
+  // v2.151.0 lights-out repro on `tusq.dev` left `active_turns: {}` with
+  // `phase_gate_status.planning_signoff: "pending"`, so the old
+  // `activeCount > 0` guard skipped the only path that could synthesize the
+  // missing transition source. Non-gate human escalations (OAuth, external
+  // decisions, schedule recovery with `proposed_next_role: "human"`) must keep
+  // the normal unblock/resume behavior instead of being forced through a
+  // phase-transition materialization check.
+  if (
+    state.status === 'blocked'
+    && resumeVia === 'operator_unblock'
+    && hasStandingPendingExitGate(state, config)
+    && latestCompletedTurnWantsPhaseContinuation(root, state, config)
+  ) {
     const reactivated = reactivateGovernedRun(root, state, { via: resumeVia, notificationConfig: config });
     if (!reactivated.ok) {
       console.log(chalk.red(`Failed to reactivate blocked run: ${reactivated.error}`));