@hegemonart/get-design-done 1.37.2 → 1.38.5

package/scripts/lib/ds-arms/design-arms-store.cjs

@@ -0,0 +1,119 @@
+'use strict';
+/**
+ * scripts/lib/ds-arms/design-arms-store.cjs — Phase 38 `design_arms` posterior class.
+ *
+ * A NEW arm class, DISTINCT from the routing bandit's `routing_arms`
+ * (scripts/lib/bandit-router.cjs) — design_arms learn "which design pattern wins with USERS"
+ * from external A/B + user-research outcomes, not internal lint/test/visual signals (D-01).
+ * Isolated store: never touches the mature routing bandit. Keyed by
+ * (component_type, variant_pattern_hash) with a conservative Beta(2, 8) prior (posterior mean
+ * 0.2 — Phase 29 fairness-gate pattern: a pattern must EARN trust from real outcomes).
+ *
+ * No new dependency: an inline FNV-1a hash for the pattern key (no `crypto`, no egress). The
+ * posterior math is pure; persistence is an atomic write to `.design/telemetry/design-arms.json`
+ * (override `armsPath`/`baseDir` for hermetic tests).
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const SCHEMA_VERSION = '38.0';
+const DEFAULT_ARMS_PATH = '.design/telemetry/design-arms.json';
+// Conservative prior — Beta(2, 8), posterior mean 0.2. A design pattern is advisory until real
+// user-outcome data shifts it (D-03 — advisory, never directive).
+const DESIGN_ARM_PRIOR = Object.freeze({ alpha: 2, beta: 8 });
+
+/** Inline FNV-1a (32-bit) hash → 8-char hex. Deterministic, dependency-free. */
+function fnv1a(str) {
+  let h = 0x811c9dc5;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h.toString(16).padStart(8, '0');
+}
+
+/** variantKey(componentType, pattern) — a stable key for a design-arm. `pattern` may be a
+ *  string ("primary-CTA-bold") or an object (canonicalized by sorted JSON). */
+function variantKey(componentType, pattern) {
+  const p = typeof pattern === 'string' ? pattern : JSON.stringify(pattern, Object.keys(pattern || {}).sort());
+  return fnv1a(`${componentType}::${p}`);
+}
+
+function resolvePath(opts = {}) {
+  const p = opts.armsPath || DEFAULT_ARMS_PATH;
+  return path.isAbsolute(p) ? p : path.resolve(opts.baseDir || process.cwd(), p);
+}
+
+function load(opts = {}) {
+  const p = resolvePath(opts);
+  if (!fs.existsSync(p)) return { schema_version: SCHEMA_VERSION, generated_at: new Date().toISOString(), arms: [] };
+  try {
+    const data = JSON.parse(fs.readFileSync(p, 'utf8'));
+    if (!Array.isArray(data.arms)) data.arms = [];
+    return data;
+  } catch (e) {
+    return { schema_version: SCHEMA_VERSION, generated_at: new Date().toISOString(), arms: [] };
+  }
+}
+
+function save(store, opts = {}) {
+  const p = resolvePath(opts);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  store.schema_version = SCHEMA_VERSION;
+  store.generated_at = new Date().toISOString();
+  const tmp = p + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(store, null, 2));
+  fs.renameSync(tmp, p);
+}
+
+const meanOf = (alpha, beta) => alpha / (alpha + beta);
+
+/** pull(componentType, hash, opts) — the arm's posterior, or the conservative prior if unseen. */
+function pull(componentType, hash, opts = {}) {
+  const store = opts._store || load(opts);
+  const arm = store.arms.find((a) => a.component_type === componentType && a.variant_pattern_hash === hash);
+  if (!arm) {
+    return { component_type: componentType, variant_pattern_hash: hash, alpha: DESIGN_ARM_PRIOR.alpha, beta: DESIGN_ARM_PRIOR.beta, count: 0, mean: meanOf(DESIGN_ARM_PRIOR.alpha, DESIGN_ARM_PRIOR.beta), seen: false };
+  }
+  return { ...arm, mean: meanOf(arm.alpha, arm.beta), seen: true };
+}
+
+/**
+ * observe(componentType, hash, outcome, opts) — fold an external outcome into the arm.
+ * outcome: { won:boolean, weight?:number=1, source?:'ab'|'research'|'dev_time', pattern?, label? }.
+ * won → alpha += weight; lost → beta += weight. Persists (unless opts._store is supplied).
+ */
+function observe(componentType, hash, outcome = {}, opts = {}) {
+  const store = opts._store || load(opts);
+  const weight = typeof outcome.weight === 'number' && outcome.weight > 0 ? outcome.weight : 1;
+  let arm = store.arms.find((a) => a.component_type === componentType && a.variant_pattern_hash === hash);
+  if (!arm) {
+    arm = {
+      component_type: componentType,
+      variant_pattern_hash: hash,
+      label: outcome.label || null,
+      alpha: DESIGN_ARM_PRIOR.alpha,
+      beta: DESIGN_ARM_PRIOR.beta,
+      count: 0,
+      prior_class: 'design_arm',
+      last_source: null,
+      last_observed: null,
+    };
+    store.arms.push(arm);
+  }
+  if (outcome.won) arm.alpha += weight; else arm.beta += weight;
+  arm.count += 1;
+  arm.last_source = outcome.source || 'ab';
+  arm.last_observed = new Date().toISOString();
+  if (!opts._store) save(store, opts);
+  return { ...arm, mean: meanOf(arm.alpha, arm.beta) };
+}
+
+/** all(opts) — every arm with its posterior mean, for design-stage ranking (advisory). */
+function all(opts = {}) {
+  const store = opts._store || load(opts);
+  return store.arms.map((a) => ({ ...a, mean: meanOf(a.alpha, a.beta) }));
+}
+
+module.exports = { variantKey, pull, observe, all, load, save, fnv1a, DESIGN_ARM_PRIOR, SCHEMA_VERSION, DEFAULT_ARMS_PATH };

