godpowers 1.6.21 → 1.6.23

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/events.js

@@ -20,6 +20,12 @@ const VALID_EVENT_NAMES = new Set([
   'gate.fail', 'gate.pass',
   'tier.skip',
   'state.repair', 'state.rollback',
+  'local-helper.run', 'local-helper.complete',
+  'dashboard.render',
+  'host-capabilities.detect',
+  'dogfood.run',
+  'source-system.import', 'source-system.sync-back',
+  'repo-doc-sync.detect', 'repo-surface-sync.detect',
   'extension.install', 'extension.activate',
   // Cost / cache / budget (v0.14 token cost saver)
   'cost.recorded', 'cache.hit', 'cache.miss', 'budget.exceeded',

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,36 @@ 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: 'dashboard-action-brief',
+    since: '1.6.22',
+    commands: ['/god-status', '/god-next', '/god-mode'],
+    description: 'Render compressed action brief, readiness, attention, and host guarantee lines from disk state.'
+  },
+  {
+    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.'
+  },
+  {
+    id: 'suite-release-dry-run',
+    since: '1.6.22',
+    commands: ['/god-suite-release'],
+    description: 'Plan Mode D suite releases with impacted dependents and planned writes before mutation.'
   }
 ];
 

package/lib/have-nots-validator.js

@@ -1,7 +1,7 @@
 /**
  * Have-Nots Validator
  *
- * Registry of mechanical checks against the 99 named have-nots from
+ * Registry of mechanical checks against the 156 named have-nots from
  * references/HAVE-NOTS.md. Each check returns structured findings:
  *
  *   { code, severity: 'error'|'warning'|'info', line, column, message, suggestion }
@@ -70,7 +70,7 @@ function findPositions(content, regex) {
 /** U-08: em or en dash present */
 function checkEmEnDash(content) {
   const findings = [];
-  const positions = findPositions(content, /[–—]/g);
+  const positions = findPositions(content, /[\u2013\u2014]/g);
   for (const p of positions) {
     findings.push({
       code: 'U-08',

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
+  }
+};

package/lib/release-surface-sync.js

@@ -12,12 +12,18 @@ const path = require('path');
 const LOG_PATH = '.godpowers/surface/RELEASE-SURFACE-SYNC.md';
 
 const REQUIRED_PACKAGE_GUARDS = [
+  'lib/dogfood-runner.js',
+  'lib/extension-authoring.js',
+  'lib/host-capabilities.js',
   'lib/route-quality-sync.js',
   'lib/recipe-coverage-sync.js',
   'lib/release-surface-sync.js'
 ];
 
 const REQUIRED_RELEASE_TESTS = [
+  'scripts/test-dogfood-runner.js',
+  'scripts/test-extension-authoring.js',
+  'scripts/test-host-capabilities.js',
   'scripts/test-automation-surface-sync.js',
   'scripts/test-repo-surface-sync.js',
   'scripts/test-extensions-publish.js',

package/lib/repo-surface-sync.js

@@ -29,6 +29,7 @@ const REQUIRED_PACKAGE_FILE_ENTRIES = [
   'workflows/',
   'schema/',
   'lib/',
+  'fixtures/',
   'extensions/',
   'RELEASE.md',
   'SKILL.md',
@@ -41,6 +42,9 @@ const REQUIRED_PACKAGE_CHECKS = [
   'lib/feature-awareness.js',
   'lib/repo-doc-sync.js',
   'lib/repo-surface-sync.js',
+  'lib/dogfood-runner.js',
+  'lib/extension-authoring.js',
+  'lib/host-capabilities.js',
   'lib/route-quality-sync.js',
   'lib/recipe-coverage-sync.js',
   'lib/release-surface-sync.js',
@@ -426,6 +430,59 @@ function suiteChecks(projectRoot) {
   return checks;
 }
 
+function dogfoodChecks(projectRoot) {
+  const checks = [];
+  const pkg = readJson(projectRoot, 'package.json') || {};
+  const scriptsText = JSON.stringify(pkg.scripts || {});
+  const scenarios = [
+    'fixtures/dogfood/half-migrated-gsd/manifest.json',
+    'fixtures/dogfood/host-degraded/manifest.json',
+    'fixtures/dogfood/host-full/manifest.json',
+    'fixtures/dogfood/extension-authoring/manifest.json',
+    'fixtures/dogfood/suite-release-dry-run/manifest.json'
+  ];
+
+  addCheck(
+    checks,
+    'dogfood',
+    'dogfood-runtime-helper',
+    exists(projectRoot, 'lib/dogfood-runner.js') ? 'fresh' : 'stale',
+    'lib/dogfood-runner.js',
+    exists(projectRoot, 'lib/dogfood-runner.js')
+      ? 'Dogfood runner helper exists.'
+      : 'Dogfood runner helper is missing.',
+    { spawn: exists(projectRoot, 'lib/dogfood-runner.js') ? null : 'god-auditor' }
+  );
+
+  addCheck(
+    checks,
+    'dogfood',
+    'dogfood-test-gate',
+    scriptsText.includes('scripts/test-dogfood-runner.js') ? 'fresh' : 'stale',
+    'package.json',
+    scriptsText.includes('scripts/test-dogfood-runner.js')
+      ? 'Release gate includes dogfood runner tests.'
+      : 'Release gate does not include dogfood runner tests.',
+    { spawn: scriptsText.includes('scripts/test-dogfood-runner.js') ? null : 'god-auditor' }
+  );
+
+  for (const scenario of scenarios) {
+    addCheck(
+      checks,
+      'dogfood',
+      `dogfood-scenario-${path.basename(path.dirname(scenario))}`,
+      exists(projectRoot, scenario) ? 'fresh' : 'stale',
+      scenario,
+      exists(projectRoot, scenario)
+        ? `${scenario} exists.`
+        : `${scenario} is missing.`,
+      { spawn: exists(projectRoot, scenario) ? null : 'god-auditor' }
+    );
+  }
+
+  return checks;
+}
+
 function releasePolicyChecks(projectRoot) {
   const checks = [];
   const docs = repoDocSync.detect(projectRoot);
@@ -463,6 +520,7 @@ function detect(projectRoot) {
     ...workflowRecipeChecks(projectRoot),
     ...extensionChecks(projectRoot),
     ...suiteChecks(projectRoot),
+    ...dogfoodChecks(projectRoot),
     ...releasePolicyChecks(projectRoot),
     ...routeQualitySync.detect(projectRoot).checks,
     ...recipeCoverageSync.detect(projectRoot).checks,