agentxchain 2.135.0 → 2.136.0

package/src/commands/resume.js

@@ -144,6 +144,9 @@ export async function resumeCommand(opts) {
         process.exit(1);
       }
       state = reactivated.state;
+      if (reactivated.migration_notice) {
+        console.log(chalk.yellow(reactivated.migration_notice));
+      }
 
       // Write dispatch bundle for the existing turn
       const bundleResult = writeDispatchBundle(root, state, config);
@@ -204,6 +207,9 @@ export async function resumeCommand(opts) {
       process.exit(1);
     }
     state = reactivated.state;
+    if (reactivated.migration_notice) {
+      console.log(chalk.yellow(reactivated.migration_notice));
+    }
 
     const bundleResult = writeDispatchBundle(root, state, config, { turnId: retainedTurn.turn_id });
     if (!bundleResult.ok) {
@@ -233,6 +239,9 @@ export async function resumeCommand(opts) {
     }
     state = initResult.state;
     console.log(chalk.green(`Initialized governed run: ${state.run_id}`));
+    if (initResult.migration_notice) {
+      console.log(chalk.yellow(initResult.migration_notice));
+    }
   }
 
   // §47: paused + run_id exists → resume same run
@@ -244,6 +253,9 @@ export async function resumeCommand(opts) {
     }
     state = reactivated.state;
     console.log(chalk.green(`Resumed blocked run: ${state.run_id}`));
+    if (reactivated.migration_notice) {
+      console.log(chalk.yellow(reactivated.migration_notice));
+    }
   }
 
   // §47: paused + run_id exists → resume same run
@@ -255,6 +267,9 @@ export async function resumeCommand(opts) {
     }
     state = reactivated.state;
     console.log(chalk.green(`Resumed governed run: ${state.run_id}`));
+    if (reactivated.migration_notice) {
+      console.log(chalk.yellow(reactivated.migration_notice));
+    }
   }
 
   // Print run-context header before dispatch

package/src/commands/step.js

@@ -260,6 +260,9 @@ export async function stepCommand(opts) {
           process.exit(1);
         }
         state = reactivated.state;
+        if (reactivated.migration_notice) {
+          console.log(chalk.yellow(reactivated.migration_notice));
+        }
         skipAssignment = true;
 
         // BUG-1 fix: refresh baseline snapshot to capture files dirtied between assignment and dispatch
@@ -285,6 +288,9 @@ export async function stepCommand(opts) {
       }
       state = initResult.state;
       console.log(chalk.green(`Initialized governed run: ${state.run_id}`));
+      if (initResult.migration_notice) {
+        console.log(chalk.yellow(initResult.migration_notice));
+      }
     }
 
     // paused → resume
@@ -296,6 +302,9 @@ export async function stepCommand(opts) {
       }
       state = reactivated.state;
       console.log(chalk.green(`Resumed blocked run: ${state.run_id}`));
+      if (reactivated.migration_notice) {
+        console.log(chalk.yellow(reactivated.migration_notice));
+      }
     }
 
     if (!skipAssignment && state.status === 'paused' && state.run_id) {
@@ -306,6 +315,9 @@ export async function stepCommand(opts) {
       }
       state = reactivated.state;
       console.log(chalk.green(`Resumed governed run: ${state.run_id}`));
+      if (reactivated.migration_notice) {
+        console.log(chalk.yellow(reactivated.migration_notice));
+      }
     }
 
     // Assign the turn

package/src/lib/connector-validate.js

