agentxchain 2.118.0 → 2.120.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.118.0",
+  "version": "2.120.0",
   "description": "CLI for AgentXchain — governed multi-agent software delivery",
   "type": "module",
   "bin": {

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);
@@ -194,10 +201,10 @@ export async function executeGovernedRun(context, opts = {}) {
   const onSigint = () => {
     sigintCount++;
     if (sigintCount >= 2) {
+      controller.abort();
       process.exit(130);
     }
     aborted = true;
-    controller.abort();
     log(chalk.yellow('\nSIGINT received — finishing current turn, then stopping.'));
   };
   process.on('SIGINT', onSigint);

package/src/commands/schedule.js

@@ -234,10 +234,12 @@ async function runDueSchedules(context, opts = {}) {
 
   const nowIso = opts.at || new Date().toISOString();
   const results = [];
+  const excludedSchedules = new Set(opts.excludeSchedules || []);
 
   for (const entry of resolved.entries) {
-    // Skip entries handled by the continuous session manager
-    if (opts.excludeSchedule && entry.id === opts.excludeSchedule) {
+    // Skip entries handled by the continuous session manager.
+    if ((opts.excludeSchedule && entry.id === opts.excludeSchedule)
+      || excludedSchedules.has(entry.id)) {
       continue;
     }
     if (!entry.enabled) {
@@ -332,6 +334,12 @@ function isSessionTerminal(session) {
   return ['completed', 'idle_exit', 'failed', 'stopped'].includes(session?.status);
 }
 
+function getContinuousEnabledScheduleIds(config) {
+  return Object.entries(config?.schedules || {})
+    .filter(([, schedule]) => schedule?.continuous?.enabled === true)
+    .map(([id]) => id);
+}
+
 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);
@@ -381,6 +389,9 @@ function createScheduleOwnedSession(schedule, scheduleId) {
     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,
   };
 }
 
@@ -443,6 +454,7 @@ async function advanceScheduleContinuousSession(context, entry, opts = {}) {
     maxRuns: contConfig.max_runs,
     maxIdleCycles: contConfig.max_idle_cycles,
     triageApproval: contConfig.triage_approval,
+    perSessionMaxUsd: contConfig.per_session_max_usd || null,
   };
 
   // Advance one step
@@ -456,7 +468,10 @@ async function advanceScheduleContinuousSession(context, entry, opts = {}) {
     blocked: 'continuous_blocked',
     running: 'continuous_running',
   };
-  const schedStatus = statusMap[step.status] || '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,
@@ -646,6 +661,7 @@ export async function scheduleDaemonCommand(opts) {
   while (true) {
     cycle += 1;
     daemonState.last_cycle_started_at = new Date().toISOString();
+    const continuousScheduleIds = getContinuousEnabledScheduleIds(context.config);
 
     // Check for continuous schedule entries first
     const contEntry = selectContinuousScheduleEntry(context.root, context.config, {
@@ -679,7 +695,7 @@ export async function scheduleDaemonCommand(opts) {
         ...opts,
         continueActiveScheduleRuns: true,
         tolerateBlockedRun: true,
-        excludeSchedule: contEntry.id,
+        excludeSchedules: continuousScheduleIds,
       });
 
       // Merge results
@@ -704,6 +720,7 @@ export async function scheduleDaemonCommand(opts) {
         ...opts,
         continueActiveScheduleRuns: true,
         tolerateBlockedRun: true,
+        excludeSchedules: continuousScheduleIds,
       });
     }
 

package/src/commands/status.js

@@ -215,6 +215,17 @@ function renderGovernedStatus(context, opts) {
     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

@@ -21,6 +21,7 @@ import {
   startIntent,
   resolveIntent,
 } from './intake.js';
+import { loadProjectState } from './config.js';
 import { safeWriteJson } from './safe-write.js';
 
 const CONTINUOUS_SESSION_PATH = '.agentxchain/continuous-session.json';
@@ -54,7 +55,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 +67,40 @@ 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.action === 'operator_stopped') {
+    return 'Continuous loop stopped by operator.';
+  }
+  if (step.status === 'idle_exit') {
+    return `All vision goals appear addressed (${contOpts.maxIdleCycles} consecutive idle cycles). Stopping.`;
+  }
+  return null;
+}
+
+function getExecutionRunSpentUsd(execution) {
+  return execution?.result?.state?.budget_status?.spent_usd || 0;
+}
+
+function isBlockedContinuousExecution(execution) {
+  const stopReason = execution?.result?.stop_reason || null;
+  const stateStatus = execution?.result?.state?.status || null;
+  return stateStatus === 'blocked'
+    || stopReason === 'blocked'
+    || stopReason === 'reject_exhausted';
+}
+
 // ---------------------------------------------------------------------------
 // Intake queue check
 // ---------------------------------------------------------------------------
@@ -274,6 +306,7 @@ 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,
   };
 }
 
@@ -312,6 +345,66 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
     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' };
+  }
+
+  // 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
+  // rejection, and permanently fail the session instead of staying paused.
+  if (session.status === 'paused') {
+    const governedState = loadProjectState(root, context.config);
+    if (governedState?.status === 'blocked') {
+      // Still blocked — stay paused, do not attempt new work
+      writeContinuousSession(root, session);
+      return { ok: true, status: 'blocked', action: 'still_blocked', run_id: session.current_run_id };
+    }
+    // Unblocked — resume by continuing the existing governed run directly.
+    // Skip the intake pipeline: the run is already in progress, and startIntent
+    // would reject because the governed state is active.
+    session.status = 'running';
+    log('Blocked run resolved — resuming continuous session.');
+    writeContinuousSession(root, session);
+
+    let execution;
+    try {
+      execution = await executeGovernedRun(context, { autoApprove: true, report: true, log });
+    } catch (err) {
+      session.status = 'failed';
+      writeContinuousSession(root, session);
+      return { ok: false, status: 'failed', action: 'run_failed', stop_reason: err.message, run_id: session.current_run_id };
+    }
+
+    session.cumulative_spent_usd = (session.cumulative_spent_usd || 0) + getExecutionRunSpentUsd(execution);
+    const resumeStopReason = execution.result?.stop_reason;
+
+    if (isBlockedContinuousExecution(execution)) {
+      session.status = 'paused';
+      log('Resumed run blocked again — continuous loop re-paused.');
+      writeContinuousSession(root, session);
+      return { ok: true, status: 'blocked', action: 'run_blocked', run_id: session.current_run_id };
+    }
+
+    if (execution.exitCode !== 0 || !execution.result) {
+      session.status = 'failed';
+      writeContinuousSession(root, session);
+      return { ok: false, status: 'failed', action: 'run_failed', stop_reason: resumeStopReason || `exit_code_${execution.exitCode}`, run_id: session.current_run_id };
+    }
+
+    session.runs_completed += 1;
+    session.current_run_id = execution.result?.state?.run_id || session.current_run_id;
+    log(`Resumed run completed (${session.runs_completed}/${contOpts.maxRuns}): ${resumeStopReason || 'completed'}`);
+    writeContinuousSession(root, session);
+    return { ok: true, status: 'running', action: 'resumed_after_unblock', run_id: session.current_run_id };
+  }
+
   // Validate vision file
   if (!existsSync(absVisionPath)) {
     session.status = 'failed';
@@ -381,38 +474,94 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
   session.status = 'running';
   writeContinuousSession(root, session);
 
-  const execution = await executeGovernedRun(context, {
-    autoApprove: true,
-    report: true,
-    log,
-  });
+  let execution;
+  try {
+    execution = await executeGovernedRun(context, {
+      autoApprove: true,
+      report: true,
+      log,
+    });
+  } catch (err) {
+    session.status = 'failed';
+    writeContinuousSession(root, session);
+    log(`Governed run threw during continuous execution: ${err.message}`);
+    return {
+      ok: false,
+      status: 'failed',
+      action: 'run_failed',
+      stop_reason: err.message,
+      run_id: preparedIntent.runId || null,
+      intent_id: targetIntentId,
+    };
+  }
 
-  session.runs_completed += 1;
-  session.current_run_id = execution.result?.state?.run_id || null;
+  session.current_run_id = execution.result?.state?.run_id || preparedIntent.runId || null;
+  session.cumulative_spent_usd = (session.cumulative_spent_usd || 0) + getExecutionRunSpentUsd(execution);
 
   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';
+  if (stopReason === 'priority_preempted') {
+    log('Priority preemption detected — consuming injected work next cycle.');
     writeContinuousSession(root, session);
-    return { ok: false, status: 'failed', action: 'resolve_failed', stop_reason: resolved.error, intent_id: targetIntentId };
+    return {
+      ok: true,
+      status: 'running',
+      action: 'consumed_injected_priority',
+      run_id: session.current_run_id,
+      intent_id: targetIntentId,
+    };
   }
 
-  if (stopReason === 'blocked') {
+  if (isBlockedContinuousExecution(execution)) {
+    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 };
+    }
     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.');
+  if (stopReason === 'caller_stopped') {
+    session.status = 'stopped';
+    writeContinuousSession(root, session);
+    return {
+      ok: true,
+      status: 'stopped',
+      action: 'operator_stopped',
+      run_id: session.current_run_id,
+      intent_id: targetIntentId,
+    };
+  }
+
+  if (execution.exitCode !== 0 || !execution.result) {
+    session.status = 'failed';
+    writeContinuousSession(root, session);
+    log(`Governed run failed during continuous execution: ${stopReason || `exit_code_${execution.exitCode}`}.`);
+    return {
+      ok: false,
+      status: 'failed',
+      action: 'run_failed',
+      stop_reason: stopReason || `exit_code_${execution.exitCode}`,
+      run_id: session.current_run_id,
+      intent_id: targetIntentId,
+    };
+  }
+
+  session.runs_completed += 1;
+  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: true, status: 'running', action: 'consumed_injected_priority', run_id: session.current_run_id, intent_id: targetIntentId };
+    return { ok: false, status: 'failed', action: 'resolve_failed', stop_reason: resolved.error, intent_id: targetIntentId };
   }
 
   writeContinuousSession(root, session);
