agentxchain 2.155.12 → 2.155.14

package/package.json

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

package/src/lib/dispatch-bundle.js

@@ -302,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';
@@ -499,6 +529,12 @@ function renderPrompt(role, roleId, turn, state, config, root) {
       lines.push(`- **You are in the \`${currentPhase}\` phase.** When your work is complete${gateClause}, set \`phase_transition_request: "${nextPhase}"\` to advance to the next phase.`);
     } else if (phaseIdx === phaseNames.length - 1) {
       lines.push(`- **You are in the \`${currentPhase}\` phase (final phase).** When ready to ship, set \`run_completion_request: true\` and \`phase_transition_request: null\`.`);
+      if (runCompletionAutoApprovalApplies(config)) {
+        lines.push('- Run completion is governed by `approval_policy.run_completion.action: "auto_approve"` for this run.');
+        lines.push('- Do NOT set `status: "needs_human"` solely to request final run approval. If the required artifacts are complete and there are no genuine blockers, set `status: "completed"` with `run_completion_request: true`; the orchestrator will evaluate and auto-approve completion.');
+      } else {
+        lines.push('- If final approval is human-gated, set `run_completion_request: true` when ready; the orchestrator will route the approval gate.');
+      }
     }
   }
   // Phase-specific guidance for proposed roles
@@ -512,6 +548,12 @@ function renderPrompt(role, roleId, turn, state, config, root) {
       lines.push(`- **You are in the \`${currentPhase}\` phase (not final phase).** When your work is complete${gateClause}, set \`phase_transition_request: "${nextPhase}"\`.`);
     } else if (phaseIdx >= 0 && phaseIdx === phaseNames.length - 1) {
       lines.push(`- **You are in the \`${currentPhase}\` phase (final phase).** When ready to ship, set \`run_completion_request: true\` and \`phase_transition_request: null\`.`);
+      if (runCompletionAutoApprovalApplies(config)) {
+        lines.push('- Run completion is governed by `approval_policy.run_completion.action: "auto_approve"` for this run.');
+        lines.push('- Do NOT set `status: "needs_human"` solely to request final run approval. If the required artifacts are complete and there are no genuine blockers, set `status: "completed"` with `run_completion_request: true`; the orchestrator will evaluate and auto-approve completion.');
+      } else {
+        lines.push('- If final approval is human-gated, set `run_completion_request: true` when ready; the orchestrator will route the approval gate.');
+      }
       if (runtimeType === 'api_proxy' || runtimeType === 'remote_agent') {
         lines.push('- **Completion turns must be no-op:** set `proposed_changes` to `[]` or omit it, set `files_changed` to `[]`, and set `artifact.type` to `"review"`. Do NOT propose file changes on a completion turn.');
       }

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',
 ];
 
 /**