@hegemonart/get-design-done 1.0.7

package/skills/debug/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: gdd-debug
+description: "Symptom-driven design investigation with persistent state. Writes findings to .design/DEBUG.md."
+argument-hint: "[<symptom description>]"
+tools: Read, Write, Grep, Glob, AskUserQuestion, Task
+---
+
+# /gdd:debug
+
+Systematic, checkpoint-driven design debugger. Loads philosophy from `reference/debugger-philosophy.md` and writes every investigation step to `.design/DEBUG.md` so killed sessions can resume.
+
+## Steps
+
+1. **Load philosophy**: Read `reference/debugger-philosophy.md` and keep its five principles in mind for the entire session.
+2. **Symptom**: If no symptom argument was passed, ask (AskUserQuestion): "What design symptom are you investigating? (observable only — 'cards look crowded', not 'padding is wrong')"
+3. **Resume check**: Read `.design/DEBUG.md` if it exists. If there is an open session with no `### Fix Proposal` block, ask: "Resume existing session '<symptom>' or start a new one?"
+4. **Ground truth load**: Read `.design/DESIGN-PLAN.md` (goals), `.design/STATE.md` `<decisions>` block (D-XX items), and any relevant source files pointed at by the symptom.
+5. **Optional rendered-output check**: Use ToolSearch to see if Playwright/Preview MCP tools are available. If yes, capture rendered state. If no, fall back to code-only analysis.
+6. **Investigation loop** — for each step:
+   - Form one hypothesis (one variable).
+   - Investigate (read files, grep, measure).
+   - Append to `.design/DEBUG.md`:
+     ```markdown
+     ## <symptom> — <date>
+     ### Hypothesis <N>
+     ### Investigation
+     ### Finding
+     ```
+   - Ask (AskUserQuestion): "Continue investigating? (yes / found it / dead end)"
+7. **When found**: Write `### Fix Proposal` block with a concrete patch description. Ask: "Create a todo with `/gdd:todo add`, or execute the fix now?"
+
+## Do Not
+
+- Do not change multiple variables at once.
+- Do not modify global tokens to fix a single component without explicit user approval.
+- Do not close the DEBUG.md session without a finding (mark as "dead end" if abandoned).
+
+## DEBUG COMPLETE

package/skills/design/SKILL.md

