agentxchain 2.118.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.118.0",
+  "version": "2.119.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);

package/src/commands/schedule.js

@@ -381,6 +381,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 +446,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 +460,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,

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

@@ -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,6 +290,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 +329,16 @@ 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' };
+  }
+
   // Validate vision file
   if (!existsSync(absVisionPath)) {
     session.status = 'failed';
@@ -390,6 +417,10 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
   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'}`);
 
@@ -449,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
@@ -466,10 +497,9 @@ export async function executeContinuousRun(context, contOpts, executeGovernedRun
 
       // 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.`);
+        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,
   };
 }