package/scripts/lib/rollout/rollout-status.cjs

@@ -0,0 +1,60 @@
+'use strict';
+/**
+ * scripts/lib/rollout/rollout-status.cjs — Phase 38.5 rollout-state classifier.
+ *
+ * Pure + dep-free (D-01): zero `require`. Given a NORMALIZED feature-flag state (the
+ * rollout-coordinator normalizes LaunchDarkly / Statsig / GrowthBook payloads to this shape),
+ * classify the per-cycle rollout state, the deployed percentage, whether a rollout is stuck,
+ * and the deployed-weight a `verify_outcome` observation carries into the `design_arms` posterior.
+ * Deterministic — same input → same output (hermetic tests, D-07).
+ *
+ * Normalized flag state:
+ *   { stagingEnabled: boolean, prodEnabled: boolean, prodPercent: number (0..100) }
+ *
+ * Rollout states: 'unrolled' | 'staging-only' | 'canary-N%' | 'prod-100%'
+ */
+
+const STUCK_DEFAULT_DAYS = 14; // D-04
+
+function clampPct(n) {
+  if (typeof n !== 'number' || !isFinite(n)) return 0;
+  return Math.max(0, Math.min(100, n));
+}
+
+/** classifyRollout(flagState) → the rollout-state string. */
+function classifyRollout(flagState = {}) {
+  const stagingEnabled = !!flagState.stagingEnabled;
+  const prodEnabled = !!flagState.prodEnabled;
+  const pct = clampPct(flagState.prodPercent);
+  if (!prodEnabled || pct === 0) {
+    return stagingEnabled || prodEnabled ? 'staging-only' : 'unrolled';
+  }
+  if (pct >= 100) return 'prod-100%';
+  return `canary-${pct}%`;
+}
+
+/** deployedPct(flagState) → the live production rollout percentage (0 when not in prod). */
+function deployedPct(flagState = {}) {
+  return flagState.prodEnabled ? clampPct(flagState.prodPercent) : 0;
+}
+
+/**
+ * isStuck(state, daysSinceChange, threshold=14) — a PARTIAL rollout (staging-only / canary-N%)
+ * that has not advanced for >= threshold days. A finished (prod-100%) or never-started (unrolled)
+ * rollout is never "stuck".
+ */
+function isStuck(state, daysSinceChange, threshold = STUCK_DEFAULT_DAYS) {
+  if (state === 'prod-100%' || state === 'unrolled') return false;
+  const partial = state === 'staging-only' || /^canary-\d+%$/.test(state);
+  return partial && typeof daysSinceChange === 'number' && daysSinceChange >= threshold;
+}
+
+/**
+ * deployedWeight(pct) — the weight a verify_outcome observation carries into design_arms.
+ * Linear (D-03): a 10%-rolled variant counts 0.1; 100% counts 1.0. Range [0, 1].
+ */
+function deployedWeight(pct) {
+  return clampPct(pct) / 100;
+}
+
+module.exports = { classifyRollout, deployedPct, isStuck, deployedWeight, clampPct, STUCK_DEFAULT_DAYS };

