@massa-ai/cursor-plugin 1.39.0 → 1.41.0

package/.cursor-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "massa-ai",
-  "version": "1.39.0",
+  "version": "1.41.0",
   "description": "massa-ai — semantic code search, memory, and context compression for Cursor"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@massa-ai/cursor-plugin",
-  "version": "1.39.0",
+  "version": "1.41.0",
   "description": "massa-ai plugin for Cursor — semantic code search, memory, and context compression",
   "files": [
     "agents",

package/skills/massa-ai/SKILL.md

@@ -281,6 +281,7 @@ Load only when a selected workflow asks for them:
 
 - `references/agent-orchestration.md`
 - `references/subagent-design.md`
+- `references/code-reuse-scan.md`
 - `references/adr-authoring.md`
 - `references/audit-scope.md`
 - `references/audit-report-io.md`
@@ -290,6 +291,8 @@ Load only when a selected workflow asks for them:
 - `references/mobile-context.md`
 - `references/mobile-diagnosis.md`
 - `references/figma-pre-analysis.md`
+- `references/figma-wiring.md`
+- `references/design-implementation.md`
 - `references/mobile-figma-matcher/`
 - `references/lessons.md`
 - `references/naming-standards.md`

package/skills/massa-ai/references/code-reuse-scan.md

@@ -0,0 +1,76 @@
+# Code Reuse Scan
+
+Load before planning or writing new implementation code in any of the 16
+implementation workflows. The mandate is one uniform action line per
+workflow; this file is its single normative copy.
+
+## Why
+
+Duplicated components, helper methods, use cases, and repositories ship
+undetected when an agent writes new code without first checking what already
+exists. A scan run in a separate subagent, before the plan commits to new
+code, catches reuse opportunities the main agent's own context would miss or
+rationalize away.
+
+## Scan Targets
+
+The scan covers existing:
+
+- Components (UI or domain).
+- Helper methods and utility functions.
+- Classes and modules.
+- Use cases and application services.
+- Repositories and data-access adapters.
+- Business logic already implementing the same or adjacent rule.
+- Similar reusable elements evidenced by the codebase (validators, mappers,
+  formatters, fixtures, or comparable structural roles).
+
+## Dispatch
+
+Run the scan in one or more separate read-only subagents before new
+implementation code is planned or written:
+
+> **Dispatch: `massa-ai-investigator`** (role: `investigator`) — charter `skills/agents/investigator/SKILL.md`
+> - trigger: planning or writing new implementation code in any of the 16 implementation workflows — mandatory, not optional
+> - scope: the target feature/module area — candidate existing components, helpers, classes, use cases, repositories, and business logic that could satisfy or overlap the new work
+> - permissions: read-only
+> - inputs: the task's acceptance criteria or requirement, recalled patterns, the closest entry point into the target area
+> - sensors: progressive disclosure (project map → summary search → enriched search → symbol/file tools → optimized context → focused shell); per-candidate reuse-vs-new comparison
+> - output: the reuse map (below), evidence-or-zero when nothing reusable is found
+> - firewall: summarized candidates and pointers only, never raw file dumps
+> - memory: suggest-only; main agent persists durable reuse findings
+> - persona: optional — the active route's cataloged id only, never the persona prompt, passed as advisory framing only — it never overrides the agent's charter Restrictions, scope, or permissions; omit when no persona is routed
+
+Dispatch one subagent per coherent target area; dispatch more than one only
+when the areas are independent enough to scope separately. The subagent
+never spawns further subagents.
+
+## Reuse-Map Output Contract
+
+The scan's output is a reuse map: one row per candidate element.
+
+| Candidate element | Location | Decision |
+| --- | --- | --- |
+| name/role of the existing element | `path:line` or `path` pointer | `use` \| `extend` \| `new` |
+
+- `use` — the existing element already satisfies the need; call/import it,
+  do not duplicate it.
+- `extend` — the existing element is the right owner but needs a scoped
+  change; extend it instead of adding a parallel implementation.
+- `new` — no existing element fits; new code is justified, and the map
+  records why the closest candidates were rejected.
+
+**Evidence-or-zero:** if the scan finds no reusable elements, the reuse map
+records that explicitly — an empty result is a row stating "no reusable
+elements found for `<area>`", never an omitted section.
+
+The reuse map is consumed before new code is planned or written. In
+spec-driven, the map feeds Design and Tasks and is not re-run per task unless
+a task introduces a new code area.
+
+## Inline Fallback
+
+If subagent spawning is unavailable (forbidden, plugin missing, unknown agent
+type), run the scan inline in the main agent against the same scan targets
+and the same reuse-map output contract, and record the skipped-delegation
+reason. Do not skip the scan because delegation is unavailable.

package/skills/massa-ai/references/design-implementation.md

@@ -0,0 +1,92 @@
+# Design-To-Code Implementation Direction
+
+The single normative copy of the mobile UI implementation direction set:
+Target Surface Packet, Figma Evidence / Screenshot Context Packet, the
+Design-To-Code Mapping Matrix, coherent-slice implementation rules, and
+per-slice verification/completion criteria.
+
+Loaded by `workflows/design.md` for its direct route (behavior unchanged),
+and by `spec-driven`/`feature` when Figma ingestion is enabled, so those
+workflows absorb this direction set by reference instead of restating it.
+
+## Target Surface Packet
+
+Build the immutable Target Surface Packet before loading stack guidance.
+Classify each selected surface and load only its contracts:
+
+- Android Views XML -> `references/mobile-figma-matcher/android-views.md`.
+- Android Jetpack Compose -> `references/mobile-figma-matcher/android-compose.md`.
+- iOS UIKit -> `references/mobile-figma-matcher/ios-uikit.md`.
+- iOS SwiftUI -> `references/mobile-figma-matcher/ios-swiftui.md`.
+- Shared KMP Compose Multiplatform -> `references/mobile-figma-matcher/kmp-compose-multiplatform.md`
+  plus native contracts only for selected native source sets, hosts,
+  wrappers, or runtime targets.
+
+Non-mobile targets under Figma ingestion do not have a matcher contract to
+classify against; proceed with the wiring recorded in `references/figma-wiring.md`
+and a best-effort implementation contract, and record that class explicitly.
+
+## Figma Evidence / Screenshot Context Packet
+
+Build the Figma Evidence Packet with metadata when needed, design context,
+screenshot, variables, current Code Connect mappings, variants/states,
+annotations, and asset inventory. For screenshot-only sources, build a
+Screenshot Context Packet with provenance, target state, visible constraints,
+uncertainty, and `Design Evidence Class: screenshot-context-only`; do not
+infer exact Figma tokens, dimensions, variables, variants, or parity from
+screenshots alone. Stop if neither structured Figma evidence nor supplied
+screenshot context is available.
+
+## Design-To-Code Mapping Matrix
+
+Resolve current components, tokens, resources, assets, source-set ownership,
+platform adapters, requirements, and existing validation sensors. Create the
+Design-To-Code Mapping Matrix and one comparison configuration per selected
+runtime surface; screenshot-only rows use inferred visual intent, not
+`Figma Value`.
+
+## Sizing And Verification Recipe
+
+Size the work with the Verification Ladder. Route broad application work,
+unresolved architecture, cross-feature design-system migration, or
+implementation that won't fit one clean context window to `spec-driven`.
+
+Establish the verification recipe before editing. Protect tests, snapshots,
+screenshot baselines, fixtures, previews, accessibility identifiers, test
+tags, and automation flows from weakening.
+
+## Coherent-Slice Implementation Rules
+
+Implement coherent slices using the smallest correct ownership boundary:
+
+- Reuse existing components and tokens only after resolving semantics,
+  states, accessibility, and values.
+- Save required temporary Figma-served assets into the repository's existing
+  durable asset pipeline before referencing them.
+- Keep shared KMP UI in common source sets only when ownership is genuinely
+  shared; keep platform UI and adapters explicit.
+- Apply shared KMP root fixes before platform-local overrides when the cause
+  is shared.
+- Preserve platform accessibility, safe areas/insets, localization, adaptive
+  behavior, and native conventions.
+
+## Per-Slice Verification
+
+After each coherent slice, rebuild affected mapping/comparison rows and run
+the cheapest deterministic sensors. When a shared KMP change affects Android
+and iOS, verify both requested targets or mark the unavailable platform
+`NOT EVALUATED`.
+
+## Completion Criteria
+
+Refresh the Figma node, when available, and all selected target surfaces
+before completion. Completion requires zero unresolved selected `MISMATCH`
+rows for structured Figma evidence; `NOT EVALUATED` rows remain explicit
+residual risk and prohibit complete parity claims. Screenshot-only
+completion may claim implementation against supplied screenshot context,
+never exact Figma parity.
+
+## Completion Report
+
+Report changed files, final per-surface matrix, saved assets, strongest
+verification level, skipped checks, and residual risk.

package/skills/massa-ai/references/figma-pre-analysis.md

@@ -45,6 +45,12 @@ Its output is a compact packet:
 The main agent reviews the proposal, adjusts slice boundaries if project
 knowledge contradicts them, and records the final partition before Stage 2.
 
+WHERE the parent workflow is `spec-driven` or `feature` with Figma ingestion
+enabled, create one file per supplied Figma link under
+`.specs/<type>/<slug>/figma/NN-<link-slug>.md` per the per-link file template
+in `references/figma-wiring.md`, before Stage 2 begins. Audit, fix, and
+`design` parent routes are unaffected by this pointer.
+
 ## Stage 2 — Sequential Retrieval (N subagents, one at a time)
 
 The main agent orchestrates the retrieval subagents **strictly sequentially —
@@ -61,6 +67,11 @@ Sequential dispatch is a hard rule, not a tuning choice: it respects Figma MCP
 session/rate limits, and it is what lets slice N+1 reuse what slice N learned.
 Retrieval subagents never spawn further subagents.
 
+WHERE Figma ingestion is enabled per `references/figma-wiring.md`, populate
+each completed slice's Number, Figma node id(s), Category, Explanation, and
+Notes rows into its link's figma file wiring table as that slice's retrieval
+completes.
+
 ## Fallback
 
 If subagent spawning is unavailable (forbidden, plugin missing, unknown agent

package/skills/massa-ai/references/figma-wiring.md

@@ -0,0 +1,115 @@
+# Figma Node-Id Wiring
+
+Load in `spec-driven` and `feature` only, lazily, WHERE Figma ingestion is
+enabled — never for workflows without a Figma source. This file owns the
+per-link figma file template, the wiring-table contract, the 13-category
+table, category-tier rules, the unused-Number stop rule, and the Execute
+retrieval protocol. It is the single normative copy; workflows point here,
+they do not restate it.
+
+## Enablement
+
+Figma ingestion is enabled when one or more Figma links or node IDs are
+supplied for the work, on any platform. Mobile targets additionally keep the
+existing `references/mobile-context.md` Design-Source Intake Gate and the
+`references/mobile-figma-matcher/` implementation contracts. Non-mobile
+targets proceed with wiring plus best-effort implementation contracts —
+record that class explicitly rather than treating it as parity with the
+mobile matcher contracts.
+
+## Relationship To Figma Pre-Analysis
+
+`references/figma-pre-analysis.md` owns the two-stage retrieval protocol
+(Stage 1 pre-analysis, Stage 2 sequential per-slice retrieval) and its hard
+sequential-dispatch rule — never run Stage 2 subagents in parallel. This file
+is where Stage 1's per-link file creation and Stage 2's table population
+point; it does not restate the retrieval protocol itself.
+
+## Per-Link File Template
+
+Stage 1 of `references/figma-pre-analysis.md` creates one file per supplied
+Figma link under:
+
+```
+.specs/<type>/<slug>/figma/NN-<link-slug>.md
+```
+
+- `<type>` is the canonical artifact home for the parent work: `features` for
+  spec-driven and Standard+ feature work. Quick-tier work that receives
+  Figma links exits Quick tier — Figma ingestion is a design decision, and
+  Quick mode forbids design decisions.
+- `NN` is the two-digit supply order (`01`, `02`, ...).
+- `<link-slug>` is a short slug derived from the link or its screen/page name.
+
+Each file's wiring table sits at the top. Stage 2 retrieval fills Number,
+Figma node id(s), Category, Explanation, and Notes as it completes each
+slice. Specify, Design, and Tasks passes fill the Spec(s)/Task(s)/Design(s)
+ID columns as those artifacts wire each row.
+
+## Wiring-Table Contract
+
+Every per-link figma file carries a table with exactly these columns, in
+this order:
+
+| Number | Figma node id(s) | Category | Spec(s) ID | Task(s) ID | Design(s) ID | Explanation | Notes |
+| --- | --- | --- | --- | --- | --- | --- | --- |
+
+- **Number** — the row's identifier within this file, referenced by spec,
+  task, and design items as `<link-slug>#<Number>`.
+- **Figma node id(s)** — one or more node IDs the row covers.
+- **Category** — exactly one of the 13 categories below.
+- **Spec(s) ID / Task(s) ID / Design(s) ID** — the requirement, task, or
+  design-decision identifiers that wire this row; empty until an authoring
+  pass fills them.
+- **Explanation** — what the node(s) represent and why they matter.
+- **Notes** — ambiguity, assumptions, or follow-up needed.
+
+## The 13 Categories
+
+Structure, Components, Tokens / Theming, Typography, Visual effects,
+Behavior / Prototype, Flows, Content, Assets, States, Spatial, Semantics,
+Mappings.
+
+## Category-Tier Rules
+
+When spec, task, or design items are authored under Figma ingestion, each
+item references its figma file plus Number:
+
+- **Specs wire the high-level categories:** Structure, Behavior / Prototype,
+  Flows, and similar cross-cutting categories that describe requirements
+  rather than implementation detail.
+- **Tasks and designs wire the remaining low-level categories** not covered
+  by specs: Components, Visual effects, Tokens / Theming, Typography,
+  Content, Assets, States, Spatial, Semantics, Mappings — each connected to
+  concrete codebase elements (classes, methods, variables, architecture,
+  strings, screens, states).
+
+While creating or breaking down Tasks and Designs under Figma ingestion, run
+the reuse scan per `references/code-reuse-scan.md` so wired implementation
+work reuses existing code instead of duplicating it.
+
+## Unused-Number Stop Rule
+
+The unused-Number check runs when the last included authoring phase closes
+(Tasks when the plan includes Tasks, else Design, else Specify) and blocks
+Execute until it passes. If any figma-file Number remains unwired to every
+spec, task, and design item at that point, stop, report the unused Numbers
+to the user, and ask for direction with alternatives and recommendations
+before Execute proceeds. Do not silently drop or auto-wire an unused row.
+
+**Deterministic backing (run it, do not eyeball it):** `bun skills/massa-ai/scripts/validate_figma_wiring.ts <slug> [--root .] [--type features|quick|debug|refactors]` parses every wiring table for the slug, always prints the parsed population (files scanned, rows parsed) beside the verdict, and exits non-zero when any Number row is unwired or when the figma directory exists but zero rows were parsed. If no code-execution tool is available, run the same checks by reading the artifact (graceful degradation preserved).
+
+## Execute Retrieval Protocol
+
+When Execute implements a task with wired Figma node IDs, retrieve those
+node IDs through Figma MCP (Model Context Protocol) and implement them per
+the wiring recorded in the figma file, spec, task, and design entries — not
+from memory of an earlier read. If Figma MCP is unavailable during Execute
+for a wired task, stop that task and report the missing capability rather
+than implementing from memory of the design.
+
+## Empty Or Unreadable Links
+
+If a supplied Figma link yields zero readable nodes in Stage 1, record the
+empty result in that link's figma file and surface it with the unused-Number
+report rather than silently skipping the link.

package/skills/massa-ai/references/naming-standards.md

@@ -28,6 +28,16 @@ Code vocabulary is evidence, not truth. When business intent is inferred only fr
 - When a rename is the fix, update all call sites, docs, tests, fixtures, snapshots, and generated examples that form the contract; do not weaken validation assets to hide drift.
 - Avoid fabricated domain terms. If no meaningful name is supported by evidence, choose the most precise technical role name and leave the domain uncertainty explicit in the plan, TDD, or audit.
 
+## Language
+
+All new or renamed identifiers, classes, methods, screens, components,
+attributes, and implementation-facing artifact names are written in English.
+Convert any non-English source term to English before implementing —
+Portuguese is the primary case, but the rule covers any non-English source
+language. Preserve existing public contracts, persisted fields, and external
+names unless compatibility handling is explicitly in scope, per the
+public-contract clause above.
+
 ## Workflow Use
 
 - Feature, spec-driven execution, and implementation execution use this before writing or changing identifiers.

package/skills/massa-ai/references/spec-driven/design.md

@@ -73,12 +73,18 @@ Overview of how components interact. Use mermaid diagrams when helpful.
 
 **CRITICAL**: What existing code can we leverage? This saves tokens and reduces errors.
 
+Consume the reuse map produced per `references/code-reuse-scan.md` here — do not re-run the scan unless this design touches a code area the map did not cover.
+
+WHERE Figma ingestion is enabled, fill this design's Design(s) ID column in the relevant `.specs/<type>/<slug>/figma/*.md` wiring table per `references/figma-wiring.md`, for the low-level categories (Components, Visual effects, Tokens / Theming, Typography, Content, Assets, States, Spatial, Semantics, Mappings) this design covers.
+
 Flag any concerns found here per step 1.5 into `## Risks & Concerns`.
 
 ### 4. Define Components and Interfaces
 
 Each component: Purpose, Location, Interfaces, Dependencies, What it reuses.
 
+Apply the English-conversion rule from `references/naming-standards.md` to every component, interface, method, and data-model name before it is written into `design.md` — convert any non-English source term to English before it reaches this artifact.
+
 ### 5. Define Data Models
 
 If the feature involves data, define models before implementation.

package/skills/massa-ai/references/spec-driven/execute.md

@@ -81,6 +81,8 @@ Success: [how to verify]
 
 Load `references/naming-standards.md` before writing or changing identifiers; use meaningful domain or precise role names.
 
+WHERE this task has wired Figma node IDs, retrieve them through Figma MCP and implement per `references/figma-wiring.md`'s Execute Retrieval Protocol before writing code — never from memory of an earlier read. Apply the English-conversion rule from `references/naming-standards.md` to every new or renamed identifier this task introduces.
+
 Ask the MCP and skill question when tool choice can change correctness or verification.
 
 ### 4. Write Tests (derived from spec, not from implementation)

package/skills/massa-ai/references/spec-driven/specify.md

@@ -157,6 +157,14 @@ After requirements close, decide the remaining phases:
 
 ---
 
+## Figma Wiring And English Naming
+
+WHERE Figma ingestion is enabled for this feature, wire each authored spec item that maps to a high-level category (Structure, Behavior / Prototype, Flows) to its figma file + Number per `references/figma-wiring.md` before presenting the spec for confirmation.
+
+Apply the English-conversion rule from `references/naming-standards.md` to every identifier, requirement name, and artifact-facing term before writing `spec.md` — convert any non-English source term before it reaches this artifact.
+
+---
+
 ## Template: `.specs/features/<slug>/spec.md`
 
 ```markdown

package/skills/massa-ai/references/spec-driven/tasks.md

@@ -50,6 +50,8 @@ Use only when the TLC v3 flow includes Tasks. The output is the `.specs/features
 
 Read `.specs/features/<slug>/design.md` before creating tasks.
 
+WHERE Figma ingestion is enabled, consume the reuse map from `references/code-reuse-scan.md` for the wired implementation work, and fill each task's Task(s) ID column in the relevant `.specs/<type>/<slug>/figma/*.md` wiring table per `references/figma-wiring.md`. Before presenting tasks (step 5 below), run that reference's unused-Number gate — stop and report any unwired Number to the user before Execute proceeds.
+
 ### 1.5. Generate the Test Coverage Matrix (ALWAYS)
 
 This step ALWAYS runs — there is no precondition. Decide which of two paths to take, then generate the two sections below.

package/skills/massa-ai/scripts/validate_figma_wiring.ts

@@ -0,0 +1,271 @@
+#!/usr/bin/env bun
+/**
+ * validate_figma_wiring.ts - deterministic backing for the Figma wiring
+ * unused-Number stop rule (FIGMA-07, design D11b).
+ *
+ * Parses every per-link figma file's wiring table under
+ * `.specs/<type>/<slug>/figma/*.md` for the given slug (`references/figma-wiring.md`
+ * owns the per-link file template and the 8-column table contract) and
+ * reports, for each Number row, whether it is wired to at least one
+ * Spec(s)/Task(s)/Design(s) ID. Bun builtins only, zero dependencies.
+ *
+ * ALWAYS prints the parsed population (files scanned + rows parsed) beside
+ * the verdict -- a bare pass/fail is not trustworthy on its own
+ * (spec-scripts-parse-strict-shapes lesson): a script that silently parses
+ * zero rows from a malformed table would otherwise report a vacuous pass.
+ *
+ * Usage:
+ *   bun skills/massa-ai/scripts/validate_figma_wiring.ts <slug> [--root .] [--type features|quick|debug|refactors]
+ *
+ * What it checks:
+ *   ERROR - the figma/ directory exists but zero wiring-table rows were
+ *           parsed from it (loud failure, not a silent pass)
+ *   ERROR - a Number row has Spec(s) ID, Task(s) ID, AND Design(s) ID all
+ *           empty (unwired -- the unused-Number stop rule)
+ *
+ * A slug with no figma/ directory at all has nothing to check (Figma
+ * ingestion was never enabled for it) and exits 0 with a zero population.
+ *
+ * Exit codes: 0 pass (or nothing to check), 1 errors found, 2 usage error.
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join, relative } from "node:path";
+
+const VALID_TYPES = ["features", "quick", "debug", "refactors"] as const;
+type ArtifactType = (typeof VALID_TYPES)[number];
+
+/** One parsed data row from a wiring table. */
+interface WiringRow {
+  number: string;
+  nodeIds: string;
+  category: string;
+  specIds: string;
+  taskIds: string;
+  designIds: string;
+  /** Path reported in output, relative to `--root`. */
+  file: string;
+}
+
+/**
+ * The wiring-table header row, per `references/figma-wiring.md`'s
+ * Wiring-Table Contract: exactly these 8 columns, in this order.
+ */
+const HEADER_RE =
+  /^\|\s*Number\s*\|\s*Figma node id\(s\)\s*\|\s*Category\s*\|\s*Spec\(s\) ID\s*\|\s*Task\(s\) ID\s*\|\s*Design\(s\) ID\s*\|\s*Explanation\s*\|\s*Notes\s*\|\s*$/i;
+
+function isFile(p: string): boolean {
+  return existsSync(p) && statSync(p).isFile();
+}
+
+function isDir(p: string): boolean {
+  return existsSync(p) && statSync(p).isDirectory();
+}
+
+/** Universal newline split. */
+function splitLines(text: string): string[] {
+  return text.split(/\r\n|\r|\n/);
+}
+
+/** Splits one markdown table row into trimmed cells, dropping the outer-pipe edge cells. */
+function splitRow(line: string): string[] {
+  const trimmed = line.trim();
+  const withoutEdges = trimmed.replace(/^\|/, "").replace(/\|$/, "");
+  return withoutEdges.split("|").map((c) => c.trim());
+}
+
+/** True when every cell of a row looks like a markdown table separator (`---`, `:--`, `--:`). */
+function isSeparatorRow(cells: string[]): boolean {
+  return cells.length > 0 && cells.every((c) => /^:?-{2,}:?$/.test(c));
+}
+
+/** A cell counts as "wired" when it is non-empty and not a bare placeholder dash. */
+function isWiredCell(cell: string): boolean {
+  return cell !== "" && cell !== "-" && cell !== "—" && cell !== "N/A";
+}
+
+/**
+ * Parses every wiring table found in one figma file's markdown content.
+ *
+ * A table is recognized by its header row matching the 8-column contract
+ * followed immediately by a markdown separator row; every subsequent
+ * pipe-prefixed line with at least 8 cells is a data row, until a
+ * non-pipe-prefixed line ends the table.
+ *
+ * @param content - Raw file text.
+ * @param fileLabel - Path recorded on each parsed row for reporting.
+ */
+function parseWiringTables(content: string, fileLabel: string): WiringRow[] {
+  const lines = splitLines(content);
+  const rows: WiringRow[] = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (!HEADER_RE.test(lines[i]!.trim())) continue;
+    const sepIdx = i + 1;
+    if (sepIdx >= lines.length || !isSeparatorRow(splitRow(lines[sepIdx]!))) continue;
+    let j = sepIdx + 1;
+    while (j < lines.length) {
+      const line = lines[j]!;
+      if (!line.trim().startsWith("|")) break;
+      const cells = splitRow(line);
+      if (cells.length < 8) break;
+      rows.push({
+        number: cells[0]!,
+        nodeIds: cells[1]!,
+        category: cells[2]!,
+        specIds: cells[3]!,
+        taskIds: cells[4]!,
+        designIds: cells[5]!,
+        file: fileLabel,
+      });
+      j++;
+    }
+    i = j - 1;
+  }
+  return rows;
+}
+
+function figmaDir(root: string, type: ArtifactType, slug: string): string {
+  return join(root, ".specs", type, slug, "figma");
+}
+
+function listFigmaFiles(dir: string): string[] {
+  if (!isDir(dir)) return [];
+  return readdirSync(dir)
+    .filter((f) => f.endsWith(".md") && isFile(join(dir, f)))
+    .sort()
+    .map((f) => join(dir, f));
+}
+
+interface CheckResult {
+  errors: string[];
+  dirPresent: boolean;
+  filesScanned: number;
+  rowsParsed: number;
+  unwired: WiringRow[];
+}
+
+function check(root: string, type: ArtifactType, slug: string): CheckResult {
+  const dir = figmaDir(root, type, slug);
+  const errors: string[] = [];
+  const dirPresent = isDir(dir);
+  const files = listFigmaFiles(dir);
+  let rowsParsed = 0;
+  const unwired: WiringRow[] = [];
+
+  for (const file of files) {
+    const content = readFileSync(file, "utf-8");
+    const label = relative(root, file);
+    const rows = parseWiringTables(content, label);
+    rowsParsed += rows.length;
+    for (const row of rows) {
+      if (!isWiredCell(row.specIds) && !isWiredCell(row.taskIds) && !isWiredCell(row.designIds)) {
+        unwired.push(row);
+      }
+    }
+  }
+
+  if (dirPresent && rowsParsed === 0) {
+    errors.push(
+      `figma/ directory exists at ${relative(root, dir)} but zero wiring-table rows were parsed -- check the table header matches the 8-column contract in references/figma-wiring.md`,
+    );
+  }
+  for (const row of unwired) {
+    errors.push(
+      `${row.file} #${row.number}: unwired -- Spec(s) ID, Task(s) ID, and Design(s) ID are all empty (category: ${row.category || "?"}, node id(s): ${row.nodeIds || "?"})`,
+    );
+  }
+
+  return { errors, dirPresent, filesScanned: files.length, rowsParsed, unwired };
+}
+
+const USAGE = "usage: validate_figma_wiring.ts [-h] [--root ROOT] [--type features|quick|debug|refactors] <slug>";
+const HELP = `${USAGE}
+
+Deterministic backing for the Figma wiring unused-Number stop rule (FIGMA-07).
+
+positional arguments:
+  slug         The feature/quick/debug/refactor slug whose figma/ directory to check
+
+options:
+  -h, --help   show this help message and exit
+  --root ROOT  Project root that contains .specs/ (default: current dir)
+  --type TYPE  Artifact type: features (default) | quick | debug | refactors`;
+
+interface Args {
+  slug: string;
+  root: string;
+  type: ArtifactType;
+}
+
+function printUsageError(msg: string): void {
+  process.stderr.write(`${USAGE}\nvalidate_figma_wiring.ts: error: ${msg}\n`);
+}
+
+function parseArgs(argv: string[]): Args | null {
+  let root = ".";
+  let type: ArtifactType = "features";
+  const positionals: string[] = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i]!;
+    if (a === "--root") {
+      if (i + 1 >= argv.length) {
+        printUsageError("argument --root: expected one argument");
+        return null;
+      }
+      root = argv[++i]!;
+    } else if (a.startsWith("--root=")) {
+      root = a.slice("--root=".length);
+    } else if (a === "--type") {
+      if (i + 1 >= argv.length) {
+        printUsageError("argument --type: expected one argument");
+        return null;
+      }
+      const v = argv[++i]!;
+      if (!(VALID_TYPES as readonly string[]).includes(v)) {
+        printUsageError(`argument --type: invalid choice: '${v}' (choose from ${VALID_TYPES.map((t) => `'${t}'`).join(", ")})`);
+        return null;
+      }
+      type = v as ArtifactType;
+    } else if (a.startsWith("--type=")) {
+      const v = a.slice("--type=".length);
+      if (!(VALID_TYPES as readonly string[]).includes(v)) {
+        printUsageError(`argument --type: invalid choice: '${v}' (choose from ${VALID_TYPES.map((t) => `'${t}'`).join(", ")})`);
+        return null;
+      }
+      type = v as ArtifactType;
+    } else if (a === "-h" || a === "--help") {
+      console.log(HELP);
+      process.exit(0);
+    } else if (a.startsWith("-") && a !== "-") {
+      printUsageError(`unrecognized arguments: ${a}`);
+      return null;
+    } else {
+      positionals.push(a);
+    }
+  }
+  if (positionals.length === 0) {
+    printUsageError("the following arguments are required: slug");
+    return null;
+  }
+  if (positionals.length > 1) {
+    printUsageError(`unrecognized arguments: ${positionals.slice(1).join(" ")}`);
+    return null;
+  }
+  return { slug: positionals[0]!, root, type };
+}
+
+function main(argv: string[]): number {
+  const args = parseArgs(argv);
+  if (args === null) return 2;
+
+  const { errors, filesScanned, rowsParsed, unwired } = check(args.root, args.type, args.slug);
+  for (const e of errors) console.log(`  ERROR ${e}`);
+  console.log(
+    `\nvalidate_figma_wiring: scanned ${filesScanned} file(s), parsed ${rowsParsed} row(s), ${unwired.length} unwired, ${errors.length} error(s) for slug "${args.slug}" (type: ${args.type})`,
+  );
+  return errors.length > 0 ? 1 : 0;
+}
+
+if (import.meta.main) {
+  process.exit(main(process.argv.slice(2)));
+}

