@hegemonart/get-design-done 1.57.1 → 1.57.3

package/dist/claude-code/.claude/skills/watch-authorities/SKILL.md

@@ -1,82 +0,0 @@
----
-name: gdd-watch-authorities
-description: "Fetches the design-authority feed whitelist, diffs against .design/authority-snapshot.json, and writes .design/authority-report.md (consumed by /gdd:reflect). Authority monitoring only - no trend-watching."
-argument-hint: "[--refresh] [--since <date>] [--feed <name>] [--schedule <weekly|daily|monthly>]"
-tools: Read, Write, Task, Bash
----
-
-# /gdd:watch-authorities
-
-Runs `design-authority-watcher` on demand. Fetches the curated design-authority feed whitelist, diffs against the prior snapshot, classifies new entries into five buckets, and writes `.design/authority-report.md`. Phase 11's reflector picks up the report automatically when you next run `/gdd:reflect`.
-
-Authority-monitoring only. Not trend-watching. See `reference/authority-feeds.md` §"Rejected kinds" for what this skill will never fetch.
-
-## Steps
-
-1. **Parse args.** Extract optional flags: `--refresh`, `--since <date>`, `--feed <name>`, `--schedule <cadence>`. Anything that doesn't match one of these is an error - print `Unknown flag: <arg>. Valid flags: --refresh --since <date> --feed <name> --schedule <weekly|daily|monthly>.` and STOP.
-
-   Mutual exclusion rules:
-   - `--schedule` is handled entirely by this skill - it does not combine with the other three. If `--schedule` is present alongside any of `--refresh | --since | --feed`, print `--schedule cannot combine with other flags. Schedule registration runs this skill with no flags at the configured cadence.` and STOP.
-   - `--refresh` and `--since` are mutually exclusive - print `--refresh and --since are mutually exclusive. --refresh re-seeds the snapshot silently; --since surfaces a backlog from a boundary date. Pick one.` and STOP.
-
-2. **Handle `--schedule <cadence>` branch** (early-return).
-
-   If `--schedule` is set:
-   - Validate cadence ∈ {`weekly`, `daily`, `monthly`}; else print `Unknown cadence: <value>. Use one of: weekly, daily, monthly.` and STOP.
-   - Probe for the scheduled-tasks MCP via ToolSearch:
-
-     ```
-     ToolSearch({ query: "scheduled-tasks", max_results: 3 })
-     ```
-
-   - If the probe returns an empty result set: print `scheduled-tasks MCP not connected. Install it with: claude mcp add scheduled-tasks ... then retry with --schedule.` - this is a documented fallback (not an error). Terminate with `## WATCH COMPLETE` and exit 0.
-   - If the probe returns one or more `scheduled-tasks` tools: register the cron. Discover the MCP's registration tool name at runtime from the ToolSearch result and follow its schema. Target command: `/gdd:watch-authorities` with NO flags (the cron invokes the default diff-and-report behavior). Cadence → cron expression mapping:
-     - `weekly`  → `0 9 * * 1` (Mondays 09:00 local)
-     - `daily`   → `0 9 * * *` (every day 09:00 local)
-     - `monthly` → `0 9 1 * *` (1st of each month 09:00 local)
-   - After registration: print `Scheduled /gdd:watch-authorities to run <cadence>.` and terminate with `## WATCH COMPLETE`.
-
-3. **Validate `--since <date>`** (if present).
-
-   Accept ISO8601 (`YYYY-MM-DD` or `YYYY-MM-DDTHH:MM:SSZ`). Sanity-check via Bash `date -d "<value>" +%s` (GNU) or the POSIX equivalent `python3 -c "from datetime import datetime; datetime.fromisoformat('<value>'.replace('Z','+00:00'))"`. On parse failure: print `Invalid --since value: <value>. Use ISO8601 (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SSZ).` and STOP.
-
-   If the parsed date is earlier than `2020-01-01`, ask: `Very old --since value: <value>. Did you mean something more recent? Proceed? [y/N]`. On anything other than `y`/`Y`, STOP.
-
-4. **Spawn the watcher.**
-
-   Build the `Task(subagent_type="design-authority-watcher", ...)` prompt. The prompt supplies the agent's required-reading block (watcher step 0), echoes the invocation flags verbatim (watcher Flags section), and instructs the agent to follow its own fetch/diff/classify/write loop:
-
-   ```
-   Task("design-authority-watcher", """
-   <required_reading>
-   @reference/authority-feeds.md
-   @.design/authority-snapshot.json
-   @.design/STATE.md
-   </required_reading>
-
-   Invocation flags: <joined flag list or "none">
-
-   Fetch the feeds listed in reference/authority-feeds.md, diff against .design/authority-snapshot.json,
-   classify new entries per the D-17 decision table, write .design/authority-snapshot.json and
-   .design/authority-report.md.
-
-   Terminate with ## WATCH COMPLETE.
-   """)
-   ```
-
-   `<joined flag list>` is the subset of `--refresh | --since <date> | --feed <name>` actually passed - e.g., `--refresh`, `--since 2026-03-01`, `--feed wai-aria-apg`, `--refresh --feed radix-ui-releases`, or literally `none` when no flags were supplied.
-
-5. **Print summary.**
-
-   After the agent returns:
-   - If STATE.md gained a `<blocker type="contract-violation">` on this run (snapshot version mismatch, hash-format violation, or over-200 entries per feed), surface the blocker verbatim and stop - do not print the default "review and reflect" line.
-   - Otherwise print the agent's one-line stdout summary (normal mode: `Surfaced N entries across M feeds. K skipped. See .design/authority-report.md.`; first-run / refresh mode: `Seeded snapshot for N feeds — next run will surface new entries.`) followed by: `Review and reflect: /gdd:reflect`.
-
-6. **Terminate with `## WATCH COMPLETE`.**
-
-## Do Not
-
-- Do not modify `agents/design-authority-watcher.md`.
-- Do not modify `agents/design-reflector.md` - Phase 13.2 does not touch the reflector agent (CONTEXT.md D-25).
-- Do not write to `.design/authority-snapshot.json` or `.design/authority-report.md` directly - those are the agent's writes.
-- Do not fetch URLs outside `reference/authority-feeds.md`. The whitelist is the allow-list.