package/skills/brief/SKILL.md

@@ -54,8 +54,16 @@ Write the brief with these sections, preserving any pre-existing answers:
 
 ## Scope
 <answer>
+
+<prior-research>
+<!-- Phase 38: populated by agents/user-research-synthesizer.md from UserTesting/Maze/Hotjar
+     (pseudonymized) — ranked findings {finding · frequency · severity}. Empty on a fresh brief;
+     the verify stage cross-checks each finding (addressed or explicitly deferred). -->
+</prior-research>
 ```
 
+Leave the `<prior-research>` block empty on a greenfield brief — it is filled by `/gdd:research-sync` (the `user-research-synthesizer`) when a research source is connected, and re-checked at verify. See `reference/design-variants.md` for the outcome loop.
+
 ## Step 4 — Bootstrap STATE.md (if missing)
 
 <!-- BOOTSTRAP EXCEPTION: STATE.md does not exist yet — MCP tools require it to exist. Direct Write is intentional. All subsequent mutations use MCP. -->

package/skills/connections/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: gdd-connections
-description: "Interactive onboarding wizard for the 27 external integrations the pipeline supports — probes all (`figma`, `refero`, `preview`, `storybook`, `chromatic`, `graphify`, `pinterest`, `claude-design`, `paper-design`, `pencil-dev`, `21st-dev`, `magic-patterns`, `lazyweb`, `mobbin`, `slack`, `discord`, `linear`, `jira`, `notion`, `lottie`, `rive`, `framer`, `penpot`, `webflow`, `v0-dev`, `plasmic`, `builder-io`), recommends based on project type, walks the user through setup (auto-run MCP install or copy-command fallback), writes results to `STATE.md <connections>`. Use after `/gdd:new-project` or whenever the user wants to add, inspect, or skip a connection. Re-runnable anytime."
+description: "Interactive onboarding wizard for the 33 external integrations the pipeline supports — probes all (`figma`, `refero`, `preview`, `storybook`, `chromatic`, `graphify`, `pinterest`, `claude-design`, `paper-design`, `pencil-dev`, `21st-dev`, `magic-patterns`, `lazyweb`, `mobbin`, `slack`, `discord`, `linear`, `jira`, `notion`, `lottie`, `rive`, `framer`, `penpot`, `webflow`, `v0-dev`, `plasmic`, `builder-io`, `launchdarkly`, `statsig`, `growthbook`, `usertesting`, `maze`, `hotjar`), recommends based on project type, walks the user through setup (auto-run MCP install or copy-command fallback), writes results to `STATE.md <connections>`. Use after `/gdd:new-project` or whenever the user wants to add, inspect, or skip a connection. Re-runnable anytime."
 argument-hint: "[list | <connection-name> | --auto]"
 user-invocable: true
 tools: Read, Write, Bash, Glob, Grep, AskUserQuestion, ToolSearch
@@ -8,11 +8,11 @@ tools: Read, Write, Bash, Glob, Grep, AskUserQuestion, ToolSearch
 
 # /gdd:connections
 
-Interactive onboarding for the 27 external integrations the pipeline supports. Replaces "probe silently at scan entry and hope the user noticed" with an explicit "here is what can plug in, here is how."
+Interactive onboarding for the 33 external integrations the pipeline supports. Replaces "probe silently at scan entry and hope the user noticed" with an explicit "here is what can plug in, here is how."
 
 Canonical per-connection specs live in `../../connections/<name>.md` (one file per integration). The capability matrix + probe-pattern spec live in `../../connections/connections.md`. This skill is the **user-facing front end** for those specs.
 
-For the 27 probe scripts (MCP + HTTP + CLI + file probes), bucket categorization, per-connection setup screen, auto-run eligibility matrix, value-prop one-liners, and STATE.md / config.json write contracts, see `./connections-onboarding.md`. For the cross-skill probe pattern + connection-handshake summary, see `../../reference/shared-preamble.md#connection-handshake-summary`. For the cross-skill output discipline, see `../../reference/shared-preamble.md#output-contract-reminders`.
+For the 33 probe scripts (MCP + HTTP + CLI + file probes), bucket categorization, per-connection setup screen, auto-run eligibility matrix, value-prop one-liners, and STATE.md / config.json write contracts, see `./connections-onboarding.md`. For the cross-skill probe pattern + connection-handshake summary, see `../../reference/shared-preamble.md#connection-handshake-summary`. For the cross-skill output discipline, see `../../reference/shared-preamble.md#output-contract-reminders`.
 
 ---
 
