godpowers 1.6.20 → 1.6.22

package/lib/dashboard.js

@@ -14,6 +14,7 @@ const router = require('./router');
 const automationProviders = require('./automation-providers');
 const repoDocSync = require('./repo-doc-sync');
 const repoSurfaceSync = require('./repo-surface-sync');
+const hostCapabilities = require('./host-capabilities');
 
 const GOD_DIR = '.godpowers';
 const PRD_PATH = '.godpowers/prd/PRD.md';
@@ -168,6 +169,7 @@ function proactiveChecks(projectRoot, changedFiles = []) {
   const repoSurfaceStatus = repoSurface.status === 'fresh'
     ? 'fresh'
     : `${repoSurface.stale.length} stale, suggest /god-doctor`;
+  const host = hostCapabilities.detect(projectRoot);
 
   return {
     checkpoint,
@@ -175,6 +177,7 @@ function proactiveChecks(projectRoot, changedFiles = []) {
     sync,
     docs: repoDocsStatus,
     repoSurface: repoSurfaceStatus,
+    host: hostCapabilities.summary(host),
     runtime: 'not-applicable',
     automation: automationSummary(projectRoot),
     security: sensitiveChanged ? 'sensitive files changed, suggest /god-harden' : 'clear',
@@ -217,7 +220,7 @@ function compute(projectRoot, opts = {}) {
 
   if (!s) {
     const next = { command: '/god-init', reason: 'No Godpowers project initialized' };
-    return {
+    const result = {
       source: 'runtime dashboard (lib/dashboard.js)',
       state: 'not initialized',
       mode: null,
@@ -234,9 +237,12 @@ function compute(projectRoot, opts = {}) {
         completionBasis: 'missing .godpowers/state.json'
       },
       proactive: proactiveChecks(projectRoot, git.entries.map(statusPath)),
+      host: hostCapabilities.detect(projectRoot, opts.host || {}),
       next,
       openItems: ['No .godpowers/state.json found']
     };
+    result.actionBrief = actionBrief(result);
+    return result;
   }
 
   const progress = state.progressSummary(s);
@@ -250,7 +256,7 @@ function compute(projectRoot, opts = {}) {
   if (reviewCount(projectRoot) > 0) openItems.push('pending review items');
   if (openItems.length === 0) openItems.push('none');
 
-  return {
+  const result = {
     source: 'runtime dashboard (lib/dashboard.js)',
     state: progress.remaining === 0 ? 'complete' : 'in progress',
     mode: s.mode || s['mode-announced-as'] || null,
@@ -261,12 +267,46 @@ function compute(projectRoot, opts = {}) {
     index: git.index,
     planning: planningVisibility(projectRoot, progress),
     proactive: proactiveChecks(projectRoot, git.entries.map(statusPath)),
+    host: hostCapabilities.detect(projectRoot, opts.host || {}),
     next,
     openItems
   };
+  result.actionBrief = actionBrief(result);
+  return result;
+}
+
+function actionBrief(dashboard) {
+  const proactive = dashboard.proactive || {};
+  const next = dashboard.next || {};
+  const blockers = [];
+  for (const [label, value] of [
+    ['Repo surface', proactive.repoSurface],
+    ['Docs', proactive.docs],
+    ['Host', proactive.host],
+    ['Reviews', proactive.reviews],
+    ['Sync', proactive.sync],
+    ['Security', proactive.security],
+    ['Dependencies', proactive.dependencies],
+    ['Hygiene', proactive.hygiene]
+  ]) {
+    if (!value) continue;
+    if (value === 'fresh' || value === 'none' || value === 'clear' || value === 'not-applicable') continue;
+    if (/^full on /.test(value)) continue;
+    if (/^available via /.test(value)) continue;
+    blockers.push(`${label}: ${value}`);
+  }
+
+  const recommended = next.command || 'describe the next intent';
+  return {
+    recommended,
+    reason: next.reason || 'No route was computed.',
+    confidence: blockers.length === 0 ? 'ready' : 'needs attention',
+    blockers: blockers.slice(0, 3),
+    overflow: Math.max(0, blockers.length - 3)
+  };
 }
 
-function render(dashboard) {
+function render(dashboard, opts = {}) {
   const current = dashboard.current || {};
   const planning = dashboard.planning || {};
   const proactive = dashboard.proactive || {};
@@ -277,6 +317,27 @@ function render(dashboard) {
   const openItems = dashboard.openItems && dashboard.openItems.length > 0
     ? dashboard.openItems
     : ['none'];
+  const brief = dashboard.actionBrief || actionBrief(dashboard);
+  if (opts.mode === 'brief' || opts.brief === true) {
+    return [
+      'Godpowers Dashboard',
+      '',
+      'Action brief:',
+      `  Next: ${brief.recommended}`,
+      `  Why: ${brief.reason}`,
+      `  Readiness: ${brief.confidence}`,
+      `  Attention: ${brief.blockers && brief.blockers.length > 0 ? brief.blockers.join('; ') : 'none'}${brief.overflow ? `; ${brief.overflow} more` : ''}`,
+      `  Host guarantees: ${dashboard.host ? hostCapabilities.summary(dashboard.host) : proactive.host || 'unknown'}`,
+      '',
+      'Current status:',
+      `  State: ${dashboard.state}`,
+      `  Progress: ${progress.percent || 0}% workflow progress (${progress.completed || 0} of ${progress.total || 0} tracked steps complete)`,
+      '',
+      'Next:',
+      `  Recommended: ${next.command || 'describe the next intent'}`,
+      `  Why: ${next.reason || 'No route was computed.'}`
+    ].join('\n');
+  }
 
   return [
     'Godpowers Dashboard',
@@ -291,6 +352,13 @@ function render(dashboard) {
     `  Worktree: ${dashboard.worktree}`,
     `  Index: ${dashboard.index}`,
     '',
+    'Action brief:',
+    `  Next: ${brief.recommended}`,
+    `  Why: ${brief.reason}`,
+    `  Readiness: ${brief.confidence}`,
+    `  Attention: ${brief.blockers && brief.blockers.length > 0 ? brief.blockers.join('; ') : 'none'}${brief.overflow ? `; ${brief.overflow} more` : ''}`,
+    `  Host guarantees: ${dashboard.host ? hostCapabilities.summary(dashboard.host) : proactive.host || 'unknown'}`,
+    '',
     'Planning visibility:',
     `  PRD: ${prd.status || 'missing'}${prd.path ? ` ${prd.path}` : ''}`,
     `  Roadmap: ${roadmap.status || 'missing'}${roadmap.path ? ` ${roadmap.path}` : ''}`,
@@ -303,6 +371,7 @@ function render(dashboard) {
     `  Sync: ${proactive.sync || 'unknown'}`,
     `  Docs: ${proactive.docs || 'unknown'}`,
     `  Repo surface: ${proactive.repoSurface || 'unknown'}`,
+    `  Host: ${proactive.host || 'unknown'}`,
     `  Runtime: ${proactive.runtime || 'unknown'}`,
     `  Automation: ${proactive.automation || 'unknown'}`,
     `  Security: ${proactive.security || 'unknown'}`,
@@ -325,5 +394,6 @@ module.exports = {
   parseGitStatus,
   proactiveChecks,
   automationSummary,
+  actionBrief,
   planningVisibility
 };

package/lib/dogfood-runner.js

@@ -0,0 +1,193 @@
+/**
+ * Dogfood runner.
+ *
+ * Executes deterministic messy-repo scenarios against the Godpowers runtime.
+ * The runner uses fixtures so release gates can verify migrations, sync-back,
+ * host guarantees, package surfaces, extension authoring, and suite planning
+ * without touching real user projects.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const planningSystems = require('./planning-systems');
+const sourceSync = require('./source-sync');
+const hostCapabilities = require('./host-capabilities');
+const extensionAuthoring = require('./extension-authoring');
+const suiteState = require('./suite-state');
+
+const FIXTURE_ROOT = path.join(__dirname, '..', 'fixtures', 'dogfood');
+
+function readJson(file) {
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    if (entry.name === 'manifest.json') continue;
+    const source = path.join(src, entry.name);
+    const target = path.join(dest, entry.name);
+    if (entry.isDirectory()) copyDir(source, target);
+    else fs.copyFileSync(source, target);
+  }
+}
+
+function listScenarios(root = FIXTURE_ROOT) {
+  if (!fs.existsSync(root)) return [];
+  return fs.readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => {
+      const dir = path.join(root, entry.name);
+      const manifest = readJson(path.join(dir, 'manifest.json'));
+      return { id: entry.name, dir, manifest };
+    })
+    .sort((a, b) => a.id.localeCompare(b.id));
+}
+
+function prepareScenario(scenario) {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), `godpowers-dogfood-${scenario.id}-`));
+  copyDir(scenario.dir, tmp);
+  return tmp;
+}
+
+function check(condition, id, message, details = {}) {
+  return {
+    id,
+    status: condition ? 'pass' : 'fail',
+    message,
+    details
+  };
+}
+
+function runMigrationScenario(projectRoot, manifest) {
+  const detection = planningSystems.detect(projectRoot);
+  const report = { detection, importResult: null, syncResult: null };
+  if (manifest.actions && manifest.actions.includes('import-planning-context')) {
+    report.importResult = planningSystems.importPlanningContext(projectRoot, { detection });
+  }
+  if (manifest.actions && manifest.actions.includes('sync-back')) {
+    report.syncResult = sourceSync.run(projectRoot);
+  }
+  return report;
+}
+
+function runExtensionScenario(projectRoot, manifest) {
+  const packName = manifest.extensionName || '@godpowers/dogfood-pack';
+  const target = path.join(projectRoot, 'extension-out');
+  return extensionAuthoring.scaffold(target, {
+    name: packName,
+    version: '0.1.0',
+    skill: 'god-dogfood-extension',
+    agent: 'god-dogfood-agent',
+    workflow: 'dogfood-workflow',
+    godpowersRange: '>=1.6.0'
+  });
+}
+
+function runSuiteScenario(projectRoot, manifest) {
+  const plan = suiteState.planRelease(projectRoot, manifest.repo || 'repo-a', manifest.version || '1.2.4');
+  return plan;
+}
+
+function runScenario(scenario, opts = {}) {
+  const projectRoot = opts.projectRoot || prepareScenario(scenario);
+  const manifest = scenario.manifest;
+  const checks = [];
+  const context = {};
+
+  if (manifest.kind === 'planning-migration') {
+    context.migration = runMigrationScenario(projectRoot, manifest);
+    const detected = context.migration.detection.systems.map((system) => system.id);
+    for (const id of manifest.expectedSystems || []) {
+      checks.push(check(detected.includes(id), `detect-${id}`, `Detected ${id}.`, { detected }));
+    }
+    for (const relPath of manifest.expectedFiles || []) {
+      checks.push(check(fs.existsSync(path.join(projectRoot, relPath)), `file-${relPath}`, `${relPath} exists.`));
+    }
+  }
+
+  if (manifest.kind === 'host-capabilities') {
+    context.host = hostCapabilities.detect(projectRoot, {
+      homeDir: path.join(projectRoot, 'home'),
+      env: { SHELL: '/bin/zsh', CODEX_HOME: path.join(projectRoot, 'home', '.codex') }
+    });
+    checks.push(check(context.host.level === manifest.expectedLevel,
+      'host-level',
+      `Host capability level is ${manifest.expectedLevel}.`,
+      { level: context.host.level }));
+  }
+
+  if (manifest.kind === 'extension-authoring') {
+    context.extension = runExtensionScenario(projectRoot, manifest);
+    for (const relPath of manifest.expectedFiles || []) {
+      checks.push(check(fs.existsSync(path.join(context.extension.path, relPath)),
+        `extension-file-${relPath}`,
+        `Extension file ${relPath} exists.`));
+    }
+    checks.push(check(context.extension.validation.length === 0,
+      'extension-validation',
+      'Scaffolded extension validates.',
+      { validation: context.extension.validation }));
+  }
+
+  if (manifest.kind === 'suite-release') {
+    context.suite = runSuiteScenario(projectRoot, manifest);
+    checks.push(check(context.suite.mode === 'dry-run',
+      'suite-dry-run',
+      'Suite release plan is dry-run mode.'));
+    checks.push(check(context.suite.impacted.length === (manifest.expectedImpacted || 0),
+      'suite-impact-count',
+      `Suite release impact count is ${manifest.expectedImpacted || 0}.`,
+      { impacted: context.suite.impacted }));
+  }
+
+  const failed = checks.filter((item) => item.status !== 'pass');
+  return {
+    id: scenario.id,
+    name: manifest.name || scenario.id,
+    projectRoot,
+    status: failed.length === 0 ? 'pass' : 'fail',
+    checks,
+    context
+  };
+}
+
+function runAll(opts = {}) {
+  const scenarios = listScenarios(opts.fixtureRoot);
+  const results = scenarios.map((scenario) => runScenario(scenario, opts));
+  const failed = results.filter((result) => result.status !== 'pass');
+  return {
+    status: failed.length === 0 ? 'pass' : 'fail',
+    total: results.length,
+    passed: results.length - failed.length,
+    failed: failed.length,
+    results
+  };
+}
+
+function render(report) {
+  const lines = [];
+  lines.push('Godpowers Dogfood Report');
+  lines.push('');
+  lines.push(`Status: ${report.status}`);
+  lines.push(`Scenarios: ${report.passed} passed, ${report.failed} failed, ${report.total} total`);
+  for (const result of report.results) {
+    lines.push('');
+    lines.push(`## ${result.name}`);
+    lines.push(`Status: ${result.status}`);
+    for (const item of result.checks) {
+      lines.push(`- [${item.status.toUpperCase()}] ${item.message}`);
+    }
+  }
+  return lines.join('\n');
+}
+
+module.exports = {
+  FIXTURE_ROOT,
+  listScenarios,
+  runScenario,
+  runAll,
+  render
+};

package/lib/extension-authoring.js

@@ -0,0 +1,154 @@
+/**
+ * Extension authoring helpers.
+ *
+ * Creates a publishable Godpowers extension skeleton that follows the same
+ * manifest, package, README, skill, agent, and workflow contracts as the
+ * first-party packs.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const extensions = require('./extensions');
+
+function ensureDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function write(filePath, content, overwrite) {
+  if (fs.existsSync(filePath) && overwrite !== true) return false;
+  ensureDir(filePath);
+  fs.writeFileSync(filePath, content);
+  return true;
+}
+
+function packageFolderName(name) {
+  return name.replace(/^@/, '').replace(/\//g, '-');
+}
+
+function scaffold(outputRoot, opts = {}) {
+  const name = opts.name || '@godpowers/custom-pack';
+  const version = opts.version || '0.1.0';
+  const skill = opts.skill || 'god-custom-pack';
+  const agent = opts.agent || null;
+  const workflow = opts.workflow || null;
+  const range = opts.godpowersRange || '>=1.6.0';
+  const folder = opts.folder || packageFolderName(name);
+  const root = path.join(outputRoot, folder);
+  const written = [];
+
+  const manifest = [
+    'apiVersion: godpowers/v1',
+    'kind: Extension',
+    'metadata:',
+    `  name: ${name}`,
+    `  version: ${version}`,
+    '  description: Custom Godpowers extension pack.',
+    'engines:',
+    `  godpowers: ${range}`,
+    'provides:',
+    '  skills:',
+    `    - ${skill}`,
+    ...(agent ? ['  agents:', `    - ${agent}`] : []),
+    ...(workflow ? ['  workflows:', `    - ${workflow}`] : []),
+    ''
+  ].join('\n');
+
+  const pkg = {
+    name,
+    version,
+    description: 'Custom Godpowers extension pack.',
+    license: 'MIT',
+    files: [
+      'manifest.yaml',
+      'README.md',
+      'skills/',
+      'agents/',
+      'workflows/',
+      'references/'
+    ],
+    peerDependencies: {
+      godpowers: range
+    },
+    publishConfig: {
+      access: 'public'
+    }
+  };
+
+  const readme = [
+    `# ${name}`,
+    '',
+    'Custom Godpowers extension pack.',
+    '',
+    '## Contents',
+    '',
+    `- Skill: ${skill}`,
+    ...(agent ? [`- Agent: ${agent}`] : []),
+    ...(workflow ? [`- Workflow: ${workflow}`] : []),
+    ''
+  ].join('\n');
+
+  const skillMd = [
+    '---',
+    `name: ${skill}`,
+    'description: |',
+    '  Custom Godpowers extension command.',
+    '',
+    `  Triggers on: "${skill.replace(/^god-/, 'god ')}", "/${skill}"`,
+    '---',
+    '',
+    `# /${skill}`,
+    '',
+    '- [DECISION] This extension command is scaffolded for project-specific behavior.',
+    '- [OPEN QUESTION] Replace this placeholder with the command workflow. Owner: extension author. Due: before publish.',
+    ''
+  ].join('\n');
+
+  if (write(path.join(root, 'manifest.yaml'), manifest, opts.overwrite)) written.push('manifest.yaml');
+  if (write(path.join(root, 'package.json'), `${JSON.stringify(pkg, null, 2)}\n`, opts.overwrite)) written.push('package.json');
+  if (write(path.join(root, 'README.md'), readme, opts.overwrite)) written.push('README.md');
+  if (write(path.join(root, 'skills', `${skill}.md`), skillMd, opts.overwrite)) written.push(`skills/${skill}.md`);
+
+  if (agent) {
+    const agentMd = [
+      '---',
+      `name: ${agent}`,
+      'description: Custom Godpowers extension specialist.',
+      '---',
+      '',
+      `# ${agent}`,
+      '',
+      '- [DECISION] Follow the extension command handoff and return only user-facing progress.',
+      ''
+    ].join('\n');
+    if (write(path.join(root, 'agents', `${agent}.md`), agentMd, opts.overwrite)) written.push(`agents/${agent}.md`);
+  }
+
+  if (workflow) {
+    const workflowYaml = [
+      'apiVersion: godpowers/v1',
+      'kind: Workflow',
+      `name: ${workflow}`,
+      'steps:',
+      `  - command: /${skill}`,
+      ''
+    ].join('\n');
+    if (write(path.join(root, 'workflows', `${workflow}.yaml`), workflowYaml, opts.overwrite)) written.push(`workflows/${workflow}.yaml`);
+  }
+
+  const parsed = extensions.parseManifest(fs.readFileSync(path.join(root, 'manifest.yaml'), 'utf8')).manifest;
+  const validation = extensions.validateManifest(parsed, opts.runtimeVersion || '1.6.0');
+
+  return {
+    path: root,
+    name,
+    version,
+    written,
+    validation
+  };
+}
+
+module.exports = {
+  scaffold,
+  packageFolderName
+};

package/lib/feature-awareness.js

@@ -64,6 +64,24 @@ const FEATURES = [
     since: '1.6.19',
     commands: ['/god-sync', '/god-docs', '/god-doctor', '/god-status', '/god-mode'],
     description: 'Detect release-facing drift across badges, release notes, changelog, package checks, and release checklist policy.'
+  },
+  {
+    id: 'dogfood-runner',
+    since: '1.6.22',
+    commands: ['/god-dogfood'],
+    description: 'Run messy-repo fixtures for migration, host guarantee, extension authoring, and suite release readiness.'
+  },
+  {
+    id: 'host-capabilities',
+    since: '1.6.22',
+    commands: ['/god-status', '/god-next'],
+    description: 'Report full, degraded, or unknown host guarantees in dashboard output.'
+  },
+  {
+    id: 'extension-authoring',
+    since: '1.6.22',
+    commands: ['/god-extension-add', '/god-test-extension'],
+    description: 'Scaffold and validate publishable Godpowers extension packs.'
   }
 ];
 

package/lib/host-capabilities.js

@@ -0,0 +1,125 @@
+/**
+ * Host capability detection.
+ *
+ * Reports what the current AI coding host can actually guarantee at runtime.
+ * This keeps Godpowers honest when true fresh-context spawning or release
+ * tools depend on the host environment.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const cp = require('child_process');
+
+function exists(filePath) {
+  return fs.existsSync(filePath);
+}
+
+function commandVersion(command, args, opts = {}) {
+  try {
+    const out = cp.execFileSync(command, args, {
+      cwd: opts.cwd || process.cwd(),
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: opts.timeout || 1500
+    }).trim();
+    return out.split(/\r?\n/)[0] || 'installed';
+  } catch (err) {
+    return null;
+  }
+}
+
+function hostName(env) {
+  if (env.CODEX_HOME || env.CODEX_SANDBOX || env.CODEX_ENV_PWD) return 'codex';
+  if (env.CLAUDECODE || env.CLAUDE_CODE || env.CLAUDE_CONFIG_DIR) return 'claude';
+  if (env.CURSOR_TRACE_ID || env.CURSOR_AGENT) return 'cursor';
+  if (env.WINDSURF) return 'windsurf';
+  return 'unknown';
+}
+
+function installedAgentSurfaces(homeDir) {
+  const codexAgents = path.join(homeDir, '.codex', 'agents');
+  const claudeAgents = path.join(homeDir, '.claude', 'agents');
+  return {
+    codex: exists(path.join(codexAgents, 'god-orchestrator.toml'))
+      || exists(path.join(codexAgents, 'god-orchestrator.md')),
+    claude: exists(path.join(claudeAgents, 'god-orchestrator.md'))
+  };
+}
+
+function detect(projectRoot, opts = {}) {
+  const env = opts.env || process.env;
+  const homeDir = opts.homeDir || os.homedir();
+  const root = projectRoot || process.cwd();
+  const installedAgents = opts.installedAgents || installedAgentSurfaces(homeDir);
+  const git = commandVersion('git', ['--version'], { cwd: root });
+  const npm = commandVersion('npm', ['--version'], { cwd: root });
+  const gh = commandVersion('gh', ['--version'], { cwd: root });
+  const shell = Boolean(env.SHELL || env.ComSpec);
+  const agentSpawn = Boolean(installedAgents.codex || installedAgents.claude || opts.agentSpawn);
+  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 gaps = [];
+  if (!shell) gaps.push('shell unavailable');
+  if (!git) gaps.push('git unavailable');
+  if (!npm) gaps.push('npm unavailable');
+  if (!agentSpawn) gaps.push('fresh-context agent spawn not detected');
+  if (!extensionAuthoring) gaps.push('extension authoring scaffold unavailable');
+  if (!suiteReleaseDryRun) gaps.push('suite release dry-run unavailable');
+
+  let level = 'unknown';
+  if (shell && git && npm && agentSpawn) level = 'full';
+  else if (shell && git && npm) level = 'degraded';
+
+  return {
+    host: opts.host || hostName(env),
+    level,
+    guarantees: {
+      shell,
+      fileEdit: true,
+      node: process.version,
+      git,
+      npm,
+      gh,
+      agentSpawn,
+      extensionAuthoring,
+      suiteReleaseDryRun
+    },
+    installedAgents,
+    gaps
+  };
+}
+
+function summary(report) {
+  if (!report) return 'unknown';
+  if (report.level === 'full') return `full on ${report.host}`;
+  const gap = report.gaps && report.gaps.length > 0 ? `, ${report.gaps[0]}` : '';
+  return `${report.level} on ${report.host}${gap}`;
+}
+
+function render(report) {
+  const lines = [];
+  lines.push('Host capabilities:');
+  lines.push(`  Host: ${report.host}`);
+  lines.push(`  Guarantee level: ${report.level}`);
+  lines.push(`  Agent spawn: ${report.guarantees.agentSpawn ? 'detected' : 'not detected'}`);
+  lines.push(`  Shell: ${report.guarantees.shell ? 'detected' : 'not detected'}`);
+  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(`  Gaps: ${report.gaps.length > 0 ? report.gaps.join('; ') : 'none'}`);
+  return lines.join('\n');
+}
+
+module.exports = {
+  detect,
+  summary,
+  render,
+  _private: {
+    commandVersion,
+    hostName,
+    installedAgentSurfaces
+  }
+};