agentxchain 2.145.0 → 2.147.0

package/src/lib/continuous-run.js

@@ -99,6 +99,9 @@ function describeContinuousTerminalStep(step, contOpts) {
     return `Continuous loop failed: ${reason}. Check "agentxchain status" for details.`;
   }
   if (step.status === 'blocked') {
+    if (step.recovery_action) {
+      return `Continuous loop paused on blocker. Recovery: ${step.recovery_action}`;
+    }
     return 'Continuous loop paused on blocker. Use "agentxchain unblock <id>" to resume.';
   }
   return null;
@@ -116,6 +119,14 @@ function isBlockedContinuousExecution(execution) {
     || stopReason === 'reject_exhausted';
 }
 
+function getBlockedRecoveryAction(state) {
+  return state?.blocked_reason?.recovery?.recovery_action || null;
+}
+
+function getBlockedCategory(state) {
+  return state?.blocked_reason?.category || null;
+}
+
 // ---------------------------------------------------------------------------
 // Intake queue check
 // ---------------------------------------------------------------------------
@@ -361,7 +372,14 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
     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 };
+      return {
+        ok: true,
+        status: 'blocked',
+        action: 'still_blocked',
+        run_id: session.current_run_id,
+        recovery_action: getBlockedRecoveryAction(governedState),
+        blocked_category: getBlockedCategory(governedState),
+      };
     }
     // Unblocked — resume by continuing the existing governed run directly.
     // Skip the intake pipeline: the run is already in progress, and startIntent