@@ -38,7 +38,7 @@ For the 27 probe scripts (MCP + HTTP + CLI + file probes), bucket categorization
 
 ## Workflow
 
-1. **Probe all 27 connections** — run every probe script per `./connections-onboarding.md#step-1--probe-all-27-connections`. MCP probes use `ToolSearch` first; HTTP / CLI / file probes follow non-MCP patterns. Merge results into `STATE.md <connections>` with the three-value schema (`available | unavailable | not_configured`) — never add new values.
+1. **Probe all 33 connections** — run every probe script per `./connections-onboarding.md#step-1--probe-all-33-connections`. MCP probes use `ToolSearch` first; HTTP / CLI / file probes follow non-MCP patterns. Merge results into `STATE.md <connections>` with the three-value schema (`available | unavailable | not_configured`) — never add new values.
 2. **Categorize + build summary** — bucket each probe result (available / recommended / optional / skipped / unavailable) using project-hint detection. Detail + recommendation mapping: `./connections-onboarding.md#step-2--bucket-categorization`.
 3. **Print summary table** — show buckets + value-prop one-liners (verbatim from `./connections-onboarding.md#step-3--summary-table`).
 4. **Route by mode** — `list` / `--auto` exits after summary; `<name>` jumps straight to Step 5; default mode opens an AskUserQuestion (configure recommended / pick one by one / configure all optional / re-check specific / exit). Routing detail: `./connections-onboarding.md#step-4--route-by-mode`.

package/skills/connections/connections-onboarding.md

@@ -9,7 +9,7 @@ last_updated: 2026-05-18
 
 Source: extracted from `skills/connections/SKILL.md` (Phase 28.5 rework — D-10 extract-then-link).
 The skill's load-bearing routing + invocation-mode dispatch stays in `../skills/connections/SKILL.md`;
-this file holds the 27 probe scripts, bucket categorization, per-connection setup screen,
+this file holds the 33 probe scripts, bucket categorization, per-connection setup screen,
 auto-run eligibility matrix, value-prop one-liners, and STATE.md / config.json write contracts.
 
 # Connections Onboarding Procedure
@@ -27,7 +27,7 @@ this file does NOT duplicate them; it points at them by name.
 
 ---
 
-## Step 1 — Probe all 27 connections
+## Step 1 — Probe all 33 connections
 
 Run every probe below in order. MCP probes call `ToolSearch` first (deferred tools fail silently without it). Write every result to `STATE.md <connections>` when done.
 
