agentxchain 2.135.1 → 2.136.1

package/bin/agentxchain.js

@@ -123,10 +123,11 @@ import { historyCommand } from '../src/commands/history.js';
 import { decisionsCommand } from '../src/commands/decisions.js';
 import { diffCommand } from '../src/commands/diff.js';
 import { eventsCommand } from '../src/commands/events.js';
-import { connectorCheckCommand, connectorValidateCommand } from '../src/commands/connector.js';
+import { connectorCapabilitiesCommand, connectorCheckCommand, connectorValidateCommand } from '../src/commands/connector.js';
 import { scheduleDaemonCommand, scheduleListCommand, scheduleRunDueCommand, scheduleStatusCommand } from '../src/commands/schedule.js';
 import { chainLatestCommand, chainListCommand, chainShowCommand } from '../src/commands/chain.js';
 import { missionAttachChainCommand, missionBindCoordinatorCommand, missionListCommand, missionPlanApproveCommand, missionPlanAutopilotCommand, missionPlanCommand, missionPlanLaunchCommand, missionPlanListCommand, missionPlanShowCommand, missionShowCommand, missionStartCommand } from '../src/commands/mission.js';
+import { workflowKitDescribeCommand } from '../src/commands/workflow-kit.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
@@ -299,6 +300,13 @@ connectorCmd
   .option('--timeout <ms>', 'Per-probe timeout in milliseconds', '8000')
   .action(connectorCheckCommand);
 
+connectorCmd
+  .command('capabilities [runtime_id]')
+  .description('Show merged capability contract for a runtime or all runtimes (machine-readable handshake)')
+  .option('-j, --json', 'Output as JSON')
+  .option('--all', 'Show capabilities for all configured runtimes')
+  .action(connectorCapabilitiesCommand);
+
 connectorCmd
   .command('validate <runtime_id>')
   .description('Dispatch one synthetic governed turn through a runtime and validate the staged turn result')
@@ -839,6 +847,16 @@ phaseCmd
   .option('-j, --json', 'Output as JSON')
   .action((phaseId, opts) => phaseCommand('show', phaseId, opts));
 
+const workflowKitCmd = program
+  .command('workflow-kit')
+  .description('Inspect the workflow kit contract for this project');
+
+workflowKitCmd
+  .command('describe')
+  .description('Show the workflow kit contract — templates, artifacts, semantic validators, gate coverage')
+  .option('-j, --json', 'Output as JSON')
+  .action(workflowKitDescribeCommand);
+
 const gateCmd = program
   .command('gate')
   .description('Inspect governed gate definitions');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxchain",
