agentxchain 2.2.0 → 2.4.0

package/src/commands/intake-start.js

@@ -0,0 +1,53 @@
+import chalk from 'chalk';
+import { findProjectRoot } from '../lib/config.js';
+import { startIntent } from '../lib/intake.js';
+
+export async function intakeStartCommand(opts) {
+  const root = findProjectRoot(process.cwd());
+  if (!root) {
+    if (opts.json) {
+      console.log(JSON.stringify({ ok: false, error: 'agentxchain.json not found' }, null, 2));
+    } else {
+      console.log(chalk.red('agentxchain.json not found'));
+    }
+    process.exit(2);
+  }
+
+  if (!opts.intent) {
+    const msg = '--intent <id> is required';
+    if (opts.json) {
+      console.log(JSON.stringify({ ok: false, error: msg }, null, 2));
+    } else {
+      console.log(chalk.red(msg));
+    }
+    process.exit(1);
+  }
+
+  const result = startIntent(root, opts.intent, {
+    role: opts.role || undefined,
+  });
+
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else if (result.ok) {
+    console.log('');
+    console.log(chalk.green(`  Started intent ${result.intent.intent_id}`));
+    console.log(`  Run:    ${result.run_id}`);
+    console.log(`  Turn:   ${result.turn_id}`);
+    console.log(`  Role:   ${result.role}`);
+    console.log(chalk.dim(`  Status: planned \u2192 executing`));
+    console.log('');
+  } else if (result.missing) {
+    console.log('');
+    console.log(chalk.red(`  Cannot start intent ${opts.intent}`));
+    console.log(chalk.red('  Recorded planning artifacts are missing on disk:'));
+    for (const m of result.missing) {
+      console.log(chalk.red(`    ${m}`));
+    }
+    console.log('');
+  } else {
+    console.log(chalk.red(`  ${result.error}`));
+  }
+
+  process.exit(result.exitCode);
+}

package/src/commands/intake-status.js

@@ -0,0 +1,113 @@
+import chalk from 'chalk';
+import { findProjectRoot } from '../lib/config.js';
+import { intakeStatus } from '../lib/intake.js';
+
+export async function intakeStatusCommand(opts) {
+  const root = findProjectRoot(process.cwd());
+  if (!root) {
+    if (opts.json) {
+      console.log(JSON.stringify({ ok: false, error: 'agentxchain.json not found' }, null, 2));
+    } else {
+      console.log(chalk.red('agentxchain.json not found'));
+    }
+    process.exit(2);
+  }
+
+  const result = intakeStatus(root, opts.intent || null);
+
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(result.exitCode);
+  }
+
+  if (!result.ok) {
+    console.log(chalk.red(`  ${result.error}`));
+    process.exit(result.exitCode);
+  }
+
+  // Detail mode: single intent
+  if (result.intent) {
+    printIntentDetail(result.intent, result.event);
+    process.exit(0);
+  }
+
+  // List mode: summary
+  printSummary(result.summary);
+  process.exit(0);
+}
+
+function printSummary(summary) {
+  console.log('');
+  console.log(chalk.bold('  AgentXchain Intake Status'));
+  console.log(chalk.dim('  ' + '─'.repeat(44)));
+  console.log(`  ${chalk.dim('Events:')}  ${summary.total_events}`);
+
+  const statusParts = Object.entries(summary.by_status)
+    .map(([s, c]) => `${s}: ${c}`)
+    .join(', ');
+  console.log(`  ${chalk.dim('Intents:')} ${summary.total_intents}  (${statusParts || 'none'})`);
+  console.log('');
+
+  if (summary.intents.length > 0) {
+    console.log(chalk.dim('  Recent Intents:'));
+    for (const i of summary.intents.slice(0, 20)) {
+      const pri = i.priority ? i.priority.padEnd(3) : '---';
+      const tpl = (i.template || '---').padEnd(12);
+      const st = statusColor(i.status);
+      console.log(`  ${chalk.dim(i.intent_id)}  ${pri}  ${tpl}  ${st}  ${chalk.dim(i.updated_at)}`);
+    }
+  }
+
+  console.log('');
+}
+
+function printIntentDetail(intent, event) {
+  console.log('');
+  console.log(chalk.bold(`  Intent: ${intent.intent_id}`));
+  console.log(chalk.dim('  ' + '─'.repeat(44)));
+  console.log(`  ${chalk.dim('Status:')}    ${statusColor(intent.status)}`);
+  console.log(`  ${chalk.dim('Event:')}     ${intent.event_id}`);
+  console.log(`  ${chalk.dim('Priority:')}  ${intent.priority || '—'}`);
+  console.log(`  ${chalk.dim('Template:')}  ${intent.template || '—'}`);
+  console.log(`  ${chalk.dim('Charter:')}   ${intent.charter || '—'}`);
+  console.log(`  ${chalk.dim('Created:')}   ${intent.created_at}`);
+  console.log(`  ${chalk.dim('Updated:')}   ${intent.updated_at}`);
+
+  if (intent.acceptance_contract && intent.acceptance_contract.length > 0) {
+    console.log('');
+    console.log(chalk.dim('  Acceptance Contract:'));
+    for (const a of intent.acceptance_contract) {
+      console.log(`    - ${a}`);
+    }
+  }
+
+  if (intent.history && intent.history.length > 0) {
+    console.log('');
+    console.log(chalk.dim('  History:'));
+    for (const h of intent.history) {
+      const from = h.from || '(new)';
+      console.log(`    ${chalk.dim(h.at)}  ${from} → ${h.to}  ${chalk.dim(h.reason)}`);
+    }
+  }
+
+  if (event) {
+    console.log('');
+    console.log(chalk.dim('  Source Event:'));
+    console.log(`    ${chalk.dim('Source:')}  ${event.source}`);
+    console.log(`    ${chalk.dim('Signal:')}  ${JSON.stringify(event.signal)}`);
+  }
+
+  console.log('');
+}
+
+function statusColor(status) {
+  switch (status) {
+    case 'detected': return chalk.yellow(status);
+    case 'triaged': return chalk.cyan(status);
+    case 'approved': return chalk.green(status);
+    case 'planned': return chalk.green(status);
+    case 'suppressed': return chalk.dim(status);
+    case 'rejected': return chalk.red(status);
+    default: return status;
+  }
+}