@@ -238,7 +238,49 @@ ToolSearch({ query: "builder", max_results: 5 })
 → Non-empty → builder-io: available
 ```
 
-After all 27 probes complete, merge results into `STATE.md <connections>`. Preserve the three-value schema verbatim (`available | unavailable | not_configured`). Do not add new values.
+**launchdarkly:** (Outcome — experiment-source; read-only A/B)
+```
+ToolSearch({ query: "launchdarkly", max_results: 5 })  (else check the platform API-key env)
+→ Empty / GDD_DISABLE_LAUNCHDARKLY=1 → launchdarkly: not_configured
+→ Non-empty / key set                       → launchdarkly: available
+```
+
+**statsig:** (Outcome — experiment-source; read-only)
+```
+ToolSearch({ query: "statsig", max_results: 5 })  (else check the platform API-key env)
+→ Empty / GDD_DISABLE_STATSIG=1 → statsig: not_configured
+→ Non-empty / key set                       → statsig: available
+```
+
+**growthbook:** (Outcome — experiment-source; self-host/cloud)
+```
+ToolSearch({ query: "growthbook", max_results: 5 })  (else check the platform API-key env)
+→ Empty / GDD_DISABLE_GROWTHBOOK=1 → growthbook: not_configured
+→ Non-empty / key set                       → growthbook: available
+```
+
+**usertesting:** (Outcome — user-research; pseudonymize-first)
+```
+ToolSearch({ query: "usertesting", max_results: 5 })  (else check the platform API-key env)
+→ Empty / GDD_DISABLE_USERTESTING=1 → usertesting: not_configured
+→ Non-empty / key set                       → usertesting: available
+```
+
+**maze:** (Outcome — user-research; pseudonymize-first)
+```
+ToolSearch({ query: "maze", max_results: 5 })  (else check the platform API-key env)
+→ Empty / GDD_DISABLE_MAZE=1 → maze: not_configured
+→ Non-empty / key set                       → maze: available
+```
+
+**hotjar:** (Outcome — user-research; indexed insights only)
+```
+ToolSearch({ query: "hotjar", max_results: 5 })  (else check the platform API-key env)
+→ Empty / GDD_DISABLE_HOTJAR=1 → hotjar: not_configured
+→ Non-empty / key set                       → hotjar: available
+```
+
+After all 33 probes complete, merge results into `STATE.md <connections>`. Preserve the three-value schema verbatim (`available | unavailable | not_configured`). Do not add new values.
 
 ---
 
@@ -334,6 +376,12 @@ One-line value props (use verbatim):
 | v0-dev | generator — Vercel v0 prompt→component (MCP-first → REST + V0_API_KEY) |
 | plasmic | generator + canvas — emit code + read the Plasmic canvas |
 | builder-io | generator — Builder.io Visual Copilot (pull-only this phase) |
+| launchdarkly | outcome — read A/B results → design_arms posterior (experiment-source) |
+| statsig | outcome — read experiment/pulse results → design_arms (experiment-source) |
+| growthbook | outcome — read experiment results → design_arms (experiment-source; OSS) |
+| usertesting | outcome — read test reports → brief findings (user-research; pseudonymized) |
+| maze | outcome — read usability metrics → brief findings (user-research; pseudonymized) |
+| hotjar | outcome — read indexed insights → brief findings (user-research; pseudonymized) |
 
 ---
 
@@ -361,7 +409,7 @@ options:
   - "Exit"                            → emit ## CONNECTIONS COMPLETE, exit
 ```
 
-If recommended bucket is empty, swap that option for "Show all 27 and pick."
+If recommended bucket is empty, swap that option for "Show all 33 and pick."
 
 ---
 
@@ -433,6 +481,12 @@ options:
 | v0-dev | `claude mcp add v0 ...` (or V0_API_KEY) | ✓ yes | Reversible; MCP-first → REST fallback |
 | plasmic | `claude mcp add plasmic ...` (or token) | ✓ yes | Reversible; dual canvas+generator |
 | builder-io | `claude mcp add builder ...` (or BUILDER_API_KEY) | ✓ yes | Reversible; pull-only this phase |
+| launchdarkly | (set `LAUNCHDARKLY_API_KEY` / add the LaunchDarkly MCP) | ✓ yes | Reversible; read-only experiment-source |
+| statsig | (set `STATSIG_API_KEY` / add the Statsig MCP) | ✓ yes | Reversible; read-only experiment-source |
+| growthbook | (set `GROWTHBOOK_API_KEY` [+ host] / add the MCP) | ✓ yes | Reversible; self-host or cloud |
+| usertesting | (set `USERTESTING_API_KEY` / add the MCP) | ✓ yes | Reversible; read-only; pseudonymize-first |
+| maze | (set `MAZE_API_KEY` / add the MCP) | ✓ yes | Reversible; read-only; pseudonymize-first |
+| hotjar | (set `HOTJAR_API_KEY` / add the MCP) | ✓ yes | Reversible; indexed insights only; pseudonymize-first |
 
 For non-auto-run connections, hide the "Run install command now" option entirely in 5.3.
 

package/skills/design/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: design
 description: "Stage 4 of 5 orchestrator that reads DESIGN-PLAN.md, partitions tasks by wave + parallel-safe flag, and spawns design-executor agents with the appropriate isolation (worktree for parallel batches, in-place for sequential tail). Use when DESIGN-PLAN.md is approved and ready for implementation."
-argument-hint: "[--auto] [--parallel]"
+argument-hint: "[--auto] [--parallel] [--variants N]"
 user-invocable: true
 tools: Read, Write, Bash, Grep, Glob, Task, AskUserQuestion, mcp__gdd_state__get, mcp__gdd_state__transition_stage, mcp__gdd_state__update_progress, mcp__gdd_state__set_status, mcp__gdd_state__add_blocker, mcp__gdd_state__resolve_blocker, mcp__gdd_state__checkpoint
 ---
