godpowers 2.3.0 → 2.4.0

package/lib/code-intelligence.js

@@ -0,0 +1,161 @@
+/**
+ * Optional code intelligence capability detection.
+ *
+ * These tools sharpen refactors and reviews when present, but Godpowers must
+ * keep working through grep-backed workflows when they are absent.
+ */
+
+const cp = require('child_process');
+
+const AST_GREP_CANDIDATES = [
+  { id: 'ast-grep', command: 'ast-grep', args: ['--version'], match: /ast-grep/i },
+  { id: 'sg', command: 'sg', args: ['--version'], match: /\b(ast-grep|sg\s+\d)/i }
+];
+
+const LSP_CANDIDATES = [
+  { id: 'omo-lsp', command: 'omo-lsp', args: ['--version'], languages: ['multi'] },
+  { id: 'typescript-language-server', command: 'typescript-language-server', args: ['--version'], languages: ['javascript', 'typescript'] },
+  { id: 'vscode-json-language-server', command: 'vscode-json-language-server', args: ['--version'], languages: ['json'] },
+  { id: 'yaml-language-server', command: 'yaml-language-server', args: ['--version'], languages: ['yaml'] },
+  { id: 'pyright-langserver', command: 'pyright-langserver', args: ['--version'], languages: ['python'] },
+  { id: 'pylsp', command: 'pylsp', args: ['--version'], languages: ['python'] },
+  { id: 'gopls', command: 'gopls', args: ['version'], languages: ['go'] },
+  { id: 'rust-analyzer', command: 'rust-analyzer', args: ['--version'], languages: ['rust'] },
+  { id: 'clangd', command: 'clangd', args: ['--version'], languages: ['c', 'cpp'] },
+  { id: 'jdtls', command: 'jdtls', args: ['--version'], languages: ['java'] },
+  { id: 'ruby-lsp', command: 'ruby-lsp', args: ['--version'], languages: ['ruby'] },
+  { id: 'solargraph', command: 'solargraph', args: ['--version'], languages: ['ruby'] },
+  { id: 'terraform-ls', command: 'terraform-ls', args: ['version'], languages: ['terraform'] }
+];
+
+function firstLine(value) {
+  if (!value) return null;
+  const text = String(value).trim();
+  if (!text) return null;
+  return text.split(/\r?\n/)[0] || 'installed';
+}
+
+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 || 800
+    });
+    return firstLine(out) || 'installed';
+  } catch (err) {
+    return null;
+  }
+}
+
+function checkCandidate(candidate, opts) {
+  const version = firstLine(opts.commandVersion(candidate.command, candidate.args, {
+    cwd: opts.cwd,
+    timeout: opts.timeout
+  }));
+  if (!version) return null;
+  if (candidate.match && !candidate.match.test(version)) return null;
+  return {
+    id: candidate.id,
+    command: candidate.command,
+    version,
+    languages: candidate.languages || []
+  };
+}
+
+function detectFirst(candidates, opts) {
+  for (const candidate of candidates) {
+    const found = checkCandidate(candidate, opts);
+    if (found) return found;
+  }
+  return null;
+}
+
+function detectAll(candidates, opts) {
+  const found = [];
+  const limit = opts.maxTools || 5;
+  for (const candidate of candidates) {
+    const result = checkCandidate(candidate, opts);
+    if (result) found.push(result);
+    if (found.length >= limit) break;
+  }
+  return found;
+}
+
+function detect(projectRoot, opts = {}) {
+  const root = projectRoot || process.cwd();
+  const probe = opts.commandVersion || commandVersion;
+  const probeOpts = {
+    cwd: root,
+    commandVersion: probe,
+    timeout: opts.timeout || 800,
+    maxTools: opts.maxTools || 5
+  };
+
+  const astGrep = detectFirst(opts.astGrepCandidates || AST_GREP_CANDIDATES, probeOpts);
+  const lspTools = detectAll(opts.lspCandidates || LSP_CANDIDATES, probeOpts);
+  const gaps = [];
+  if (!astGrep) gaps.push('ast-grep not detected');
+  if (lspTools.length === 0) gaps.push('LSP tools not detected');
+
+  return {
+    level: astGrep || lspTools.length > 0 ? 'available' : 'not-detected',
+    astGrep: astGrep
+      ? { available: true, command: astGrep.command, version: astGrep.version }
+      : { available: false, command: null, version: null },
+    lsp: {
+      available: lspTools.length > 0,
+      primary: lspTools[0] || null,
+      tools: lspTools
+    },
+    gaps
+  };
+}
+
+function lspSummary(lsp) {
+  if (!lsp || !lsp.available) return 'not detected';
+  return lsp.tools.map(tool => tool.command).join(', ');
+}
+
+function summary(report) {
+  if (!report) return 'not detected';
+  const parts = [];
+  if (report.astGrep && report.astGrep.available) {
+    parts.push(`ast-grep via ${report.astGrep.command}`);
+  }
+  if (report.lsp && report.lsp.available) {
+    parts.push(`LSP via ${lspSummary(report.lsp)}`);
+  }
+  return parts.length > 0 ? parts.join('; ') : 'not detected';
+}
+
+function render(report) {
+  const ast = report && report.astGrep && report.astGrep.available
+    ? `${report.astGrep.command} (${report.astGrep.version})`
+    : 'not detected';
+  const lsp = report && report.lsp && report.lsp.available
+    ? lspSummary(report.lsp)
+    : 'not detected';
+  const gaps = report && report.gaps && report.gaps.length > 0
+    ? report.gaps.join('; ')
+    : 'none';
+  return [
+    'Code intelligence:',
+    `  Structural search: ${ast}`,
+    `  LSP tools: ${lsp}`,
+    `  Gaps: ${gaps}`
+  ].join('\n');
+}
+
+module.exports = {
+  detect,
+  summary,
+  render,
+  _private: {
+    AST_GREP_CANDIDATES,
+    LSP_CANDIDATES,
+    commandVersion,
+    firstLine
+  }
+};