package/src/commands/intake-triage.js

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+import { findProjectRoot } from '../lib/config.js';
+import { triageIntent } from '../lib/intake.js';
+
+export async function intakeTriageCommand(opts) {
+  const root = findProjectRoot(process.cwd());
+  if (!root) {
+    if (opts.json) {
+      console.log(JSON.stringify({ ok: false, error: 'agentxchain.json not found' }, null, 2));
+    } else {
+      console.log(chalk.red('agentxchain.json not found'));
+    }
+    process.exit(2);
+  }
+
+  if (!opts.intent) {
+    const msg = '--intent <id> is required';
+    if (opts.json) {
+      console.log(JSON.stringify({ ok: false, error: msg }, null, 2));
+    } else {
+      console.log(chalk.red(msg));
+    }
+    process.exit(1);
+  }
+
+  const fields = {
+    suppress: opts.suppress || false,
+    reject: opts.reject || false,
+    reason: opts.reason || null,
+    priority: opts.priority || null,
+    template: opts.template || null,
+    charter: opts.charter || null,
+    acceptance_contract: opts.acceptance
+      ? opts.acceptance.split(',').map(s => s.trim()).filter(Boolean)
+      : [],
+  };
+
+  const result = triageIntent(root, opts.intent, fields);
+
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else if (result.ok) {
+    console.log('');
+    console.log(chalk.green(`  Intent ${result.intent.intent_id} → ${result.intent.status}`));
+    if (result.intent.priority) {
+      console.log(chalk.dim(`  Priority: ${result.intent.priority}  Template: ${result.intent.template}`));
+    }
+    console.log('');
+  } else {
+    console.log(chalk.red(`  ${result.error}`));
+  }
+
+  process.exit(result.exitCode);
+}

package/src/commands/step.js

@@ -17,6 +17,7 @@
  *   - local_cli: implemented via subprocess dispatch + staged turn result
  *   - api_proxy: implemented for synchronous review-only turns and stages
  *     provider-backed JSON before validation/acceptance
+ *   - mcp: implemented for synchronous MCP stdio tool dispatch
  */
 
 import chalk from 'chalk';
@@ -45,6 +46,7 @@ import {
   saveDispatchLogs,
   resolvePromptTransport,
 } from '../lib/adapters/local-cli-adapter.js';