@@ -449,7 +598,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
@@ -465,11 +614,10 @@ export async function executeContinuousRun(context, contOpts, executeGovernedRun
       const step = await advanceContinuousRunOnce(context, session, contOpts, executeGovernedRun, log);
 
       // Terminal states
-      if (step.status === 'completed' || step.status === 'idle_exit' || step.status === 'failed' || step.status === 'blocked') {
-        if (step.status === 'completed') {
-          log(`Max runs reached (${contOpts.maxRuns}). Stopping.`);
-        } else if (step.status === 'idle_exit') {
-          log(`All vision goals appear addressed (${contOpts.maxIdleCycles} consecutive idle cycles). Stopping.`);
+      if (step.status === 'completed' || step.status === 'idle_exit' || step.status === 'failed' || step.status === 'blocked' || step.status === 'stopped') {
+        const terminalMessage = describeContinuousTerminalStep(step, contOpts);
+        if (terminalMessage) {
+          log(terminalMessage);
         }
         return { exitCode: step.ok ? 0 : 1, session };
       }

package/src/lib/normalized-config.js

@@ -711,6 +711,13 @@ export function validateSchedulesConfig(schedules, roles) {
         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`);
+          }
+        }
       }
     }
   }
@@ -1153,6 +1160,9 @@ function normalizeContinuousConfig(raw) {
     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,
   };
 }