package/dist/claude-code/.claude/skills/zoom-out/SKILL.md

@@ -1,26 +0,0 @@
----
-name: zoom-out
-description: "Asks the agent to go up a layer of abstraction and map the relevant modules and callers using the project's CONTEXT.md vocabulary. Use when the user is working in an unfamiliar area of code and needs orientation before deep work."
-disable-model-invocation: true
-argument-hint: "[scope]"
----
-
-Source: mattpocock/skills (MIT) - adapted with permission. See `../NOTICE` for the full attribution block.
-
-# Zoom Out
-
-**Role:** Give the user a map, not a fix.
-
-I don't know this area of code well. Go up a layer of abstraction. Give me a map of all the relevant modules and callers, using the project's domain glossary (`CONTEXT.md`) vocabulary.
-
-When invoked, produce a one-screen map that names:
-
-1. **Modules in scope** - one-line description of each, using terms from `CONTEXT.md` (see `./../reference/context-md-format.md` for the schema). Do not invent terms.
-2. **Callers** - who calls these modules from elsewhere, with file paths.
-3. **Seams** - where data crosses module boundaries, named per `./../reference/architecture-vocabulary.md`.
-
-Do not propose fixes. Do not write code. The output is a map.
-
-If `CONTEXT.md` is absent, suggest `/gdd:discuss` to start one, but still produce the map using basenames and inferred terms.
-
-## ZOOM-OUT COMPLETE

package/hooks/first-run-nudge.sh

