bigpowers 2.0.0 → 2.1.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [2.1.0](https://github.com/danielvm-git/bigpowers/compare/v2.0.1...v2.1.0) (2026-06-11)
+
+
+### Features
+
+* **dashboard/tui:** render blessed tags and improve layout ([fba0e49](https://github.com/danielvm-git/bigpowers/commit/fba0e4918a4d99c94c30e595378565263d72734d))
+
+## [2.0.1](https://github.com/danielvm-git/bigpowers/compare/v2.0.0...v2.0.1) (2026-06-11)
+
+
+### Bug Fixes
+
+* **dashboard/tui:** render blessed tags and improve layout ([ca3a161](https://github.com/danielvm-git/bigpowers/commit/ca3a1617a341d05dacf3b571abf58cb6c0cfceeb))
+
 # [2.0.0](https://github.com/danielvm-git/bigpowers/compare/v1.5.1...v2.0.0) (2026-06-11)
 
 

package/CONVENTIONS.md

@@ -49,13 +49,29 @@ Every skill that produces written output writes to `specs/` at the project root.
 
 | Layer | File | Answers |
 |-------|------|---------|
-| Session | `specs/state.yaml` | Active flow, epic/bug, ship-epic step, git |
-| Release index | `specs/release-plan.yaml` | Target semver, WSJF epic list, pointers to `epics/` |
+| Session | `specs/state.yaml` | Active flow, epic/bug, ship-epic step, git, `handoff.next_skill`, `metrics.story_start` |
+| Release index | `specs/release-plan.yaml` | Target semver, WSJF epic list, BCP baseline per story |
 | Progress | `specs/execution-status.yaml` | Flat status keys (`e01`, `e01s01`) — sole SoT for story state |
+| Cycle-time ledger | `specs/metrics/cycle-times.yaml` | Per-story: BCPs, start, end, cycle minutes, BCP/hr **(v2.0.0)** |
 | Planning UI | `specs/planning-status.yaml` | Discover-phase workflow checklist (optional) |
 
 **Do not** put story status in `release-plan.yaml`. **Do not** duplicate the release plan inside `state.yaml`.
 
+### BCP accounting mandate (v2.0.0)
+
+Every task written by `plan-work` MUST be labeled `[BCP N]` where N is the estimated Build Commit Points for that task. The story total is summed and written to `state.yaml` as `epic_cycle.story_bcps`. The BCP baseline for each story MUST appear in `specs/release-plan.yaml` before implementation begins. `release-branch` automatically appends a row to `specs/metrics/cycle-times.yaml` with the final BCP/hr after the story lands.
+
+### Timestamp mandate (v2.0.0)
+
+- `survey-context` MUST write `metrics.story_start` (ISO 8601) to `specs/state.yaml` at the start of every story.
+- `release-branch` MUST write `metrics.story_end`, `metrics.cycle_minutes`, and `metrics.bcp_per_hour` to `specs/state.yaml` and append a row to `specs/metrics/cycle-times.yaml` when the story lands.
+
+Missing timestamps are a gate violation — do not advance past `release-branch` without them.
+
+### next_skill signaling mandate (v2.0.0)
+
+Every critical-path skill (survey-context, plan-work, kickoff-branch, develop-tdd, verify-work, audit-code, commit-message, release-branch) MUST write `handoff.next_skill` to `specs/state.yaml` as its last action. Agents MUST read `state.yaml` and follow `handoff.next_skill` before asking "what comes next?".
+
 ### Intent vs delivery vs execution
 
 | Question | File | Format |

package/README.md

@@ -8,7 +8,7 @@
 
 `bigpowers` provides a prescriptive, vertical-slice methodology for building software with AI agents (Claude Code, Gemini CLI, Cursor). It bridges the gap between raw LLM capabilities and professional engineering standards.
 
-Published on npm: [bigpowers@1.0.0](https://www.npmjs.com/package/bigpowers)
+Published on npm: [bigpowers@2.0.0](https://www.npmjs.com/package/bigpowers)
 
 ---
 
@@ -96,16 +96,39 @@ bigpowers
 
 ---
 
-## 🏗 The BMAD Lifecycle
+## 🏗 The v2.0.0 Lifecycle
 
-Every task in `bigpowers` follows a prescriptive lifecycle (see `SKILL-INDEX.md`):
+Every project follows the **orchestrate-project 6-phase model** (full SOP: [`docs/WORKFLOW-SOP-v2.md`](docs/WORKFLOW-SOP-v2.md)):
 
-1.  **Discover**: survey-context, research-first, elaborate-spec.
-2.  **Elaborate / Plan**: scope-work, plan-work, slice-tasks.
-3.  **Build**: develop-tdd, execute-plan.
-4.  **Verify**: verify-work, run-evals — prove it works before review.
-5.  **Review / Release**: audit-code, request-review, release-branch.
-6.  **Sustain**: stocktake-skills, evolve-skill (benchmark-gated).
+```
+ONE TIME    seed-conventions  (CLAUDE.md, .claude/, .gemini/, agents/, skill sync)
+              ↓
+ONCE/PROJECT orchestrate-project
+              │
+              ├─ Ph1 DISCOVER   survey-context, research-first, elaborate-spec
+              ├─ Ph2 ELABORATE  model-domain, grill-me, define-language, deepen-architecture
+              ├─ Ph3 PLAN       scope-work, slice-tasks, plan-work → release-plan.yaml (BCP baseline)
+              ├─ Ph4 BUILD      build-epic × N stories
+              │
+              │  Per story — 8-step build-epic cycle:
+              │   1. survey-context   ← stamps story_start in state.yaml
+              │   2. plan-work        ← [BCP N] tasks + verify: commands
+              │   3. kickoff-branch   ← worktree + feature branch
+              │   4. develop-tdd      ← RED → GREEN → REFACTOR
+              │   5. verify-work      ← UAT gate
+              │   6. audit-code       ← quality gate ≥ 94%
+              │   7. commit-message   ← Conventional Commits + semver
+              │   8. release-branch   ← land to main; writes story_end + cycle-times.yaml
+              │
+              ├─ Ph5 VERIFY     run-evals, verify-work (project-level)
+              └─ Ph6 RELEASE    semantic-release → v1.0.0 MVP tag
+```
+
+**Semver:** projects start at `0.0.0-β`; each `feat:` story → minor bump; developer declares MVP → `1.0.0`.
+
+**BCP accounting:** every task labeled `[BCP N]`; story total in `state.yaml`; BCP/hr logged to `specs/metrics/cycle-times.yaml`.
+
+**next_skill signaling:** each critical-path skill writes `handoff.next_skill` to `state.yaml`. Call `survey-context` after any interruption to resume exactly where you left off.
 
 ---
 
@@ -118,8 +141,9 @@ Every task in `bigpowers` follows a prescriptive lifecycle (see `SKILL-INDEX.md`
 | **Scope** | `specs/requirements/SCOPE_LATEST.yaml` | In-scope / out-of-scope and success criteria. |
 | **Vision** | `specs/requirements/VISION_LATEST.yaml` | North star and initiative success criteria. |
 | **Decisions** | `specs/adr/` | Architectural Decision Records (irreversible choices). |
-| **Roadmap** | `specs/release-plan.yaml` + `specs/epics/` | WSJF-prioritized epics and stories. |
-| **Current** | `specs/state.yaml` | Session flow, active epic, handoff. |
+| **Roadmap** | `specs/release-plan.yaml` + `specs/epics/` | WSJF-prioritized epics and stories with BCP baseline. |
+| **Current** | `specs/state.yaml` | Session flow, active epic, `handoff.next_skill`, timestamps. |
+| **Metrics** | `specs/metrics/cycle-times.yaml` | Per-story BCPs, cycle minutes, BCP/hr (v2.0.0). |
 | **Index** | `SKILL-INDEX.md` | Canonical list of all active skills. |
 | **Style** | `CONVENTIONS.md` | Coding, testing, and naming standards. |
 
@@ -128,8 +152,10 @@ Every task in `bigpowers` follows a prescriptive lifecycle (see `SKILL-INDEX.md`
 ## 📁 Project Structure
 
 - `scripts/`: Installation, syncing, and compliance tools.
-- `specs/`: The "Brain" of your project — all planning and decisions live here (YAML cockpit: `state.yaml`, `release-plan.yaml`, `epics/`, `requirements/`).
-- `specs/wiki/`: Deprecated Obsidian layer — use `visual-dashboard` HTTP cockpit instead of `maintain-wiki`.
+- `specs/`: YAML cockpit — `state.yaml`, `release-plan.yaml`, `epics/`, `execution-status.yaml`, `requirements/`.
+- `specs/metrics/`: Cycle-time ledger (`cycle-times.yaml`) — per-story BCPs, timestamps, BCP/hr (v2.0.0).
+- `dashboard/`: Live monitoring tool — TUI (`npm run dashboard`) and web (`npm run dashboard:web`, port 7742).
+- `docs/`: Guides including `WORKFLOW-SOP-v2.md` (full SDLC SOP) and `using-bigpowers.md`.
 - `docs/references/`: Theoretical foundations (Uncle Bob, Ousterhout, Karpathy, etc.).
 - `[skill-name]/`: Source files for each of the 61 skills.
 

package/RELEASE.md

@@ -48,12 +48,27 @@ npm view bigpowers
 # GitHub → Releases
 ```
 
+## Per-Project Semver Convention (v2.0.0)
+
+When using bigpowers to build a *project* (not the bigpowers package itself), the recommended semver lifecycle is:
+
+| Stage | Version | How |
+|-------|---------|-----|
+| Pre-delivery | `0.0.0-β` | Initial state after `seed-conventions` |
+| Each `feat:` story lands | `0.1.0`, `0.2.0`, … | `semantic-release` minor bump |
+| Developer declares MVP | `1.0.0` | Allow the `1.0.0` tag in release config |
+| Post-MVP features | `1.1.0`, `1.2.0`, … | Normal semver from Conventional Commits |
+
+> This keeps all pre-MVP work in the `0.x.x` range, making the `1.0.0` tag a meaningful project milestone rather than an arbitrary number.
+
+---
+
 ## Commit Message Format
 
 **Required for automatic releases:**
 
 ```
-feat(scope): description          # Minor version bump (1.0.0 → 1.1.0)
+feat(scope): description          # Minor version bump (0.1.0 → 0.2.0 or 1.0.0 → 1.1.0)
 fix(scope): description           # Patch version bump (1.0.0 → 1.0.1)
 docs: description                 # No version bump
 ```

package/SKILL-INDEX.md

@@ -2,7 +2,7 @@
 
 **Purpose:** One canonical reference for all bigpowers skills. Referenced by README.md, RELEASE-PLAN.md, and CONVENTIONS.md. Updated per-release.
 
-**Last updated:** 2026-06-11 (v3.1.0 — verified 61 active skills; 18 sub-op concepts absorbed as sub-sections into parent SKILL.md files; count confirmed accurate)
+**Last updated:** 2026-06-11 (v2.0.0 — verified 61 active skills; 18 sub-op concepts absorbed as sub-sections into parent SKILL.md files; count confirmed accurate)
 
 ---
 
@@ -84,7 +84,7 @@
 | 49 | Utility | `edit-document` | Edit documents in specs/ | specs/<name>.md | ✅ Active |
 | 50 | Utility | `session-state` | Track decisions in state.yaml; absorbs show-state, reset-state, compact-state, list-epics, check-gates | state.yaml | ✅ Active |
 | 51 | Utility | `migrate-spec` | Migrate foreign spec formats | specs/ | ✅ Active |
-| 52 | Utility | `visual-dashboard` | Browser dashboard | .bigpowers/dashboard/ | ✅ Active |
+| 52 | Utility | `visual-dashboard` | Browser dashboard (HTTP cockpit) | `npm run visual-dashboard` → GET /cockpit.html | ✅ Active |
 | 53 | Utility | `write-document` | BMAD technical documents | specs/<name>.md | ✅ Active |
 | 54 | Utility | `setup-environment` | Pre-install deps before work | (.env, packages) | ✅ Active |
 | 55 | Utility | `reset-baseline` | Restore clean known state | (clean tree) | ✅ Active |

package/dashboard/src/tui/epic-queue.js

@@ -1,5 +1,3 @@
-const { gateIcon, gateColor } = require('../loaders/gate-status');
-
 function renderEpicQueue(box, epics, executionStatus) {
   if (!box || typeof box.setContent !== 'function') {
     return;
@@ -10,25 +8,68 @@ function renderEpicQueue(box, epics, executionStatus) {
     return;
   }
 
-  let lines = [];
-  let totalBcps = 0;
+  const statusMap = executionStatus?.epics || new Map();
+  const doneStatuses = new Set(['done', 'complete', 'completed', 'released']);
+  const activeStatuses = new Set(['in_progress', 'running', 'active']);
 
-  epics.forEach(epic => {
-    const epicStatusIcon = gateIcon[epic.status] || '?';
-    lines.push(`${epicStatusIcon} ${epic.id} ${epic.title}`);
-
-    if (epic.stories && epic.stories.length > 0) {
-      epic.stories.forEach(story => {
-        const storyStatusIcon = gateIcon[story.status] || '?';
-        const bcpCount = story.bcps || 0;
-        totalBcps += bcpCount;
-        lines.push(`  ${storyStatusIcon} ${story.id} ${story.title} (${bcpCount} BCPs)`);
-      });
+  function dot(id) {
+    const s = statusMap.get(id) || '';
+    if (doneStatuses.has(s)) return '{green-fg}●{/green-fg}';
+    if (activeStatuses.has(s)) return '{yellow-fg}●{/yellow-fg}';
+    return '{dim}·{/dim}';
+  }
+
+  function epicDot(epic) {
+    const s = statusMap.get(epic.id) || '';
+    if (doneStatuses.has(s)) return '{green-fg}●{/green-fg}';
+    if (activeStatuses.has(s)) return '{yellow-fg}●{/yellow-fg}';
+    const stories = epic.stories || [];
+    if (stories.length > 0 && stories.every(st => doneStatuses.has(statusMap.get(st.id) || ''))) {
+      return '{green-fg}●{/green-fg}';
     }
+    return '{dim}·{/dim}';
+  }
+
+  const lines = [];
+  let grandTotalBcps = 0;
+  const perEpicBcp = [];
+
+  epics.forEach(epic => {
+    lines.push(`${epicDot(epic)} {bold}${epic.id}{/bold} {dim}·{/dim} ${epic.title || '—'}`);
+
+    const stories = epic.stories || [];
+    let epicBcpDone = 0;
+    let epicBcpTotal = 0;
+    let epicStoriesDone = 0;
+
+    stories.forEach(story => {
+      const bcp = story.bcps || 0;
+      epicBcpTotal += bcp;
+      grandTotalBcps += bcp;
+      const isDone = doneStatuses.has(statusMap.get(story.id) || '');
+      if (isDone) { epicBcpDone += bcp; epicStoriesDone++; }
+
+      const bcpStr = isDone
+        ? `{green-fg}${bcp} BCP{/green-fg}`
+        : `{dim}${bcp} BCP{/dim}`;
+      lines.push(`  ${dot(story.id)} {dim}${story.id}{/dim} ${story.title || '—'}  ${bcpStr}`);
+    });
+
+    perEpicBcp.push({ id: epic.id, bcps: epicBcpTotal });
+
+    const bcpProgressStr = epicBcpDone > 0
+      ? `{green-fg}${epicBcpDone}{/green-fg}{dim}/${epicBcpTotal} BCP{/dim}`
+      : `{dim}0/${epicBcpTotal} BCP{/dim}`;
+    lines.push(`  {dim}${epicStoriesDone}/${stories.length} done · ${bcpProgressStr}`);
+    lines.push('');
   });
 
-  lines.push('');
-  lines.push(`Total: ${totalBcps} BCPs`);
+  // Release baseline footer
+  lines.push('{dim}─────────────────────────{/dim}');
+  lines.push(`{dim}release baseline{/dim}`);
+  lines.push(`{dim}total: {/dim}{yellow-fg}${grandTotalBcps} BCPs{/yellow-fg}`);
+  lines.push(perEpicBcp.map(e => `{dim}${e.id}: ${e.bcps} BCP{/dim}`).join('  '));
+  lines.push(`{dim}target: {/dim}{bold}v2.0.0{/bold}`);
 
   box.setContent(lines.join('\n'));
 }

package/dashboard/src/tui/filesystem.js

@@ -15,8 +15,6 @@ function renderFilesystem(box, projectRoot) {
 
   const now = Date.now();
   const lines = [];
-  lines.push('{bold}{cyan}Filesystem{/cyan}{/bold}');
-
   let fileCount = 0;
 
   try {

package/dashboard/src/tui/index.js

@@ -9,6 +9,9 @@ const { renderStateYaml } = require('./state-yaml');
 const { renderFilesystem } = require('./filesystem');
 const { renderLedger } = require('./ledger');
 
+// Blessed box defaults — tags must be enabled for markup to render
+const BOX_DEFAULTS = { tags: true };
+
 let blessed;
 try {
   blessed = require('blessed');
@@ -32,15 +35,16 @@ function start(projectRoot) {
   });
 
   // Check terminal size
-  if (screen.width < 120 || screen.height < 30) {
+  if (screen.width < 120 || screen.height < 34) {
     const msg = blessed.box({
       parent: screen,
       top: 'center',
       left: 'center',
       width: 60,
       height: 10,
-      content: '{center}Terminal must be at least 120x30{/center}\n{center}Please resize and try again{/center}',
+      content: '{center}Terminal must be at least 120x34{/center}\n{center}Please resize and try again{/center}',
       border: 'line',
+      tags: true,
       style: { border: { fg: 'yellow' } }
     });
     screen.render();
@@ -48,76 +52,97 @@ function start(projectRoot) {
   }
 
   // Create layout zones
-  const metricsBar = blessed.box({
+  const titleBar = blessed.box({
     parent: screen,
     top: 0,
     left: 0,
     width: '100%',
-    height: 3,
+    height: 1,
+    tags: true,
+  });
+
+  // height 5 = 3 content lines + top/bottom borders: status bar, step info, stats row
+  const metricsBar = blessed.box({
+    parent: screen,
+    top: 1,
+    left: 0,
+    width: '100%',
+    height: 5,
     border: 'line',
+    tags: true,
     style: { border: { fg: 'blue' } }
   });
 
   const pipeline = blessed.box({
     parent: screen,
-    top: 3,
+    top: 6,
     left: 0,
     width: '100%',
     height: 5,
     border: 'line',
-    style: { border: { fg: 'cyan' } }
+    tags: true,
+    label: ' {green-fg}≡ PIPELINE{/green-fg} ',
+    style: { border: { fg: 'green' } }
   });
 
   const epicQueue = blessed.box({
     parent: screen,
-    top: 8,
+    top: 11,
     left: 0,
     width: '33%',
-    height: screen.height - 20,
+    height: screen.height - 23,
     border: 'line',
     scrollable: true,
     mouse: true,
     keys: true,
+    tags: true,
+    label: ' {green-fg}≡ EPIC QUEUE{/green-fg} ',
     style: { border: { fg: 'green' } }
   });
 
   const actionLog = blessed.box({
     parent: screen,
-    top: 8,
+    top: 11,
     left: '33%',
     width: '33%',
-    height: screen.height - 20,
+    height: screen.height - 23,
     border: 'line',
     scrollable: true,
     mouse: true,
     keys: true,
-    style: { border: { fg: 'yellow' } }
+    tags: true,
+    label: ' {cyan-fg}>_ STATE.YAML{/cyan-fg} ',
+    style: { border: { fg: 'cyan' } }
   });
 
   const fsPanel = blessed.box({
     parent: screen,
-    top: 8,
+    top: 11,
     left: '66%',
     width: '34%',
-    height: screen.height - 20,
+    height: screen.height - 23,
     border: 'line',
     scrollable: true,
     mouse: true,
     keys: true,
+    tags: true,
+    label: ' {magenta-fg}□ FILESYSTEM{/magenta-fg} ',
     style: { border: { fg: 'magenta' } }
   });
 
   const ledger = blessed.box({
     parent: screen,
-    top: screen.height - 12,
+    top: screen.height - 11,
     left: 0,
     width: '100%',
-    height: 12,
+    height: 11,
     border: 'line',
     scrollable: true,
     mouse: true,
     keys: true,
-    style: { border: { fg: 'white' } }
+    tags: true,
+    label: ' {cyan-fg}⊙ CYCLE TIME LEDGER — BCPS · TIMESTAMPS · THROUGHPUT{/cyan-fg} ',
+    style: { border: { fg: 'cyan' } }
   });
 
   // Refresh function
@@ -128,7 +153,10 @@ function start(projectRoot) {
     const cycleTimes = readCycleTimes(projectRoot);
     const metrics = computeProjectMetrics(cycleTimes);
 
-    renderMetricsBar(metricsBar, metrics, stateData);
+    // Title bar: fixed project identity
+    titleBar.setContent(' {bold}{cyan-fg}⚙ bigpowers factory{/cyan-fg}{/bold} {dim}v2 — seed {cyan-fg}→{/cyan-fg} epics {cyan-fg}→{/cyan-fg} mvp{/dim}');
+
+    renderMetricsBar(metricsBar, metrics, stateData, epics, cycleTimes);
     renderPipeline(pipeline, stateData);
     renderEpicQueue(epicQueue, epics, executionStatus);
     renderStateYaml(actionLog, stateData);

package/dashboard/src/tui/ledger.js

@@ -1,61 +1,56 @@
+function pad(str, width) {
+  const s = String(str);
+  return s.length >= width ? s : s + ' '.repeat(width - s.length);
+}
+
 function renderLedger(box, cycleTimes) {
   if (!box || typeof box.setContent !== 'function') {
     return;
   }
 
   if (!cycleTimes || cycleTimes.length === 0) {
-    box.setContent('{center}{dim}no completed stories yet{/dim}{/center}');
+    box.setContent('{dim}stories complete here as they land{/dim}');
     return;
   }
 
   const lines = [];
-  lines.push('{bold}{cyan}Ledger{/cyan}{/bold}');
-  lines.push('');
 
-  // Header row
+  // Column widths
+  const W = { sid: 12, epic: 6, bcps: 5, min: 8, bhr: 7 };
+
+  // Header
   lines.push(
-    '{bold}' +
-    '{cyan}Story ID{/cyan}  ' +
-    '{cyan}Epic{/cyan}  ' +
-    '{cyan}BCPs{/cyan}  ' +
-    '{cyan}Minutes{/cyan}  ' +
-    '{cyan}BCP/hr{/cyan}' +
-    '{/bold}'
+    `{cyan-fg}{bold}${pad('Story ID', W.sid)}${pad('Epic', W.epic)}${pad('BCPs', W.bcps)}${pad('Minutes', W.min)}${pad('BCP/hr', W.bhr)}{/bold}{/cyan-fg}`
   );
+  lines.push('{dim}' + '─'.repeat(W.sid + W.epic + W.bcps + W.min + W.bhr) + '{/dim}');
 
   let totalBCPs = 0;
   let totalMinutes = 0;
 
-  // Data rows
-  cycleTimes.forEach((cycle) => {
+  cycleTimes.forEach(cycle => {
     const storyId = cycle.id || '—';
-    const epicPrefix = cycle.epic || '—';
+    const epicId = cycle.epic || '—';
     const bcps = cycle.bcps || 0;
     const minutes = cycle.cycleMin || 0;
-    const bcpPerHour = minutes > 0 ? ((bcps * 60) / minutes).toFixed(1) : '—';
+    const bph = minutes > 0 ? ((bcps * 60) / minutes).toFixed(1) : '—';
 
     totalBCPs += bcps;
     totalMinutes += minutes;
 
     lines.push(
-      `  ${storyId}  ` +
-      `${epicPrefix}  ` +
-      `${bcps}  ` +
-      `${minutes}  ` +
-      `${bcpPerHour}`
+      `{white-fg}${pad(storyId, W.sid)}{/white-fg}` +
+      `{dim}${pad(epicId, W.epic)}{/dim}` +
+      `{yellow-fg}${pad(bcps, W.bcps)}{/yellow-fg}` +
+      `{dim}${pad(minutes, W.min)}{/dim}` +
+      `{green-fg}${pad(bph, W.bhr)}{/green-fg}`
     );
   });
 
-  lines.push('');
-
-  // Totals row
-  const avgBcpPerHour =
-    totalMinutes > 0 ? ((totalBCPs * 60) / totalMinutes).toFixed(1) : '—';
+  lines.push('{dim}' + '─'.repeat(W.sid + W.epic + W.bcps + W.min + W.bhr) + '{/dim}');
 
+  const avgBph = totalMinutes > 0 ? ((totalBCPs * 60) / totalMinutes).toFixed(1) : '—';
   lines.push(
-    '{bold}{yellow}' +
-    `TOTAL  —  ${totalBCPs}  ${totalMinutes}  ${avgBcpPerHour}` +
-    '{/yellow}{/bold}'
+    `{bold}{yellow-fg}${pad('TOTAL', W.sid)}${pad('—', W.epic)}${pad(totalBCPs, W.bcps)}${pad(totalMinutes, W.min)}${pad(avgBph, W.bhr)}{/yellow-fg}{/bold}`
   );
 
   box.setContent(lines.join('\n'));

package/dashboard/src/tui/metrics-bar.js

@@ -1,30 +1,82 @@
-function renderMetricsBar(box, projectMetrics, stateData) {
+function renderMetricsBar(box, projectMetrics, stateData, epics, cycleTimes) {
   if (!box || typeof box.setContent !== 'function') {
     return;
   }
 
-  const totalBcps = projectMetrics?.totalBcps ?? '-';
-  const totalMin = projectMetrics?.totalMin ?? '-';
-  const avgBcpPerHour = projectMetrics?.avgBcpPerHour ?? '-';
-  const version = stateData?.release?.target_version ?? '-';
+  const ct = cycleTimes || [];
+  const epicList = epics && Array.isArray(epics) ? epics : [];
 
-  let bcpHrColor = 'white';
-  if (typeof avgBcpPerHour === 'number') {
-    if (avgBcpPerHour >= 2.0) {
-      bcpHrColor = 'green';
-    } else if (avgBcpPerHour >= 1.0) {
-      bcpHrColor = 'yellow';
-    } else {
-      bcpHrColor = 'red';
+  // Compute totals
+  let totalStories = 0;
+  let targetBcps = 0;
+  epicList.forEach(epic => {
+    if (epic.stories && Array.isArray(epic.stories)) {
+      totalStories += epic.stories.length;
+      epic.stories.forEach(s => { targetBcps += s.bcps || 0; });
     }
+  });
+
+  const doneStories = ct.length;
+  const totalEpics = epicList.length;
+  const doneStoryIds = new Set(ct.map(c => c.id));
+  const doneEpics = epicList.filter(e =>
+    e.stories && e.stories.length > 0 && e.stories.every(s => doneStoryIds.has(s.id))
+  ).length;
+
+  const deliveredBcps = projectMetrics?.totalBcps ?? 0;
+  const totalMin = projectMetrics?.totalMin ?? 0;
+  const avgBcpPerHour = projectMetrics?.avgBcpPerHour;
+  const version = stateData?.release?.target_version ?? '—';
+  const branch = stateData?.gitBranch ?? 'main';
+
+  // BCP/hr color threshold
+  let bphColor = 'white';
+  if (typeof avgBcpPerHour === 'number') {
+    if (avgBcpPerHour >= 2.0) bphColor = 'green';
+    else if (avgBcpPerHour >= 1.0) bphColor = 'yellow';
+    else bphColor = 'red';
   }
+  const bphDisplay = typeof avgBcpPerHour === 'number' ? avgBcpPerHour.toFixed(2) : '—';
+  const cycleDisplay = totalMin > 0 ? `${totalMin}m` : '—';
+
+  // ── Line 1: status bar ──
+  const statusLine =
+    `{dim}BCPs:{/dim} {yellow-fg}${deliveredBcps}{/yellow-fg}{dim}/${targetBcps}{/dim}` +
+    `  {dim}│{/dim}  {dim}Cycle:{/dim} ${cycleDisplay}` +
+    `  {dim}│{/dim}  {dim}BCP/hr:{/dim} {${bphColor}-fg}${bphDisplay}{/${bphColor}-fg}` +
+    `  {dim}│{/dim}  {dim}v{/dim}{green-fg}${version}{/green-fg}` +
+    `{|}  {dim}branch:{/dim} {green-fg}${branch}{/green-fg}  `;
+
+  // ── Line 2: step info ──
+  const currentStep = stateData?.epicCycle?.current_step;
+  const activeStory = stateData?.activeStory ?? '—';
+  const activeEpic = stateData?.activeEpic ?? '—';
+  const activeFlow = stateData?.activeFlow ?? '—';
 
-  const avgCycleTime = totalMin === '-' ? '-' : `${totalMin}m`;
-  const bcpHrDisplay = typeof avgBcpPerHour === 'number' ? avgBcpPerHour.toFixed(2) : avgBcpPerHour;
+  const STEP_NAMES = ['survey-context','plan-work','kickoff-branch','develop-tdd','verify-work','audit-code','commit-message','release-branch'];
+  const stepName = typeof currentStep === 'number' ? (STEP_NAMES[currentStep] ?? '—') : (currentStep ?? '—');
+  const isActive = stepName !== '—' && activeStory !== '—';
+  const statusWord = isActive
+    ? `{yellow-fg}running{/yellow-fg}`
+    : `{green-fg}ready{/green-fg}`;
+  const storyDesc = isActive
+    ? `{dim}${activeEpic}{/dim} {dim}›{/dim} {cyan-fg}${activeStory}{/cyan-fg} {dim}—{/dim} ${stepName}`
+    : `{dim}flow:{/dim} ${activeFlow}  {dim}next:{/dim} {cyan-fg}${stateData?.epicCycle?.next_skill ?? 'survey-context'}{/cyan-fg}`;
+  const stepLine =
+    `{dim}step {/dim}{cyan-fg}${doneStories}{/cyan-fg}{dim}/${totalStories}{/dim}` +
+    `  {dim}—{/dim}  ${statusWord}` +
+    `  {dim}—{/dim}  ${storyDesc}`;
 
-  const line = `BCPs: ${totalBcps} | Cycle: ${avgCycleTime} | {${bcpHrColor}}BCP/hr: ${bcpHrDisplay}{/${bcpHrColor}} | v${version}`;
+  // ── Line 3: stats row ──
+  const statsLine =
+    `{dim}[{/dim} epics {green-fg}${doneEpics}${doneEpics > 0 ? '' : ''}{/green-fg}{dim}/${totalEpics} ]{/dim}` +
+    `   {dim}[{/dim} stories {cyan-fg}${doneStories}{/cyan-fg}{dim}/${totalStories} ]{/dim}` +
+    `   {dim}[{/dim} BCPs {yellow-fg}${deliveredBcps}{/yellow-fg}{dim}/${targetBcps} ]{/dim}` +
+    `   {dim}[{/dim} cycle ${cycleDisplay}{dim} ]{/dim}` +
+    `   {dim}[{/dim} BCP/hr {${bphColor}-fg}${bphDisplay}{/${bphColor}-fg}{dim} ]{/dim}` +
+    `   {dim}[{/dim} v{green-fg}${version}{/green-fg}{dim} ]{/dim}`;
 
-  box.setContent(line);
+  box.setContent([statusLine, stepLine, statsLine].join('\n'));
 }
 
 module.exports = { renderMetricsBar };

package/dashboard/src/tui/pipeline.js

@@ -1,5 +1,7 @@
 const { STEPS } = require('../loaders/pipeline-map');
 
+const STEP_ABBR = ['sur','pla','kic','tdd','ver','aud','com','rel'];
+
 function renderPipeline(box, stateData) {
   if (!box || typeof box.setContent !== 'function') {
     return;
@@ -10,37 +12,27 @@ function renderPipeline(box, stateData) {
     return;
   }
 
-  const currentStep = stateData.epicCycle?.current_step || null;
-  const completedSteps = stateData.epicCycle?.completed_steps || [];
-
-  // Build pipeline visualization
-  const lines = [];
-  lines.push('{bold}{cyan}Pipeline{/cyan}{/bold}');
-  lines.push('');
-
-  // Create step display
-  const stepDisplay = STEPS.map((step, index) => {
-    const isCompleted = completedSteps.includes(step);
-    const isCurrent = step === currentStep;
-
-    let display = `  ${index + 1}. ${step}`;
-
-    if (isCurrent) {
-      display = `{reverse}{bold}${display}{/bold}{/reverse}`;
-    } else if (isCompleted) {
-      display = `{green-fg}${display}{/green-fg}`;
+  // current_step is a 0-based index (number) in state.yaml
+  const rawStep = stateData.epicCycle?.current_step;
+  const currentIdx = typeof rawStep === 'number' ? rawStep : STEPS.indexOf(rawStep);
+
+  // Build pipeline strip
+  const strip = STEPS.map((step, i) => {
+    const abbr = STEP_ABBR[i];
+    if (i < currentIdx) {
+      return `{green-fg}${i + 1} ${step}{/green-fg}`;
+    } else if (i === currentIdx) {
+      return `{reverse}{cyan-fg}${i + 1} ${step}{/cyan-fg}{/reverse}`;
     } else {
-      display = `{gray-fg}${display}{/gray-fg}`;
+      return `{dim}${i + 1} ${step}{/dim}`;
     }
+  }).join(' {dim}›{/dim} ');
 
-    return display;
-  }).join('\n');
-
-  lines.push(stepDisplay);
-  lines.push('');
-  lines.push(`{dim}Current: ${currentStep || '—'}{/dim}`);
+  const stepLabel = currentIdx >= 0 && currentIdx < STEPS.length
+    ? `{dim}step{/dim} {cyan-fg}${currentIdx + 1}{/cyan-fg}{dim}/${STEPS.length}{/dim}  {dim}—{/dim}  ${STEPS[currentIdx]}`
+    : '{dim}no active step{/dim}';
 
-  box.setContent(lines.join('\n'));
+  box.setContent(stepLabel + '\n\n' + strip);
 }
 
 module.exports = { renderPipeline };

package/dashboard/src/tui/state-yaml.js

@@ -1,45 +1,63 @@
+const STEP_NAMES = [
+  'survey-context', 'plan-work', 'kickoff-branch', 'develop-tdd',
+  'verify-work', 'audit-code', 'commit-message', 'release-branch'
+];
+const STEP_ABBR = ['sur', 'pla', 'kic', 'tdd', 'ver', 'aud', 'com', 'rel'];
+
 function renderStateYaml(box, stateData) {
   if (!box || typeof box.setContent !== 'function') {
     return;
   }
 
   if (!stateData) {
-    box.setContent('{center}state.yaml not found{/center}');
+    box.setContent('{center}{dim}state.yaml not found{/dim}{/center}');
     return;
   }
 
-  const lines = [];
-  lines.push('{bold}{cyan}state.yaml{/cyan}{/bold}');
-  lines.push('');
+  const rawStep = stateData.epicCycle?.current_step;
+  const currentIdx = typeof rawStep === 'number' ? rawStep : STEP_NAMES.indexOf(rawStep);
+  const stepName = currentIdx >= 0 ? STEP_NAMES[currentIdx] : (rawStep ?? '—');
+  const nextSkill = stateData.epicCycle?.next_skill ?? stateData.handoff?.next_skill ?? '—';
 
-  const pairs = [
-    { key: 'active_flow', value: stateData.active_flow },
-    { key: 'active_epic', value: stateData.active_epic },
-    { key: 'active_story', value: stateData.active_story },
-    { key: 'current_step', value: stateData.current_step },
-    { key: 'next_skill', value: stateData.next_skill },
-    { key: 'git.branch', value: stateData.git?.branch },
-    { key: 'metrics.story_start', value: stateData.metrics?.story_start },
+  const fields = [
+    { key: 'active_flow',         value: stateData.activeFlow,    color: 'cyan' },
+    { key: 'active_epic',         value: stateData.activeEpic,    color: 't' },
+    { key: 'active_story',        value: stateData.activeStory,   color: 't' },
+    { key: 'current_step',        value: stepName,                color: currentIdx >= 0 ? 'yellow' : 'dim' },
+    { key: 'next_skill',          value: nextSkill,               color: 'green' },
+    { key: 'git.branch',          value: stateData.gitBranch,     color: 'green' },
+    { key: 'metrics.story_start', value: stateData.metrics?.story_start, color: 'dim' },
   ];
 
-  pairs.forEach(({ key, value }) => {
-    let displayValue = String(value || '—');
-
-    // Color rules: use blessed markup, not chalk
-    if (key === 'git.branch') {
-      if (displayValue === 'main') {
-        displayValue = `{green-fg}${displayValue}{/green-fg}`;
-      } else if (displayValue.startsWith('feat/')) {
-        displayValue = `{yellow-fg}${displayValue}{/yellow-fg}`;
-      }
+  const lines = fields.map(({ key, value }) => {
+    const v = value ?? '—';
+    const isDash = v === '—';
+    let colored;
+    if (isDash) {
+      colored = `{dim}${v}{/dim}`;
+    } else if (fields.find(f => f.key === key)?.color === 'cyan') {
+      colored = `{cyan-fg}${v}{/cyan-fg}`;
+    } else if (fields.find(f => f.key === key)?.color === 'green') {
+      colored = `{green-fg}${v}{/green-fg}`;
+    } else if (fields.find(f => f.key === key)?.color === 'yellow') {
+      colored = `{yellow-fg}${v}{/yellow-fg}`;
+    } else if (fields.find(f => f.key === key)?.color === 'dim') {
+      colored = `{dim}${v}{/dim}`;
+    } else {
+      colored = v;
     }
+    return `{dim}${key}:{/dim} ${colored}`;
+  });
 
-    if (key === 'next_skill' && value) {
-      displayValue = `{green-fg}${displayValue}{/green-fg}`;
-    }
+  // Stage tracker strip
+  const tracker = STEP_ABBR.map((abbr, i) => {
+    if (i < currentIdx) return `{green-fg}${abbr}{/green-fg}`;
+    if (i === currentIdx) return `{cyan-fg}{bold}${abbr}{/bold}{/cyan-fg}`;
+    return `{dim}${abbr}{/dim}`;
+  }).join(' {dim}·{/dim} ');
 
-    lines.push(`  {dim}${key}:{/dim} ${displayValue}`);
-  });
+  lines.push('');
+  lines.push(tracker);
 
   box.setContent(lines.join('\n'));
 }

package/orchestrate-project/REFERENCE.md

@@ -23,10 +23,14 @@ Detailed documentation for the `orchestrate-project` meta-skill.
 - **Gate**: Quality (request-review ≥94%) + slopcheck [SUS]/[SLOP].
 
 ### PHASE 4: BUILD
-- **Goal**: Execute the plan step-by-step using TDD and vertical slices.
-- **Deliverables**: Code; `execution-status.yaml` updated per story.
-- **Skills**: `kickoff-branch`, `develop-tdd`, `delegate-task`, `execute-plan`.
-- **Gate**: Integration tests PASS.
+- **Goal**: Execute the plan story-by-story using the 8-step `build-epic` cycle with TDD and vertical slices.
+- **Deliverables**: Code; `execution-status.yaml` updated per story; `specs/metrics/cycle-times.yaml` row per story.
+- **Skills**: `build-epic` (conductor) → per-story: `survey-context`, `plan-work`, `kickoff-branch`, `develop-tdd`, `verify-work`, `audit-code`, `commit-message`, `release-branch`.
+- **BCP tracking**: `plan-work` labels every task `[BCP N]`; total written to `state.yaml` as `epic_cycle.story_bcps`. BCP baseline must exist in `release-plan.yaml` before starting.
+- **Timestamps**: `survey-context` stamps `metrics.story_start`; `release-branch` stamps `metrics.story_end` and writes BCP/hr to `specs/metrics/cycle-times.yaml`.
+- **next_skill**: Each critical-path skill writes `handoff.next_skill` to `state.yaml`. Agents resume by reading `state.yaml` — no guessing.
+- **Dashboard**: `npm run dashboard` (TUI) or `npm run dashboard:web` (browser, port 7742) shows live pipeline, epic queue, BCP metrics, and cycle-time ledger.
+- **Gate**: Integration tests PASS; all 8 build-epic steps completed per story.
 
 ### PHASE 5: VERIFY
 - **Goal**: Validate success criteria and ensure production readiness.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bigpowers",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "61 agent skills for spec-driven, test-first software development by solo developers",
   "main": "index.js",
   "scripts": {

package/seed-conventions/SKILL.md

@@ -203,7 +203,7 @@ touch specs/tech-architecture/design.md
 touch specs/tech-architecture/REFACTOR_LATEST.md
 touch specs/tech-architecture/IMPACT_LATEST.md
 touch specs/bugs/registry.yaml
-echo "# Specs\n\nAll planning documents for this project. Evolved bigpowers structure (v4.0.0+)." > specs/README.md
+echo "# Specs\n\nAll planning documents for this project. Evolved bigpowers structure (v2.0.0+)." > specs/README.md
 ```
 
 **Note:** `specs/state.yaml.lock` is NOT pre-created — it is acquired and released dynamically during writes to prevent concurrency conflicts.