agentxchain 2.139.0 → 2.140.0

package/bin/agentxchain.js

@@ -1031,6 +1031,7 @@ intakeCmd
   .command('resolve')
   .description('Resolve an executing intent by reading the governed run outcome')
   .option('--intent <id>', 'Intent ID to resolve')
+  .option('--outcome <status>', 'Force transition to this status (e.g., "completed")')
   .option('-j, --json', 'Output as JSON')
   .action(intakeResolveCommand);
 

package/package.json

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

package/src/commands/intake-resolve.js

@@ -15,7 +15,11 @@ export async function intakeResolveCommand(opts) {
     process.exit(1);
   }
 
-  const result = resolveIntent(root, opts.intent);
+  const resolveOpts = {};
+  if (opts.outcome) {
+    resolveOpts.outcome = opts.outcome;
+  }
+  const result = resolveIntent(root, opts.intent, resolveOpts);
 
   if (opts.json) {
     console.log(JSON.stringify(result, null, 2));

package/src/lib/governed-state.js

@@ -115,6 +115,50 @@ function listIntakeIntentFiles(root) {
     .map((name) => join(intentsDir, name));
 }
 
+// BUG-45: Reconcile embedded intake_context against the live intent file.
+// The embedded copy is historical state; the live intent file is authoritative.
+// If the live intent cannot be read, acceptance must fail closed instead of
+// silently reusing the stale embedded contract.
+const INTENT_TERMINAL_STATES = ['completed', 'satisfied', 'superseded', 'suppressed', 'failed', 'rejected'];
+
+function reconcileIntakeContext(root, intakeCtx) {
+  if (!intakeCtx || !intakeCtx.intent_id) {
+    return { ok: true, intakeCtx };
+  }
+
+  try {
+    const intentPath = join(root, INTAKE_INTENTS_DIR, `${intakeCtx.intent_id}.json`);
+    if (!existsSync(intentPath)) {
+      return {
+        ok: false,
+        error: `Intent reconciliation failed: live intent ${intakeCtx.intent_id} not found at ${INTAKE_INTENTS_DIR}/${intakeCtx.intent_id}.json`,
+      };
+    }
+
+    const liveIntent = JSON.parse(readFileSync(intentPath, 'utf8'));
+
+    // If the intent has reached a terminal state, skip coverage enforcement
+    if (INTENT_TERMINAL_STATES.includes(liveIntent.status)) {
+      return { ok: true, intakeCtx: null };
+    }
+
+    // Intent is still active — use the CURRENT acceptance_contract from disk
+    if (Array.isArray(liveIntent.acceptance_contract)) {
+      return {
+        ok: true,
+        intakeCtx: { ...intakeCtx, acceptance_contract: liveIntent.acceptance_contract },
+      };
+    }
+
+    return { ok: true, intakeCtx };
+  } catch (error) {
+    return {
+      ok: false,
+      error: `Intent reconciliation failed: could not read live intent ${intakeCtx.intent_id}: ${error.message}`,
+    };
+  }
+}
+
 function retireApprovedPhaseScopedIntents(root, state, config, exitedPhase, now) {
   const retired = [];
 
@@ -3222,10 +3266,33 @@ function _acceptGovernedTurnLocked(root, config, opts) {
     };
   }
 
-  // ── Intent coverage validation (BUG-14) ──────────────────────────────────
-  // When a turn is bound to an injected intent, verify the turn result
-  // addresses each acceptance item.  Default: strict for p0, lenient for others.
-  const intakeCtx = currentTurn.intake_context;
+  // ── BUG-45: Reconcile intake_context against live intent state ──────────
+  // The embedded intake_context is a snapshot from dispatch time. The intent
+  // may have since been completed, satisfied, or had its contract updated.
+  // Re-read the live intent file and reconcile before evaluating coverage.
+  const intakeReconciliation = reconcileIntakeContext(root, currentTurn.intake_context);
+  if (!intakeReconciliation.ok) {
+    transitionToFailedAcceptance(root, state, currentTurn, intakeReconciliation.error, {
+      error_code: 'intent_reconciliation_failed',
+      stage: 'intent_reconciliation',
+      extra: {
+        intent_id: currentTurn.intake_context?.intent_id || null,
+      },
+    });
+    return {
+      ok: false,
+      error: intakeReconciliation.error,
+      validation: {
+        ...validation,
+        ok: false,
+        stage: 'intent_reconciliation',
+        error_class: 'intent_reconciliation_error',
+        errors: [intakeReconciliation.error],
+        warnings: validation.warnings,
+      },
+    };
+  }
+  const intakeCtx = intakeReconciliation.intakeCtx;
   if (intakeCtx && Array.isArray(intakeCtx.acceptance_contract) && intakeCtx.acceptance_contract.length > 0) {
     const intentCoverage = evaluateIntentCoverage(turnResult, intakeCtx, {
       state,

package/src/lib/intake.js

@@ -1270,7 +1270,7 @@ export function handoffIntent(root, intentId, options = {}) {
 // Resolve — execution exit and intent closure linkage (V3-S5)
 // ---------------------------------------------------------------------------
 
-export function resolveIntent(root, intentId) {
+export function resolveIntent(root, intentId, opts = {}) {
   const loadedIntent = readIntent(root, intentId);
   if (!loadedIntent.ok) {
     return loadedIntent;
@@ -1298,6 +1298,38 @@ export function resolveIntent(root, intentId) {
     };
   }
 
+  // BUG-45: operator-forced completion — transition executing → completed
+  // when the operator knows the work is done but the framework hasn't retired
+  // the intent automatically (e.g., retained-turn deadlock recovery).
+  if (opts.outcome === 'completed' && intent.status === 'executing') {
+    const now = nowISO();
+    const previousStatus = intent.status;
+    intent.status = 'completed';
+    intent.completed_at = now;
+    intent.updated_at = now;
+    if (!Array.isArray(intent.history)) intent.history = [];
+    intent.history.push({
+      from: previousStatus,
+      to: 'completed',
+      at: now,
+      reason: opts.reason || 'operator-resolved: intent marked completed via intake resolve --outcome completed',
+    });
+
+    const obsDir = join(dirs.base, 'observations', intent.intent_id);
+    mkdirSync(obsDir, { recursive: true });
+
+    safeWriteJson(intentPath, intent);
+    return {
+      ok: true,
+      intent,
+      previous_status: previousStatus,
+      new_status: 'completed',
+      run_outcome: 'completed',
+      no_change: false,
+      exitCode: 0,
+    };
+  }
+
   if (intent.target_workstream) {
     return resolveCoordinatorBackedIntent(root, intentPath, dirs, intent);
   }

package/src/lib/repo-observer.js

@@ -50,6 +50,7 @@ const ORCHESTRATOR_STATE_FILES = [
   '.agentxchain/human-escalations.jsonl',
   '.agentxchain/sla-reminders.json',
   'TALK.md',
+  'HUMAN_TASKS.md',
 ];
 
 // Evidence paths may legitimately remain dirty across turns without blocking the