@codyswann/lisa 3.45.9 → 3.46.0

package/expo/copy-overwrite/scripts/classify-maestro-failures.mjs

@@ -149,6 +149,57 @@ const PLACEHOLDER_METHODS = new Set([
   "?",
 ]);
 
+/**
+ * An `id:` line, with everything after the colon captured verbatim.
+ *
+ * Two deliberate spellings, both there to keep the match linear (S5852):
+ * `[ \t]` rather than `\s`, because this is applied to one already-split line
+ * and `\s`'s newline class only lets the indentation run overlap the next
+ * line's; and `(?:\S.*)?` rather than `.*`, because `[ \t]*(.*)` lets both
+ * halves claim the same spaces, which is a choice the engine has to make at
+ * every one of them.
+ */
+const ID_LINE = /^[ \t]*id:[ \t]*((?:\S.*)?)$/;
+
+/** A `text:` line, read the same way. */
+const TEXT_LINE = /^[ \t]*text:[ \t]*((?:\S.*)?)$/;
+
+/**
+ * A scalar value with one layer of matching quotes removed.
+ *
+ * Character comparison rather than `['"]?(...)['"]?`, because the regex form
+ * cannot express "the same quote at both ends" without a backreference, and
+ * the shape it settled for — a lazy capture between two optional quotes and a
+ * trailing `\s*$` — has three quantifiers competing for the same characters.
+ * That is super-linear in the line's length (S5852) on flow files.
+ * @param {string} value - An already-trimmed scalar.
+ * @returns {string} The value without its surrounding quote pair.
+ */
+function unquote(value) {
+  const first = value.at(0);
+  const isQuote = first === "'" || first === '"';
+  return isQuote && value.length > 1 && value.at(-1) === first
+    ? value.slice(1, -1)
+    : value;
+}
+
+/**
+ * The selector a `key: value` line declares, or null when the line is not one.
+ *
+ * An empty value reads as "no selector here" rather than as the empty
+ * selector, which is what the previous `[^'"\n]+?` (one character minimum)
+ * also did.
+ * @param {string} line - One line of flow YAML.
+ * @param {RegExp} pattern - The key's line pattern.
+ * @returns {string|null} The selector, or null.
+ */
+function scalarSelector(line, pattern) {
+  const match = pattern.exec(line);
+  if (!match) return null;
+  const value = unquote(match[1].trim());
+  return value === "" ? null : value;
+}
+
 /**
  * Pull `id:`/`text:` selectors and their ceilings out of a flow's YAML source.
  *
@@ -178,7 +229,12 @@ export function extractGates(source) {
 
   for (const line of lines) {
     if (/^\s*#/.test(line) || line.trim() === "") continue;
-    const command = line.match(/^(\s*)-?\s*(\w+):/);
+    // `(?:-\s*)?` rather than `-?\s*`: with two `\s*` runs either side of an
+    // optional dash, both can claim the same spaces and the engine has a
+    // choice at every one — super-linear in the line's length (S5852). Tying
+    // the dash to the whitespace that follows it removes the choice and
+    // recognises exactly the same lines.
+    const command = line.match(/^(\s*)(?:-\s*)?(\w+):/);
     if (command && GATE_COMMANDS.includes(command[2])) {
       if (inGate) flush();
       inGate = true;
@@ -198,18 +254,35 @@ export function extractGates(source) {
       timeout = Number(timeoutMatch[1]);
       continue;
     }
-    const idMatch = line.match(/^\s*id:\s*['"]?([^'"\n]+?)['"]?\s*$/);
-    if (idMatch) {
-      pending.push({ kind: "id", selector: idMatch[1] });
+    const idSelector = scalarSelector(line, ID_LINE);
+    if (idSelector !== null) {
+      pending.push({ kind: "id", selector: idSelector });
       continue;
     }
-    const textMatch = line.match(/^\s*text:\s*['"]?([^'"\n]+?)['"]?\s*$/);
-    if (textMatch) pending.push({ kind: "text", selector: textMatch[1] });
+    const textSelector = scalarSelector(line, TEXT_LINE);
+    if (textSelector !== null)
+      pending.push({ kind: "text", selector: textSelector });
   }
   if (inGate) flush();
   return gates;
 }
 
+/** The extension a referenced flow must carry to be followed. */
+const YAML_SUFFIX = ".yaml";
+
+/**
+ * A `runFlow: <path>` line, in the shorthand list-item form.
+ *
+ * `[ \t]` rather than `\s` throughout, and the dash tied to the whitespace
+ * that follows it. Under `m`, a `\s*` run can cross a newline into the next
+ * line's own `^`, so the scan re-attempts the same characters from many start
+ * positions — super-linear in the file's length (S5852).
+ */
+const INLINE_RUN_FLOW = /^[ \t]*(?:-[ \t]*)?runFlow:[ \t]*['"]?([^'"\s]+)/gm;
+
+/** The `file: <path>` line of the expanded `runFlow:` form. */
+const NESTED_RUN_FLOW = /^[ \t]*file:[ \t]*['"]?([^'"\s]+)/gm;
+
 /**
  * Resolve the `runFlow:` targets a flow references, as absolute paths.
  * @param {string} source - Flow YAML source
@@ -219,10 +292,18 @@ export function extractGates(source) {
 export function extractRunFlowTargets(source, flowPath) {
   const dir = path.dirname(flowPath);
   const targets = [];
-  const inline = source.matchAll(/^\s*-?\s*runFlow:\s*['"]?([^'"\s]+\.yaml)/gm);
-  for (const match of inline) targets.push(path.resolve(dir, match[1]));
-  const nested = source.matchAll(/^\s*file:\s*['"]?([^'"\s]+\.yaml)/gm);
-  for (const match of nested) targets.push(path.resolve(dir, match[1]));
+  // The `.yaml` suffix is checked in JS rather than written as `[^'"\s]+\.yaml`.
+  // A greedy class that already contains `.` has to give characters back one at
+  // a time before the literal suffix can match, at every start position a `g`
+  // scan tries — super-linear in the source's length (S5852), on flow files.
+  // The class stops at whitespace or a quote either way, so the token it
+  // captures is the same one; only the suffix test moved.
+  for (const match of source.matchAll(INLINE_RUN_FLOW))
+    if (match[1].endsWith(YAML_SUFFIX))
+      targets.push(path.resolve(dir, match[1]));
+  for (const match of source.matchAll(NESTED_RUN_FLOW))
+    if (match[1].endsWith(YAML_SUFFIX))
+      targets.push(path.resolve(dir, match[1]));
   return targets;
 }
 

package/package.json

@@ -132,7 +132,7 @@
     "ws": ">=8.21.0"
   },
   "name": "@codyswann/lisa",
-  "version": "3.45.9",
+  "version": "3.46.0",
   "description": "Claude Code governance framework that applies guardrails, guidance, and automated enforcement to projects",
   "main": "dist/index.js",
   "exports": {

package/plugins/lisa/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa",
-  "version": "3.45.9",
+  "version": "3.46.0",
   "description": "Universal governance — agents, skills, commands, hooks, and rules for all projects",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa",
-  "version": "3.45.9",
+  "version": "3.46.0",
   "description": "Universal governance: agents, skills, commands, hooks, and rules for all projects.",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa/.codex-plugin/skills/lisa-design-intake/SKILL.md

@@ -0,0 +1,169 @@
+---
+name: lisa-design-intake
+description: "Design-handoff gate for a work…"
+allowed-tools: ["Skill", "Bash", "Read", "Write"]
+---
+
+# Design Intake: $ARGUMENTS
+
+`$ARGUMENTS` is one canonical work-item reference (JIRA key, Linear ref, `org/repo#123`), optionally followed by a design reference. With no arguments, resolve the work item from the worktree binding (`node scripts/lisa-work-item.mjs current`).
+
+Run one design-handoff cycle against that work item: resolve the regime per axis, gather the facts, let `scripts/design-intake-gate.mjs` decide, and either escalate a block or hand back a proceed with the derived values recorded.
+
+This skill carries the **judgment**. It does not carry the **policy** — that is the `design-value-binding` rule, which it cites rather than restates. Read the rule; do not re-derive its conditions here.
+
+## What this is not
+
+`design-source-of-truth` and `scripts/design-source-gate.mjs` already ask whether a changed surface **declares where its design came from**. This asks the orthogonal question: are the **values on it bound**. Both apply. A surface can cite a perfectly valid design node and still paint a literal that no variable backs — that is the case this skill exists for, and it is invisible to the other gate.
+
+## Phase 0 — Is there a design source at all?
+
+**A design source is optional, and this is the most important step in the skill.** Most projects have no designs. Run the probe and read its verdict:
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT:-.}/scripts/design-bindings-probe.mjs" --json
+```
+
+A `SKIPPED` verdict means one of: `design.tokens.source` is unset, no access token is present, or no committed variable-id map exists. **Say so and stop cleanly — do not block.** A mandatory gate on an absent integration breaks every project that has no designs, which is a worse outcome than any drift it would have caught.
+
+If a design source *is* configured, then per `tool-access-gate` a failed probe **against a configured source** is a block, not a reason to fall back to reading pixels: post the Access Needed comment, move the item to the configured `blocked` role with the `human_needed` marker, and stop.
+
+## Phase 1 — Resolve configuration
+
+Read `.lisa.config.local.json` first, then `.lisa.config.json`; local overrides global per key. Use `jq` — never hand-parse JSON.
+
+```bash
+read_key() {
+  local key="$1" local_v global_v
+  local_v=$(jq -r "$key // empty" .lisa.config.local.json 2>/dev/null)
+  global_v=$(jq -r "$key // empty" .lisa.config.json 2>/dev/null)
+  printf '%s' "${local_v:-$global_v}"
+}
+tokens_source=$(read_key '.design.tokens.source')
+escalation_assignee=$(read_key '.design.escalation.assignee')
+escalation_label=$(read_key '.design.escalation.label')
+```
+
+| Key | Missing means |
+|---|---|
+| `design.tokens.source` | Stop and report: the authoritative design source is not configured, so there is nothing to resolve the regime against. |
+| `design.escalation.assignee` | **A block condition in its own right.** Do not guess a person, do not skip the escalation, do not assign to the current user. The gate raises `escalation-target-unset` and the run ends blocked. |
+| `design.escalation.label` | Nothing. The label is an additive marker; absent means no marker is added. |
+
+**Never write a person's name, handle, or identity into any artifact this skill produces.** These are config keys; the host supplies the values.
+
+## Phase 2 — Resolve the regime, per axis
+
+For each of the six axes — `color`, `spacing`, `typography`, `radius`, `elevation`, `motion` — determine whether the design source publishes variables covering it. **Never ask a human.**
+
+**Do not try to list the published collections.** That route does not exist headlessly, and the measurement is worth carrying:
+
+| Route | Gives names? | Headless? |
+|---|---|---|
+| Variables REST (`/v1/files/:key/variables/local`) | yes | **no** — Enterprise-plan only; the read scope is not offered in the token scope picker on other plans, so no token change unlocks it |
+| Design-tool MCP (`get_variable_defs`) | yes, every plan | **no** — browser OAuth, which cron, CI, and a subagent cannot perform |
+| `/v1/files/:key/nodes` | no — opaque `VariableID:106:15` | **yes**, on a plain access token |
+
+A gate built on either of the first two runs interactively and silently no-ops everywhere else. So the regime is derived from the **committed variable-id map**, which `design-variable-ids.mjs` produced once, interactively, and which `design-bindings-probe.mjs` reads headlessly. An axis is typed when the map names at least one variable in its namespace.
+
+`result.regime` from Phase 0 already carries this. Use it; do not re-derive it.
+
+A mixed regime is the expected case, not an error state. Colour blocking while spacing gets measured, in the same work item, is the design working correctly.
+
+**Probe the subtree you are implementing, not the enclosing screen.** Pass `--node` for the component you will actually build. A frame-level read counts the chrome behind a modal and over-reports — one measured work item scored 14 bound values at frame level and **zero** inside the modal subtree, and applying this rule changed 5 of 11 real work-item verdicts.
+
+### When the map cannot name what it saw
+
+The probe reports `owner: "us"` when a `VariableID` is unknown (the map is stale) or ambiguous (two variables share a value). **Neither is the designer's fault** — those values ARE bound. Do not escalate them to design. Regenerate the map:
+
+```bash
+FIGMA_ACCESS_TOKEN=… FIGMA_MCP_TOKEN=… \
+  node "${CLAUDE_PLUGIN_ROOT:-.}/scripts/design-variable-ids.mjs" \
+  --file <key> --light <nodes> --dark <nodes>
+```
+
+Pass `--dark` wherever the library has a dark mode: the light+dark signature is what separates variables that share a value, and without it more ids stay ambiguous. An ambiguous id is still a failure — guessing which variable a value came from is exactly what this contract forbids.
+
+## Phase 3 — Gather findings
+
+The probe already produced `hardcoded-in-design` and `bound` findings for every value in the subtree, with the two silent-under-reporting traps handled: the corner-keyed `rectangleCornerRadii` shape is normalised, and boundness is read from `boundVariables` directly rather than inferred from a resolved value (Figma omits zero-valued properties, so a padding bound to a zero-valued variable would otherwise vanish).
+
+Add the findings the probe cannot see from a node payload — a named variable that does not exist, an unpublished component, a missing state, a source disagreement — plus the two non-blocking observations. **Findings are observations, not verdicts** — do not pre-judge them; the gate decides.
+
+| `kind` | Emit when | Required fields |
+|---|---|---|
+| `bound` | A variable exists and the design binds it. The happy path. | `axis`, `component` |
+| `hardcoded-in-design` | The frame paints a literal instead of binding a variable. | `axis`, `component`, `value` |
+| `measured` | You read the value off the rendering rather than from a variable. | `axis`, `component`, `value` |
+| `missing-token` | The item or frame names a variable the library does not publish. | `axis`, `component`, `name` |
+| `unpublished-component` | The component lives in a draft or local file. | `component` |
+| `missing-state` | A required state (disabled / error / loading / empty) has no design. | `component`, `state` |
+| `source-disagreement` | The bound variable resolves to one value and the frame renders another. | `axis`, `component`, `tokenValue`, `frameValue` |
+| `one-off` | A value that was never going to be shared — an illustration's exact offset. | `axis`, `component`, `value` |
+| `aesthetic-concern` | You find the design ambiguous, unusual, or ugly, and every value you need is bound. | `component`, `note` |
+
+Two of these rows carry most of the weight.
+
+**`hardcoded-in-design` is the condition most often missed**, because nothing about the artifact looks wrong. The design is finished, the component renders, review sees a screenshot that matches — and the only symptom is that there is nothing to extract. Treating "I can see the value" as "I have the value" is precisely the failure this gate exists to catch.
+
+**`aesthetic-concern` is a finding, not a block, and it must still be emitted.** Recording the observation without stopping on it is what keeps the gate from firing on opinion. If you find yourself reaching for a block because the design seems off rather than because a value is missing, that is an `aesthetic-concern` and the work proceeds.
+
+Emit no finding kind outside this table. The gate throws on an unrecognised kind rather than inventing a verdict for facts it did not understand.
+
+## Phase 4 — Let the gate decide
+
+Merge the probe's findings with your own, write them to a JSON payload, and run the gate. Do not reimplement the decision in prose — a verdict reasoned out fresh each time is a verdict that decides differently on Tuesday.
+
+```bash
+node "${CLAUDE_PLUGIN_ROOT:-.}/scripts/design-intake-gate.mjs" --findings=design-facts.json --json
+```
+
+Payload shape:
+
+```json
+{
+  "config": { "design": { "escalation": { "assignee": "…", "label": "…" } } },
+  "regime": { "color": "typed", "spacing": "untyped" },
+  "findings": [ { "kind": "hardcoded-in-design", "axis": "color", "component": "Raised card", "value": "#3A7BD5" } ]
+}
+```
+
+Omit `config` to have the gate read the merged project config itself. Exit 0 = PROCEED, 1 = BLOCK, 2 = usage. **The gate fails closed**: an unreadable payload is a BLOCK with a named reason, never a quiet pass, because a gate that returns PROCEED on what it could not look at proves nothing.
+
+## Phase 5a — BLOCK
+
+1. **Post the comment.** Use `result.comment` **verbatim**. It is written for the non-technical operator standing at the gate: plain language, naming the specific missing artifact and what to do about it, with no factory vocabulary. Do not "improve" it into engineering terms — the vocabulary ban is enforced by the gate's own tests, and rewriting the comment is how it gets lost.
+
+   > The 'Raised card' component uses the colour #3A7BD5 directly rather than a colour variable. I need that colour published as a variable so the app and the design stay in sync — otherwise I'd be copying a number that changes without warning.
+
+2. **Transition to the configured `blocked` role** through `lisa-tracker-sync` / `lisa-tracker-write`. Never call a vendor label API directly — per `config-resolution`, Linear resolves `blocked` to a native workflow **state**, GitHub to a **label**, JIRA to a **status**, and hardcoding any one of them breaks the other two.
+
+3. **Assign to `result.assignee`.** If it is `null`, the `escalation-target-unset` condition is already in `result.blocks` and the comment says so — post it and leave the item unassigned. Do not substitute a person.
+
+4. **Add `result.label` as an additive marker** alongside the `blocked` role when one is configured, never instead of it. Add `human_needed` as well: a missing variable, an unpublished component, and a source disagreement all need a person to make a design decision, and none of them clear on a retry.
+
+5. **Stop.** Do not partially build the surfaces that were fine. Design decisions arrive together, and half a screen built against half a design is rework.
+
+**Route by owner.** Only `owner: "design"` reaches a designer. A stale or ambiguous id is `owner: "us"` — regenerate the map (Phase 2) and re-run. Sending that to a designer is the wrong person and the wrong work, and it teaches them to ignore the next one.
+
+## Phase 5b — PROCEED
+
+1. **Record the derived values** from `result.derived` on the work item — axis, component, and value for everything measured in an untyped axis. This costs nothing now and accumulates into an inventory of what the variable system is missing, **ranked by what people actually needed**, which no design-system audit produces on its own.
+2. Build. In a **typed** axis, bind the variable and use a screenshot only to *verify*; a disagreement you find at that point is `source-disagreement` and sends the item back through this skill. In an **untyped** axis, measure — that is the correct source there.
+
+The rule is never "do not look at pixels". It is **"do not derive a value from pixels when a binding exists."**
+
+## Contract
+
+- **Block on unbound, never on unsure.** Every block traces to one of the eight conditions in `BLOCK_CONDITIONS`. If you cannot name the condition, it is not a block.
+- **The regime is per-axis**, derived from the committed variable-id map. Never per-project, never asked of a human, and never from a live collection query — that route does not run headlessly.
+- **A design source is optional.** No source, no token, or no map is SKIPPED at exit 0, never a block.
+- **Every failure names an owner.** Unbound values are design's; a stale or ambiguous map is ours.
+- **The threshold is 100%.** Relax it only with an explicit `--min` on the command line, never by softening anything in code.
+- **Never guess an escalation target**, and never proceed without one.
+- **Never pick a side in a disagreement.** Which source is right is a design decision.
+- **Never name a person** in a comment, a commit, or any artifact. Config keys only.
+- **Never work around missing design information.** Substituting a nearby value, inventing a state, or narrowing scope to dodge the gap are all forbidden — same standard as `tool-access-gate`.
+- Host design-system rules (`figma-design-system`, `design-system`, `use-the-design-library`, or the project's equivalent) stay authoritative about *what* to build. This skill never overrides them.
+
+Full policy: the `design-value-binding` rule.

package/plugins/lisa/.codex-plugin/skills/lisa-design-intake/agents/openai.yaml

@@ -0,0 +1,4 @@
+display_name: "Design Intake"
+short_description: "Design-handoff gate for a work…"
+default_prompt:
+  - "Use $lisa-design-intake: Design-handoff gate for a work…."

package/plugins/lisa/.codex-plugin/skills/lisa-implement/SKILL.md

@@ -157,6 +157,8 @@ For any Fix flow, and for any Build flow that changes user-visible behavior, reg
 
 For work that adds or changes a **UI surface**, the `design-source-of-truth` rule adds a second non-demotable deliverable landing in this same PR: every UI surface the change touches declares where its design came from. Figma is the source of truth, so **prefer sync-back** — if the surface is not in Figma yet and the tool-access preflight proved Figma access, reflect it there and cite the node with `DESIGN-SOURCE: <figma-url>`. Only when the surface genuinely does not belong in the design source (debug affordance, dev-only playground, internal tooling) does it carry the exception marker `DESIGN-SOURCE: none — not in Figma`, ideally with a trailing reason. `scripts/design-source-gate.mjs` decides this deterministically and fails closed on anything it cannot resolve; a FAIL blocks the item exactly as a failing coverage gate does. Host design-system rules (`figma-design-system`, `design-system`, `use-the-design-library`, or the project's equivalent) stay authoritative about *what* to build — this obligation is only about declaring the source. Cite the rule; do not restate its marker grammar, host-precedence, or bootstrap mechanics here.
 
+The `design-value-binding` rule adds a second, orthogonal obligation on the same surfaces: **values come from design variables where a variable system exists.** That contract asks whether the values are *bound*, not whether the source is *declared* — a surface can cite a valid design node and still paint a literal no variable backs. Resolve the regime per axis, block only on the five objectively checkable conditions, and record every value derived in an untyped axis on the work item. `/lisa:design:intake` runs it. Cite the rule; do not restate its conditions, config schema, or comment grammar here.
+
 For work that adds or changes **persistent state**, the `reset-seed-coverage` rule adds a third non-demotable deliverable landing in this same PR: every entity the item introduces or changes is classified in the project's state contract (`fixture-owned` / `preserve` / `derived-rebuild` / `forbidden`) with a reason and an owner, anything `fixture-owned` declares its ownership predicate and is actually swept, and the state-classification check passes. Writing a flow that creates a record and deletes it only on its happy path does NOT satisfy this — that is the leak, not the coverage. Cite the rule; do not restate its policy, waiver, or bootstrap mechanics here.
 
 The team lead may not waive, defer, demote, or phrase this regression spec as "optional", "if cheap", "nice to have", or equivalent. The only permitted exits are:

package/plugins/lisa/.codex-plugin/skills/lisa-quality-review/SKILL.md

@@ -24,6 +24,8 @@ For each changed file, evaluate:
 
    Exit 1 is a **Critical** finding under the `design-source-of-truth` rule -- the change is blocked until every UI surface either cites a Figma node (`DESIGN-SOURCE: <figma-url>`, the preferred fix -- sync it back) or carries the exception marker `DESIGN-SOURCE: none — not in Figma`. The gate fails closed: an unreadable file or an uncomputable diff is a FAIL, not a pass. Host design-system rules (`figma-design-system`, `design-system`, `use-the-design-library`, or the project's equivalent) stay authoritative about what to build; this checks only that the source is declared. If the gate script is absent, say so in the review rather than skipping silently.
 
+   Review the same surfaces against the `design-value-binding` rule as well — it asks the orthogonal question of whether each value is *bound* to what the design system publishes, not whether the source is declared. A literal in an axis the project publishes variables for is a **Critical** finding; the identical literal in an axis with no variable collection is correct and must not be flagged. Aesthetic disagreement is never a finding under this rule. Cite the rule; do not restate its conditions here.
+
 ## Output Format
 
 Rank findings by severity:

package/plugins/lisa/.codex-plugin/skills/lisa-review-local/SKILL.md

@@ -41,6 +41,15 @@ asks whether the source is declared. If the gate script is not present (the
 project predates the plugin version that ships it), say so explicitly in the
 review — a silent skip is not one of the exits.
 
+**Design-value binding (`design-value-binding` rule).** A separate, orthogonal
+question about the same surfaces: not *is the source declared* but *are the
+values bound*. In an axis the project publishes design variables for, a literal
+is a **blocking** finding — it is a copied number that will drift when the
+system moves. In an axis with no variable collection, the identical literal is
+correct and must not be flagged; measuring is the legitimate source there, and
+the derived values belong on the work item. Aesthetic disagreement is never a
+finding under this rule. Cite the rule; do not restate its conditions here.
+
 To do this, follow these steps precisely:
 
 1. Use a Haiku agent to check the current git state:

package/plugins/lisa/.codex-plugin/skills/lisa-tdd-implementation/SKILL.md

@@ -72,6 +72,7 @@ TDD Cycle:
 - Write the minimum production code to make the test pass
 - Do not optimize, do not add features beyond what the test requires
 - For any UI surface the implementation adds or changes, the `design-source-of-truth` rule requires its design-source declaration to land in the same commit as the surface it describes — `DESIGN-SOURCE: <figma-url>` when the surface is backed by a Figma node (sync it back first if Figma access exists), or the exception marker `DESIGN-SOURCE: none — not in Figma` when it genuinely is not captured at the source. `scripts/design-source-gate.mjs` fails closed on an undeclared surface. Cite the rule; do not restate its marker grammar here.
+- Separately, the `design-value-binding` rule governs where each *value* on that surface came from: in an axis with a published variable collection, bind the variable and use a screenshot only to verify; in an axis with none, measure and record what you derived. A literal in a typed axis is a block, not a TODO. Cite the rule; do not restate its conditions here.
 - The goal is the simplest code that makes the test green
 
 ### REFACTOR Phase

package/plugins/lisa/commands/design/intake.md

@@ -0,0 +1,7 @@
+---
+description: "Design-handoff gate for a work item with a UI surface. Resolves the source of truth per axis (colour, spacing, typography, radius, elevation, motion) by querying the configured design source's published variable collections — never by asking a human — then judges the item against the five objectively checkable block conditions. Values come from design variables where a variable system exists; measurement is the legitimate source where none does. Blocks on unbound, never on unsure. Escalates through the configured tracker to `design.escalation.assignee` with a plain-language comment — an unset assignee is itself a block, never a silent skip — and records every measured value so the gaps in the variable system accumulate on their own."
+argument-hint: "[work-item-ref] [design-ref]"
+allowed-tools: ["Skill"]
+---
+
+Use the /lisa-design-intake skill to run one design-handoff cycle: prove access to the design source, resolve the regime per axis, gather findings, let `scripts/design-intake-gate.mjs` decide, then either escalate the block to the configured assignee with the verbatim plain-language comment or proceed with the derived values recorded on the work item. $ARGUMENTS

package/plugins/lisa/rules/eager/design-value-binding.md

@@ -0,0 +1,80 @@
+# Design Value Binding (load-bearing)
+
+**Values come from design variables where a variable system exists.** Visual measurement is supplemental there, and it is the legitimate primary source where no variable system exists. Missing design information blocks the work item; it is never worked around.
+
+**One vendor-neutral contract, cited by** `lisa-design-intake`, `lisa-implement`, `lisa-tdd-implementation`, `lisa-review-local`, and `lisa-quality-review` (the `leaf-only-lifecycle` / `repo-scope-split` precedent: one shared slug, never divergent per-skill prose).
+
+This is **not** `design-source-of-truth`. That contract asks whether a changed surface *declares where its design came from*. This one asks whether the *values on it are bound*. A surface can cite a perfectly valid design node and still paint a literal that no variable backs — the design looks finished and has nothing to extract. Both apply; neither substitutes for the other.
+
+## Regime is per-dimension, not per-project
+
+Resolve the source of truth **per-axis** — colour, spacing, typography, radius, elevation, motion — from what the design source **actually publishes**. **Never by asking a human**, and never once per project.
+
+The axis vocabulary is fixed, and the identifiers are what the config and the lint rule use: `color`, `spacing`, `typography`, `radius`, `elevation`, `motion`. Projects declare which of them are typed; they never invent a seventh.
+
+| axis has a published variable collection | source of truth | an unbound value means |
+|---|---|---|
+| yes (**typed**) | the variable | **block** |
+| no (**untyped**) | visual measurement | measure it, and record what you derived |
+
+A library with a mature colour system and no spacing scale is the common case and must work: colour blocks while spacing gets measured, in the same work item, without contradiction.
+
+**Asking the design tool "which collections are published?" does not work headlessly, and that is measured.** The Variables REST endpoint returns names but is Enterprise-plan only; the design-tool MCP returns names on every plan but authenticates by browser OAuth, which cron, CI, and a subagent cannot perform. A gate built on either runs interactively and silently no-ops everywhere else. So the regime is derived from a **committed variable-id map**: `/v1/files/:key/nodes` reports every binding as an opaque `VariableID`, that id→name mapping is static, and `design-variable-ids.mjs` resolves it once interactively so `design-bindings-probe.mjs` runs headlessly on a plain access token forever after. An axis is typed when the committed map names at least one variable in its namespace.
+
+**Staleness is self-detecting, and that is what makes a committed map safe to trust.** An id the map has never seen fails loudly telling you to regenerate; it never silently resolves to the wrong variable.
+
+**Measure the subtree you are implementing, not the enclosing screen.** A frame-level read counts the chrome behind a modal and over-reports — one measured work item scored 14 bound values at frame level and zero inside the modal subtree it actually had to build.
+
+## Block on *unbound*, never on *unsure*
+
+This distinction is the whole contract. "I cannot tell what they meant" is a judgment call, and an agent asked to make it blocks on everything or nothing. "The design does not bind a value I need" is objective and decides the same way twice.
+
+**Block conditions — five, all objectively checkable:**
+
+1. **A named token does not exist.** The work item or frame references a variable the library does not have.
+2. **A value is hardcoded in the design file itself, in a typed axis.** The most important and easiest to miss: the frame paints a literal instead of binding a variable, so the design looks finished and there is nothing to extract.
+3. **The component is not published.** Local to a draft file, so there is no stable reference.
+4. **A required state has no design.** The work item specifies disabled/error/loading and the component set has no such variant.
+5. **Two sources disagree.** The bound token says one value, the frame renders another. Never guess which is right.
+
+**Explicit non-block list — equally load-bearing, or the gate fires constantly:**
+
+- Anything in an **untyped** axis. Measure it.
+- One-off values that are not semantic (an illustration's exact offset).
+- Anything where a token exists and is bound — the happy path.
+- **Aesthetic uncertainty.** If every value needed is bound and the agent merely finds the design ambiguous or ugly, that is an opinion, not a block.
+
+## What visual matching is for, precisely
+
+In a **typed** axis it is *verification*: build from the variable, screenshot, confirm agreement — and a disagreement is condition 5, not a licence to trust the pixels. In an **untyped** axis it is *derivation*, and legitimate. The rule is never "do not look at pixels"; it is **"do not derive a value from pixels when a binding exists."**
+
+## Derived values are recorded, not just used
+
+When measuring in an untyped axis, record the derived values on the work item. Over time that accumulates a free inventory of what the token system is missing, ranked by what people actually needed.
+
+## Escalation is configured, never hardcoded
+
+The escalation target, label, and authoritative design source are host configuration — `design.escalation.assignee`, `design.escalation.label`, `design.tokens.source`. **An unset `assignee` is itself a block condition**: a blocked item assigned to nobody is an item nobody sees. Escalation routes through the vendor-neutral tracker abstraction per `config-resolution` — Linear lifecycle is native state, GitHub uses labels, JIRA uses status — never a hardcoded label call.
+
+The blocked comment is written for the non-technical operator standing at the gate: plain language, no engineering vocabulary, naming the specific missing artifact and what to do about it.
+
+## A design source is OPTIONAL; a configured one fails closed
+
+**Most projects have no designs, and this contract must not break them.** No configured design source, no access token, or no committed id map is **SKIPPED** — loudly, exit 0. A mandatory gate on an absent integration breaks every non-design project on upgrade, which is a worse outcome than any drift it would have caught.
+
+Where a design source *is* configured, the gate fails closed: `scripts/design-bindings-probe.mjs` gathers the facts, `scripts/design-intake-gate.mjs` decides deterministically, and `/lisa:design:intake` carries the judgment between them. Facts it could not gather are a block with a named reason, never a quiet pass. The threshold is **100% by default** — the rule as written — with a `--min` flag so any relaxation is an explicit reviewable decision on the command line rather than a quiet softening in code.
+
+The lint rung (`ui-standards/no-unbound-design-value`) catches the same defect at authoring time, and is silent on any axis the project has not declared typed.
+
+## Every failure names an OWNER
+
+Conflating these sends the wrong person the wrong work.
+
+| Owner | Failure | What happens |
+|---|---|---|
+| **design** | Values are unbound. | Block the work item with the exact bind-list. |
+| **us** | The committed id map is stale or ambiguous. | The values ARE bound; regenerate the map. Not the designer's problem. |
+
+An ambiguous id is still a failure even though nothing is wrong in the design: two variables share a value, our map cannot say which one is meant, and guessing is exactly what this contract forbids.
+
+Full contract (axis vocabulary, the five conditions in detail, config schema, comment grammar, escalation routing): [reference/design-value-binding.md](../reference/design-value-binding.md).