godpowers 1.6.11 → 1.6.12

package/CHANGELOG.md

@@ -5,6 +5,37 @@ All notable changes to Godpowers will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.6.12] - 2026-05-16
+
+Executable dashboard CLI and shared runtime status engine.
+
+### Added
+- Added `lib/dashboard.js`, a shared executable engine for project status,
+  progress percentage, tier position, planning visibility, proactive checks,
+  open items, and recommended next command.
+- Added `godpowers status --project .` for human, CI, and host-runtime status
+  checks outside the slash command layer.
+- Added `godpowers next --project .` for direct next-action routing from disk
+  state.
+- Added `--json` output for the new status and next commands.
+- Added dashboard behavioral tests, CLI status and next tests, and git
+  porcelain parsing tests.
+
+### Changed
+- `/god-status`, `/god-next`, `/god-mode`, and `god-orchestrator` now point to
+  the shared dashboard engine when local runtime execution is available.
+- The installer help now documents status and next as first-class commands.
+- Release documentation now names the executable dashboard contract instead of
+  treating progress visibility as Markdown-only guidance.
+
+### Fixed
+- Fixed git porcelain parsing so leading-space worktree entries such as
+  ` M README.md` do not clip filenames in dashboard output.
+
+### Validation
+- Added tests prove dashboard computation, dashboard rendering, CLI JSON
+  output, proactive review suggestions, and staged path reporting.
+
 ## [1.6.11] - 2026-05-16
 
 Auto-invoke visibility and platform-neutral spawning patch.

package/README.md

