agentxchain 2.116.0 → 2.118.0

package/src/commands/schedule.js

@@ -6,13 +6,24 @@ import {
   listSchedules,
   updateScheduleState,
   evaluateScheduleLaunchEligibility,
+  findContinuableScheduleRun,
   readDaemonState,
   writeDaemonState,
   updateDaemonHeartbeat,
   createDaemonState,
   evaluateDaemonStatus,
 } 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();
@@ -86,7 +97,136 @@ function buildScheduleProvenance(entry) {
   };
 }
 
+function buildScheduleExecutionResult(entryId, execution, fallbackState, action = 'ran') {
+  const state = execution.result?.state || fallbackState || null;
+  return {
+    id: entryId,
+    action,
+    run_id: state?.run_id || null,
+    stop_reason: execution.result?.stop_reason || null,
+    exit_code: execution.exitCode,
+  };
+}
+
+function recordScheduleExecution(context, entryId, execution, fallbackState, nowIso, action = 'ran') {
+  const state = execution.result?.state || fallbackState || null;
+  const runId = state?.run_id || null;
+  const startedAt = state?.created_at || nowIso;
+
+  updateScheduleState(context.root, context.config, entryId, (record) => ({
+    ...record,
+    last_started_at: startedAt,
+    last_finished_at: new Date().toISOString(),
+    last_run_id: runId,
+    last_status: execution.result?.stop_reason || (execution.exitCode === 0 ? 'completed' : 'launch_failed'),
+    last_skip_at: null,
+    last_skip_reason: null,
+  }));
+
+  return buildScheduleExecutionResult(entryId, execution, fallbackState, action);
+}
+
+function consumeScheduledPriorityPreemption(context, scheduleId, schedule, execution, fallbackState, at) {
+  const scheduleResult = recordScheduleExecution(
+    context,
+    scheduleId,
+    execution,
+    fallbackState,
+    at || new Date().toISOString(),
+    'preempted',
+  );
+  const consumed = consumePreemptionMarker(context.root, {
+    role: schedule.initial_role || undefined,
+  });
+
+  if (!consumed.ok) {
+    return {
+      ok: false,
+      exitCode: 1,
+      result: {
+        ...scheduleResult,
+        action: 'preemption_failed',
+        error: consumed.error,
+        injected_intent_id: execution.result?.preempted_by || null,
+      },
+    };
+  }
+
+  return {
+    ok: true,
+    exitCode: 0,
+    result: {
+      ...scheduleResult,
+      action: 'preempted',
+      injected_intent_id: consumed.intent_id,
+      injected_turn_id: consumed.turn_id,
+      injected_role: consumed.role,
+    },
+  };
+}
+
+async function continueActiveScheduledRun(context, opts = {}) {
+  const continuation = findContinuableScheduleRun(context.root, context.config, {
+    scheduleId: opts.schedule || null,
+  });
+  if (!continuation.ok) {
+    return { matched: false, reason: continuation.reason };
+  }
+
+  const { schedule_id: scheduleId, schedule, state } = continuation;
+
+  if (!opts.json) {
+    console.log(chalk.cyan(`Continuing active scheduled run: ${scheduleId}`));
+  }
+
+  const execution = await executeGovernedRun(context, {
+    maxTurns: schedule.max_turns,
+    autoApprove: schedule.auto_approve !== false,
+    report: true,
+    log: opts.json ? () => {} : console.log,
+  });
+
+  if (execution.result?.stop_reason === 'priority_preempted') {
+    const promoted = consumeScheduledPriorityPreemption(context, scheduleId, schedule, execution, state, opts.at);
+    return {
+      matched: true,
+      ok: promoted.ok,
+      exitCode: promoted.exitCode,
+      result: promoted.result,
+    };
+  }
+
+  const blocked = execution.result?.stop_reason === 'blocked';
+  const action = blocked && opts.tolerateBlockedRun ? 'blocked' : 'continued';
+  const result = recordScheduleExecution(context, scheduleId, execution, state, opts.at || new Date().toISOString(), action);
+
+  if (execution.exitCode !== 0 && !(opts.tolerateBlockedRun && blocked)) {
+    return {
+      matched: true,
+      ok: false,
+      exitCode: execution.exitCode,
+      result,
+    };
+  }
+
+  return {
+    matched: true,
+    ok: true,
+    exitCode: 0,
+    result,
+  };
+}
+
 async function runDueSchedules(context, opts = {}) {
+  if (opts.continueActiveScheduleRuns) {
+    const continuation = await continueActiveScheduledRun(context, opts);
+    if (continuation.matched) {
+      return continuation.ok
+        ? { ok: true, exitCode: continuation.exitCode, results: [continuation.result] }
+        : { ok: false, exitCode: continuation.exitCode, results: [continuation.result], error: 'Scheduled run failed' };
+    }
+  }
+
   const resolved = resolveScheduleEntries(context, opts.schedule, opts.at);
   if (!resolved.ok) {
     return { ok: false, exitCode: 1, error: resolved.error, results: [] };
@@ -96,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;
@@ -150,26 +294,29 @@ async function runDueSchedules(context, opts = {}) {
       continue;
     }
 
-    const runId = execution.result?.state?.run_id || null;
-    const startedAt = execution.result?.state?.created_at || nowIso;
-    updateScheduleState(context.root, context.config, entry.id, (record) => ({
-      ...record,
-      last_started_at: startedAt,
-      last_finished_at: new Date().toISOString(),
-      last_run_id: runId,
-      last_status: execution.result?.stop_reason || (execution.exitCode === 0 ? 'completed' : 'launch_failed'),
-      last_skip_at: null,
-      last_skip_reason: null,
-    }));
-    results.push({
-      id: entry.id,
-      action: 'ran',
-      run_id: runId,
-      stop_reason: execution.result?.stop_reason || null,
-      exit_code: execution.exitCode,
-    });
+    if (execution.result?.stop_reason === 'priority_preempted') {
+      const promoted = consumeScheduledPriorityPreemption(context, entry.id, entry, execution, execution.result?.state || null, nowIso);
+      results.push(promoted.result);
+      if (!promoted.ok) {
+        return { ok: false, exitCode: promoted.exitCode, results };
+      }
+      continue;
+    }
+
+    const blocked = execution.result?.stop_reason === 'blocked';
+    results.push(recordScheduleExecution(
+      context,
+      entry.id,
+      execution,
+      execution.result?.state || null,
+      nowIso,
+      blocked && opts.tolerateBlockedRun ? 'blocked' : 'ran',
+    ));
 
     if (execution.exitCode !== 0) {
+      if (opts.tolerateBlockedRun && blocked) {
+        continue;
+      }
       return { ok: false, exitCode: execution.exitCode, results };
     }
   }
@@ -177,6 +324,159 @@ 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,
+  };
+}
+
+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,
+  };
+
+  // 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',
+  };
+  const schedStatus = statusMap[step.status] || 'continuous_running';
+
+  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;
@@ -214,6 +514,14 @@ export async function scheduleRunDueCommand(opts) {
     for (const entry of result.results) {
       if (entry.action === 'ran') {
         console.log(chalk.green(`Schedule ran: ${entry.id} (${entry.run_id || 'no run id'})`));
+      } else if (entry.action === 'continued') {
+        console.log(chalk.green(`Schedule continued: ${entry.id} (${entry.run_id || 'no run id'})`));
+      } else if (entry.action === 'preempted') {
+        console.log(chalk.yellow(`Schedule preempted by injected priority: ${entry.id} (${entry.injected_intent_id || 'unknown intent'})`));
+      } else if (entry.action === 'preemption_failed') {
+        console.log(chalk.red(`Schedule preemption failed: ${entry.id} (${entry.error || 'unknown error'})`));
+      } else if (entry.action === 'blocked') {
+        console.log(chalk.yellow(`Schedule waiting on unblock: ${entry.id}`));
       } else if (entry.action === 'skipped') {
         console.log(chalk.yellow(`Schedule skipped: ${entry.id} (${entry.reason})`));
       } else if (entry.action === 'not_due') {
@@ -338,7 +646,66 @@ export async function scheduleDaemonCommand(opts) {
   while (true) {
     cycle += 1;
     daemonState.last_cycle_started_at = new Date().toISOString();
-    const result = await runDueSchedules(context, opts);
+
+    // 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

@@ -19,7 +19,10 @@ import { summarizeRunProvenance } from '../lib/run-provenance.js';
 import { readRecentRunEventSummary } from '../lib/recent-event-summary.js';
 import { deriveConflictedTurnResolutionActions } from '../lib/conflict-actions.js';
 import { summarizeLatestGateActionAttempt } from '../lib/gate-actions.js';
+import { findCurrentHumanEscalation } from '../lib/human-escalations.js';
 import { getDashboardPid, getDashboardSession } from './dashboard.js';
+import { readPreemptionMarker } from '../lib/intake.js';
+import { readContinuousSession } from '../lib/continuous-run.js';
 
 export async function statusCommand(opts) {
   const context = loadStatusContext();
@@ -127,6 +130,9 @@ function renderGovernedStatus(context, opts) {
   const repoDecisionSummary = summarizeRepoDecisions(readRepoDecisions(root), config);
 
   const workflowKitArtifacts = deriveWorkflowKitArtifacts(root, config, state);
+  const humanEscalation = findCurrentHumanEscalation(root, state);
+  const preemptionMarker = readPreemptionMarker(root);
+  const continuousSession = readContinuousSession(root);
   const gateActionAttempt = state?.pending_phase_transition
     ? summarizeLatestGateActionAttempt(root, 'phase_transition', state.pending_phase_transition.gate)
     : state?.pending_run_completion
@@ -162,6 +168,9 @@ function renderGovernedStatus(context, opts) {
       next_actions: nextActions,
       connector_health: connectorHealth,
       recent_event_summary: recentEventSummary,
+      human_escalation: humanEscalation,
+      preemption_marker: preemptionMarker,
+      continuous_session: continuousSession,
       gate_action_attempt: gateActionAttempt,
       workflow_kit_artifacts: workflowKitArtifacts,
       dashboard_session: dashboardSessionObj,
@@ -174,6 +183,42 @@ function renderGovernedStatus(context, opts) {
   console.log(chalk.dim('  ' + '─'.repeat(44)));
   console.log('');
 
+  // Priority injection banner — above all other status
+  if (preemptionMarker) {
+    console.log(chalk.red.bold('  ⚡ Priority injection pending'));
+    console.log(chalk.dim(`  Intent:      ${preemptionMarker.intent_id}`));
+    console.log(`  Priority:    ${chalk.red.bold(preemptionMarker.priority)}`);
+    if (preemptionMarker.description) {
+      console.log(chalk.dim(`  Description: ${preemptionMarker.description}`));
+    }
+    if (preemptionMarker.injected_at) {
+      console.log(chalk.dim(`  Injected at: ${preemptionMarker.injected_at}`));
+    }
+    console.log(chalk.dim('  Effect:      Will preempt current workstream after this turn completes'));
+    console.log(chalk.dim('  ' + '─'.repeat(44)));
+    console.log('');
+  }
+
+  // Continuous session banner
+  if (continuousSession) {
+    console.log(chalk.cyan.bold('  🔄 Continuous Vision-Driven Session'));
+    console.log(chalk.dim(`  Session:     ${continuousSession.session_id}`));
+    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}`));
+    }
+    console.log(chalk.dim('  ' + '─'.repeat(44)));
+    console.log('');
+  }
+
   console.log(`  ${chalk.dim('Project:')}  ${config.project.name}`);
   if (config.project.goal) {
     console.log(`  ${chalk.dim('Goal:')}     ${config.project.goal}`);
@@ -325,6 +370,16 @@ function renderGovernedStatus(context, opts) {
     }
   }
 
+  if (humanEscalation) {
+    console.log('');
+    console.log(`  ${chalk.dim('Human task:')} ${chalk.yellow(humanEscalation.escalation_id)}${humanEscalation.service ? ` (${humanEscalation.service})` : ''}`);
+    console.log(`  ${chalk.dim('Type:')}     ${humanEscalation.type}`);
+    console.log(`  ${chalk.dim('Unblock:')}  ${chalk.cyan(humanEscalation.resolution_command)}`);
+    if (humanEscalation.action) {
+      console.log(`  ${chalk.dim('Task:')}     ${humanEscalation.action}`);
+    }
+  }
+
   if (runtimeGuidance.length > 0) {
     console.log('');
     console.log(`  ${chalk.dim('Runtime guidance:')}`);

package/src/commands/unblock.js

@@ -0,0 +1,67 @@
+import chalk from 'chalk';
+import { loadProjectContext, loadProjectState } from '../lib/config.js';
+import { findCurrentHumanEscalation, getOpenHumanEscalation } from '../lib/human-escalations.js';
+import { resumeCommand } from './resume.js';
+
+export async function unblockCommand(escalationId) {
+  const context = loadProjectContext();
+  if (!context) {
+    console.log(chalk.red('No agentxchain.json found. Run `agentxchain init` first.'));
+    process.exit(1);
+  }
+
+  const { root, config } = context;
+
+  if (config.protocol_mode !== 'governed') {
+    console.log(chalk.red('The unblock command is only available for governed projects.'));
+    process.exit(1);
+  }
+
+  if (!escalationId || !String(escalationId).trim()) {
+    console.log(chalk.red('An escalation id is required. Example: agentxchain unblock hesc_1234'));
+    process.exit(1);
+  }
+
+  const state = loadProjectState(root, config);
+  if (!state) {
+    console.log(chalk.red('No governed state.json found. Run `agentxchain init --governed` first.'));
+    process.exit(1);
+  }
+
+  if (state.status !== 'blocked') {
+    console.log(chalk.red(`Cannot unblock run: status is "${state.status}", expected "blocked".`));
+    process.exit(1);
+  }
+
+  const requested = getOpenHumanEscalation(root, escalationId);
+  if (!requested) {
+    console.log(chalk.red(`No open human escalation found for ${escalationId}.`));
+    process.exit(1);
+  }
+
+  const current = findCurrentHumanEscalation(root, state);
+  if (!current) {
+    console.log(chalk.red('The current blocked run does not have a linked human escalation record.'));
+    process.exit(1);
+  }
+
+  if (current.escalation_id !== requested.escalation_id) {
+    console.log(chalk.red(`Escalation ${escalationId} is not the current blocker for this run.`));
+    console.log(chalk.dim(`Current blocker: ${current.escalation_id}`));
+    process.exit(1);
+  }
+
+  console.log('');
+  console.log(chalk.green(`  Unblocking ${requested.escalation_id}`));
+  console.log(chalk.dim(`  Type: ${requested.type}${requested.service ? ` (${requested.service})` : ''}`));
+  if (requested.detail) {
+    console.log(chalk.dim(`  Detail: ${requested.detail}`));
+  }
+  console.log(chalk.dim('  Continuing governed execution...'));
+  console.log('');
+
+  await resumeCommand({
+    _via: 'operator_unblock',
+    turn: requested.turn_id || undefined,
+  });
+}