godpowers 2.5.2 → 2.7.0

package/agents/god-updater.md

@@ -54,13 +54,13 @@ After feature work, every artifact that was impacted needs to reflect reality.
 - Validate have-nots S-01 through S-05
 
 ### DEPLOY update (if reconciler said "needs-extension")
-- Update deploy/STATE.md
+- Update `.godpowers/state.json` deploy evidence
 - Document new env vars
 - Update CI/CD config notes
 - Have-nots D-01 through D-08
 
 ### OBSERVE update (if reconciler said "needs-slo" or "needs-alert")
-- Update observe/STATE.md
+- Update `.godpowers/state.json` observe evidence
 - Define new SLO with error budget policy
 - Define new alert with runbook reference
 - Have-nots OB-01 through OB-08
@@ -71,7 +71,7 @@ After feature work, every artifact that was impacted needs to reflect reality.
 - Have-nots H-01 through H-11
 
 ### LAUNCH update (if reconciler said "copy-update" or "new-launch")
-- Update launch/STATE.md
+- Update `.godpowers/state.json` launch evidence
 - Update landing copy if user-visible
 - Substitution-test new copy
 
@@ -260,8 +260,8 @@ Updated:
 - arch/ARCH.md: added ADR-007 (auth refactor)
 - arch/adr/007-auth-refactor.md: created
 - roadmap/ROADMAP.md: Milestone 2 marked complete
-- deploy/STATE.md: added STRIPE_WEBHOOK_SECRET env var
-- observe/STATE.md: added SLO for /api/stripe-webhook (99.5%)
+- state.json tier-3.deploy: added STRIPE_WEBHOOK_SECRET env var
+- state.json tier-3.observe: added SLO for /api/stripe-webhook (99.5%)
 - backlog/BACKLOG.md: resolved entry "Stripe webhook handling"
 - todos/TODOS.md: marked "wire stripe events" as done
 - threads/auth-migration.md: appended progress note

package/bin/install.js