@@ -1,82 +0,0 @@
-#!/usr/bin/env bash
-# get-design-done — first-run nudge (Phase 14.7)
-# SessionStart hook. Silent-on-failure by policy: exits 0 on every error path.
-# Prints exactly one restrained line pointing at /gdd:start when all gates pass,
-# and nothing otherwise.
-
-set -u  # intentionally no -e: we want to fall through to exit 0
-
-# Silent logger — writes nothing by default. Set GDD_NUDGE_DEBUG=1 to enable stderr.
-log() {
-  if [ "${GDD_NUDGE_DEBUG:-0}" = "1" ]; then
-    printf '[gdd first-run-nudge] %s\n' "$*" >&2
-  fi
-}
-
-DESIGN_DIR="$(pwd)/.design"
-STATE="${DESIGN_DIR}/STATE.md"
-CONFIG="${DESIGN_DIR}/config.json"
-DISMISS_FLAG="${HOME:-$USERPROFILE}/.claude/gdd-nudge-dismissed"
-
-# Gate 1 — repo already has GDD state, suppress.
-has_design_state() {
-  [ -f "${CONFIG}" ] || [ -f "${STATE}" ]
-}
-
-# Gate 2 — per-install dismissal flag.
-is_dismissed() {
-  [ -f "${DISMISS_FLAG}" ]
-}
-
-# Gate 3 — STATE.md stage belongs to an active pipeline window.
-# Inherits the shape used by Phase 13.3 update-check.sh.
-read_state_stage() {
-  [ -f "${STATE}" ] || { printf ''; return; }
-  grep -E '^stage:' "${STATE}" 2>/dev/null | head -n1 | \
-    sed -E 's/^stage:[[:space:]]*"?([^"[:space:]]+)"?.*/\1/'
-}
-
-is_active_stage() {
-  local s
-  s="$(read_state_stage)"
-  case "${s}" in
-    plan|design|verify|executing|discussing) return 0 ;;
-    *) return 1 ;;
-  esac
-}
-
-# Gate 4 — recent session history has a gdd:* command. We cannot reliably read
-# session history from a hook in all runtimes; when the signal is unavailable,
-# treat it as "unknown → not suppressed". This preserves the nudge's
-# usefulness without creating false suppression.
-has_recent_gdd_command() {
-  # Placeholder: no portable transcript path exposed to SessionStart hooks today.
-  # Keep the function for future wiring; for now always returns non-zero (unknown).
-  return 1
-}
-
-# MANDATORY sourcing guard: unit tests source this script to test the helper
-# functions without executing the main flow. Non-negotiable.
-if [ "${BASH_SOURCE[0]}" = "$0" ]; then
-  if has_design_state; then
-    log "design state present — suppress"
-    exit 0
-  fi
-  if is_dismissed; then
-    log "dismissal flag present — suppress"
-    exit 0
-  fi
-  if is_active_stage; then
-    log "active stage — suppress"
-    exit 0
-  fi
-  if has_recent_gdd_command; then
-    log "recent gdd:* command detected — suppress"
-    exit 0
-  fi
-  # All gates passed — emit the locked one-line nudge.
-  printf 'Tip: run /gdd:start to let GDD inspect this codebase and suggest one first fix.\n'
-  exit 0
-fi
-# When sourced (BASH_SOURCE != $0), fall through with function definitions loaded
-# and without side effects.

package/hooks/inject-using-gdd.sh

