agentxchain 2.127.0 → 2.128.0

package/README.md

@@ -172,7 +172,8 @@ agentxchain step
 | `template validate` | Prove the template registry, workflow-kit scaffold contract, and planning artifact completeness (`--json` exposes a `workflow_kit` block) |
 | `verify turn` | Replay a staged turn's declared machine-evidence commands to confirm reproducibility before acceptance |
 | `replay turn` | Replay an accepted turn's machine-evidence commands from history for audit and drift detection |
-| `verify protocol` | Run the shipped protocol conformance suite against a target implementation |
+| `conformance check` | Preferred front door for the shipped protocol conformance suite |
+| `verify protocol` | Compatibility alias for the shipped protocol conformance suite |
 | `dashboard` | Open the live local governance dashboard in your browser for the current repo/workspace or multi-repo coordinator initiative, including pending gate approvals |
 | `run [--auto-approve] [--max-turns N] [--dry-run]` | Drive a governed run from start to completion — dispatches turns, handles gates, manages rejection/retry |
 
@@ -247,9 +248,11 @@ Partial coordinator artifacts are first-class here too: `audit` and `report` kee
 AgentXchain ships a conformance kit under `.agentxchain-conformance/`. Use it to prove a runner or fork still implements the governed workflow contract:
 
 ```bash
-agentxchain verify protocol --tier 3 --target .
+agentxchain conformance check --tier 3 --target .
 ```
 
+`agentxchain verify protocol` remains available as a compatibility alias.
+
 Useful flags:
 
 - `--tier 1|2|3`: maximum conformance tier to verify

package/bin/agentxchain.js

@@ -542,6 +542,22 @@ program
   .option('-j, --json', 'Output as JSON')
   .action(validateCommand);
 
+const conformanceCmd = program
+  .command('conformance')
+  .description('Run protocol conformance checks against local or remote implementations');
+
+conformanceCmd
+  .command('check')
+  .description('Run the shipped protocol conformance fixture suite against a target implementation')
+  .option('--tier <tier>', 'Conformance tier to verify (1, 2, or 3)', '1')
+  .option('--surface <surface>', 'Restrict verification to a single surface')
+  .option('--target <path>', 'Target root containing .agentxchain-conformance/capabilities.json', '.')
+  .option('--remote <url>', 'Remote HTTP conformance endpoint base URL')
+  .option('--token <token>', 'Bearer token for remote HTTP conformance endpoint')
+  .option('--timeout <ms>', 'Per-fixture remote HTTP timeout in milliseconds', '30000')
+  .option('--format <format>', 'Output format: text or json', 'text')
+  .action(verifyProtocolCommand);
+
 const verifyCmd = program
   .command('verify')
   .description('Verify governed turns, export artifacts, and protocol conformance targets');

package/package.json

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

package/src/commands/init.js

@@ -441,10 +441,20 @@ function commandHasPromptPlaceholder(parts = []) {
   return parts.some((part) => typeof part === 'string' && part.includes('{prompt}'));
 }
 
+function normalizeGovernedDevCommand(parts = []) {
+  if (!Array.isArray(parts) || parts.length === 0) {
+    return null;
+  }
+  const [head, ...rest] = parts;
+  const normalizedHead = String(head || '').trim().split(/\s+/).filter(Boolean);
+  const normalizedRest = rest
+    .map((part) => String(part).trim())
+    .filter(Boolean);
+  return [...normalizedHead, ...normalizedRest];
+}
+
 function resolveGovernedLocalDevRuntime(opts = {}) {
-  const customCommand = Array.isArray(opts.devCommand)
-    ? opts.devCommand.map((part) => String(part).trim()).filter(Boolean)
-    : null;
+  const customCommand = normalizeGovernedDevCommand(opts.devCommand);
   const explicitTransport = typeof opts.devPromptTransport === 'string' && opts.devPromptTransport.trim()
     ? opts.devPromptTransport.trim()
     : null;

package/src/commands/run.js

@@ -193,6 +193,19 @@ export async function executeGovernedRun(context, opts = {}) {
       const supported = rtType !== 'manual';
       log(`  ${supported ? chalk.green('✓') : chalk.red('✗')} ${rid} → ${rtType}${supported ? '' : ' (not supported in run mode)'}`);
     }
+    // Warn if the first-dispatched role in the current phase is manual
+    if (roleId) {
+      const firstRole = config.roles?.[roleId];
+      const firstRtId = firstRole?.runtime;
+      const firstRt = config.runtimes?.[firstRtId];
+      const firstRtType = firstRt?.type || firstRole?.runtime_class || 'manual';
+      if (firstRtType === 'manual') {
+        log('');
+        log(chalk.yellow(`  ⚠ The current phase's first role (${roleId}) is manual.`));
+        log(chalk.yellow(`    "run" will block immediately. Complete manual turns via "agentxchain step" first,`));
+        log(chalk.yellow(`    or configure ${roleId} with an automatable runtime.`));
+      }
+    }
     return { exitCode: 0, result: null };
   }
 

package/src/lib/adapters/local-cli-adapter.js

@@ -278,7 +278,13 @@ function resolveCommand(runtime, fullPrompt) {
 
   // Shape 1: command is an array
   if (Array.isArray(runtime.command)) {
-    const [cmd, ...rest] = runtime.command;
+    // Normalize: if the first element contains spaces (e.g., ["echo test"]), split it
+    // into binary + args. Only the first element is split — later elements may contain
+    // legitimate spaces (e.g., script text for `node -e "..."`).
+    const first = runtime.command[0] || '';
+    const headParts = typeof first === 'string' && first.includes(' ') ? first.split(/\s+/) : [first];
+    const [cmd, ...headArgs] = headParts;
+    const rest = [...headArgs, ...runtime.command.slice(1)];
     const args = transport === 'argv'
       ? rest.map(arg => arg === '{prompt}' ? fullPrompt : arg)
       : rest.filter(arg => arg !== '{prompt}');

package/src/lib/connector-probe.js

@@ -38,7 +38,9 @@ function formatTarget(runtime) {
 
 function commandHead(runtime) {
   if (Array.isArray(runtime?.command)) {
-    return runtime.command[0] || null;
+    const first = runtime.command[0] || null;
+    if (first && first.includes(' ')) return first.split(/\s+/)[0];
+    return first;
   }
   if (typeof runtime?.command === 'string' && runtime.command.trim()) {
     return runtime.command.trim().split(/\s+/)[0];