agentxchain 2.1.1 → 2.3.0

package/src/lib/normalized-config.js

@@ -13,9 +13,11 @@
  */
 
 import { validateHooksConfig } from './hook-runner.js';
+import { SUPPORTED_TOKEN_COUNTER_PROVIDERS } from './token-counter.js';
 
 const VALID_WRITE_AUTHORITIES = ['authoritative', 'proposed', 'review_only'];
 const VALID_RUNTIME_TYPES = ['manual', 'local_cli', 'api_proxy'];
+const VALID_API_PROXY_PROVIDERS = ['anthropic', 'openai'];
 const VALID_PROMPT_TRANSPORTS = ['argv', 'stdin', 'dispatch_bundle_only'];
 const VALID_PHASES = ['planning', 'implementation', 'qa'];
 const VALID_API_PROXY_RETRY_JITTER = ['none', 'full'];
@@ -146,6 +148,12 @@ function validateApiProxyPreflightTokenization(runtimeId, runtime, errors) {
   }
 
   if (preflight.enabled === true) {
+    if (!SUPPORTED_TOKEN_COUNTER_PROVIDERS.includes(runtime.provider)) {
+      errors.push(
+        `Runtime "${runtimeId}": preflight_tokenization tokenizer "provider_local" is not supported for provider "${runtime.provider}". Supported providers: ${SUPPORTED_TOKEN_COUNTER_PROVIDERS.join(', ')}`
+      );
+    }
+
     if (!Number.isInteger(runtime.context_window_tokens) || runtime.context_window_tokens <= 0) {
       errors.push(`Runtime "${runtimeId}": context_window_tokens is required when preflight_tokenization.enabled is true`);
       return;
@@ -239,6 +247,8 @@ export function validateV4Config(data, projectRoot) {
       if (rt.type === 'api_proxy') {
         if (typeof rt.provider !== 'string' || !rt.provider.trim()) {
           errors.push(`Runtime "${id}": api_proxy requires "provider" (e.g. "anthropic", "openai")`);
+        } else if (!VALID_API_PROXY_PROVIDERS.includes(rt.provider)) {
+          errors.push(`Runtime "${id}": api_proxy provider must be one of: ${VALID_API_PROXY_PROVIDERS.join(', ')}`);
         }
         if (typeof rt.model !== 'string' || !rt.model.trim()) {
           errors.push(`Runtime "${id}": api_proxy requires "model" (e.g. "claude-sonnet-4-6")`);

package/src/lib/protocol-conformance.js

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const DEFAULT_FIXTURE_ROOT = resolve(__dirname, '..', '..', '..', '.agentxchain-conformance', 'fixtures');
-const VALID_RESPONSE_STATUSES = new Set(['pass', 'fail', 'error']);
+const VALID_RESPONSE_STATUSES = new Set(['pass', 'fail', 'error', 'not_implemented']);
 const VALID_TIERS = new Set([1, 2, 3]);
 
 function readJsonFile(filePath) {
@@ -119,16 +119,18 @@ function createTierSummary(status = 'skipped', note = null) {
     fixtures_passed: 0,
     fixtures_failed: 0,
     fixtures_errored: 0,
+    fixtures_not_implemented: 0,
     surfaces: {},
     failures: [],
     errors: [],
+    not_implemented: [],
     ...(note ? { note } : {}),
   };
 }
 
 function ensureSurfaceSummary(tierSummary, surface) {
   if (!tierSummary.surfaces[surface]) {
-    tierSummary.surfaces[surface] = { passed: 0, failed: 0, errored: 0 };
+    tierSummary.surfaces[surface] = { passed: 0, failed: 0, errored: 0, not_implemented: 0 };
   }
   return tierSummary.surfaces[surface];
 }
@@ -149,7 +151,7 @@ function executeFixture(targetRoot, adapterCommand, fixture) {
     };
   }
 
-  if (![0, 1, 2].includes(result.status ?? -1)) {
+  if (![0, 1, 2, 3].includes(result.status ?? -1)) {
     return {
       status: 'error',
       message: `Adapter exited with unsupported status ${result.status}`,
@@ -182,7 +184,7 @@ function executeFixture(targetRoot, adapterCommand, fixture) {
     };
   }
 
-  const expectedExitCode = parsed.status === 'pass' ? 0 : parsed.status === 'fail' ? 1 : 2;
+  const expectedExitCode = parsed.status === 'pass' ? 0 : parsed.status === 'fail' ? 1 : parsed.status === 'not_implemented' ? 3 : 2;
   if (result.status !== expectedExitCode) {
     return {
       status: 'error',
@@ -210,6 +212,17 @@ export function verifyProtocolConformance({
 
   const resolvedTargetRoot = resolve(targetRoot);
   const capabilities = loadCapabilities(resolvedTargetRoot);
+
+  // Enforce surface claims when capabilities.surfaces exists and --surface is requested
+  if (surface && capabilities.surfaces && typeof capabilities.surfaces === 'object') {
+    if (!capabilities.surfaces[surface]) {
+      throw new Error(
+        `Surface "${surface}" is not claimed in capabilities.json. ` +
+        `Claimed surfaces: ${Object.keys(capabilities.surfaces).join(', ')}`
+      );
+    }
+  }
+
   const fixtureEntries = selectFixtureFiles(fixtureRoot, requestedTier, surface);
   const claimedTiers = new Set(capabilities.tiers);
   const report = {
@@ -250,6 +263,17 @@ export function verifyProtocolConformance({
       continue;
     }
 
+    if (adapterResult.status === 'not_implemented') {
+      tierSummary.fixtures_not_implemented += 1;
+      surfaceSummary.not_implemented += 1;
+      tierSummary.not_implemented.push({
+        fixture_id: fixture.fixture_id,
+        surface: fixture.surface,
+        message: adapterResult.message || 'Not implemented',
+      });
+      continue;
+    }
+
     if (adapterResult.status === 'fail') {
       tierSummary.fixtures_failed += 1;
       surfaceSummary.failed += 1;

package/src/lib/reference-conformance-adapter.js

@@ -13,6 +13,9 @@ import { validateStagedTurnResult } from './turn-result-validator.js';
 import { finalizeDispatchManifest, verifyDispatchManifest } from './dispatch-manifest.js';
 import { getDispatchTurnDir } from './turn-paths.js';
 import { runHooks } from './hook-runner.js';
+import { validateCoordinatorConfig, normalizeCoordinatorConfig } from './coordinator-config.js';
+import { projectRepoAcceptance, evaluateBarriers } from './coordinator-acceptance.js';
+import { readBarriers, saveCoordinatorState, readCoordinatorHistory } from './coordinator-state.js';
 
 const VALID_DECISION_CATEGORIES = ['implementation', 'architecture', 'scope', 'process', 'quality', 'release'];
 const FULL_STAGE_PIPELINE = ['schema', 'assignment', 'artifact', 'verification', 'protocol'];
@@ -213,6 +216,69 @@ function materializeFixtureWorkspace(fixture) {
   };
 }
 
+// ── Tier 3: Multi-workspace materialization ─────────────────────────────────
+
+function materializeTier3Workspace(fixture) {
+  const root = mkdtempSync(join(tmpdir(), 'agentxchain-conformance-multi-'));
+  const setup = fixture.setup || {};
+
+  // Write coordinator config
+  if (setup.coordinator_config) {
+    writeJson(join(root, 'agentxchain-multi.json'), setup.coordinator_config);
+  }
+
+  // Materialize governed repo roots
+  for (const [repoId, repoSetup] of Object.entries(setup.repos || {})) {
+    const repoPath = join(root, repoSetup.path || `./repos/${repoId}`);
+    mkdirSync(join(repoPath, '.agentxchain'), { recursive: true });
+
+    // Write repo-local agentxchain.json
+    if (repoSetup.config) {
+      writeJson(join(repoPath, 'agentxchain.json'), repoSetup.config);
+    }
+
+    // Write repo-local state
+    if (repoSetup.state) {
+      const repoConfig = repoSetup.config || {};
+      const inflatedRepoConfig = inflateConfig(repoConfig);
+      const repoState = inflateState(repoSetup.state, inflatedRepoConfig);
+      writeJson(join(repoPath, '.agentxchain', 'state.json'), repoState);
+    }
+
+    // Write repo-local history
+    if (repoSetup.history) {
+      writeJsonl(join(repoPath, '.agentxchain', 'history.jsonl'), repoSetup.history);
+    }
+
+    // Write repo-local files
+    for (const [filePath, content] of Object.entries(repoSetup.files || {})) {
+      const absPath = join(repoPath, filePath);
+      mkdirSync(dirname(absPath), { recursive: true });
+      writeFileSync(absPath, content);
+    }
+  }
+
+  // Write coordinator multirepo state if provided
+  if (setup.coordinator_state || setup.barriers) {
+    const multiDir = join(root, '.agentxchain', 'multirepo');
+    mkdirSync(multiDir, { recursive: true });
+
+    if (setup.coordinator_state) {
+      writeJson(join(multiDir, 'state.json'), setup.coordinator_state);
+    }
+
+    if (setup.barriers) {
+      writeJson(join(multiDir, 'barriers.json'), setup.barriers);
+    }
+
+    // Write coordinator history
+    writeJsonl(join(multiDir, 'history.jsonl'), setup.coordinator_history || []);
+    writeJsonl(join(multiDir, 'barrier-ledger.jsonl'), setup.barrier_ledger || []);
+  }
+
+  return root;
+}
+
 function isAssertionObject(value) {
   return value && typeof value === 'object' && !Array.isArray(value) && typeof value.assert === 'string';
 }
@@ -699,6 +765,74 @@ function executeFixtureOperation(workspace, fixture) {
   }
 }
 
+function executeTier3Operation(fixture) {
+  const root = materializeTier3Workspace(fixture);
+  try {
+    const operation = fixture.input.operation;
+
+    if (operation === 'validate_coordinator_config') {
+      const configPath = join(root, 'agentxchain-multi.json');
+      const raw = JSON.parse(readFileSync(configPath, 'utf8'));
+      const validation = validateCoordinatorConfig(raw);
+      if (!validation.ok) {
+        const firstError = validation.errors[0] || '';
+        let errorType = 'invalid_coordinator_config';
+        if (firstError.startsWith('workstream_cycle:')) {
+          errorType = 'workstream_cycle';
+        }
+        return { result: 'error', error_type: errorType, errors: validation.errors };
+      }
+      return { result: 'success', errors: [] };
+    }
+
+    if (operation === 'project_repo_acceptance') {
+      const args = fixture.input.args;
+      const configPath = join(root, 'agentxchain-multi.json');
+      const raw = JSON.parse(readFileSync(configPath, 'utf8'));
+      const normalized = normalizeCoordinatorConfig(raw);
+
+      // Resolve repo paths against the materialized workspace
+      for (const [repoId, repo] of Object.entries(normalized.repos)) {
+        const resolvedPath = join(root, repo.path);
+        normalized.repos[repoId] = { ...repo, resolved_path: resolvedPath };
+      }
+      normalized.repo_order = Object.keys(normalized.repos);
+
+      const stateDir = join(root, '.agentxchain', 'multirepo');
+      const state = JSON.parse(readFileSync(join(stateDir, 'state.json'), 'utf8'));
+
+      const projectionResult = projectRepoAcceptance(
+        root, state, normalized,
+        args.repo_id, args.accepted_turn, args.workstream_id,
+      );
+
+      if (!projectionResult.ok) {
+        let errorType = 'projection_failed';
+        if (projectionResult.error && projectionResult.error.includes('Cross-repo write violation')) {
+          errorType = 'cross_repo_write_violation';
+        }
+        return { result: 'error', error_type: errorType, error: projectionResult.error };
+      }
+
+      // Evaluate barriers after projection
+      const barrierResult = evaluateBarriers(root, state, normalized);
+
+      return {
+        result: 'success',
+        projection_ref: projectionResult.projection_ref,
+        barrier_effects: projectionResult.barrier_effects || [],
+        barrier_snapshot: Object.fromEntries(
+          Object.entries(barrierResult.barriers).map(([id, b]) => [id, { status: b.status }]),
+        ),
+      };
+    }
+
+    return { result: 'error', error_type: 'unsupported_operation', operation };
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+}
+
 function compareActualToExpected(fixture, actual) {
   if (matchExpected(fixture.expected, actual)) {
     return buildPass(actual);
@@ -707,6 +841,13 @@ function compareActualToExpected(fixture, actual) {
 }
 
 export function runReferenceFixture(fixture) {
+  // Tier 3 fixtures use multi-workspace materialization; route before creating a Tier 1/2 workspace
+  const operation = fixture.input?.operation;
+  if (operation === 'validate_coordinator_config' || operation === 'project_repo_acceptance') {
+    const actual = executeTier3Operation(fixture);
+    return compareActualToExpected(fixture, actual);
+  }
+
   const workspace = materializeFixtureWorkspace(fixture);
   try {
     const actual = executeFixtureOperation(workspace, fixture);

package/src/lib/repo-observer.js

@@ -25,6 +25,7 @@ import { join } from 'path';
 const OPERATIONAL_PATH_PREFIXES = [
   '.agentxchain/dispatch/',
   '.agentxchain/staging/',
+  '.agentxchain/intake/',
   '.agentxchain/locks/',
   '.agentxchain/transactions/',
 ];