agentxchain 2.119.0 → 2.120.0

package/package.json

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

package/src/commands/run.js

@@ -201,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);
@@ -653,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, {
@@ -686,7 +695,7 @@ export async function scheduleDaemonCommand(opts) {
         ...opts,
         continueActiveScheduleRuns: true,
         tolerateBlockedRun: true,
-        excludeSchedule: contEntry.id,
+        excludeSchedules: continuousScheduleIds,
       });
 
       // Merge results
@@ -711,6 +720,7 @@ export async function scheduleDaemonCommand(opts) {
         ...opts,
         continueActiveScheduleRuns: true,
         tolerateBlockedRun: true,
+        excludeSchedules: continuousScheduleIds,
       });
     }
 

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';
@@ -79,12 +80,27 @@ function describeContinuousTerminalStep(step, contOpts) {
   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
 // ---------------------------------------------------------------------------
@@ -339,6 +355,56 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
     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';
@@ -408,42 +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,
-  });
-
-  session.runs_completed += 1;
-  session.current_run_id = execution.result?.state?.run_id || null;
+  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,
+    };
+  }
 
-  // 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;
+  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);
@@ -496,7 +614,7 @@ 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' || step.status === 'idle_exit' || step.status === 'failed' || step.status === 'blocked' || step.status === 'stopped') {
         const terminalMessage = describeContinuousTerminalStep(step, contOpts);
         if (terminalMessage) {
           log(terminalMessage);