agentxchain 2.155.29 → 2.155.31

package/bin/agentxchain.js

@@ -708,6 +708,7 @@ program
   .option('--checkpoint', 'Checkpoint the accepted turn to git immediately after acceptance')
   .option('--resolution <mode>', 'Conflict resolution mode for conflicted turns (standard, human_merge)', 'standard')
   .option('--normalize-artifact-type <type>', 'Normalize an empty workspace artifact to a safe artifact type before acceptance (currently: review)')
+  .option('--normalize-staged-result', 'Run known-safe staged-result normalization before acceptance')
   .action(acceptTurnCommand);
 
 program

package/package.json

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

package/src/commands/accept-turn.js

@@ -23,6 +23,7 @@ export async function acceptTurnCommand(opts = {}) {
     turnId: opts.turn,
     resolutionMode: opts.resolution || 'standard',
     normalizeArtifactType: opts.normalizeArtifactType || null,
+    normalizeStagedResult: Boolean(opts.normalizeStagedResult),
   });
   if (!result.ok) {
     if (result.error_code === 'policy_escalation' || result.error_code === 'policy_violation') {
@@ -137,6 +138,10 @@ export async function acceptTurnCommand(opts = {}) {
     console.log(`  ${chalk.dim('Reason:')}   ${errorClass}`);
     console.log(`  ${chalk.dim('Owner:')}    human`);
     console.log(`  ${chalk.dim('Action:')}   Fix staged result and rerun agentxchain accept-turn, or reject with agentxchain reject-turn --reason "..."`);
+    if (result.validation?.errors?.some((err) => /objections\[\d+\]\.statement/.test(err))) {
+      const retainedTurnId = opts.turn || result.state?.current_turn?.turn_id || '(turn_id)';
+      console.log(`  ${chalk.dim('Recovery:')} agentxchain accept-turn --turn ${retainedTurnId} --normalize-staged-result`);
+    }
     console.log(`  ${chalk.dim('Turn:')}     retained`);
     if (result.validation?.errors?.length) {
       for (const err of result.validation.errors) {

package/src/commands/init.js

@@ -546,6 +546,7 @@ You are the **${role.title}** on this project.
 3. Write your structured turn result to the turn-scoped staging path printed by the orchestrator (\`.agentxchain/staging/<turn_id>/turn-result.json\`).
 4. If you make zero repo file edits, set \`artifact.type: "review"\` and \`files_changed: []\`.
 5. Only set \`artifact.type: "workspace"\` when you actually modified repo files and listed every changed path in \`files_changed\`.
+6. Every objection must include a non-empty \`statement\`; do not use \`summary\` or \`detail\` as a substitute.
 
 ## File Access
 

package/src/lib/dispatch-bundle.js

@@ -502,6 +502,7 @@ function renderPrompt(role, roleId, turn, state, config, root) {
   lines.push('- `artifact.type`: one of `workspace`, `patch`, `commit`, `review`');
   lines.push('- If you make zero repo file edits, set `artifact.type` to `"review"` and `files_changed` to `[]`.');
   lines.push('- Only set `artifact.type` to `"workspace"` when you actually modified repo files and listed every changed path in `files_changed`.');
+  lines.push('- Every `objections[]` item must include a non-empty `statement`; do not use `summary` or `detail` as a substitute.');
   lines.push('- `proposed_next_role`: must be in allowed_next_roles for current phase, or `human`');
   if (role.write_authority === 'review_only') {
     lines.push('- `objections`: **must be non-empty** (challenge requirement for review_only roles)');

package/src/lib/governed-state.js

@@ -4315,7 +4315,10 @@ function _acceptGovernedTurnLocked(root, config, opts) {
   }
 
   if (!validation.ok) {
-    const failError = `Validation failed at stage ${validation.stage}: ${validation.errors.join('; ')}`;
+    const recoveryHint = validation.errors.some((error) => /objections\[\d+\]\.statement/.test(error))
+      ? ` Recovery: agentxchain accept-turn --turn ${currentTurn.turn_id} --normalize-staged-result`
+      : '';
+    const failError = `Validation failed at stage ${validation.stage}: ${validation.errors.join('; ')}${recoveryHint}`;
     transitionToFailedAcceptance(root, state, currentTurn, failError, {
       error_code: 'validation_failed',
       stage: validation.stage,
@@ -4345,6 +4348,22 @@ function _acceptGovernedTurnLocked(root, config, opts) {
       },
     });
   }
+  for (const event of Array.isArray(validation.normalization_events) ? validation.normalization_events : []) {
+    emitRunEvent(root, 'staged_result_auto_normalized', {
+      run_id: state.run_id,
+      phase: state.phase,
+      status: state.status,
+      turn: { turn_id: currentTurn.turn_id, role_id: currentTurn.assigned_role },
+      intent_id: currentTurn.intake_context?.intent_id || null,
+      payload: {
+        field: event.field,
+        original_value: event.original_value,
+        normalized_value: event.normalized_value,
+        rationale: event.rationale,
+        staging_path: resolvedStagingPath,
+      },
+    });
+  }
 
   const rawTurnResult = validation.turnResult;
   const verificationProducedFiles = normalizeVerificationProducedFiles(rawTurnResult.verification);
@@ -6948,6 +6967,12 @@ function evaluateIntentCoverage(turnResult, intakeContext, { state = null, confi
       continue;
     }
 
+    const roadmapCoverage = evaluateRoadmapDerivedConditionalCoverage(item, turnResult, intakeContext, state);
+    if (roadmapCoverage === true) {
+      addressed.push(item);
+      continue;
+    }
+
     // Check 1: Structural — intent_response field with explicit status
     const structuralEntry = responseMap.get(normalizedItem);
     if (structuralEntry && ['addressed', 'deferred', 'rejected'].includes(structuralEntry.status)) {
@@ -7031,6 +7056,68 @@ function evaluateIdleExpansionConditionalCoverage(item, turnResult, intakeContex
   return null;
 }
 
+// ── Roadmap-derived intent conditional coverage (BUG-80) ────────────────────
+//
+// Roadmap-derived intents (charter starts with "[roadmap]") include literal
+// implementation text as acceptance items.  PM turns in planning phase produce
+// charter/scoping artifacts, not implementation code, so the generic 50%
+// keyword-overlap check fails.  This function provides phase-aware evaluation:
+//  - "Evidence source:" items are metadata provenance → always addressed
+//  - "Unchecked roadmap item completed:" in planning phase → milestone-mention check
+//  - In implementation+ phases → falls through to normal semantic matching
+
+function evaluateRoadmapDerivedConditionalCoverage(item, turnResult, intakeContext, state) {
+  const charter = intakeContext?.charter || '';
+  if (!charter.startsWith('[roadmap]')) {
+    return null;
+  }
+
+  const normalizedItem = typeof item === 'string' ? item.toLowerCase().trim() : '';
+
+  // "Evidence source:" items are provenance metadata, not deliverables.
+  // No turn of any role can "address" a file path reference.
+  if (normalizedItem.startsWith('evidence source:')) {
+    return true;
+  }
+
+  // "Unchecked roadmap item completed:" contains literal implementation text.
+  // In planning phase, PM scopes the milestone — check for milestone mention
+  // rather than requiring implementation-keyword overlap.
+  // In implementation/qa/launch phases, fall through to normal semantic matching
+  // so dev turns are still evaluated against actual implementation keywords.
+  if (normalizedItem.startsWith('unchecked roadmap item completed:')) {
+    const currentPhase = state?.phase || '';
+    if (currentPhase !== 'planning') {
+      return null;
+    }
+
+    // Extract milestone section identifier from charter: "[roadmap] M28: ..."
+    const sectionMatch = charter.match(/\[roadmap\]\s*(M\d+)/i);
+    if (!sectionMatch) {
+      return null;
+    }
+
+    const milestoneId = sectionMatch[1].toLowerCase();
+
+    // Build a searchable corpus from the turn result
+    const corpus = [
+      turnResult.summary || '',
+      ...(turnResult.decisions || []).map(d => `${d.statement || ''} ${d.rationale || ''}`),
+      ...(turnResult.objections || []).map(o => o.statement || ''),
+      ...(turnResult.files_changed || []),
+      ...(turnResult.artifacts_created || []),
+      ...(Array.isArray(turnResult.intent_response)
+        ? turnResult.intent_response.map(r => `${r.item || ''} ${r.detail || ''}`)
+        : []),
+    ].join('\n').toLowerCase();
+
+    // If the turn mentions the milestone section ID, the item is addressed
+    return corpus.includes(milestoneId);
+  }
+
+  return null;
+}
+
 export {
   STATE_PATH,
   HISTORY_PATH,

package/src/lib/run-events.js

@@ -50,6 +50,7 @@ export const VALID_RUN_EVENTS = [
   'operator_commit_reconcile_refused',
   'charter_materialization_required',
   'artifact_type_auto_normalized',
+  'staged_result_auto_normalized',
 ];
 
 /**

package/src/lib/turn-result-validator.js

@@ -94,7 +94,7 @@ export function validateStagedTurnResult(root, state, config, opts = {}) {
   if (opts.normalizeArtifactType === 'review') {
     normContext.forceReviewArtifact = true;
   }
-  const { normalized, corrections } = normalizeTurnResult(turnResult, config, normContext);
+  const { normalized, corrections, normalizationEvents } = normalizeTurnResult(turnResult, config, normContext);
   turnResult = normalized;
   const sidecarResult = maybeAttachIdleExpansionSidecar(
     root,
@@ -159,6 +159,7 @@ export function validateStagedTurnResult(root, state, config, opts = {}) {
     warnings: allWarnings,
     turnResult,
     normalizations: corrections,
+    normalization_events: normalizationEvents,
   };
 }
 
@@ -995,8 +996,9 @@ function validateProtocol(tr, state, config) {
  */
 export function normalizeTurnResult(tr, config, context = {}) {
   const corrections = [];
+  const normalizationEvents = [];
   if (tr === null || typeof tr !== 'object' || Array.isArray(tr)) {
-    return { normalized: tr, corrections };
+    return { normalized: tr, corrections, normalizationEvents };
   }
 
   const normalized = { ...tr };
@@ -1023,7 +1025,7 @@ export function normalizeTurnResult(tr, config, context = {}) {
     && !Array.isArray(normalized.artifact)
     && normalized.artifact.type === 'workspace'
     && filesChangedIsEmpty
-    && (context.forceReviewArtifact || isReviewOnly || hasExplicitNoEditLifecycleSignal)
+    && (context.forceReviewArtifact || hasExplicitNoEditLifecycleSignal)
   ) {
     normalized.artifact = {
       ...normalized.artifact,
@@ -1033,6 +1035,42 @@ export function normalizeTurnResult(tr, config, context = {}) {
         : normalized.artifact.ref ?? null,
     };
     corrections.push('artifact.type: auto-normalized empty workspace artifact to review because files_changed is empty and no repo mutation was declared');
+    normalizationEvents.push({
+      field: 'artifact.type',
+      original_value: 'workspace',
+      normalized_value: 'review',
+      rationale: 'empty_files_changed_no_repo_mutation_declared',
+    });
+  }
+
+  if (Array.isArray(normalized.objections)) {
+    normalized.objections = normalized.objections.map((objection, index) => {
+      if (objection === null || typeof objection !== 'object' || Array.isArray(objection)) {
+        return objection;
+      }
+      const statement = typeof objection.statement === 'string' ? objection.statement.trim() : '';
+      if (statement) {
+        return objection;
+      }
+      const summary = typeof objection.summary === 'string' ? objection.summary.trim() : '';
+      const detail = typeof objection.detail === 'string' ? objection.detail.trim() : '';
+      const sourceField = summary ? 'summary' : detail ? 'detail' : null;
+      const sourceValue = summary || detail;
+      if (!sourceField) {
+        return objection;
+      }
+      corrections.push(`objections[${index}].statement: copied from ${sourceField}`);
+      normalizationEvents.push({
+        field: `objections[${index}].statement`,
+        original_value: objection.statement ?? null,
+        normalized_value: sourceValue,
+        rationale: `copied_from_${sourceField}`,
+      });
+      return {
+        ...objection,
+        statement: sourceValue,
+      };
+    });
   }
 
   const pickAllowedRoleFallback = () => {
@@ -1238,7 +1276,7 @@ export function normalizeTurnResult(tr, config, context = {}) {
     }
   }
 
-  return { normalized, corrections };
+  return { normalized, corrections, normalizationEvents };
 }
 
 function normalizeIdleExpansionMutualExclusionSentinel(result) {