@hegemonart/get-design-done 1.23.0 → 1.24.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.23.0"
+    "version": "1.24.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.23.0",
+      "version": "1.24.0",
       "author": {
         "name": "hegemonart"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "get-design-done",
   "short_name": "gdd",
-  "version": "1.23.0",
+  "version": "1.24.0",
   "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.",
   "author": {
     "name": "hegemonart",

package/CHANGELOG.md

@@ -4,6 +4,103 @@ All notable changes to get-design-done are documented here. Versions follow [sem
 
 ---
 
+## [1.24.0] — 2026-04-25
+
+Phase 24 Multi-Runtime Installer milestone — `npx @hegemonart/get-design-done` with no flags now launches a polished interactive install session (`@clack/prompts`) that walks the user through a multi-select of all 14 supported AI coding runtimes plus a Global/Local radio. Scripted / CI installs continue to work via the existing flag surface unchanged. Strict superset over v1.23.5: any non-zero invocation still works exactly as before.
+
+### Added
+
+- **Per-runtime install matrix** — `scripts/lib/install/runtimes.cjs` exports a 14-entry frozen list. Each entry: `{id, displayName, configDirEnv, configDirFallback, kind, files, marketplaceEntry?}`. Two install kinds are supported: `claude-marketplace` (registers an `extraKnownMarketplaces` entry + flips `enabledPlugins[<plugin>@<marketplace>]`, today only Claude Code) and `agents-md` (drops a runtime-specific instructions file in the runtime's config dir, used by the other 13). Adding a new runtime is one append to this file + one append to `test-fixture/baselines/phase-24/runtimes.txt`. (Plan 24-01)
+
+- **14 runtimes scoped** — Claude Code, OpenCode, Gemini CLI, Kilo Code, OpenAI Codex CLI, GitHub Copilot CLI, Cursor, Windsurf, Antigravity, Augment, Trae, Qwen Code, CodeBuddy, Cline. Gemini drops `GEMINI.md`; the other 12 `agents-md` runtimes drop `AGENTS.md`. (Plan 24-01)
+
+- **Config-dir lookup chain** — `scripts/lib/install/config-dir.cjs` exposes `resolveConfigDir(runtimeId, opts)` and `resolveAllConfigDirs(opts)`. Precedence: explicit `--config-dir` flag > per-runtime env var (`CLAUDE_CONFIG_DIR`, `OPENCODE_CONFIG_DIR`, `GEMINI_CONFIG_DIR`, `CODEX_HOME`, `CURSOR_CONFIG_DIR`, …) > POSIX/Windows fallback at `$HOME/$USERPROFILE` joined with the runtime's `configDirFallback`. Mirrors GSD `install.js`'s lookup pattern. (Plan 24-01)
+
+- **Settings merge / unmerge primitives** — `scripts/lib/install/merge.cjs` exports pure `mergeClaudeSettings(existing, marketplaceEntry) → {next, changed}` and `removeClaudeSettings(existing, marketplaceEntry) → {next, changed}`. Both are idempotent and preserve unrelated user keys. `buildAgentsFileContent(runtime)` produces the runtime-tagged AGENTS.md/GEMINI.md payload with a `<!-- get-design-done plugin instructions -->` fingerprint. `isPluginOwned(content)` is the inverse used by uninstall + foreign-file detection. (Plan 24-02)
+
+- **Per-runtime install/uninstall orchestrator** — `scripts/lib/install/installer.cjs` exports `installRuntime(runtimeId, opts)` and `uninstallRuntime(runtimeId, opts)`, both returning a structured `Result = {runtime, path, action: 'created'|'updated'|'unchanged'|'removed'|'skipped-foreign', dryRun, reason?}`. Atomic writes (`.tmp-<pid>` + rename) throughout. Foreign AGENTS.md/GEMINI.md files (no plugin fingerprint) are never clobbered — install reports `skipped-foreign` with a remediation hint. `detectInstalled(opts)` scans every runtime's config dir and returns the IDs that have a plugin-owned install. (Plan 24-02)
+
+- **`@clack/prompts` interactive session** — `scripts/lib/install/interactive.cjs` exports `runInteractiveInstall()` (3 steps: multi-select runtimes → Global/Local radio → confirmation) and `runInteractiveUninstall(opts)` (2 steps: multi-select detected-installed → confirmation). ESC at any step returns `null` so the entrypoint exits 0 with a "cancelled" message — no partial writes. `@clack/prompts ^0.7.0` added as a runtime dependency (~8KB). (Plan 24-03)
+
+- **Multi-runtime entrypoint** — `scripts/install.cjs` rewritten as a router. Decision tree: zero flags + TTY → interactive multi-select; zero flags + non-TTY (CI, pipes) → defaults to `--claude --global` for backwards compatibility with v1.23.5; any explicit per-runtime flag (or `--all`) → scripted, no prompts. `--uninstall` with no runtime list also enters interactive mode and only shows runtimes detected as installed. Per-runtime summary printed at the end with per-runtime path + action. (Plan 24-04)
+
+- **Existing flag surface preserved 1:1** — `--claude`, `--opencode`, `--gemini`, `--kilo`, `--codex`, `--copilot`, `--cursor`, `--windsurf`, `--antigravity`, `--augment`, `--trae`, `--qwen`, `--codebuddy`, `--cline`, `--all`, `--global`, `--local`, `--uninstall`, `--config-dir <path>`, `--dry-run`, `--help`, `-h`. Existing CI installs (`CLAUDE_CONFIG_DIR=/tmp npx @hegemonart/get-design-done`) continue to work with no source changes. (Plan 24-04)
+
+- **Idempotent + foreign-safe install** — re-running install over an already-installed runtime emits `unchanged` with the v1.23.5 "already registered" message preserved. AGENTS.md / GEMINI.md files NOT authored by this plugin are detected via missing fingerprint and never overwritten or deleted by uninstall. (Plan 24-02)
+
+### Changed
+
+- `tests/semver-compare.test.cjs` `OFF_CADENCE_VERSIONS` gains `1.24.0`.
+- `scripts/install.cjs` — full rewrite. The original v1.23.5 single-runtime marketplace registration logic is now extracted into `scripts/lib/install/merge.cjs` (`mergeClaudeSettings` / `removeClaudeSettings`) and reused by the new orchestrator.
+
+### Tests
+
+- `tests/install-runtimes.test.cjs` — 14-entry shape, kind/file mapping per runtime, baseline-file alignment, ID uniqueness, unknown-runtime throws (10 tests).
+- `tests/install-config-dir.test.cjs` — env override, explicit override, fallback resolution, empty env-var fallthrough, all-runtimes resolution (8).
+- `tests/install-merge.test.cjs` — merge/remove idempotency + key preservation, fingerprint helpers, full install→idempotent→uninstall round-trips for both kinds, foreign-file refusal + missing-target uninstall (15).
+- `tests/phase-24-baseline.test.cjs` — 3-manifest version alignment at 1.24.0, `@clack/prompts` registration, surface-export contract per module, runtimes.txt baseline match, install.cjs rewrite anchor (8).
+- All 7 existing `tests/install-script.test.cjs` end-to-end spawn tests pass against the rewritten entrypoint.
+
+Total: 41 new tests. All Phase 20/21/22/23/23.5 tests still green.
+
+### Deferred
+
+- Stdin-simulation integration tests for the interactive flow itself (requires a PTY shim; manual smoke-test on Windows CMD / PowerShell / Windows Terminal covers v1).
+- Auto-detection of installed runtimes during the install flow (multi-select with all 14 visible is sufficient for v1; uninstall flow already filters to detected-installed via `detectInstalled`).
+- Per-runtime MCP server registration writes — each runtime's MCP entry format differs and the install matrix records the format but does not generate the entries.
+
+---
+
+## [1.23.5] — 2026-04-25
+
+Phase 23.5 No-Regret Adaptive Layer milestone — turns the passive Phase 22–23 observability + validation infrastructure into a closed self-tuning loop. Three tightly-scoped no-regret algorithms sharing one feature-flag ladder. Single-user viable via informed Beta-prior bootstrap (no shared telemetry required). Ships as a decimal patch on the v1.23 minor — does NOT shift Phase 24 → v1.24.0.
+
+### Added
+
+- **Bandit router** — `scripts/lib/bandit-router.cjs` implements contextual Thompson sampling over `(agent_type, touches_size_bin) → {haiku, sonnet, opus}`. Per-arm `Beta(α, β)` posterior at `.design/telemetry/posterior.json` (atomic .tmp + rename). Discounted Thompson via per-arm time-decay factor `ρ^days_since_last_use` applied at sample time (default ρ=0.988 → 60-day half-life). Informed bootstrap: each arm starts at `Beta(α, β)` with α weighted toward the historical tier success rate (haiku=0.6, sonnet=0.8, opus=0.85) and `α + β ≈ 10` so 5–10 local samples shift the posterior. Two-stage lexicographic reward: `if !solidify_pass: 0; elif user_undo_in_session: 0; else: 1 − λ · normalize(cost + ε · wall_time)`. API: `pull / update / reset / loadPosterior / savePosterior / computeReward`. Touches-size bins: `tiny <5`, `small 5–15`, `medium 16–50`, `large >50` globs. (Plan 23.5-01)
+
+- **Hedge ensemble** — `scripts/lib/hedge-ensemble.cjs` implements parameter-free AdaNormalHedge weighted-majority over verifier + checker agents. Weights persist at `.design/telemetry/hedge-weights.json`. Update rule: `η_i = sqrt(ln(N) / max(1, cumLoss2_i))` per-agent learning rate; `w_i *= exp(-η_i * loss_i)`; renormalise. Vote semantics: weighted sum normalised by the SUM of voting agents' weights — agents in the pool that didn't vote this round don't dilute the verdict. API: `loss / vote / weights / loadWeights / saveWeights`. Default vote threshold 0.5. (Plan 23.5-02)
+
+- **MMR re-rank** — `scripts/lib/mmr-rerank.cjs` implements Maximal Marginal Relevance over scored items. Solves the "all 5 surfaced learnings are about the same thing" failure mode in the Phase 14.5 decision-injector. Greedy criterion: `next = argmax_{i ∉ selected} λ * relevance(i) − (1 − λ) * max_sim(i, selected)`. Similarity = Jaccard on word n-grams (default n=2). λ default 0.7. No external deps, no embedding API. API: `rerank / similarity / tokenize / ngrams / jaccard`. (Plan 23.5-03)
+
+- **Adaptive-mode feature flag ladder** — `scripts/lib/adaptive-mode.cjs` is the single source of truth for which Phase 23.5 components are active. Three modes:
+  - `static` (DEFAULT) — Phase 10.1 behaviour. Static `tier_overrides` applies. No posterior writes / no hedge updates / no MMR.
+  - `hedge` — Adds AdaNormalHedge consensus + MMR re-rank. Routing still static (bandit OFF). Safest intro level.
+  - `full` — Adds bandit Thompson-sampling routing + reflector confidence-interval proposals. Both posterior + hedge persist.
+  Read from `.design/budget.json.adaptive_mode` with safe fallback to `static` on missing/malformed/unknown values. API: `getMode / setMode / caps / isBanditEnabled / isHedgeEnabled / isMmrEnabled / isReflectorProposalsEnabled`. (Plan 23.5-04)
+
+### Changed
+
+- `tests/semver-compare.test.cjs` `OFF_CADENCE_VERSIONS` gains `1.23.5`.
+- `test-fixture/baselines/phase-20/resilience-primitives.txt` regenerated alphabetically with all four new `.cjs` modules added.
+
+### Tests
+
+- `tests/bandit-router.test.cjs` — bin partitioning, prior elevation per tier, beta sampling, pull persistence, missing-input throws, update/reward/clamp, reset, decay-toward-prior, all reward branches, load+save, 60-round convergence smoke test (18 tests)
+- `tests/hedge-ensemble.test.cjs` — init uniform, high-loss penalty, normalisation, simple vs weighted vote, boolean=numeric equivalence, custom threshold, empty votes, loss clamp, NaN throw, round-trip (14)
+- `tests/mmr-rerank.test.cjs` — tokenize edges, ngram size+fallback, similarity properties, λ=1 pure relevance, λ=0 pure diversity, textOf/relevanceOf overrides, empty input, non-array throw, k>length truncation, defaults, jaccard guards, canonical "5 D-13 hits" scenario (18)
+- `tests/adaptive-mode.test.cjs` — missing-file fallback, malformed-JSON fallback, unknown-mode quiet fallback, all 3 capability matrices, all 4 predicates, setMode preserves other fields, parent-dir creation, mode rejection, exports, absolute-path support (13)
+- `tests/phase-23.5-baseline.test.cjs` — Phase 23.5 regression baseline (8)
+
+Total: 71 new tests. All Phase 20/21/22/23 tests still green.
+
+### Reflector integration
+
+The Phase 22 code-level reflector reads `posterior.json` + hedge weights at run time (under `adaptive_mode: "full"`). When `stddev(Beta(α, β)) < 0.05` for a single-arm dominant tier, it proposes `tier_overrides` updates via `/gdd:apply-reflections`. Pure-read; never auto-writes. Same proposal pattern as Plan 23-06 touches pattern miner.
+
+### Deferred (evidence-gated, per ROADMAP)
+
+- Hierarchical shared prior (revisit after 20+ cycles of single-user convergence data)
+- Dense-embedding retrieval (revisit if MMR-only miss-rate exceeds 15%)
+- Offline policy evaluation harness (bootstraps from bandit's stochastic logs once accumulated)
+- Auto changepoint detection (manual `/gdd:bandit-reset --reason "<msg>"` covers v1)
+
+### Explicitly out of scope
+
+- HDBSCAN auto-crystallization, BOCPD changepoint detection, Personalized PageRank, MinHash/LSH dedup, Borda/Kemeny rank aggregation, submodular greedy — each rejected with rationale in ROADMAP.md.
+
+---
+
 ## [1.23.0] — 2026-04-25
 
 Phase 23 GDD SDK Domain Primitives milestone — lands the highest-leverage code primitives from the ROADMAP "GDD SDK Domain Primitives" entry as typed Node modules with tests. 10 atomic plans (23-01 through 23-10), additive — every Phase 20/21/22 consumer keeps working unchanged. Distribution as separate `@hegemonart/gdd-sdk` npm package and screenshot-capture orchestration are explicitly deferred to follow-up phases.

package/README.md

@@ -104,7 +104,11 @@ Built-in quality gates catch real problems: Handoff Faithfulness scoring on Clau
 - **Component generators** — 21st.dev Magic MCP adds a prior-art gate before any greenfield build; Magic Patterns generates DS-aware components with a `preview_url` for visual verification. Both feed into a shared `design-component-generator` agent.
 - **Twelve tool connections** — Four new connections (paper.design, pencil.dev, 21st.dev, Magic Patterns) join the original eight. All are optional; the pipeline degrades gracefully to fallbacks when any connection is unavailable.
 
-## What's New in v1.21.0
+## What's New in v1.24.0
+
+**Multi-runtime installer** (headline upgrade) — `npx @hegemonart/get-design-done` with no flags now opens a polished interactive multi-select (`@clack/prompts`) for all 14 supported AI coding runtimes — Claude Code, OpenCode, Gemini CLI, Kilo Code, OpenAI Codex CLI, GitHub Copilot CLI, Cursor, Windsurf, Antigravity, Augment, Trae, Qwen Code, CodeBuddy, Cline. Pick any subset, choose Global or Local, confirm, done. Idempotent + foreign-AGENTS.md-safe. Scripted CI installs continue to work via the existing flag surface unchanged. See the [Getting Started](#getting-started) section below.
+
+### Previously in v1.21.0
 
 **Headless SDK** (headline upgrade) — the plugin now ships a `gdd-sdk` CLI that runs the full design pipeline without Claude Code. Five subcommands (`run`, `stage`, `query`, `audit`, `init`) work on any CI runner with Node 22+ and an `ANTHROPIC_API_KEY`. See the [Headless SDK](#headless-sdk) section below for examples.
 
@@ -134,14 +138,22 @@ Built-in quality gates catch real problems: Handoff Faithfulness scoring on Clau
 npx @hegemonart/get-design-done@latest
 ```
 
-That's it. The installer writes a `get-design-done` marketplace entry and enables the plugin in `~/.claude/settings.json` atomically. Restart Claude Code (or run `/reload-plugins`), and the pipeline is live.
+In a TTY this opens a polished interactive multi-select (`@clack/prompts`) — pick which AI runtimes to install into and whether to install Globally or Locally. Press `[a]` to select all 14 supported runtimes at once. In non-TTY contexts (CI, pipes), the same command falls back to `--claude --global` for full backwards compatibility with v1.23.5 and earlier.
+
+After install, restart the affected runtime(s) (or run `/reload-plugins` for Claude Code) and the pipeline is live.
+
+**Supported runtimes** *(v1.24.0+)*
+
+Claude Code, OpenCode, Gemini CLI, Kilo Code, OpenAI Codex CLI, GitHub Copilot CLI, Cursor, Windsurf, Antigravity, Augment, Trae, Qwen Code, CodeBuddy, Cline.
+
+Claude Code uses marketplace registration (`extraKnownMarketplaces` + `enabledPlugins` in `settings.json`); the other 13 runtimes follow the AGENTS.md / GEMINI.md convention — the installer drops a fingerprinted instructions file in the runtime's config dir (and refuses to overwrite an existing AGENTS.md it didn't author).
 
 **What the installer does**
 
-- Registers the `github:hegemonart/get-design-done` marketplace in `extraKnownMarketplaces`
-- Flips `enabledPlugins["get-design-done@get-design-done"]` to `true`
-- Preserves every other key in your settings — theme, permissions, other marketplaces — untouched
-- Idempotent: safe to re-run; no duplicate entries
+- For Claude Code: registers the `github:hegemonart/get-design-done` marketplace in `extraKnownMarketplaces` and flips `enabledPlugins["get-design-done@get-design-done"]` to `true`.
+- For AGENTS.md runtimes: drops a fingerprinted `AGENTS.md` (or `GEMINI.md`) in the runtime's config dir.
+- Preserves every other key in your settings — theme, permissions, other marketplaces — untouched.
+- Idempotent: safe to re-run; no duplicate entries; foreign AGENTS.md files are never overwritten.
 
 On first Claude Code launch after install, a `SessionStart` bootstrap hook provisions the companion reference library `~/.claude/libs/awesome-design-md` (idempotent — subsequent sessions run `git pull --ff-only`).
 
@@ -158,13 +170,30 @@ A one-line SessionStart nudge surfaces `/gdd:start` in fresh repos; run `/gdd:st
 ### Non-interactive install (CI, Docker, scripts)
 
 ```bash
-# Dry-run: print the diff, don't write
+# Dry-run: print the diff, don't write (Claude Code only by default)
 npx @hegemonart/get-design-done@latest --dry-run
 
 # Custom config dir (Docker, non-default Claude root)
 CLAUDE_CONFIG_DIR=/workspace/.claude npx @hegemonart/get-design-done@latest
+
+# Pick specific runtimes (any flag → scripted, no prompts)
+npx @hegemonart/get-design-done@latest --claude --opencode --gemini
+
+# Install into every supported runtime
+npx @hegemonart/get-design-done@latest --all
+
+# Local install (drops files into the current working directory)
+npx @hegemonart/get-design-done@latest --opencode --local
+
+# Uninstall — bare flag enters interactive multi-select of detected runtimes
+npx @hegemonart/get-design-done@latest --uninstall
+
+# Uninstall scripted (no prompt)
+npx @hegemonart/get-design-done@latest --uninstall --claude --gemini
 ```
 
+Per-runtime env-var overrides: `CLAUDE_CONFIG_DIR`, `OPENCODE_CONFIG_DIR`, `GEMINI_CONFIG_DIR`, `CODEX_HOME`, `CURSOR_CONFIG_DIR`, `KILO_CONFIG_DIR`, `COPILOT_CONFIG_DIR`, `WINDSURF_CONFIG_DIR`, `ANTIGRAVITY_CONFIG_DIR`, `AUGMENT_CONFIG_DIR`, `TRAE_CONFIG_DIR`, `QWEN_CONFIG_DIR`, `CODEBUDDY_CONFIG_DIR`, `CLINE_CONFIG_DIR`. Each falls back to `$HOME / $USERPROFILE` joined with the runtime's default subdirectory (e.g. `~/.claude`, `~/.gemini`, `~/.config/opencode`).
+
 ### Alternative: Claude Code CLI
 
 Prefer to skip the npm package entirely? Use the native plugin CLI:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hegemonart/get-design-done",
-  "version": "1.23.0",
+  "version": "1.24.0",
   "description": "A Claude Code plugin for systematic design improvement",
   "author": "Hegemon",
   "homepage": "https://github.com/hegemonart/get-design-done",
@@ -84,6 +84,7 @@
   "hooks": "hooks/hooks.json",
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.119",
+    "@clack/prompts": "^0.7.0",
     "@modelcontextprotocol/sdk": "^1.0.0"
   },
   "optionalDependencies": {

package/scripts/install.cjs

@@ -2,153 +2,201 @@
 'use strict';
 
 // npx @hegemonart/get-design-done
-// One-command installer for the get-design-done Claude Code plugin.
+// Multi-runtime installer for the get-design-done plugin.
 //
-// Registers the github.com/hegemonart/get-design-done marketplace and enables
-// the plugin in ~/.claude/settings.json (or $CLAUDE_CONFIG_DIR/settings.json).
-// Claude Code fetches the plugin payload from the marketplace on next launch.
+// Runtime selection:
+//   • zero-flag in TTY      → @clack/prompts interactive multi-select
+//   • zero-flag in non-TTY  → defaults to --claude --global (back-compat)
+//   • any explicit flag     → scripted, no prompts
 //
-// Usage:
-//   npx @hegemonart/get-design-done           # install
-//   npx @hegemonart/get-design-done --dry-run # show what would change
-//   npx @hegemonart/get-design-done --help
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const REPO = 'hegemonart/get-design-done';
-const MARKETPLACE_NAME = 'get-design-done';
-const PLUGIN_NAME = 'get-design-done';
-const ENABLED_KEY = `${PLUGIN_NAME}@${MARKETPLACE_NAME}`;
-
-const args = new Set(process.argv.slice(2));
-
-if (args.has('--help') || args.has('-h')) {
-  process.stdout.write(
-    [
-      'npx @hegemonart/get-design-done — install the plugin',
-      '',
-      'Registers the github.com/hegemonart/get-design-done marketplace and',
-      'enables the get-design-done plugin in your Claude Code settings.',
-      '',
-      'Flags:',
-      '  --dry-run    Print the diff without writing',
-      '  --help, -h   Show this message',
-      '',
-      'Environment:',
-      '  CLAUDE_CONFIG_DIR   Override the Claude config directory',
-      '                      (default: ~/.claude)',
-      '',
-      'After install, restart Claude Code to load the plugin.',
-      '',
-    ].join('\n'),
-  );
-  process.exit(0);
+// Per-runtime flags: --claude, --opencode, --gemini, --kilo, --codex,
+//   --copilot, --cursor, --windsurf, --antigravity, --augment, --trae,
+//   --qwen, --codebuddy, --cline. --all selects every runtime.
+//
+// Modifiers: --global (default) | --local; --uninstall; --dry-run;
+//   --config-dir <path>; --help / -h.
+
+const path = require('node:path');
+
+const { listRuntimes, listRuntimeIds } = require('./lib/install/runtimes.cjs');
+const { installRuntime, uninstallRuntime } = require('./lib/install/installer.cjs');
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const flags = new Set();
+  let configDir = null;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === '--config-dir') {
+      configDir = args[++i] || null;
+      continue;
+    }
+    if (a.startsWith('--config-dir=')) {
+      configDir = a.slice('--config-dir='.length);
+      continue;
+    }
+    flags.add(a);
+  }
+  return { flags, configDir };
 }
 
-const DRY_RUN = args.has('--dry-run');
+function helpText() {
+  const ids = listRuntimes()
+    .map((r) => `  --${r.id.padEnd(12)} ${r.displayName}`)
+    .join('\n');
+  return [
+    'npx @hegemonart/get-design-done — install the plugin into one or more runtimes',
+    '',
+    'Zero-flag in a TTY launches the interactive multi-select.',
+    'Zero-flag in a non-TTY (CI, pipes) defaults to --claude --global.',
+    '',
+    'Per-runtime flags:',
+    ids,
+    '  --all           Select every runtime',
+    '',
+    'Modifiers:',
+    '  --global        Install at $HOME / $USERPROFILE level (default)',
+    '  --local         Install in current working directory',
+    '  --uninstall     Remove the plugin from selected runtimes',
+    '  --dry-run       Print the diff without writing',
+    '  --config-dir D  Override the config directory',
+    '  --help, -h      Show this message',
+    '',
+    'Environment overrides (per-runtime):',
+    '  CLAUDE_CONFIG_DIR, OPENCODE_CONFIG_DIR, GEMINI_CONFIG_DIR,',
+    '  CODEX_HOME, CURSOR_CONFIG_DIR, … (one per runtime)',
+    '',
+  ].join('\n');
+}
 
-function resolveConfigDir() {
-  if (process.env.CLAUDE_CONFIG_DIR && process.env.CLAUDE_CONFIG_DIR.trim()) {
-    return process.env.CLAUDE_CONFIG_DIR.trim();
+function runtimesFromFlags(flags) {
+  if (flags.has('--all')) return listRuntimeIds();
+  const picked = [];
+  for (const id of listRuntimeIds()) {
+    if (flags.has(`--${id}`)) picked.push(id);
   }
-  return path.join(os.homedir(), '.claude');
+  return picked;
 }
 
-function loadSettings(settingsPath) {
-  if (!fs.existsSync(settingsPath)) return {};
-  try {
-    const raw = fs.readFileSync(settingsPath, 'utf8');
-    if (!raw.trim()) return {};
-    return JSON.parse(raw);
-  } catch (err) {
-    process.stderr.write(
-      `get-design-done installer: cannot parse ${settingsPath} as JSON\n` +
-        `  ${err.message}\n` +
-        `  Fix the file manually or delete it, then re-run.\n`,
-    );
-    process.exit(1);
+async function pickRuntimesInteractively(opts) {
+  const { runInteractiveInstall, runInteractiveUninstall } = require('./lib/install/interactive.cjs');
+  if (opts.uninstall) {
+    return runInteractiveUninstall(opts);
   }
+  return runInteractiveInstall();
 }
 
-function mergeSettings(existing) {
-  const next = { ...existing };
-
-  const marketplaces = { ...(next.extraKnownMarketplaces || {}) };
-  const marketplaceEntry = {
-    source: { source: 'github', repo: REPO },
-  };
-  const marketplaceChanged =
-    JSON.stringify(marketplaces[MARKETPLACE_NAME]) !==
-    JSON.stringify(marketplaceEntry);
-  marketplaces[MARKETPLACE_NAME] = marketplaceEntry;
-  next.extraKnownMarketplaces = marketplaces;
-
-  const enabled = { ...(next.enabledPlugins || {}) };
-  const enabledChanged = enabled[ENABLED_KEY] !== true;
-  enabled[ENABLED_KEY] = true;
-  next.enabledPlugins = enabled;
-
-  return { next, changed: marketplaceChanged || enabledChanged };
+function resolveLocalConfigDir(runtime) {
+  return path.resolve(process.cwd(), runtime.configDirFallback);
 }
 
-function atomicWrite(target, contents) {
-  const tmp = `${target}.tmp-${process.pid}`;
-  fs.writeFileSync(tmp, contents, { encoding: 'utf8', mode: 0o600 });
-  fs.renameSync(tmp, target);
+function shouldUseInteractive(flags) {
+  // Any of these flags means "scripted mode":
+  //   per-runtime, --all, --uninstall (with explicit list), --help
+  if (flags.has('--all')) return false;
+  for (const id of listRuntimeIds()) {
+    if (flags.has(`--${id}`)) return false;
+  }
+  // Bare --uninstall (no runtime list) is itself a trigger for interactive
+  // select-which-to-remove flow, so it returns true.
+  return Boolean(process.stdout.isTTY) && Boolean(process.stdin.isTTY);
 }
 
-function main() {
-  const configDir = resolveConfigDir();
-  const settingsPath = path.join(configDir, 'settings.json');
+function summariseResults(results) {
+  const lines = [];
+  for (const r of results) {
+    const tag = r.dryRun ? '[dry-run] ' : '';
+    const status = r.action;
+    lines.push(`${tag}• ${r.runtime.padEnd(12)} ${status.padEnd(16)} ${r.path}`);
+    if (r.reason) lines.push(`    ${r.reason}`);
+  }
+  return lines.join('\n');
+}
 
-  if (!fs.existsSync(configDir)) {
-    if (DRY_RUN) {
-      process.stdout.write(
-        `[dry-run] would create ${configDir}\n`,
-      );
+async function main() {
+  const { flags, configDir } = parseArgs(process.argv);
+
+  if (flags.has('--help') || flags.has('-h')) {
+    process.stdout.write(helpText());
+    process.exit(0);
+  }
+
+  const dryRun = flags.has('--dry-run');
+  const uninstall = flags.has('--uninstall');
+  const local = flags.has('--local');
+  const explicitRuntimes = runtimesFromFlags(flags);
+
+  let runtimes = explicitRuntimes;
+  let location = local ? 'local' : 'global';
+
+  if (runtimes.length === 0) {
+    if (shouldUseInteractive(flags)) {
+      const opts = { uninstall };
+      const picked = await pickRuntimesInteractively(opts);
+      if (picked == null) {
+        process.exit(0);
+      }
+      runtimes = picked.runtimes;
+      if (picked.location) location = picked.location;
     } else {
-      fs.mkdirSync(configDir, { recursive: true });
+      // Non-TTY zero-flag fallback: back-compat with v1.23.5 behaviour.
+      runtimes = ['claude'];
+      location = local ? 'local' : 'global';
     }
   }
 
-  const existing = loadSettings(settingsPath);
-  const { next, changed } = mergeSettings(existing);
-  const formatted = `${JSON.stringify(next, null, 2)}\n`;
-
-  if (!changed) {
-    process.stdout.write(
-      `get-design-done is already registered in ${settingsPath}\n` +
-        `Nothing to do. Restart Claude Code if you haven't yet.\n`,
-    );
-    return;
+  const results = [];
+  const { getRuntime } = require('./lib/install/runtimes.cjs');
+  for (const id of runtimes) {
+    const runtime = getRuntime(id);
+    const opts = { dryRun };
+    if (configDir) {
+      opts.configDir = configDir;
+    } else if (location === 'local') {
+      opts.configDir = resolveLocalConfigDir(runtime);
+    }
+    const result = uninstall
+      ? uninstallRuntime(id, opts)
+      : installRuntime(id, opts);
+    results.push(result);
   }
 
-  if (DRY_RUN) {
+  const verb = uninstall ? 'uninstall' : 'install';
+  const allUnchanged = results.length > 0 && results.every((r) => r.action === 'unchanged');
+  if (allUnchanged && !dryRun) {
     process.stdout.write(
-      `[dry-run] would update ${settingsPath}\n` +
-        `  extraKnownMarketplaces["${MARKETPLACE_NAME}"] = { source: { source: "github", repo: "${REPO}" } }\n` +
-        `  enabledPlugins["${ENABLED_KEY}"] = true\n`,
+      [
+        `get-design-done is already registered (${runtimes.length} runtime(s) unchanged):`,
+        summariseResults(results),
+        '',
+        'Nothing to do. Restart the affected runtime(s) if you have not yet.',
+        '',
+      ].join('\n'),
     );
     return;
   }
-
-  atomicWrite(settingsPath, formatted);
-
   process.stdout.write(
     [
-      `✓ get-design-done registered in ${settingsPath}`,
-      `  marketplace: github:${REPO}`,
-      `  plugin:      ${ENABLED_KEY}`,
+      dryRun
+        ? `[dry-run] would ${verb} into ${runtimes.length} runtime(s):`
+        : `${verb} complete (${runtimes.length} runtime(s)):`,
+      summariseResults(results),
       '',
-      'Next steps:',
-      '  1. Restart Claude Code (or run /reload-plugins).',
-      '  2. Claude Code will fetch the plugin on first launch.',
-      '  3. Verify with: /plugin list',
+      uninstall
+        ? ''
+        : 'Restart the affected runtime(s) for the plugin to load.',
       '',
     ].join('\n'),
   );
 }
 
-main();
+main().catch((err) => {
+  if (err && err.code === 'EINSTALLER_BAD_JSON') {
+    process.stderr.write(`${err.message}\n`);
+  } else {
+    process.stderr.write(
+      `get-design-done installer error: ${err && err.stack ? err.stack : err}\n`,
+    );
+  }
+  process.exit(1);
+});