@@ -28,6 +28,7 @@ Detail: `./design-procedure.md` §Stage entry.
 
 - `--auto` -> `auto_mode=true` (no mid-stage prompts; architectural deviations stop the individual task but continue the rest).
 - `--parallel` -> `parallel_mode=true` (use worktree isolation for `Parallel: true` tasks).
+- `--variants N` -> `variants_mode` (default N=2): for tasks that build a user-facing surface, the executor emits **N competing, hypothesis-tagged variants** (`<variant id component pattern hypothesis>`) instead of one. Before generating, consult the `design_arms` posterior (`scripts/lib/ds-arms/design-arms-store.cjs`) to bias toward patterns that have won prior A/B / user-research outcomes — **advisory, never directive** (the user's explicit choice always wins). The tagged variants flow to A/B (LaunchDarkly/Statsig/GrowthBook) for outcome ingestion. Full schema + the outcome loop: `../../reference/design-variants.md`.
 - **Directionally-open check** (skipped if `auto_mode`): scan DESIGN-PLAN.md for tasks whose criteria read "explore N directions" / "pick a visual approach" and suggest `/gdd:sketch` first.
 - **Project-local conventions**: include any `./.claude/skills/design-*-conventions.md` and `~/.claude/gdd/global-skills/*.md` in every executor's `<required_reading>` — global conventions inform but do not override project-local D-XX decisions.
 - **`.stories.tsx` stub**: after each new component file is created by the executor, emit a CSF stub alongside if `.storybook/` exists or `"storybook"` is in `package.json`, even with the dev server offline. Detail: `./design-procedure.md` §.stories.tsx Stub.

package/skills/rollout-status/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: gdd-rollout-status
+description: "Shows where a finished design cycle actually is in production rollout — unrolled / staging-only / canary-N% / prod-100% — by reading the feature-flag service (LaunchDarkly/Statsig/GrowthBook) via the rollout-coordinator. Surfaces STUCK rollouts (a canary that hasn't advanced for N days) and the design_arms outcome weighting. Read-only — GDD never advances or rolls back; it reports and notifies. Use after /gdd:ship to track the post-merge journey."
+argument-hint: "[<cycle>] [--all] [--stuck]"
+user-invocable: true
+tools: Read, Bash, Grep, Glob, ToolSearch, Task
+---
+
+# /gdd:rollout-status
+
+Closes the visibility gap after `/gdd:ship`: a PR merges, but staging → canary → 100% rollout happens outside GDD. This skill reports where each cycle's design actually is in production, by delegating to `agents/rollout-coordinator.md` (which reads the feature-flag service via the Phase 38 connections). **Read-only** — it reports + notifies; it never advances or rolls back a rollout. Contract + the `<rollout_status>` schema: `../../reference/rollout-coordination.md`.
+
+## Invocation
+
+| Command | Behavior |
+|---|---|
+| `/gdd:rollout-status` | The current cycle's rollout state (from `.design/STATE.md <rollout_status>`, refreshed via the coordinator). |
+| `/gdd:rollout-status <cycle>` | A specific cycle's rollout state. |
+| `/gdd:rollout-status --all` | Every cycle with a `<rollout_status>` block — a rollout dashboard. |
+| `/gdd:rollout-status --stuck` | Only the **stuck** rollouts (partial rollouts that haven't advanced for ≥ the threshold). |
+
+## Steps
+
+1. **Probe the flag service.** Check a flag connection is `available` (`connections/launchdarkly.md` / `statsig.md` / `growthbook.md`). None → print `rollout-status: no flag service configured — connect one via /gdd:connections.` and exit.
+2. **Delegate to `rollout-coordinator`** (via `Task`): it reads the service, classifies via `scripts/lib/rollout/rollout-status.cjs`, refreshes the `<rollout_status>` block, and reports state + deployed % + stuck.
+3. **Render.** Show each cycle: `state` · `deployed_pct` · `last_changed` · `stuck?`. For `--stuck`, list only stuck cycles with the days-since-change and an advance-or-rollback suggestion.
+4. **Do not act.** Never run a flag-service mutation, advance a canary, or roll back — GDD reports; the human + the flag service decide.
+
+## Output
+
+End with:
+
+```
+## ROLLOUT-STATUS COMPLETE
+```