agentxchain 2.117.0 → 2.119.0

package/bin/agentxchain.js

@@ -676,6 +676,7 @@ program
   .option('--max-runs <n>', 'Maximum consecutive governed runs in continuous mode (default: 100)', parseInt)
   .option('--poll-seconds <n>', 'Seconds between idle-detection cycles in continuous mode (default: 30)', parseInt)
   .option('--max-idle-cycles <n>', 'Stop after N consecutive idle cycles with no derivable work (default: 3)', parseInt)
+  .option('--session-budget <usd>', 'Cumulative session-level budget cap in USD for continuous mode', parseFloat)
   .action(runCommand);
 
 program

package/package.json

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

package/scripts/render-github-release-body.mjs

@@ -70,7 +70,7 @@ function extractAggregateEvidenceLine(text) {
     return best;
   }, null);
 
-  return aggregate.line.replace(/\*\*/g, '').replace(/`/g, '').trim();
+  return aggregate.line.replace(/\*\*/g, '').replace(/`/g, '').replace(/,/g, '').trim();
 }
 
 function getPreviousVersionTag(repoRoot, version) {

package/src/commands/run.js

@@ -57,10 +57,17 @@ export async function runCommand(opts) {
   // Continuous vision-driven mode
   const contOpts = resolveContinuousOptions(opts, context.config);
   if (contOpts.enabled) {
+    if (contOpts.perSessionMaxUsd != null && (!Number.isFinite(contOpts.perSessionMaxUsd) || contOpts.perSessionMaxUsd <= 0)) {
+      console.log(chalk.red('--session-budget must be a finite number greater than 0'));
+      process.exit(1);
+    }
     console.log(chalk.cyan.bold('agentxchain run --continuous'));
     console.log(chalk.dim(`  Vision: ${contOpts.visionPath}`));
     console.log(chalk.dim(`  Max runs: ${contOpts.maxRuns}, Poll: ${contOpts.pollSeconds}s, Idle limit: ${contOpts.maxIdleCycles}`));
     console.log(chalk.dim(`  Triage approval: ${contOpts.triageApproval}`));
+    if (contOpts.perSessionMaxUsd != null) {
+      console.log(chalk.dim(`  Session budget: $${contOpts.perSessionMaxUsd.toFixed(2)}`));
+    }
     console.log('');
     const { exitCode } = await executeContinuousRun(context, contOpts, executeGovernedRun);
     process.exit(exitCode);

package/src/commands/schedule.js

@@ -15,6 +15,15 @@ import {
 } from '../lib/run-schedule.js';
 import { consumePreemptionMarker } from '../lib/intake.js';
 import { executeGovernedRun } from './run.js';
+import {
+  readContinuousSession,
+  writeContinuousSession,
+  advanceContinuousRunOnce,
+  resolveContinuousOptions,
+} from '../lib/continuous-run.js';
+import { resolveVisionPath } from '../lib/vision-reader.js';
+import { existsSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
 
 function loadScheduleContext() {
   const context = loadProjectContext();
@@ -227,6 +236,10 @@ async function runDueSchedules(context, opts = {}) {
   const results = [];
 
   for (const entry of resolved.entries) {
+    // Skip entries handled by the continuous session manager
+    if (opts.excludeSchedule && entry.id === opts.excludeSchedule) {
+      continue;
+    }
     if (!entry.enabled) {
       results.push({ id: entry.id, action: 'disabled' });
       continue;
@@ -311,6 +324,166 @@ async function runDueSchedules(context, opts = {}) {
   return { ok: true, exitCode: 0, results };
 }
 
+// ---------------------------------------------------------------------------
+// Schedule-owned continuous session management
+// ---------------------------------------------------------------------------
+
+function isSessionTerminal(session) {
+  return ['completed', 'idle_exit', 'failed', 'stopped'].includes(session?.status);
+}
+
+export function selectContinuousScheduleEntry(root, config, opts = {}) {
+  const entries = listSchedules(root, config, { at: opts.at });
+  const continuousEntries = entries.filter((entry) => config?.schedules?.[entry.id]?.continuous?.enabled === true);
+
+  if (continuousEntries.length === 0) {
+    return null;
+  }
+
+  if (opts.scheduleId) {
+    const selected = continuousEntries.find((entry) => entry.id === opts.scheduleId);
+    return selected
+      ? { id: selected.id, schedule: config.schedules[selected.id], due: selected.due }
+      : null;
+  }
+
+  const activeSession = readContinuousSession(root);
+  if (activeSession && !isSessionTerminal(activeSession) && activeSession.owner_type === 'schedule') {
+    const ownerEntry = continuousEntries.find((entry) => entry.id === activeSession.owner_id);
+    if (!ownerEntry) {
+      return {
+        id: activeSession.owner_id,
+        error: `active continuous session owned by unknown schedule "${activeSession.owner_id}"`,
+      };
+    }
+    return { id: ownerEntry.id, schedule: config.schedules[ownerEntry.id], due: ownerEntry.due };
+  }
+
+  const dueEntry = continuousEntries.find((entry) => entry.due);
+  if (!dueEntry) {
+    return null;
+  }
+
+  return { id: dueEntry.id, schedule: config.schedules[dueEntry.id], due: dueEntry.due };
+}
+
+function createScheduleOwnedSession(schedule, scheduleId) {
+  return {
+    session_id: `cont-${randomUUID().slice(0, 8)}`,
+    started_at: new Date().toISOString(),
+    vision_path: schedule.continuous.vision_path,
+    runs_completed: 0,
+    max_runs: schedule.continuous.max_runs,
+    idle_cycles: 0,
+    max_idle_cycles: schedule.continuous.max_idle_cycles,
+    current_run_id: null,
+    current_vision_objective: null,
+    status: 'running',
+    owner_type: 'schedule',
+    owner_id: scheduleId,
+    per_session_max_usd: schedule.continuous.per_session_max_usd || null,
+    cumulative_spent_usd: 0,
+    budget_exhausted: false,
+  };
+}
+
+async function advanceScheduleContinuousSession(context, entry, opts = {}) {
+  const { root, config } = context;
+  const scheduleId = entry.id;
+  const schedule = entry.schedule;
+  const contConfig = schedule.continuous;
+  const log = opts.json ? () => {} : console.log;
+
+  // Read existing session
+  let session = readContinuousSession(root);
+
+  // If there's an active session owned by a different schedule, fail closed
+  if (session && !isSessionTerminal(session) && session.owner_type === 'schedule' && session.owner_id !== scheduleId) {
+    return {
+      ok: false,
+      action: 'skipped',
+      reason: `continuous session owned by schedule "${session.owner_id}"`,
+    };
+  }
+
+  // Determine if we need a new session
+  const needsNewSession = !session || isSessionTerminal(session) || session.owner_id !== scheduleId;
+
+  if (needsNewSession) {
+    // Only start a new session if the schedule is due
+    if (!opts.isDue) {
+      return { ok: true, action: 'not_due', reason: 'waiting_interval' };
+    }
+
+    // Check launch eligibility
+    const eligibility = evaluateScheduleLaunchEligibility(root, config);
+    if (!eligibility.ok) {
+      return { ok: false, action: 'skipped', reason: eligibility.reason };
+    }
+
+    // Validate vision path
+    const absVision = resolveVisionPath(root, contConfig.vision_path);
+    if (!existsSync(absVision)) {
+      return { ok: false, action: 'failed', reason: `VISION.md not found at ${absVision}` };
+    }
+
+    session = createScheduleOwnedSession(schedule, scheduleId);
+    writeContinuousSession(root, session);
+    log(chalk.cyan(`Started schedule-owned continuous session: ${session.session_id} (schedule: ${scheduleId})`));
+
+    // Record schedule start
+    updateScheduleState(root, config, scheduleId, (record) => ({
+      ...record,
+      last_started_at: new Date().toISOString(),
+      last_status: 'continuous_running',
+      last_continuous_session_id: session.session_id,
+    }));
+  }
+
+  // Build contOpts from schedule continuous config
+  const contOpts = {
+    visionPath: contConfig.vision_path,
+    maxRuns: contConfig.max_runs,
+    maxIdleCycles: contConfig.max_idle_cycles,
+    triageApproval: contConfig.triage_approval,
+    perSessionMaxUsd: contConfig.per_session_max_usd || null,
+  };
+
+  // Advance one step
+  const step = await advanceContinuousRunOnce(context, session, contOpts, executeGovernedRun, log);
+
+  // Update schedule state based on step result
+  const statusMap = {
+    completed: 'continuous_completed',
+    idle_exit: 'continuous_idle_exit',
+    failed: 'continuous_failed',
+    blocked: 'continuous_blocked',
+    running: 'continuous_running',
+  };
+  let schedStatus = statusMap[step.status] || 'continuous_running';
+  if (step.action === 'session_budget_exhausted') {
+    schedStatus = 'continuous_session_budget_exhausted';
+  }
+
+  updateScheduleState(root, config, scheduleId, (record) => ({
+    ...record,
+    last_finished_at: new Date().toISOString(),
+    last_status: schedStatus,
+    last_run_id: step.run_id || record.last_run_id,
+    last_continuous_session_id: session.session_id,
+  }));
+
+  return {
+    ok: step.ok,
+    action: step.action,
+    status: step.status,
+    session_id: session.session_id,
+    run_id: step.run_id || null,
+    intent_id: step.intent_id || null,
+    runs_completed: session.runs_completed,
+  };
+}
+
 export async function scheduleListCommand(opts) {
   const context = loadScheduleContext();
   if (!context) return;
@@ -480,11 +653,66 @@ export async function scheduleDaemonCommand(opts) {
   while (true) {
     cycle += 1;
     daemonState.last_cycle_started_at = new Date().toISOString();
-    const result = await runDueSchedules(context, {
-      ...opts,
-      continueActiveScheduleRuns: true,
-      tolerateBlockedRun: true,
+
+    // Check for continuous schedule entries first
+    const contEntry = selectContinuousScheduleEntry(context.root, context.config, {
+      scheduleId: opts.schedule || null,
+      at: opts.at,
     });
+    let result;
+
+    if (contEntry?.error) {
+      result = {
+        ok: false,
+        exitCode: 1,
+        results: [{
+          id: contEntry.id,
+          action: 'failed',
+          continuous: true,
+          reason: contEntry.error,
+        }],
+      };
+    } else if (contEntry) {
+      const isDue = contEntry.due ?? false;
+
+      const contResult = await advanceScheduleContinuousSession(context, contEntry, {
+        isDue,
+        json: opts.json,
+        at: opts.at,
+      });
+
+      // Run non-continuous schedules normally alongside
+      const nonContResult = await runDueSchedules(context, {
+        ...opts,
+        continueActiveScheduleRuns: true,
+        tolerateBlockedRun: true,
+        excludeSchedule: contEntry.id,
+      });
+
+      // Merge results
+      const contResultEntry = {
+        id: contEntry.id,
+        action: contResult.action,
+        continuous: true,
+        session_id: contResult.session_id || null,
+        status: contResult.status || null,
+        run_id: contResult.run_id || null,
+        runs_completed: contResult.runs_completed ?? null,
+      };
+      if (contResult.reason) contResultEntry.reason = contResult.reason;
+
+      result = {
+        ok: contResult.ok !== false && nonContResult.ok,
+        exitCode: (contResult.ok === false || !nonContResult.ok) ? 1 : 0,
+        results: [contResultEntry, ...nonContResult.results],
+      };
+    } else {
+      result = await runDueSchedules(context, {
+        ...opts,
+        continueActiveScheduleRuns: true,
+        tolerateBlockedRun: true,
+      });
+    }
 
     updateDaemonHeartbeat(context.root, daemonState, result);
 

package/src/commands/status.js

@@ -206,12 +206,26 @@ function renderGovernedStatus(context, opts) {
     console.log(chalk.dim(`  Vision:      ${continuousSession.vision_path}`));
     console.log(`  Status:      ${chalk.cyan(continuousSession.status || 'unknown')}`);
     console.log(`  Runs:        ${continuousSession.runs_completed || 0}/${continuousSession.max_runs || '?'}`);
+    if (continuousSession.owner_type === 'schedule') {
+      console.log(chalk.dim(`  Owner:       schedule:${continuousSession.owner_id}`));
+    }
     if (continuousSession.current_vision_objective) {
       console.log(`  Objective:   ${chalk.yellow(continuousSession.current_vision_objective)}`);
     }
     if (continuousSession.idle_cycles > 0) {
       console.log(chalk.dim(`  Idle cycles: ${continuousSession.idle_cycles}/${continuousSession.max_idle_cycles}`));
     }
+    if (continuousSession.per_session_max_usd != null) {
+      const spent = (continuousSession.cumulative_spent_usd || 0).toFixed(2);
+      const limit = continuousSession.per_session_max_usd.toFixed(2);
+      const pct = continuousSession.per_session_max_usd > 0
+        ? ((continuousSession.cumulative_spent_usd || 0) / continuousSession.per_session_max_usd * 100).toFixed(1)
+        : '0.0';
+      const budgetStr = continuousSession.budget_exhausted
+        ? chalk.red(`$${spent} / $${limit} (${pct}%) [EXHAUSTED]`)
+        : `$${spent} / $${limit} (${pct}%)`;
+      console.log(`  Budget:      ${budgetStr}`);
+    }
     console.log(chalk.dim('  ' + '─'.repeat(44)));
     console.log('');
   }

package/src/lib/continuous-run.js

@@ -54,7 +54,7 @@ export function removeContinuousSession(root) {
   }
 }
 
-function createSession(visionPath, maxRuns, maxIdleCycles) {
+function createSession(visionPath, maxRuns, maxIdleCycles, perSessionMaxUsd) {
   return {
     session_id: `cont-${randomUUID().slice(0, 8)}`,
     started_at: new Date().toISOString(),
@@ -66,9 +66,25 @@ function createSession(visionPath, maxRuns, maxIdleCycles) {
     current_run_id: null,
     current_vision_objective: null,
     status: 'running',
+    per_session_max_usd: perSessionMaxUsd || null,
+    cumulative_spent_usd: 0,
+    budget_exhausted: false,
   };
 }
 
+function describeContinuousTerminalStep(step, contOpts) {
+  if (step.action === 'max_runs_reached') {
+    return `Max runs reached (${contOpts.maxRuns}). Stopping.`;
+  }
+  if (step.action === 'session_budget_exhausted') {
+    return 'Session budget exhausted. Stopping.';
+  }
+  if (step.status === 'idle_exit') {
+    return `All vision goals appear addressed (${contOpts.maxIdleCycles} consecutive idle cycles). Stopping.`;
+  }
+  return null;
+}
+
 // ---------------------------------------------------------------------------
 // Intake queue check
 // ---------------------------------------------------------------------------
@@ -274,11 +290,174 @@ export function resolveContinuousOptions(opts, config) {
     maxIdleCycles: opts.maxIdleCycles ?? configCont.max_idle_cycles ?? 3,
     triageApproval: configCont.triage_approval ?? 'auto',
     cooldownSeconds: opts.cooldownSeconds ?? configCont.cooldown_seconds ?? 5,
+    perSessionMaxUsd: opts.sessionBudget ?? configCont.per_session_max_usd ?? null,
   };
 }
 
 // ---------------------------------------------------------------------------
-// Main continuous loop
+// Single-step continuous advancement primitive
+// ---------------------------------------------------------------------------
+
+/**
+ * Advance a continuous session by exactly one step.
+ *
+ * This is the shared primitive used by both `run --continuous` (CLI-owned loop)
+ * and `schedule daemon` (daemon-owned poll). Neither caller embeds a nested
+ * poll/sleep loop — the caller owns cadence, this function owns one step.
+ *
+ * @param {object} context - { root, config }
+ * @param {object} session - mutable session object (read/written by caller)
+ * @param {object} contOpts - resolved continuous options (visionPath, maxRuns, maxIdleCycles, triageApproval)
+ * @param {Function} executeGovernedRun - the run executor function
+ * @param {Function} [log] - logging function
+ * @returns {Promise<{ ok: boolean, status: string, action: string, run_id?: string, intent_id?: string, stop_reason?: string }>}
+ */
+export async function advanceContinuousRunOnce(context, session, contOpts, executeGovernedRun, log = console.log) {
+  const { root } = context;
+  const absVisionPath = resolveVisionPath(root, contOpts.visionPath);
+
+  // Terminal checks
+  if (session.runs_completed >= contOpts.maxRuns) {
+    session.status = 'completed';
+    writeContinuousSession(root, session);
+    return { ok: true, status: 'completed', action: 'max_runs_reached', stop_reason: 'max_runs' };
+  }
+
+  if (session.idle_cycles >= contOpts.maxIdleCycles) {
+    session.status = 'completed';
+    writeContinuousSession(root, session);
+    return { ok: true, status: 'idle_exit', action: 'max_idle_reached', stop_reason: 'idle_exit' };
+  }
+
+  // Session budget check (cumulative spend across all runs)
+  const sessionBudget = session.per_session_max_usd ?? contOpts.perSessionMaxUsd ?? null;
+  if (sessionBudget != null && (session.cumulative_spent_usd || 0) >= sessionBudget) {
+    session.status = 'completed';
+    session.budget_exhausted = true;
+    writeContinuousSession(root, session);
+    log(`Session budget exhausted: $${(session.cumulative_spent_usd || 0).toFixed(2)} spent of $${sessionBudget.toFixed(2)} limit.`);
+    return { ok: true, status: 'completed', action: 'session_budget_exhausted', stop_reason: 'session_budget' };
+  }
+
+  // Validate vision file
+  if (!existsSync(absVisionPath)) {
+    session.status = 'failed';
+    writeContinuousSession(root, session);
+    return { ok: false, status: 'failed', action: 'vision_missing', stop_reason: `VISION.md not found at ${absVisionPath}` };
+  }
+
+  // Step 1: Check intake queue for pending work
+  const queued = findNextQueuedIntent(root);
+  let targetIntentId = null;
+  let visionObjective = null;
+
+  if (queued.ok) {
+    targetIntentId = queued.intentId;
+    session.idle_cycles = 0;
+    log(`Found queued intent: ${queued.intentId} (${queued.status})`);
+  } else {
+    // Step 2: Derive from vision
+    const seeded = seedFromVision(root, absVisionPath, {
+      triageApproval: contOpts.triageApproval,
+    });
+
+    if (!seeded.ok) {
+      log(`Vision scan error: ${seeded.error}`);
+      session.status = 'failed';
+      writeContinuousSession(root, session);
+      return { ok: false, status: 'failed', action: 'vision_scan_error', stop_reason: seeded.error };
+    }
+
+    if (seeded.idle) {
+      session.idle_cycles += 1;
+      log(`Idle cycle ${session.idle_cycles}/${contOpts.maxIdleCycles} — no derivable work from vision.`);
+      writeContinuousSession(root, session);
+      return { ok: true, status: 'running', action: 'no_work_found' };
+    }
+
+    // If triage_approval is "human", the intent is in "triaged" state — don't auto-start
+    if (contOpts.triageApproval === 'human') {
+      log(`Vision-derived intent ${seeded.intentId} left in triaged state (triage_approval: human).`);
+      session.idle_cycles += 1;
+      writeContinuousSession(root, session);
+      return { ok: true, status: 'running', action: 'waited_for_human', intent_id: seeded.intentId };
+    }
+
+    targetIntentId = seeded.intentId;
+    visionObjective = `${seeded.section}: ${seeded.goal}`;
+    session.idle_cycles = 0;
+    log(`Vision-derived: ${visionObjective}`);
+  }
+
+  // Prepare intent through intake lifecycle
+  const provenance = buildContinuousProvenance(targetIntentId, {
+    trigger: visionObjective ? 'vision_scan' : 'intake',
+    triggerReason: visionObjective || readIntent(root, targetIntentId)?.charter || null,
+  });
+  const preparedIntent = prepareIntentForRun(root, targetIntentId, { provenance });
+  if (!preparedIntent.ok) {
+    log(`Continuous start error: ${preparedIntent.error}`);
+    session.status = 'failed';
+    writeContinuousSession(root, session);
+    return { ok: false, status: 'failed', action: 'prepare_failed', stop_reason: preparedIntent.error, intent_id: targetIntentId };
+  }
+
+  // Execute the governed run
+  session.current_run_id = preparedIntent.runId;
+  session.current_vision_objective = visionObjective || preparedIntent.intent?.charter || null;
+  session.status = 'running';
+  writeContinuousSession(root, session);
+
+  const execution = await executeGovernedRun(context, {
+    autoApprove: true,
+    report: true,
+    log,
+  });
+
+  session.runs_completed += 1;
+  session.current_run_id = execution.result?.state?.run_id || null;
+
+  // Accumulate cost from this run into the session total
+  const runSpentUsd = execution.result?.state?.budget_status?.spent_usd || 0;
+  session.cumulative_spent_usd = (session.cumulative_spent_usd || 0) + runSpentUsd;
+
+  const stopReason = execution.result?.stop_reason;
+  log(`Run ${session.runs_completed}/${contOpts.maxRuns} completed: ${stopReason || 'unknown'}`);
+
+  // Resolve the consumed intent
+  const resolved = resolveIntent(root, targetIntentId);
+  if (!resolved.ok) {
+    log(`Continuous resolve error: ${resolved.error}`);
+    session.status = 'failed';
+    writeContinuousSession(root, session);
+    return { ok: false, status: 'failed', action: 'resolve_failed', stop_reason: resolved.error, intent_id: targetIntentId };
+  }
+
+  if (stopReason === 'blocked') {
+    session.status = 'paused';
+    log('Run blocked — continuous loop paused. Use `agentxchain unblock <id>` to resume.');
+    writeContinuousSession(root, session);
+    return { ok: true, status: 'blocked', action: 'run_blocked', run_id: session.current_run_id, intent_id: targetIntentId };
+  }
+
+  if (stopReason === 'priority_preempted') {
+    log('Priority preemption detected — consuming injected work next cycle.');
+    writeContinuousSession(root, session);
+    return { ok: true, status: 'running', action: 'consumed_injected_priority', run_id: session.current_run_id, intent_id: targetIntentId };
+  }
+
+  writeContinuousSession(root, session);
+  return {
+    ok: true,
+    status: 'running',
+    action: visionObjective ? 'seeded_from_vision' : 'started_run',
+    run_id: session.current_run_id,
+    intent_id: targetIntentId,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Main continuous loop (CLI-owned, built on advanceContinuousRunOnce)
 // ---------------------------------------------------------------------------
 
 /**
@@ -293,7 +472,6 @@ export function resolveContinuousOptions(opts, config) {
 export async function executeContinuousRun(context, contOpts, executeGovernedRun, log = console.log) {
   const { root } = context;
   const absVisionPath = resolveVisionPath(root, contOpts.visionPath);
-  let exitCode = 0;
 
   // Validate vision file exists
   if (!existsSync(absVisionPath)) {
@@ -302,7 +480,7 @@ export async function executeContinuousRun(context, contOpts, executeGovernedRun
     return { exitCode: 1, session: null };
   }
 
-  const session = createSession(contOpts.visionPath, contOpts.maxRuns, contOpts.maxIdleCycles);
+  const session = createSession(contOpts.visionPath, contOpts.maxRuns, contOpts.maxIdleCycles, contOpts.perSessionMaxUsd);
   writeContinuousSession(root, session);
 
   // SIGINT handler
@@ -315,122 +493,25 @@ export async function executeContinuousRun(context, contOpts, executeGovernedRun
 
   try {
     while (!stopping) {
-      // Check max runs
-      if (session.runs_completed >= contOpts.maxRuns) {
-        session.status = 'completed';
-        log(`Max runs reached (${contOpts.maxRuns}). Stopping.`);
-        break;
-      }
+      const step = await advanceContinuousRunOnce(context, session, contOpts, executeGovernedRun, log);
 
-      // Check max idle cycles
-      if (session.idle_cycles >= contOpts.maxIdleCycles) {
-        session.status = 'completed';
-        log(`All vision goals appear addressed (${contOpts.maxIdleCycles} consecutive idle cycles). Stopping.`);
-        break;
-      }
-
-      // Step 1: Check intake queue for pending work
-      const queued = findNextQueuedIntent(root);
-      let targetIntentId = null;
-      let visionObjective = null;
-      let preparedIntent = null;
-
-      if (queued.ok) {
-        targetIntentId = queued.intentId;
-        session.idle_cycles = 0;
-        log(`Found queued intent: ${queued.intentId} (${queued.status})`);
-      } else {
-        // Step 2: Derive from vision
-        const seeded = seedFromVision(root, absVisionPath, {
-          triageApproval: contOpts.triageApproval,
-        });
-
-        if (!seeded.ok) {
-          log(`Vision scan error: ${seeded.error}`);
-          session.status = 'stopped';
-          exitCode = 1;
-          break;
-        }
-
-        if (seeded.idle) {
-          session.idle_cycles += 1;
-          log(`Idle cycle ${session.idle_cycles}/${contOpts.maxIdleCycles} — no derivable work from vision.`);
-          writeContinuousSession(root, session);
-          if (session.idle_cycles >= contOpts.maxIdleCycles) continue;
-          await new Promise(r => setTimeout(r, contOpts.pollSeconds * 1000));
-          continue;
-        }
-
-        // If triage_approval is "human", the intent is in "triaged" state — don't auto-start
-        if (contOpts.triageApproval === 'human') {
-          log(`Vision-derived intent ${seeded.intentId} left in triaged state (triage_approval: human).`);
-          session.idle_cycles += 1;
-          writeContinuousSession(root, session);
-          await new Promise(r => setTimeout(r, contOpts.pollSeconds * 1000));
-          continue;
+      // Terminal states
+      if (step.status === 'completed' || step.status === 'idle_exit' || step.status === 'failed' || step.status === 'blocked') {
+        const terminalMessage = describeContinuousTerminalStep(step, contOpts);
+        if (terminalMessage) {
+          log(terminalMessage);
         }
-
-        targetIntentId = seeded.intentId;
-        visionObjective = `${seeded.section}: ${seeded.goal}`;
-        session.idle_cycles = 0;
-        log(`Vision-derived: ${visionObjective}`);
-      }
-
-      const provenance = buildContinuousProvenance(targetIntentId, {
-        trigger: visionObjective ? 'vision_scan' : 'intake',
-        triggerReason: visionObjective || readIntent(root, targetIntentId)?.charter || null,
-      });
-      preparedIntent = prepareIntentForRun(root, targetIntentId, { provenance });
-      if (!preparedIntent.ok) {
-        log(`Continuous start error: ${preparedIntent.error}`);
-        session.status = 'stopped';
-        exitCode = 1;
-        break;
+        return { exitCode: step.ok ? 0 : 1, session };
       }
 
-      // Step 3: Execute the prepared governed run.
-      session.current_run_id = preparedIntent.runId;
-      session.current_vision_objective = visionObjective || preparedIntent.intent?.charter || null;
-      session.status = 'running';
-      writeContinuousSession(root, session);
-
-      const execution = await executeGovernedRun(context, {
-        autoApprove: true,
-        report: true,
-        log,
-      });
-
-      session.runs_completed += 1;
-      session.current_run_id = execution.result?.state?.run_id || null;
-
-      const stopReason = execution.result?.stop_reason;
-      log(`Run ${session.runs_completed}/${contOpts.maxRuns} completed: ${stopReason || 'unknown'}`);
-
-      const resolved = resolveIntent(root, targetIntentId);
-      if (!resolved.ok) {
-        log(`Continuous resolve error: ${resolved.error}`);
-        session.status = 'stopped';
-        writeContinuousSession(root, session);
-        return { exitCode: 1, session };
-      }
-
-      if (stopReason === 'blocked') {
-        session.status = 'paused';
-        log('Run blocked — continuous loop paused. Use `agentxchain unblock <id>` to resume.');
-        writeContinuousSession(root, session);
-        break;
-      }
-
-      if (stopReason === 'priority_preempted') {
-        log('Priority preemption detected — consuming injected work next cycle.');
-      }
-
-      writeContinuousSession(root, session);
-
-      // Brief cooldown between runs
-      const cooldownMs = (contOpts.cooldownSeconds ?? 5) * 1000;
-      if (!stopping && session.runs_completed < contOpts.maxRuns && cooldownMs > 0) {
-        await new Promise(r => setTimeout(r, cooldownMs));
+      // Non-terminal: sleep before next step
+      if (!stopping) {
+        const sleepMs = step.action === 'no_work_found' || step.action === 'waited_for_human'
+          ? contOpts.pollSeconds * 1000
+          : (contOpts.cooldownSeconds ?? 5) * 1000;
+        if (sleepMs > 0) {
+          await new Promise(r => setTimeout(r, sleepMs));
+        }
       }
     }
 
@@ -440,7 +521,7 @@ export async function executeContinuousRun(context, contOpts, executeGovernedRun
     }
 
     writeContinuousSession(root, session);
-    return { exitCode, session };
+    return { exitCode: 0, session };
 
   } finally {
     process.removeListener('SIGINT', sigHandler);

package/src/lib/normalized-config.js

@@ -689,6 +689,37 @@ export function validateSchedulesConfig(schedules, roles) {
         errors.push(`Schedule "${scheduleId}": initial_role "${schedule.initial_role}" is not a defined role`);
       }
     }
+
+    // Continuous mode validation
+    if ('continuous' in schedule && schedule.continuous != null) {
+      const cont = schedule.continuous;
+      if (typeof cont !== 'object' || Array.isArray(cont)) {
+        errors.push(`Schedule "${scheduleId}": continuous must be an object`);
+      } else {
+        if ('enabled' in cont && typeof cont.enabled !== 'boolean') {
+          errors.push(`Schedule "${scheduleId}": continuous.enabled must be a boolean`);
+        }
+        if (cont.enabled === true && (!cont.vision_path || typeof cont.vision_path !== 'string' || !cont.vision_path.trim())) {
+          errors.push(`Schedule "${scheduleId}": continuous.vision_path is required when continuous.enabled is true`);
+        }
+        if ('max_runs' in cont && (!Number.isInteger(cont.max_runs) || cont.max_runs < 1)) {
+          errors.push(`Schedule "${scheduleId}": continuous.max_runs must be an integer >= 1`);
+        }
+        if ('max_idle_cycles' in cont && (!Number.isInteger(cont.max_idle_cycles) || cont.max_idle_cycles < 1)) {
+          errors.push(`Schedule "${scheduleId}": continuous.max_idle_cycles must be an integer >= 1`);
+        }
+        if ('triage_approval' in cont && cont.triage_approval !== 'auto' && cont.triage_approval !== 'human') {
+          errors.push(`Schedule "${scheduleId}": continuous.triage_approval must be "auto" or "human"`);
+        }
+        if ('per_session_max_usd' in cont && cont.per_session_max_usd != null) {
+          if (typeof cont.per_session_max_usd !== 'number' || !Number.isFinite(cont.per_session_max_usd)) {
+            errors.push(`Schedule "${scheduleId}": continuous.per_session_max_usd must be a finite number when provided`);
+          } else if (cont.per_session_max_usd <= 0) {
+            errors.push(`Schedule "${scheduleId}": continuous.per_session_max_usd must be greater than 0 when provided`);
+          }
+        }
+      }
+    }
   }
 
   return { ok: errors.length === 0, errors };
@@ -1120,6 +1151,21 @@ export function normalizeV4(raw) {
   };
 }
 
+function normalizeContinuousConfig(raw) {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+  if (raw.enabled !== true) return null;
+  return {
+    enabled: true,
+    vision_path: raw.vision_path || '.planning/VISION.md',
+    max_runs: Number.isInteger(raw.max_runs) && raw.max_runs >= 1 ? raw.max_runs : 50,
+    max_idle_cycles: Number.isInteger(raw.max_idle_cycles) && raw.max_idle_cycles >= 1 ? raw.max_idle_cycles : 5,
+    triage_approval: raw.triage_approval === 'human' ? 'human' : 'auto',
+    per_session_max_usd: Number.isFinite(raw.per_session_max_usd) && raw.per_session_max_usd > 0
+      ? raw.per_session_max_usd
+      : null,
+  };
+}
+
 function normalizeSchedules(rawSchedules) {
   if (!rawSchedules || typeof rawSchedules !== 'object' || Array.isArray(rawSchedules)) {
     return {};
@@ -1135,6 +1181,7 @@ function normalizeSchedules(rawSchedules) {
         max_turns: schedule?.max_turns ?? 50,
         initial_role: schedule?.initial_role || null,
         trigger_reason: schedule?.trigger_reason?.trim() || `schedule:${scheduleId}`,
+        continuous: normalizeContinuousConfig(schedule?.continuous),
       },
     ]),
   );

package/src/lib/run-schedule.js

@@ -27,6 +27,7 @@ function normalizeScheduleStateRecord(value) {
       last_status: null,
       last_skip_at: null,
       last_skip_reason: null,
+      last_continuous_session_id: null,
     };
   }
 
@@ -37,6 +38,7 @@ function normalizeScheduleStateRecord(value) {
     last_status: typeof value.last_status === 'string' ? value.last_status : null,
     last_skip_at: typeof value.last_skip_at === 'string' ? value.last_skip_at : null,
     last_skip_reason: typeof value.last_skip_reason === 'string' ? value.last_skip_reason : null,
+    last_continuous_session_id: typeof value.last_continuous_session_id === 'string' ? value.last_continuous_session_id : null,
   };
 }