package/lib/command-families.js

@@ -0,0 +1,375 @@
+/**
+ * Command family metadata.
+ *
+ * Keeps the user-facing command catalog small without removing leaf commands.
+ * These groupings are used by help, routing, docs, and UX audits.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const COMMAND_FAMILIES = [
+  {
+    id: 'start',
+    label: 'Start',
+    purpose: 'Start or import a project.',
+    commands: [
+      '/god',
+      '/god-init',
+      '/god-mode',
+      '/god-explore',
+      '/god-discuss',
+      '/god-list-assumptions',
+      '/god-prd',
+      '/god-design',
+      '/god-design-impact',
+      '/god-arch',
+      '/god-roadmap',
+      '/god-stack',
+      '/god-repo',
+      '/god-preflight',
+      '/god-map-codebase',
+      '/god-archaeology',
+      '/god-org-context',
+      '/god-migrate'
+    ]
+  },
+  {
+    id: 'continue',
+    label: 'Continue',
+    purpose: 'Understand state and choose the next move.',
+    commands: [
+      '/god-status',
+      '/god-next',
+      '/god-progress',
+      '/god-lifecycle',
+      '/god-locate',
+      '/god-resume-work',
+      '/god-pause-work'
+    ]
+  },
+  {
+    id: 'build',
+    label: 'Build',
+    purpose: 'Plan, implement, test, and ship product work.',
+    commands: [
+      '/god-build',
+      '/god-feature',
+      '/god-story',
+      '/god-stories',
+      '/god-story-build',
+      '/god-story-verify',
+      '/god-story-close',
+      '/god-fast',
+      '/god-quick',
+      '/god-debug',
+      '/god-add-tests',
+      '/god-refactor',
+      '/god-spike'
+    ]
+  },
+  {
+    id: 'verify',
+    label: 'Verify',
+    purpose: 'Check artifacts, code, runtime behavior, and release readiness.',
+    commands: [
+      '/god-lint',
+      '/god-standards',
+      '/god-review',
+      '/god-review-changes',
+      '/god-test-runtime',
+      '/god-audit',
+      '/god-agent-audit',
+      '/god-hygiene',
+      '/god-dogfood',
+      '/god-preflight'
+    ]
+  },
+  {
+    id: 'operate',
+    label: 'Operate',
+    purpose: 'Deploy, observe, harden, launch, and respond in production.',
+    commands: [
+      '/god-deploy',
+      '/god-observe',
+      '/god-harden',
+      '/god-launch',
+      '/god-hotfix',
+      '/god-postmortem',
+      '/god-logs',
+      '/god-metrics',
+      '/god-trace',
+      '/god-export-otel'
+    ]
+  },
+  {
+    id: 'maintain',
+    label: 'Maintain',
+    purpose: 'Keep artifacts, docs, dependencies, context, and repo surfaces current.',
+    commands: [
+      '/god-docs',
+      '/god-sync',
+      '/god-scan',
+      '/god-link',
+      '/god-reconcile',
+      '/god-reconstruct',
+      '/god-intel',
+      '/god-tech-debt',
+      '/god-update-deps',
+      '/god-upgrade',
+      '/god-context',
+      '/god-context-scan',
+      '/god-roadmap-check',
+      '/god-roadmap-update'
+    ]
+  },
+  {
+    id: 'capture',
+    label: 'Capture',
+    purpose: 'Save thoughts, tasks, backlog items, seeds, and learnings.',
+    commands: [
+      '/god-note',
+      '/god-add-todo',
+      '/god-check-todos',
+      '/god-add-backlog',
+      '/god-plant-seed',
+      '/god-extract-learnings',
+      '/god-thread',
+      '/god-graph'
+    ]
+  },
+  {
+    id: 'recover',
+    label: 'Recover',
+    purpose: 'Undo, repair, restore, skip, or diagnose broken state.',
+    commands: [
+      '/god-undo',
+      '/god-redo',
+      '/god-rollback',
+      '/god-restore',
+      '/god-repair',
+      '/god-skip',
+      '/god-smite',
+      '/god-doctor'
+    ]
+  },
+  {
+    id: 'extend',
+    label: 'Extend',
+    purpose: 'Install, inspect, test, remove, or author extension packs.',
+    commands: [
+      '/god-extension-scaffold',
+      '/god-extension-add',
+      '/god-extension-list',
+      '/god-extension-info',
+      '/god-extension-remove',
+      '/god-test-extension',
+      '/god-build-agent'
+    ]
+  },
+  {
+    id: 'collaborate',
+    label: 'Collaborate',
+    purpose: 'Coordinate people, workstreams, suites, sprints, and pull requests.',
+    commands: [
+      '/god-workstream',
+      '/god-suite-init',
+      '/god-suite-status',
+      '/god-suite-sync',
+      '/god-suite-patch',
+      '/god-suite-release',
+      '/god-party',
+      '/god-sprint',
+      '/god-pr-branch'
+    ]
+  },
+  {
+    id: 'configure',
+    label: 'Configure',
+    purpose: 'Tune settings, budgets, cache, profiles, help, and version info.',
+    commands: [
+      '/god-settings',
+      '/god-set-profile',
+      '/god-budget',
+      '/god-cost',
+      '/god-cache-clear',
+      '/god-automation-status',
+      '/god-automation-setup',
+      '/god-help',
+      '/god-version'
+    ]
+  }
+];
+
+const STATUS_VIEWS = [
+  { id: 'overview', command: '/god-status', label: 'Overview', purpose: 'Operational state, proactive checks, and blockers.' },
+  { id: 'progress', command: '/god-progress', label: 'Progress', purpose: 'Requirement and roadmap increment completion.' },
+  { id: 'lifecycle', command: '/god-lifecycle', label: 'Lifecycle', purpose: 'Project phase and fitting workflows.' },
+  { id: 'locate', command: '/god-locate', label: 'Locate', purpose: 'Resume orientation from checkpoint and disk state.' },
+  { id: 'next', command: '/god-next', label: 'Next', purpose: 'Single recommended command with reason.' }
+];
+
+const CAPTURE_LADDER = [
+  { id: 'note', command: '/god-note', signal: 'save only', purpose: 'Save a thought without priority or workflow impact.' },
+  { id: 'todo', command: '/god-add-todo', signal: 'actionable soon', purpose: 'Create a prioritized action item.' },
+  { id: 'backlog', command: '/god-add-backlog', signal: 'optional later', purpose: 'Park an idea for future roadmap review.' },
+  { id: 'seed', command: '/god-plant-seed', signal: 'conditional future trigger', purpose: 'Store an idea until a metric, date, or event happens.' }
+];
+
+const WORK_SIZE_LADDER = [
+  { id: 'fast', command: '/god-fast', signal: 'trivial direct edit', purpose: 'One tiny edit with existing verification.' },
+  { id: 'quick', command: '/god-quick', signal: 'small TDD task', purpose: 'Small task with TDD and review but no full planning tier.' },
+  { id: 'story', command: '/god-story', signal: 'fine-grained planned slice', purpose: 'Create a STORY.md before implementation.' },
+  { id: 'feature', command: '/god-feature', signal: 'existing-product feature', purpose: 'Feature workflow with mini-PRD, build, harden, and sync.' },
+  { id: 'build', command: '/god-build', signal: 'current milestone work', purpose: 'Build the planned roadmap increment.' },
+  { id: 'debug', command: '/god-debug', signal: 'non-urgent bug', purpose: 'Run the systematic debug loop.' },
+  { id: 'hotfix', command: '/god-hotfix', signal: 'production outage', purpose: 'Expedited production fix and postmortem trigger.' }
+];
+
+const VERIFY_LADDER = [
+  { id: 'lint', command: '/god-lint', signal: 'mechanical artifact check', purpose: 'Fast file-level artifact validation.' },
+  { id: 'standards', command: '/god-standards', signal: 'artifact quality gate', purpose: 'Substitution, labels, and have-nots for one artifact.' },
+  { id: 'review', command: '/god-review', signal: 'code diff review', purpose: 'Two-stage spec and quality review.' },
+  { id: 'runtime', command: '/god-test-runtime', signal: 'live behavior check', purpose: 'Browser-backed design and acceptance verification.' },
+  { id: 'audit', command: '/god-audit', signal: 'artifact set score', purpose: 'Score existing Godpowers artifacts.' },
+  { id: 'hygiene', command: '/god-hygiene', signal: 'ongoing project health', purpose: 'Composite audit, dependency, and docs check.' },
+  { id: 'preflight', command: '/god-preflight', signal: 'existing repo intake', purpose: 'Read-only readiness check before stronger workflows.' },
+  { id: 'dogfood', command: '/god-dogfood', signal: 'release fixture readiness', purpose: 'Messy-repo scenarios for release confidence.' }
+];
+
+const TRIGGER_PRECEDENCE = {
+  continue: {
+    default: '/god-next',
+    conditional: [
+      { command: '/god-resume-work', when: 'handoff-exists', reason: 'A handoff exists on disk.' }
+    ],
+    reason: 'Continue means resume a handoff when present, otherwise compute the next route.'
+  },
+  'think through': {
+    default: '/god-discuss',
+    conditional: [
+      { command: '/god-explore', when: 'broad-idea', reason: 'The request is broad ideation rather than a concrete decision.' }
+    ],
+    reason: 'Discussion handles concrete decisions while exploration handles broad ideation.'
+  },
+  'what happened': {
+    default: '/god-logs',
+    conditional: [
+      { command: '/god-postmortem', when: 'post-incident-pending', reason: 'The project is waiting on incident follow-up.' }
+    ],
+    reason: 'Logs answer run history unless an incident loop is open.'
+  },
+  "what's done": {
+    default: '/god-progress',
+    conditional: [
+      { command: '/god-status', when: 'operational-status-request', reason: 'The wording asks for operational state, not deliverables.' }
+    ],
+    reason: 'Progress answers deliverables while status answers operational state.'
+  },
+  'where am i': {
+    default: '/god-lifecycle',
+    conditional: [
+      { command: '/god-locate', when: 'checkpoint-or-handoff-exists', reason: 'Resume artifacts exist on disk.' }
+    ],
+    reason: 'Lifecycle explains the phase while locate orients a resumed session.'
+  }
+};
+
+function familyForCommand(command) {
+  return COMMAND_FAMILIES.find((family) => family.commands.includes(command)) || null;
+}
+
+function renderFamilyCards(families = COMMAND_FAMILIES) {
+  return families.map((family) => (
+    `${family.label}: ${family.purpose} (${family.commands.join(', ')})`
+  ));
+}
+
+function renderLadder(ladder) {
+  return ladder.map((step) => `${step.command}: ${step.signal} - ${step.purpose}`);
+}
+
+function detectCondition(condition, projectRoot, text = '') {
+  if (!condition) return false;
+  const root = projectRoot || process.cwd();
+  if (condition === 'handoff-exists') {
+    return fs.existsSync(path.join(root, '.godpowers', 'HANDOFF.md'));
+  }
+  if (condition === 'checkpoint-or-handoff-exists') {
+    return fs.existsSync(path.join(root, '.godpowers', 'CHECKPOINT.md'))
+      || fs.existsSync(path.join(root, '.godpowers', 'HANDOFF.md'));
+  }
+  if (condition === 'post-incident-pending') {
+    try {
+      const statePath = path.join(root, '.godpowers', 'state.json');
+      if (!fs.existsSync(statePath)) return false;
+      const parsed = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+      return parsed['lifecycle-phase'] === 'post-incident-pending';
+    } catch (e) {
+      return false;
+    }
+  }
+  if (condition === 'broad-idea') {
+    return /\b(idea|brainstorm|explore|what if|possibilities|options)\b/i.test(text || '');
+  }
+  if (condition === 'operational-status-request') {
+    return /\b(status|state|blocked|sync|health|where)\b/i.test(text || '');
+  }
+  return false;
+}
+
+function resolveTrigger(trigger, opts = {}) {
+  const key = String(trigger || '').trim().toLowerCase();
+  const rule = TRIGGER_PRECEDENCE[key];
+  if (!rule) return null;
+  for (const branch of rule.conditional || []) {
+    if (detectCondition(branch.when, opts.projectRoot, opts.text)) {
+      return { trigger: key, command: branch.command, reason: branch.reason, rule };
+    }
+  }
+  return { trigger: key, command: rule.default, reason: rule.reason, rule };
+}
+
+function classifyCapture(text = '') {
+  if (/\b(when|if|after|in \d+|once)\b/i.test(text)) return CAPTURE_LADDER.find((item) => item.id === 'seed');
+  if (/\b(todo|task|remind|priority|p[0-3])\b/i.test(text)) return CAPTURE_LADDER.find((item) => item.id === 'todo');
+  if (/\b(backlog|later|someday|future)\b/i.test(text)) return CAPTURE_LADDER.find((item) => item.id === 'backlog');
+  return CAPTURE_LADDER.find((item) => item.id === 'note');
+}
+
+function classifyWorkSize(text = '') {
+  if (/\b(production|outage|down|urgent|hotfix)\b/i.test(text)) return WORK_SIZE_LADDER.find((item) => item.id === 'hotfix');
+  if (/\b(bug|debug|failing|error|regression)\b/i.test(text)) return WORK_SIZE_LADDER.find((item) => item.id === 'debug');
+  if (/\b(story|acceptance criteria)\b/i.test(text)) return WORK_SIZE_LADDER.find((item) => item.id === 'story');
+  if (/\b(feature|new capability|enhancement)\b/i.test(text)) return WORK_SIZE_LADDER.find((item) => item.id === 'feature');
+  if (/\b(milestone|roadmap|increment)\b/i.test(text)) return WORK_SIZE_LADDER.find((item) => item.id === 'build');
+  if (/\b(tiny|typo|one-line|config tweak|trivial)\b/i.test(text)) return WORK_SIZE_LADDER.find((item) => item.id === 'fast');
+  return WORK_SIZE_LADDER.find((item) => item.id === 'quick');
+}
+
+function classifyVerification(text = '') {
+  if (/\b(dogfood|release readiness|fixture)\b/i.test(text)) return VERIFY_LADDER.find((item) => item.id === 'dogfood');
+  if (/\b(preflight|intake|existing repo)\b/i.test(text)) return VERIFY_LADDER.find((item) => item.id === 'preflight');
+  if (/\b(hygiene|health|weekly|monthly)\b/i.test(text)) return VERIFY_LADDER.find((item) => item.id === 'hygiene');
+  if (/\b(audit|score artifacts)\b/i.test(text)) return VERIFY_LADDER.find((item) => item.id === 'audit');
+  if (/\b(runtime|browser|e2e|flow|render|design audit)\b/i.test(text)) return VERIFY_LADDER.find((item) => item.id === 'runtime');
+  if (/\b(review|diff|code review)\b/i.test(text)) return VERIFY_LADDER.find((item) => item.id === 'review');
+  if (/\b(standard|substitution|have-nots)\b/i.test(text)) return VERIFY_LADDER.find((item) => item.id === 'standards');
+  return VERIFY_LADDER.find((item) => item.id === 'lint');
+}
+
+module.exports = {
+  COMMAND_FAMILIES,
+  STATUS_VIEWS,
+  CAPTURE_LADDER,
+  WORK_SIZE_LADDER,
+  VERIFY_LADDER,
+  TRIGGER_PRECEDENCE,
+  familyForCommand,
+  renderFamilyCards,
+  renderLadder,
+  resolveTrigger,
+  classifyCapture,
+  classifyWorkSize,
+  classifyVerification
+};

package/lib/dashboard.js

@@ -133,20 +133,43 @@ function hasRecentPath(projectRoot, relPath, maxAgeMs) {
   return Date.now() - modified <= maxAgeMs;
 }
 
-function proactiveChecks(projectRoot, changedFiles = []) {
+function isGodpowersRuntimeRepo(projectRoot) {
+  try {
+    const pkgPath = path.join(projectRoot, 'package.json');
+    if (!fs.existsSync(pkgPath)) return false;
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    return pkg.name === 'godpowers'
+      && exists(projectRoot, 'skills')
+      && exists(projectRoot, 'routing')
+      && exists(projectRoot, 'agents');
+  } catch (e) {
+    return false;
+  }
+}
+
+function proactiveChecks(projectRoot, changedFiles = [], opts = {}) {
   const oneDay = 24 * 60 * 60 * 1000;
   const thirtyDays = 30 * oneDay;
+  const initialized = opts.initialized !== false;
+  const runtimeRepo = opts.runtimeRepo !== undefined
+    ? opts.runtimeRepo
+    : isGodpowersRuntimeRepo(projectRoot);
   const reviews = reviewCount(projectRoot);
 
-  const checkpoint = exists(projectRoot, CHECKPOINT_PATH)
-    ? (hasRecentPath(projectRoot, CHECKPOINT_PATH, oneDay) ? 'fresh' : 'stale')
-    : 'missing';
+  const checkpoint = initialized
+    ? (exists(projectRoot, CHECKPOINT_PATH)
+        ? (hasRecentPath(projectRoot, CHECKPOINT_PATH, oneDay) ? 'fresh' : 'stale')
+        : 'missing')
+    : 'not-applicable';
 
-  const sync = exists(projectRoot, SYNC_LOG_PATH)
-    ? (hasRecentPath(projectRoot, SYNC_LOG_PATH, oneDay) ? 'fresh' : 'stale, suggest /god-sync')
-    : 'missing, suggest /god-sync';
+  const sync = initialized
+    ? (exists(projectRoot, SYNC_LOG_PATH)
+        ? (hasRecentPath(projectRoot, SYNC_LOG_PATH, oneDay) ? 'fresh' : 'stale, suggest /god-sync')
+        : 'missing, suggest /god-sync')
+    : 'not-applicable';
 
-  const hygieneFresh = exists(projectRoot, CHECKPOINT_PATH)
+  const hygieneFresh = initialized
+    && exists(projectRoot, CHECKPOINT_PATH)
     && hasRecentPath(projectRoot, CHECKPOINT_PATH, thirtyDays);
 
   const pkgChanged = changedFiles.some(file => [
@@ -162,14 +185,22 @@ function proactiveChecks(projectRoot, changedFiles = []) {
     'auth',
     'security'
   ]));
-  const repoDocs = repoDocSync.detect(projectRoot, { changedFiles });
-  const repoDocsStatus = repoDocs.status === 'fresh'
-    ? 'fresh'
-    : `${repoDocs.stale.length} stale, suggest /god-docs`;
-  const repoSurface = repoSurfaceSync.detect(projectRoot);
-  const repoSurfaceStatus = repoSurface.status === 'fresh'
-    ? 'fresh'
-    : `${repoSurface.stale.length} stale, suggest /god-doctor`;
+  const repoDocsStatus = runtimeRepo
+    ? (() => {
+        const repoDocs = repoDocSync.detect(projectRoot, { changedFiles });
+        return repoDocs.status === 'fresh'
+          ? 'fresh'
+          : `${repoDocs.stale.length} stale, suggest /god-docs`;
+      })()
+    : 'not-applicable';
+  const repoSurfaceStatus = runtimeRepo
+    ? (() => {
+        const repoSurface = repoSurfaceSync.detect(projectRoot);
+        return repoSurface.status === 'fresh'
+          ? 'fresh'
+          : `${repoSurface.stale.length} stale, suggest /god-doctor`;
+      })()
+    : 'not-applicable';
   const host = hostCapabilities.detect(projectRoot);
 
   return {
@@ -183,7 +214,7 @@ function proactiveChecks(projectRoot, changedFiles = []) {
     automation: automationSummary(projectRoot),
     security: sensitiveChanged ? 'sensitive files changed, suggest /god-harden' : 'clear',
     dependencies: pkgChanged ? 'dependency files changed, suggest /god-update-deps' : 'clear',
-    hygiene: hygieneFresh ? 'fresh' : 'stale, suggest /god-hygiene'
+    hygiene: initialized ? (hygieneFresh ? 'fresh' : 'stale, suggest /god-hygiene') : 'not-applicable'
   };
 }
 
@@ -237,7 +268,7 @@ function compute(projectRoot, opts = {}) {
         completion: '0% workflow progress because .godpowers/state.json is missing',
         completionBasis: 'missing .godpowers/state.json'
       },
-      proactive: proactiveChecks(projectRoot, git.entries.map(statusPath)),
+      proactive: proactiveChecks(projectRoot, git.entries.map(statusPath), { initialized: false }),
       host: hostCapabilities.detect(projectRoot, opts.host || {}),
       next,
       deliverables: { hasRequirements: false },
@@ -276,7 +307,7 @@ function compute(projectRoot, opts = {}) {
     worktree: git.worktree,
     index: git.index,
     planning: planningVisibility(projectRoot, progress),
-    proactive: proactiveChecks(projectRoot, git.entries.map(statusPath)),
+    proactive: proactiveChecks(projectRoot, git.entries.map(statusPath), { initialized: true }),
     host: hostCapabilities.detect(projectRoot, opts.host || {}),
     next,
     deliverables,
@@ -289,6 +320,7 @@ function compute(projectRoot, opts = {}) {
 function actionBrief(dashboard) {
   const proactive = dashboard.proactive || {};
   const next = dashboard.next || {};
+  const recommended = next.command || 'describe the next intent';
   const blockers = [];
   for (const [label, value] of [
     ['Repo surface', proactive.repoSurface],
@@ -304,10 +336,11 @@ function actionBrief(dashboard) {
     if (value === 'fresh' || value === 'none' || value === 'clear' || value === 'not-applicable') continue;
     if (/^full on /.test(value)) continue;
     if (/^available via /.test(value)) continue;
+    if (label === 'Sync' && recommended !== '/god-sync') continue;
+    if (label === 'Hygiene' && recommended !== '/god-hygiene') continue;
     blockers.push(`${label}: ${value}`);
   }
 
-  const recommended = next.command || 'describe the next intent';
   return {
     recommended,
     reason: next.reason || 'No route was computed.',
@@ -414,6 +447,7 @@ module.exports = {
   parseGitStatus,
   proactiveChecks,
   automationSummary,
+  isGodpowersRuntimeRepo,
   actionBrief,
   planningVisibility
 };