agentxchain 2.135.1 → 2.136.1

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/governed-state.js

@@ -46,6 +46,10 @@ import { emitRunEvent } from './run-events.js';
 import { writeSessionCheckpoint } from './session-checkpoint.js';
 import { recordRunHistory } from './run-history.js';
 import { buildDefaultRunProvenance } from './run-provenance.js';
+import {
+  archiveStaleIntentsForRun,
+  formatLegacyIntentMigrationNotice,
+} from './intent-startup-migration.js';
 import {
   ensureHumanEscalation,
   findCurrentHumanEscalation,
@@ -1243,6 +1247,13 @@ function buildConflictContext(turn) {
         files_changed: Array.isArray(entry.files_changed) ? entry.files_changed : [],
       }))
     : [];
+  const forwardRevisionTurnsSince = Array.isArray(conflictError.forward_revision_turns)
+    ? conflictError.forward_revision_turns.map((entry) => ({
+        turn_id: entry.turn_id,
+        role: entry.role,
+        files_changed: Array.isArray(entry.files_changed) ? entry.files_changed : [],
+      }))
+    : [];
 
   return {
     prior_attempt_turn_id: turn.turn_id,
@@ -1250,6 +1261,8 @@ function buildConflictContext(turn) {
     conflict_type: conflictError.type || 'file_conflict',
     conflicting_files: Array.isArray(conflictError.conflicting_files) ? conflictError.conflicting_files : [],
     accepted_turns_since: acceptedTurnsSince,
+    forward_revision_files: Array.isArray(conflictError.forward_revision_files) ? conflictError.forward_revision_files : [],
+    forward_revision_turns_since: forwardRevisionTurnsSince,
     non_conflicting_files_preserved: Array.isArray(conflictError.non_conflicting_files)
       ? conflictError.non_conflicting_files
       : [],
@@ -2067,6 +2080,25 @@ export function reactivateGovernedRun(root, state, details = {}) {
 
   writeState(root, nextState);
 
+  const startupIntents = nextState.run_id
+    ? archiveStaleIntentsForRun(root, nextState.run_id, {
+      protocolVersion: nextState.protocol_version || state.protocol_version || '2.x',
+    })
+    : { archived_migration_intent_ids: [], migration_notice: null };
+
+  if (startupIntents.archived_migration_intent_ids?.length > 0) {
+    emitRunEvent(root, 'intents_migrated', {
+      run_id: nextState.run_id,
+      phase: nextState.phase,
+      status: nextState.status,
+      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 run reactivation',
+      },
+    });
+  }
+
   if (humanEscalation) {
     resolveHumanEscalation(root, humanEscalation.escalation_id, {
       resolved_at: now,
@@ -2108,7 +2140,11 @@ export function reactivateGovernedRun(root, state, details = {}) {
     });
   }
 
-  return { ok: true, state: attachLegacyCurrentTurnAlias(nextState) };
+  return {
+    ok: true,
+    state: attachLegacyCurrentTurnAlias(nextState),
+    migration_notice: formatLegacyIntentMigrationNotice(startupIntents.archived_migration_intent_ids),
+  };
 }
 
 // ── Core Operations ──────────────────────────────────────────────────────────
@@ -2162,48 +2198,10 @@ export function initializeGovernedRun(root, config, options = {}) {
 
   writeState(root, updatedState);
 
-  // BUG-34 + BUG-39: retroactive migration — archive stale intents from prior runs.
-  // Intents with an approved_run_id from a DIFFERENT run are archived (BUG-34).
-  // BUG-39: Intents with approved_run_id: null are pre-BUG-34 legacy files that
-  // must be archived with status "archived_migration", NOT adopted into the current
-  // run. Silently adopting them caused continuous mode to pick up stale intents.
-  const archivedMigrationIntentIds = [];
-  try {
-    const intentsDir = join(root, '.agentxchain', 'intake', 'intents');
-    if (existsSync(intentsDir)) {
-      const DISPATCHABLE = new Set(['planned', 'approved']);
-      const intNow = new Date().toISOString();
-      for (const f of readdirSync(intentsDir).filter(x => x.endsWith('.json') && !x.startsWith('.tmp-'))) {
-        const ip = join(intentsDir, f);
-        try {
-          const intent = JSON.parse(readFileSync(ip, 'utf8'));
-          if (!intent || !DISPATCHABLE.has(intent.status)) continue;
-          if (intent.cross_run_durable === true) continue;
-          if (intent.approved_run_id === runId) continue;
-
-          const prevStatus = intent.status;
-          if (intent.approved_run_id && intent.approved_run_id !== runId) {
-            // Intent from a different run — archive it (BUG-34)
-            intent.status = 'suppressed';
-            intent.updated_at = intNow;
-            intent.archived_reason = `stale: approved under run ${intent.approved_run_id}, archived on run ${runId} initialization`;
-            if (!intent.history) intent.history = [];
-            intent.history.push({ from: prevStatus, to: 'suppressed', at: intNow, reason: intent.archived_reason });
-          } else if (!intent.approved_run_id) {
-            // BUG-39: pre-BUG-34 legacy intent with no run binding — archive it
-            // with explicit migration reason. Do NOT adopt into current run.
-            intent.status = 'archived_migration';
-            intent.updated_at = intNow;
-            intent.archived_reason = `pre-BUG-34 intent with no run scope; archived during v${updatedState.protocol_version || '2.x'} migration on run ${runId}`;
-            if (!intent.history) intent.history = [];
-            intent.history.push({ from: prevStatus, to: 'archived_migration', at: intNow, reason: intent.archived_reason });
-            if (intent.intent_id) archivedMigrationIntentIds.push(intent.intent_id);
-          }
-          safeWriteJson(ip, intent);
-        } catch { /* non-fatal per-intent */ }
-      }
-    }
-  } catch { /* non-fatal — intent migration is best-effort */ }
+  const startupIntents = archiveStaleIntentsForRun(root, runId, {
+    protocolVersion: updatedState.protocol_version || '2.x',
+  });
+  const archivedMigrationIntentIds = startupIntents.archived_migration_intent_ids || [];
 
   // BUG-39: emit intents_migrated event when pre-BUG-34 intents were archived
   if (archivedMigrationIntentIds.length > 0) {
@@ -2226,9 +2224,7 @@ export function initializeGovernedRun(root, config, options = {}) {
     payload: { provenance: provenance || {} },
   });
   // BUG-39: return migration notice so callers can display it
-  const migrationNotice = archivedMigrationIntentIds.length > 0
-    ? `Archived ${archivedMigrationIntentIds.length} pre-BUG-34 intent(s). Review: agentxchain intake status --archived.`
-    : null;
+  const migrationNotice = startupIntents.migration_notice;
 
   return { ok: true, state: attachLegacyCurrentTurnAlias(updatedState), migration_notice: migrationNotice };
 }

package/src/lib/intake.js

@@ -17,6 +17,11 @@ import { getDispatchTurnDir } from './turn-paths.js';
 import { loadCoordinatorConfig } from './coordinator-config.js';
 import { loadCoordinatorState, readBarriers } from './coordinator-state.js';
 import { writeCoordinatorHandoff } from './intake-handoff.js';
+import {
+  archiveStaleIntentsForRun,
+  migratePreBug34Intents,
+  formatLegacyIntentMigrationNotice,
+} from './intent-startup-migration.js';
 
 const VALID_SOURCES = ['manual', 'ci_failure', 'git_ref_change', 'schedule', 'vision_scan'];
 const VALID_PRIORITIES = ['p0', 'p1', 'p2', 'p3'];
@@ -516,16 +521,14 @@ export function findNextDispatchableIntent(root, options = {}) {
     .filter((intent) => intent && DISPATCHABLE_STATUSES.has(intent.status));
 
   // BUG-34: when run_id scoping is active, filter out intents that belong to
-  // a different run. An intent belongs to the current run if:
-  //   (a) it has approved_run_id matching the current run, OR
-  //   (b) it has no approved_run_id AND is marked cross_run_durable, OR
-  //   (c) it was injected in the current run (approved_run_id matches)
-  // Legacy intents (no approved_run_id, no cross_run_durable) are excluded
-  // because they are stale leftovers from prior runs.
+  // a different run. `cross_run_durable` is only a pre-run holding state for
+  // freshly approved idle intents. Once a run starts, those intents must be
+  // rebound onto that run and the flag cleared; it must never override an
+  // existing run binding.
   if (scopeRunId) {
     intents = intents.filter((intent) => {
       if (intent.approved_run_id === scopeRunId) return true;
-      if (intent.cross_run_durable === true) return true;
+      if (!intent.approved_run_id && intent.cross_run_durable === true) return true;
       // Legacy intent with no run binding — stale, skip it
       if (!intent.approved_run_id) return false;
       // Intent bound to a different run — stale, skip it
@@ -579,10 +582,11 @@ export function findPendingApprovedIntents(root, options = {}) {
   return readJsonDir(dirs.intents)
     .filter((intent) => {
       if (!intent || intent.status !== 'approved') return false;
-      // BUG-34: run_id scoping — same logic as findNextDispatchableIntent
+      // BUG-34: run_id scoping — same logic as findNextDispatchableIntent.
+      // `cross_run_durable` only applies before the first run binding exists.
       if (scopeRunId) {
         if (intent.approved_run_id === scopeRunId) return true;
-        if (intent.cross_run_durable === true) return true;
+        if (!intent.approved_run_id && intent.cross_run_durable === true) return true;
         return false;
       }
       return true;
@@ -616,51 +620,7 @@ export function findPendingApprovedIntents(root, options = {}) {
  * @returns {{ archived: number }}
  */
 export function archiveStaleIntents(root, newRunId) {
-  const dirs = intakeDirs(root);
-  if (!existsSync(dirs.intents)) return { archived: 0, adopted: 0 };
-
-  const now = nowISO();
-  let archived = 0;
-  let adopted = 0;
-
-  const files = readdirSync(dirs.intents).filter(f => f.endsWith('.json') && !f.startsWith('.tmp-'));
-  for (const file of files) {
-    const intentPath = join(dirs.intents, file);
-    let intent;
-    try {
-      intent = JSON.parse(readFileSync(intentPath, 'utf8'));
-    } catch {
-      continue;
-    }
-
-    if (!intent || !DISPATCHABLE_STATUSES.has(intent.status)) continue;
-    if (intent.cross_run_durable === true) continue;
-    if (intent.approved_run_id === newRunId) continue;
-
-    if (intent.approved_run_id && intent.approved_run_id !== newRunId) {
-      // Intent from a different run — archive it
-      intent.status = 'suppressed';
-      intent.updated_at = now;
-      intent.archived_reason = `stale: approved under run ${intent.approved_run_id}, archived on run ${newRunId} initialization`;
-      if (!intent.history) intent.history = [];
-      intent.history.push({ from: 'approved', to: 'suppressed', at: now, reason: intent.archived_reason });
-      safeWriteJson(intentPath, intent);
-      archived++;
-    } else if (!intent.approved_run_id) {
-      // BUG-39: pre-BUG-34 legacy intent with no run binding — archive it
-      // with explicit migration reason. Do NOT adopt into current run.
-      const prevStatus = intent.status;
-      intent.status = 'archived_migration';
-      intent.updated_at = now;
-      intent.archived_reason = `pre-BUG-34 intent with no run scope; archived during migration on run ${newRunId}`;
-      if (!intent.history) intent.history = [];
-      intent.history.push({ from: prevStatus, to: 'archived_migration', at: now, reason: intent.archived_reason });
-      safeWriteJson(intentPath, intent);
-      archived++;
-    }
-  }
-
-  return { archived, adopted };
+  return archiveStaleIntentsForRun(root, newRunId);
 }
 
 /**
@@ -823,9 +783,9 @@ export function approveIntent(root, intentId, options = {}) {
 
   // BUG-34/39: stamp the current run_id on approval so the intent is scoped
   // to the run that approved it. When approval happens before any governed
-  // run exists, mark the intent as cross_run_durable so the next run init
-  // preserves this freshly approved work instead of archiving it as legacy
-  // migration debt.
+  // run exists, hold the intent in a pre-run durable state so the *next* run
+  // initialization can bind it to that run. The flag is not an evergreen
+  // cross-run bypass; it exists only until first run binding happens.
   if (!intent.approved_run_id) {
     const statePath = join(root, '.agentxchain', 'state.json');
     if (existsSync(statePath)) {

package/src/lib/intent-startup-migration.js

@@ -0,0 +1,151 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { safeWriteJson } from './safe-write.js';
+
+const DISPATCHABLE_STATUSES = new Set(['planned', 'approved']);
+
+function nowISO() {
+  return new Date().toISOString();
+}
+
+function getIntentsDir(root) {
+  return join(root, '.agentxchain', 'intake', 'intents');
+}
+
+function listIntentFiles(intentsDir) {
+  if (!existsSync(intentsDir)) return [];
+  return readdirSync(intentsDir).filter((file) => file.endsWith('.json') && !file.startsWith('.tmp-'));
+}
+
+export function formatLegacyIntentMigrationNotice(intentIds) {
+  if (!Array.isArray(intentIds) || intentIds.length === 0) return null;
+  return `Archived ${intentIds.length} pre-BUG-34 intent(s): ${intentIds.join(', ')}`;
+}
+
+export function migratePreBug34Intents(root, runId, options = {}) {
+  const intentsDir = getIntentsDir(root);
+  if (!existsSync(intentsDir)) {
+    return {
+      archived_migration_count: 0,
+      archived_migration_intent_ids: [],
+      migration_notice: null,
+    };
+  }
+
+  const now = nowISO();
+  const archivedMigrationIntentIds = [];
+  const protocolVersion = options.protocolVersion || '2.x';
+
+  for (const file of listIntentFiles(intentsDir)) {
+    const intentPath = join(intentsDir, file);
+    let intent;
+    try {
+      intent = JSON.parse(readFileSync(intentPath, 'utf8'));
+    } catch {
+      continue;
+    }
+
+    if (!intent || !DISPATCHABLE_STATUSES.has(intent.status)) continue;
+    if (intent.cross_run_durable === true) continue;
+    if (intent.approved_run_id) continue;
+
+    const prevStatus = intent.status;
+    intent.status = 'archived_migration';
+    intent.updated_at = now;
+    intent.archived_reason = `pre-BUG-34 intent with no run scope; archived during v${protocolVersion} migration on run ${runId}`;
+    if (!intent.history) intent.history = [];
+    intent.history.push({
+      from: prevStatus,
+      to: 'archived_migration',
+      at: now,
+      reason: intent.archived_reason,
+    });
+    safeWriteJson(intentPath, intent);
+    if (intent.intent_id) archivedMigrationIntentIds.push(intent.intent_id);
+  }
+
+  return {
+    archived_migration_count: archivedMigrationIntentIds.length,
+    archived_migration_intent_ids: archivedMigrationIntentIds,
+    migration_notice: formatLegacyIntentMigrationNotice(archivedMigrationIntentIds),
+  };
+}
+
+export function archiveStaleIntentsForRun(root, runId, options = {}) {
+  const intentsDir = getIntentsDir(root);
+  if (!existsSync(intentsDir)) {
+    return {
+      archived: 0,
+      adopted: 0,
+      archived_migration_count: 0,
+      archived_migration_intent_ids: [],
+      migration_notice: null,
+    };
+  }
+
+  const now = nowISO();
+  let archived = 0;
+  let adopted = 0;
+
+  for (const file of listIntentFiles(intentsDir)) {
+    const intentPath = join(intentsDir, file);
+    let intent;
+    try {
+      intent = JSON.parse(readFileSync(intentPath, 'utf8'));
+    } catch {
+      continue;
+    }
+
+    if (!intent || !DISPATCHABLE_STATUSES.has(intent.status)) continue;
+
+    if (intent.cross_run_durable === true && !intent.approved_run_id) {
+      intent.approved_run_id = runId;
+      delete intent.cross_run_durable;
+      intent.updated_at = now;
+      if (!intent.history) intent.history = [];
+      intent.history.push({
+        from: intent.status,
+        to: intent.status,
+        at: now,
+        reason: `pre-run durable approval bound to run ${runId}`,
+      });
+      safeWriteJson(intentPath, intent);
+      adopted += 1;
+      continue;
+    }
+
+    if (intent.cross_run_durable === true && intent.approved_run_id === runId) {
+      delete intent.cross_run_durable;
+      intent.updated_at = now;
+      safeWriteJson(intentPath, intent);
+      continue;
+    }
+
+    if (intent.approved_run_id && intent.approved_run_id !== runId) {
+      const prevStatus = intent.status;
+      intent.status = 'suppressed';
+      intent.updated_at = now;
+      intent.archived_reason = `stale: approved under run ${intent.approved_run_id}, archived on run ${runId} initialization`;
+      if (!intent.history) intent.history = [];
+      intent.history.push({
+        from: prevStatus,
+        to: 'suppressed',
+        at: now,
+        reason: intent.archived_reason,
+      });
+      safeWriteJson(intentPath, intent);
+      archived += 1;
+    }
+  }
+
+  const migration = migratePreBug34Intents(root, runId, options);
+
+  return {
+    archived,
+    adopted,
+    archived_migration_count: migration.archived_migration_count,
+    archived_migration_intent_ids: migration.archived_migration_intent_ids,
+    migration_notice: migration.migration_notice,
+  };
+}