@@ -1,72 +0,0 @@
-#!/usr/bin/env bash
-# hooks/inject-using-gdd.sh — SessionStart per-harness context injector (D-07).
-#
-# The forcing function GDD lacked: on every session start / /clear / compact this
-# reads skills/using-gdd/SKILL.md (the bootstrap discipline contract) and emits it
-# as the host harness's SessionStart "additionalContext" shape so the agent is
-# primed with the 1%-rule + red-flags + skill-priority before it acts.
-#
-# Ported MECHANISM (not content) from obra/superpowers (MIT): one polyglot script,
-# env-var branch, pure-bash escape_for_json (no jq/python dependency). See NOTICE.
-#
-# Three emitted shapes (ONE JSON object on stdout, nothing else):
-#   Cursor       (CURSOR_PLUGIN_ROOT set)        -> {"additional_context": "<escaped>"}
-#   Claude Code  (CLAUDE_PLUGIN_ROOT set, no Cursor)
-#                                                -> {"hookSpecificOutput":
-#                                                     {"hookEventName":"SessionStart",
-#                                                      "additionalContext":"<escaped>"}}
-#   SDK-standard (neither; e.g. COPILOT_CLI)     -> {"additionalContext": "<escaped>"}
-#
-# Branch order: check Cursor BEFORE Claude Code — a Cursor session may also export
-# CLAUDE_PLUGIN_ROOT, and Cursor's own var must win.
-#
-# NO-CASCADE (D-06): this script is wired ONLY under the SessionStart hook event in
-# hooks/hooks.json. Subagent spawns do not fire SessionStart, so the inject cannot
-# cascade into a subagent's context. (Structural guarantee; behavioral proof = P33.)
-
-set -u
-
-# --- Resolve the plugin root so we can locate skills/using-gdd/SKILL.md ---------
-# Prefer the harness-provided roots; fall back to this script's parent dir so the
-# emitter is runnable straight from hooks/ in tests and in bare shells.
-SELF_DIR="$(cd "$(dirname "$0")" && pwd)"
-ROOT="${CURSOR_PLUGIN_ROOT:-${CLAUDE_PLUGIN_ROOT:-${SELF_DIR}/..}}"
-ROOT="${ROOT//\\//}"  # normalize Windows backslashes to forward slashes
-SKILL="${ROOT}/skills/using-gdd/SKILL.md"
-
-# Defensive: if the skill file is missing we must STILL emit a syntactically valid
-# JSON object (an empty additionalContext) so the SessionStart pipeline never
-# breaks on a partial install. Never crash the session start.
-if [[ -r "${SKILL}" ]]; then
-  CONTENT="$(cat "${SKILL}")"
-else
-  CONTENT=""
-fi
-
-# --- escape_for_json (superpowers pattern; pure bash param-substitution) --------
-# Order matters: backslash FIRST (so escapes we add next aren't re-escaped), then
-# double-quote, then the control chars newline / tab / carriage-return. Emits the
-# value WITH surrounding double-quotes so callers can splice it directly.
-escape_for_json() {
-  local s="$1"
-  s="${s//\\/\\\\}"   # \  -> \\
-  s="${s//\"/\\\"}"   # "  -> \"
-  s="${s//$'\t'/\\t}" # tab -> \t
-  s="${s//$'\r'/\\r}" # CR  -> \r
-  s="${s//$'\n'/\\n}" # LF  -> \n  (do last: newlines are the record separator)
-  printf '"%s"' "$s"
-}
-
-ESCAPED="$(escape_for_json "${CONTENT}")"
-
-# --- Branch on harness env vars and emit the matching single JSON object --------
-if [[ -n "${CURSOR_PLUGIN_ROOT:-}" ]]; then
-  # Cursor: top-level additional_context.
-  printf '{"additional_context": %s}\n' "${ESCAPED}"
-elif [[ -n "${CLAUDE_PLUGIN_ROOT:-}" ]]; then
-  # Claude Code: hookSpecificOutput envelope (mirrors hooks/gdd-decision-injector.js).
-  printf '{"hookSpecificOutput": {"hookEventName": "SessionStart", "additionalContext": %s}}\n' "${ESCAPED}"
-else
-  # SDK-standard (COPILOT_CLI or none): top-level additionalContext.
-  printf '{"additionalContext": %s}\n' "${ESCAPED}"
-fi

package/hooks/run-hook.cmd

