agentxchain 2.155.20 → 2.155.22

package/package.json

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

package/src/lib/config.js

@@ -9,6 +9,7 @@ import {
   reconcileApprovalPausesWithConfig,
   reconcileBudgetStatusWithConfig,
   reconcileRecoveryActionsWithConfig,
+  recoverStaleIdleExpansionRun,
 } from './governed-state.js';
 
 function attachLegacyCurrentTurnAlias(state) {
@@ -160,7 +161,10 @@ export function loadProjectState(root, config) {
     stateData = reconciledBudget.state;
     const reconciledRecovery = reconcileRecoveryActionsWithConfig(stateData, config);
     stateData = reconciledRecovery.state;
-    if (normalized.changed || reconciledApprovals.changed || reconciledBudget.changed || reconciledRecovery.changed) {
+    // BUG-75: recover stale idle-expansion runs missing charter_materialization_pending
+    const staleRecovery = recoverStaleIdleExpansionRun(root, stateData);
+    stateData = staleRecovery.state;
+    if (normalized.changed || reconciledApprovals.changed || reconciledBudget.changed || reconciledRecovery.changed || staleRecovery.changed) {
       safeWriteJson(filePath, stateData);
     }
   }

package/src/lib/governed-state.js

@@ -2500,6 +2500,99 @@ export function normalizeGovernedStateShape(state) {
   return { state: stripLegacyCurrentTurn(nextState), changed };
 }
 
+// BUG-75: Recover stale idle-expansion runs created before BUG-74 that lack
+// charter_materialization_pending. These runs loop on gate_semantic_coverage
+// because the PM prompt never receives the materialization directive.
+const INTAKE_EVENTS_DIR = '.agentxchain/intake/events';
+
+export function recoverStaleIdleExpansionRun(root, state) {
+  if (!state || typeof state !== 'object') {
+    return { state, changed: false };
+  }
+
+  // Only recover active planning runs missing the materialization flag
+  if (
+    state.status !== 'active'
+    || state.phase !== 'planning'
+    || state.charter_materialization_pending
+  ) {
+    return { state, changed: false };
+  }
+
+  // Trace the run back to its intake intent via provenance
+  const intentId = state.provenance?.intake_intent_id;
+  if (!intentId) {
+    return { state, changed: false };
+  }
+
+  // Read the intent file
+  const intentPath = join(root, INTAKE_INTENTS_DIR, `${intentId}.json`);
+  if (!existsSync(intentPath)) {
+    return { state, changed: false };
+  }
+
+  let intent;
+  try {
+    intent = JSON.parse(readFileSync(intentPath, 'utf8'));
+  } catch {
+    return { state, changed: false };
+  }
+
+  const eventId = intent.event_id;
+  if (!eventId) {
+    return { state, changed: false };
+  }
+
+  // Read the event file to check the category
+  const eventPath = join(root, INTAKE_EVENTS_DIR, `${eventId}.json`);
+  if (!existsSync(eventPath)) {
+    return { state, changed: false };
+  }
+
+  let event;
+  try {
+    event = JSON.parse(readFileSync(eventPath, 'utf8'));
+  } catch {
+    return { state, changed: false };
+  }
+
+  if (event.category !== 'pm_idle_expansion_derived') {
+    return { state, changed: false };
+  }
+
+  // Reconstruct charter_materialization_pending from the intake context
+  const recoveredState = {
+    ...state,
+    charter_materialization_pending: {
+      charter: intent.charter || null,
+      acceptance_contract: Array.isArray(intent.acceptance_contract)
+        ? intent.acceptance_contract
+        : [],
+      suppressed_transition: 'implementation',
+      source_turn_id: null,
+      recorded_at: new Date().toISOString(),
+    },
+  };
+
+  // Emit recovery event
+  emitRunEvent(root, 'charter_materialization_required', {
+    run_id: state.run_id,
+    phase: state.phase,
+    status: state.status,
+    payload: {
+      suppressed_transition: 'implementation',
+      reason: 'Stale run from idle-expansion-derived intent recovered missing charter_materialization_pending flag.',
+      new_intake_charter: intent.charter || null,
+      source: 'stale_run_recovery',
+      recovered_missing_flag: true,
+      intent_id: intentId,
+      event_id: eventId,
+    },
+  });
+
+  return { state: recoveredState, changed: true };
+}
+
 export function markRunBlocked(root, details) {
   const state = readState(root);
   if (!state) {
@@ -3312,8 +3405,39 @@ export function initializeGovernedRun(root, config, options = {}) {
     }
   }
 
+  // BUG-74: When a new run starts from an idle-expansion-derived intent,
+  // set charter_materialization_pending so the first PM turn receives the
+  // "You MUST create or update these planning artifacts" directive.
+  const intakeCtx = options.intakeContext;
+  if (intakeCtx?.category === 'pm_idle_expansion_derived') {
+    updatedState.charter_materialization_pending = {
+      charter: intakeCtx.charter || null,
+      acceptance_contract: Array.isArray(intakeCtx.acceptance_contract)
+        ? intakeCtx.acceptance_contract
+        : [],
+      suppressed_transition: 'implementation',
+      source_turn_id: null,
+      recorded_at: new Date().toISOString(),
+    };
+  }
+
   writeState(root, updatedState);
 
+  // BUG-74: emit event so consumers know materialization is required from run start
+  if (updatedState.charter_materialization_pending) {
+    emitRunEvent(root, 'charter_materialization_required', {
+      run_id: runId,
+      phase: updatedState.phase,
+      status: 'active',
+      payload: {
+        suppressed_transition: 'implementation',
+        reason: 'New run from idle-expansion-derived intent must materialize charter into planning artifacts.',
+        new_intake_charter: updatedState.charter_materialization_pending.charter,
+        source: 'run_initialization',
+      },
+    });
+  }
+
   const startupIntents = archiveStaleIntentsForRun(root, runId, {
     protocolVersion: updatedState.protocol_version || '2.x',
   });

package/src/lib/intake.js

@@ -1139,6 +1139,7 @@ export function startIntent(root, intentId, options = {}) {
     const initResult = initializeGovernedRun(root, config, {
       provenance: startProvenance,
       allow_terminal_restart: allowCompletedRestart,
+      intakeContext,
     });
     if (!initResult.ok) {
       return { ok: false, error: `run initialization failed: ${initResult.error}`, exitCode: 1 };