package/skills/massa-ai/workflows/architecture/architecture-fix.md

@@ -3,7 +3,7 @@ name: architecture-fix
 description: "Executes fixes from a saved architecture audit report; not for findings-only review or broad new design work with missing requirements."
 license: MIT
 metadata:
-  version: "1.2.0"
+  version: "1.3.0"
 ---
 
 ### Architecture Fix
@@ -17,10 +17,13 @@ Before the first repository mutation, load `references/implementation-delivery.m
 **Isolation Gate — before the first file edit:** execute `references/implementation-delivery.md` Stage 0–1 now (fetch base, create the worktree + branch, work inside it) and record the worktree path + branch — or one of Stage 1's two legal skip reasons, verbatim — before any repository mutation.
 
 Not for findings-only architecture review — route to `workflows/architecture/architecture-audit.md`. Not for broad new design work with missing requirements — route to `workflows/spec-driven.md`.
+**Reuse Scan — before writing new implementation code:** run the mandatory reuse scan per `references/code-reuse-scan.md` (separate read-only subagents; the reuse map's use/extend/new decisions are consumed before new code is planned or written) — or record its inline-fallback reason, verbatim.
+
 
 1. Resolve/reuse `workflowSessionId`: `architecture-fix-[entity]`
 2. Load shared references:
    - `references/audit-report-io.md` before any code change
+   - `references/naming-standards.md` before introducing or renaming identifiers, screens, components, attributes, or implementation-facing names (English-conversion rule applies)
    - `references/architecture-lenses.md`
    - `references/architecture-domain-lens.md` when executing domain or bounded-context findings
    - `references/architecture-coupling-lens.md` when executing dependency, contract, or coupling findings

package/skills/massa-ai/workflows/bugs/bugs-fix.md

@@ -3,7 +3,7 @@ name: bugs-fix
 description: "Executes fixes from a saved bugs audit report; not for findings-only discovery, single known issues without a report, or broad product changes."
 license: MIT
 metadata:
-  version: "1.2.0"
+  version: "1.3.0"
 ---
 
 ### Bugs Fix
@@ -17,10 +17,13 @@ Before the first repository mutation, load `references/implementation-delivery.m
 **Isolation Gate — before the first file edit:** execute `references/implementation-delivery.md` Stage 0–1 now (fetch base, create the worktree + branch, work inside it) and record the worktree path + branch — or one of Stage 1's two legal skip reasons, verbatim — before any repository mutation.
 
 Not for findings-only bug discovery — route to `workflows/bugs/bugs-audit.md`. Not for one known broken behavior without an audit report — route to `workflows/debug.md`. Not for broad product/design changes — route to `workflows/spec-driven.md`.