@@ -51,7 +51,9 @@ function showHelp() {
   log('Commands:');
   log('  status               Show the Godpowers Dashboard for a project');
   log('  next                 Show the dashboard and recommended next command');
+  log('  state advance        Update one tracked Godpowers state step');
   log('  gate                 Check a tier artifact gate');
+  log('  mcp-info             Show read-only MCP companion setup instructions');
   log('  quick-proof          Show a runnable proof from the shipped fixture');
   log('  automation-status    Show host automation provider support');
   log('  automation-setup     Show an opt-in automation setup plan');
@@ -64,7 +66,9 @@ function showHelp() {
   }
   log('');
   log('Options:');
-  log('  --project=<path>     Project root for status, next, proof, or automation commands');
+  log('  --project=<path>     Project root for status, next, state, proof, or automation commands');
+  log('  --step=<name>        Step for state advance, such as prd or tier-1.prd');
+  log('  --status=<status>    Status for state advance');
   log('  --tier=<name>        Tier for gate: prd, design, arch, roadmap, stack, repo, build, or harden');
   log('  --json               Emit JSON for status, next, proof, or automation commands');
   log('  --brief              Render compact output for status, next, or proof');
@@ -99,7 +103,9 @@ function showHelp() {
   log('Examples:');
   log('  npx godpowers status --project=.');
   log('  npx godpowers next --project=.');
+  log('  npx godpowers state advance --step=prd --status=done --project=.');
   log('  npx godpowers gate --tier=prd --project=.');
+  log('  npx godpowers mcp-info --project=.');
   log('  npx godpowers quick-proof --project=.');
   log('  npx godpowers automation-status --project=.');
   log('  npx godpowers automation-setup --project=.');
@@ -211,8 +217,10 @@ module.exports = {
   runDashboardCommand: cliDispatch.runDashboardCommand,
   runDogfoodCommand: cliDispatch.runDogfoodCommand,
   runQuickProofCommand: cliDispatch.runQuickProofCommand,
+  runMcpInfoCommand: cliDispatch.runMcpInfoCommand,
   runExtensionScaffoldCommand: cliDispatch.runExtensionScaffoldCommand,
   runGateCommand: cliDispatch.runGateCommand,
+  runStateCommand: cliDispatch.runStateCommand,
   applyDefaultRuntimeSelection,
   runInstall,
   runUninstall,

package/fixtures/gate/build-pass/.godpowers/state.json

@@ -0,0 +1,33 @@
+{
+  "$schema": "https://godpowers.dev/schema/state.v1.json",
+  "version": "1.0.0",
+  "project": {
+    "name": "build-pass",
+    "started": "2026-06-10T00:00:00.000Z"
+  },
+  "tiers": {
+    "tier-2": {
+      "build": {
+        "status": "done",
+        "updated": "2026-06-10T18:08:00.000Z",
+        "artifact": "build/STATE.md",
+        "verification": {
+          "commands": [
+            {
+              "command": "npm test",
+              "status": "pass",
+              "exitCode": 0,
+              "ranAt": "2026-06-10T18:07:00.000Z"
+            },
+            {
+              "command": "npm run lint",
+              "status": "pass",
+              "exitCode": 0,
+              "ranAt": "2026-06-10T18:07:30.000Z"
+            }
+          ]
+        }
+      }
+    }
+  }
+}

package/lib/README.md

@@ -9,6 +9,8 @@ package-level integrations.
 | Module | Purpose |
 |--------|---------|
 | `state.js` | Read, initialize, validate, and write `.godpowers/state.json`. |
+| `state-views.js` | Generate managed markdown views such as `.godpowers/PROGRESS.md` and Godpowers-owned per-tier `STATE.md` files from `state.json`. |
+| `state-advance.js` | Mutate one tracked state step through locking and generated state view refresh. |
 | `state-lock.js` | Coordinate state writes with a lock file. |
 | `intent.js` | Read and validate `intent.yaml` from project roots or `.godpowers/`. |
 | `frontmatter.js` | Parse shared markdown YAML frontmatter for skills, agents, Pillars, checkpoints, and design specs. |

package/lib/artifact-map.js

@@ -9,7 +9,7 @@ const TIER_ARTIFACTS = {
   design: [
     { path: 'DESIGN.md', required: true, lint: true },
     { path: 'PRODUCT.md', required: false, lint: true },
-    { path: '.godpowers/design/STATE.md', required: true, lint: true }
+    { path: '.godpowers/state.json', required: true, lint: false }
   ],
   arch: [
     { path: '.godpowers/arch/ARCH.md', required: true, lint: true }
@@ -24,13 +24,18 @@ const TIER_ARTIFACTS = {
     { path: '.godpowers/repo/AUDIT.md', required: true, lint: true }
   ],
   build: [
-    { path: '.godpowers/build/STATE.md', required: true, lint: true }
+    { path: '.godpowers/state.json', required: true, lint: false }
   ],
   harden: [
     { path: '.godpowers/harden/FINDINGS.md', required: true, lint: true }
   ]
 };
 
+const TIER_STATE_STEPS = {
+  design: { tierKey: 'tier-1', subStepKey: 'design' },
+  build: { tierKey: 'tier-2', subStepKey: 'build' }
+};
+
 function normalizeTier(tier) {
   if (!tier) return null;
   return String(tier).replace(/^\/?god-/, '').toLowerCase();
@@ -51,10 +56,17 @@ function requiredArtifactsForTier(tier) {
   return artifacts ? artifacts.filter((artifact) => artifact.required) : null;
 }
 
+function stateStepForTier(tier) {
+  const key = normalizeTier(tier);
+  if (!key || !TIER_STATE_STEPS[key]) return null;
+  return { ...TIER_STATE_STEPS[key] };
+}
+
 module.exports = {
   TIER_ARTIFACTS,
   normalizeTier,
   tiers,
   artifactsForTier,
-  requiredArtifactsForTier
+  requiredArtifactsForTier,
+  stateStepForTier
 };

package/lib/cli-dispatch.js

@@ -4,6 +4,7 @@
 
 const gate = require('./gate');
 const identity = require('./package-identity');
+const stateAdvance = require('./state-advance');
 
 const VERSION = identity.PACKAGE_VERSION;
 
@@ -74,6 +75,16 @@ function runQuickProofCommand(opts) {
   }
 }
 
+function runMcpInfoCommand(opts) {
+  const mcpInfo = require('./mcp-info');
+  const result = mcpInfo.info(opts.project);
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(mcpInfo.render(result));
+  }
+}
+
 function runExtensionScaffoldCommand(opts) {
   const authoring = require('./extension-authoring');
   if (!opts.extensionName) {
@@ -130,10 +141,47 @@ function runGateCommand(opts) {
   }
 }
 
+function runStateCommand(opts) {
+  if (opts.stateAction !== 'advance') {
+    const result = {
+      command: 'state',
+      verdict: 'fail',
+      project: opts.project,
+      step: opts.step || null,
+      status: opts.status || null,
+      previousStatus: null,
+      updated: null,
+      warnings: [],
+      checks: [{ id: 'state-action-required', status: 'fail', artifact: '.godpowers/state.json', reason: 'state requires subcommand advance' }],
+      findings: [{ id: 'state-action-required', severity: 'error', artifact: '.godpowers/state.json', reason: 'state requires subcommand advance' }],
+      summary: { updated: false, state: '.godpowers/state.json', views: ['.godpowers/PROGRESS.md'] }
+    };
+    if (opts.json) console.log(JSON.stringify(result, null, 2));
+    else console.log(stateAdvance.render(result));
+    process.exitCode = 1;
+    return;
+  }
+
+  const result = stateAdvance.advance(opts.project, {
+    step: opts.step,
+    status: opts.status
+  });
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(stateAdvance.render(result));
+  }
+  if (stateAdvance.exitCode(result) !== 0) {
+    process.exitCode = 1;
+  }
+}
+
 const COMMAND_RUNNERS = {
   status: runDashboardCommand,
   next: runDashboardCommand,
+  state: runStateCommand,
   'quick-proof': runQuickProofCommand,
+  'mcp-info': runMcpInfoCommand,
   'automation-status': runAutomationCommand,
   'automation-setup': runAutomationCommand,
   dogfood: runDogfoodCommand,
@@ -157,6 +205,8 @@ module.exports = {
   runDashboardCommand,
   runDogfoodCommand,
   runQuickProofCommand,
+  runMcpInfoCommand,
   runExtensionScaffoldCommand,
-  runGateCommand
+  runGateCommand,
+  runStateCommand
 };

package/lib/context-writer.js

@@ -83,13 +83,13 @@ function buildCanonicalContent(state, opts = {}) {
   const scale = (state && (state.scale || (state.project && state.project.scale))) || opts.scale || 'unknown';
   lines.push(`- Project: ${projectName}`);
   lines.push(`- Mode: ${mode}    Scale: ${scale}`);
-  lines.push('- State: `.godpowers/state.json` (machine) and `.godpowers/PROGRESS.md` (human)');
+  lines.push('- State: `.godpowers/state.json` is authority; `.godpowers/PROGRESS.md` is generated for humans');
   lines.push('');
 
   lines.push('### Quarterback rule');
   lines.push('');
-  lines.push('There is exactly one orchestrator: `god-orchestrator`. It owns all writes to');
-  lines.push('`state.json`, `PROGRESS.md`, `intent.yaml`, and `events.jsonl`. Skills like');
+  lines.push('There is exactly one orchestrator: `god-orchestrator`. It owns writes to');
+  lines.push('`state.json`, `intent.yaml`, and `events.jsonl`; `PROGRESS.md` is regenerated from state. Skills like');
   lines.push('`/god`, `/god-next`, `/god-status` read state without writing.');
   lines.push('');
 
@@ -148,7 +148,7 @@ function buildCanonicalContent(state, opts = {}) {
     }
   }
 
-  lines.push('See `.godpowers/PROGRESS.md` for the live tier table.');
+  lines.push('See `.godpowers/state.json` for authority and `.godpowers/PROGRESS.md` for the generated tier table.');
   return lines.join('\n');
 }
 

package/lib/gate.js

@@ -11,6 +11,7 @@ const path = require('path');
 const artifactMap = require('./artifact-map');
 const linter = require('./artifact-linter');
 const router = require('./router');
+const stateStore = require('./state');
 
 function relToAbs(projectRoot, relPath) {
   return path.join(projectRoot, relPath);
@@ -168,12 +169,108 @@ function extractCommandStatuses(text) {
   return entries;
 }
 
-function checkBuildEvidence(projectRoot, result) {
-  const relPath = '.godpowers/build/STATE.md';
-  const file = relToAbs(projectRoot, relPath);
-  if (!fs.existsSync(file)) return;
-  const text = fs.readFileSync(file, 'utf8');
-  const failedCommands = extractFailedCommands(text);
+function commandName(entry) {
+  if (!entry || typeof entry !== 'object') return null;
+  const value = entry.command || entry.cmd || entry.name;
+  return value ? String(value).trim() : null;
+}
+
+function normalizeVerificationStatus(entry) {
+  if (!entry || typeof entry !== 'object') return null;
+  const raw = entry.status || entry.result || entry.verdict;
+  if (raw) {
+    const text = String(raw).trim().toLowerCase();
+    if (/^(pass|passed|green|success|succeeded|ok)$/.test(text)) return 'pass';
+    if (/^(fail|failed|red|error)$/.test(text)) return 'fail';
+  }
+  if (Number.isInteger(entry.exitCode)) return entry.exitCode === 0 ? 'pass' : 'fail';
+  return null;
+}
+
+function stateVerificationCommands(subStep) {
+  if (!subStep || typeof subStep !== 'object') return [];
+  const verification = subStep.verification && typeof subStep.verification === 'object'
+    ? subStep.verification
+    : {};
+  const commands = verification.commands ||
+    subStep.verificationCommands ||
+    subStep['verification-commands'] ||
+    [];
+  return Array.isArray(commands) ? commands : [];
+}
+
+function commandsWithStatus(subStep, wantedStatus) {
+  const commands = [];
+  for (const entry of stateVerificationCommands(subStep)) {
+    const name = commandName(entry);
+    if (!name) continue;
+    if (normalizeVerificationStatus(entry) !== wantedStatus) continue;
+    if (!commands.includes(name)) commands.push(name);
+  }
+  return commands;
+}
+
+function checkStateStepEvidence(projectRoot, tier, result) {
+  const stepRef = artifactMap.stateStepForTier(tier);
+  if (!stepRef) return null;
+
+  const relPath = '.godpowers/state.json';
+  const currentState = stateStore.read(projectRoot);
+  if (!currentState) {
+    const finding = makeFinding(
+      `state:${tier}:missing`,
+      'error',
+      relPath,
+      `${tier} gate requires structured state evidence in state.json.`
+    );
+    result.findings.push(finding);
+    addFindingSummary(result.summary, finding.severity);
+    result.checks.push(makeCheck(`state:${tier}:status`, 'fail', relPath, finding.reason));
+    return null;
+  }
+
+  const tierState = currentState.tiers && currentState.tiers[stepRef.tierKey];
+  const subStep = tierState && tierState[stepRef.subStepKey];
+  if (!subStep) {
+    const finding = makeFinding(
+      `state:${tier}:step-missing`,
+      'error',
+      relPath,
+      `state.json does not record ${stepRef.tierKey}.${stepRef.subStepKey}.`
+    );
+    result.findings.push(finding);
+    addFindingSummary(result.summary, finding.severity);
+    result.checks.push(makeCheck(`state:${tier}:status`, 'fail', relPath, finding.reason));
+    return null;
+  }
+
+  const status = subStep.status || 'pending';
+  const complete = stateStore.isCompleteStatus(status);
+  if (!complete) {
+    const finding = makeFinding(
+      `state:${tier}:incomplete`,
+      'error',
+      relPath,
+      `${stepRef.tierKey}.${stepRef.subStepKey} status is ${status}, expected a complete status.`
+    );
+    result.findings.push(finding);
+    addFindingSummary(result.summary, finding.severity);
+  }
+  result.checks.push(makeCheck(
+    `state:${tier}:status`,
+    complete ? 'pass' : 'fail',
+    relPath,
+    complete
+      ? `${stepRef.tierKey}.${stepRef.subStepKey} records complete status ${status}.`
+      : `${stepRef.tierKey}.${stepRef.subStepKey} must be complete before this gate passes.`
+  ));
+  return subStep;
+}
+
+function checkBuildEvidence(result, buildStep) {
+  const relPath = '.godpowers/state.json';
+  if (!buildStep) return;
+  const failedCommands = commandsWithStatus(buildStep, 'fail');
   if (failedCommands.length > 0) {
     const finding = makeFinding(
       'build-verification-failed-command',
@@ -192,7 +289,7 @@ function checkBuildEvidence(projectRoot, result) {
     result.summary.buildVerificationFailedCommands = failedCommands;
     return;
   }
-  const passedCommands = extractPassedCommands(text);
+  const passedCommands = commandsWithStatus(buildStep, 'pass');
   if (passedCommands.length === 0) {
     const finding = makeFinding(
       'build-verification-evidence',
@@ -214,7 +311,7 @@ function checkBuildEvidence(projectRoot, result) {
     'build-verification-evidence',
     'pass',
     relPath,
-    `Build state records ${passedCommands.length} passed verification command(s).`
+    `state.json records ${passedCommands.length} passed build verification command(s).`
   ));
   result.summary.buildVerificationCommands = passedCommands;
 }
@@ -280,7 +377,8 @@ function check(opts = {}) {
   }
 
   checkArtifacts(projectRoot, tier, artifacts, opts, result);
-  if (tier === 'build') checkBuildEvidence(projectRoot, result);
+  const stateStep = checkStateStepEvidence(projectRoot, tier, result);
+  if (tier === 'build') checkBuildEvidence(result, stateStep);
   if (tier === 'harden') checkHardenCriticals(projectRoot, result);
   return finalize(result);
 }

package/lib/host-capabilities.js

@@ -48,6 +48,48 @@ function installedAgentSurfaces(homeDir) {
   };
 }
 
+function detectMcpAvailability(projectRoot, opts = {}) {
+  if (opts.mcp) return opts.mcp;
+  if (Object.prototype.hasOwnProperty.call(opts, 'mcpAvailable')) {
+    return {
+      available: Boolean(opts.mcpAvailable),
+      source: opts.mcpAvailable ? (opts.mcpSource || 'override') : 'override'
+    };
+  }
+
+  const env = opts.env || process.env;
+  if (env.GODPOWERS_MCP === '1' || env.GODPOWERS_MCP === 'true') {
+    return { available: true, source: 'environment' };
+  }
+
+  const root = projectRoot || process.cwd();
+  if (exists(path.join(root, 'packages', 'mcp', 'package.json'))) {
+    return { available: true, source: 'workspace package' };
+  }
+
+  try {
+    require.resolve('@godpowers/mcp/package.json', { paths: [root, __dirname] });
+    return { available: true, source: 'installed package' };
+  } catch (error) {
+    // Continue to host registration detection.
+  }
+
+  const homeDir = opts.homeDir || os.homedir();
+  const codexConfig = path.join(homeDir, '.codex', 'config.toml');
+  if (exists(codexConfig)) {
+    try {
+      const text = fs.readFileSync(codexConfig, 'utf8');
+      if (/\[mcp_servers\.godpowers\]/.test(text)) {
+        return { available: true, source: 'codex registration' };
+      }
+    } catch (error) {
+      return { available: false, source: 'codex registration unreadable' };
+    }
+  }
+
+  return { available: false, source: 'not configured' };
+}
+
 function detect(projectRoot, opts = {}) {
   const env = opts.env || process.env;
   const homeDir = opts.homeDir || os.homedir();
@@ -62,6 +104,7 @@ function detect(projectRoot, opts = {}) {
   const extensionAuthoring = exists(path.join(root, 'lib', 'extension-authoring.js'))
     && exists(path.join(root, 'schema', 'extension-manifest.v1.json'));
   const suiteReleaseDryRun = exists(path.join(root, 'lib', 'suite-state.js'));
+  const mcp = detectMcpAvailability(root, opts);
 
   const gaps = [];
   if (!shell) gaps.push('shell unavailable');
@@ -86,6 +129,7 @@ function detect(projectRoot, opts = {}) {
       npm,
       gh,
       agentSpawn,
+      mcp,
       codeIntelligence: codeIntel,
       extensionAuthoring,
       suiteReleaseDryRun
@@ -97,9 +141,13 @@ function detect(projectRoot, opts = {}) {
 
 function summary(report) {
   if (!report) return 'unknown';
-  if (report.level === 'full') return `full on ${report.host}`;
+  const mcp = report.guarantees && report.guarantees.mcp;
+  const mcpText = mcp && mcp.available
+    ? `; MCP available via ${mcp.source}`
+    : '; MCP not configured';
+  if (report.level === 'full') return `full on ${report.host}${mcpText}`;
   const gap = report.gaps && report.gaps.length > 0 ? `, ${report.gaps[0]}` : '';
-  return `${report.level} on ${report.host}${gap}`;
+  return `${report.level} on ${report.host}${gap}${mcpText}`;
 }
 
 function render(report) {
@@ -112,6 +160,7 @@ function render(report) {
   lines.push(`  Git: ${report.guarantees.git || 'not detected'}`);
   lines.push(`  npm: ${report.guarantees.npm || 'not detected'}`);
   lines.push(`  GitHub CLI: ${report.guarantees.gh || 'not detected'}`);
+  lines.push(`  MCP: ${report.guarantees.mcp.available ? `available via ${report.guarantees.mcp.source}` : 'not configured'}`);
   lines.push(`  Code intelligence: ${codeIntelligence.summary(report.guarantees.codeIntelligence)}`);
   lines.push(`  Gaps: ${report.gaps.length > 0 ? report.gaps.join('; ') : 'none'}`);
   return lines.join('\n');
@@ -124,6 +173,7 @@ module.exports = {
   _private: {
     commandVersion,
     hostName,
-    installedAgentSurfaces
+    installedAgentSurfaces,
+    detectMcpAvailability
   }
 };

package/lib/installer-args.js

@@ -4,7 +4,9 @@ const { RUNTIMES } = require('./installer-runtimes');
 const COMMANDS = new Set([
   'status',
   'next',
+  'state',
   'quick-proof',
+  'mcp-info',
   'automation-status',
   'automation-setup',
   'dogfood',
@@ -19,6 +21,9 @@ function parseArgs(argv, cwd = process.cwd()) {
     project: cwd,
     json: false,
     brief: false,
+    stateAction: null,
+    step: null,
+    status: null,
     extensionName: null,
     extensionOutput: cwd,
     extensionSkill: null,
@@ -40,6 +45,10 @@ function parseArgs(argv, cwd = process.cwd()) {
       opts.command = arg;
       continue;
     }
+    if (opts.command === 'state' && !opts.stateAction && !arg.startsWith('-')) {
+      opts.stateAction = arg;
+      continue;
+    }
 
     switch (arg) {
       case '--json':
@@ -54,6 +63,18 @@ function parseArgs(argv, cwd = process.cwd()) {
           i++;
         }
         break;
+      case '--step':
+        if (args[i + 1]) {
+          opts.step = args[i + 1];
+          i++;
+        }
+        break;
+      case '--status':
+        if (args[i + 1]) {
+          opts.status = args[i + 1];
+          i++;
+        }
+        break;
       case '--project':
         if (args[i + 1]) {
           opts.project = path.resolve(args[i + 1]);
@@ -103,6 +124,10 @@ function parseArgs(argv, cwd = process.cwd()) {
           opts.extensionWorkflow = arg.slice('--workflow='.length);
         } else if (arg.startsWith('--tier=')) {
           opts.tier = arg.slice('--tier='.length);
+        } else if (arg.startsWith('--step=')) {
+          opts.step = arg.slice('--step='.length);
+        } else if (arg.startsWith('--status=')) {
+          opts.status = arg.slice('--status='.length);
         } else if (arg.startsWith('--profile=')) {
           opts.profile = arg.slice('--profile='.length);
         } else if (arg.startsWith('--') && RUNTIMES[arg.slice(2)]) {

package/lib/mcp-info.js

@@ -0,0 +1,93 @@
+const path = require('path');
+
+const identity = require('./package-identity');
+
+const MCP_PACKAGE = '@godpowers/mcp';
+
+function projectPath(projectRoot) {
+  return path.resolve(projectRoot || process.cwd());
+}
+
+function serverCommand(projectRoot, version = identity.PACKAGE_VERSION) {
+  return {
+    command: 'npx',
+    args: [
+      '-y',
+      '-p',
+      `${identity.PACKAGE_NAME}@${version}`,
+      '-p',
+      `${MCP_PACKAGE}@${version}`,
+      'godpowers-mcp',
+      'serve',
+      '--project',
+      projectPath(projectRoot)
+    ]
+  };
+}
+
+function setupCommand(projectRoot, version = identity.PACKAGE_VERSION) {
+  return {
+    command: 'npx',
+    args: [
+      '-y',
+      '-p',
+      `${identity.PACKAGE_NAME}@${version}`,
+      '-p',
+      `${MCP_PACKAGE}@${version}`,
+      'godpowers-mcp',
+      'setup',
+      '--host=codex',
+      '--project',
+      projectPath(projectRoot),
+      '--write'
+    ]
+  };
+}
+
+function info(projectRoot, version = identity.PACKAGE_VERSION) {
+  const project = projectPath(projectRoot);
+  return {
+    package: MCP_PACKAGE,
+    version,
+    project,
+    boundary: 'The MCP SDK dependency is isolated in @godpowers/mcp. The main godpowers package has no production dependencies.',
+    tools: ['status', 'next', 'gate_check', 'lint_artifact', 'trace_requirement'],
+    server: serverCommand(project, version),
+    setup: setupCommand(project, version),
+    automaticRegistration: false
+  };
+}
+
+function renderCommand(command) {
+  return `${command.command} ${command.args.join(' ')}`;
+}
+
+function render(result) {
+  return [
+    'Godpowers MCP',
+    '',
+    `Package: ${result.package}@${result.version}`,
+    `Project: ${result.project}`,
+    `Boundary: ${result.boundary}`,
+    '',
+    'Tools:',
+    `  ${result.tools.join(', ')}`,
+    '',
+    'Run server:',
+    `  ${renderCommand(result.server)}`,
+    '',
+    'Opt-in Codex setup:',
+    `  ${renderCommand(result.setup)}`,
+    '',
+    'Automatic registration: disabled'
+  ].join('\n');
+}
+
+module.exports = {
+  MCP_PACKAGE,
+  serverCommand,
+  setupCommand,
+  info,
+  render,
+  renderCommand
+};