@hegemonart/get-design-done 1.38.0 → 1.38.5

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.38.0"
+    "version": "1.38.5"
   },
   "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.38.0",
+      "version": "1.38.5",
       "author": {
         "name": "hegemonart"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "get-design-done",
   "short_name": "gdd",
-  "version": "1.38.0",
+  "version": "1.38.5",
   "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), 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,28 @@ All notable changes to get-design-done are documented here. Versions follow [sem
 
 ---
 
+## [1.38.5] - 2026-06-01
+
+### Phase 38.5 — Deployment Coordination Loop
+
+Bridges the gap between `/gdd:verify` passing and the design **actually being live**. `/gdd:ship` ends at "PR merged"; the post-merge journey (staging → canary % → 100% rollout) was invisible. 38.5 reads the feature-flag service (Phase 38's LaunchDarkly/Statsig/GrowthBook connections), tracks per-cycle rollout %, and weights the `design_arms` posterior by how widely a variant actually deployed. **No new runtime dependency, no new egress** (pure classifier + the Phase-38 read-only connections). **Read-only** — GDD reports + notifies; it never advances or rolls back.
+
+### Added
+
+- **`scripts/lib/rollout/rollout-status.cjs`** — pure, dep-free classifier: `classifyRollout` (`unrolled`/`staging-only`/`canary-N%`/`prod-100%`), `deployedPct`, `isStuck` (default 14 days), `deployedWeight` (linear). Deterministic.
+- **`agents/rollout-coordinator.md`** — reads the flag service → classifies → writes `STATE.md <rollout_status>` → emits `rollout_*`/`verify_outcome` events → folds the outcome into `design_arms` weighted by `deployedPct` (a 10%-rolled variant counts 0.1; a 100% one counts 1.0). Read-only, notify-on-stuck.
+- **`skills/rollout-status/SKILL.md`** (`/gdd:rollout-status [<cycle>] [--all] [--stuck]`) — reports rollout state + surfaces stuck rollouts.
+- **`reference/rollout-coordination.md`** — the `<rollout_status>` schema + state transitions + the deployed_pct weighting + the events. Registered.
+- **`reference/schemas/events.schema.json`** — the free-form `type` seed list gains `verify_outcome` / `rollout_started` / `rollout_advanced` / `rollout_stuck` (Phase 22 extension).
+
+### Notes
+
+- **No new runtime dependency, no new egress** — pure classifier; the flag-service reads reuse Phase 38's read-only connections.
+- 6-manifest lockstep at **v1.38.5** + `OFF_CADENCE_VERSIONS.add('1.38.5')` + the 29 live-pinned `manifests-version.txt` baselines forward-propagated 1.38.0 → 1.38.5.
+- Inventory relock: skill-list 76 → 77 (+`rollout-status`), agent-list 52 → 53 (+`rollout-coordinator`) + both frontmatter-snapshots, registry-diff 152 → 153, tarball golden 690 → 694 (+4), and the phase-20 `event-schema-snapshot.json` sha256 re-locked (the seed-list edit). Root `SKILL.md` command table + `command-count-sync` updated.
+
+---
+
 ## [1.38.0] - 2026-06-01
 
 ### Phase 38 — Outcome-Driven Adaptation (A/B Variants + Inbound User-Research Signals)

package/README.md

@@ -174,6 +174,10 @@ Six more AI-native design tools join the connection layer (Phase 14's backlog, n
 
 GDD now learns **which design patterns win with users**, not just which pass lint. `/gdd:design --variants N` emits N competing, hypothesis-tagged variants; a new `design_arms` posterior ([`design-arms-store`](scripts/lib/ds-arms/design-arms-store.cjs) — Beta(2,8), distinct from the routing bandit) consults prior outcomes to bias generation (**advisory, never directive**). Two read-only external signal sources close the loop: **A/B experiments** ([LaunchDarkly / Statsig / GrowthBook](connections/launchdarkly.md) → [`experiment-result-ingester`](agents/experiment-result-ingester.md)) and **user research** ([UserTesting / Maze / Hotjar](connections/usertesting.md) → [`user-research-synthesizer`](agents/user-research-synthesizer.md)), the latter **pseudonymized before any agent context** (a tested PII guard). Findings populate the brief's `<prior-research>` block, which verify cross-checks. **No new runtime dependency.** Onboarding 27 → 33.
 
+### Deployment coordination (v1.38.5)
+
+GDD now tracks a design past "PR merged" to **actually live**. [`/gdd:rollout-status`](skills/rollout-status/SKILL.md) reads the feature-flag service (the Phase 38 LaunchDarkly/Statsig/GrowthBook connections) via [`rollout-coordinator`](agents/rollout-coordinator.md) and classifies each cycle — `unrolled` / `staging-only` / `canary-N%` / `prod-100%` — surfacing **stuck** rollouts (a canary that hasn't advanced in N days). The pure [`rollout-status`](scripts/lib/rollout/rollout-status.cjs) classifier also computes a **deployed-percentage weight** that feeds the `design_arms` posterior via `verify_outcome` events — a variant that only reached 10% of users counts as weak evidence (0.1), a fully-rolled one counts 1.0. **Read-only** (GDD never advances or rolls back) and **no new runtime dependency**.
+
 ### Previous releases
 
 - **v1.26.0** — Headless Model Resolver (per-runtime tier→model map, `resolved_models` router field, per-runtime price tables, `reasoning-class` runtime-neutral alias).

package/SKILL.md

@@ -101,6 +101,7 @@ Each stage produces artifacts in `.design/` inside the current project.
 | `benchmark <component\|--wave N\|--list\|--refresh component>` | `get-design-done:gdd-benchmark` | Harvest + synthesize per-component design specs from 18 design systems → `reference/components/<name>.md` |
 | `export <cycle> --format html\|pdf\|notion [--pseudonymize] [--pr]` | `get-design-done:gdd-export` | Phase 35.5 — package a finished cycle's design output into a stakeholder-shareable artifact (self-contained HTML / Paged.js-print PDF / Notion page); redacts always, `--pseudonymize` masks identity for external sharing, `--pr` posts the HTML preview via pr-commenter |
 | `bootstrap-ds [--primary <color>] [--secondary <color>] [--tone <tags>] [--framework <t>]` | `get-design-done:gdd-bootstrap-ds` | Phase 37.2 — bootstrap a design system for a GREENFIELD project (no DS): brand input → OKLCH token system (color tints + modular type + 4pt/8pt spacing + radius/motion) in 3 variants to pick, then button/input/card proof scaffolding via `ds-generator` |
+| `rollout-status [<cycle>] [--all] [--stuck]` | `get-design-done:gdd-rollout-status` | Phase 38.5 — track a shipped cycle's production rollout (unrolled / staging-only / canary-N% / prod-100%) by reading the feature-flag service via `rollout-coordinator`; surfaces STUCK rollouts; feeds `design_arms` by deployed %. Read-only — never advances or rolls back |
 
 ## Handoff Routing
 

package/agents/rollout-coordinator.md

@@ -0,0 +1,71 @@
+---
+name: rollout-coordinator
+description: Tracks a design cycle from "PR merged" to "live for 100% of users". Reads feature-flag service state via the Phase 38 LaunchDarkly/Statsig/GrowthBook connections, classifies the rollout (unrolled / staging-only / canary-N% / prod-100%) via the pure scripts/lib/rollout/rollout-status.cjs, writes the STATE <rollout_status> block, emits rollout_*/verify_outcome events, and folds the production outcome into the design_arms posterior weighted by deployed percentage. Read-only — notifies on stuck/rollback, never drives the rollout.
+tools: Read, Bash, Grep, Glob, ToolSearch
+color: green
+default-tier: sonnet
+tier-rationale: "Mechanical classification of flag-service state + a weighted posterior update via pure helpers; no design judgment — sonnet-tier."
+size_budget: M
+size_budget_rationale: "Honest tier sized to the ~100-line body. DELEGATES the classification math to scripts/lib/rollout/rollout-status.cjs, the posterior to scripts/lib/ds-arms/design-arms-store.cjs, the per-service probe to connections/{launchdarkly,statsig,growthbook}.md, and the contract to reference/rollout-coordination.md."
+parallel-safe: false
+typical-duration-seconds: 30
+reads-only: false
+writes:
+  - ".design/STATE.md (the <rollout_status> block)"
+  - ".design/telemetry/design-arms.json"
+  - ".design/intel/insights.jsonl"
+---
+
+@reference/shared-preamble.md
+
+# rollout-coordinator
+
+## Role
+
+Close the deployment loop: GDD's pipeline ends at "PR merged", but the post-merge journey (staging → canary % → 100%) is invisible. Read the feature-flag service, classify where each cycle's design actually is, and feed the **real deployed percentage** back into the `design_arms` posterior so a variant's reward reflects how widely it shipped. **Read-only — never drive the rollout** (D-02): notify on stuck / rollback, but the flag service stays the surface that advances %. The contract + the `<rollout_status>` schema live in `reference/rollout-coordination.md`.
+
+## When invoked
+
+After `/gdd:ship` merges a cycle's PR, and on demand via `/gdd:rollout-status`. Gate on an experiment-source/flag connection being `available` (per `connections/launchdarkly.md` / `statsig.md` / `growthbook.md`); none → `rollout: no flag service configured — skipped.` (degrade-to-noop).
+
+## Step 1 — Read the flag service (read-only)
+
+Probe the configured service (ToolSearch MCP, else the platform API key env; injectable read path for hermetic tests). Read the cycle's flag: staging enablement, prod enablement, prod rollout %, and when it last changed. Normalize to `{ stagingEnabled, prodEnabled, prodPercent }` + `daysSinceChange`. Read-only scopes only.
+
+## Step 2 — Classify
+
+```bash
+node -e "const r=require('./scripts/lib/rollout/rollout-status.cjs'); \
+  const s=r.classifyRollout(FLAG); \
+  console.log(JSON.stringify({ state:s, pct:r.deployedPct(FLAG), stuck:r.isStuck(s, DAYS, THRESHOLD) }))"
+```
+
+`THRESHOLD` = `.design/config.json rollout.stuck_days` (default 14).
+
+## Step 3 — Write STATE + emit events
+
+Write the `<rollout_status>` block (cycle, state, deployed_pct, flag_service, last_changed, stuck) per `reference/rollout-coordination.md`. Emit the matching event(s) into `.design/intel/insights.jsonl`: `rollout_started` (first prod exposure), `rollout_advanced` (% up / → 100%), `rollout_stuck` (crossed the threshold). PII-free payloads (cycle/component/pattern/percent only).
+
+## Step 4 — Feed `design_arms` (deployed_pct weighting)
+
+When the cycle's variant is in prod and an outcome is known (won/lost per the experiment or a manual call), fold it into the posterior **weighted by deployment**:
+
+```bash
+node -e "const {deployedWeight}=require('./scripts/lib/rollout/rollout-status.cjs'); \
+  const {variantKey,observe}=require('./scripts/lib/ds-arms/design-arms-store.cjs'); \
+  observe(COMPONENT, variantKey(COMPONENT, PATTERN), { won: WON, weight: deployedWeight(PCT), source: 'verify_outcome' });"
+```
+
+A 10%-rolled variant contributes a 0.1-weight observation; 100% → full weight (D-03). Emit a `verify_outcome` event carrying `deployed_pct` + `weight`. This is a **slow-loop** reward, distinct from internal lint/test signals.
+
+## Stuck handling (notify only)
+
+If `stuck`, surface it ("cycle X has been canary-10% for 18 days") and suggest advance-or-rollback. **Do not** auto-advance or roll back — append no `<blocker>`; the human + the flag service own the decision.
+
+## Record
+
+Emit a `## Rollout status` summary: per-cycle state, deployed %, stuck flag, and any posterior update (component → pattern → weight). Close with:
+
+```
+## ROLLOUT COORDINATION COMPLETE
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hegemonart/get-design-done",
-  "version": "1.38.0",
+  "version": "1.38.5",
   "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",

package/reference/registry.json

@@ -986,6 +986,13 @@
       "type": "heuristic",
       "phase": 38,
       "description": "Phase 38 design-variants schema + the design_arms outcome loop: /gdd:design --variants N emits N hypothesis-tagged competing variants (<variant id component pattern hypothesis>); each (component_type, variant_pattern_hash) is a Beta(2,8) arm in scripts/lib/ds-arms/design-arms-store.cjs that learns which patterns win with USERS from A/B (experiment-result-ingester) + user-research (user-research-synthesizer) outcomes. Advisory not directive (the user always wins, D-03). Distinct from the routing bandit."
+    },
+    {
+      "name": "rollout-coordination",
+      "path": "reference/rollout-coordination.md",
+      "type": "heuristic",
+      "phase": 38.5,
+      "description": "Phase 38.5 rollout-coordination contract: the <rollout_status> STATE block (unrolled/staging-only/canary-N%/prod-100%), stuck detection (default 14 days), linear deployed_pct weighting feeding design_arms via verify_outcome (a 10%-rolled variant counts 0.1), and the rollout_started/advanced/stuck/verify_outcome events. Classifier scripts/lib/rollout/rollout-status.cjs; agent agents/rollout-coordinator.md; skill /gdd:rollout-status. Read-only — GDD never drives the rollout."
     }
   ]
 }

package/reference/rollout-coordination.md

@@ -0,0 +1,63 @@
+# Rollout Coordination — the `<rollout_status>` contract + the verify→prod loop
+
+How GDD tracks a design from "PR merged" to "live for 100% of users", and feeds the **actual deployment percentage** back into the `design_arms` posterior so a variant's reward reflects how widely it was really shipped. The deterministic classifier is `scripts/lib/rollout/rollout-status.cjs`; the orchestration is `agents/rollout-coordinator.md` + `/gdd:rollout-status`. GDD **reads** the feature-flag service (via the Phase 38 LaunchDarkly/Statsig/GrowthBook connections) — it never drives the rollout.
+
+---
+
+## Rollout states
+
+A cycle's rollout is classified from a normalized flag state (`{ stagingEnabled, prodEnabled, prodPercent }`):
+
+| State | Meaning |
+|---|---|
+| `unrolled` | not in staging or prod |
+| `staging-only` | enabled in staging (or prod-enabled at 0%) — no prod traffic |
+| `canary-N%` | live to N% of prod (0 < N < 100) |
+| `prod-100%` | fully rolled out |
+
+`deployedPct(flagState)` returns the live prod percentage (0 when not in prod).
+
+## The `<rollout_status>` STATE block
+
+The coordinator writes one block per cycle into `.design/STATE.md`:
+
+```xml
+<rollout_status>
+cycle: 2026-06-checkout-redesign
+state: canary-10%
+deployed_pct: 10
+flag_service: launchdarkly
+last_changed: 2026-05-20
+stuck: false
+</rollout_status>
+```
+
+`state` ∈ the four states above; `deployed_pct` 0–100; `stuck` is `true` when a **partial** rollout (`staging-only`/`canary-N%`) has not advanced for ≥ the threshold.
+
+## Stuck detection
+
+`isStuck(state, daysSinceChange, threshold)` — a partial rollout that has not progressed for ≥ `threshold` days (default **14**, configurable via `.design/config.json rollout.stuck_days`). `prod-100%` and `unrolled` are never stuck. `/gdd:rollout-status` surfaces stuck cycles ("canary-10% for 18 days — advance or roll back?"). GDD **notifies**; it does not auto-advance or roll back (read-only — D-02).
+
+## Feeding `design_arms` (deployed_pct weighting)
+
+When a cycle's variant reaches prod, the coordinator folds the outcome into the `design_arms` posterior weighted by how widely it deployed (D-03, linear):
+
+```js
+const { deployedWeight } = require('scripts/lib/rollout/rollout-status.cjs');
+const { variantKey, observe } = require('scripts/lib/ds-arms/design-arms-store.cjs');
+observe(component, variantKey(component, pattern),
+        { won, weight: deployedWeight(deployed_pct), source: 'verify_outcome' });
+```
+
+`deployedWeight(pct) = pct/100` — a variant rolled to 10% contributes a 0.1-weight observation; a fully-rolled variant contributes 1.0. This keeps the bandit honest: a "win" that only reached 10% of users is weak evidence. `verify_outcome` is a **slow-loop** reward, distinct from internal lint/test signals.
+
+## Events (Phase 22 chain)
+
+The coordinator emits free-form `type` events (registered in `reference/schemas/events.schema.json`):
+
+- `rollout_started` — first prod exposure (`unrolled`/`staging-only` → `canary-N%`).
+- `rollout_advanced` — canary % increased, or → `prod-100%`.
+- `rollout_stuck` — a partial rollout crossed the stuck threshold.
+- `verify_outcome` — the outcome fed to `design_arms` (carries `deployed_pct` + `weight`).
+
+All event payloads are PII-free (cycle id, component, pattern slug, percentages — no user data).

package/reference/schemas/events.schema.json

@@ -10,7 +10,7 @@
     "type": {
       "type": "string",
       "minLength": 1,
-      "description": "Free-form event type identifier. Pre-registered seeds: state.mutation, state.transition, stage.entered, stage.exited, hook.fired, error, capability_gap, kfm-candidate, router_pick."
+      "description": "Free-form event type identifier. Pre-registered seeds: state.mutation, state.transition, stage.entered, stage.exited, hook.fired, error, capability_gap, kfm-candidate, router_pick, verify_outcome, rollout_started, rollout_advanced, rollout_stuck."
     },
     "timestamp": {
       "type": "string",

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/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
+```