@@ -106,6 +106,12 @@ export async function validateConfiguredConnector(sourceRoot, options = {}) {
   const tempBase = mkdtempSync(join(tmpdir(), 'axc-connector-validate-'));
   const scratchRoot = join(tempBase, 'workspace');
   const warnings = [...roleSelection.warnings];
+
+  // Surface capability declaration warnings for self-declared connectors
+  const { getCapabilityDeclarationWarnings } = await import('./runtime-capabilities.js');
+  const capWarnings = getCapabilityDeclarationWarnings(runtime);
+  warnings.push(...capWarnings);
+
   let keepArtifacts = options.keepArtifacts === true;
   let dispatch = null;
   let validation = null;

package/src/lib/context-section-parser.js

@@ -10,6 +10,8 @@ const SECTION_DEFINITIONS = [
   { id: 'last_turn_summary', header: null, required: false },
   { id: 'last_turn_decisions', header: null, required: false },
   { id: 'last_turn_objections', header: null, required: false },
+  { id: 'last_turn_files_changed', header: null, required: false },
+  { id: 'last_turn_changed_file_previews', header: null, required: false },
   { id: 'last_turn_verification', header: null, required: false },
   { id: 'decision_history', header: 'Decision History', required: false },
   { id: 'blockers', header: 'Blockers', required: true },
@@ -54,6 +56,8 @@ export function parseContextSections(contextMd) {
       summaryLines,
       decisionsLines,
       objectionsLines,
+      filesChangedLines,
+      changedFilePreviewLines,
       verificationLines,
     } = splitLastAcceptedTurn(lastAcceptedTurnBody);
 
@@ -61,6 +65,8 @@ export function parseContextSections(contextMd) {
     pushSection(parsedSections, 'last_turn_summary', summaryLines);
     pushSection(parsedSections, 'last_turn_decisions', decisionsLines);
     pushSection(parsedSections, 'last_turn_objections', objectionsLines);
+    pushSection(parsedSections, 'last_turn_files_changed', filesChangedLines);
+    pushSection(parsedSections, 'last_turn_changed_file_previews', changedFilePreviewLines);
     pushSection(parsedSections, 'last_turn_verification', verificationLines);
   }
 
@@ -91,6 +97,8 @@ export function renderContextSections(sections) {
     sectionMap.get('last_turn_summary')?.content,
     sectionMap.get('last_turn_decisions')?.content,
     sectionMap.get('last_turn_objections')?.content,
+    sectionMap.get('last_turn_files_changed')?.content,
+    sectionMap.get('last_turn_changed_file_previews')?.content,
     sectionMap.get('last_turn_verification')?.content,
   ]);
 
@@ -157,6 +165,8 @@ function splitLastAcceptedTurn(lines) {
   let summaryLines = [];
   let decisionsLines = [];
   let objectionsLines = [];
+  let filesChangedLines = [];
+  let changedFilePreviewLines = [];
   let verificationLines = [];
 
   let inVerification = false;
@@ -200,6 +210,20 @@ function splitLastAcceptedTurn(lines) {
       continue;
     }
 
+    if (line.startsWith('### Files Changed')) {
+      const { blockLines, nextIndex } = consumeLevel3Block(lines, index);
+      filesChangedLines = blockLines;
+      index = nextIndex - 1;
+      continue;
+    }
+
+    if (line.startsWith('### Changed File Previews')) {
+      const { blockLines, nextIndex } = consumeLevel3Block(lines, index);
+      changedFilePreviewLines = blockLines;
+      index = nextIndex - 1;
+      continue;
+    }
+
     headerLines.push(line);
   }
 
@@ -208,6 +232,8 @@ function splitLastAcceptedTurn(lines) {
     summaryLines: trimBlankLines(summaryLines),
     decisionsLines: trimBlankLines(decisionsLines),
     objectionsLines: trimBlankLines(objectionsLines),
+    filesChangedLines: trimBlankLines(filesChangedLines),
+    changedFilePreviewLines: trimBlankLines(changedFilePreviewLines),
     verificationLines: trimBlankLines(verificationLines),
   };
 }
@@ -232,6 +258,32 @@ function consumeIndentedBlock(lines, startIndex) {
   };
 }
 
+function consumeLevel3Block(lines, startIndex) {
+  const blockLines = [lines[startIndex]];
+  let index = startIndex + 1;
+  let inCodeBlock = false;
+
+  while (index < lines.length) {
+    const line = lines[index];
+
+    if (line.startsWith('```')) {
+      inCodeBlock = !inCodeBlock;
+    }
+
+    if (!inCodeBlock && line.startsWith('### ')) {
+      break;
+    }
+
+    blockLines.push(line);
+    index += 1;
+  }
+
+  return {
+    blockLines: trimBlankLines(blockLines),
+    nextIndex: index,
+  };
+}
+
 function pushSection(target, id, lines) {
   const normalizedLines = trimBlankLines(lines || []);
   if (!normalizedLines.length) return;

package/src/lib/continuous-run.js

@@ -24,6 +24,11 @@ import {
 } from './intake.js';
 import { loadProjectState } from './config.js';
 import { safeWriteJson } from './safe-write.js';
+import { emitRunEvent } from './run-events.js';
+import {
+  archiveStaleIntentsForRun,
+  formatLegacyIntentMigrationNotice,
+} from './intent-startup-migration.js';
 
 const CONTINUOUS_SESSION_PATH = '.agentxchain/continuous-session.json';
 
@@ -56,7 +61,7 @@ export function removeContinuousSession(root) {
   }
 }
 