@@ -388,10 +406,20 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
     const resumeStopReason = execution.result?.stop_reason;
 
     if (isBlockedContinuousExecution(execution)) {
+      const blockedRecoveryAction = getBlockedRecoveryAction(execution?.result?.state || loadProjectState(root, context.config));
       session.status = 'paused';
-      log('Resumed run blocked again — continuous loop re-paused.');
+      log(blockedRecoveryAction
+        ? `Resumed run blocked again — continuous loop re-paused. Recovery: ${blockedRecoveryAction}`
+        : '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 };
+      return {
+        ok: true,
+        status: 'blocked',
+        action: 'run_blocked',
+        run_id: session.current_run_id,
+        recovery_action: blockedRecoveryAction,
+        blocked_category: getBlockedCategory(execution?.result?.state || loadProjectState(root, context.config)),
+      };
     }
 
     if (execution.exitCode !== 0 || !execution.result) {
@@ -473,9 +501,35 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
     return { ok: false, status: 'failed', action: 'prepare_failed', stop_reason: preparedIntent.error, intent_id: targetIntentId };
   }
 
+  // BUG-53: Auto-chain audit trail. When this advance step seeds a NEXT run
+  // (i.e., at least one prior run already completed in this session), emit a
+  // `session_continuation` event so operators have a visible record that the
+  // loop auto-derived the next vision objective without intervention. Event
+  // is emitted BEFORE we overwrite session.current_run_id so previous_run_id
+  // reflects the just-completed run and next_run_id reflects the newly
+  // prepared one. See HUMAN-ROADMAP BUG-53 fix #4.
+  const previousRunId = session.current_run_id;
+  const nextObjective = visionObjective || preparedIntent.intent?.charter || null;
+  if ((session.runs_completed || 0) >= 1 && previousRunId && previousRunId !== preparedIntent.run_id) {
+    emitRunEvent(root, 'session_continuation', {
+      run_id: preparedIntent.run_id,
+      phase: null,
+      status: 'active',
+      payload: {
+        session_id: session.session_id,
+        previous_run_id: previousRunId,
+        next_run_id: preparedIntent.run_id,
+        next_objective: nextObjective,
+        next_intent_id: targetIntentId,
+        runs_completed: session.runs_completed || 0,
+        trigger: visionObjective ? 'vision_scan' : 'intake',
+      },
+    });
+  }
+
   // Execute the governed run
   session.current_run_id = preparedIntent.run_id;
-  session.current_vision_objective = visionObjective || preparedIntent.intent?.charter || null;
+  session.current_vision_objective = nextObjective;
   session.status = 'running';
   writeContinuousSession(root, session);
 
@@ -519,6 +573,7 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
   }
 
   if (isBlockedContinuousExecution(execution)) {
+    const blockedRecoveryAction = getBlockedRecoveryAction(execution?.result?.state || loadProjectState(root, context.config));
     const resolved = resolveIntent(root, targetIntentId);
     if (!resolved.ok) {
       log(`Continuous resolve error: ${resolved.error}`);
@@ -527,9 +582,19 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
       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.');
+    log(blockedRecoveryAction
+      ? `Run blocked — continuous loop paused. Recovery: ${blockedRecoveryAction}`
+      : '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 };
+    return {
+      ok: true,
+      status: 'blocked',
+      action: 'run_blocked',
+      run_id: session.current_run_id,
+      intent_id: targetIntentId,
+      recovery_action: blockedRecoveryAction,
+      blocked_category: getBlockedCategory(execution?.result?.state || loadProjectState(root, context.config)),
+    };
   }
 
   if (stopReason === 'caller_stopped') {

package/src/lib/dashboard/actions.js

@@ -1,5 +1,5 @@
 import { dirname } from 'path';
-import { loadProjectContext } from '../config.js';
+import { loadProjectContext, loadProjectState } from '../config.js';
 import { approvePhaseTransition, approveRunCompletion } from '../governed-state.js';
 import { deriveGovernedRunNextActions, deriveRecoveryDescriptor } from '../blocked-state.js';
 import {
@@ -205,10 +205,16 @@ function approveCoordinatorGate(workspacePath, state, config) {
 
 export function approvePendingDashboardGate(agentxchainDir) {
   const workspacePath = dirname(agentxchainDir);
-  const repoState = readJsonFile(agentxchainDir, 'state.json');
+  const context = loadProjectContext(workspacePath);
+
+  // Use loadProjectState to get reconciled state — approval-pause repair
+  // may surface a pending_run_completion from an orphaned blocked_on marker,
+  // and we must route on the reconciled truth, not the raw state.json.
+  const repoState = (context?.config?.protocol_mode === 'governed'
+    ? loadProjectState(workspacePath, context.config)
+    : null) || readJsonFile(agentxchainDir, 'state.json');
 
   if (repoState?.pending_phase_transition || repoState?.pending_run_completion) {
-    const context = loadProjectContext(workspacePath);
     return approveRepoGate(workspacePath, context?.config, repoState);
   }
 

package/src/lib/dashboard/bridge-server.js

@@ -23,6 +23,7 @@ import { readCoordinatorRepoStatusRows } from './coordinator-repo-status.js';
 import { readCoordinatorTimeoutStatus } from './coordinator-timeout-status.js';
 import { readAggregatedCoordinatorEvents, watchChildRepoEvents } from './coordinator-event-aggregation.js';
 import { readWorkflowKitArtifacts } from './workflow-kit-artifacts.js';
+import { readNotificationSnapshot } from './notifications-reader.js';
 import { readConnectorHealthSnapshot } from './connectors.js';
 import { readTimeoutStatus } from './timeout-status.js';
 import { queryRunHistory } from '../run-history.js';
@@ -431,6 +432,16 @@ export function createBridgeServer({ agentxchainDir, dashboardDir, port = 3847,
       return;
     }
 
+    if (pathname === '/api/notifications') {
+      if (replayMode) {
+        writeJson(res, 200, { ok: true, replay_mode: true, message: 'Notification audit is live-only and not available in replay mode.' });
+        return;
+      }
+      const result = readNotificationSnapshot(workspacePath);
+      writeJson(res, result.status, result.body);
+      return;
+    }
+
     if (pathname === '/api/connectors') {
       const result = readConnectorHealthSnapshot(workspacePath);
       writeJson(res, result.status, result.body);

package/src/lib/dashboard/notifications-reader.js

@@ -0,0 +1,91 @@
+import { loadConfig, loadProjectContext } from '../config.js';
+import { readJsonlFile } from './state-reader.js';
+
+function summarizeAuditEntries(entries) {
+  const summary = {
+    total_attempts: entries.length,
+    delivered: 0,
+    failed: 0,
+    timed_out: 0,
+    last_emitted_at: null,
+    last_failure_at: null,
+  };
+
+  for (const entry of entries) {
+    if (entry?.delivered === true) {
+      summary.delivered += 1;
+    } else {
+      summary.failed += 1;
+      if (!summary.last_failure_at || String(entry?.emitted_at || '') > summary.last_failure_at) {
+        summary.last_failure_at = entry?.emitted_at || null;
+      }
+    }
+    if (entry?.timed_out === true) {
+      summary.timed_out += 1;
+    }
+    if (!summary.last_emitted_at || String(entry?.emitted_at || '') > summary.last_emitted_at) {
+      summary.last_emitted_at = entry?.emitted_at || null;
+    }
+  }
+
+  return summary;
+}
+
+function normalizeWebhook(webhook) {
+  return {
+    name: webhook.name,
+    timeout_ms: webhook.timeout_ms,
+    event_count: Array.isArray(webhook.events) ? webhook.events.length : 0,
+    events: Array.isArray(webhook.events) ? webhook.events : [],
+  };
+}
+
+export function readNotificationSnapshot(workspacePath) {
+  const context = loadProjectContext(workspacePath);
+  const governedContext = context?.config ? context : null;
+  const legacyConfigResult = governedContext ? null : loadConfig(workspacePath);
+  if (!governedContext && !legacyConfigResult) {
+    return {
+      ok: false,
+      status: 404,
+      body: {
+        ok: false,
+        code: 'config_missing',
+        error: 'Project config not found. Run `agentxchain init --governed` first.',
+      },
+    };
+  }
+
+  const root = governedContext?.root || legacyConfigResult.root;
+  const config = governedContext?.config || legacyConfigResult.config;
+  const notifications = config?.notifications || {};
+  const webhooks = Array.isArray(notifications.webhooks)
+    ? notifications.webhooks.map(normalizeWebhook)
+    : [];
+  const configured = webhooks.length > 0;
+  const approvalSla = notifications.approval_sla
+    ? {
+      enabled: notifications.approval_sla.enabled !== false,
+      reminder_after_seconds: Array.isArray(notifications.approval_sla.reminder_after_seconds)
+        ? notifications.approval_sla.reminder_after_seconds
+        : [],
+    }
+    : null;
+
+  const auditEntries = (readJsonlFile(`${root}/.agentxchain`, 'notification-audit.jsonl') || [])
+    .slice()
+    .sort((a, b) => String(b?.emitted_at || '').localeCompare(String(a?.emitted_at || '')));
+
+  return {
+    ok: true,
+    status: 200,
+    body: {
+      ok: true,
+      configured,
+      webhooks,
+      approval_sla: approvalSla,
+      summary: summarizeAuditEntries(auditEntries),
+      recent: auditEntries.slice(0, 10),
+    },
+  };
+}

package/src/lib/dashboard/state-reader.js

@@ -12,8 +12,9 @@ import {
   deriveGovernedRunNextActions,
   deriveRuntimeBlockedGuidance,
 } from '../blocked-state.js';
-import { loadProjectContext } from '../config.js';
+import { loadProjectContext, loadProjectState } from '../config.js';
 import { getContinuityStatus } from '../continuity-status.js';
+import { reconcileStaleTurns } from '../stale-turn-watchdog.js';
 import { readRepoDecisions, summarizeRepoDecisions } from '../repo-decisions.js';
 import { readAllDispatchProgress } from '../dispatch-progress.js';
 
@@ -136,10 +137,21 @@ function enrichGovernedState(agentxchainDir, state) {
     return state;
   }
 
+  // Use loadProjectState to get reconciled state (approval-pause repair,
+  // budget reconciliation, recovery-action reconciliation applied and
+  // persisted to disk).  Then apply stale-turn reconciliation so recovery
+  // and next-action surfaces reflect the post-watchdog truth — matching
+  // the same ordering used by the CLI `status` command.
+  let reconciledState = loadProjectState(workspacePath, context.config) || state;
+  const staleResult = reconcileStaleTurns(workspacePath, reconciledState, context.config);
+  if (staleResult.changed) {
+    reconciledState = staleResult.state;
+  }
+
   return {
-    ...state,
-    runtime_guidance: deriveRuntimeBlockedGuidance(state, context.config),
-    next_actions: deriveGovernedRunNextActions(state, context.config),
+    ...reconciledState,
+    runtime_guidance: deriveRuntimeBlockedGuidance(reconciledState, context.config),
+    next_actions: deriveGovernedRunNextActions(reconciledState, context.config),
     dispatch_progress: readAllDispatchProgress(workspacePath),
   };
 }

package/src/lib/dispatch-bundle.js

@@ -55,7 +55,7 @@ const RESERVED_PATHS = [
  * Write a dispatch bundle for the currently assigned turn.
  *
  * @param {string} root - project root directory
- * @param {object} state - current governed state (must have current_turn)
+ * @param {object} state - current governed state (must expose an active turn via active_turns; current_turn is a non-enumerable compatibility alias re-attached on load, not a persisted schema field)
  * @param {object} config - normalized config
  * @param {object} [opts]
  * @param {string} [opts.turnId]

package/src/lib/dispatch-progress.js

@@ -71,9 +71,10 @@ export function createDispatchProgressTracker(root, turn, options = {}) {
     runtime_id: turn.runtime_id || null,
     adapter_type,
     started_at: null,
+    first_output_at: null,
     last_activity_at: null,
-    activity_type: 'output',
-    activity_summary: 'Dispatch starting',
+    activity_type: 'starting',
+    activity_summary: 'Waiting for first output',
     output_lines: 0,
     stderr_lines: 0,
     silent_since: null,
@@ -123,7 +124,7 @@ export function createDispatchProgressTracker(root, turn, options = {}) {
       const now = new Date().toISOString();
       state.started_at = now;
       state.last_activity_at = now;
-      state.activity_type = 'output';
+      state.activity_type = 'starting';
       state.activity_summary = 'Subprocess started';
       dirty = true;
       writeProgress();
@@ -137,6 +138,7 @@ export function createDispatchProgressTracker(root, turn, options = {}) {
       const now = new Date().toISOString();
       const wasSilent = state.activity_type === 'silent';
       state.last_activity_at = now;
+      state.first_output_at = state.first_output_at || now;
       state.activity_type = 'output';
       state.silent_since = null;
       if (stream === 'stderr') {