@@ -2,7 +2,7 @@
 
 [![CI](https://github.com/aihxp/godpowers/actions/workflows/ci.yml/badge.svg)](https://github.com/aihxp/godpowers/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
-[![Version](https://img.shields.io/badge/version-1.6.11-blue)](CHANGELOG.md)
+[![Version](https://img.shields.io/badge/version-1.6.12-blue)](CHANGELOG.md)
 [![npm](https://img.shields.io/npm/v/godpowers.svg)](https://www.npmjs.com/package/godpowers)
 
 **Ship fast. Ship right. Ship everything. Ship accountably.**
@@ -12,10 +12,10 @@ idea to hardened production. It runs as **slash commands inside your AI coding
 tool** (Claude Code, Codex, Cursor, etc.) that orchestrate **specialist agents**
 in fresh contexts to do the work.
 
-Version 1.6.11 keeps the stable Godpowers surface while making automatic work
-more visible and portable: syncs, proactive checks, and specialist spawning now
-report what ran, what changed, and which host-platform agent mechanism is being
-used.
+Version 1.6.12 adds an executable dashboard engine and CLI status surface:
+`godpowers status --project .` and `godpowers next --project .` now compute the
+same disk-derived progress, planning visibility, proactive checks, and next
+action used by `/god-status`, `/god-next`, and God Mode closeouts.
 
 It fuses four disciplines into one unified workflow:
 
@@ -109,6 +109,16 @@ This reads `.godpowers/PROGRESS.md`, scans disk, reconciles any drift, and
 suggests the next logical command. The SessionStart hook does the same thing
 when you open a new session in a Godpowers project.
 
+The same status engine is available from the installer CLI for humans, CI,
+Codex, Claude, Cursor, Gemini, OpenCode, Windsurf, Antigravity, and any host
+runtime that can execute Node:
+
+```bash
+npx godpowers status --project=.
+npx godpowers next --project=.
+npx godpowers status --project=. --json
+```
+
 ### Slash Commands
 
 | Command | What it does | Spawns agent |
@@ -179,6 +189,14 @@ Under `--yolo`, Godpowers also auto-applies Pillars sync proposals when
 durable `.godpowers` artifacts change project truth. The decision is logged to
 `.godpowers/YOLO-DECISIONS.md`.
 
+Every completing command now ends with a **Godpowers Dashboard**. It shows the
+current phase, tier, step count, percent complete, PRD and roadmap visibility,
+recent work, proactive checks, open items, and the single recommended next
+action. `/god-status` and `/god-next` use the same shape so the project never
+ends in a vague "done" state. The dashboard is backed by
+`lib/dashboard.js`, so status and next-step commands share one executable
+source of disk truth instead of parallel Markdown-only contracts.
+
 For existing codebases and org-constrained new projects, God Mode now runs a
 greenfield simulation audit and then actions it through a greenfieldification
 plan. It pauses before risky artifact rewrites because that process can change

package/RELEASE.md

@@ -1,11 +1,10 @@
-# Godpowers 1.6.11 Release
+# Godpowers 1.6.12 Release
 
 Date: 2026-05-16
 
-Godpowers 1.6.11 makes automatic work easier to trust across supported AI
-coding tools. The release keeps the existing 106 slash commands, 39 specialist
-agents, 13 workflows, and 36 recipes, while clarifying when Godpowers spawned
-an agent, called a local runtime helper, or only suggested the next action.
+Godpowers 1.6.12 turns progress visibility into executable product behavior.
+The same dashboard logic now powers slash command closeouts, direct CLI status
+checks, JSON status output, and next-action recommendations from disk state.
 
 ## What is stable
 
@@ -14,37 +13,30 @@ an agent, called a local runtime helper, or only suggested the next action.
 - 13 executable workflows
 - 36 intent recipes
 - 15-runtime installer
+- 453 package files in the npm tarball
 - Codex installs with generated `god-*.toml` agent metadata files
 - Markdown specialist agent contracts at `<runtime>/agents/god-*.md`
-- Safe-sync routing before deploy, observe, harden, launch, or god-mode work
-- Critical harden finding gate before launch
+- Shared runtime bundle at `<runtime>/godpowers-runtime`
 - Native Pillars project context through `AGENTS.md` and `agents/*.md`
 - `.godpowers/` workflow state and artifact layout
-- Core schemas: intent, state, events, workflow, routing, recipes, extension
-  manifests
-- Extension pack compatibility range for the 1.x line
+- Safe-sync routing before deploy, observe, harden, launch, or god-mode work
+- Critical harden finding gate before launch
 - GSD-style proposition closeouts for exploratory, diagnostic, audit,
   lifecycle, status, reconciliation, and decision-support outputs
 - Plain-language project-run wording in user-facing reports
-- Planning visibility blocks for PRD, roadmap, milestone, and completion basis
 
 ## What is new
 
-- The master skill now defines a proactive auto-invoke policy with four levels:
-  read-only suggestions, visible local helpers, bounded specialist agent spawns,
-  and explicit-approval-only actions.
-- `/god-next`, `/god-status`, and God Mode closeouts now include proactive
-  checks for checkpoint freshness, pending reviews, sync state, docs drift,
-  runtime verification, security, dependencies, and hygiene.
-- `/god-sync`, `/god-scan`, `god-updater`, and `god-orchestrator` now distinguish
-  spawned agents from local runtime helpers such as reverse-sync, Pillars sync,
-  checkpoint sync, and context refresh.
-- Docs drift, runtime verification, and review queue workflows now document when
-  they may be suggested or auto-invoked.
-- Spawning instructions now use platform-neutral host-agent language instead of
-  Claude-specific "Task tool" wording.
-- The installer now replaces Codex skill directories before writing `SKILL.md`,
-  which removes stale nested files from older Codex install shapes.
+- Added `lib/dashboard.js`, a shared executable status engine.
+- Added `godpowers status --project .`.
+- Added `godpowers next --project .`.
+- Added `--json` output for machine-readable status and next-step routing.
+- Dashboard output now reports current phase, tier position, percentage,
+  planning visibility, proactive checks, open items, and recommended action.
+- `/god-status`, `/god-next`, `/god-mode`, and `god-orchestrator` now reference
+  the same dashboard engine when local runtime execution is available.
+- Tests now cover dashboard computation, rendering, CLI output, review queue
+  detection, and git porcelain parsing.
 
 ## Platform behavior
 
@@ -53,9 +45,11 @@ Trae, Cline, Kilo, Antigravity, Qwen, CodeBuddy, and Pi all receive the same
 portable Markdown agent contracts. Codex also receives `god-*.toml` files as
 its registry adapter.
 
-If a host platform cannot provide a true fresh-context agent spawn, Godpowers
-must say so visibly and report the work as local runtime only or simulated in
-current context. It must not imply that a detached background agent ran.
+The dashboard engine ships in the installed runtime bundle so host tools can
+use one shared implementation instead of parallel command-specific Markdown
+contracts. If a host platform cannot provide a true fresh-context agent spawn,
+Godpowers must say so visibly and report the work as local runtime only or
+simulated in current context.
 
 ## Safety policy
 
@@ -76,14 +70,13 @@ Godpowers still must not auto-run these without explicit user intent:
 
 ## Validation
 
-Release validation should include:
+Release validation includes:
 
-- `node scripts/validate-skills.js`
-- `bash scripts/smoke.sh`
-- `node scripts/test-agent-validator.js`
-- `node scripts/test-install-smoke.js`
+- `node scripts/test-dashboard.js`
+- `npm test`
+- `npm run test:audit`
 - `node scripts/check-package-contents.js`
-- `npm run release:check`
+- `git diff --check`
 
-The `v1.6.11` git tag should point to the release commit that matches the npm
-`godpowers@1.6.11` package.
+The `v1.6.12` git tag points to the release commit that matches the npm
+`godpowers@1.6.12` package.

package/SKILL.md

@@ -112,12 +112,28 @@ that edits code or artifacts, do not stop at "complete" plus validation. End
 with a disk-derived closeout that tells the user the current state and what is
 next.
 
+Every closeout must include a **Godpowers Dashboard**. This dashboard is the
+same mental model across `/god-status`, `/god-next`, `/god-mode`, and every
+command that completes, pauses, or proposes work.
+
+When the runtime bundle is available, compute this with
+`lib/dashboard.compute(projectRoot)` and render it with
+`lib/dashboard.render(result)`. The executable dashboard engine is the shared
+source for phase, tier, step, progress, PRD and roadmap visibility, proactive
+checks, open items, and the next route. If the runtime module is unavailable,
+fall back to a manual disk scan and say `Dashboard engine: unavailable, manual
+scan used`.
+
 Use this shape:
 
 ```
+Godpowers Dashboard
+
 Current status:
   State: <complete | partial | blocked | complete with deferred item>
-  Progress: <pct>% (<done> of <total> steps complete; current step <n> of <total>) when available
+  Phase: <plain-language phase> (tier <human ordinal> of <human total>) when available
+  Step: <sub-step label> (<step n> of <total steps>) when available
+  Progress: <pct>% (<done> of <total> steps complete) when available
   Worktree: <clean | modified files unstaged | staged changes | mixed>
   Index: <untouched | staged files listed>
 
@@ -134,8 +150,18 @@ What changed:
 Validation:
   + <command>: <result>
 
+Proactive checks:
+  Checkpoint: <fresh | refreshed | missing | stale | conflicts with state.json>
+  Reviews: <none | N pending, suggest /god-review-changes>
+  Sync: <fresh | missing | stale | local helper ran | suggest /god-sync>
+  Docs: <fresh | possible drift, suggest /god-docs>
+  Runtime: <not-applicable | known URL, suggest /god-test-runtime | no known URL, defer deployed verification>
+  Security: <clear | sensitive files changed, suggest /god-harden>
+  Dependencies: <clear | dependency files changed, suggest /god-update-deps>
+  Hygiene: <fresh | stale, suggest /god-hygiene>
+
 Open items:
-  1. <deferred staging, unstaged files, pending review, or none>
+  1. <deferred staging, unstaged files, pending review, blocker, or none>
 
 Next:
   Recommended: <one concrete command or user decision>
@@ -149,6 +175,11 @@ pre-existing unrelated changes, say the index was left untouched and recommend
 a scoped review or staging command rather than implying the project is fully
 shipped.
 
+When the command only recommends work, keep the same dashboard but set
+`State: proposal` and end with the proposition block from Section 9. When the
+command pauses, set `State: blocked` or `State: paused` and make `Next` the
+one exact user decision needed to continue.
+
 ### 11. User-Facing Vocabulary
 Godpowers may use internal words such as "arc" in routing, recipes, and agent
 implementation notes. Do not require the user to decode that word in visible
@@ -158,7 +189,7 @@ Use these plain-language substitutions in user-facing responses:
 - Say "project run" or "workflow" instead of "arc".
 - Say "phase" or "current step" instead of "tier" unless the user has asked
   for tier details. If tier detail helps, say both, for example
-  "Planning, Tier 1".
+  "Planning phase, tier 2 of 4".
 - Say "current milestone" or "roadmap step" when ROADMAP.md has a matching
   milestone.
 - If you must use "arc", define it once as "the end-to-end project workflow"

package/agents/god-orchestrator.md

@@ -676,12 +676,16 @@ across all 14 categories.
 
 After Launch completes, write a transition message:
 
-```
+```text
 Godpowers project run complete.
 
+Godpowers Dashboard
+
 Current status:
   State: complete
-  Progress: <pct>% (<done> of <total> steps complete; current step <n> of <total>)
+  Phase: <plain-language phase> (tier <human ordinal> of <human total>)
+  Step: <sub-step label> (step <n> of <total steps>)
+  Progress: <pct>% (<done> of <total> steps complete)
   Worktree: <clean | modified files unstaged | staged changes | mixed>
   Index: <untouched | staged files listed>
 
@@ -737,6 +741,11 @@ Proposition:
   4. Run deployed staging: provide STAGING_APP_URL=<deployed staging origin> when needed
 ```
 
+Generate the dashboard with `lib/dashboard.compute(projectRoot)` and
+`lib/dashboard.render(result)` when the runtime bundle is available. If the
+runtime module cannot be loaded, fall back to a manual disk scan and say
+`Dashboard engine: unavailable, manual scan used`.
+
 Update PROGRESS.md status to `steady-state-active`.
 
 For focused brownfield, hotfix, refactor, or build workflows that finish without a
@@ -860,7 +869,8 @@ Show:
 - commands being run and whether they passed or failed
 - scoped file changes
 - final validation summary
-- final current status from disk, including progress, lifecycle, open items,
+- final Godpowers Dashboard from disk, including phase, tier, step, progress,
+  lifecycle, planning visibility, proactive checks, open items,
   worktree/index state, and recommended next action
 - plain-language workflow names. Say "project run" or "workflow" instead of
   unexplained "arc" in visible output
@@ -918,11 +928,11 @@ one compact card.
 
 Before starting a tier/sub-step:
 
-```
+```text
 Next step
-Progress: <pct>% (<done> of <total> steps complete; current step <n> of <total>)
-Tier: <tier-number> <tier-label>
+Phase: <plain-language phase> (tier <human ordinal> of <human total>)
 Step: <sub-step-label>
+Progress: <pct>% (<done> of <total> steps complete; step <n> of <total>)
 Why this now: <one sentence tied to disk state or the prior gate>
 What will happen:
   1. <first observable action>
@@ -933,11 +943,11 @@ Expected output: <artifact path or verification result>
 
 After a tier/sub-step completes or pauses:
 
-```
+```text
 Step result
-Progress: <pct>% (<done> of <total> steps complete; current step <n> of <total>)
-Tier: <tier-number> <tier-label>
+Phase: <plain-language phase> (tier <human ordinal> of <human total>)
 Step: <sub-step-label>
+Progress: <pct>% (<done> of <total> steps complete; step <n> of <total>)
 Result: <done | blocked | failed | skipped | imported>
 What happened:
   1. <observable action completed>

package/bin/install.js

@@ -300,6 +300,9 @@ function removeSkillEntry(skillsDir, entry) {
 function parseArgs(argv) {
   const args = argv.slice(2);
   const opts = {
+    command: null,
+    project: process.cwd(),
+    json: false,
     runtimes: [],
     global: false,
     local: false,
@@ -308,8 +311,22 @@ function parseArgs(argv) {
     uninstall: false,
   };
 
-  for (const arg of args) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
     switch (arg) {
+      case 'status':
+      case 'next':
+        opts.command = arg;
+        break;
+      case '--json':
+        opts.json = true;
+        break;
+      case '--project':
+        if (args[i + 1]) {
+          opts.project = path.resolve(args[i + 1]);
+          i++;
+        }
+        break;
       case '-g':
       case '--global':
         opts.global = true;
@@ -330,7 +347,9 @@ function parseArgs(argv) {
         opts.uninstall = true;
         break;
       default:
-        if (arg.startsWith('--') && RUNTIMES[arg.slice(2)]) {
+        if (arg.startsWith('--project=')) {
+          opts.project = path.resolve(arg.slice('--project='.length));
+        } else if (arg.startsWith('--') && RUNTIMES[arg.slice(2)]) {
           opts.runtimes.push(arg.slice(2));
         }
         break;
@@ -548,8 +567,14 @@ function uninstallForRuntime(runtimeKey, opts = {}) {
 
 function showHelp() {
   console.log(BANNER);
-  log('Usage: npx godpowers [options]\n');
+  log('Usage: npx godpowers [command] [options]\n');
+  log('Commands:');
+  log('  status               Show the Godpowers Dashboard for a project');
+  log('  next                 Show the dashboard and recommended next command');
+  log('');
   log('Options:');
+  log('  --project=<path>     Project root for status or next (default: cwd)');
+  log('  --json               Emit JSON for status or next');
   log('  -g, --global         Install globally (to config directory)');
   log('  -l, --local          Install locally (to current directory)');
   log('  --claude             Install for Claude Code');
@@ -572,11 +597,28 @@ function showHelp() {
   log('  -h, --help           Show this help message');
   log('');
   log('Examples:');
+  log('  npx godpowers status --project=.');
+  log('  npx godpowers next --project=.');
   log('  npx godpowers --claude --global');
   log('  npx godpowers --all');
   log('  npx godpowers --codex --cursor');
 }
 
+function runDashboardCommand(opts) {
+  const dashboard = require('../lib/dashboard');
+  const result = dashboard.compute(opts.project);
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(dashboard.render(result));
+    if (opts.command === 'next') {
+      console.log('');
+      console.log('Suggested next command:');
+      console.log(`  ${result.next && result.next.command ? result.next.command : 'describe the next intent'}`);
+    }
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Main
 // ---------------------------------------------------------------------------
@@ -589,6 +631,11 @@ function main() {
     process.exit(0);
   }
 
+  if (opts.command === 'status' || opts.command === 'next') {
+    runDashboardCommand(opts);
+    return;
+  }
+
   console.log(BANNER);
 
   const srcDir = path.resolve(__dirname, '..');

package/lib/dashboard.js

@@ -0,0 +1,296 @@
+/**
+ * Godpowers Dashboard
+ *
+ * Shared executable status engine for /god-status, /god-next, /god-sync,
+ * /god-scan, and /god-mode closeouts. Disk state is authoritative.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const cp = require('child_process');
+
+const state = require('./state');
+const router = require('./router');
+
+const GOD_DIR = '.godpowers';
+const PRD_PATH = '.godpowers/prd/PRD.md';
+const ROADMAP_PATH = '.godpowers/roadmap/ROADMAP.md';
+const CHECKPOINT_PATH = '.godpowers/CHECKPOINT.md';
+const SYNC_LOG_PATH = '.godpowers/SYNC-LOG.md';
+const REVIEW_PATH = '.godpowers/REVIEW-REQUIRED.md';
+
+function exists(projectRoot, relPath) {
+  return fs.existsSync(path.join(projectRoot, relPath));
+}
+
+function readText(projectRoot, relPath) {
+  const file = path.join(projectRoot, relPath);
+  if (!fs.existsSync(file)) return '';
+  return fs.readFileSync(file, 'utf8');
+}
+
+function mtimeMs(projectRoot, relPath) {
+  const file = path.join(projectRoot, relPath);
+  if (!fs.existsSync(file)) return null;
+  return fs.statSync(file).mtimeMs;
+}
+
+function artifactStatus(projectRoot, relPath) {
+  return exists(projectRoot, relPath) ? 'done' : 'missing';
+}
+
+function currentPhase(progress) {
+  const current = progress && progress.current;
+  if (!current) {
+    return {
+      phase: 'Complete',
+      tierKey: null,
+      tierNumber: null,
+      tierTotal: 0,
+      tierOrdinal: 0,
+      tierCount: 0,
+      tierLabel: 'Complete',
+      stepLabel: 'Complete',
+      stepNumber: 0,
+      totalSteps: progress ? progress.total : 0
+    };
+  }
+
+  const tierNumbers = (progress.tiers || [])
+    .map(tier => tier.tierNumber)
+    .filter(n => Number.isFinite(n))
+    .sort((a, b) => a - b);
+  const tierTotal = tierNumbers.length > 0 ? Math.max(...tierNumbers) : current.tierNumber;
+  const tierOrdinal = tierNumbers.indexOf(current.tierNumber) + 1;
+  const tierCount = tierNumbers.length || (Number.isFinite(current.tierNumber) ? current.tierNumber + 1 : 0);
+
+  return {
+    phase: current.tierLabel,
+    tierKey: current.tierKey,
+    tierNumber: current.tierNumber,
+    tierTotal,
+    tierOrdinal: tierOrdinal > 0 ? tierOrdinal : 1,
+    tierCount,
+    tierLabel: current.tierLabel,
+    stepLabel: current.subStepLabel,
+    stepNumber: current.ordinal,
+    totalSteps: progress.total
+  };
+}
+
+function worktree(projectRoot) {
+  try {
+    const out = cp.execFileSync('git', ['status', '--porcelain'], {
+      cwd: projectRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore']
+    });
+    return parseGitStatus(out);
+  } catch (e) {
+    return { worktree: 'unknown', index: 'unknown', entries: [] };
+  }
+}
+
+function parseGitStatus(out) {
+  if (!out || !out.trim()) {
+    return { worktree: 'clean', index: 'untouched', entries: [] };
+  }
+  const entries = out.split(/\r?\n/).filter(Boolean);
+  const staged = entries.filter(line => line[0] !== ' ' && line[0] !== '?');
+  const unstaged = entries.filter(line => line[1] !== ' ' || line.startsWith('??'));
+  let worktreeState = 'modified files unstaged';
+  if (staged.length > 0 && unstaged.length > 0) worktreeState = 'mixed';
+  else if (staged.length > 0) worktreeState = 'staged changes';
+  return {
+    worktree: worktreeState,
+    index: staged.length > 0 ? staged.map(statusPath).join(', ') : 'untouched',
+    entries
+  };
+}
+
+function statusPath(line) {
+  if (line.startsWith('?? ')) return line.slice(3);
+  return line.length > 3 ? line.slice(3) : line.trim();
+}
+
+function reviewCount(projectRoot) {
+  const text = readText(projectRoot, REVIEW_PATH);
+  if (!text.trim()) return 0;
+  const unchecked = (text.match(/\[\s\]\s*(?:TODO|PENDING|OPEN|REVIEW|BLOCKER|[Pp][0-3])/g) || []).length;
+  if (unchecked > 0) return unchecked;
+  const headings = (text.match(/^###\s+/gm) || []).length;
+  return headings;
+}
+
+function hasRecentPath(projectRoot, relPath, maxAgeMs) {
+  const modified = mtimeMs(projectRoot, relPath);
+  if (!modified) return false;
+  return Date.now() - modified <= maxAgeMs;
+}
+
+function proactiveChecks(projectRoot, changedFiles = []) {
+  const oneDay = 24 * 60 * 60 * 1000;
+  const thirtyDays = 30 * oneDay;
+  const reviews = reviewCount(projectRoot);
+
+  const checkpoint = exists(projectRoot, CHECKPOINT_PATH)
+    ? (hasRecentPath(projectRoot, CHECKPOINT_PATH, oneDay) ? 'fresh' : 'stale')
+    : 'missing';
+
+  const sync = exists(projectRoot, SYNC_LOG_PATH)
+    ? (hasRecentPath(projectRoot, SYNC_LOG_PATH, oneDay) ? 'fresh' : 'stale, suggest /god-sync')
+    : 'missing, suggest /god-sync';
+
+  const hygieneFresh = exists(projectRoot, CHECKPOINT_PATH)
+    && hasRecentPath(projectRoot, CHECKPOINT_PATH, thirtyDays);
+
+  const pkgChanged = changedFiles.some(file => [
+    'package.json',
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'yarn.lock'
+  ].includes(file));
+  const sensitiveChanged = changedFiles.some(file => matchesAnyPrefix(file, [
+    '.env.example',
+    'SECURITY.md',
+    '.github/workflows',
+    'auth',
+    'security'
+  ]));
+
+  return {
+    checkpoint,
+    reviews: reviews > 0 ? `${reviews} pending, suggest /god-review-changes` : 'none',
+    sync,
+    docs: 'fresh',
+    runtime: 'not-applicable',
+    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'
+  };
+}
+
+function matchesAnyPrefix(file, prefixes) {
+  return prefixes.some(prefix => file === prefix || file.startsWith(`${prefix}/`));
+}
+
+function planningVisibility(projectRoot, progress) {
+  const prd = artifactStatus(projectRoot, PRD_PATH);
+  const roadmap = artifactStatus(projectRoot, ROADMAP_PATH);
+  const phase = currentPhase(progress);
+  return {
+    prd: { status: prd, path: prd === 'done' ? PRD_PATH : null },
+    roadmap: { status: roadmap, path: roadmap === 'done' ? ROADMAP_PATH : null },
+    currentMilestone: phase.stepLabel ? `${phase.phase} / ${phase.stepLabel}` : phase.phase,
+    completion: `${progress.percent}% based on state.json tracked steps`
+  };
+}
+
+function compute(projectRoot, opts = {}) {
+  const s = state.read(projectRoot);
+  const git = opts.git === false ? { worktree: 'not-checked', index: 'not-checked', entries: [] } : worktree(projectRoot);
+
+  if (!s) {
+    const next = { command: '/god-init', reason: 'No Godpowers project initialized' };
+    return {
+      state: 'not initialized',
+      mode: null,
+      lifecycle: 'pre-init',
+      progress: { percent: 0, completed: 0, total: 0, currentStep: 0, current: null, tiers: [] },
+      current: currentPhase(null),
+      worktree: git.worktree,
+      index: git.index,
+      planning: {
+        prd: { status: 'missing', path: null },
+        roadmap: { status: 'missing', path: null },
+        currentMilestone: 'Project initialization',
+        completion: '0% based on missing state.json'
+      },
+      proactive: proactiveChecks(projectRoot, git.entries.map(statusPath)),
+      next,
+      openItems: ['No .godpowers/state.json found']
+    };
+  }
+
+  const progress = state.progressSummary(s);
+  const current = currentPhase(progress);
+  const next = router.suggestNext(projectRoot);
+  const openItems = [];
+  const drift = state.detectDrift(projectRoot);
+
+  if (drift.length > 0) openItems.push(`${drift.length} artifact drift item(s), suggest /god-repair`);
+  if (next && next.blocker) openItems.push(`${next.blocker} blocks next route`);
+  if (reviewCount(projectRoot) > 0) openItems.push('pending review items');
+  if (openItems.length === 0) openItems.push('none');
+
+  return {
+    state: progress.remaining === 0 ? 'complete' : 'in progress',
+    mode: s.mode || s['mode-announced-as'] || null,
+    lifecycle: s['lifecycle-phase'] || 'in-arc',
+    progress,
+    current,
+    worktree: git.worktree,
+    index: git.index,
+    planning: planningVisibility(projectRoot, progress),
+    proactive: proactiveChecks(projectRoot, git.entries.map(statusPath)),
+    next,
+    openItems
+  };
+}
+
+function render(dashboard) {
+  const current = dashboard.current || {};
+  const planning = dashboard.planning || {};
+  const proactive = dashboard.proactive || {};
+  const next = dashboard.next || {};
+  const progress = dashboard.progress || {};
+  const prd = planning.prd || {};
+  const roadmap = planning.roadmap || {};
+  const openItems = dashboard.openItems && dashboard.openItems.length > 0
+    ? dashboard.openItems
+    : ['none'];
+
+  return [
+    'Godpowers Dashboard',
+    '',
+    'Current status:',
+    `  State: ${dashboard.state}`,
+    `  Phase: ${current.phase || 'unknown'}${current.tierNumber !== null && current.tierNumber !== undefined ? ` (tier ${current.tierOrdinal} of ${current.tierCount}, internal ${current.tierKey || `tier-${current.tierNumber}`})` : ''}`,
+    `  Step: ${current.stepLabel || 'unknown'}${current.stepNumber ? ` (step ${current.stepNumber} of ${current.totalSteps})` : ''}`,
+    `  Progress: ${progress.percent || 0}% (${progress.completed || 0} of ${progress.total || 0} steps complete)`,
+    `  Worktree: ${dashboard.worktree}`,
+    `  Index: ${dashboard.index}`,
+    '',
+    'Planning visibility:',
+    `  PRD: ${prd.status || 'missing'}${prd.path ? ` ${prd.path}` : ''}`,
+    `  Roadmap: ${roadmap.status || 'missing'}${roadmap.path ? ` ${roadmap.path}` : ''}`,
+    `  Current milestone: ${planning.currentMilestone || 'unknown'}`,
+    `  Completion: ${planning.completion || 'unknown'}`,
+    '',
+    'Proactive checks:',
+    `  Checkpoint: ${proactive.checkpoint || 'unknown'}`,
+    `  Reviews: ${proactive.reviews || 'unknown'}`,
+    `  Sync: ${proactive.sync || 'unknown'}`,
+    `  Docs: ${proactive.docs || 'unknown'}`,
+    `  Runtime: ${proactive.runtime || 'unknown'}`,
+    `  Security: ${proactive.security || 'unknown'}`,
+    `  Dependencies: ${proactive.dependencies || 'unknown'}`,
+    `  Hygiene: ${proactive.hygiene || 'unknown'}`,
+    '',
+    'Open items:',
+    ...openItems.map((item, index) => `  ${index + 1}. ${item}`),
+    '',
+    'Next:',
+    `  Recommended: ${next.command || 'describe the next intent'}`,
+    `  Why: ${next.reason || 'No route was computed.'}`
+  ].join('\n');
+}
+
+module.exports = {
+  compute,
+  render,
+  worktree,
+  parseGitStatus,
+  proactiveChecks,
+  planningVisibility
+};

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "godpowers",
-  "version": "1.6.11",
+  "version": "1.6.12",
   "description": "AI-powered development system: 106 slash commands and 39 specialist agents that take a project from raw idea to hardened production. Runs inside Claude Code, Codex, Cursor, Windsurf, Gemini, and 10+ other AI coding tools.",
   "bin": {
     "godpowers": "./bin/install.js"
   },
   "scripts": {
-    "test": "node scripts/validate-skills.js && node scripts/test-doc-surface-counts.js && bash scripts/smoke.sh && node scripts/test-runtime.js && node scripts/test-router.js && node scripts/test-recipes.js && node scripts/test-context-writer.js && node scripts/test-pillars.js && node scripts/test-artifact-linter.js && node scripts/test-artifact-diff.js && node scripts/test-design-foundation.js && node scripts/test-linkage.js && node scripts/test-impact.js && node scripts/test-reverse-sync.js && node scripts/test-integration.js && node scripts/test-cross-artifact.js && node scripts/test-awesome-design.js && node scripts/test-skillui-bridge.js && node scripts/test-runtime-verification.js && node scripts/test-agent-browser.js && node scripts/test-mode-d.js && node scripts/test-runtime-heuristics.js && node scripts/test-agent-validator.js && node scripts/test-story-validator.js && node scripts/test-state.js && node scripts/test-intent.js && node scripts/test-events.js && node scripts/test-golden-artifacts.js && node scripts/test-install-smoke.js && node scripts/test-checkpoint.js && node scripts/test-extensions.js && node scripts/test-event-reader.js && node scripts/test-state-lock.js && node scripts/test-cost-saver.js && node scripts/test-budget-onoff.js && node scripts/test-workflow-runner.js && npm run test:e2e && node scripts/test-otel-exporter.js && node scripts/test-extensions-publish.js",
+    "test": "node scripts/validate-skills.js && node scripts/test-doc-surface-counts.js && bash scripts/smoke.sh && node scripts/test-runtime.js && node scripts/test-router.js && node scripts/test-recipes.js && node scripts/test-context-writer.js && node scripts/test-pillars.js && node scripts/test-artifact-linter.js && node scripts/test-artifact-diff.js && node scripts/test-design-foundation.js && node scripts/test-linkage.js && node scripts/test-impact.js && node scripts/test-reverse-sync.js && node scripts/test-integration.js && node scripts/test-cross-artifact.js && node scripts/test-awesome-design.js && node scripts/test-skillui-bridge.js && node scripts/test-runtime-verification.js && node scripts/test-agent-browser.js && node scripts/test-mode-d.js && node scripts/test-runtime-heuristics.js && node scripts/test-agent-validator.js && node scripts/test-story-validator.js && node scripts/test-state.js && node scripts/test-dashboard.js && node scripts/test-intent.js && node scripts/test-events.js && node scripts/test-golden-artifacts.js && node scripts/test-install-smoke.js && node scripts/test-checkpoint.js && node scripts/test-extensions.js && node scripts/test-event-reader.js && node scripts/test-state-lock.js && node scripts/test-cost-saver.js && node scripts/test-budget-onoff.js && node scripts/test-workflow-runner.js && npm run test:e2e && node scripts/test-otel-exporter.js && node scripts/test-extensions-publish.js",
     "prepublishOnly": "npm test",
     "validate-skills": "node scripts/validate-skills.js",
     "test:surface": "node scripts/test-doc-surface-counts.js",

package/skills/god-mode.md

@@ -178,8 +178,9 @@ Show:
 - short progress updates for phases, commands, validations, and file edits
 - concise validation summaries instead of full command noise when possible
 - final changed paths, validation results, and completion or pause status
-- final current status, open items, worktree/index state, and recommended next
-  action
+- final Godpowers Dashboard from disk, including phase, tier, step, progress,
+  planning visibility, proactive checks, open items, worktree/index state, and
+  recommended next action
 
 Hide:
 - raw spawn input
@@ -202,11 +203,11 @@ missing them, synthesize them from disk state before continuing.
 
 Before work starts:
 
-```
+```text
 Next step
-Progress: <pct>% (<done> of <total> steps complete; current step <n> of <total>)
-Tier: <tier-number> <tier-label>
+Phase: <plain-language phase> (tier <human ordinal> of <human total>)
 Step: <sub-step-label>
+Progress: <pct>% (<done> of <total> steps complete; step <n> of <total>)
 Why this now: <one sentence>
 What will happen:
   1. <observable action>
@@ -216,11 +217,11 @@ Expected output: <artifact path or verification result>
 
 After work completes or pauses:
 
-```
+```text
 Step result
-Progress: <pct>% (<done> of <total> steps complete; current step <n> of <total>)
-Tier: <tier-number> <tier-label>
+Phase: <plain-language phase> (tier <human ordinal> of <human total>)
 Step: <sub-step-label>
+Progress: <pct>% (<done> of <total> steps complete; step <n> of <total>)
 Result: <done | blocked | failed | skipped | imported>
 What happened:
   1. <observable action completed>

package/skills/god-next.md

@@ -22,6 +22,9 @@ Before reading routing data or calling runtime modules, resolve the Godpowers ru
 1. If `<projectRoot>/lib/router.js` exists, use the repository checkout runtime at `<projectRoot>`.
 2. Otherwise use the installed bundle at `<tool-config-dir>/godpowers-runtime`, where `<tool-config-dir>` is the directory that contains this installed skill, such as `~/.claude`, `~/.codex`, `~/.cursor`, `~/.windsurf`, or `~/.gemini`.
 3. Read routing definitions from `<runtimeRoot>/routing/*.yaml` and recipes from `<runtimeRoot>/routing/recipes/*.yaml`.
+4. For status output, load `<runtimeRoot>/lib/dashboard.js` and call
+   `dashboard.compute(projectRoot)`. Use `dashboard.render(result)` for the
+   shared dashboard section before adding route-specific detail.
 
 ## Three modes of invocation
 
@@ -333,11 +336,31 @@ recommending archaeology, reconstruction, project-run readiness, pillars, or ref
 
 ## Output Format
 
-```
+`/god-next` must emit the same Godpowers Dashboard shape used by
+`/god-status`, then add routing detail and the proposition block.
+Prefer the executable `lib/dashboard.js` output over manually recomputing the
+same fields. If the module is unavailable, say
+`Dashboard engine: unavailable, manual scan used`.
+
+```text
 Godpowers Next
 
-Current state: [where we are]
-Progress: [pct]% ([done] of [total] steps complete; current step [n] of [total])
+Godpowers Dashboard
+
+Current status:
+  State: proposal
+  Phase: [plain-language phase] (tier [human ordinal] of [human total])
+  Step: [current step label] (step [n] of [total steps])
+  Progress: [pct]% ([done] of [total] steps complete)
+  Worktree: [clean | modified files unstaged | staged changes | mixed]
+  Index: [untouched | staged files listed]
+
+Planning visibility:
+  PRD: [done | pending | missing | deferred] [path when present]
+  Roadmap: [done | pending | missing | deferred] [path when present]
+  Current milestone: [roadmap milestone, phase, tier, or next planning gate]
+  Completion: [pct]% [basis from state.json, PROGRESS.md, or artifacts]
+
 Suggested next: [/god-X]
 
 Why: [one-line reason]
@@ -359,14 +382,21 @@ Previous tier had standards failures. Address before proceeding:
 Suggested: /god-redo [tier] OR /god-skip [tier] --reason="..."
 
 Proactive checks:
-  Checkpoint: [fresh | refreshed | stale]
-  Reviews: [none | N pending]
-  Sync: [fresh | suggested | local helper ran]
-  Docs: [fresh | suggested]
-  Runtime: [not-applicable | suggested | ran]
-  Security: [clear | suggested]
-  Dependencies: [clear | suggested]
-  Hygiene: [fresh | suggested]
+  Checkpoint: [fresh | refreshed | missing | stale]
+  Reviews: [none | N pending, suggest /god-review-changes]
+  Sync: [fresh | missing | stale | local helper ran | suggest /god-sync]
+  Docs: [fresh | possible drift, suggest /god-docs]
+  Runtime: [not-applicable | known URL, suggest /god-test-runtime | no known URL, defer deployed verification]
+  Security: [clear | sensitive files changed, suggest /god-harden]
+  Dependencies: [clear | dependency files changed, suggest /god-update-deps]
+  Hygiene: [fresh | stale, suggest /god-hygiene]
+
+Open items:
+  1. [missing prerequisite, blocker, pending review, or none]
+
+Next:
+  Recommended: [/god-X or exact user decision]
+  Why: [one sentence tied to disk state]
 ```
 
 ## Proposition Closeout

package/skills/god-status.md

@@ -15,8 +15,12 @@ Re-derive state from disk. Your memory is not authoritative. The file system is.
 
 1. Check if `.godpowers/PROGRESS.md` exists
    - If not: "No Godpowers project found. Run `god init` to start."
-2. Read PROGRESS.md for recorded state
-3. Scan ALL artifact paths on disk:
+2. Resolve the runtime root and load `<runtimeRoot>/lib/dashboard.js`.
+3. Call `dashboard.compute(projectRoot)` and use the returned object as the
+   primary dashboard source.
+4. Read PROGRESS.md for recorded state when state.json is missing or when you
+   need to explain legacy progress.
+5. Scan ALL artifact paths on disk:
    - `.godpowers/prd/PRD.md`
    - `.godpowers/arch/ARCH.md`
    - `.godpowers/roadmap/ROADMAP.md`
@@ -29,12 +33,13 @@ Re-derive state from disk. Your memory is not authoritative. The file system is.
    - `.godpowers/harden/FINDINGS.md`
    - `.godpowers/SYNC-LOG.md`
    - `.godpowers/CHECKPOINT.md`
-4. For each artifact found: run a lightweight have-nots check
-5. Compare disk state to PROGRESS.md state:
+6. For each artifact found: run a lightweight have-nots check
+7. Compare disk state to PROGRESS.md state:
    - If PROGRESS.md says "done" but artifact is missing: FLAG as phantom resume
    - If artifact exists but PROGRESS.md says "pending": FLAG as untracked work
-6. Report:
+8. Report the Godpowers Dashboard from `dashboard.render(result)`:
    - Current mode and scale
+   - Current phase, tier number, step label, and step number
    - Progress summary: percentage, completed step count, current step number
    - Planning visibility: PRD status, roadmap status, active milestone, and
      completion basis
@@ -45,17 +50,26 @@ Re-derive state from disk. Your memory is not authoritative. The file system is.
    - Per-tier status (with disk verification)
    - Any inconsistencies between PROGRESS.md and disk
    - Suggested next action
-7. If inconsistencies found: offer to repair PROGRESS.md to match disk truth
+9. If inconsistencies found: offer to repair PROGRESS.md to match disk truth
+
+If the runtime module is unavailable, fall back to the manual scan below and
+say `Dashboard engine: unavailable, manual scan used`.
 
 ## Output Format
 
-```
-Godpowers Status
+```text
+Godpowers Dashboard
 
 Mode: A (greenfield)    Scale: medium
 Started: 2026-05-09
-Progress: 15% (2 of 13 steps complete; current step 3 of 13)
-Current: Tier 1 Planning / Architecture
+
+Current status:
+  State: in progress
+  Phase: Planning (tier 2 of 4, internal tier-1)
+  Step: Architecture (step 3 of 13)
+  Progress: 15% (2 of 13 steps complete)
+  Worktree: clean
+  Index: untouched
 
 Planning visibility:
   PRD: done .godpowers/prd/PRD.md
@@ -121,7 +135,12 @@ Suite (Mode D) status:
   This repo is a sibling of suite "my-products" (hub: ../hub)
   Run /god-suite-status to see all 3 repos and meta-linter findings.
 
-Next: god roadmap
+Open items:
+  1. Roadmap and stack are still pending
+
+Next:
+  Recommended: /god-roadmap
+  Why: architecture is done and the roadmap is the next planning gate.
 ```
 
 ## Proposition Closeout