@@ -1,35 +0,0 @@
-@echo off
-REM hooks/run-hook.cmd — Windows polyglot wrapper that invokes a GDD .sh hook
-REM through bash.
-REM
-REM Workaround for Claude Code's Windows auto-bash bug: CC can mis-handle a
-REM SessionStart `command` that points directly at a `.sh` file on Windows
-REM shells. This .cmd shim locates bash and runs the script explicitly, so the
-REM SessionStart inject (hooks/inject-using-gdd.sh) fires on Windows too.
-REM
-REM Usage:  run-hook.cmd <script-name.sh> [args...]
-REM Default (no arg): inject-using-gdd.sh — the SessionStart using-gdd injector.
-REM The host harness's env (CLAUDE_PLUGIN_ROOT / CURSOR_PLUGIN_ROOT / COPILOT_CLI)
-REM is inherited by bash and drives the emitter's per-harness branch.
-setlocal
-
-REM Script to run, relative to this .cmd's own directory (%~dp0 ends with a backslash).
-set "HOOK_SCRIPT=%~1"
-if "%HOOK_SCRIPT%"=="" set "HOOK_SCRIPT=inject-using-gdd.sh"
-if not "%~1"=="" shift
-
-set "HOOK_PATH=%~dp0%HOOK_SCRIPT%"
-
-REM Prefer bash on PATH; fall back to a typical Git-for-Windows install location.
-where bash >nul 2>nul
-if %ERRORLEVEL%==0 (
-  bash "%HOOK_PATH%" %*
-) else if exist "%ProgramFiles%\Git\bin\bash.exe" (
-  "%ProgramFiles%\Git\bin\bash.exe" "%HOOK_PATH%" %*
-) else (
-  REM No bash available: emit a valid empty SDK-shape JSON object so the
-  REM SessionStart pipeline still receives parseable output and never breaks.
-  echo {"additionalContext": ""}
-)
-
-endlocal

package/hooks/update-check.sh

