agentxchain 2.155.11 → 2.155.13

package/package.json

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

package/src/lib/dispatch-bundle.js

@@ -51,6 +51,14 @@ const RESERVED_PATHS = [
   '.agentxchain/lock.json',
 ];
 
+function phaseTransitionAutoApprovalApplies(config) {
+  return config?.approval_policy?.phase_transitions?.default === 'auto_approve';
+}
+
+function runCompletionAutoApprovalApplies(config) {
+  return config?.approval_policy?.run_completion?.action === 'auto_approve';
+}
+
 /**
  * Write a dispatch bundle for the currently assigned turn.
  *
@@ -294,6 +302,36 @@ function renderPrompt(role, roleId, turn, state, config, root) {
     lines.push('');
   }
 
+  // BUG-70: Charter materialization directive for PM after idle-expansion new_intake_intent
+  if (state.charter_materialization_pending && phase === 'planning') {
+    const cmp = state.charter_materialization_pending;
+    lines.push('### Charter Materialization Required');
+    lines.push('');
+    lines.push('A previous idle-expansion turn proposed a new intake intent that has NOT been materialized into planning artifacts.');
+    lines.push('The phase transition to implementation was suppressed because the planning artifacts do not yet charter the new work.');
+    lines.push('');
+    lines.push('**Your job this turn is to materialize this charter into concrete planning artifacts:**');
+    lines.push('');
+    if (cmp.charter) {
+      lines.push(`- **Charter:** ${cmp.charter}`);
+    }
+    if (Array.isArray(cmp.acceptance_contract) && cmp.acceptance_contract.length > 0) {
+      lines.push('- **Acceptance Contract:**');
+      for (const req of cmp.acceptance_contract) {
+        lines.push(`  - ${req}`);
+      }
+    }
+    lines.push('');
+    lines.push('You MUST create or update these planning artifacts to reflect the new work:');
+    lines.push('- `.planning/SYSTEM_SPEC.md` — technical specification for the new increment');
+    lines.push('- `.planning/ROADMAP.md` — updated roadmap including the new milestone');
+    lines.push('- `.planning/PM_SIGNOFF.md` — planning sign-off with acceptance criteria');
+    lines.push('');
+    lines.push('Only after these artifacts exist and reference the new charter may you request `phase_transition_request: "implementation"`.');
+    lines.push('Do NOT repeat the idle-expansion proposal. Write the actual planning documents.');
+    lines.push('');
+  }
+
   const workflowResponsibilities = getWorkflowPromptResponsibilities(config, phase, roleId, root);
   if (workflowResponsibilities.length > 0) {
     const isReviewOnlyOwner = role.write_authority === 'review_only';
@@ -334,7 +372,10 @@ function renderPrompt(role, roleId, turn, state, config, root) {
     if (gateConfig.requires_verification_pass) {
       lines.push('- Requires verification pass');
     }
-    if (gateConfig.requires_human_approval) {
+    if (gateConfig.requires_human_approval && phaseTransitionAutoApprovalApplies(config)) {
+      lines.push('- Requires approval, but `approval_policy.phase_transitions.default` is `auto_approve` for this run.');
+      lines.push('- Do NOT set `status: "needs_human"` solely to request phase-gate approval. If the required artifacts are complete, set the appropriate `phase_transition_request`; the orchestrator will evaluate and auto-approve the gate.');
+    } else if (gateConfig.requires_human_approval) {
       lines.push('- Requires human approval');
     }
     lines.push('');
@@ -512,7 +553,12 @@ function renderPrompt(role, roleId, turn, state, config, root) {
     const isTerminal = currentPhase && phaseNames.indexOf(currentPhase) === phaseNames.length - 1;
     if (isTerminal) {
       lines.push(`- **You are in the \`${currentPhase}\` phase (final phase).**`);
-      lines.push('- **If your review verdict is ship-ready (no blocking issues):** set `run_completion_request: true` and `status: "completed"`. This triggers the human approval gate — it does NOT bypass human review.');
+      if (runCompletionAutoApprovalApplies(config)) {
+        lines.push('- **If your review verdict is ship-ready (no blocking issues):** set `run_completion_request: true` and `status: "completed"`. This triggers orchestrator run-completion evaluation and auto-approval under `approval_policy.run_completion.action: "auto_approve"`.');
+        lines.push('- Do NOT use `status: "needs_human"` solely to request final approval when the approval policy is auto-approve. Use `needs_human` only for genuine blockers.');
+      } else {
+        lines.push('- **If your review verdict is ship-ready (no blocking issues):** set `run_completion_request: true` and `status: "completed"`. This triggers the human approval gate — it does NOT bypass human review.');
+      }
       lines.push('- **If you found genuine blocking issues that prevent shipping:** set `status: "needs_human"` and explain the blockers in `needs_human_reason`.');
       lines.push('- Do NOT use `status: "needs_human"` to mean "human should approve the release." That is what `run_completion_request: true` is for.');
       lines.push('- Do NOT set `phase_transition_request` to the exit gate name.');

package/src/lib/governed-state.js

@@ -5222,6 +5222,42 @@ function _acceptGovernedTurnLocked(root, config, opts) {
   let gateResult = null;
   let completionResult = null;
   let timeoutResult = null;
+
+  // BUG-70: idle-expansion new_intake_intent is a proposal, not a chartered plan.
+  // Suppress phase_transition_request — the new intake must be materialized into
+  // planning artifacts by a subsequent turn before implementation can proceed.
+  const isIdleExpansionNewIntake = idleExpansionResultSummary?.kind === 'new_intake_intent';
+  if (isIdleExpansionNewIntake && turnResult.phase_transition_request) {
+    const rawIdleResult = turnResult.idle_expansion_result;
+    updatedState.charter_materialization_pending = {
+      charter: rawIdleResult?.new_intake_intent?.charter
+        || idleExpansionResultSummary.new_intent_title
+        || null,
+      acceptance_contract: rawIdleResult?.new_intake_intent?.acceptance_contract
+        || [],
+      suppressed_transition: turnResult.phase_transition_request,
+      source_turn_id: turnResult.turn_id,
+      recorded_at: now,
+    };
+    emitRunEvent(root, 'charter_materialization_required', {
+      run_id: updatedState.run_id,
+      phase: state.phase,
+      status: updatedState.status,
+      turn: { turn_id: currentTurn.turn_id, role_id: currentTurn.assigned_role },
+      payload: {
+        suppressed_transition: turnResult.phase_transition_request,
+        reason: 'New intake from idle expansion must be materialized into planning artifacts before implementation dispatch.',
+        new_intake_charter: updatedState.charter_materialization_pending.charter,
+      },
+    });
+  }
+
+  // BUG-70: clear charter_materialization_pending when a non-idle-expansion turn
+  // in the planning phase is accepted (the PM has had a chance to materialize).
+  if (updatedState.charter_materialization_pending && !isIdleExpansionNewIntake && state.phase === 'planning') {
+    updatedState.charter_materialization_pending = null;
+  }
+
   const hasRemainingTurns = Object.keys(remainingTurns).length > 0;
   if (turnResult.status !== 'needs_human') {
     if (hasRemainingTurns) {
@@ -5231,7 +5267,7 @@ function _acceptGovernedTurnLocked(root, config, opts) {
           requested_at: now,
         };
       }
-      if (turnResult.phase_transition_request && !updatedState.queued_phase_transition) {
+      if (turnResult.phase_transition_request && !updatedState.queued_phase_transition && !isIdleExpansionNewIntake) {
         updatedState.queued_phase_transition = {
           from: state.phase,
           to: turnResult.phase_transition_request,
@@ -5342,8 +5378,14 @@ function _acceptGovernedTurnLocked(root, config, opts) {
       }
 
       if (updatedState.status !== 'blocked' && updatedState.status !== 'paused' && updatedState.status !== 'completed') {
-        const phaseSource = turnResult.phase_transition_request
-          ? turnResult
+        // BUG-70: suppress phase transition for idle-expansion new_intake_intent turns.
+        // Strip phase_transition_request from the effective turn so evaluatePhaseExit
+        // sees no transition request and returns { action: 'no_request' }.
+        const effectiveTurnResult = isIdleExpansionNewIntake
+          ? { ...turnResult, phase_transition_request: null }
+          : turnResult;
+        const phaseSource = effectiveTurnResult.phase_transition_request
+          ? effectiveTurnResult
           : findHistoryTurnRequest(nextHistoryEntries, state.queued_phase_transition?.requested_by_turn, 'phase_transition');
 
         // Always evaluate phase exit when the run drains — even without a request,
@@ -5351,7 +5393,7 @@ function _acceptGovernedTurnLocked(root, config, opts) {
         gateResult = evaluatePhaseExit({
           state: postAcceptanceState,
           config,
-          acceptedTurn: phaseSource || turnResult,
+          acceptedTurn: phaseSource || effectiveTurnResult,
           root,
         });
 

package/src/lib/run-events.js

@@ -48,6 +48,7 @@ export const VALID_RUN_EVENTS = [
   'ghost_retry_exhausted',
   'state_reconciled_operator_commits',
   'operator_commit_reconcile_refused',
+  'charter_materialization_required',
 ];
 
 /**