-  "version": "2.135.1",
+  "version": "2.136.1",
   "description": "CLI for AgentXchain — governed multi-agent software delivery",
   "type": "module",
   "bin": {
@@ -10,7 +10,9 @@
     ".": "./bin/agentxchain.js",
     "./adapter-interface": "./src/lib/adapter-interface.js",
     "./runner-interface": "./src/lib/runner-interface.js",
-    "./run-loop": "./src/lib/run-loop.js"
+    "./run-loop": "./src/lib/run-loop.js",
+    "./schemas/agentxchain-config": "./src/lib/schemas/agentxchain-config.schema.json",
+    "./schemas/connector-capabilities-output": "./src/lib/schemas/connector-capabilities-output.schema.json"
   },
   "files": [
     "bin/",

package/scripts/release-preflight.sh

@@ -154,6 +154,8 @@ if [[ "$PUBLISH_GATE" -eq 1 ]]; then
     test/release-identity-hardening.test.js
     test/normalized-config.test.js
     test/conformance.test.js
+    test/beta-scenario-emission-guard.test.js
+    test/claim-reality-preflight.test.js
     test/beta-tester-scenarios/*.test.js
   )
   GATE_TEST_ARGS=()

package/src/commands/connector.js

@@ -3,6 +3,7 @@ import chalk from 'chalk';
 import { loadProjectContext } from '../lib/config.js';
 import { DEFAULT_VALIDATE_TIMEOUT_MS, validateConfiguredConnector } from '../lib/connector-validate.js';
 import { DEFAULT_TIMEOUT_MS, probeConfiguredConnectors } from '../lib/connector-probe.js';
+import { buildRuntimeCapabilityReport } from '../lib/runtime-capabilities.js';
 
 function printJson(result, exitCode) {
   console.log(JSON.stringify(result, null, 2));
@@ -164,6 +165,14 @@ function printValidateText(result, exitCode) {
     }
   }
 
+  if (result.schema_contract) {
+    console.log('');
+    console.log(`  ${chalk.dim('Schema:')}   ${result.schema_contract.ok ? chalk.green('ok') : chalk.red('failed')}`);
+    if (Array.isArray(result.schema_contract.failures) && result.schema_contract.failures.length > 0) {
+      console.log(`  ${chalk.dim('Contract:')} ${result.schema_contract.failures.join(' | ')}`);
+    }
+  }
+
   if (result.dispatch) {
     console.log('');
     console.log(`  ${chalk.dim('Dispatch:')} ${result.dispatch.ok ? chalk.green('ok') : chalk.red('failed')}`);
@@ -192,6 +201,110 @@ function printValidateText(result, exitCode) {
   process.exit(exitCode);
 }
 
+function printCapabilitiesText(report) {
+  console.log('');
+  console.log(chalk.bold(`  ${report.runtime_id}`) + chalk.dim(` (${report.runtime_type})`));
+  console.log(chalk.dim('  ' + '-'.repeat(44)));
+
+  const c = report.merged_contract;
+  console.log(`  ${chalk.dim('Transport:')}         ${c.transport}`);
+  console.log(`  ${chalk.dim('Write files:')}       ${c.can_write_files}`);
+  console.log(`  ${chalk.dim('Proposals:')}         ${c.proposal_support}`);
+  console.log(`  ${chalk.dim('Artifact ownership:')} ${c.workflow_artifact_ownership}`);
+  console.log(`  ${chalk.dim('Local binary:')}      ${c.requires_local_binary ? 'yes' : 'no'}`);
+
+  if (Object.keys(report.declared_capabilities).length > 0) {
+    console.log('');
+    console.log(`  ${chalk.dim('Declared overrides:')}`);
+    for (const [k, v] of Object.entries(report.declared_capabilities)) {
+      console.log(`    ${k}: ${v}`);
+    }
+  }
+
+  if (report.declaration_warnings.length > 0) {
+    console.log('');
+    for (const w of report.declaration_warnings) {
+      console.log(`  ${chalk.yellow('!')} ${w}`);
+    }
+  }
+
+  if (report.role_bindings.length > 0) {
+    console.log('');
+    console.log(`  ${chalk.dim('Role bindings:')}`);
+    for (const rb of report.role_bindings) {
+      const badge = rb.effective_write_path.startsWith('invalid') ? chalk.red('INVALID') : chalk.green('OK');
+      console.log(`    ${badge}  ${rb.role_id} (${rb.role_write_authority}) -> ${rb.effective_write_path}`);
+      for (const note of rb.notes) {
+        console.log(`         ${chalk.dim(note)}`);
+      }
+    }
+  }
+}
+
+export async function connectorCapabilitiesCommand(runtimeId, options = {}) {
+  const context = loadProjectContext();
+  if (!context) {
+    const payload = { error: 'No governed agentxchain.json found.' };
+    if (options.json) { printJson(payload, 2); return; }
+    console.error(chalk.red('No governed agentxchain.json found. Run this inside a governed project.'));
+    process.exit(2);
+  }
+
+  const config = context.config;
+  const runtimes = config.runtimes || {};
+  const roles = config.roles || {};
+
+  if (options.all) {
+    const reports = [];
+    for (const [id, runtime] of Object.entries(runtimes)) {
+      reports.push(buildRuntimeCapabilityReport(id, runtime, roles));
+    }
+    const payload = { runtimes: reports };
+    if (options.json) { printJson(payload, 0); return; }
+
+    console.log('');
+    console.log(chalk.bold('  AgentXchain Connector Capabilities'));
+    console.log(chalk.dim('  ' + '='.repeat(44)));
+    if (reports.length === 0) {
+      console.log('  No runtimes configured.');
+    } else {
+      for (const r of reports) { printCapabilitiesText(r); }
+    }
+    console.log('');
+    process.exit(0);
+  }
+
+  if (!runtimeId) {
+    const payload = { error: 'Runtime ID required. Use --all to list all runtimes.', available_runtimes: Object.keys(runtimes) };
+    if (options.json) { printJson(payload, 2); return; }
+    console.error(chalk.red('Runtime ID required. Use --all to list all runtimes.'));
+    if (Object.keys(runtimes).length > 0) {
+      console.error(chalk.dim(`Available: ${Object.keys(runtimes).join(', ')}`));
+    }
+    process.exit(2);
+  }
+
+  if (!runtimes[runtimeId]) {
+    const payload = { error: `Runtime "${runtimeId}" not found.`, available_runtimes: Object.keys(runtimes) };
+    if (options.json) { printJson(payload, 2); return; }
+    console.error(chalk.red(`Runtime "${runtimeId}" not found.`));
+    if (Object.keys(runtimes).length > 0) {
+      console.error(chalk.dim(`Available: ${Object.keys(runtimes).join(', ')}`));
+    }
+    process.exit(2);
+  }
+
+  const report = buildRuntimeCapabilityReport(runtimeId, runtimes[runtimeId], roles);
+  if (options.json) { printJson(report, 0); return; }
+
+  console.log('');
+  console.log(chalk.bold('  AgentXchain Connector Capabilities'));
+  console.log(chalk.dim('  ' + '='.repeat(44)));
+  printCapabilitiesText(report);
+  console.log('');
+  process.exit(0);
+}
+
 export async function connectorValidateCommand(runtimeId, options = {}) {
   const context = loadProjectContext();
   if (!context) {

package/src/commands/restart.js

@@ -326,6 +326,9 @@ export async function restartCommand(opts) {
       console.log(chalk.red(`Failed to reactivate run: ${reactivated.error}`));
       process.exit(1);
     }
+    if (reactivated.migration_notice) {
+      console.log(chalk.yellow(reactivated.migration_notice));
+    }
   }
 
   // Determine role from option or routing

package/src/commands/resume.js

@@ -144,6 +144,9 @@ export async function resumeCommand(opts) {
         process.exit(1);
       }
       state = reactivated.state;
+      if (reactivated.migration_notice) {
+        console.log(chalk.yellow(reactivated.migration_notice));
+      }
 
       // Write dispatch bundle for the existing turn
       const bundleResult = writeDispatchBundle(root, state, config);
@@ -204,6 +207,9 @@ export async function resumeCommand(opts) {
       process.exit(1);
     }
     state = reactivated.state;
+    if (reactivated.migration_notice) {
+      console.log(chalk.yellow(reactivated.migration_notice));
+    }
 
     const bundleResult = writeDispatchBundle(root, state, config, { turnId: retainedTurn.turn_id });
     if (!bundleResult.ok) {
@@ -233,6 +239,9 @@ export async function resumeCommand(opts) {
     }
     state = initResult.state;
     console.log(chalk.green(`Initialized governed run: ${state.run_id}`));
+    if (initResult.migration_notice) {
+      console.log(chalk.yellow(initResult.migration_notice));
+    }
   }
 
   // §47: paused + run_id exists → resume same run
@@ -244,6 +253,9 @@ export async function resumeCommand(opts) {
     }
     state = reactivated.state;
     console.log(chalk.green(`Resumed blocked run: ${state.run_id}`));
+    if (reactivated.migration_notice) {
+      console.log(chalk.yellow(reactivated.migration_notice));
+    }
   }
 
   // §47: paused + run_id exists → resume same run
@@ -255,6 +267,9 @@ export async function resumeCommand(opts) {
     }
     state = reactivated.state;
     console.log(chalk.green(`Resumed governed run: ${state.run_id}`));
+    if (reactivated.migration_notice) {
+      console.log(chalk.yellow(reactivated.migration_notice));
+    }
   }
 
   // Print run-context header before dispatch

package/src/commands/step.js

@@ -260,6 +260,9 @@ export async function stepCommand(opts) {
           process.exit(1);
         }
         state = reactivated.state;
+        if (reactivated.migration_notice) {
+          console.log(chalk.yellow(reactivated.migration_notice));
+        }
         skipAssignment = true;
 
         // BUG-1 fix: refresh baseline snapshot to capture files dirtied between assignment and dispatch
@@ -285,6 +288,9 @@ export async function stepCommand(opts) {
       }
       state = initResult.state;
       console.log(chalk.green(`Initialized governed run: ${state.run_id}`));
+      if (initResult.migration_notice) {
+        console.log(chalk.yellow(initResult.migration_notice));
+      }
     }
 
     // paused → resume
@@ -296,6 +302,9 @@ export async function stepCommand(opts) {
       }
       state = reactivated.state;
       console.log(chalk.green(`Resumed blocked run: ${state.run_id}`));
+      if (reactivated.migration_notice) {
+        console.log(chalk.yellow(reactivated.migration_notice));
+      }
     }
 
     if (!skipAssignment && state.status === 'paused' && state.run_id) {
@@ -306,6 +315,9 @@ export async function stepCommand(opts) {
       }
       state = reactivated.state;
       console.log(chalk.green(`Resumed governed run: ${state.run_id}`));
+      if (reactivated.migration_notice) {
+        console.log(chalk.yellow(reactivated.migration_notice));
+      }
     }
 
     // Assign the turn

package/src/commands/workflow-kit.js

@@ -0,0 +1,186 @@
+import chalk from 'chalk';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { loadProjectContext } from '../lib/config.js';
+import {
+  VALID_WORKFLOW_KIT_PHASE_TEMPLATE_IDS,
+} from '../lib/workflow-kit-phase-templates.js';
+import { getEffectiveGateArtifacts } from '../lib/gate-evaluator.js';
+
+const WORKFLOW_KIT_VERSION = '1.0';
+
+const SEMANTIC_VALIDATOR_IDS = [
+  'pm_signoff',
+  'system_spec',
+  'implementation_notes',
+  'acceptance_matrix',
+  'ship_verdict',
+  'release_notes',
+  'section_check',
+];
+
+const DEFAULT_TEMPLATE_BY_PHASE = {
+  planning: 'planning-default',
+  implementation: 'implementation-default',
+  qa: 'qa-default',
+};
+
+export { WORKFLOW_KIT_VERSION, SEMANTIC_VALIDATOR_IDS };
+
+function getGateLinkedPhases(config, gateId, gateDef) {
+  const linkedPhases = [];
+
+  if (typeof gateDef?.phase === 'string' && gateDef.phase.trim()) {
+    linkedPhases.push(gateDef.phase.trim());
+  }
+
+  for (const [phaseId, route] of Object.entries(config.routing || {})) {
+    if (route?.exit_gate === gateId && !linkedPhases.includes(phaseId)) {
+      linkedPhases.push(phaseId);
+    }
+  }
+
+  return linkedPhases;
+}
+
+function buildWorkflowKitContract(root, config) {
+  const phaseIds = Object.keys(config.routing || {});
+  const hasExplicitKit = config.workflow_kit?._explicit === true;
+
+  const templatesInUse = new Set();
+  const phases = {};
+
+  for (const phaseId of phaseIds) {
+    const phaseKit = config.workflow_kit?.phases?.[phaseId] || null;
+    // For default (non-explicit) workflow kits, infer template from phase name
+    const template = phaseKit?.template || (!hasExplicitKit ? (DEFAULT_TEMPLATE_BY_PHASE[phaseId] || null) : null);
+    if (template) templatesInUse.add(template);
+
+    const source = !hasExplicitKit
+      ? 'default'
+      : phaseKit
+        ? 'explicit'
+        : 'not_declared';
+
+    const artifacts = (phaseKit?.artifacts || [])
+      .filter((a) => a && typeof a.path === 'string')
+      .map((artifact) => ({
+        path: artifact.path,
+        required: artifact.required !== false,
+        semantics: artifact.semantics || null,
+        exists: existsSync(join(root, artifact.path)),
+      }));
+
+    phases[phaseId] = { template: template || null, source, artifacts };
+  }
+
+  const overallSource = !hasExplicitKit
+    ? 'default'
+    : phaseIds.every((id) => phases[id].source === 'explicit')
+      ? 'explicit'
+      : 'mixed';
+
+  const gateArtifactCoverage = {};
+  const gates = config.gates || {};
+  for (const [gateId, gateDef] of Object.entries(gates)) {
+    const linkedPhases = getGateLinkedPhases(config, gateId, gateDef);
+    const artifactPaths = [];
+    const seenPaths = new Set();
+
+    for (const linkedPhase of linkedPhases) {
+      for (const artifact of getEffectiveGateArtifacts(config, gateDef, linkedPhase)) {
+        if (!seenPaths.has(artifact.path)) {
+          seenPaths.add(artifact.path);
+          artifactPaths.push(artifact.path);
+        }
+      }
+    }
+
+    gateArtifactCoverage[gateId] = {
+      linked_phases: linkedPhases,
+      predicates_referencing_artifacts: artifactPaths.length,
+      artifacts_covered: artifactPaths,
+    };
+  }
+
+  return {
+    workflow_kit_version: WORKFLOW_KIT_VERSION,
+    source: overallSource,
+    phase_templates: {
+      available: [...VALID_WORKFLOW_KIT_PHASE_TEMPLATE_IDS],
+      in_use: [...templatesInUse],
+    },
+    phases,
+    semantic_validators: [...SEMANTIC_VALIDATOR_IDS],
+    gate_artifact_coverage: gateArtifactCoverage,
+  };
+}
+
+export { buildWorkflowKitContract };
+
+export function workflowKitDescribeCommand(opts) {
+  const context = loadProjectContext();
+  if (!context) {
+    console.log(chalk.red('  No agentxchain.json found. Run `agentxchain init` first.'));
+    process.exit(1);
+  }
+
+  const { root, config, version } = context;
+  if (version !== 4 || config.protocol_mode !== 'governed') {
+    console.log(chalk.red('  Not a governed AgentXchain project (requires v4 config).'));
+    process.exit(1);
+  }
+
+  const phaseIds = Object.keys(config.routing || {});
+  if (phaseIds.length === 0) {
+    console.log(chalk.red('  No governed phases are defined in routing.'));
+    process.exit(1);
+  }
+
+  const contract = buildWorkflowKitContract(root, config);
+
+  if (opts.json) {
+    console.log(JSON.stringify(contract, null, 2));
+    return;
+  }
+
+  console.log(chalk.bold(`\n  Workflow Kit v${contract.workflow_kit_version}\n`));
+  console.log(`  Source:     ${contract.source}`);
+  console.log(`  Templates:  ${contract.phase_templates.available.length} available, ${contract.phase_templates.in_use.length} in use`);
+  if (contract.phase_templates.in_use.length > 0) {
+    console.log(`              ${chalk.dim(contract.phase_templates.in_use.join(', '))}`);
+  }
+  console.log(`  Validators: ${contract.semantic_validators.join(', ')}`);
+  console.log('');
+
+  for (const [phaseId, phase] of Object.entries(contract.phases)) {
+    const templateLabel = phase.template ? ` (${phase.template})` : '';
+    console.log(chalk.bold(`  Phase: ${chalk.cyan(phaseId)}`) + chalk.dim(templateLabel));
+    console.log(`  Source: ${phase.source}`);
+
+    if (phase.artifacts.length === 0) {
+      console.log(`  ${chalk.dim('No artifacts declared')}`);
+    } else {
+      for (const artifact of phase.artifacts) {
+        const icon = artifact.exists
+          ? chalk.green('✓')
+          : artifact.required
+            ? chalk.red('✗')
+            : chalk.yellow('○');
+        const sem = artifact.semantics ? chalk.dim(` [${artifact.semantics}]`) : '';
+        const req = artifact.required ? '' : chalk.dim(' (optional)');
+        console.log(`    ${icon} ${artifact.path}${sem}${req}`);
+      }
+    }
+    console.log('');
+  }
+
+  const gateEntries = Object.entries(contract.gate_artifact_coverage);
+  if (gateEntries.length > 0) {
+    console.log(chalk.bold('  Gate artifact coverage:'));
+    for (const [gateId, cov] of gateEntries) {
+      console.log(`    ${gateId}: ${cov.predicates_referencing_artifacts} artifact(s) — ${cov.artifacts_covered.join(', ') || chalk.dim('none')}`);
+    }
+    console.log('');
+  }
+}

package/src/lib/connector-schema-contract.js

@@ -0,0 +1,57 @@
+import { buildRuntimeCapabilityReport } from './runtime-capabilities.js';
+
+export const CONFIG_SCHEMA_ARTIFACT = 'agentxchain/schemas/agentxchain-config';
+export const CAPABILITIES_OUTPUT_SCHEMA_ARTIFACT = 'agentxchain/schemas/connector-capabilities-output';
+
+export function buildConnectorSchemaContract(rawConfig, normalizedConfig, runtimeId, roleId) {
+  const continuity = {
+    raw_config_runtime_present: Boolean(rawConfig?.runtimes?.[runtimeId]),
+    raw_role_present: Boolean(rawConfig?.roles?.[roleId]),
+    raw_role_binding_matches_runtime: false,
+    capabilities_report_runtime_matches: false,
+    capabilities_report_role_binding_matches: false,
+  };
+  const failures = [];
+
+  const rawRole = rawConfig?.roles?.[roleId];
+  if (continuity.raw_role_present) {
+    continuity.raw_role_binding_matches_runtime = rawRole?.runtime === runtimeId;
+  }
+
+  const report = buildRuntimeCapabilityReport(
+    runtimeId,
+    normalizedConfig?.runtimes?.[runtimeId],
+    normalizedConfig?.roles || {}
+  );
+  continuity.capabilities_report_runtime_matches = report.runtime_id === runtimeId;
+  continuity.capabilities_report_role_binding_matches = report.role_bindings.some(
+    (binding) => binding.role_id === roleId
+  );
+
+  if (!continuity.raw_config_runtime_present) {
+    failures.push(`Raw config does not define runtime "${runtimeId}".`);
+  }
+  if (!continuity.raw_role_present) {
+    failures.push(`Raw config does not define role "${roleId}".`);
+  } else if (!continuity.raw_role_binding_matches_runtime) {
+    failures.push(
+      `Raw role binding mismatch: roles.${roleId}.runtime is "${rawRole.runtime}" instead of "${runtimeId}".`
+    );
+  }
+  if (!continuity.capabilities_report_runtime_matches) {
+    failures.push(`Capability report emitted runtime "${report.runtime_id}" instead of "${runtimeId}".`);
+  }
+  if (!continuity.capabilities_report_role_binding_matches) {
+    failures.push(`Capability report omitted the "${roleId}" binding under runtime "${runtimeId}".`);
+  }
+
+  return {
+    ok: failures.length === 0,
+    config_schema_artifact: CONFIG_SCHEMA_ARTIFACT,
+    capabilities_output_schema_artifact: CAPABILITIES_OUTPUT_SCHEMA_ARTIFACT,
+    runtime_id: runtimeId,
+    role_id: roleId,
+    continuity,
+    failures,
+  };
+}

package/src/lib/connector-validate.js

@@ -23,6 +23,7 @@ import { dispatchRemoteAgent } from './adapters/remote-agent-adapter.js';
 import { getDispatchPromptPath, getTurnStagingResultPath } from './turn-paths.js';
 import { validateStagedTurnResult } from './turn-result-validator.js';
 import { probeRuntimeSpawnContext } from './runtime-spawn-context.js';
+import { buildConnectorSchemaContract } from './connector-schema-contract.js';
 
 const VALIDATABLE_RUNTIME_TYPES = new Set(['local_cli', 'api_proxy', 'mcp', 'remote_agent']);
 const DEFAULT_VALIDATE_TIMEOUT_MS = 120_000;
@@ -106,12 +107,42 @@ export async function validateConfiguredConnector(sourceRoot, options = {}) {
   const tempBase = mkdtempSync(join(tmpdir(), 'axc-connector-validate-'));
   const scratchRoot = join(tempBase, 'workspace');
   const warnings = [...roleSelection.warnings];
+  const schemaContract = buildConnectorSchemaContract(
+    sourceContext.rawConfig,
+    sourceContext.config,
+    runtimeId,
+    roleSelection.roleId
+  );
+
+  // Surface capability declaration warnings for self-declared connectors
+  const { getCapabilityDeclarationWarnings } = await import('./runtime-capabilities.js');
+  const capWarnings = getCapabilityDeclarationWarnings(runtime);
+  warnings.push(...capWarnings);
+
   let keepArtifacts = options.keepArtifacts === true;
   let dispatch = null;
   let validation = null;
   let costUsd = null;
 
   try {
+    if (!schemaContract.ok) {
+      return {
+        ok: false,
+        exitCode: 1,
+        overall: 'fail',
+        runtime_id: runtimeId,
+        runtime_type: runtime.type,
+        role_id: roleSelection.roleId,
+        timeout_ms: timeoutMs,
+        warnings,
+        schema_contract: schemaContract,
+        dispatch: null,
+        validation: null,
+        error: 'Schema contract continuity failed before synthetic dispatch.',
+        scratch_root: null,
+      };
+    }
+
     copyRepoForValidation(sourceRoot, scratchRoot);
     initializeScratchGit(scratchRoot);
 
@@ -126,6 +157,7 @@ export async function validateConfiguredConnector(sourceRoot, options = {}) {
         role_id: roleSelection.roleId,
         timeout_ms: timeoutMs,
         warnings,
+        schema_contract: schemaContract,
         error: 'Failed to load governed config inside scratch workspace.',
         scratch_root: scratchRoot,
       };
@@ -143,6 +175,7 @@ export async function validateConfiguredConnector(sourceRoot, options = {}) {
           role_id: roleSelection.roleId,
           timeout_ms: timeoutMs,
           warnings,
+          schema_contract: schemaContract,
           dispatch: null,
           validation: null,
           error: spawnProbe.detail,
@@ -168,6 +201,7 @@ export async function validateConfiguredConnector(sourceRoot, options = {}) {
         role_id: roleSelection.roleId,
         timeout_ms: timeoutMs,
         warnings,
+        schema_contract: schemaContract,
         error: initResult.error,
         scratch_root: scratchRoot,
       };
@@ -184,6 +218,7 @@ export async function validateConfiguredConnector(sourceRoot, options = {}) {
         role_id: roleSelection.roleId,
         timeout_ms: timeoutMs,
         warnings,
+        schema_contract: schemaContract,
         error: assignResult.error,
         scratch_root: scratchRoot,
       };
@@ -201,6 +236,7 @@ export async function validateConfiguredConnector(sourceRoot, options = {}) {
         role_id: roleSelection.roleId,
         timeout_ms: timeoutMs,
         warnings,
+        schema_contract: schemaContract,
         error: 'Synthetic validation turn was not assigned.',
         scratch_root: scratchRoot,
       };
@@ -217,6 +253,7 @@ export async function validateConfiguredConnector(sourceRoot, options = {}) {
         role_id: roleSelection.roleId,
         timeout_ms: timeoutMs,
         warnings,
+        schema_contract: schemaContract,
         error: bundleResult.error,
         scratch_root: scratchRoot,
       };
@@ -260,6 +297,7 @@ export async function validateConfiguredConnector(sourceRoot, options = {}) {
         role_id: roleSelection.roleId,
         timeout_ms: timeoutMs,
         warnings,
+        schema_contract: schemaContract,
         dispatch,
         validation: null,
         scratch_root: scratchRoot,
@@ -282,6 +320,7 @@ export async function validateConfiguredConnector(sourceRoot, options = {}) {
         role_id: roleSelection.roleId,
         timeout_ms: timeoutMs,
         warnings,
+        schema_contract: schemaContract,
         dispatch,
         validation: {
           ok: false,
@@ -304,6 +343,7 @@ export async function validateConfiguredConnector(sourceRoot, options = {}) {
       role_id: roleSelection.roleId,
       timeout_ms: timeoutMs,
       warnings,
+      schema_contract: schemaContract,
       dispatch,
       validation: {
         ok: true,
@@ -326,6 +366,7 @@ export async function validateConfiguredConnector(sourceRoot, options = {}) {
       role_id: roleSelection.roleId,
       timeout_ms: timeoutMs,
       warnings,
+      schema_contract: schemaContract,
       dispatch,
       validation,
       error: error.message,