+**Reuse Scan — before writing new implementation code:** run the mandatory reuse scan per `references/code-reuse-scan.md` (separate read-only subagents; the reuse map's use/extend/new decisions are consumed before new code is planned or written) — or record its inline-fallback reason, verbatim.
+
 
 1. Resolve/reuse `workflowSessionId`: `bugs-fix-[entity]`
 2. Load shared references:
    - `references/audit-report-io.md` before any code or test change
+   - `references/naming-standards.md` before introducing or renaming identifiers, screens, components, attributes, or implementation-facing names (English-conversion rule applies)
    - `references/lessons.md` to load confirmed project lessons
    - `references/codebase-investigation.md` before changing unfamiliar bug paths
    - `references/verification-ladder.md` before non-trivial edits

package/skills/massa-ai/workflows/code-quality/code-quality-fix.md

@@ -3,7 +3,7 @@ name: code-quality-fix
 description: "Executes fixes from a saved code quality audit report; not for findings-only SOLID, Clean Code, KISS, YAGNI, DRY, or overengineering analysis."
 license: MIT
 metadata:
-  version: "1.2.0"
+  version: "1.3.0"
 ---
 
 ### Code Quality Fix
@@ -17,6 +17,8 @@ Before the first repository mutation, load `references/implementation-delivery.m
 **Isolation Gate — before the first file edit:** execute `references/implementation-delivery.md` Stage 0–1 now (fetch base, create the worktree + branch, work inside it) and record the worktree path + branch — or one of Stage 1's two legal skip reasons, verbatim — before any repository mutation.
 
 Not for findings-only SOLID, Clean Code, KISS, YAGNI, DRY, maintainability, or overengineering analysis — route to `workflows/code-quality/code-quality-audit.md`.
+**Reuse Scan — before writing new implementation code:** run the mandatory reuse scan per `references/code-reuse-scan.md` (separate read-only subagents; the reuse map's use/extend/new decisions are consumed before new code is planned or written) — or record its inline-fallback reason, verbatim.
+
 
 1. Resolve/reuse `workflowSessionId`: `code-quality-fix-[entity]`
 2. Load shared references:

package/skills/massa-ai/workflows/debug.md

@@ -3,7 +3,7 @@ name: debug
 description: "Use this workflow for evidence-backed root-cause diagnosis of broken behavior, failures, regressions, or crashes; route new capabilities to feature and broad redesign to spec-driven."
 license: MIT
 metadata:
-  version: "1.2.0"
+  version: "1.3.0"
 ---
 
 ### 🔴 Debug
@@ -17,8 +17,11 @@ Before the first repository mutation, load `references/implementation-delivery.m
 **Isolation Gate — before the first file edit:** execute `references/implementation-delivery.md` Stage 0–1 now (fetch base, create the worktree + branch, work inside it) and record the worktree path + branch — or one of Stage 1's two legal skip reasons, verbatim — before any repository mutation.
 
 1. Generate/reuse `workflowSessionId`: `debug-[entity]`
+**Reuse Scan — before writing new implementation code:** run the mandatory reuse scan per `references/code-reuse-scan.md` (separate read-only subagents; the reuse map's use/extend/new decisions are consumed before new code is planned or written) — or record its inline-fallback reason, verbatim.
+
 2. Load shared references:
    - `references/codebase-investigation.md`
+   - `references/naming-standards.md` before introducing or renaming identifiers, screens, components, attributes, or implementation-facing names (English-conversion rule applies)
    - `references/debug-diagnosis-loop.md`
    - `references/mobile-diagnosis.md` when the bug target involves KMP, iOS, Android, native bridges, devices, simulators/emulators, or mobile lifecycle
    - `references/verification-ladder.md` before Quick/Standard/Spec-driven sizing or applying fixes

package/skills/massa-ai/workflows/design.md

@@ -3,7 +3,7 @@ name: design
 description: "Implements or updates a concrete mobile UI from structured Figma evidence or screenshots when no saved audit report exists; route comparisons to mobile-figma-audit."
 license: MIT
 metadata:
-  version: "1.1.0"
+  version: "1.3.0"
 ---
 
 ### Design
@@ -17,32 +17,16 @@ Before the first repository mutation, load `references/implementation-delivery.m
 **Isolation Gate — before the first file edit:** execute `references/implementation-delivery.md` Stage 0–1 now (fetch base, create the worktree + branch, work inside it) and record the worktree path + branch — or one of Stage 1's two legal skip reasons, verbatim — before any repository mutation.
 
 Not for Flutter, React Native, web UI, generic Figma exploration, variable-only queries, or MCP troubleshooting.
+**Reuse Scan — before writing new implementation code:** run the mandatory reuse scan per `references/code-reuse-scan.md` (separate read-only subagents; the reuse map's use/extend/new decisions are consumed before new code is planned or written) — or record its inline-fallback reason, verbatim.
+
 
 1. Resolve/reuse `workflowSessionId`: `design-[entity]`.
-2. Load `references/mobile-figma-matcher/repository-detection.md`, `references/mobile-figma-matcher/core.md`, `references/mobile-context.md`, `references/codebase-investigation.md`, and `references/verification-ladder.md`. When Figma links or node IDs are provided, load `references/figma-pre-analysis.md` and run its two-stage sequential retrieval protocol before building the Figma Evidence Packet. Load `references/context-firewall.md` before large design/runtime artifacts and `references/synapse-policy.md` when repeated massa-ai searches are expected.
+2. Load `references/mobile-figma-matcher/repository-detection.md`, `references/mobile-figma-matcher/core.md`, `references/mobile-context.md`, `references/codebase-investigation.md`, `references/verification-ladder.md`, and `references/naming-standards.md` (before introducing or renaming identifiers, screens, components, attributes, or implementation-facing names — English-conversion rule applies). When Figma links or node IDs are provided, load `references/figma-pre-analysis.md` and run its two-stage sequential retrieval protocol before building the Figma Evidence Packet. Load `references/context-firewall.md` before large design/runtime artifacts and `references/synapse-policy.md` when repeated massa-ai searches are expected.
 3. `recall` -> load current component conventions, design-system rules, approved platform/accessibility deviations, prior Figma mappings, asset pipelines, and reusable render recipes. Memory is context, not proof.
 4. Require a concrete feature/module target plus at least one design source: readable Figma node/selection or supplied screenshots. Resolve required visual and interactive states plus a requirements source for behavior not represented in the design source. Ask only when target ownership, runtime platforms, platform-frame mappings, or screenshot authority stay ambiguous after source inspection.
-5. Build the immutable Target Surface Packet before loading stack guidance. Classify each selected surface and load only its contracts:
-   - Android Views XML -> `references/mobile-figma-matcher/android-views.md`.
-   - Android Jetpack Compose -> `references/mobile-figma-matcher/android-compose.md`.
-   - iOS UIKit -> `references/mobile-figma-matcher/ios-uikit.md`.
-   - iOS SwiftUI -> `references/mobile-figma-matcher/ios-swiftui.md`.
-   - Shared KMP Compose Multiplatform -> `references/mobile-figma-matcher/kmp-compose-multiplatform.md` plus native contracts only for selected native source sets, hosts, wrappers, or runtime targets.
-6. Build the Figma Evidence Packet with metadata when needed, design context, screenshot, variables, current Code Connect mappings, variants/states, annotations, and asset inventory. For screenshot-only sources, build a Screenshot Context Packet with provenance, target state, visible constraints, uncertainty, and `Design Evidence Class: screenshot-context-only`; do not infer exact Figma tokens, dimensions, variables, variants, or parity from screenshots alone. Stop if neither structured Figma evidence nor supplied screenshot context is available.
-7. Resolve current components, tokens, resources, assets, source-set ownership, platform adapters, requirements, and existing validation sensors. Create the Design-To-Code Mapping Matrix and one comparison configuration per selected runtime surface; screenshot-only rows use inferred visual intent, not `Figma Value`.
-8. Size the work with the Verification Ladder. Route broad application work, unresolved architecture, cross-feature design-system migration, or implementation that won't fit one clean context window to `spec-driven`.
-9. Establish the verification recipe before editing. Protect tests, snapshots, screenshot baselines, fixtures, previews, accessibility identifiers, test tags, and automation flows from weakening.
-10. Implement coherent slices using the smallest correct ownership boundary:
-    - Reuse existing components and tokens only after resolving semantics, states, accessibility, and values.
-    - Save required temporary Figma-served assets into the repository's existing durable asset pipeline before referencing them.
-    - Keep shared KMP UI in common source sets only when ownership is genuinely shared; keep platform UI and adapters explicit.
-    - Apply shared KMP root fixes before platform-local overrides when the cause is shared.
-    - Preserve platform accessibility, safe areas/insets, localization, adaptive behavior, and native conventions.
-11. After each coherent slice, rebuild affected mapping/comparison rows and run the cheapest deterministic sensors. When a shared KMP change affects Android and iOS, verify both requested targets or mark the unavailable platform `NOT EVALUATED`.
-12. Refresh the Figma node, when available, and all selected target surfaces before completion. Completion requires zero unresolved selected `MISMATCH` rows for structured Figma evidence; `NOT EVALUATED` rows remain explicit residual risk and prohibit complete parity claims. Screenshot-only completion may claim implementation against supplied screenshot context, never exact Figma parity.
-13. Report changed files, final per-surface matrix, saved assets, strongest verification level, skipped checks, and residual risk.
-14. Persist only durable token/component mappings, approved deviations, source-set ownership rules, asset-pipeline rules, or reusable render recipes after Importance Calibration. Use `workflow:design` and required project/session/entity/memory tags.
-15. Complete `references/evidence-gate.md`. Model visual judgment alone cannot satisfy completion.
+5. Follow `references/design-implementation.md` for the Target Surface Packet, the Figma Evidence / Screenshot Context Packet, the Design-To-Code Mapping Matrix, sizing and the verification recipe, coherent-slice implementation rules, per-slice verification, completion criteria, and the completion report — the single normative copy of this direction set, shared with `spec-driven`/`feature` under Figma ingestion.
+6. Persist only durable token/component mappings, approved deviations, source-set ownership rules, asset-pipeline rules, or reusable render recipes after Importance Calibration. Use `workflow:design` and required project/session/entity/memory tags.
+7. Complete `references/evidence-gate.md`. Model visual judgment alone cannot satisfy completion.
 
 ## Examples
 

package/skills/massa-ai/workflows/feature.md

@@ -3,7 +3,7 @@ name: feature
 description: "Use this workflow to add a new capability, screen, command, integration, or user-facing improvement with clear intent; route broken behavior to debug and broad work to spec-driven."
 license: MIT
 metadata:
-  version: "1.2.0"
+  version: "1.4.0"
 ---
 
 ### 🟡 Feature
@@ -17,6 +17,8 @@ Before the first repository mutation, load `references/implementation-delivery.m
 **Isolation Gate — before the first file edit:** execute `references/implementation-delivery.md` Stage 0–1 now (fetch base, create the worktree + branch, work inside it) and record the worktree path + branch — or one of Stage 1's two legal skip reasons, verbatim — before any repository mutation.
 
 1. Resolve/reuse `projectId` and `workflowSessionId` (`feature-[entity]`)
+**Reuse Scan — before writing new implementation code:** run the mandatory reuse scan per `references/code-reuse-scan.md` (separate read-only subagents; the reuse map's use/extend/new decisions are consumed before new code is planned or written) — or record its inline-fallback reason, verbatim.
+
 2. `recall` → load prior decisions and patterns for this area
    - Use the default recall budget: `limit <= 3`, `minImportance >= 0.7`, and `types=["critical","decision","pattern"]` unless the feature needs broader memory discovery.
    - Recall is context only and must not load or reconstruct canonical artifact state.
@@ -30,6 +32,7 @@ Before the first repository mutation, load `references/implementation-delivery.m
    - `references/lessons.md` when `.specs/lessons.json` exists, to load confirmed project lessons before sizing
    - `references/knowledge-verification-chain.md` when the feature depends on an external library or API whose behavior is not already established from this codebase, running the 5-step chain (codebase → project docs → Context7 → web → flag-uncertain) before relying on that dependency's behavior
    - `references/brownfield-mapping.md` (Minimum Bar only — CONCERNS.md + TESTING.md) when the feature touches an area this codebase does not already document; the full onboarding need stays the existing route-to-`workflows/spec-driven.md` boundary stated above for broad, ambiguous, or cross-boundary work, not a new escalation here
+   - `references/figma-pre-analysis.md`, `references/figma-wiring.md`, and `references/design-implementation.md`, lazily, WHERE one or more Figma links or node IDs are supplied for this feature (any platform) — before PR-group decomposition in step 5
 4. For Android, iOS, KMP Compose Multiplatform UI, or work whose target matches the enumerated mobile-context trigger set (KMP, iOS, Android, native bridges, mobile lifecycle, offline/sync, permissions, push/background behavior, local persistence, or backend-mobile contracts), run the design-source intake gate from `references/mobile-context.md` (Design-Source Intake Gate) before implementation.
 5. Size the task before implementation:
    - Use the exact Quick, Standard, and Spec-driven thresholds in `references/verification-ladder.md`.

package/skills/massa-ai/workflows/general.md

@@ -3,7 +3,7 @@ name: general
 description: "Final fallback workflow for coding, planning, review, or implementation work when no specialized massa-ai workflow is a better match."
 license: MIT
 metadata:
-  version: "1.2.0"
+  version: "1.3.0"
 ---
 
 ### General Coding Workflow
@@ -17,6 +17,8 @@ Before the first repository mutation, load `references/implementation-delivery.m
 **Isolation Gate — before the first file edit:** execute `references/implementation-delivery.md` Stage 0–1 now (fetch base, create the worktree + branch, work inside it) and record the worktree path + branch — or one of Stage 1's two legal skip reasons, verbatim — before any repository mutation.
 
 1. Resolve or reuse `projectId` and a stable `workflowSessionId`: `general-[entity]`.
+**Reuse Scan — before writing new implementation code:** run the mandatory reuse scan per `references/code-reuse-scan.md` (separate read-only subagents; the reuse map's use/extend/new decisions are consumed before new code is planned or written) — or record its inline-fallback reason, verbatim.
+
 2. Run General fallback preflight before source work: name the specialized workflow considered, the exact rejected reason, and why fallback does not change verification, mutation behavior, or memory scope. Ask the user only when the rejected workflow would change those behaviors. One delivery authorization obtained here covers the fallback change's commits, push, and PR creation; force-push, deploy, or merge are separately gated (`references/implementation-delivery.md` Stage 3).
 3. Recall relevant durable context with `recall`. Treat recalled memory as a lead until current source confirms it. Confirm against current source before relying on it only when the change touches the enumerated risk-domain set: public API, data loss, auth/PII, migrations, or cross-service contracts. Otherwise trust recalled memory and cite it with a one-line source note. When recall returns no hit and the repository is otherwise unmapped on Standard+ fallback work, run the Minimum Bar sweep from `references/brownfield-mapping.md` first, writing only `CONCERNS.md` and `TESTING.md` into `.specs/project/onboarding/` before continuing.
 4. Create a Synapse session when planned related `search` calls >=2, following `references/synapse-policy.md`.
@@ -27,7 +29,7 @@ Before the first repository mutation, load `references/implementation-delivery.m
    - deepen into enriched search, symbols, or exact files only when needed
    - prefer `read_file` over native Read when symbol metadata + imports are useful (retrieval order per `references/mcp-tools.md`); use `symbol_snippet` for raw code snippets by file + line range
    - prefer current repository truth over stale or conflicting memories
-6. Execute the requested work using existing repository conventions. Tie verification depth to the Verification Ladder tier table in `references/verification-ladder.md`: Quick (<=3 files and <=200 changed LOC) runs static + file-integrity checks; Standard (<=10 files or <=500 changed LOC) adds a named verification recipe and behavioral checks; Spec-driven (>10 files, >500 changed LOC) escalates to `workflows/spec-driven.md`. Do not invent new thresholds; load specialized references only when the task needs their exact contracts.
+6. Execute the requested work using existing repository conventions. Load `references/naming-standards.md` before introducing or renaming identifiers, screens, components, attributes, or implementation-facing names (English-conversion rule applies). Tie verification depth to the Verification Ladder tier table in `references/verification-ladder.md`: Quick (<=3 files and <=200 changed LOC) runs static + file-integrity checks; Standard (<=10 files or <=500 changed LOC) adds a named verification recipe and behavioral checks; Spec-driven (>10 files, >500 changed LOC) escalates to `workflows/spec-driven.md`. Do not invent new thresholds; load specialized references only when the task needs their exact contracts.
    - For analysis that benefits from running code (derived values, data inspection, bulk transforms), call `execute` with `language` and `code` or `batch_execute` with `commands`[] instead of loading raw data into context. Respect the local-dev-only trust model (no untrusted-client exposure).
    - When the chosen approach leans on an external library's or API's exact behavior, resolve it through the 5-step chain in `references/knowledge-verification-chain.md` (codebase, project docs, Context7, web, flag-uncertain) before committing to that approach — the trigger is the dependence itself, not the task's Quick/Standard/Spec-driven tier.
 7. Use `compress` only when accumulated source or conversation context is reducing execution quality; preserve decisions, constraints, current state, and next steps rather than raw history.

package/skills/massa-ai/workflows/implementation/implementation-fix.md

@@ -3,7 +3,7 @@ name: implementation-fix
 description: "Executes confirmed findings from a saved implementation audit report; the saved audits/implementation report is the source of truth, not chat summaries."
 license: MIT
 metadata:
-  version: "1.2.0"
+  version: "1.3.0"
 ---
 
 ### Implementation Fix
@@ -17,6 +17,8 @@ Before the first repository mutation, load `references/implementation-delivery.m
 **Isolation Gate — before the first file edit:** execute `references/implementation-delivery.md` Stage 0–1 now (fetch base, create the worktree + branch, work inside it) and record the worktree path + branch — or one of Stage 1's two legal skip reasons, verbatim — before any repository mutation.
 
 Do not execute from chat summaries, inline review comments, remembered findings, or old PR audit reports. The saved `audits/implementation/<YYYY-MM-DD implementation-audit.md>` report is the source of truth. Route fresh findings work to `workflows/implementation/implementation-audit.md`.
+**Reuse Scan — before writing new implementation code:** run the mandatory reuse scan per `references/code-reuse-scan.md` (separate read-only subagents; the reuse map's use/extend/new decisions are consumed before new code is planned or written) — or record its inline-fallback reason, verbatim.
+
 
 1. Resolve/reuse `workflowSessionId`: `implementation-fix-[entity]`.
 2. Load shared references:

package/skills/massa-ai/workflows/maestro/maestro-fix.md

@@ -3,7 +3,7 @@ name: maestro-fix
 description: "Child-only workflow to fix confirmed MST-prefixed findings from a saved Maestro audit report or an explicit maestro-audit handoff."
 license: MIT
 metadata:
-  version: "1.2.0"
+  version: "1.3.0"
 ---
 
 ### Maestro Fix
@@ -17,6 +17,8 @@ Before the first repository mutation, load `references/implementation-delivery.m
 **Isolation Gate — before the first file edit:** execute `references/implementation-delivery.md` Stage 0–1 now (fetch base, create the worktree + branch, work inside it) and record the worktree path + branch — or one of Stage 1's two legal skip reasons, verbatim — before any repository mutation.
 
 Reject direct use without a saved `audits/maestro/<YYYY-MM-DD maestro-audit.md>` report or a parent audit handoff that includes the same required metadata. Do not execute from chat summaries, remembered findings, inline comments, or unsaved model analysis. The saved report or parent handoff is the source of truth.
+**Reuse Scan — before writing new implementation code:** run the mandatory reuse scan per `references/code-reuse-scan.md` (separate read-only subagents; the reuse map's use/extend/new decisions are consumed before new code is planned or written) — or record its inline-fallback reason, verbatim.
+
 
 1. Resolve/reuse `workflowSessionId`: `maestro-fix-[entity]`.
 2. Load shared references:

package/skills/massa-ai/workflows/maestro/maestro.md

@@ -3,7 +3,7 @@ name: maestro
 description: "Implements new Maestro mobile E2E flows from Jira/Confluence, prompt text, attached scenario files, or inferred scenarios when no explicit source is supplied."
 license: MIT
 metadata:
-  version: "1.1.0"
+  version: "1.2.0"
 ---
 
 ### Maestro
@@ -17,6 +17,8 @@ Before the first repository mutation, load `references/implementation-delivery.m
 **Isolation Gate — before the first file edit:** execute `references/implementation-delivery.md` Stage 0–1 now (fetch base, create the worktree + branch, work inside it) and record the worktree path + branch — or one of Stage 1's two legal skip reasons, verbatim — before any repository mutation.
 
 Not for findings-only review of existing flows — route to `workflows/maestro/maestro-audit.md`. Not to execute saved audit findings — route to `workflows/maestro/maestro-fix.md`. Not for app bug fixes or product behavior changes — route to `workflows/debug.md`, `workflows/feature.md`, or `workflows/requirements/requirements-audit.md`.
+**Reuse Scan — before writing new implementation code:** run the mandatory reuse scan per `references/code-reuse-scan.md` (separate read-only subagents; the reuse map's use/extend/new decisions are consumed before new code is planned or written) — or record its inline-fallback reason, verbatim.
+
 
 1. Resolve/reuse `workflowSessionId`: `maestro-[entity]`.
 2. Load shared references:

package/skills/massa-ai/workflows/mobile-figma/mobile-figma-fix.md

@@ -3,7 +3,7 @@ name: mobile-figma-fix
 description: "Fixes confirmed MFM-prefixed findings from a saved mobile Figma audit report; the saved audit report is the source of truth, not screenshots or chat summaries."
 license: MIT
 metadata:
-  version: "1.2.0"
+  version: "1.3.0"
 ---
 
 ### Mobile Figma Fix
@@ -17,6 +17,8 @@ Before the first repository mutation, load `references/implementation-delivery.m
 **Isolation Gate — before the first file edit:** execute `references/implementation-delivery.md` Stage 0–1 now (fetch base, create the worktree + branch, work inside it) and record the worktree path + branch — or one of Stage 1's two legal skip reasons, verbatim — before any repository mutation.
 
 Do not execute from chat summaries, screenshots alone, remembered findings, or an unsaved comparison table. The saved `audits/mobile-figma/<YYYY-MM-DD mobile-figma-audit>.md` report is the source of truth. Route fresh comparison work to `mobile-figma-audit`.
+**Reuse Scan — before writing new implementation code:** run the mandatory reuse scan per `references/code-reuse-scan.md` (separate read-only subagents; the reuse map's use/extend/new decisions are consumed before new code is planned or written) — or record its inline-fallback reason, verbatim.
+
 
 1. Resolve/reuse `workflowSessionId`: `mobile-figma-fix-[entity]`.
 2. Load shared references:
@@ -24,6 +26,7 @@ Do not execute from chat summaries, screenshots alone, remembered findings, or a
    - `references/mobile-figma-matcher/core.md` for Figma, assets, mapping, Maestro, matrix, and claim contracts.
    - `references/figma-pre-analysis.md` when the findings span multiple Figma links or nodes — run its two-stage sequential retrieval protocol for the re-read.
    - `references/lessons.md` to load confirmed project lessons
+   - `references/naming-standards.md` before introducing or renaming identifiers, screens, components, attributes, or implementation-facing names (English-conversion rule applies)
    - `references/mobile-context.md` for mobile boundary and verification guidance.
    - `references/audit-report-io.md` before any source or validation-asset edit.
    - `references/audit-scope.md` and `references/codebase-investigation.md` for freshness and current source.

package/skills/massa-ai/workflows/refactor.md

@@ -3,7 +3,7 @@ name: refactor
 description: "Behavior-preserving structural cleanup, simplification, decoupling, and testability workflow; route broken behavior to debug and broad boundary redesign to architecture-audit or spec-driven."
 license: MIT
 metadata:
-  version: "1.2.0"
+  version: "1.3.0"
 ---
 
 ### 🔨 Refactor
@@ -17,10 +17,13 @@ Before the first repository mutation, load `references/implementation-delivery.m
 **Isolation Gate — before the first file edit:** execute `references/implementation-delivery.md` Stage 0–1 now (fetch base, create the worktree + branch, work inside it) and record the worktree path + branch — or one of Stage 1's two legal skip reasons, verbatim — before any repository mutation.
 
 1. Resolve/reuse `workflowSessionId`: `refactor-[entity]`
+**Reuse Scan — before writing new implementation code:** run the mandatory reuse scan per `references/code-reuse-scan.md` (separate read-only subagents; the reuse map's use/extend/new decisions are consumed before new code is planned or written) — or record its inline-fallback reason, verbatim.
+
 2. `recall` → load architectural decisions and coupling patterns for the area
    - Canonical artifact home: Standard+ refactors write to `.specs/refactors/<slug>/` (`CHARACTERIZATION.md` required; `PLAN.md` and `SENSOR.md` optional); Quick-sized refactors reuse `.specs/quick/NNN-slug/` verbatim. If the target directory is unwritable, block the write per `references/artifact-persistence.md`.
 3. Load shared references as needed:
    - `references/codebase-investigation.md` before changing unfamiliar code
+   - `references/naming-standards.md` before introducing or renaming identifiers, screens, components, attributes, or implementation-facing names (English-conversion rule applies)
    - `references/architecture-lenses.md` when the refactor is driven by coupling, seams, adapters, depth, leverage, or locality
    - `references/architecture-deepening-lens.md` and its Interface Design Method when a refactor candidate has two or more viable interface shapes (Design It Twice before choosing)
    - `references/knowledge-verification-chain.md` when Design It Twice or an architecture-lens library-pattern investigation depends on external library/API behavior not already verified in this session

package/skills/massa-ai/workflows/requirements/requirements-fix.md

@@ -3,7 +3,7 @@ name: requirements-fix
 description: "Executes fixes from a saved requirements audit report; not for findings-only review or broad feature design when acceptance criteria are missing."
 license: MIT
 metadata:
-  version: "1.2.0"
+  version: "1.3.0"
 ---
 
 ### Requirements Fix
@@ -17,10 +17,13 @@ Before the first repository mutation, load `references/implementation-delivery.m
 **Isolation Gate — before the first file edit:** execute `references/implementation-delivery.md` Stage 0–1 now (fetch base, create the worktree + branch, work inside it) and record the worktree path + branch — or one of Stage 1's two legal skip reasons, verbatim — before any repository mutation.
 
 Not for findings-only requirements review — route to `workflows/requirements/requirements-audit.md`. Not for broad feature design when acceptance criteria are missing — route to `workflows/spec-driven.md`.
+**Reuse Scan — before writing new implementation code:** run the mandatory reuse scan per `references/code-reuse-scan.md` (separate read-only subagents; the reuse map's use/extend/new decisions are consumed before new code is planned or written) — or record its inline-fallback reason, verbatim.
+
 
 1. Resolve/reuse `workflowSessionId`: `requirements-fix-[entity]`
 2. Load shared references:
    - `references/audit-report-io.md` before any code change
+   - `references/naming-standards.md` before introducing or renaming identifiers, screens, components, attributes, or implementation-facing names (English-conversion rule applies)
    - `references/lessons.md` to load confirmed project lessons
    - `references/codebase-investigation.md` before changing unfamiliar requirement flows
    - `references/verification-ladder.md` before non-trivial edits

package/skills/massa-ai/workflows/security/security-fix.md

@@ -3,7 +3,7 @@ name: security-fix
 description: "Executes fixes from a saved security audit report; not for findings-only security review or generic correctness fixes outside an exploitable path."
 license: MIT
 metadata:
-  version: "1.2.0"
+  version: "1.3.0"
 ---
 
 ### Security Fix
@@ -17,10 +17,13 @@ Before the first repository mutation, load `references/implementation-delivery.m
 **Isolation Gate — before the first file edit:** execute `references/implementation-delivery.md` Stage 0–1 now (fetch base, create the worktree + branch, work inside it) and record the worktree path + branch — or one of Stage 1's two legal skip reasons, verbatim — before any repository mutation.
 
 Not for findings-only security review — route to `workflows/security/security-audit.md`. Not for generic correctness fixes unless the security report identifies the correctness issue as part of an exploitable path.
+**Reuse Scan — before writing new implementation code:** run the mandatory reuse scan per `references/code-reuse-scan.md` (separate read-only subagents; the reuse map's use/extend/new decisions are consumed before new code is planned or written) — or record its inline-fallback reason, verbatim.
+
 
 1. Resolve/reuse `workflowSessionId`: `security-fix-[entity]`
 2. Load shared references:
    - `references/audit-report-io.md` before any code change
+   - `references/naming-standards.md` before introducing or renaming identifiers, screens, components, attributes, or implementation-facing names (English-conversion rule applies)
    - `references/lessons.md` to load confirmed project lessons
    - `references/codebase-investigation.md` before changing unfamiliar security boundaries; that trigger also gates `.specs/project/onboarding/CONCERNS.md` — consult it before working the finding
    - `references/mobile-context.md` when the report target touches KMP, iOS, Android, native bridges, mobile permissions, secure storage, biometrics, deep links, push/background behavior, local persistence, offline queues, logs/crash privacy, or backend-mobile contracts

package/skills/massa-ai/workflows/spec-driven.md

@@ -3,7 +3,7 @@ name: spec-driven
 description: "Use this workflow for explicit spec-driven requests and broad, ambiguous, migration-heavy, or cross-boundary delivery needing requirements-through-verification control."
 license: MIT
 metadata:
-  version: "1.1.0"
+  version: "1.3.0"
 ---
 
 ### Spec-Driven
@@ -88,6 +88,7 @@ Quick artifacts live under `.specs/quick/NNN-slug/` with a `TASK.md` (one-line i
    - Load `references/context-firewall.md` before broad source inspection, generated reports, external research, or verbose tool output.
    - Keep the loaded context budget under the `references/spec-driven/context-limits.md` target; summarize or narrow before loading bulky artifacts.
    - Use `references/spec-driven/code-analysis.md` when source inspection needs structural search or tool fallback.
+   - Load `references/naming-standards.md` before introducing or renaming identifiers, screens, components, attributes, or implementation-facing names (English-conversion rule applies).
    - Load current canonical artifacts from `.specs/` files: `.specs/project/FEATURES.json`, `.specs/project/STATE.md`, `.specs/HANDOFF.md`, existing `.specs/features/<slug>/` phase artifacts, lessons, and project source. Current repository source and approved `.specs/` artifacts override stale memory, old handoff notes, external summaries, debug exports, or unapproved generated plans.
    - `search` only counts as codebase evidence when it is fresh for the current repository path and commit/worktree state, or when the result is confirmed against source files read in this session.
    - Load confirmed project lessons through `references/lessons.md` when `.specs/lessons.json` exists:
@@ -96,7 +97,10 @@ Quick artifacts live under `.specs/quick/NNN-slug/` with a `TASK.md` (one-line i
    - Capture stable requirement IDs, testable acceptance criteria, edge cases, and explicit out-of-scope items.
    - Run `references/spec-driven/discuss.md` inside Specify when gray areas, implicit requirements, persistence/state, external calls, auth, payments, concurrency, or state transitions affect behavior.
    - For Android, iOS, or KMP Compose Multiplatform UI work, run the optional design-source intake gate from `references/mobile-context.md` (Design-Source Intake Gate).
+   - WHERE one or more Figma links or node IDs are supplied for this work (any platform), lazily load `references/figma-pre-analysis.md`, `references/figma-wiring.md`, and `references/design-implementation.md` before Design/Tasks close; mobile targets additionally keep the Design-Source Intake Gate above.
    - Apply the Requirement Closure Gate: every open requirement question is resolved with the user or recorded as an accepted assumption before execution begins.
+**Reuse Scan — before writing new implementation code:** run the mandatory reuse scan per `references/code-reuse-scan.md` (separate read-only subagents; the reuse map's use/extend/new decisions are consumed before new code is planned or written) — or record its inline-fallback reason, verbatim.
+
 4. Decide whether `Design` is required. If yes, run `references/spec-driven/design.md`, including its deterministic validation before presenting `design.md` for confirmation; if no, record why the skip is valid. When Design is skipped and a design concern appears later, stop and create `design.md` before continuing.
 5. Decide whether `Tasks` is required. If yes, run `references/spec-driven/tasks.md`; if no, list the inline atomic execution steps before editing. If the inline list reveals more than 5 steps or complex dependencies, stop and create `tasks.md` — the Tasks phase was wrongly skipped (safety valve).
 6. Run `Execute` with `references/spec-driven/execute.md`.

package/skills/massa-ai/workflows/tests/tests-fix.md

@@ -3,7 +3,7 @@ name: tests-fix
 description: "Executes fixes from a saved tests audit report; not for findings-only coverage review or generic test-writing work without an audit report."
 license: MIT
 metadata:
-  version: "1.2.0"
+  version: "1.3.0"
 ---
 
 ### Tests Fix
@@ -17,10 +17,13 @@ Before the first repository mutation, load `references/implementation-delivery.m
 **Isolation Gate — before the first file edit:** execute `references/implementation-delivery.md` Stage 0–1 now (fetch base, create the worktree + branch, work inside it) and record the worktree path + branch — or one of Stage 1's two legal skip reasons, verbatim — before any repository mutation.
 
 Not for findings-only test coverage, assertion quality, fixture health, flakiness, or regression-risk review — route to `workflows/tests/tests-audit.md`. Not for generic "write some tests" work without an audit report — route broad test planning through the relevant feature, debug, refactor, or spec-driven workflow.
+**Reuse Scan — before writing new implementation code:** run the mandatory reuse scan per `references/code-reuse-scan.md` (separate read-only subagents; the reuse map's use/extend/new decisions are consumed before new code is planned or written) — or record its inline-fallback reason, verbatim.
+
 
 1. Resolve/reuse `workflowSessionId`: `tests-fix-[entity]`
 2. Load shared references:
    - `references/audit-report-io.md` before any code or test change
+   - `references/naming-standards.md` before introducing or renaming identifiers, screens, components, attributes, or implementation-facing names (English-conversion rule applies)
    - `references/lessons.md` to load confirmed project lessons
    - `references/codebase-investigation.md` before changing unfamiliar tests or fixtures
    - `references/mobile-context.md` when the report target touches KMP, iOS, Android, native bridges, mobile lifecycle, offline sync, permissions, local persistence, UI snapshots/screenshots, or backend-mobile contracts