agentxchain 2.25.1 → 2.26.0

package/README.md

@@ -88,6 +88,7 @@ Built-in governed templates:
 - `cli-tool`: command surface, platform support, distribution checklist
 - `library`: public API, compatibility policy, release and adoption checklist
 - `web-app`: user flows, UI acceptance, browser support
+- `enterprise-app`: enterprise planning artifacts plus blueprint-backed `architect` and `security_reviewer` phases
 
 `step` writes a turn-scoped bundle under `.agentxchain/dispatch/turns/<turn_id>/` and expects a staged result at `.agentxchain/staging/<turn_id>/turn-result.json`. Typical continuation:
 

package/bin/agentxchain.js

@@ -120,7 +120,7 @@ program
   .option('-y, --yes', 'Skip prompts, use defaults')
   .option('--governed', 'Create a governed project (orchestrator-owned state)')
   .option('--dir <path>', 'Scaffold target directory. Use "." for in-place bootstrap.')
-  .option('--template <id>', 'Governed scaffold template: generic, api-service, cli-tool, library, web-app')
+  .option('--template <id>', 'Governed scaffold template: generic, api-service, cli-tool, library, web-app, enterprise-app')
   .option('--dev-command <parts...>', 'Governed local-dev command parts. Include {prompt} for argv prompt delivery.')
   .option('--dev-prompt-transport <mode>', 'Governed local-dev prompt transport: argv, stdin, dispatch_bundle_only')
   .option('--schema-version <version>', 'Schema version (3 for legacy, or use --governed for current)')
@@ -469,7 +469,7 @@ intakeCmd
   .description('Triage a detected intent — set priority, template, charter, and acceptance')
   .option('--intent <id>', 'Intent ID to triage')
   .option('--priority <level>', 'Priority level (p0, p1, p2, p3)')
-  .option('--template <id>', 'Governed template (generic, api-service, cli-tool, library, web-app)')
+  .option('--template <id>', 'Governed template (generic, api-service, cli-tool, library, web-app, enterprise-app)')
   .option('--charter <text>', 'Delivery charter text')
   .option('--acceptance <text>', 'Comma-separated acceptance criteria')
   .option('--suppress', 'Suppress the intent instead of triaging')

package/package.json

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

package/src/commands/init.js

@@ -142,7 +142,7 @@ const GOVERNED_GATES = {
   }
 };
 