@@ -0,0 +1,281 @@
+---
+name: design
+description: "Stage 4 of 5 — reads DESIGN-PLAN.md, spawns design-executor per task with wave coordination and parallel/sequential routing. Thin orchestrator."
+argument-hint: "[--auto] [--parallel]"
+user-invocable: true
+---
+
+# Get Design Done — Design
+
+**Stage 4 of 5** in the get-design-done pipeline. Thin orchestrator. All design execution intelligence lives in `agents/design-executor.md`.
+
+---
+
+## State Integration
+
+1. Read `.design/STATE.md`.
+   - **If missing:** create minimal skeleton from `reference/STATE-TEMPLATE.md` with `stage: design`, `status: in_progress`; log warning: "STATE.md not found — creating from template. Prior stage outputs may be incomplete."
+   - **If present and `stage == design` and `status == in_progress`:** RESUME — use `task_progress` numerator as source of truth; skip tasks that already have a corresponding `.design/tasks/task-NN.md` file.
+   - **Otherwise:** normal transition — set `stage: design`, `status: in_progress`.
+2. Probe `<connections>`, update `last_checkpoint`, write STATE.md.
+
+Abort only if `.design/DESIGN-PLAN.md` is missing:
+> "No plan found. Run `/get-design-done:plan` first."
+
+---
+
+## Flag Parsing
+
+- `--auto` → `auto_mode=true` (no mid-stage prompts; architectural deviations still stop the individual task but continue with remaining tasks)
+- `--parallel` → `parallel_mode=true` (use worktree isolation for `Parallel: true` tasks)
+
+---
+
+## Pre-execution — Directionally-open check
+
+Scan DESIGN-PLAN.md for tasks marked as "directionally open" (exploration-appropriate — e.g., tasks whose acceptance criteria read "explore N directions" or "pick a visual approach"). If any are found, print:
+
+> "Tasks [IDs] appear directionally open — consider running `/gdd:sketch` first to explore variants before implementation."
+
+Skip if `auto_mode=true`.
+
+## Pre-execution — Project-local conventions
+
+When spawning the executor, include any `./.claude/skills/design-*-conventions.md` files in `<required_reading>` so the executor sees project-local design conventions (typography, color, layout, motion, component, interaction decisions codified from prior sketch wrap-ups). Also include any `~/.claude/gdd/global-skills/*.md` files if the directory exists � global skills are cross-project conventions that inform but do not override project-local D-XX decisions.
+
+---
+
+### .stories.tsx Stub (when storybook project detected)
+
+After every new component file is created by the design-executor:
+
+Step 1 — Check project detection (does not require server running):
+  Bash: ls .storybook/ 2>/dev/null || grep '"storybook"' package.json 2>/dev/null
+  → Found → storybook_project: true
+  → Not found → skip .stories.tsx emission
+
+Step 2 — When storybook_project: true, emit a CSF stub alongside the component:
+  File: `<same directory as component>/<ComponentName>.stories.tsx`
+  Content follows CSF format (see `connections/storybook.md` for full template):
+  - Import `Meta` and `StoryObj` from `@storybook/react`
+  - Import the new component
+  - `meta: Meta<typeof ComponentName>` with `title` and `parameters.a11y.test = 'error'`
+  - Export `Default`, `Primary`, `Disabled` story variants
+  Adjust `title` to match directory structure (e.g., `'Components/Button'` or `'Features/Auth/LoginForm'`)
+
+Note: the `.stories.tsx` stub is emitted whenever `storybook_project: true` regardless of whether
+the dev server is running. New components need stories even in offline/CI contexts.
+
+---
+
+## Step 1 — Parse DESIGN-PLAN.md
+
+Read `.design/DESIGN-PLAN.md`. Partition tasks by `## Wave N` heading. Within each wave, partition by `Parallel: true` vs `Parallel: false`. Compute `total_tasks` for `task_progress` denominator.
+
+If resuming: skip tasks where `.design/tasks/task-NN.md` already exists.
+
+---
+
+## Parallelism Decision (per wave, before spawning)
+
+For each wave:
+1. Read `.design/config.json` `parallelism` (or defaults from `reference/config-schema.md`).
+2. Collect candidates in the wave; check `Touches:`, `writes:`, `parallel-safe`, and `typical-duration-seconds` fields.
+3. Apply rules in order from `reference/parallelism-rules.md` (hard → soft). Overlapping Touches split into sequential sub-waves.
+4. Write `<parallelism_decision>` to STATE.md per wave (stage: design, wave: N).
+5. If `parallel`: spawn all candidates via concurrent `Task()` calls in one response. If `serial`: spawn sequentially.
+
+## Step 2 — Wave-by-Wave Execution
+
+For each Wave in order (Wave 1, Wave 2, ...):
+
+### Parallel batch (if `parallel_mode=true` AND any `Parallel: true` tasks in wave)
+
+Report the partition before spawning:
+
+```
+━━━ Wave [N] — parallel mode ━━━
+Parallel batch ([N] tasks — spawning concurrently):
+  [01] [type]: [scope] — touches: [files]
+  [02] [type]: [scope] — touches: [files]
+
+Sequential tail ([N] tasks):
+  [03] [type]: [scope] — touches: [files]
+
+Spawning agents now...
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+Spawn ALL `Parallel: true` tasks in this wave as concurrent `Task()` calls in ONE response. Each call uses `isolation: "worktree"`:
+
+```
+Task("design-executor", """
+<required_reading>
+@.design/STATE.md
+@.design/DESIGN-PLAN.md
+@.design/DESIGN-CONTEXT.md
+@reference/[type-relevant].md
+</required_reading>
+
+You are the design-executor agent. Execute Task NN from DESIGN-PLAN.md.
+
+Prompt context:
+  task_id: NN
+  task_type: [type]
+  task_scope: [scope]
+  task_acceptance_criteria:
+    - [criterion 1]
+    - [criterion 2]
+  wave: N
+  is_parallel: true
+  auto_mode: [true|false]
+
+Write .design/tasks/task-NN.md and make an atomic commit `feat(design-NN): [type] — [scope]`.
+
+Emit `## EXECUTION COMPLETE` when done.
+""", subagent_type="design-executor", isolation="worktree")
+```
+
+Wait for all parallel tasks to emit `## EXECUTION COMPLETE`.
+
+**Merge worktrees** (preserved from v2.1.0 — do not redesign):
+
+```
+━━━ Parallel batch complete ━━━
+[✓/⚠/✗] Task 01 — [type]
+[✓/⚠/✗] Task 02 — [type]
+
+Merging worktrees...
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+Merge each worktree branch back into the working directory. Each agent touched non-overlapping files (guaranteed by the conflict check on `Touches:` fields). If an unexpected merge conflict appears, flag it and ask the user to resolve before continuing.
+
+Update STATE.md `task_progress` after merge.
+
+### Sequential tail (Parallel: false tasks, or all tasks if `parallel_mode=false`)
+
+Announce each wave before starting:
+
+```
+━━━ Wave [N] — [N tasks] — sequential ━━━
+Tasks:
+  [01] [type]: [scope]
+  [02] [type]: [scope]
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+Run one at a time. Same `Task("design-executor", ...)` pattern with `is_parallel: false` (no worktree isolation):
+
+```
+Task("design-executor", """
+<required_reading>
+@.design/STATE.md
+@.design/DESIGN-PLAN.md
+@.design/DESIGN-CONTEXT.md
+@reference/[type-relevant].md
+</required_reading>
+
+You are the design-executor agent. Execute Task NN from DESIGN-PLAN.md.
+
+Prompt context:
+  task_id: NN
+  task_type: [type]
+  task_scope: [scope]
+  task_acceptance_criteria:
+    - [criterion 1]
+    - [criterion 2]
+  wave: N
+  is_parallel: false
+  auto_mode: [true|false]
+
+Write .design/tasks/task-NN.md and make an atomic commit `feat(design-NN): [type] — [scope]`.
+
+Emit `## EXECUTION COMPLETE` when done.
+""", subagent_type="design-executor")
+```
+
+Update STATE.md `task_progress` after each task completes.
+
+---
+
+## Step 3 — Wave Checkpoint
+
+After each wave (unless `--auto` flag was passed):
+
+```
+━━━ Wave [N] complete ━━━
+  ✓ [N] tasks complete
+  ⚠ [N] deviations (see .design/tasks/ files)
+
+Ready for Wave [N+1]? (yes / review first)
+━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+Skip checkpoint if `auto_mode=true`.
+
+---
+
+## Step 4 — Handle Deviations
+
+After each wave, check task-NN.md files for `status: deviation`. If any found:
+
+- Present affected task IDs and their blocker descriptions (from `.design/STATE.md <blockers>`)
+- Offer: (a) stop stage, (b) continue remaining tasks
+- In `auto_mode`: continue automatically, log all deviations
+
+---
+
+## State Update (exit)
+
+1. Set `<position> status: completed`, `stage: design`.
+2. Set `<timestamps> design_completed_at: [now ISO 8601]`.
+3. Write STATE.md.
+
+---
+
+## After Completion
+
+Print summary:
+
+```
+━━━ Design stage complete ━━━
+Tasks: [N] complete / [M] total
+Deviations: [N]
+Commits: [git log --oneline since stage start]
+
+Next: /get-design-done:verify
+  → Scores the result against baseline, checks must-haves,
+    runs NNG heuristic evaluation, and identifies gaps.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+---
+
+### Figma Write Dispatch (after design-executor completes)
+
+After design-executor has finished and DESIGN-PLAN.md tasks are complete:
+
+1. Read `figma_writer:` status from `.design/STATE.md` `<connections>`:
+   - If `figma_writer: not_configured` or absent → skip this block entirely (no prompt, no output)
+   - If `figma_writer: available` → proceed to step 2
+
+2. Offer the user a prompt:
+   ```
+   figma-writer is available — propagate design decisions back to Figma?
+   Modes: annotate (layer comments) | tokenize (variable bindings) | mappings (Code Connect)
+   Run figma-write? (y/N):
+   ```
+
+3. If user answers "y" or "yes":
+   - Ask which mode: annotate / tokenize / mappings (or all)
+   - Spawn `design-figma-writer` agent with the selected mode
+   - Pass `--dry-run` flag if user requests preview first
+
+4. If user answers "n", "N", or no response: skip silently.
+
+Note: This dispatch is always opt-in. The design stage never auto-runs figma-writer without user confirmation.
+
+---
+
+## DESIGN COMPLETE

package/skills/discover/SKILL.md

@@ -0,0 +1,172 @@
+---
+name: discover
+description: "Stage 1.5 of 4 — thin orchestrator that spawns design-context-builder (auto-detect + interview) and design-context-checker (6-dimension validator) to produce DESIGN-CONTEXT.md."
+argument-hint: "[--auto]"
+user-invocable: true
+---
+
+# Get Design Done — Discover
+
+**Stage 1.5 of 4.** Produces `.design/DESIGN-CONTEXT.md`.
+
+---
+
+## State Integration
+
+1. Read `.design/STATE.md`.
+   - If missing: create minimal skeleton from `reference/STATE-TEMPLATE.md` with stage=discover, status=in_progress, task_progress=0/1, and log warning: "STATE.md not found — created fresh. If this is a resumed session, run /get-design-done:scan first."
+   - If present and stage==discover and status==in_progress: RESUME — continue existing interview; do not reset.
+   - Otherwise: normal transition — set frontmatter stage=discover, <position> stage=discover, status=in_progress, task_progress=0/1.
+2. **Probe connection availability** — ToolSearch runs FIRST because MCP tools may be in the deferred tool set. This is the canonical probe pattern (spec lives in `connections/connections.md`; copied inline because SKILL.md has no include mechanism — if the probe pattern changes, update all stages that copied it).
+
+   **A — Figma probe:**
+
+   ```
+   A1. ToolSearch({ query: "select:mcp__figma-desktop__get_metadata", max_results: 1 })
+   A2. Empty result → figma: not_configured (skip all Figma paths)
+       Non-empty result → call mcp__figma-desktop__get_metadata
+         Success → figma: available
+         Error   → figma: unavailable
+   ```
+
+   **B — Refero probe (ToolSearch presence is sufficient — no tool call needed):**
+
+   ```
+   B1. ToolSearch({ query: "refero", max_results: 5 })
+   B2. Empty result  → refero: not_configured
+       Non-empty     → refero: available
+   ```
+
+   **C — Pinterest probe (ToolSearch-only, same pattern as Refero):**
+
+   ```
+   C1. ToolSearch({ query: "mcp-pinterest", max_results: 5 })
+   C2. Empty result  → pinterest: not_configured
+       Non-empty     → pinterest: available
+   ```
+
+   No live `pinterest_search` call at probe time — ToolSearch presence is sufficient. The synthesizer makes the actual search calls.
+
+   After all probes (A, B, C), update `.design/STATE.md` `<connections>` with the results and continue. Downstream stages (design-context-builder) read `<connections>` from STATE.md rather than re-probing.
+3. Update last_checkpoint. Write STATE.md.
+
+## Auto Mode
+
+Auto Mode CSS detection (when `auto_mode: true` is passed to the builder):
+  1. If tailwind.config.{js,cjs,mjs,ts} exists → Tailwind-only project
+     - Skip CSS file grep
+     - Parse tailwind.config for color palette, spacing scale, font families
+     - Use tailwind.config values as the baseline style signal
+  2. Else → fall through to existing CSS file grep logic
+
+## Step 1 — Spawn design-context-builder
+
+Task("design-context-builder", """
+<required_reading>
+@.design/STATE.md
+@reference/audit-scoring.md
+@reference/anti-patterns.md
+</required_reading>
+
+You are the design-context-builder agent. Auto-detect existing design system
+state via grep/glob before asking questions. Interview the user ONLY for areas
+where auto-detect returned no confident answer. Write .design/DESIGN-CONTEXT.md.
+
+Baseline audit directory detection (ordered fallback chain):
+  1. If src/ exists → use src/
+  2. Elif app/ exists → use app/ (Next.js App Router)
+  3. Elif pages/ exists → use pages/ (Next.js Pages Router)
+  4. Elif lib/ exists → use lib/ (library-only projects)
+  5. Else → flag "layout unknown", skip baseline, note in DESIGN-CONTEXT.md
+
+Common gray areas to probe during discovery (Area 7):
+  1. font-change risk — switching type families when existing UI has body copy in a specific family. Ask: "Is the current body font intentional or inherited? OK to change?"
+  2. token-layer introduction risk — adding CSS custom properties to a codebase that uses direct values. Ask: "Do you want design tokens (--primary, --surface) or inline values (hex, rgb)?"
+  3. Component rebuild vs restyle — when to keep existing component, when to rebuild from scratch. Ask: "For <component>, restyle in place or rebuild?"
+
+Context:
+  auto_mode: <true|false>
+
+Output file: .design/DESIGN-CONTEXT.md
+Emit `## CONTEXT COMPLETE` when done.
+""")
+
+Wait for `## CONTEXT COMPLETE`. Update STATE.md task_progress = 0.5.
+
+## Step 1.75 — Lazy gate: should design-context-checker run? (Plan 10.1-04, D-21)
+
+Spawn the cheap Haiku gate before the full context-checker:
+
+    Task("design-context-checker-gate", """
+    <required_reading>
+    @.design/STATE.md
+    </required_reading>
+
+    You are the design-context-checker-gate.
+
+    Context:
+      diff_files: <git diff --name-only HEAD~1..HEAD>
+      diff_body: (not needed — single-file heuristic)
+      baseline_sha: <HEAD~1>
+
+    Apply the heuristic (DESIGN-CONTEXT.md in diff_files?). Emit JSON + `## GATE COMPLETE`.
+    """)
+
+Wait for `## GATE COMPLETE`. Parse JSON:
+
+- `spawn: false` → append `lazy_skipped: true` telemetry row for `design-context-checker`, skip Step 2, set STATE.md `<position>` as if checker passed (rationale: DESIGN-CONTEXT.md didn't change, last validation still holds), emit `design-context-checker skipped — <rationale>`.
+- `spawn: true` → proceed to Step 2 as currently written.
+
+**Note:** On first-run discover, the builder just wrote DESIGN-CONTEXT.md so the gate returns `spawn: true`. The gate meaningfully short-circuits only on re-runs where the builder made no changes.
+
+**Parallel synthesizer note:** discover does not spawn parallel researchers in v1, so `skills/synthesize/` is not wired here. If future variants spawn N parallel interviewers/auto-detectors, wire synthesize between dispatch and collate as in `skills/map/` Step 3.5.
+
+## Step 2 — Spawn design-context-checker
+
+Task("design-context-checker", """
+<required_reading>
+@.design/STATE.md
+@.design/DESIGN-CONTEXT.md
+</required_reading>
+
+You are the design-context-checker agent. Validate DESIGN-CONTEXT.md across
+6 dimensions. Return APPROVED or BLOCKED with per-dimension verdicts.
+
+Emit `## CONTEXT CHECK COMPLETE` when done.
+""")
+
+Wait for `## CONTEXT CHECK COMPLETE`.
+
+## Step 3 — Handle checker verdict
+
+If APPROVED: proceed to state update.
+If BLOCKED: present dimensions that BLOCKED to user, offer fix-and-retry loop
+(re-spawn builder with specific fix instructions). Do not proceed to planning.
+
+---
+
+## State Update (exit)
+
+1. Set <position> status=completed, task_progress=1/1.
+2. Set <timestamps> discover_completed_at=<ISO 8601 now>.
+3. Update last_checkpoint. Write STATE.md.
+
+---
+
+## After Writing
+
+```
+━━━ Discovery complete ━━━
+Saved: .design/DESIGN-CONTEXT.md
+
+Baseline score: [N]/100 ([grade])
+Key issues: [top issue 1], [top issue 2], [top issue 3]
+
+Next: /get-design-done:plan
+  → Decomposes your context into executable design tasks.
+━━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+Do not proceed to planning automatically unless `--auto` was passed.
+
+## DISCOVER COMPLETE

package/skills/discuss/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: gdd-discuss
+description: "Adaptive design interview — spawns design-discussant to gather decisions via one-question-at-a-time questioning. Writes D-XX decisions to STATE.md <decisions> block."
+argument-hint: "[topic] [--all] [--spec] [--cycle <name>]"
+tools: Read, Write, Task
+---
+
+# /gdd:discuss
+
+**Role:** You are the `/gdd:discuss` command. You spawn the `design-discussant` agent with the right mode and context.
+
+## Step 1 — Read state
+
+Read `.design/STATE.md`. Note:
+- Current `cycle:` frontmatter value
+- Highest existing `D-XX` number under `<decisions>`
+
+If `.design/STATE.md` does not exist, tell the user to run `/gdd:brief` first and stop.
+
+## Step 2 — Parse arguments
+
+Inspect `$ARGUMENTS`:
+- Free-text before flags → `<topic>`
+- `--all` → batch gray-areas mode
+- `--spec` → Socratic ambiguity scoring mode
+- `--cycle <name>` → scope decisions to that cycle
+
+## Step 3 — Spawn design-discussant
+
+```
+Task("design-discussant", """
+<required_reading>
+@.design/STATE.md
+@.design/BRIEF.md
+@.design/DESIGN-CONTEXT.md
+@./.claude/skills
+</required_reading>
+
+<mode>{normal|--all|--spec}</mode>
+<topic>{topic or omit}</topic>
+<cycle>{cycle-name or omit}</cycle>
+
+Run an adaptive design interview. Append D-XX decisions to STATE.md <decisions> block.
+Emit `## DISCUSS COMPLETE` when done.
+""")
+```
+
+Use only the modes the user actually passed. Missing flags → `<mode>normal</mode>`.
+
+## Step 4 — Report
+
+Wait for `## DISCUSS COMPLETE`. Re-read STATE.md. Count new D-XX entries since Step 1. Print:
+
+```
+━━━ Discuss complete ━━━
+New decisions: N (D-XX through D-YY)
+Mode: normal | --all | --spec
+Cycle: <name or "default">
+━━━━━━━━━━━━━━━━━━━━━━━━
+```
+
+## Constraints
+
+- Do not run the interview yourself — always spawn the agent.
+- Do not touch files outside `.design/`.
+
+## DISCUSS COMMAND COMPLETE

package/skills/do/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: gdd-do
+description: "Natural-language design task router. Parses your intent, maps to the right gdd command(s), confirms before executing."
+argument-hint: "<natural language description>"
+tools: Read, Write, AskUserQuestion
+---
+
+# /gdd:do
+
+Takes a free-form description, maps it to a `/gdd:*` command, confirms with the user, then routes.
+
+## Intent parsing table
+
+| Intent signals | Maps to |
+|---|---|
+| "explore", "scan", "what design patterns", "what components" | `/gdd:explore` |
+| "discuss", "decide", "what should we use for", "help me decide" | `/gdd:discuss` |
+| "plan", "create tasks", "what tasks do we need" | `@get-design-done plan` |
+| "design", "implement", "build", "execute" | `@get-design-done design` |
+| "verify", "check", "audit", "review" | `/gdd:audit` |
+| "sketch", "explore directions", "try designs", "variant" | `/gdd:sketch` |
+| "spike", "experiment", "feasibility", "test if" | `/gdd:spike` |
+| "fix [specific thing]" | `/gdd:fast` |
+| "pause", "stop", "save my place" | `/gdd:pause` |
+| "resume", "pick back up", "continue where I left off" | `/gdd:resume` |
+| "ship", "PR", "submit", "merge" | `/gdd:ship` |
+| "undo", "revert", "roll back" | `/gdd:undo` |
+
+## Steps
+
+1. Parse the argument text. Match it against the intent signals table. Choose the best fit.
+2. If two intents tie, ask (AskUserQuestion): "Did you mean <option A> or <option B>?"
+3. Print the routing decision in this exact shape:
+   ```
+   I'll run `/gdd:<command>` — "<one-line rationale>". Confirm? (yes/no)
+   ```
+4. On confirmation: invoke the target skill with any parameters extracted from the input (e.g., topic for `discuss`, symptom for `debug`).
+5. On rejection: ask "What did you mean instead?" and retry once, then abort gracefully.
+
+## Do Not
+
+- Do not execute the target command without confirmation.
+- Do not invent new commands — if no intent matches, say so and list the closest options.
+
+## DO COMPLETE