agentxchain 2.136.0 → 2.137.0

package/bin/agentxchain.js

@@ -66,6 +66,7 @@ import { kickoffCommand } from '../src/commands/kickoff.js';
 import { rebindCommand } from '../src/commands/rebind.js';
 import { branchCommand } from '../src/commands/branch.js';
 import { migrateCommand } from '../src/commands/migrate.js';
+import { migrateIntentsCommand } from '../src/commands/migrate-intents.js';
 import { resumeCommand } from '../src/commands/resume.js';
 import { unblockCommand } from '../src/commands/unblock.js';
 import { injectCommand } from '../src/commands/inject.js';
@@ -127,6 +128,7 @@ import { connectorCapabilitiesCommand, connectorCheckCommand, connectorValidateC
 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'));
@@ -644,6 +646,13 @@ program
   .option('-j, --json', 'Output migration report as JSON')
   .action(migrateCommand);
 
+program
+  .command('migrate-intents')
+  .description('Archive legacy intents with no run scope (pre-BUG-34 repair)')
+  .option('-j, --json', 'Output as JSON')
+  .option('--dry-run', 'List legacy intents without modifying them')
+  .action(migrateIntentsCommand);
+
 program
   .command('resume')
   .description('Resume a governed project: initialize or continue a run and assign the next turn')
@@ -846,6 +855,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.136.0",
+  "version": "2.137.0",
   "description": "CLI for AgentXchain — governed multi-agent software delivery",
   "type": "module",
   "bin": {

package/src/commands/connector.js

@@ -3,7 +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 { getRuntimeCapabilityContract, getRoleRuntimeCapabilityContract, getCapabilityDeclarationWarnings } from '../lib/runtime-capabilities.js';
+import { buildRuntimeCapabilityReport } from '../lib/runtime-capabilities.js';
 
 function printJson(result, exitCode) {
   console.log(JSON.stringify(result, null, 2));
@@ -165,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')}`);
@@ -193,37 +201,6 @@ function printValidateText(result, exitCode) {
   process.exit(exitCode);
 }
 
-function buildCapabilityReport(runtimeId, runtime, roles) {
-  const mergedContract = getRuntimeCapabilityContract(runtime);
-  const declaredCapabilities = (runtime.capabilities && typeof runtime.capabilities === 'object' && !Array.isArray(runtime.capabilities))
-    ? { ...runtime.capabilities }
-    : {};
-  const declarationWarnings = getCapabilityDeclarationWarnings(runtime);
-
-  const roleBindings = [];
-  for (const [roleId, role] of Object.entries(roles)) {
-    const boundRuntime = role.runtime_id || role.runtime;
-    if (boundRuntime !== runtimeId) continue;
-    const roleContract = getRoleRuntimeCapabilityContract(roleId, role, runtime);
-    roleBindings.push({
-      role_id: roleContract.role_id,
-      role_write_authority: roleContract.role_write_authority,
-      effective_write_path: roleContract.effective_write_path,
-      workflow_artifact_ownership: roleContract.workflow_artifact_ownership,
-      notes: roleContract.notes,
-    });
-  }
-
-  return {
-    runtime_id: runtimeId,
-    runtime_type: runtime.type || 'unknown',
-    declared_capabilities: declaredCapabilities,
-    merged_contract: mergedContract,
-    declaration_warnings: declarationWarnings,
-    role_bindings: roleBindings,
-  };
-}
-
 function printCapabilitiesText(report) {
   console.log('');
   console.log(chalk.bold(`  ${report.runtime_id}`) + chalk.dim(` (${report.runtime_type})`));
@@ -280,7 +257,7 @@ export async function connectorCapabilitiesCommand(runtimeId, options = {}) {
   if (options.all) {
     const reports = [];
     for (const [id, runtime] of Object.entries(runtimes)) {
-      reports.push(buildCapabilityReport(id, runtime, roles));
+      reports.push(buildRuntimeCapabilityReport(id, runtime, roles));
     }
     const payload = { runtimes: reports };
     if (options.json) { printJson(payload, 0); return; }
@@ -317,7 +294,7 @@ export async function connectorCapabilitiesCommand(runtimeId, options = {}) {
     process.exit(2);
   }
 
-  const report = buildCapabilityReport(runtimeId, runtimes[runtimeId], roles);
+  const report = buildRuntimeCapabilityReport(runtimeId, runtimes[runtimeId], roles);
   if (options.json) { printJson(report, 0); return; }
 
   console.log('');

package/src/commands/migrate-intents.js

@@ -0,0 +1,121 @@
+/**
+ * One-shot repair command for legacy intents stuck with approved_run_id: null.
+ *
+ * Belt-and-suspenders insurance for BUG-41: the automatic startup migration
+ * is now idempotent, but operators who already have stuck repos need a direct
+ * lever that works without starting a governed run.
+ */
+
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import chalk from 'chalk';
+
+import { findProjectRoot } from '../lib/config.js';
+import { migratePreBug34Intents } from '../lib/intent-startup-migration.js';
+
+function loadRunId(root) {
+  const statePath = join(root, '.agentxchain', 'state.json');
+  if (!existsSync(statePath)) return 'manual-migration';
+  try {
+    const state = JSON.parse(readFileSync(statePath, 'utf8'));
+    return state.run_id || 'manual-migration';
+  } catch {
+    return 'manual-migration';
+  }
+}
+
+function listLegacyIntents(root) {
+  const intentsDir = join(root, '.agentxchain', 'intake', 'intents');
+  if (!existsSync(intentsDir)) return [];
+
+  const DISPATCHABLE = new Set(['planned', 'approved']);
+  const results = [];
+
+  for (const file of readdirSync(intentsDir)) {
+    if (!file.endsWith('.json') || file.startsWith('.tmp-')) continue;
+    const intentPath = join(intentsDir, file);
+    let intent;
+    try {
+      intent = JSON.parse(readFileSync(intentPath, 'utf8'));
+    } catch {
+      continue;
+    }
+    if (!intent || !DISPATCHABLE.has(intent.status)) continue;
+    if (intent.cross_run_durable === true) continue;
+    if (intent.approved_run_id) continue;
+    results.push({ file, intent_id: intent.intent_id || file.replace('.json', ''), status: intent.status });
+  }
+  return results;
+}
+
+export function migrateIntentsCommand(opts) {
+  const root = findProjectRoot();
+  if (!root) {
+    if (opts.json) {
+      console.log(JSON.stringify({ error: 'No agentxchain.json found. Run from inside a governed project.' }));
+    } else {
+      console.error(chalk.red('  No agentxchain.json found. Run this from inside a governed project.'));
+    }
+    process.exit(1);
+  }
+
+  const legacyIntents = listLegacyIntents(root);
+
+  if (opts.dryRun) {
+    if (opts.json) {
+      console.log(JSON.stringify({
+        archived_count: legacyIntents.length,
+        archived_intent_ids: legacyIntents.map(i => i.intent_id),
+        dry_run: true,
+        message: legacyIntents.length > 0
+          ? `Would archive ${legacyIntents.length} pre-BUG-34 intent(s)`
+          : 'No legacy intents found',
+      }, null, 2));
+    } else {
+      if (legacyIntents.length === 0) {
+        console.log(chalk.green('  No legacy intents found. Nothing to migrate.'));
+      } else {
+        console.log(chalk.yellow(`  Would archive ${legacyIntents.length} legacy intent(s):`));
+        for (const item of legacyIntents) {
+          console.log(`    ${chalk.dim('•')} ${item.intent_id} (${item.status})`);
+        }
+      }
+    }
+    return;
+  }
+
+  if (legacyIntents.length === 0) {
+    if (opts.json) {
+      console.log(JSON.stringify({
+        archived_count: 0,
+        archived_intent_ids: [],
+        dry_run: false,
+        message: 'No legacy intents found',
+      }, null, 2));
+    } else {
+      console.log(chalk.green('  No legacy intents found. Nothing to migrate.'));
+    }
+    return;
+  }
+
+  const runId = loadRunId(root);
+  const result = migratePreBug34Intents(root, runId);
+
+  if (opts.json) {
+    console.log(JSON.stringify({
+      archived_count: result.archived_migration_count,
+      archived_intent_ids: result.archived_migration_intent_ids,
+      dry_run: false,
+      message: result.migration_notice || `Archived ${result.archived_migration_count} pre-BUG-34 intent(s)`,
+    }, null, 2));
+  } else {
+    if (result.archived_migration_count === 0) {
+      console.log(chalk.green('  No legacy intents found. Nothing to migrate.'));
+    } else {
+      console.log(chalk.green(`  ✓ ${result.migration_notice}`));
+      for (const id of result.archived_migration_intent_ids) {
+        console.log(`    ${chalk.dim('•')} ${id}`);
+      }
+    }
+  }
+}

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,6 +107,12 @@ 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');
@@ -118,6 +125,24 @@ export async function validateConfiguredConnector(sourceRoot, options = {}) {
   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);
 
@@ -132,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,
       };
@@ -149,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,
@@ -174,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,
       };
@@ -190,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,
       };
@@ -207,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,
       };
@@ -223,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,
       };
@@ -266,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,
@@ -288,6 +320,7 @@ export async function validateConfiguredConnector(sourceRoot, options = {}) {
         role_id: roleSelection.roleId,
         timeout_ms: timeoutMs,
         warnings,
+        schema_contract: schemaContract,
         dispatch,
         validation: {
           ok: false,
@@ -310,6 +343,7 @@ export async function validateConfiguredConnector(sourceRoot, options = {}) {
       role_id: roleSelection.roleId,
       timeout_ms: timeoutMs,
       warnings,
+      schema_contract: schemaContract,
       dispatch,
       validation: {
         ok: true,
@@ -332,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,

package/src/lib/continuous-run.js

@@ -154,7 +154,7 @@ function reconcileContinuousStartupState(context, session, contOpts, log) {
     sessionChanged = true;
   }
 
-  if (scopedRunId && session.startup_reconciled_run_id !== scopedRunId) {
+  if (scopedRunId) {
     const startupIntents = archiveStaleIntentsForRun(root, scopedRunId, {
       protocolVersion: governedState?.protocol_version || config?.schema_version || '2.x',
     });
@@ -172,8 +172,10 @@ function reconcileContinuousStartupState(context, session, contOpts, log) {
       const migrationNotice = formatLegacyIntentMigrationNotice(startupIntents.archived_migration_intent_ids);
       if (migrationNotice) log(migrationNotice);
     }
-    session.startup_reconciled_run_id = scopedRunId;
-    sessionChanged = true;
+    if (session.startup_reconciled_run_id !== scopedRunId) {
+      session.startup_reconciled_run_id = scopedRunId;
+      sessionChanged = true;
+    }
   }
 
   if (sessionChanged) {

package/src/lib/runtime-capabilities.js

@@ -240,3 +240,34 @@ export function summarizeRoleRuntimeCapability(contract) {
     `owned_by=${contract.workflow_artifact_ownership}`,
   ].join('; ');
 }
+
+export function buildRuntimeCapabilityReport(runtimeId, runtime, roles) {
+  const mergedContract = getRuntimeCapabilityContract(runtime);
+  const declaredCapabilities = (runtime?.capabilities && typeof runtime.capabilities === 'object' && !Array.isArray(runtime.capabilities))
+    ? { ...runtime.capabilities }
+    : {};
+  const declarationWarnings = getCapabilityDeclarationWarnings(runtime);
+
+  const roleBindings = [];
+  for (const [roleId, role] of Object.entries(roles || {})) {
+    const boundRuntime = role.runtime_id || role.runtime;
+    if (boundRuntime !== runtimeId) continue;
+    const roleContract = getRoleRuntimeCapabilityContract(roleId, role, runtime);
+    roleBindings.push({
+      role_id: roleContract.role_id,
+      role_write_authority: roleContract.role_write_authority,
+      effective_write_path: roleContract.effective_write_path,
+      workflow_artifact_ownership: roleContract.workflow_artifact_ownership,
+      notes: roleContract.notes,
+    });
+  }
+
+  return {
+    runtime_id: runtimeId,
+    runtime_type: runtime?.type || 'unknown',
+    declared_capabilities: declaredCapabilities,
+    merged_contract: mergedContract,
+    declaration_warnings: declarationWarnings,
+    role_bindings: roleBindings,
+  };
+}