-function buildGovernedPrompt(roleId, role) {
+function buildGovernedPrompt(roleId, role, scaffoldContext = {}) {
   const rolePrompts = {
     pm: buildPmPrompt,
     dev: buildDevPrompt,
@@ -154,7 +154,7 @@ function buildGovernedPrompt(roleId, role) {
   if (builder) return builder(role);
 
   // Fallback for custom roles
-  return buildGenericPrompt(roleId, role);
+  return buildGenericPrompt(roleId, role, scaffoldContext);
 }
 
 function buildPmPrompt(role) {
@@ -351,7 +351,66 @@ If you cannot resolve the deadlock:
 `;
 }
 
-function buildGenericPrompt(roleId, role) {
+function summarizeRoleWorkflow(roleId, scaffoldContext = {}) {
+  const routing = scaffoldContext.routing || {};
+  const gates = scaffoldContext.gates || {};
+  const workflowKitConfig = scaffoldContext.workflowKitConfig || {};
+  const ownedPhases = Object.entries(routing)
+    .filter(([, route]) => route?.entry_role === roleId)
+    .map(([phaseName]) => phaseName);
+  const gateLines = [];
+  const artifactLines = [];
+  const ownershipLines = [];
+
+  for (const phaseName of ownedPhases) {
+    const exitGate = routing[phaseName]?.exit_gate;
+    if (exitGate) {
+      gateLines.push(`- ${phaseName}: ${exitGate}`);
+    }
+
+    const phaseArtifacts = Array.isArray(workflowKitConfig?.phases?.[phaseName]?.artifacts)
+      ? workflowKitConfig.phases[phaseName].artifacts.filter((artifact) => artifact?.path)
+      : [];
+    const workflowArtifacts = phaseArtifacts
+      .map((artifact) => artifact.path)
+      .filter(Boolean);
+    const gateArtifacts = Array.isArray(gates?.[exitGate]?.requires_files)
+      ? gates[exitGate].requires_files.filter(Boolean)
+      : [];
+    const ownedArtifacts = [...new Set([...workflowArtifacts, ...gateArtifacts])];
+    if (ownedArtifacts.length > 0) {
+      artifactLines.push(`- ${phaseName}: ${ownedArtifacts.join(', ')}`);
+    }
+
+    const enforcedArtifacts = phaseArtifacts
+      .filter((artifact) => artifact.owned_by === roleId)
+      .map((artifact) => artifact.path);
+    if (enforcedArtifacts.length > 0) {
+      const verb = enforcedArtifacts.length === 1 ? 'requires' : 'require';
+      ownershipLines.push(
+        `- ${phaseName}: ${enforcedArtifacts.join(', ')} ${verb} an accepted turn from you before the gate can pass`,
+      );
+    }
+  }
+
+  return { ownedPhases, gateLines, artifactLines, ownershipLines };
+}
+
+function buildGenericPrompt(roleId, role, scaffoldContext = {}) {
+  const workflowSummary = summarizeRoleWorkflow(roleId, scaffoldContext);
+  const primaryPhasesSection = workflowSummary.ownedPhases.length > 0
+    ? `\n## Primary Phases\n\n- ${workflowSummary.ownedPhases.join(', ')}\n`
+    : '';
+  const phaseGatesSection = workflowSummary.gateLines.length > 0
+    ? `\n## Phase Gates\n\n${workflowSummary.gateLines.join('\n')}\n`
+    : '';
+  const workflowArtifactsSection = workflowSummary.artifactLines.length > 0
+    ? `\n## Workflow Artifacts You Own\n\n${workflowSummary.artifactLines.join('\n')}\n`
+    : '';
+  const ownershipSection = workflowSummary.ownershipLines.length > 0
+    ? `\n## Ownership Enforcement\n\n${workflowSummary.ownershipLines.join('\n')}\n`
+    : '';
+
   return `# ${role.title} — Role Prompt
 
 You are the **${role.title}** on this project.
@@ -371,7 +430,7 @@ ${role.write_authority === 'authoritative'
     ? 'You may modify product files directly.'
     : role.write_authority === 'proposed'
       ? 'You may propose changes via patches.'
-      : 'You may NOT modify product files. Only create review artifacts under `.planning/` and `.agentxchain/reviews/`.'}
+      : 'You may NOT modify product files. Only create review artifacts under `.planning/` and `.agentxchain/reviews/`.'}${primaryPhasesSection}${phaseGatesSection}${workflowArtifactsSection}${ownershipSection}
 `;
 }
 
@@ -454,13 +513,118 @@ function formatInitTarget(dir) {
   return dir;
 }
 
-export function scaffoldGoverned(dir, projectName, projectId, templateId = 'generic', runtimeOptions = {}) {
+function generateWorkflowKitPlaceholder(artifact, projectName) {
+  const filename = basename(artifact.path);
+  const title = filename.replace(/\.[^.]+$/, '').replace(/[-_]/g, ' ');
+
+  if (artifact.semantics === 'section_check' && artifact.semantics_config?.required_sections?.length) {
+    const sections = artifact.semantics_config.required_sections
+      .map(s => `${s}\n\n(Content here.)\n`)
+      .join('\n');
+    return `# ${title} — ${projectName}\n\n${sections}`;
+  }
+
+  return `# ${title} — ${projectName}\n\n(Operator fills this in.)\n`;
+}
+
+function cloneJsonCompatible(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}
+
+function buildScaffoldConfigFromTemplate(template, localDevRuntime, workflowKitConfig) {
+  const blueprint = template.scaffold_blueprint || null;
+  const roles = cloneJsonCompatible(blueprint?.roles || GOVERNED_ROLES);
+  const runtimes = cloneJsonCompatible(blueprint?.runtimes || GOVERNED_RUNTIMES);
+
+  if (!blueprint || Object.values(roles).some((role) => role?.runtime === 'local-dev')) {
+    runtimes['local-dev'] = localDevRuntime;
+  }
+
+  const routing = cloneJsonCompatible(blueprint?.routing || GOVERNED_ROUTING);
+  const gates = cloneJsonCompatible(blueprint?.gates || GOVERNED_GATES);
+  const effectiveWorkflowKitConfig = workflowKitConfig || cloneJsonCompatible(blueprint?.workflow_kit || null);
+  const prompts = Object.fromEntries(
+    Object.keys(roles).map((roleId) => [roleId, `.agentxchain/prompts/${roleId}.md`])
+  );
+
+  return {
+    roles,
+    runtimes,
+    routing,
+    gates,
+    prompts,
+    workflowKitConfig: effectiveWorkflowKitConfig,
+  };
+}
+
+function buildRoadmapPhaseTable(routing, roles) {
+  const rows = Object.entries(routing).map(([phaseKey, phaseConfig]) => {
+    const phaseName = phaseKey.replace(/_/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+    const entryRole = phaseConfig.entry_role;
+    const role = roles[entryRole];
+    const goal = role?.mandate || phaseName;
+    const status = phaseKey === Object.keys(routing)[0] ? 'In progress' : 'Pending';
+    return `| ${phaseName} | ${goal} | ${status} |`;
+  });
+  return `| Phase | Goal | Status |\n|-------|------|--------|\n${rows.join('\n')}\n`;
+}
+
+function buildPlanningSummaryLines(template, workflowKitConfig) {
+  const lines = [
+    'PM_SIGNOFF.md / ROADMAP.md / SYSTEM_SPEC.md',
+    'acceptance-matrix.md / ship-verdict.md',
+    'RELEASE_NOTES.md',
+  ];
+  const templatePlanningFiles = Array.isArray(template?.planning_artifacts)
+    ? template.planning_artifacts
+      .map((artifact) => artifact?.filename)
+      .filter(Boolean)
+    : [];
+  const defaultScaffoldPaths = new Set([
+    '.planning/PM_SIGNOFF.md',
+    '.planning/ROADMAP.md',
+    '.planning/SYSTEM_SPEC.md',
+    '.planning/IMPLEMENTATION_NOTES.md',
+    '.planning/acceptance-matrix.md',
+    '.planning/ship-verdict.md',
+    '.planning/RELEASE_NOTES.md',
+  ]);
+  const customWorkflowFiles = [];
+
+  if (workflowKitConfig?.phases && typeof workflowKitConfig.phases === 'object') {
+    for (const phaseConfig of Object.values(workflowKitConfig.phases)) {
+      if (!Array.isArray(phaseConfig?.artifacts)) continue;
+      for (const artifact of phaseConfig.artifacts) {
+        if (!artifact?.path || defaultScaffoldPaths.has(artifact.path)) continue;
+        customWorkflowFiles.push(basename(artifact.path));
+      }
+    }
+  }
+
+  if (templatePlanningFiles.length > 0) {
+    lines.push(`template: ${templatePlanningFiles.join(' / ')}`);
+  }
+  const uniqueCustomWorkflowFiles = [...new Set(customWorkflowFiles)];
+  if (uniqueCustomWorkflowFiles.length > 0) {
+    lines.push(`workflow: ${uniqueCustomWorkflowFiles.join(' / ')}`);
+  }
+
+  return lines;
+}
+
+export function scaffoldGoverned(dir, projectName, projectId, templateId = 'generic', runtimeOptions = {}, workflowKitConfig = null) {
   const template = loadGovernedTemplate(templateId);
   const { runtime: localDevRuntime } = resolveGovernedLocalDevRuntime(runtimeOptions);
-  const runtimes = {
-    ...GOVERNED_RUNTIMES,
-    'local-dev': localDevRuntime,
-  };
+  const scaffoldConfig = buildScaffoldConfigFromTemplate(template, localDevRuntime, workflowKitConfig);
+  const { roles, runtimes, routing, gates, prompts, workflowKitConfig: effectiveWorkflowKitConfig } = scaffoldConfig;
+  const initialPhase = Object.keys(routing)[0] || 'planning';
+  const phaseGateStatus = Object.fromEntries(
+    [...new Set(
+      Object.values(routing)
+        .map((route) => route?.exit_gate)
+        .filter(Boolean)
+    )].map((gateId) => [gateId, 'pending'])
+  );
   const config = {
     schema_version: '1.0',
     template: template.id,
@@ -469,10 +633,10 @@ export function scaffoldGoverned(dir, projectName, projectId, templateId = 'gene
       name: projectName,
       default_branch: 'main'
     },
-    roles: GOVERNED_ROLES,
+    roles,
     runtimes,
-    routing: GOVERNED_ROUTING,
-    gates: GOVERNED_GATES,
+    routing,
+    gates,
     budget: {
       per_turn_max_usd: 2.0,
       per_run_max_usd: 50.0,
@@ -482,25 +646,23 @@ export function scaffoldGoverned(dir, projectName, projectId, templateId = 'gene
       talk_strategy: 'append_only',
       history_strategy: 'jsonl_append_only'
     },
-    prompts: {
-      pm: '.agentxchain/prompts/pm.md',
-      dev: '.agentxchain/prompts/dev.md',
-      qa: '.agentxchain/prompts/qa.md',
-      eng_director: '.agentxchain/prompts/eng_director.md'
-    },
+    prompts,
     rules: {
       challenge_required: true,
       max_turn_retries: 2,
       max_deadlock_cycles: 2
     }
   };
+  if (effectiveWorkflowKitConfig) {
+    config.workflow_kit = effectiveWorkflowKitConfig;
+  }
 
   const state = {
     schema_version: '1.1',
     run_id: null,
     project_id: projectId,
     status: 'idle',
-    phase: 'planning',
+    phase: initialPhase,
     accepted_integration_ref: null,
     active_turns: {},
     turn_sequence: 0,
@@ -510,11 +672,7 @@ export function scaffoldGoverned(dir, projectName, projectId, templateId = 'gene
     escalation: null,
     queued_phase_transition: null,
     queued_run_completion: null,
-    phase_gate_status: {
-      planning_signoff: 'pending',
-      implementation_complete: 'pending',
-      qa_ship_verdict: 'pending'
-    },
+    phase_gate_status: phaseGateStatus,
     budget_reservations: {},
     budget_status: {
       spent_usd: 0,
@@ -536,15 +694,19 @@ export function scaffoldGoverned(dir, projectName, projectId, templateId = 'gene
   writeFileSync(join(dir, '.agentxchain', 'decision-ledger.jsonl'), '');
 
   // Prompt templates
-  for (const [roleId, role] of Object.entries(GOVERNED_ROLES)) {
-    const basePrompt = buildGovernedPrompt(roleId, role);
+  for (const [roleId, role] of Object.entries(roles)) {
+    const basePrompt = buildGovernedPrompt(roleId, role, {
+      routing,
+      gates,
+      workflowKitConfig: effectiveWorkflowKitConfig,
+    });
     const prompt = appendPromptOverride(basePrompt, template.prompt_overrides?.[roleId]);
     writeFileSync(join(dir, '.agentxchain', 'prompts', `${roleId}.md`), prompt);
   }
 
   // Planning artifacts
   writeFileSync(join(dir, '.planning', 'PM_SIGNOFF.md'), `# PM Signoff — ${projectName}\n\nApproved: NO\n\n> This scaffold starts blocked on purpose. Change this to \`Approved: YES\` only after a human reviews the planning artifacts and is ready to open the planning gate.\n\n## Discovery Checklist\n- [ ] Target user defined\n- [ ] Core pain point defined\n- [ ] Core workflow defined\n- [ ] MVP scope defined\n- [ ] Out-of-scope list defined\n- [ ] Success metric defined\n\n## Notes for team\n(PM and human add final kickoff notes here.)\n`);
-  writeFileSync(join(dir, '.planning', 'ROADMAP.md'), `# Roadmap — ${projectName}\n\n## Phases\n\n| Phase | Goal | Status |\n|-------|------|--------|\n| Planning | Align scope, requirements, acceptance criteria | In progress |\n| Implementation | Build and verify | Pending |\n| QA | Challenge correctness and ship readiness | Pending |\n`);
+  writeFileSync(join(dir, '.planning', 'ROADMAP.md'), `# Roadmap — ${projectName}\n\n## Phases\n\n${buildRoadmapPhaseTable(routing, roles)}`);
   writeFileSync(join(dir, '.planning', 'SYSTEM_SPEC.md'), buildSystemSpecContent(projectName, template.system_spec_overlay));
   writeFileSync(join(dir, '.planning', 'IMPLEMENTATION_NOTES.md'), `# Implementation Notes — ${projectName}\n\n## Changes\n\n(Dev fills this during implementation)\n\n## Verification\n\n(Dev fills this during implementation)\n\n## Unresolved Follow-ups\n\n(Dev lists any known gaps, tech debt, or follow-up items here.)\n`);
   const baseAcceptanceMatrix = `# Acceptance Matrix — ${projectName}\n\n| Req # | Requirement | Acceptance criteria | Test status | Last tested | Status |\n|-------|-------------|-------------------|-------------|-------------|--------|\n| (QA fills this from ROADMAP.md) | | | | | |\n`;
@@ -561,6 +723,37 @@ export function scaffoldGoverned(dir, projectName, projectId, templateId = 'gene
     );
   }
 
+  // Workflow-kit custom artifacts — only scaffold files from explicit workflow_kit config
+  // that are not already handled by the default scaffold above
+  if (effectiveWorkflowKitConfig && effectiveWorkflowKitConfig.phases && typeof effectiveWorkflowKitConfig.phases === 'object') {
+    const defaultScaffoldPaths = new Set([
+      '.planning/PM_SIGNOFF.md',
+      '.planning/ROADMAP.md',
+      '.planning/SYSTEM_SPEC.md',
+      '.planning/IMPLEMENTATION_NOTES.md',
+      '.planning/acceptance-matrix.md',
+      '.planning/ship-verdict.md',
+      '.planning/RELEASE_NOTES.md',
+    ]);
+
+    for (const phaseConfig of Object.values(effectiveWorkflowKitConfig.phases)) {
+      if (!Array.isArray(phaseConfig.artifacts)) continue;
+      for (const artifact of phaseConfig.artifacts) {
+        if (!artifact.path || defaultScaffoldPaths.has(artifact.path)) continue;
+        const absPath = join(dir, artifact.path);
+        if (existsSync(absPath)) continue;
+
+        // Ensure parent directory exists
+        const parentDir = dirname(absPath);
+        if (!existsSync(parentDir)) mkdirSync(parentDir, { recursive: true });
+
+        // Generate placeholder content based on semantics type
+        const content = generateWorkflowKitPlaceholder(artifact, projectName);
+        writeFileSync(absPath, content);
+      }
+    }
+  }
+
   // TALK.md
   writeFileSync(join(dir, 'TALK.md'), `# ${projectName} — Team Talk File\n\nCanonical human-readable handoff log for all agents.\n\n---\n\n`);
 
@@ -584,6 +777,7 @@ export function scaffoldGoverned(dir, projectName, projectId, templateId = 'gene
 async function initGoverned(opts) {
   let projectName, folderName;
   const templateId = opts.template || 'generic';
+  let selectedTemplate;
   let explicitDir;
 
   try {
@@ -604,6 +798,7 @@ async function initGoverned(opts) {
     console.error('    web-app       Governed scaffold for a web application');
     process.exit(1);
   }
+  selectedTemplate = loadGovernedTemplate(templateId);
 
   if (opts.yes) {
     projectName = explicitDir
@@ -662,47 +857,68 @@ async function initGoverned(opts) {
 
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 
-  scaffoldGoverned(dir, projectName, projectId, templateId, opts);
+  // If reinitializing a project that has explicit workflow_kit config, preserve it for scaffold
+  let workflowKitConfig = null;
+  const existingConfigPath = join(dir, CONFIG_FILE);
+  if (existsSync(existingConfigPath)) {
+    try {
+      const existing = JSON.parse(readFileSync(existingConfigPath, 'utf8'));
+      if (existing.workflow_kit && typeof existing.workflow_kit === 'object' && Object.keys(existing.workflow_kit).length > 0) {
+        workflowKitConfig = existing.workflow_kit;
+      }
+    } catch {
+      // Ignore parse errors — scaffold will overwrite the config anyway
+    }
+  }
+
+  const { config } = scaffoldGoverned(dir, projectName, projectId, templateId, opts, workflowKitConfig);
 
   console.log('');
   console.log(chalk.green(`  ✓ Created governed project ${chalk.bold(targetLabel)}/`));
   console.log('');
+  const promptRoleIds = Object.keys(config.roles);
+  const phaseNames = Object.keys(config.routing);
   console.log(`    ${chalk.dim('├──')} agentxchain.json  ${chalk.dim('(governed)')}`);
   console.log(`    ${chalk.dim('├──')} .agentxchain/`);
   console.log(`    ${chalk.dim('│')}    ${chalk.dim('├──')} state.json / history.jsonl / decision-ledger.jsonl`);
   console.log(`    ${chalk.dim('│')}    ${chalk.dim('├──')} staging/`);
-  console.log(`    ${chalk.dim('│')}    ${chalk.dim('├──')} prompts/  ${chalk.dim('(pm, dev, qa, eng_director)')}`);
+  console.log(`    ${chalk.dim('│')}    ${chalk.dim('├──')} prompts/  ${chalk.dim(`(${promptRoleIds.join(', ')})`)}`);
   console.log(`    ${chalk.dim('│')}    ${chalk.dim('├──')} reviews/`);
   console.log(`    ${chalk.dim('│')}    ${chalk.dim('└──')} dispatch/`);
   console.log(`    ${chalk.dim('├──')} .planning/`);
-  console.log(`    ${chalk.dim('│')}    ${chalk.dim('├──')} PM_SIGNOFF.md / ROADMAP.md / SYSTEM_SPEC.md`);
-  console.log(`    ${chalk.dim('│')}    ${chalk.dim('├──')} acceptance-matrix.md / ship-verdict.md`);
-  console.log(`    ${chalk.dim('│')}    ${chalk.dim('└──')} RELEASE_NOTES.md`);
+  const planningSummaryLines = buildPlanningSummaryLines(selectedTemplate, config.workflow_kit);
+  for (const [index, line] of planningSummaryLines.entries()) {
+    const branch = index === planningSummaryLines.length - 1 ? '└──' : '├──';
+    console.log(`    ${chalk.dim('│')}    ${chalk.dim(branch)} ${line}`);
+  }
   console.log(`    ${chalk.dim('└──')} TALK.md`);
   console.log('');
-  console.log(`  ${chalk.dim('Roles:')} pm, dev, qa, eng_director`);
-  console.log(`  ${chalk.dim('Phases:')} planning → implementation → qa ${chalk.dim('(default; extend via routing in agentxchain.json)')}`);
+  console.log(`  ${chalk.dim('Roles:')} ${promptRoleIds.join(', ')}`);
+  console.log(`  ${chalk.dim('Phases:')} ${phaseNames.join(' → ')} ${chalk.dim(selectedTemplate.scaffold_blueprint ? '(template-defined; edit routing in agentxchain.json to customize)' : '(default; extend via routing in agentxchain.json)')}`);
   console.log(`  ${chalk.dim('Template:')} ${templateId}`);
   console.log(`  ${chalk.dim('Dev runtime:')} ${formatGovernedRuntimeCommand(localDevRuntime)} ${chalk.dim(`(${localDevRuntime.prompt_transport})`)}`);
   console.log(`  ${chalk.dim('Protocol:')} governed convergence`);
   console.log('');
 
   // Readiness hint: tell user which roles work immediately vs which need API keys
-  const allRuntimes = { ...GOVERNED_RUNTIMES, 'local-dev': localDevRuntime };
-  const needsKey = Object.entries(allRuntimes)
-    .filter(([, rt]) => rt.auth_env)
-    .map(([id, rt]) => ({ id, env: rt.auth_env }));
-  if (needsKey.length > 0) {
-    const envVars = [...new Set(needsKey.map(r => r.env))];
-    const roleNames = needsKey.map(r => r.id);
+  const allRuntimes = config.runtimes;
+  const manualRoleIds = Object.entries(config.roles)
+    .filter(([, role]) => allRuntimes[role.runtime]?.type === 'manual')
+    .map(([roleId]) => roleId);
+  const rolesNeedingKeys = Object.entries(config.roles)
+    .filter(([, role]) => Boolean(allRuntimes[role.runtime]?.auth_env))
+    .map(([roleId, role]) => ({ roleId, env: allRuntimes[role.runtime].auth_env }));
+  if (rolesNeedingKeys.length > 0) {
+    const envVars = [...new Set(rolesNeedingKeys.map((r) => r.env))];
+    const roleNames = rolesNeedingKeys.map((r) => r.roleId);
     const hasKeys = envVars.every(v => process.env[v]);
     if (hasKeys) {
       console.log(`  ${chalk.green('Ready:')} all runtimes configured (${envVars.join(', ')} detected)`);
     } else {
-      console.log(`  ${chalk.yellow('Mixed-mode:')} pm and eng_director work immediately (manual).`);
+      console.log(`  ${chalk.yellow('Mixed-mode:')} ${manualRoleIds.join(', ')} work immediately (manual).`);
       console.log(`  ${chalk.yellow('  ')}${roleNames.join(', ')} need ${chalk.bold(envVars.join(', '))} to dispatch automatically.`);
       console.log(`  ${chalk.yellow('  ')}Without it, those turns fall back to manual input.`);
-      if (allRuntimes['manual-qa']) {
+      if (config.roles?.qa?.runtime === 'api-qa' && allRuntimes['manual-qa']) {
         console.log(`  ${chalk.yellow('  ')}No-key QA path: change ${chalk.bold('roles.qa.runtime')} from ${chalk.bold('"api-qa"')} to ${chalk.bold('"manual-qa"')} in ${chalk.bold('agentxchain.json')}.`);
       }
     }

package/src/commands/template-list.js

@@ -10,6 +10,7 @@ export function templateListCommand(opts) {
       description: t.description,
       planning_artifacts: (t.planning_artifacts || []).map((a) => a.filename),
       prompt_overrides: Object.keys(t.prompt_overrides || {}),
+      scaffold_blueprint_roles: Object.keys(t.scaffold_blueprint?.roles || {}),
       acceptance_hints: t.acceptance_hints || [],
     }));
     console.log(JSON.stringify(output, null, 2));
@@ -27,6 +28,9 @@ export function templateListCommand(opts) {
     if (t.prompt_overrides && Object.keys(t.prompt_overrides).length > 0) {
       console.log(`    Prompt overrides: ${Object.keys(t.prompt_overrides).join(', ')}`);
     }
+    if (t.scaffold_blueprint?.roles && Object.keys(t.scaffold_blueprint.roles).length > 0) {
+      console.log(`    Scaffold roles: ${Object.keys(t.scaffold_blueprint.roles).join(', ')}`);
+    }
     console.log('');
   }
   console.log(chalk.dim(`  Usage: agentxchain template set <id>\n`));

package/src/commands/template-set.js

@@ -64,6 +64,12 @@ export async function templateSetCommand(templateId, opts) {
 
   // ── Load manifest ─────────────────────────────────────────────────────
   const manifest = loadGovernedTemplate(templateId);
+  if (manifest.scaffold_blueprint) {
+    console.error(chalk.red(`  Error: Template "${templateId}" defines a custom governed team blueprint.`));
+    console.error(chalk.yellow(`  Use ${chalk.bold(`agentxchain init --governed --template ${templateId}`)} for new repos.`));
+    console.error(chalk.yellow('  Retrofitting an existing repo to a blueprint-backed team is deferred until a dedicated migrator exists.'));
+    process.exit(1);
+  }
   const projectName = config.project?.name || 'Untitled';
 
   // ── Build mutation plan ───────────────────────────────────────────────