@hegemonart/get-design-done 1.54.0 → 1.55.0

package/.claude-plugin/marketplace.json

@@ -5,14 +5,14 @@
   },
   "metadata": {
     "description": "Get Design Done — 5-stage agent-orchestrated design pipeline with 9 connections, handoff-first workflow, bidirectional Figma write-back, 22+ specialized agents, queryable knowledge layer (intel store, dependency analysis, learnings extraction), and a self-improvement loop (reflector, frontmatter + budget feedback, global-skills layer). v1.20.0 ships the SDK foundation: gdd-state MCP server (11 typed tools), lockfile-safe STATE.md mutations, event stream, and resilience primitives (jittered-backoff, rate-guard, error-classifier, iteration-budget) for rate-limit + 429 + context-overflow recovery. Full CI/CD pipeline (Node 22/24 × Linux/macOS/Windows) and release automation (auto-tag + GitHub Release + release-time smoke test).",
-    "version": "1.54.0"
+    "version": "1.55.0"
   },
   "plugins": [
     {
       "name": "get-design-done",
       "source": "./",
       "description": "Agent-orchestrated 5-stage design pipeline: Brief → Explore → Plan → Design → Verify. 22+ specialized agents, 9 connections (Figma, Refero, Preview, Storybook, Chromatic, Figma Writer, Graphify, Pinterest, Claude Design), Claude Design handoff, bidirectional Figma write-back, and a queryable intel store (.design/intel/) for dependency and learnings queries. Standalone commands: style, darkmode, compare, figma-write, graphify, handoff, analyze-dependencies, skill-manifest, extract-learnings. Embeds NNG heuristics, WCAG thresholds, typographic systems, motion framework, and anti-pattern catalog. Ships with a full CI/CD pipeline (Node 22/24 × Linux/macOS/Windows) and release automation. Optimization layer (v1.0.4.1, retroactive): gdd-router + gdd-cache-manager skills, PreToolUse budget-enforcer hook, tier-aware agent frontmatter, lazy checker gates, streaming synthesizer, /gdd:warm-cache + /gdd:optimize commands, and cost telemetry at .design/telemetry/costs.jsonl — targeting 50-70% per-task token-cost reduction with no quality-floor regression. v1.20.0 SDK foundation: gdd-state MCP server (11 typed tools), lockfile-safe STATE.md mutations, event stream at .design/telemetry/events.jsonl, resilience primitives (jittered-backoff, rate-guard, error-classifier, iteration-budget) with rate-limit + 429 + context-overflow recovery, and TypeScript toolchain.",
-      "version": "1.54.0",
+      "version": "1.55.0",
       "author": {
         "name": "hegemonart"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "get-design-done",
   "short_name": "gdd",
-  "version": "1.54.0",
+  "version": "1.55.0",
   "description": "Agent-orchestrated 5-stage design pipeline: Brief → Explore → Plan → Design → Verify. 59 specialized agents, 88 skills, 41 connection integrations (Figma, Refero, Preview, Storybook, Chromatic, Graphify, Slack, Linear, Jira, Notion, and more), handoff-first workflow via Claude Design bundles, bidirectional Figma write-back (annotations, Code Connect), queryable intel store (`.design/intel/`) for O(1) design surface lookups, and self-improvement loop (reflector agent, frontmatter + budget feedback, global-skills layer at `~/.claude/gdd/global-skills/`). Standalone commands: style, darkmode, compare, figma-write, graphify, handoff, analyze-dependencies, skill-manifest, extract-learnings, reflect, apply-reflections. Embeds NNG heuristics, WCAG thresholds, typographic systems, motion framework, and anti-pattern catalog. Ships with a full CI/CD pipeline (Node 22/24 × Linux/macOS/Windows, lint + schema + frontmatter + stale-ref + shellcheck + gitleaks + injection-scan + blocking size-budget) and release automation (auto-tag + GitHub Release + release-time smoke test). Optimization layer (v1.0.4.1, retroactive): gdd-router + gdd-cache-manager skills, PreToolUse budget-enforcer hook, tier-aware agent frontmatter, lazy checker gates, streaming synthesizer, /gdd:warm-cache + /gdd:optimize commands, and cost telemetry at .design/telemetry/costs.jsonl — targeting 50-70% per-task token-cost reduction with no quality-floor regression. v1.20.0 SDK foundation: gdd-state MCP server (11 typed tools), lockfile-safe STATE.md mutations, event stream at .design/telemetry/events.jsonl, resilience primitives (jittered-backoff, rate-guard, error-classifier, iteration-budget) with rate-limit + 429 + context-overflow recovery, and TypeScript toolchain. v1.27.7 ships gdd-mcp (Phase 27.7): 12 read-only MCP tools for sub-3s priming. v1.28.0 (Phase 28): Foundational References Tier 2 — 5 new reference files (color-theory, composition, proportion-systems, i18n, contrast-advanced), 2 verifier i18n probes + 1 explore i18n-readiness probe, 12 additive cross-link insertions across 10 existing references, 2 orthogonal audit-scoring lens-tags (composition_alignment + i18n_readiness).",
   "author": {
     "name": "hegemonart",

package/CHANGELOG.md

@@ -4,6 +4,53 @@ All notable changes to get-design-done are documented here. Versions follow [sem
 
 ---
 
+## [1.55.0] - 2026-06-03
+
+### Phase 55 - GDD Dashboard (Multi-Harness Control Plane + Graph Visualization + Session Surface)
+
+GDD ships to 14 runtimes and users run multi-harness sessions in parallel; a control plane is the natural way to surface
+that. Phase 55 ships a READ-ONLY dashboard: a terminal TUI (`bin/gdd-dashboard`) and an opt-in browser graph view
+(`gdd dashboard --web`) that visualizes the Phase 52 DesignContext graph. **Built fully dep-free** (maintainer Rule-4
+decision): no Ink, no React / Vite / React Flow. The ROADMAP had named those stacks (~100 packages / ~84 MB + a CI build
+gate); a footprint study plus the read-only / single-machine / opt-in scale made a hand-rolled ANSI TUI + a
+self-contained-HTML graph (extending the Phase 35.5 `build-html.cjs` precedent) the better fit, and it keeps the
+zero-new-dependency streak intact. The web layer is kept swappable, so a React Flow migration later needs no data rewrite.
+Planned and executed via the GSD pipeline (3 + 3 parallel executors).
+
+### Breaking changes
+
+- **New `bin/gdd-dashboard` + `gdd dashboard [--web]`.** A new bin (the TUI) and a new SDK CLI subcommand. Read-only by
+  design: the dashboard never mutates state (the action surface is "open this file / copy this command / run the
+  slash-skill"). The `--web` server is an ephemeral LOCAL loopback (127.0.0.1, OS-assigned port) serving a single
+  self-contained HTML file to your own browser, then exits.
+- **`gsd-health` gains a 10th check** (`dashboard_reachable`); the health check count moves 9 -> 10.
+
+### Added
+
+- **Data plane** `sdk/dashboard/data/` - `source.cjs` (`loadDashboardModel` reads state / events / graph / health via the
+  shared libs in-process, with a `.design/*` file-scrape fallback; never throws), `cost-aggregator.cjs` (per-runtime +
+  cumulative + per-cycle), `discovery.cjs` (14-runtime detection, worktree enumeration via `git worktree list`,
+  best-effort session manifests).
+- **TUI** `bin/gdd-dashboard` + `sdk/dashboard/tui/` - a hand-rolled ANSI render core (`ansi.cjs`: box/column layout,
+  width-aware truncation incl. CJK, line-diff repaint) + 5 panes (Sessions / Cycle / Cost / Findings /
+  DesignContext-tree), keyboard navigation, alt-screen, event-tail live refresh. Plain `.cjs` (no bundle, no flags).
+- **Web graph** `scripts/lib/dashboard/graph-html.cjs` (`buildGraphHtml`) - one self-contained HTML doc (inline SVG +
+  vanilla JS): layered Atomic / Molecular / Organism / Template layout with barycenter crossing-reduction, viewBox
+  pan/zoom, click-to-inspect, type/tag filters, find-consumers highlight, unreachable outline, PNG export, minimap.
+  Deterministic (hermetic byte-equal test). Launched by `gdd dashboard --web` (`node:http` loopback + browser-open;
+  headless prints the URL; `--once` writes `.design/dashboard.html`).
+- **Risk surfacing** `sdk/dashboard/data/risk-surface.cjs` - reads `risk_score`/`confidence` when present (Phase 56),
+  color-routes Allow/Review/RequireConfirmation/Block; a blank placeholder pre-56.
+
+### Notes
+
+- 6-manifest lockstep at **v1.55.0** + `OFF_CADENCE_VERSIONS.add('1.55.0')` + 37 `manifests-version.txt` baselines.
+  No new skill (the dashboard is a bin + CLI subcommand) -> skill-list / build:skills / skills.json unchanged. No new
+  agent. The dashboard's local `node:http` server is allowlisted in `scripts/security/outbound-allowlist.json` (an
+  inbound loopback read-only server, not outbound egress). Tarball golden 969 -> 979. **No new runtime dependency.**
+
+---
+
 ## [1.54.0] - 2026-06-03
 
 ### Phase 54 - Composable Reference Addendums (Per-DS + Per-Framework + Per-Motion-Lib)

package/README.md

@@ -269,6 +269,8 @@ All 14 runtimes receive their native artifact layout (`skills/`, `command/`, `ag
 
 **Composable reference addendums (v1.54.0).** One general mapper prompt cannot know Tailwind's `@theme` tokens from shadcn's `cn()` from vanilla-extract's `style({})`. Phase 54 adds 18 stack-specific addendums (8 design systems, 6 frameworks, 4 motion libraries) under `reference/{systems,frameworks,motion}/`, each at most 50 lines with Conventions / File patterns / Gotchas / Example-output sections. `scripts/lib/detect/stack.cjs` detects the project stack from dependencies plus config files and import signatures; `scripts/lib/mapper-spawn.cjs` composes the matching addendums (capped at one DS + one framework + one motion) into each explore mapper's prompt at spawn time, additively, so a project on an unknown stack just keeps the base prompt and `gsd-health` reports the coverage gap. A `/gdd:new-addendum` scaffolder adds more. Maintainer-authored, vendor-cross-checked, no LLM-generated content. **No new runtime dependency.**
 
+**GDD dashboard (v1.55.0).** A read-only multi-harness control plane. `gdd-dashboard` opens a terminal TUI with five panes (sessions per runtime, current cycle, cost telemetry, findings, a DesignContext tree); `gdd dashboard --web` opens an interactive browser view of the Phase 52 graph (layered Atomic/Molecular/Organism/Template layout, pan/zoom, click-to-inspect, type/tag filters, find-consumers highlight, PNG export, minimap). It is **built fully dep-free** (a maintainer decision over the roadmap's Ink + React Flow + Vite stack, which would have added ~100 packages): the TUI is a hand-rolled ANSI renderer, the graph view is a self-contained HTML file (inline SVG + vanilla JS, extending the export builder), and the data plane reads GDD state through the existing shared libraries in-process. Read-only by design (the action surface is open-file / copy-command / run-skill); the `--web` server is a local loopback that serves to your own browser and exits. **No new runtime dependency.**
+
 Verify with:
 
 ```

package/bin/gdd-dashboard

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// bin/gdd-dashboard — Phase 55 (GDD Dashboard, DEP-FREE), TUI-01 (executor D).
+//
+// CJS trampoline that launches the terminal dashboard
+// (sdk/dashboard/tui/index.cjs) under `node`, forwarding argv + the child's
+// exit code / signal. Windows-safe.
+//
+// SIMPLER than bin/gdd-sdk (R8): the TUI is plain `.cjs` (Node builtins only),
+// so there is NO esbuild bundle and NO `--experimental-strip-types` flag — we
+// just `node <entry>`. The only reason this is a spawning trampoline (rather
+// than a direct require) is the same one gdd-sdk documents: npm's
+// auto-generated Windows `.cmd` shim invokes `node bin/gdd-dashboard` and we
+// want a single, platform-uniform launch path that cleanly forwards the exit
+// code and re-raises a terminating signal (so Ctrl-C tears down correctly).
+//
+// Sibling resolution uses a PACKAGE-ROOT WALK-UP (the Phase 53/54 lesson, D7),
+// never a fixed `__dirname`-relative cross-tree jump: we climb from this file's
+// directory to the GDD package root (package.json with name
+// "get-design-done") and resolve `sdk/dashboard/tui/index.cjs` from there. This
+// keeps the bin correct even if it is copied/relocated within the tree.
+
+'use strict';
+
+const { spawn } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+
+/**
+ * Walk up from `startDir` to the GDD package root: the first ancestor whose
+ * package.json declares `name === "get-design-done"`. Falls back to the first
+ * ancestor that has any package.json, then to `startDir`. Bounded climb.
+ * @param {string} startDir
+ * @returns {string} absolute package-root directory
+ */
+function findPackageRoot(startDir) {
+  let dir = path.resolve(startDir);
+  let firstWithPkg = null;
+  for (let i = 0; i < 12; i++) {
+    const pkgPath = path.join(dir, 'package.json');
+    let pkg = null;
+    try {
+      pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    } catch {
+      pkg = null;
+    }
+    if (pkg) {
+      if (firstWithPkg === null) firstWithPkg = dir;
+      if (pkg.name === 'get-design-done') return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return firstWithPkg || path.resolve(startDir);
+}
+
+const root = findPackageRoot(__dirname);
+const entry = path.join(root, 'sdk', 'dashboard', 'tui', 'index.cjs');
+
+if (!fs.existsSync(entry)) {
+  // eslint-disable-next-line no-console
+  console.error(`gdd-dashboard: TUI entry not found at ${entry}`);
+  process.exit(3);
+}
+
+const child = spawn(process.execPath, [entry, ...process.argv.slice(2)], {
+  stdio: 'inherit',
+  shell: false,
+});
+
+child.on('exit', (code, signal) => {
+  if (signal) {
+    // Re-raise the signal so the parent shell sees the same termination mode
+    // (e.g. Ctrl+C propagates as SIGINT). Falls back to a non-zero exit if the
+    // self-signal cannot be delivered.
+    try {
+      process.kill(process.pid, signal);
+    } catch {
+      process.exit(1);
+    }
+    return;
+  }
+  process.exit(typeof code === 'number' ? code : 0);
+});
+
+child.on('error', (err) => {
+  // Failure to spawn node itself — extremely rare; surface to stderr.
+  // eslint-disable-next-line no-console
+  console.error('gdd-dashboard: failed to launch the TUI:', err.message);
+  process.exit(3);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hegemonart/get-design-done",
-  "version": "1.54.0",
+  "version": "1.55.0",
   "description": "A design-quality pipeline for AI coding agents: brief, plan, implement, and verify UI work against your design system.",
   "author": "Hegemon",
   "homepage": "https://github.com/hegemonart/get-design-done",
@@ -34,6 +34,7 @@
     "NOTICE"
   ],
   "bin": {
+    "gdd-dashboard": "./bin/gdd-dashboard",
     "gdd-detect": "./bin/gdd-detect",
     "gdd-events": "./scripts/cli/gdd-events.mjs",
     "gdd-graph": "./bin/gdd-graph",

package/scripts/lib/health-mirror/index.cjs

@@ -8,7 +8,7 @@
 // Surface:
 //   async getHealthChecks(rootDir) → { checks: HealthCheck[] }
 //
-// The 9 checks (in stable order) are:
+// The 10 checks (in stable order) are:
 //   1. claude_md            — CLAUDE.md presence
 //   2. planning_dir         — .planning/ presence
 //   3. design_dir           — .design/ presence
@@ -18,6 +18,7 @@
 //   7. skill_discipline     — using-gdd bootstrap + SessionStart inject (Plan 32-07)
 //   8. harness_freshness    — per-harness last_verified age (Phase 44)
 //   9. stack_addendums      — Phase 54 coverage: N/M detected stacks have addendums
+//  10. dashboard_reachable  — Phase 55: bin/gdd-dashboard on disk + data plane loads
 //
 // Check 5 was added in Plan 30-06 — surfaces the report-issue kill-switch
 // (env or config disable) so users can verify why the command is
@@ -48,6 +49,22 @@
 //                                           inject-using-gdd entry)
 // status: 'ok' when ready, 'warn' otherwise. PURE read-only (rootDir-relative
 // file + JSON inspection only) — NEVER throws, NEVER networks.
+//
+// Check 10 was added in Phase 55 — surfaces whether the GDD dashboard is
+// reachable so a user running /gdd:health knows the `gdd dashboard` entrypoint
+// is wired. GRACEFUL-ABSENT by design (D-8 risk surfacing precedent): the
+// dashboard is an opt-in, read-only surface that also works via file-scrape, so
+// a missing bin or absent data plane is a 'warn' (actionable note), NEVER a
+// hard 'fail'. The status is 'ok' when BOTH the bin/gdd-dashboard trampoline
+// resolves on disk (located via a package-root walk-up — the Phase 53/54 lesson,
+// NEVER a fixed __dirname jump) AND the dashboard data plane module
+// (sdk/dashboard/data/source.cjs) loads + exposes loadDashboardModel. The detail
+// line is one of:
+//   - "dashboard: bin/gdd-dashboard present; data plane ok"
+//   - "dashboard: bin missing"                 (trampoline not on disk)
+//   - "dashboard: data plane unavailable"      (bin present, source.cjs absent)
+//   - "dashboard: bin missing; data plane unavailable"
+// PURE read-only (fs.statSync + a wrapped require) — NEVER throws, NEVER networks.
 
 const fs = require('node:fs');
 const path = require('node:path');
@@ -310,6 +327,39 @@ async function getHealthChecks(rootDir) {
     checks.push({ name: 'stack_addendums', status, detail });
   }
 
+  // 10. dashboard_reachable — Phase 55. GRACEFUL-ABSENT: reports whether the
+  // GDD dashboard entrypoint is wired (bin/gdd-dashboard on disk) AND its data
+  // plane module loads. NEVER 'fail' — a missing bin is a 'warn' note because
+  // the dashboard is opt-in and also works via file-scrape. PURE read-only
+  // (fs.statSync + a wrapped require); NEVER throws, NEVER networks.
+  {
+    let status;
+    let detail;
+    try {
+      const gddRoot = resolveDashboardRoot(rootDir);
+      const binPresent = dashboardBinResolves(gddRoot);
+      const dataPlaneOk = dashboardDataPlaneLoads(gddRoot);
+      if (binPresent && dataPlaneOk) {
+        status = 'ok';
+        detail = 'dashboard: bin/gdd-dashboard present; data plane ok';
+      } else {
+        status = 'warn';
+        if (!binPresent && !dataPlaneOk) {
+          detail = 'dashboard: bin missing; data plane unavailable';
+        } else if (!binPresent) {
+          detail = 'dashboard: bin missing';
+        } else {
+          detail = 'dashboard: data plane unavailable';
+        }
+      }
+    } catch {
+      // Absolute safety net — the health probe must never crash on this check.
+      status = 'warn';
+      detail = 'dashboard: unavailable';
+    }
+    checks.push({ name: 'dashboard_reachable', status, detail });
+  }
+
   return { checks };
 }
 
@@ -402,4 +452,99 @@ function figmaVariablesBlockedLocally(rootDir) {
   }
 }
 
+/**
+ * Walk UP from `startDir` to the GDD package root (the first ancestor whose
+ * package.json `name` is the GDD package). This mirrors the Phase 53/54 lesson
+ * (sdk/dashboard/data/_pkg-root.cjs): NEVER resolve a cross-tree sibling via a
+ * fixed __dirname-relative jump. The shipped package name is scoped
+ * ("@hegemonart/get-design-done"); dev/self-host/fixture roots may use the bare
+ * "get-design-done" — both match. Bounded climb; defensive. Returns null if no
+ * GDD root marker is found.
+ *
+ * @param {string} startDir
+ * @returns {string|null} absolute package-root dir, or null
+ */
+function findGddPackageRoot(startDir) {
+  try {
+    let dir = path.resolve(startDir);
+    for (let i = 0; i < 12; i++) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+        if (pkg && typeof pkg.name === 'string') {
+          if (pkg.name === 'get-design-done' || /\/get-design-done$/.test(pkg.name)) {
+            return dir;
+          }
+        }
+      } catch {
+        // no/garbage package.json at this level — keep climbing
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve the AUTHORITATIVE GDD package root for the dashboard probe, given the
+ * project root being health-checked. Resolution (D-7 walk-up, never a fixed
+ * __dirname jump):
+ *   - If `rootDir` itself sits inside a GDD checkout (dev / self-host / a
+ *     hermetic fixture that declares the GDD name), THAT root is authoritative —
+ *     its own bin/ + sdk/dashboard/ are the truth. No cross-root fallback (so a
+ *     fixture is hermetic + deterministic regardless of the shipped tree).
+ *   - Otherwise `rootDir` is an unrelated CONSUMER project (no GDD marker); the
+ *     dashboard ships alongside THIS module, so walk up from __dirname.
+ * Returns null only if neither resolves (degrades the check to 'warn').
+ *
+ * @param {string} rootDir project root passed to getHealthChecks
+ * @returns {string|null}
+ */
+function resolveDashboardRoot(rootDir) {
+  const fromRoot = findGddPackageRoot(rootDir);
+  if (fromRoot) return fromRoot;
+  return findGddPackageRoot(__dirname);
+}
+
+/**
+ * Does the bin/gdd-dashboard trampoline resolve on disk under the authoritative
+ * GDD root? (Phase 55, check 10.) `fs.statSync` follows symlinks, so an npm
+ * bin-linked trampoline (a symlink resolving to a file) counts as present. PURE
+ * read-only; NEVER throws.
+ *
+ * @param {string} gddRoot authoritative GDD root (or null)
+ * @returns {boolean} true iff bin/gdd-dashboard is present on disk
+ */
+function dashboardBinResolves(gddRoot) {
+  if (!gddRoot) return false;
+  try {
+    return fs.statSync(path.join(gddRoot, 'bin', 'gdd-dashboard')).isFile();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Does the dashboard data plane module load + expose loadDashboardModel under
+ * the authoritative GDD root? (Phase 55, check 10.) The data plane is
+ * sdk/dashboard/data/source.cjs (R1 — the in-process shared-lib read surface the
+ * dashboard renders). A missing module or a require error degrades to false
+ * (→ 'warn'), NEVER throws.
+ *
+ * @param {string} gddRoot authoritative GDD root (or null)
+ * @returns {boolean} true iff source.cjs loads and exports loadDashboardModel
+ */
+function dashboardDataPlaneLoads(gddRoot) {
+  if (!gddRoot) return false;
+  try {
+    const mod = require(path.join(gddRoot, 'sdk', 'dashboard', 'data', 'source.cjs'));
+    return !!(mod && typeof mod.loadDashboardModel === 'function');
+  } catch {
+    return false;
+  }
+}
+
 module.exports = { getHealthChecks };