agentxchain 2.155.17 → 2.155.19

package/package.json

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

package/src/commands/resume.js

@@ -21,6 +21,7 @@ import { loadProjectContext, loadProjectState } from '../lib/config.js';
 import {
   initializeGovernedRun,
   assignGovernedTurn,
+  reissueTurn,
   deriveAfterDispatchHookRecoveryAction,
   markRunBlocked,
   getActiveTurns,
@@ -44,6 +45,7 @@ import { runHooks } from '../lib/hook-runner.js';
 import { summarizeRunProvenance } from '../lib/run-provenance.js';
 import { consumeNextApprovedIntent } from '../lib/intake.js';
 import { reconcileStaleTurns } from '../lib/stale-turn-watchdog.js';
+import { resolveGovernedRole } from '../lib/role-resolution.js';
 
 function hasStandingPendingExitGate(state, config) {
   const phase = state?.phase;
@@ -442,12 +444,6 @@ export async function resumeCommand(opts) {
       process.exit(1);
     }
 
-    printResumeRunContext({ root, state, config });
-    console.log(chalk.yellow(`Re-dispatching blocked turn: ${retainedTurn.turn_id}`));
-    console.log(`  Role:    ${retainedTurn.assigned_role}`);
-    console.log(`  Attempt: ${retainedTurn.attempt}`);
-    console.log('');
-
     const reactivated = reactivateGovernedRun(root, state, { via: turnResumeVia, notificationConfig: config });
     if (!reactivated.ok) {
       console.log(chalk.red(`Failed to reactivate blocked run: ${reactivated.error}`));
@@ -461,6 +457,38 @@ export async function resumeCommand(opts) {
       console.log(chalk.yellow(reactivated.phantom_notice));
     }
 
+    const materializationResolution = resolveGovernedRole({ state, config });
+    if (
+      state.charter_materialization_pending
+      && state.phase === 'planning'
+      && materializationResolution.roleId
+      && materializationResolution.roleId !== retainedTurn.assigned_role
+      && !opts.turn
+    ) {
+      const reason = `charter materialization pending superseded stale retained ${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 retained turn for materialization: ${reissued.error}`));
+        process.exit(1);
+      }
+      state = reissued.state;
+      retainedTurn = reissued.newTurn;
+      console.log(chalk.yellow(`Reissued retained turn for charter materialization: ${retainedTurn.turn_id}`));
+      console.log(`  Role:    ${retainedTurn.assigned_role}`);
+      console.log(`  Reason:  ${reason}`);
+      console.log('');
+    } else {
+      printResumeRunContext({ root, state, config });
+      console.log(chalk.yellow(`Re-dispatching blocked turn: ${retainedTurn.turn_id}`));
+      console.log(`  Role:    ${retainedTurn.assigned_role}`);
+      console.log(`  Attempt: ${retainedTurn.attempt}`);
+      console.log('');
+    }
+
     const bundleResult = writeDispatchBundle(root, state, config, { turnId: retainedTurn.turn_id });
     if (!bundleResult.ok) {
       console.log(chalk.red(`Failed to write dispatch bundle: ${bundleResult.error}`));
@@ -709,38 +737,24 @@ function printResumeRunContext({ root, state, config }) {
 }
 
 function resolveTargetRole(opts, state, config) {
-  const phase = state.phase;
-  const routing = config.routing?.[phase];
-
-  if (opts.role) {
-    // Validate the override
-    if (!config.roles?.[opts.role]) {
-      console.log(chalk.red(`Unknown role: "${opts.role}"`));
-      console.log(chalk.dim(`Available roles: ${Object.keys(config.roles || {}).join(', ')}`));
-      return null;
-    }
-    if (routing?.allowed_next_roles && !routing.allowed_next_roles.includes(opts.role) && opts.role !== 'human') {
-      console.log(chalk.yellow(`Warning: role "${opts.role}" is not in allowed_next_roles for phase "${phase}".`));
-      console.log(chalk.dim(`Allowed: ${routing.allowed_next_roles.join(', ')}`));
-      // Allow it as an override, but warn
+  const resolved = resolveGovernedRole({ override: opts.role || null, state, config });
+  if (resolved.error) {
+    console.log(chalk.red(resolved.error));
+    if (resolved.availableRoles.length) {
+      console.log(chalk.dim(`Available roles: ${resolved.availableRoles.join(', ')}`));
     }
-    return opts.role;
+    return null;
   }
 
-  // Default: use the phase's entry_role
-  if (routing?.entry_role) {
-    return routing.entry_role;
+  if (!opts.role && state.next_recommended_role && resolved.roleId === state.next_recommended_role) {
+    console.log(chalk.dim(`Using recommended role: ${resolved.roleId} (from previous turn)`));
   }
 
-  // Fallback: first role in config
-  const roles = Object.keys(config.roles || {});
-  if (roles.length > 0) {
-    console.log(chalk.yellow(`No entry_role for phase "${phase}". Defaulting to "${roles[0]}".`));
-    return roles[0];
+  for (const warning of resolved.warnings) {
+    console.log(chalk.yellow(`Warning: ${warning}`));
   }
 
-  console.log(chalk.red('No roles defined in config.'));
-  return null;
+  return resolved.roleId;
 }
 
 function runAfterDispatchHooks(root, hooksConfig, state, turn, config) {

package/src/commands/step.js

@@ -30,6 +30,7 @@ import {
   assignGovernedTurn,
   acceptGovernedTurn,
   deriveAfterDispatchHookRecoveryAction,
+  reissueTurn,
   rejectGovernedTurn,
   markRunBlocked,
   getActiveTurnCount,
@@ -251,6 +252,30 @@ export async function stepCommand(opts) {
       state = reactivated.state;
       skipAssignment = true;
 
+      const materializationResolution = resolveGovernedRole({ state, config });
+      if (
+        state.charter_materialization_pending
+        && state.phase === 'planning'
+        && materializationResolution.roleId
+        && materializationResolution.roleId !== targetTurn.assigned_role
+        && !opts.turn
+      ) {
+        const reason = `charter materialization pending superseded stale retained ${targetTurn.assigned_role} turn`;
+        const reissued = reissueTurn(root, config, {
+          turnId: targetTurn.turn_id,
+          roleId: materializationResolution.roleId,
+          reason,
+        });
+        if (!reissued.ok) {
+          console.log(chalk.red(`Failed to reissue retained turn for materialization: ${reissued.error}`));
+          process.exit(1);
+        }
+        state = reissued.state;
+        targetTurn = reissued.newTurn;
+        console.log(chalk.yellow(`Reissued retained turn for charter materialization: ${targetTurn.turn_id}`));
+        console.log(`  Role:    ${targetTurn.assigned_role}`);
+      }
+
       // BUG-1 fix: refresh baseline snapshot to capture files dirtied between assignment and dispatch
       refreshTurnBaselineSnapshot(root, targetTurn.turn_id);
       state = JSON.parse(readFileSync(join(root, '.agentxchain/state.json'), 'utf8'));

package/src/lib/coordinator-dispatch.js

@@ -77,6 +77,15 @@ function getDependencyBarrierId(workstreamId) {
 
 function resolveRecommendedRole(repoState, repoConfig, workstreamPhase) {
   const routing = repoConfig.routing?.[workstreamPhase];
+  if (repoState.charter_materialization_pending && workstreamPhase === 'planning') {
+    if (repoConfig.roles?.pm) {
+      return 'pm';
+    }
+    if (routing?.entry_role && repoConfig.roles?.[routing.entry_role]) {
+      return routing.entry_role;
+    }
+  }
+
   const recommendedRole = repoState.next_recommended_role;
   if (
     recommendedRole

package/src/lib/governed-state.js

@@ -3712,6 +3712,7 @@ export function refreshTurnBaselineSnapshot(root, turnId) {
  * @param {object} config - normalized config
  * @param {object} opts
  * @param {string} [opts.turnId] - specific turn to reissue
+ * @param {string} [opts.roleId] - replacement role; defaults to original turn role
  * @param {string} [opts.reason] - reason for reissue
  * @returns {{ ok: boolean, state?: object, newTurn?: object, baselineDelta?: object, error?: string }}
  */
@@ -3769,7 +3770,8 @@ export function reissueTurn(root, config, opts = {}) {
   const oldTurn = activeTurns[turnId];
   if (!oldTurn) return { ok: false, error: `Turn ${turnId} not found in active turns` };
 
-  const roleId = oldTurn.assigned_role;
+  const oldRoleId = oldTurn.assigned_role;
+  const roleId = opts.roleId || oldRoleId;
   const role = config.roles?.[roleId];
   if (!role) return { ok: false, error: `Role "${roleId}" not found in config` };
 
@@ -3795,7 +3797,7 @@ export function reissueTurn(root, config, opts = {}) {
   appendJsonl(root, HISTORY_PATH, {
     turn_id: oldTurn.turn_id,
     run_id: state.run_id,
-    role: roleId,
+    role: oldRoleId,
     phase: state.phase,
     status: 'reissued',
     summary: `Turn reissued: ${reason}`,
@@ -3811,7 +3813,8 @@ export function reissueTurn(root, config, opts = {}) {
     timestamp: now,
     decision: 'turn_reissued',
     turn_id: oldTurn.turn_id,
-    role: roleId,
+    role: oldRoleId,
+    new_role: roleId,
     phase: state.phase,
     reason,
     old_baseline: {
@@ -3895,6 +3898,8 @@ export function reissueTurn(root, config, opts = {}) {
       new_head: newBaseline.head_ref,
       old_runtime: oldRuntimeId,
       new_runtime: currentRuntimeId,
+      old_role: oldRoleId,
+      new_role: roleId,
     },
   });
 

package/src/lib/role-resolution.js

@@ -95,6 +95,24 @@ export function resolveGovernedRole({ override = null, state = null, config }) {
     };
   }
 
+  // BUG-73: charter materialization is planning-owned work. Persisted state from
+  // older releases may still recommend dev, so resolve the role from the pending
+  // materialization rather than trusting a stale implementation recommendation.
+  if (state?.charter_materialization_pending && phase === 'planning') {
+    const materializationRole = config?.roles?.pm
+      ? 'pm'
+      : (routing?.entry_role && config?.roles?.[routing.entry_role] ? routing.entry_role : null);
+    if (materializationRole) {
+      return {
+        roleId: materializationRole,
+        warnings,
+        error: null,
+        availableRoles: roles,
+        phase,
+      };
+    }
+  }
+
   if (state?.next_recommended_role && config?.roles?.[state.next_recommended_role]) {
     const recommended = state.next_recommended_role;
     const isLegal = !routing?.allowed_next_roles || routing.allowed_next_roles.includes(recommended);