+import { dispatchMcp } from '../lib/adapters/mcp-adapter.js';
 import {
   getDispatchAssignmentPath,
   getDispatchContextPath,
@@ -423,12 +425,64 @@ export async function stepCommand(opts) {
       console.log(chalk.dim(`  Tokens: ${apiResult.usage.input_tokens || 0} in / ${apiResult.usage.output_tokens || 0} out`));
     }
     console.log('');
+  } else if (runtimeType === 'mcp') {
+    console.log(chalk.cyan(`Dispatching to MCP stdio: ${runtime?.command || '(unknown)'}`));
+    console.log(chalk.dim(`Turn: ${turn.turn_id}  Role: ${roleId}  Phase: ${state.phase}  Tool: ${runtime?.tool_name || 'agentxchain_turn'}`));
+
+    const mcpResult = await dispatchMcp(root, state, config, {
+      signal: controller.signal,
+      onStatus: (msg) => console.log(chalk.dim(`  ${msg}`)),
+      onStderr: opts.verbose ? (text) => process.stderr.write(chalk.yellow(text)) : undefined,
+      verifyManifest: true,
+    });
+
+    if (mcpResult.logs?.length) {
+      saveDispatchLogs(root, turn.turn_id, mcpResult.logs);
+    }
+
+    if (mcpResult.aborted) {
+      console.log('');
+      console.log(chalk.yellow('Aborted. Turn remains assigned.'));
+      console.log(chalk.dim('Resume later with: agentxchain step --resume'));
+      console.log(chalk.dim('Or accept/reject manually: agentxchain accept-turn / reject-turn'));
+      process.exit(0);
+    }
+
+    if (!mcpResult.ok) {
+      const blocked = markRunBlocked(root, {
+        blockedOn: 'dispatch:mcp_failure',
+        category: 'dispatch_error',
+        recovery: {
+          typed_reason: 'dispatch_error',
+          owner: 'human',
+          recovery_action: 'Resolve the MCP dispatch issue, then run agentxchain step --resume',
+          turn_retained: true,
+          detail: mcpResult.error,
+        },
+        turnId: turn.turn_id,
+        hooksConfig,
+      });
+      if (blocked.ok) {
+        state = blocked.state;
+      }
+
+      console.log('');
+      console.log(chalk.red(`MCP dispatch failed: ${mcpResult.error}`));
+      console.log(chalk.dim('The turn remains assigned. You can:'));
+      console.log(chalk.dim('  - Fix the MCP server/runtime and retry: agentxchain step --resume'));
+      console.log(chalk.dim('  - Complete manually: edit .agentxchain/staging/turn-result.json'));
+      console.log(chalk.dim('  - Reject: agentxchain reject-turn --reason "mcp dispatch failed"'));
+      process.exit(1);
+    }
+
+    console.log(chalk.green(`MCP tool completed${mcpResult.toolName ? ` (${mcpResult.toolName})` : ''}. Staged result detected.`));
+    console.log('');
   }
 
   // ── Phase 3: Wait for turn completion ─────────────────────────────────────
 