@@ -1,251 +0,0 @@
-#!/usr/bin/env bash
-# get-design-done — update check (Phase 13.3)
-# SessionStart hook. Silent-on-failure by policy (D-04): exits 0 on every error path.
-# 24h-cached unauthenticated GET of /releases/latest. Renders .design/update-available.md
-# only when a newer version exists AND it is not dismissed AND stage-guard allows.
-
-set -u  # intentionally no -e: we want to fall through to exit 0
-
-PLUGIN_ROOT="${CLAUDE_PLUGIN_ROOT:-$(cd "$(dirname "$0")/.." && pwd)}"
-PLUGIN_ROOT="${PLUGIN_ROOT//\\//}"  # Windows → POSIX slashes
-
-DESIGN_DIR="$(pwd)/.design"
-CACHE="${DESIGN_DIR}/update-cache.json"
-BANNER="${DESIGN_DIR}/update-available.md"
-CONFIG="${DESIGN_DIR}/config.json"
-STATE="${DESIGN_DIR}/STATE.md"
-CACHE_TTL_SECONDS=86400  # 24h
-
-# Silent logger — writes nothing by default. Set GDD_UPDATE_DEBUG=1 to enable stderr.
-log() {
-  if [ "${GDD_UPDATE_DEBUG:-0}" = "1" ]; then
-    printf '[gdd update-check] %s\n' "$*" >&2
-  fi
-}
-
-# Ensure .design/ exists (bootstrap normally creates it; belt+suspenders).
-mkdir -p "${DESIGN_DIR}" 2>/dev/null || exit 0
-
-# ---- Read current plugin version (no jq) ----
-PLUGIN_JSON="${PLUGIN_ROOT}/.claude-plugin/plugin.json"
-
-read_current_tag() {
-  [ -f "${PLUGIN_JSON}" ] || return 1
-  grep -E '^[[:space:]]*"version"[[:space:]]*:' "${PLUGIN_JSON}" | head -n1 | \
-    sed -E 's/.*"version"[[:space:]]*:[[:space:]]*"([^"]+)".*/\1/'
-}
-
-# ---- Semver normalizer: "v1.0.7" -> "1 0 7 0"; "v1.0.7.3" -> "1 0 7 3" ----
-normalize_semver() {
-  local t="${1#v}"
-  # strip any -pre/-beta suffix after first hyphen (unauth'd API rarely surfaces these, best-effort)
-  t="${t%%-*}"
-  # Replace dots with spaces; pad to 4 segments
-  # shellcheck disable=SC2086
-  set -- $(printf '%s' "${t}" | tr '.' ' ')
-  local a="${1:-0}" b="${2:-0}" c="${3:-0}" d="${4:-0}"
-  # Sanitize to digits only (POSIX: tr -cd 0-9 — BSD+GNU safe)
-  a="$(printf '%s' "$a" | tr -cd '0-9')"; a="${a:-0}"
-  b="$(printf '%s' "$b" | tr -cd '0-9')"; b="${b:-0}"
-  c="$(printf '%s' "$c" | tr -cd '0-9')"; c="${c:-0}"
-  d="$(printf '%s' "$d" | tr -cd '0-9')"; d="${d:-0}"
-  printf '%s %s %s %s' "$a" "$b" "$c" "$d"
-}
-
-# ---- Classify delta: compare 4-segment tuples ----
-# Args: current_tag latest_tag
-# Prints: "newer|same|older|invalid" + "major|minor|patch|off-cadence|none"
-classify_delta() {
-  local cur lat
-  cur="$(normalize_semver "$1")" || { printf 'invalid none'; return; }
-  lat="$(normalize_semver "$2")" || { printf 'invalid none'; return; }
-  # shellcheck disable=SC2086
-  set -- $cur; local ca="$1" cb="$2" cc="$3" cd="$4"
-  # shellcheck disable=SC2086
-  set -- $lat; local la="$1" lb="$2" lc="$3" ld="$4"
-
-  # Per-segment integer compare (lexicographic per segment by numeric value)
-  if   [ "$la" -gt "$ca" ]; then printf 'newer major'; return
-  elif [ "$la" -lt "$ca" ]; then printf 'older major'; return
-  fi
-  if   [ "$lb" -gt "$cb" ]; then printf 'newer minor'; return
-  elif [ "$lb" -lt "$cb" ]; then printf 'older minor'; return
-  fi
-  if   [ "$lc" -gt "$cc" ]; then printf 'newer patch'; return
-  elif [ "$lc" -lt "$cc" ]; then printf 'older patch'; return
-  fi
-  if   [ "$ld" -gt "$cd" ]; then printf 'newer off-cadence'; return
-  elif [ "$ld" -lt "$cd" ]; then printf 'older off-cadence'; return
-  fi
-  printf 'same none'
-}
-
-# ---- Cache freshness check: returns 0 if fresh (<24h old), 1 if stale or missing ----
-is_cache_fresh() {
-  [ -f "${CACHE}" ] || return 1
-  local now mtime age
-  now="$(date +%s)"
-  # BSD date -r on macOS; GNU stat -c on Linux; fall back to perl then python.
-  if mtime="$(date -r "${CACHE}" +%s 2>/dev/null)"; then :
-  elif mtime="$(stat -c %Y "${CACHE}" 2>/dev/null)"; then :
-  elif mtime="$(perl -e 'print((stat shift)[9])' "${CACHE}" 2>/dev/null)"; then :
-  else return 1
-  fi
-  [ -n "${mtime:-}" ] || return 1
-  age=$((now - mtime))
-  [ "${age}" -lt "${CACHE_TTL_SECONDS}" ]
-}
-
-# ---- Fetch latest release. Writes raw body to stdout on success, nothing on failure. ----
-fetch_latest() {
-  command -v curl >/dev/null 2>&1 || { log "no curl"; return 1; }
-  local url="https://api.github.com/repos/hegemonart/get-design-done/releases/latest"
-  curl -sf --max-time 3 -H 'Accept: application/vnd.github+json' "${url}" 2>/dev/null || return 1
-}
-
-# ---- Extract fields from the release JSON (no jq). Robust to whitespace; fails soft. ----
-extract_tag() {
-  grep -E '"tag_name"[[:space:]]*:' | head -n1 | sed -E 's/.*"tag_name"[[:space:]]*:[[:space:]]*"([^"]+)".*/\1/'
-}
-# Body extraction: python3-only. If python3 is absent, we intentionally return empty
-# (D-04 silent-on-failure posture). No awk/sed fallback — JSON string decoding in pure
-# bash is fragile and untested; empty excerpt is the correct degraded state.
-extract_body() {
-  command -v python3 >/dev/null 2>&1 || return 0
-  python3 -c 'import json,sys
-try:
-  d=json.load(sys.stdin)
-  b=d.get("body","") or ""
-  print(b[:500])
-except Exception:
-  pass' 2>/dev/null
-}
-
-# ---- Read .design/STATE.md stage field. Returns "brief"|"explore"|"plan"|"design"|"verify"|"" ----
-# Schema source: reference/STATE-TEMPLATE.md — `stage:` lives in both the frontmatter
-# and the <position> block with identical values per the write contract. We take the
-# first occurrence (head -n1), which is the frontmatter line.
-read_state_stage() {
-  [ -f "${STATE}" ] || { printf ''; return; }
-  grep -E '^stage:' "${STATE}" 2>/dev/null | head -n1 | sed -E 's/^stage:[[:space:]]*"?([^"[:space:]]+)"?.*/\1/'
-}
-
-# ---- Read .design/config.json for update_dismissed. Returns tag or empty. ----
-read_dismissed() {
-  [ -f "${CONFIG}" ] || { printf ''; return; }
-  grep -E '"update_dismissed"[[:space:]]*:' "${CONFIG}" 2>/dev/null | head -n1 | \
-    sed -E 's/.*"update_dismissed"[[:space:]]*:[[:space:]]*"([^"]+)".*/\1/'
-}
-
-# ---- Main control flow ----
-# MANDATORY sourcing guard: wrap the entire main flow so that `source update-check.sh`
-# (used by unit tests and interactive debugging) loads the function definitions without
-# executing steps 1-6 and exiting the sourcing shell. This is non-negotiable — the
-# semver self-test acceptance criterion sources this script.
-if [ "${BASH_SOURCE[0]}" = "$0" ]; then
-
-  CURRENT_TAG="$(read_current_tag)" || { log "no plugin.json"; exit 0; }
-  [ -n "${CURRENT_TAG:-}" ] || { log "no current version parsed"; exit 0; }
-  # Normalize to "vX.Y.Z" shape for display (plugin.json stores bare "1.0.7")
-  DISPLAY_CURRENT="v${CURRENT_TAG#v}"
-
-  # Optional --refresh forces a fresh fetch (called by plan 13.3-04's /gdd:check-update --refresh).
-  FORCE_REFRESH=0
-  for arg in "$@"; do
-    case "$arg" in
-      --refresh) FORCE_REFRESH=1 ;;
-    esac
-  done
-
-  # 1. Populate cache if missing/stale or forced.
-  if [ "${FORCE_REFRESH}" -eq 1 ] || ! is_cache_fresh; then
-    RAW="$(fetch_latest)" || RAW=""
-    if [ -n "${RAW}" ]; then
-      LATEST_TAG="$(printf '%s' "${RAW}" | extract_tag)"
-      BODY_EXCERPT="$(printf '%s' "${RAW}" | extract_body)"
-      # Strip control chars defensively (T-13.3-03)
-      BODY_EXCERPT="$(printf '%s' "${BODY_EXCERPT}" | tr -d '\000-\010\013\014\016-\037')"
-      # Strip double-quotes so the JSON round-trip sed read-back cannot be injected via a
-      # crafted release body. Body is display-only — losing quotes is acceptable.
-      BODY_EXCERPT="$(printf '%s' "${BODY_EXCERPT}" | tr -d '"')"
-      # Validate LATEST_TAG is a safe semver string before trusting it (CR-02).
-      if ! printf '%s' "${LATEST_TAG}" | grep -qE '^v?[0-9]+\.[0-9]+(\.[0-9]+)*$'; then
-        log "LATEST_TAG '${LATEST_TAG}' failed semver safety check — aborting cache write"
-        LATEST_TAG=""
-      fi
-      if [ -n "${LATEST_TAG}" ]; then
-        read -r DELTA_STATE DELTA_KIND <<EOF
-$(classify_delta "${DISPLAY_CURRENT}" "${LATEST_TAG}")
-EOF
-        IS_NEWER=false
-        [ "${DELTA_STATE}" = "newer" ] && IS_NEWER=true
-        CHECKED_AT="$(date +%s)"
-        # Write cache atomically (write-to-tmp + rename) — T-13.3-04 mitigation
-        TMP="${CACHE}.tmp.$$"
-        {
-          printf '{\n'
-          printf '  "checked_at": %s,\n' "${CHECKED_AT}"
-          printf '  "current_tag": "%s",\n' "${DISPLAY_CURRENT}"
-          printf '  "latest_tag": "%s",\n' "${LATEST_TAG}"
-          printf '  "delta": "%s",\n' "${DELTA_KIND}"
-          printf '  "is_newer": %s,\n' "${IS_NEWER}"
-          # Escape the body for JSON — backslashes first, then quotes, then newlines.
-          ESC="$(printf '%s' "${BODY_EXCERPT}" | sed -e 's/\\/\\\\/g' -e 's/"/\\"/g' | awk '{printf "%s\\n", $0}')"
-          printf '  "changelog_excerpt": "%s"\n' "${ESC}"
-          printf '}\n'
-        } > "${TMP}" 2>/dev/null && mv "${TMP}" "${CACHE}" 2>/dev/null || rm -f "${TMP}" 2>/dev/null
-      fi
-    fi
-  fi
-
-  # 2. Read cache (whether freshly written or still valid).
-  [ -f "${CACHE}" ] || exit 0  # no cache, nothing to do — silent exit
-
-  C_LATEST="$(grep -E '"latest_tag"' "${CACHE}" 2>/dev/null | head -n1 | sed -E 's/.*"latest_tag"[[:space:]]*:[[:space:]]*"([^"]+)".*/\1/')"
-  C_DELTA="$(grep -E '"delta"' "${CACHE}" 2>/dev/null | head -n1 | sed -E 's/.*"delta"[[:space:]]*:[[:space:]]*"([^"]+)".*/\1/')"
-  # Allowlist-gate C_DELTA before it reaches any shell context (WR-04).
-  case "${C_DELTA:-}" in
-    major|minor|patch|off-cadence|none) : ;;
-    *) C_DELTA="unknown" ;;
-  esac
-  C_NEWER="$(grep -E '"is_newer"' "${CACHE}" 2>/dev/null | head -n1 | sed -E 's/.*"is_newer"[[:space:]]*:[[:space:]]*(true|false).*/\1/')"
-  C_BODY="$(grep -E '"changelog_excerpt"' "${CACHE}" 2>/dev/null | head -n1 | sed -E 's/.*"changelog_excerpt"[[:space:]]*:[[:space:]]*"(.*)".*/\1/' | sed -E 's/\\n/\n/g')"
-
-  # 3. Gate: if cache says not newer, remove any stale banner and exit.
-  if [ "${C_NEWER:-false}" != "true" ]; then
-    rm -f "${BANNER}" 2>/dev/null
-    exit 0
-  fi
-
-  # 4. Dismissal gate (D-13): if user already dismissed this exact tag, suppress.
-  DISMISSED="$(read_dismissed)"
-  if [ -n "${DISMISSED}" ] && [ "${DISMISSED}" = "${C_LATEST}" ]; then
-    rm -f "${BANNER}" 2>/dev/null
-    exit 0
-  fi
-
-  # 5. State-machine guard (D-11/D-12): suppress during plan|design|verify.
-  STAGE="$(read_state_stage)"
-  case "${STAGE}" in
-    plan|design|verify)
-      rm -f "${BANNER}" 2>/dev/null
-      exit 0
-      ;;
-  esac
-
-  # 6. All gates passed — render the banner atomically.
-  TMP="${BANNER}.tmp.$$"
-  {
-    printf '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'
-    printf ' 📦 Plugin update: %s → %s (%s)\n' "${DISPLAY_CURRENT}" "${C_LATEST}" "${C_DELTA}"
-    if [ -n "${C_BODY}" ]; then
-      printf '%s\n' "${C_BODY}"
-    fi
-    printf ' Install: /gdd:update   Dismiss: /gdd:check-update --dismiss\n'
-    printf '━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'
-  } > "${TMP}" 2>/dev/null && mv "${TMP}" "${BANNER}" 2>/dev/null || rm -f "${TMP}" 2>/dev/null
-
-  exit 0
-fi
-# When sourced (BASH_SOURCE != $0), fall through with function definitions loaded
-# and without side effects. Sourcing callers must invoke functions explicitly.