@hegemonart/get-design-done 1.59.2 → 1.59.4

package/.claude-plugin/marketplace.json

@@ -5,14 +5,14 @@
   },
   "metadata": {
     "description": "Get Design Done — 5-stage agent-orchestrated design pipeline (Brief → Explore → Plan → Design → Verify) for AI coding agents. 64 agents, 95 skills, 39 connection integrations, two MCP servers, opt-in SQLite state backbone, bidirectional Figma write-back, and a reflector-driven self-improvement loop. Cross-runtime install for Claude Code, Codex, Cursor, OpenCode, Gemini, and more.",
-    "version": "1.59.2"
+    "version": "1.59.4"
   },
   "plugins": [
     {
       "name": "get-design-done",
       "source": "./",
       "description": "Agent-orchestrated 5-stage design pipeline (Brief → Explore → Plan → Design → Verify) for AI coding agents. 64 specialized agents, 95 skills, 39 connection integrations (Figma, Refero, Preview, Storybook, Chromatic, Graphify, Linear, Jira, Notion, …), bidirectional Figma write-back, queryable intel store, opt-in SQLite state backbone, and a reflector-driven self-improvement loop. Two MCP servers (gdd-state for typed STATE mutators, gdd-mcp for 13 read-only project-priming tools), tier-aware routing with cost telemetry, and defense-in-depth hooks (protected paths, MCP circuit breaker, injection scanner, budget enforcer). Cross-runtime install for Claude Code, Codex, Cursor, OpenCode, Gemini, Copilot, and more.",
-      "version": "1.59.2",
+      "version": "1.59.4",
       "author": {
         "name": "hegemonart"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "get-design-done",
   "short_name": "gdd",
-  "version": "1.59.2",
+  "version": "1.59.4",
   "description": "Agent-orchestrated 5-stage design pipeline (Brief → Explore → Plan → Design → Verify) for AI coding agents. 64 specialized agents, 95 skills, 39 connection integrations (Figma, Refero, Preview, Storybook, Chromatic, Graphify, Linear, Jira, Notion, …), bidirectional Figma write-back, queryable intel store for O(1) design-surface lookups, opt-in SQLite state backbone, and a reflector-driven self-improvement loop. Two MCP servers (`gdd-state` for typed STATE mutators, `gdd-mcp` for 13 read-only project-priming tools), tier-aware agent routing with cost telemetry, defense-in-depth hooks (protected paths, MCP circuit breaker, injection scanner, budget enforcer), and a cross-runtime install layer for Claude Code, Codex, Cursor, OpenCode, Gemini, Copilot, and more.",
   "author": {
     "name": "hegemonart",

package/CHANGELOG.md

@@ -4,6 +4,62 @@ All notable changes to get-design-done are documented here. Versions follow [sem
 
 ---
 
+## [1.59.4] - 2026-06-04
+
+Fourth point release of the **v1.59 "Audit Closeout & Honesty Pass"** milestone. Skill-surface + build hygiene.
+
+### Changed
+
+- **`skill-templates/` relocated to `scripts/skill-templates/`** (source-dir move, git history preserved; 36 reference updates). The committed `skills/` build output is unchanged, so the `build:skills:check` drift gate stays meaningful.
+- **`/gdd:help` is now complete and dynamic.** It reads `scripts/lib/manifest/skills.json` and renders every skill, replacing a hardcoded ~41-command subset (of 95). Root SKILL.md Jump Mode now notes it is a curated subset and points to `/gdd:help` for the full manifest-rendered reference.
+
+### Added
+
+- **npm-installed users can now author skills.** `package.json#files[]` ships `scripts/skill-templates/`, `scripts/build-skills.cjs`, and `scripts/generate-skill-frontmatter.cjs` (so `/gdd:new-skill` + rebuild work off an `npm install`), plus the figma plugin source (`figma-plugin/`).
+- **`codegen:schemas:check` drift gate** (EOL-agnostic) wired into CI, closing the one previously un-gated generator (`reference/schemas/generated.d.ts`).
+
+### Fixed
+
+- **Stale "gitignored" README claims** corrected: `skills/` has been a committed build artifact since v1.58.1, not gitignored.
+- Pre-existing stale `source/skills` regex in `hooks/gdd-intel-trigger.js` repointed to `scripts/skill-templates`.
+
+### Note
+
+- The "7 Phase-28.8 baseline regen pending" skips named in the plan were already resolved by earlier phases (no such markers remain), so there was nothing to burn down.
+
+### Breaking changes
+
+None.
+
+5,049/5,049 tests pass.
+
+---
+
+## [1.59.3] - 2026-06-04
+
+Third point release of the **v1.59 "Audit Closeout & Honesty Pass"** milestone. A routing-coherence pass on agent model/tier declarations.
+
+### Added
+
+- **Model-vs-default-tier coherence check** in `scripts/validate-frontmatter.ts`. The CI frontmatter gate now errors when an agent declares a literal `model` that contradicts its `default-tier` (for example `model: sonnet` under `default-tier: opus`), and emits a non-failing advisory when a haiku-tier agent uses `model: inherit` (which would defeat the cheap-gate cost intent).
+
+### Fixed
+
+- **Two tier contradictions corrected.** `design-advisor` (was `model: sonnet` under an opus-tier rationale, now `model: inherit`) and `design-plan-checker` (dropped the contradicting `model: sonnet`; it resolves via `default-tier: haiku`).
+- **Cheap-gate cost governance restored.** Stripped the redundant `model: inherit` from 10 haiku-tier gate/checker agents (`design-context-checker`, `design-context-reviewer`, `design-integration-checker`, `design-verifier`, their four `-gate` variants, `prototype-gate`, `quality-gate-runner`) so they resolve to the cheap haiku model instead of inheriting the session model.
+
+### Note
+
+- The rest of the original 59.3 plan was already shipped by earlier phases: peer-CLI `delegate_to`, the intel-updater PostToolUse hook, the context-reviewer wiring in explore, the planner/verifier output-contracts, and the `audit-aggregator` / `hedge-ensemble` dead-code removal. `touches-pattern-miner` was retained because it has a live caller (`incubator-proposals`); it is not dead code.
+
+### Breaking changes
+
+None.
+
+5,049/5,049 tests pass.
+
+---
+
 ## [1.59.2] - 2026-06-04
 
 Second point release of the **v1.59 "Audit Closeout & Honesty Pass"** milestone. Wires the AI-native Wave-2 connections and reconciles the connection count to the honest number.

package/SKILL.md

@@ -199,6 +199,8 @@ Use `[✓]` for complete, `[→]` for current, `[ ]` for pending, `[!]` for gaps
 
 If `$ARGUMENTS` is a stage or command name - invoke it directly, no state check:
 
+> This table lists the common stage and shortcut routes. Every skill in `scripts/lib/manifest/skills.json` is auto-resolvable as `/gdd:<name>`; run `/gdd:help` for the complete, always-current command reference (rendered from the manifest, never a hardcoded subset).
+
 ```
 /gdd:brief     → Skill("get-design-done:gdd-brief")
 /gdd:explore   → Skill("get-design-done:gdd-explore")

package/agents/design-advisor.md

@@ -3,7 +3,7 @@ name: design-advisor
 description: Researches a single gray area and produces a 5-column comparison table with rationale. Spawned by design-context-builder when a gray area exceeds judgment threshold. Returns inline text - no file output.
 tools: Read, Grep, Glob, WebSearch
 color: blue
-model: sonnet
+model: inherit
 default-tier: opus
 tier-rationale: "Questions prompts to surface ambiguity; wrong advice cascades across downstream spawns"
 parallel-safe: always

package/agents/design-context-checker-gate.md

@@ -3,7 +3,6 @@ name: design-context-checker-gate
 description: "Cheap Haiku gate that reads a diff and decides whether design-context-checker should spawn. Spawns only when DESIGN-CONTEXT.md itself was modified."
 tools: Read, Bash, Grep
 color: cyan
-model: inherit
 default-tier: haiku
 tier-rationale: "Cheap diff-scan gate - context checker only runs when DESIGN-CONTEXT.md changed"
 size_budget: S

package/agents/design-context-checker.md

@@ -3,7 +3,6 @@ name: design-context-checker
 description: Validates .design/DESIGN-CONTEXT.md across 6 dimensions (copy specificity, color contract, typography scale, spacing scale, must-have testability, goal observability). Returns APPROVED or BLOCKED with per-dimension BLOCK/FLAG/PASS verdicts. Spawned by the discover stage after design-context-builder completes.
 tools: Read, Grep, Glob
 color: cyan
-model: inherit
 default-tier: haiku
 tier-rationale: "Schema-driven completeness check; deterministic rubric, no reasoning density needed"
 size_budget: LARGE

package/agents/design-context-reviewer-gate.md

@@ -3,7 +3,6 @@ name: design-context-reviewer-gate
 description: "Cheap Haiku gate that reads a change signal and decides whether design-context-reviewer should spawn. Suppresses the reviewer when project change is below 5 percent."
 tools: Read, Bash, Grep
 color: cyan
-model: inherit
 default-tier: haiku
 tier-rationale: "Cheap change-signal gate - graph reviewer only runs when the graph changed enough to matter"
 size_budget: S

package/agents/design-context-reviewer.md

@@ -3,7 +3,6 @@ name: design-context-reviewer
 description: "Reviews the merged .design/context-graph.json after mapper assembly across 9 checks (schema validity, referential integrity, completeness, layer coverage, id uniqueness, summary quality, edge-expectation consistency, type-prefix consistency, coverage-vs-stack). Hard-rejects on critical breakage; soft-warns on advisory issues. Spawned by the explore stage after the synthesizer merges all fragments."
 tools: Read, Grep, Glob
 color: cyan
-model: inherit
 default-tier: haiku
 tier-rationale: "Schema-driven graph review on top of a deterministic validator; rubric-bound, no reasoning density needed"
 size_budget: LARGE

package/agents/design-integration-checker-gate.md

@@ -3,7 +3,6 @@ name: design-integration-checker-gate
 description: "Cheap Haiku gate that reads a diff and decides whether design-integration-checker should spawn. Returns {spawn, rationale}. Short-circuits when no D-XX decisions or reference docs were touched."
 tools: Read, Bash, Grep
 color: blue
-model: inherit
 default-tier: haiku
 tier-rationale: "Cheap diff-scan gate - expensive integration checker spawned only on heuristic hit"
 size_budget: S

package/agents/design-integration-checker.md

@@ -3,7 +3,6 @@ name: design-integration-checker
 description: Verifies D-XX design decisions from DESIGN-CONTEXT.md are actually wired through source code via grep-based checks on tokens, colors, spacing, component patterns. Runs AFTER design-verifier in the verify stage. Returns Connected/Orphaned/Missing counts.
 tools: Read, Bash, Grep, Glob
 color: blue
-model: inherit
 default-tier: haiku
 tier-rationale: "Cross-artifact link-integrity scan; structured input, structured output"
 size_budget: LARGE

package/agents/design-plan-checker.md

@@ -3,7 +3,6 @@ name: design-plan-checker
 description: Validates DESIGN-PLAN.md will achieve DESIGN-CONTEXT.md brief goals before execution. Goal-backward check on plan structure, not on code. Spawned by the plan stage after design-planner completes.
 tools: Read, Bash, Grep, Glob
 color: green
-model: sonnet
 default-tier: haiku
 tier-rationale: "Checks plan artifact against a fixed schema; boolean + gap-list output fits Haiku"
 parallel-safe: always

package/agents/design-verifier-gate.md

@@ -3,7 +3,6 @@ name: design-verifier-gate
 description: "Cheap Haiku gate that reads a diff and decides whether design-verifier should spawn. Returns {spawn, rationale}. Short-circuits verifier spawns on small or copy-only changes that don't touch design-system surfaces."
 tools: Read, Bash, Grep
 color: green
-model: inherit
 default-tier: haiku
 tier-rationale: "Cheap diff-scan gate - expensive verifier spawned only on heuristic hit"
 size_budget: S

package/agents/design-verifier.md

@@ -3,7 +3,6 @@ name: design-verifier
 description: Goal-backward verification of design outcomes against .design/STATE.md must-haves, NNG heuristics, and audit rubric. Returns pass result or structured gap list. Spawned by the verify stage.
 tools: Read, Write, Bash, Grep, Glob, mcp__Claude_Preview__preview_list, mcp__Claude_Preview__preview_navigate, mcp__Claude_Preview__preview_screenshot, mcp__Claude_Preview__preview_eval, mcp__Claude_Preview__preview_snapshot, mcp__Claude_Preview__preview_inspect
 color: green
-model: inherit
 default-tier: haiku
 tier-rationale: "Verifier runs structured goal-backward checks - cheap Haiku is sufficient and fast"
 size_budget: XXL

package/agents/prototype-gate.md

@@ -3,7 +3,6 @@ name: prototype-gate
 description: "Cheap Haiku gate that scores sketch / spike signals from the active brief / context / plan and emits a JSON verdict recommending whether to prototype before continuing."
 tools: Read, Bash, Grep
 color: yellow
-model: inherit
 default-tier: haiku
 tier-rationale: "Signal-counting rubric over a few small inputs - no synthesis, no writes, no agent spawning. Belongs on Haiku to keep gate latency cheap (≤ 2 s typical)."
 size_budget: S

package/agents/quality-gate-runner.md

@@ -3,7 +3,6 @@ name: quality-gate-runner
 description: "Cheap Haiku classifier that ingests {command, exit_code, stderr} tuples from the quality-gate skill's parallel run and emits a JSON verdict - pass/fail plus per-bucket failure groupings (lint / type / test / visual / a11y). Read-only. Does not run commands itself."
 tools: Read, Bash, Grep
 color: amber
-model: inherit
 default-tier: haiku
 tier-rationale: "Pattern-match exit codes and bucket stderr into five named categories - no synthesis, no rewrites, no spawning. Belongs on Haiku to keep classification cost trivial relative to the actual command runs."
 size_budget: S

package/figma-plugin/README.md

@@ -0,0 +1,61 @@
+# GDD Sync — Figma plugin
+
+`GDD Sync` is the Figma-side half of GDD's design-system extractor (Path C). It reads
+your file's **local Figma variables** from inside Figma and POSTs them as JSON to a
+GDD extract receiver listening on `localhost:5179`.
+
+## Why this exists
+
+GDD's extractor pulls a design system from the Figma REST API into a compact local
+digest. The Variables REST API, however, is **Enterprise-only** — it returns `403` on
+Free/Pro/Org plans. A Figma plugin has full `figma.variables` access on **any** plan, so
+this plugin fills that gap: it reads what the API cannot and ships it to GDD locally.
+
+## Security
+
+The plugin can talk to **localhost only**. `manifest.json` declares
+`networkAccess.allowedDomains` as exactly:
+
+```json
+["http://localhost:5179", "http://127.0.0.1:5179"]
+```
+
+No wildcard, no external host. This is the single hard security boundary of Path C
+(decision D-06): the plugin has no exfiltration surface — it can reach the local GDD
+receiver and nothing else.
+
+## Development
+
+This is a standalone TypeScript package (decision D-05). It is **not** part of the root
+`get-design-done` package.
+
+### Build
+
+```bash
+cd figma-plugin
+npm install
+npm run build   # runs tsc → emits code.js next to code.ts
+```
+
+`code.ts` (sandbox entry) and `src/*.ts` compile under `tsconfig.json` against
+`@figma/plugin-typings` into `code.js`, which `manifest.json` references via `main`.
+
+### Dev-install (Figma desktop)
+
+1. Build (`npm run build`) so `code.js` exists.
+2. In the **Figma desktop app**: **Plugins → Development → Import plugin from manifest…**
+3. Select `figma-plugin/manifest.json`.
+
+### Usage
+
+1. Start a GDD extract run so the receiver is listening on `localhost:5179`.
+2. Open the Figma file whose variables you want to export.
+3. Run **GDD Sync** (Plugins → Development → GDD Sync).
+4. Click **Export to GDD**. The plugin reads the file's local variables and POSTs them
+   to the receiver, which writes them into the extract cache.
+
+## Distribution
+
+Community submission is **deferred** (decision D-07). For v1.31.0 the supported path is
+**dev-install** via the manifest, as documented above. Publishing to the Figma Community
+is a follow-up that will not block the version cut.

package/figma-plugin/code.ts

@@ -0,0 +1,36 @@
+// GDD Sync — Figma plugin sandbox entry (main thread).
+//
+// SCAFFOLD (Plan 31-04): this is the shell only. It opens the single-button UI
+// (ui.html) and wires the message plumbing that routes the "export" action to
+// exportVariables(). The actual variables-read + POST logic lives in
+// ./src/export-variables (a compiling PLACEHOLDER in this plan; Plan 31-05
+// replaces it with the real implementation).
+//
+// Message contract (the seam 31-05 builds on):
+//   ui.html  -- parent.postMessage({ pluginMessage: { type: 'export' } }) -->  code.ts
+//   code.ts  -- figma.ui.onmessage receives { type: 'export' } --> exportVariables()
+//   exportVariables() (31-05) reads figma.variables, builds the payload, and
+//   POSTs it to http://localhost:5179/variables (the GDD receiver, Plan 31-06).
+//
+// Security: the only network destination the manifest permits is localhost:5179
+// (manifest.networkAccess.allowedDomains, D-06). code.ts itself opens no sockets.
+
+import { exportVariables } from './src/export-variables';
+
+// Messages the UI may post to the sandbox. 31-05 may extend this union.
+interface ExportMessage {
+  type: 'export';
+}
+
+type UiMessage = ExportMessage;
+
+figma.showUI(__html__, { width: 280, height: 160 });
+
+figma.ui.onmessage = (msg: UiMessage): void => {
+  if (msg && msg.type === 'export') {
+    // Delegate to the export entry point. 31-05 supplies the real logic;
+    // this scaffold ships a notify-only placeholder so code.ts compiles
+    // standalone in Wave B.1.
+    void exportVariables();
+  }
+};

package/figma-plugin/manifest.json

@@ -0,0 +1,12 @@
+{
+  "name": "GDD Sync",
+  "id": "gdd-sync-figma-variables-export",
+  "api": "1.0.0",
+  "main": "code.js",
+  "ui": "ui.html",
+  "editorType": ["figma"],
+  "networkAccess": {
+    "allowedDomains": ["http://localhost:5179", "http://127.0.0.1:5179"],
+    "reasoning": "GDD Sync POSTs locally-read Figma variables to an ephemeral GDD extract receiver bound to 127.0.0.1:5179 ONLY (Path C, decision D-06). The plugin has NO other network surface: no external host, no wildcard. This is the security boundary that prevents design-data exfiltration."
+  }
+}

package/figma-plugin/package-lock.json

@@ -0,0 +1,35 @@
+{
+  "name": "gdd-figma-sync-plugin",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "gdd-figma-sync-plugin",
+      "devDependencies": {
+        "@figma/plugin-typings": "^1.109.0",
+        "typescript": "^5.7.2"
+      }
+    },
+    "node_modules/@figma/plugin-typings": {
+      "version": "1.127.0",
+      "resolved": "https://registry.npmjs.org/@figma/plugin-typings/-/plugin-typings-1.127.0.tgz",
+      "integrity": "sha512-Y8fjfUCdWN6bUTs1wsd9GFZ3zF4USDVNmmxfUo/4Ia7NmFemSK2nBxOu7BKcusEHCERwiO7N8iOqw5jwvbL80g==",
+      "dev": true,
+      "license": "MIT License"
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    }
+  }
+}

package/figma-plugin/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "gdd-figma-sync-plugin",
+  "private": true,
+  "description": "GDD Sync — Figma plugin that reads local Figma variables and POSTs them to the GDD extract receiver on localhost:5179 (Path C for non-Enterprise token extraction).",
+  "scripts": {
+    "build": "tsc"
+  },
+  "devDependencies": {
+    "@figma/plugin-typings": "^1.109.0",
+    "typescript": "^5.7.2"
+  }
+}

package/figma-plugin/src/export-variables.ts

@@ -0,0 +1,144 @@
+// figma-plugin/src/export-variables.ts — Plan 31-05 (Wave B.2)
+//
+// Path C of the three-path token extraction (D-04). The Variables REST API is
+// Enterprise-only (the spike hit a 403); the in-Figma sandbox Variables API
+// (figma.variables.*) works on ANY plan. This module reads the local variable
+// collections + variables from inside Figma, resolves aliases, includes mode
+// metadata, emits ALL local variables (D-13 — no published filter), builds a
+// payload conforming to the receiver's payload-schema.json (31-06), and POSTs it
+// to the ephemeral localhost receiver (D-06: 127.0.0.1:5179 ONLY).
+//
+// Replaces the 31-04 placeholder. Contract preserved: `export async function
+// exportVariables(): Promise<void>` is what code.ts calls on the { type:'export' }
+// message. The PURE builder (buildPayload, re-exported from ./payload-schema) is
+// kept network-free so the offline test drives it against a figma.variables mock.
+//
+// Reading strategy: the async API (getLocalVariableCollectionsAsync /
+// getLocalVariablesAsync / getVariableByIdAsync) is used rather than the
+// deprecated sync variants — the sync methods throw under
+// `"documentAccess":"dynamic-page"` manifests, and async is the documented,
+// future-proof surface. The pure buildPayload stays synchronous so the data
+// gathering (async, Figma-bound) and the shaping (sync, testable) are separated.
+
+import {
+  buildPayload,
+  type GddSyncPayload,
+  type RawCollectionLike,
+  type RawVariableLike,
+  type VariableNameResolver,
+} from './payload-schema';
+
+// Re-export the pure builder + payload type so code.ts / tests have one import
+// site for the plugin-side contract.
+export {
+  buildPayload,
+  isGddSyncPayload,
+  type GddSyncPayload,
+} from './payload-schema';
+
+// D-06: the ONE permitted network destination. Matches the receiver's bind host
+// (127.0.0.1 — receiver.cjs RECEIVER_HOST) and manifest.networkAccess.allowedDomains.
+// Using the explicit loopback IP (not `localhost`) avoids any IPv6 `::1`
+// resolution surprise and matches the receiver's 127.0.0.1 bind exactly.
+export const RECEIVER_URL = 'http://127.0.0.1:5179/variables';
+
+/**
+ * Read local collections + variables from the Figma sandbox and shape them into
+ * a GddSyncPayload via the pure buildPayload. Async because the non-deprecated
+ * Variables API is async. Emits ALL local variables (D-13). Alias targets are
+ * resolved to names (via getVariableByIdAsync) so the digest can render the
+ * alias chain like the spike's `{alias}` form.
+ *
+ * Separated from exportVariables() so the network POST is the only impure part.
+ */
+export async function gatherPayload(): Promise<GddSyncPayload> {
+  // getLocalVariableCollectionsAsync(): VariableCollection[] — { id, name, modes:[{modeId,name}] }
+  const rawCollections = await figma.variables.getLocalVariableCollectionsAsync();
+  // getLocalVariablesAsync(): Variable[] — ALL locals (D-13; no type filter).
+  const rawVariables = await figma.variables.getLocalVariablesAsync();
+
+  const collections: RawCollectionLike[] = rawCollections.map((c) => ({
+    id: c.id,
+    name: c.name,
+    modes: c.modes.map((m) => ({ modeId: m.modeId, name: m.name })),
+  }));
+
+  const variables: RawVariableLike[] = rawVariables.map((v) => ({
+    id: v.id,
+    name: v.name,
+    resolvedType: v.resolvedType,
+    variableCollectionId: v.variableCollectionId,
+    // valuesByMode is { [modeId]: VariableValue }; pass through — buildPayload
+    // resolves alias markers + renders the flat tokens[].
+    valuesByMode: v.valuesByMode as RawVariableLike['valuesByMode'],
+  }));
+
+  // Pre-resolve every alias target name once (async), then hand buildPayload a
+  // synchronous resolver. We gather the set of alias target ids first to avoid
+  // N awaits inside the pure builder.
+  const aliasIds = new Set<string>();
+  for (const v of rawVariables) {
+    for (const modeId of Object.keys(v.valuesByMode)) {
+      const value = v.valuesByMode[modeId] as unknown;
+      if (
+        value &&
+        typeof value === 'object' &&
+        (value as { type?: string }).type === 'VARIABLE_ALIAS' &&
+        typeof (value as { id?: string }).id === 'string'
+      ) {
+        aliasIds.add((value as { id: string }).id);
+      }
+    }
+  }
+
+  const nameById = new Map<string, string>();
+  for (const id of aliasIds) {
+    try {
+      const target = await figma.variables.getVariableByIdAsync(id);
+      if (target) nameById.set(id, target.name);
+    } catch {
+      // A missing/unreadable alias target is non-fatal — buildPayload falls back
+      // to `{id}` so the reference is still recorded.
+    }
+  }
+  const resolveName: VariableNameResolver = (id) => nameById.get(id);
+
+  return buildPayload(collections, variables, {
+    fileKey: figma.fileKey,
+    exportedAt: new Date().toISOString(),
+    resolveName,
+  });
+}
+
+/**
+ * The export entry point code.ts calls on the { type:'export' } message. Builds
+ * the payload then POSTs it to the receiver. Network failures + non-2xx
+ * responses are surfaced via figma.notify and NEVER crash the sandbox.
+ */
+export async function exportVariables(): Promise<void> {
+  let payload: GddSyncPayload;
+  try {
+    payload = await gatherPayload();
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    figma.notify('GDD Sync: failed to read variables — ' + msg);
+    return;
+  }
+
+  try {
+    const res = await fetch(RECEIVER_URL, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    });
+    if (!res.ok) {
+      figma.notify('GDD Sync: receiver rejected payload (' + res.status + ')');
+    } else {
+      figma.notify('GDD Sync: exported ' + payload.variables.length + ' variables');
+    }
+  } catch {
+    // No receiver listening (the common case when no extract run is active),
+    // or any other network error. Guide the user; do not throw.
+    figma.notify('GDD Sync: no receiver on 127.0.0.1:5179 — start a GDD extract run first');
+  }
+}