-  if (runtimeType === 'api_proxy') {
-    // api_proxy is synchronous — result already staged in Phase 2
+  if (runtimeType === 'api_proxy' || runtimeType === 'mcp') {
+    // api_proxy and mcp are synchronous — result already staged in Phase 2
   } else if (runtimeType === 'local_cli') {
     // ── Local CLI adapter: spawn subprocess ──
     const transport = runtime ? resolvePromptTransport(runtime) : 'dispatch_bundle_only';

package/src/commands/template-validate.js

@@ -0,0 +1,159 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import chalk from 'chalk';
+import { CONFIG_FILE, findProjectRoot } from '../lib/config.js';
+import {
+  validateGovernedProjectTemplate,
+  validateGovernedTemplateRegistry,
+  validateProjectPlanningArtifacts,
+  validateAcceptanceHintCompletion,
+} from '../lib/governed-templates.js';
+
+function loadProjectTemplateValidation() {
+  const root = findProjectRoot();
+  if (!root) {
+    return {
+      present: false,
+      root: null,
+      template: null,
+      source: null,
+      ok: true,
+      errors: [],
+      warnings: [],
+    };
+  }
+
+  const configPath = join(root, CONFIG_FILE);
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(configPath, 'utf8'));
+  } catch (err) {
+    return {
+      present: true,
+      root,
+      template: null,
+      source: 'agentxchain.json',
+      ok: false,
+      errors: [`Failed to parse ${CONFIG_FILE}: ${err.message}`],
+      warnings: [],
+    };
+  }
+
+  const projectValidation = validateGovernedProjectTemplate(parsed.template);
+  return {
+    present: true,
+    root,
+    ...projectValidation,
+  };
+}
+
+export function templateValidateCommand(opts = {}) {
+  const registry = validateGovernedTemplateRegistry();
+  const project = loadProjectTemplateValidation();
+
+  // Planning artifact completeness check
+  let planningArtifacts = null;
+  if (project.present && project.ok && project.root) {
+    planningArtifacts = validateProjectPlanningArtifacts(project.root, project.template);
+  }
+
+  // Acceptance hint completion check
+  let acceptanceHints = null;
+  if (project.present && project.ok && project.root) {
+    acceptanceHints = validateAcceptanceHintCompletion(project.root, project.template);
+  }
+
+  const errors = [
+    ...registry.errors,
+    ...project.errors,
+    ...(planningArtifacts?.errors || []),
+  ];
+  const warnings = [
+    ...registry.warnings,
+    ...project.warnings,
+    ...(planningArtifacts?.warnings || []),
+    ...(acceptanceHints?.warnings || []),
+  ];
+  const ok = errors.length === 0;
+
+  const payload = {
+    ok,
+    registry,
+    project,
+    planning_artifacts: planningArtifacts,
+    acceptance_hints: acceptanceHints,
+    errors,
+    warnings,
+  };
+
+  if (opts.json) {
+    console.log(JSON.stringify(payload, null, 2));
+    if (!ok) process.exit(1);
+    return;
+  }
+
+  console.log('');
+  console.log(chalk.bold('  AgentXchain Template Validate'));
+  console.log(chalk.dim('  ' + '─'.repeat(44)));
+  console.log('');
+
+  if (ok) {
+    console.log(chalk.green('  ✓ Template validation passed.'));
+  } else {
+    console.log(chalk.red(`  ✗ Template validation failed (${errors.length} errors).`));
+  }
+
+  console.log('');
+  console.log(`  ${chalk.dim('Registry:')} ${registry.ok ? chalk.green('OK') : chalk.red('FAIL')} (${registry.registered_ids.length} registered, ${registry.manifest_ids.length} manifests)`);
+
+  if (project.present) {
+    const sourceLabel = project.source === 'implicit_default'
+      ? 'implicit default'
+      : project.source;
+    console.log(`  ${chalk.dim('Project:')}  ${project.ok ? chalk.green('OK') : chalk.red('FAIL')} (${project.template} via ${sourceLabel})`);
+    if (project.root && existsSync(project.root)) {
+      console.log(`  ${chalk.dim('Root:')}     ${project.root}`);
+    }
+    if (planningArtifacts) {
+      const total = planningArtifacts.expected.length;
+      const found = planningArtifacts.present.length;
+      if (total === 0) {
+        console.log(`  ${chalk.dim('Planning:')}   ${chalk.green('OK')} (no template artifacts required)`);
+      } else if (planningArtifacts.ok) {
+        console.log(`  ${chalk.dim('Planning:')}   ${chalk.green('OK')} (${found}/${total} present)`);
+      } else {
+        console.log(`  ${chalk.dim('Planning:')}   ${chalk.red('FAIL')} (${planningArtifacts.missing.length}/${total} missing: ${planningArtifacts.missing.join(', ')})`);
+      }
+    }
+    if (acceptanceHints) {
+      if (acceptanceHints.total === 0) {
+        console.log(`  ${chalk.dim('Acceptance:')} ${chalk.green('OK')} (no template hints defined)`);
+      } else if (acceptanceHints.unchecked === 0) {
+        console.log(`  ${chalk.dim('Acceptance:')} ${chalk.green('OK')} (${acceptanceHints.checked}/${acceptanceHints.total} checked)`);
+      } else {
+        console.log(`  ${chalk.dim('Acceptance:')} ${chalk.yellow('WARN')} (${acceptanceHints.unchecked}/${acceptanceHints.total} unchecked)`);
+      }
+    }
+  } else {
+    console.log(`  ${chalk.dim('Project:')}  ${chalk.dim('No project detected; registry-only validation')}`);
+  }
+
+  if (errors.length > 0) {
+    console.log('');
+    console.log(chalk.red('  Errors:'));
+    for (const error of errors) {
+      console.log(`    - ${error}`);
+    }
+  }
+
+  if (warnings.length > 0) {
+    console.log('');
+    console.log(chalk.yellow('  Warnings:'));
+    for (const warning of warnings) {
+      console.log(`    - ${warning}`);
+    }
+  }
+
+  console.log('');
+  if (!ok) process.exit(1);
+}

package/src/commands/verify.js

@@ -57,13 +57,18 @@ function printProtocolReport(report) {
       : tier.status === 'skipped'
         ? chalk.yellow('skipped')
         : chalk.red(tier.status);
-    console.log(`  ${tierKey}: ${label} (${tier.fixtures_passed}/${tier.fixtures_run} passed)`);
+    const niCount = tier.fixtures_not_implemented || 0;
+    const niSuffix = niCount > 0 ? chalk.yellow(`, ${niCount} not implemented`) : '';
+    console.log(`  ${tierKey}: ${label} (${tier.fixtures_passed}/${tier.fixtures_run} passed${niSuffix})`);
 
+    for (const ni of tier.not_implemented || []) {
+      console.log(chalk.yellow(`    ○ ${ni.fixture_id}: ${ni.message}`));
+    }
     for (const failure of tier.failures || []) {
-      console.log(chalk.red(`    - ${failure.fixture_id}: ${failure.message}`));
+      console.log(chalk.red(`    ✗ ${failure.fixture_id}: ${failure.message}`));
     }
     for (const error of tier.errors || []) {
-      console.log(chalk.red(`    - ${error.fixture_id}: ${error.message}`));
+      console.log(chalk.red(`    ✗ ${error.fixture_id}: ${error.message}`));
     }
   }