agentxchain 2.155.19 → 2.155.21

package/package.json

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

package/src/commands/step.js

@@ -100,6 +100,35 @@ export async function stepCommand(opts) {
     process.exit(1);
   }
 
+  if (opts.resume && !opts.turn) {
+    const activeTurnsBeforeStaleCheck = getActiveTurns(state);
+    const activeTurnListBeforeStaleCheck = Object.values(activeTurnsBeforeStaleCheck);
+    const retainedTurn = activeTurnListBeforeStaleCheck.length === 1 ? activeTurnListBeforeStaleCheck[0] : null;
+    const materializationResolution = resolveGovernedRole({ state, config });
+    if (
+      retainedTurn
+      && state.status === 'active'
+      && state.charter_materialization_pending
+      && state.phase === 'planning'
+      && materializationResolution.roleId
+      && materializationResolution.roleId !== retainedTurn.assigned_role
+    ) {
+      const reason = `charter materialization pending superseded stale active ${retainedTurn.assigned_role} turn`;
+      const reissued = reissueTurn(root, config, {
+        turnId: retainedTurn.turn_id,
+        roleId: materializationResolution.roleId,
+        reason,
+      });
+      if (!reissued.ok) {
+        console.log(chalk.red(`Failed to reissue active turn for materialization: ${reissued.error}`));
+        process.exit(1);
+      }
+      state = reissued.state;
+      console.log(chalk.yellow(`Reissued active turn for charter materialization: ${reissued.newTurn.turn_id}`));
+      console.log(`  Role:    ${reissued.newTurn.assigned_role}`);
+    }
+  }
+
   const staleReconciliation = reconcileStaleTurns(root, state, config);
   state = staleReconciliation.state || state;
   if (staleReconciliation.ghost_turns.length > 0) {

package/src/lib/governed-state.js

@@ -3312,8 +3312,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 };