-function createSession(visionPath, maxRuns, maxIdleCycles, perSessionMaxUsd) {
+function createSession(visionPath, maxRuns, maxIdleCycles, perSessionMaxUsd, currentRunId = null) {
   return {
     session_id: `cont-${randomUUID().slice(0, 8)}`,
     started_at: new Date().toISOString(),
@@ -65,12 +70,13 @@ function createSession(visionPath, maxRuns, maxIdleCycles, perSessionMaxUsd) {
     max_runs: maxRuns,
     idle_cycles: 0,
     max_idle_cycles: maxIdleCycles,
-    current_run_id: null,
+    current_run_id: currentRunId,
     current_vision_objective: null,
     status: 'running',
     per_session_max_usd: perSessionMaxUsd || null,
     cumulative_spent_usd: 0,
     budget_exhausted: false,
+    startup_reconciled_run_id: null,
   };
 }
 
@@ -133,8 +139,46 @@ function buildContinuousProvenance(intentId, options = {}) {
   };
 }
 
-export function findNextQueuedIntent(root) {
-  return findNextDispatchableIntent(root);
+export function findNextQueuedIntent(root, options = {}) {
+  return findNextDispatchableIntent(root, { run_id: options.run_id || null });
+}
+
+function reconcileContinuousStartupState(context, session, contOpts, log) {
+  const { root, config } = context;
+  const governedState = loadProjectState(root, config);
+  const scopedRunId = session.current_run_id || contOpts.continueFrom || governedState?.run_id || null;
+
+  let sessionChanged = false;
+  if (scopedRunId && session.current_run_id !== scopedRunId) {
+    session.current_run_id = scopedRunId;
+    sessionChanged = true;
+  }
+
+  if (scopedRunId && session.startup_reconciled_run_id !== scopedRunId) {
+    const startupIntents = archiveStaleIntentsForRun(root, scopedRunId, {
+      protocolVersion: governedState?.protocol_version || config?.schema_version || '2.x',
+    });
+    if (startupIntents.archived_migration_intent_ids?.length > 0) {
+      emitRunEvent(root, 'intents_migrated', {
+        run_id: scopedRunId,
+        phase: governedState?.phase || null,
+        status: governedState?.status || 'active',
+        payload: {
+          archived_count: startupIntents.archived_migration_intent_ids.length,
+          archived_intent_ids: startupIntents.archived_migration_intent_ids,
+          reason: 'pre-BUG-34 intents with approved_run_id: null archived during continuous startup',
+        },
+      });
+      const migrationNotice = formatLegacyIntentMigrationNotice(startupIntents.archived_migration_intent_ids);
+      if (migrationNotice) log(migrationNotice);
+    }
+    session.startup_reconciled_run_id = scopedRunId;
+    sessionChanged = true;
+  }
+
+  if (sessionChanged) {
+    writeContinuousSession(root, session);
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -232,6 +276,7 @@ export function resolveContinuousOptions(opts, config) {
 
   return {
     enabled: opts.continuous ?? configCont.enabled ?? false,
+    continueFrom: opts.continueFrom ?? null,
     visionPath: opts.vision ?? configCont.vision_path ?? '.planning/VISION.md',
     maxRuns: opts.maxRuns ?? configCont.max_runs ?? 100,
     pollSeconds: opts.pollSeconds ?? configCont.poll_seconds ?? 30,
@@ -288,6 +333,8 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
     return { ok: true, status: 'completed', action: 'session_budget_exhausted', stop_reason: 'session_budget' };
   }
 
+  reconcileContinuousStartupState(context, session, contOpts, log);
+
   // Paused-session guard: if session is paused (blocked run awaiting unblock),
   // check governed state before attempting to advance. Without this guard, the
   // loop would try to startIntent() on a blocked project, hit the blocked-state
@@ -540,7 +587,15 @@ export async function executeContinuousRun(context, contOpts, executeGovernedRun
     return { exitCode: 1, session: null };
   }
 
-  const session = createSession(contOpts.visionPath, contOpts.maxRuns, contOpts.maxIdleCycles, contOpts.perSessionMaxUsd);
+  const startupState = loadProjectState(root, context.config);
+  const initialRunId = contOpts.continueFrom || startupState?.run_id || null;
+  const session = createSession(
+    contOpts.visionPath,
+    contOpts.maxRuns,
+    contOpts.maxIdleCycles,
+    contOpts.perSessionMaxUsd,
+    initialRunId,
+  );
   writeContinuousSession(root, session);
 
   // SIGINT handler

package/src/lib/dispatch-bundle.js

@@ -389,6 +389,20 @@ function renderPrompt(role, roleId, turn, state, config, root) {
       }
       lines.push('');
     }
+    if (turn.conflict_context.forward_revision_files?.length) {
+      lines.push('Forward-revision files already safe to carry forward:');
+      for (const file of turn.conflict_context.forward_revision_files) {
+        lines.push(`- \`${file}\``);
+      }
+      if (turn.conflict_context.forward_revision_turns_since?.length) {
+        lines.push('');
+        lines.push('Forward-revision turns since assignment:');
+        for (const acceptedTurn of turn.conflict_context.forward_revision_turns_since) {
+          lines.push(`- \`${acceptedTurn.turn_id}\` (${acceptedTurn.role}) touched: ${acceptedTurn.files_changed.join(', ') || '(none)'}`);
+        }
+      }
+      lines.push('');
+    }
     if (turn.conflict_context.non_conflicting_files_preserved?.length) {
       lines.push('Non-conflicting files to preserve from your prior attempt:');
       for (const file of turn.conflict_context.non_conflicting_files_preserved) {

package/src/lib/gate-evaluator.js

@@ -85,6 +85,15 @@ function addMissingFile(result, filePath) {
   }
 }
 
+function addFailingFile(result, filePath) {
+  if (!filePath) {
+    return;
+  }
+  if (!result.failing_files.includes(filePath)) {
+    result.failing_files.push(filePath);
+  }
+}
+
 function prefixSemanticReason(filePath, reason) {
   if (!reason || reason.includes(filePath)) {
     return reason;
@@ -111,6 +120,7 @@ function evaluateGateArtifacts({ root, config, gateDef, phase, result, state })
     if (!existsSync(absPath)) {
       if (artifact.required) {
         addMissingFile(result, artifact.path);
+        addFailingFile(result, artifact.path);
         failures.push(`Required file missing: ${artifact.path}`);
       }
       continue;
@@ -119,6 +129,7 @@ function evaluateGateArtifacts({ root, config, gateDef, phase, result, state })
     if (artifact.useLegacySemantics) {
       const semanticCheck = evaluateWorkflowGateSemantics(root, artifact.path);
       if (semanticCheck && !semanticCheck.ok) {
+        addFailingFile(result, artifact.path);
         failures.push(semanticCheck.reason);
       }
     }
@@ -130,12 +141,14 @@ function evaluateGateArtifacts({ root, config, gateDef, phase, result, state })
         semantics_config: semantic.semantics_config,
       });
       if (semanticCheck && !semanticCheck.ok) {
+        addFailingFile(result, artifact.path);
         failures.push(prefixSemanticReason(artifact.path, semanticCheck.reason));
       }
     }
 
     // Charter enforcement: verify owning role participated in this phase
     if (artifact.owned_by && !hasRoleParticipationInPhase(state, phase, artifact.owned_by)) {
+      addFailingFile(result, artifact.path);
       failures.push(
         `"${artifact.path}" requires participation from role "${artifact.owned_by}" in phase "${phase}", but no accepted turn from that role was found`,
       );
@@ -161,11 +174,12 @@ function evaluateGateArtifacts({ root, config, gateDef, phase, result, state })
  * @property {boolean} blocked_by_human_approval - gate passed structurally but needs human sign-off
  * @property {string[]} reasons - human-readable failure reasons
  * @property {string[]} missing_files - files required by gate but not found
+ * @property {string[]} failing_files - files tied to gate failures
  * @property {boolean} missing_verification - verification required but not passed
  * @property {string|null} next_phase - the target phase if transition was requested and gate passed
  * @property {string|null} transition_request - the raw phase_transition_request value
  * @property {'no_request'|'unknown_phase'|'gate_failed'|'advance'|'awaiting_human_approval'|'no_gate'} action
- */
+*/
 export function evaluatePhaseExit({ state, config, acceptedTurn, root }) {
   const currentPhase = state.phase;
   const transitionRequest = acceptedTurn.phase_transition_request || null;
@@ -176,6 +190,7 @@ export function evaluatePhaseExit({ state, config, acceptedTurn, root }) {
     blocked_by_human_approval: false,
     reasons: [],
     missing_files: [],
+    failing_files: [],
     missing_verification: false,
     next_phase: null,
     transition_request: transitionRequest,
@@ -303,6 +318,7 @@ export function evaluatePhaseExit({ state, config, acceptedTurn, root }) {
  * @property {boolean} blocked_by_human_approval - gate passed structurally but needs human sign-off
  * @property {string[]} reasons - human-readable failure reasons
  * @property {string[]} missing_files - files required by gate but not found
+ * @property {string[]} failing_files - files tied to gate failures
  * @property {boolean} missing_verification - verification required but not passed
  * @property {'no_request'|'not_final_phase'|'gate_failed'|'complete'|'awaiting_human_approval'} action
  */
@@ -313,6 +329,7 @@ export function evaluateRunCompletion({ state, config, acceptedTurn, root }) {
     blocked_by_human_approval: false,
     reasons: [],
     missing_files: [],
+    failing_files: [],
     missing_verification: false,
     action: 'no_request',
   };