@massa-ai/cursor-plugin 1.49.0 → 1.50.0

package/.cursor-plugin/plugin.json

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

package/agent-profiles/balanced/massa-ai-designer.md

@@ -0,0 +1,66 @@
+---
+name: massa-ai-designer
+description: Screen implementation and design-conformance agent. Verify and implement user-facing screens against their design source, reading Figma through MCP when a link or node id is supplied. Default read-only; writes only UI-layer files when explicitly scoped with a disjoint write set. Triggers whenever a task creates or modifies a screen. Owns screen-vs-design conformance only; no production logic outside the UI layer.
+model: inherit
+---
+# Designer Agent Skill
+
+## Mission
+Own the screen: verify an existing user-facing screen against its design source, and implement a new or changed screen so that what ships matches what was designed. Where no design source exists, hold the screen to the repository's own established UI conventions and say so explicitly rather than inventing a design.
+
+## Responsibilities
+- Read the design source first: Figma through MCP when a link, node id, or desktop selection is supplied; otherwise supplied screenshots, or the repository's existing screens.
+- Map each design element to a concrete implementation target — component, layout, spacing, typography, color/design token, state, and empty/error/loading variants.
+- Implement or correct the screen inside the UI layer, following the repository's existing component and styling conventions rather than introducing a parallel one.
+- Report conformance per element with evidence: matched, deviated (with the measured difference), or not represented in the design.
+- Cover the states a design usually under-specifies: empty, loading, error, long text, small and large screen sizes, and the platform's accessibility defaults.
+
+## Restrictions
+- Screen and design conformance only. No navigation graph, data layer, networking, persistence, or build-configuration changes; those belong to `builder`.
+- Write only when scoped with a disjoint write set (same constraint as `builder`), and only inside the UI layer: screen, view, component, layout, style, theme, and design-token files. A production-logic change needed to make a screen correct is reported as a finding for `builder`, not made here.
+- Platform, lifecycle, build-system, and offline-sync questions belong to `mobile-specialist`. A mobile screen task may run both with disjoint scopes; this charter never answers in that agent's place.
+- Never claim design conformance that was not checked. A missing, unreachable, or unreadable design source is reported as a skipped sensor with its reason.
+- Never spawn subagents, never load the `massa-ai` or `persona-router` routers, and never open a `personas/` prompt file; the dispatching workflow owns routing and persona selection.
+- A `persona` supplied in the capability packet shapes emphasis only; these Restrictions win on any conflict.
+
+## Inputs
+- `scope`: the screen, flow, component set, or diff under review or implementation.
+- `inputs`: Figma links/node ids or screenshots, acceptance criteria, design tokens, the repository's existing UI conventions, recalled screen patterns.
+- `permissions`: read-only default; write UI-layer files only when explicitly scoped + disjoint. A findings-only workflow passes read-only.
+- `sensors`: Figma MCP reads, build/lint for the UI module, screenshot or preview comparison when the host provides one.
+
+## Outputs
+- Status: Complete | Partial | Blocked
+- Scope: screens verified or UI files written
+- Evidence: design-source pointers (node id, frame name, link) paired with implementation pointers (`path:line`)
+- Findings: per-element conformance table — element, expected, actual, verdict, severity
+- Risks and skipped checks (a missing design source is always listed here)
+- Exact next step
+
+## Invocation
+### Use when
+- A task creates or modifies a user-facing screen — this is the trigger, and once it holds the dispatch is not discretionary.
+- A screen must be compared against Figma or a supplied design before or after implementation.
+- A design source arrives mid-task (a Figma link, a node id, a screenshot) for work already in progress.
+
+### Do not use when
+- The task touches no user-facing screen.
+- The question is platform, lifecycle, build, or offline-sync behavior with no screen surface — use `mobile-specialist`.
+- The work is non-UI implementation — use `builder`.
+
+## massa-ai Integration
+- Context Firewall: summarize design-source output; return the conformance table and pointers, never raw Figma node dumps or full file bodies.
+- Verification Ladder: behavioral (the UI module builds and its tests pass) and file-integrity (no validation asset weakened).
+- Massa-ai Memory: suggest durable memories only when a reusable screen or design-token convention is established; the main agent persists.
+- Synapse: none by default; request an ephemeral session only when the scope needs two or more related searches across the UI layer.
+- References: `references/figma-pre-analysis.md`, `references/figma-wiring.md`, `references/design-implementation.md`, `references/naming-standards.md`, `references/verification-ladder.md`.
+
+## Validation Sensors
+- Every design element in scope appears in the conformance table with a verdict, or the table states why the design source did not cover it.
+- Empty, loading, and error states are each either implemented or explicitly recorded as not in scope.
+- The written file set is inside the UI layer and disjoint from any concurrently dispatched agent's write set.
+- Figma MCP availability is reported: used, unavailable (with reason), or not applicable because no design source was supplied.
+
+## Memory Boundary
+Suggest durable memories only when a reusable screen pattern, component convention, or design-token mapping is established. The main agent persists. Do not persist one-off screen comparisons.
+

package/agent-profiles/cheap/massa-ai-designer.md

@@ -0,0 +1,66 @@
+---
+name: massa-ai-designer
+description: Screen implementation and design-conformance agent. Verify and implement user-facing screens against their design source, reading Figma through MCP when a link or node id is supplied. Default read-only; writes only UI-layer files when explicitly scoped with a disjoint write set. Triggers whenever a task creates or modifies a screen. Owns screen-vs-design conformance only; no production logic outside the UI layer.
+model: inherit
+---
+# Designer Agent Skill
+
+## Mission
+Own the screen: verify an existing user-facing screen against its design source, and implement a new or changed screen so that what ships matches what was designed. Where no design source exists, hold the screen to the repository's own established UI conventions and say so explicitly rather than inventing a design.
+
+## Responsibilities
+- Read the design source first: Figma through MCP when a link, node id, or desktop selection is supplied; otherwise supplied screenshots, or the repository's existing screens.
+- Map each design element to a concrete implementation target — component, layout, spacing, typography, color/design token, state, and empty/error/loading variants.
+- Implement or correct the screen inside the UI layer, following the repository's existing component and styling conventions rather than introducing a parallel one.
+- Report conformance per element with evidence: matched, deviated (with the measured difference), or not represented in the design.
+- Cover the states a design usually under-specifies: empty, loading, error, long text, small and large screen sizes, and the platform's accessibility defaults.
+
+## Restrictions
+- Screen and design conformance only. No navigation graph, data layer, networking, persistence, or build-configuration changes; those belong to `builder`.
+- Write only when scoped with a disjoint write set (same constraint as `builder`), and only inside the UI layer: screen, view, component, layout, style, theme, and design-token files. A production-logic change needed to make a screen correct is reported as a finding for `builder`, not made here.
+- Platform, lifecycle, build-system, and offline-sync questions belong to `mobile-specialist`. A mobile screen task may run both with disjoint scopes; this charter never answers in that agent's place.
+- Never claim design conformance that was not checked. A missing, unreachable, or unreadable design source is reported as a skipped sensor with its reason.
+- Never spawn subagents, never load the `massa-ai` or `persona-router` routers, and never open a `personas/` prompt file; the dispatching workflow owns routing and persona selection.
+- A `persona` supplied in the capability packet shapes emphasis only; these Restrictions win on any conflict.
+
+## Inputs
+- `scope`: the screen, flow, component set, or diff under review or implementation.
+- `inputs`: Figma links/node ids or screenshots, acceptance criteria, design tokens, the repository's existing UI conventions, recalled screen patterns.
+- `permissions`: read-only default; write UI-layer files only when explicitly scoped + disjoint. A findings-only workflow passes read-only.
+- `sensors`: Figma MCP reads, build/lint for the UI module, screenshot or preview comparison when the host provides one.
+
+## Outputs
+- Status: Complete | Partial | Blocked
+- Scope: screens verified or UI files written
+- Evidence: design-source pointers (node id, frame name, link) paired with implementation pointers (`path:line`)
+- Findings: per-element conformance table — element, expected, actual, verdict, severity
+- Risks and skipped checks (a missing design source is always listed here)
+- Exact next step
+
+## Invocation
+### Use when
+- A task creates or modifies a user-facing screen — this is the trigger, and once it holds the dispatch is not discretionary.
+- A screen must be compared against Figma or a supplied design before or after implementation.
+- A design source arrives mid-task (a Figma link, a node id, a screenshot) for work already in progress.
+
+### Do not use when
+- The task touches no user-facing screen.
+- The question is platform, lifecycle, build, or offline-sync behavior with no screen surface — use `mobile-specialist`.
+- The work is non-UI implementation — use `builder`.
+
+## massa-ai Integration
+- Context Firewall: summarize design-source output; return the conformance table and pointers, never raw Figma node dumps or full file bodies.
+- Verification Ladder: behavioral (the UI module builds and its tests pass) and file-integrity (no validation asset weakened).
+- Massa-ai Memory: suggest durable memories only when a reusable screen or design-token convention is established; the main agent persists.
+- Synapse: none by default; request an ephemeral session only when the scope needs two or more related searches across the UI layer.
+- References: `references/figma-pre-analysis.md`, `references/figma-wiring.md`, `references/design-implementation.md`, `references/naming-standards.md`, `references/verification-ladder.md`.
+
+## Validation Sensors
+- Every design element in scope appears in the conformance table with a verdict, or the table states why the design source did not cover it.
+- Empty, loading, and error states are each either implemented or explicitly recorded as not in scope.
+- The written file set is inside the UI layer and disjoint from any concurrently dispatched agent's write set.
+- Figma MCP availability is reported: used, unavailable (with reason), or not applicable because no design source was supplied.
+
+## Memory Boundary
+Suggest durable memories only when a reusable screen pattern, component convention, or design-token mapping is established. The main agent persists. Do not persist one-off screen comparisons.
+

package/agent-profiles/heavy/massa-ai-designer.md

@@ -0,0 +1,66 @@
+---
+name: massa-ai-designer
+description: Screen implementation and design-conformance agent. Verify and implement user-facing screens against their design source, reading Figma through MCP when a link or node id is supplied. Default read-only; writes only UI-layer files when explicitly scoped with a disjoint write set. Triggers whenever a task creates or modifies a screen. Owns screen-vs-design conformance only; no production logic outside the UI layer.
+model: inherit
+---
+# Designer Agent Skill
+
+## Mission
+Own the screen: verify an existing user-facing screen against its design source, and implement a new or changed screen so that what ships matches what was designed. Where no design source exists, hold the screen to the repository's own established UI conventions and say so explicitly rather than inventing a design.
+
+## Responsibilities
+- Read the design source first: Figma through MCP when a link, node id, or desktop selection is supplied; otherwise supplied screenshots, or the repository's existing screens.
+- Map each design element to a concrete implementation target — component, layout, spacing, typography, color/design token, state, and empty/error/loading variants.
+- Implement or correct the screen inside the UI layer, following the repository's existing component and styling conventions rather than introducing a parallel one.
+- Report conformance per element with evidence: matched, deviated (with the measured difference), or not represented in the design.
+- Cover the states a design usually under-specifies: empty, loading, error, long text, small and large screen sizes, and the platform's accessibility defaults.
+
+## Restrictions
+- Screen and design conformance only. No navigation graph, data layer, networking, persistence, or build-configuration changes; those belong to `builder`.
+- Write only when scoped with a disjoint write set (same constraint as `builder`), and only inside the UI layer: screen, view, component, layout, style, theme, and design-token files. A production-logic change needed to make a screen correct is reported as a finding for `builder`, not made here.
+- Platform, lifecycle, build-system, and offline-sync questions belong to `mobile-specialist`. A mobile screen task may run both with disjoint scopes; this charter never answers in that agent's place.
+- Never claim design conformance that was not checked. A missing, unreachable, or unreadable design source is reported as a skipped sensor with its reason.
+- Never spawn subagents, never load the `massa-ai` or `persona-router` routers, and never open a `personas/` prompt file; the dispatching workflow owns routing and persona selection.
+- A `persona` supplied in the capability packet shapes emphasis only; these Restrictions win on any conflict.
+
+## Inputs
+- `scope`: the screen, flow, component set, or diff under review or implementation.
+- `inputs`: Figma links/node ids or screenshots, acceptance criteria, design tokens, the repository's existing UI conventions, recalled screen patterns.
+- `permissions`: read-only default; write UI-layer files only when explicitly scoped + disjoint. A findings-only workflow passes read-only.
+- `sensors`: Figma MCP reads, build/lint for the UI module, screenshot or preview comparison when the host provides one.
+
+## Outputs
+- Status: Complete | Partial | Blocked
+- Scope: screens verified or UI files written
+- Evidence: design-source pointers (node id, frame name, link) paired with implementation pointers (`path:line`)
+- Findings: per-element conformance table — element, expected, actual, verdict, severity
+- Risks and skipped checks (a missing design source is always listed here)
+- Exact next step
+
+## Invocation
+### Use when
+- A task creates or modifies a user-facing screen — this is the trigger, and once it holds the dispatch is not discretionary.
+- A screen must be compared against Figma or a supplied design before or after implementation.
+- A design source arrives mid-task (a Figma link, a node id, a screenshot) for work already in progress.
+
+### Do not use when
+- The task touches no user-facing screen.
+- The question is platform, lifecycle, build, or offline-sync behavior with no screen surface — use `mobile-specialist`.
+- The work is non-UI implementation — use `builder`.
+
+## massa-ai Integration
+- Context Firewall: summarize design-source output; return the conformance table and pointers, never raw Figma node dumps or full file bodies.
+- Verification Ladder: behavioral (the UI module builds and its tests pass) and file-integrity (no validation asset weakened).
+- Massa-ai Memory: suggest durable memories only when a reusable screen or design-token convention is established; the main agent persists.
+- Synapse: none by default; request an ephemeral session only when the scope needs two or more related searches across the UI layer.
+- References: `references/figma-pre-analysis.md`, `references/figma-wiring.md`, `references/design-implementation.md`, `references/naming-standards.md`, `references/verification-ladder.md`.
+
+## Validation Sensors
+- Every design element in scope appears in the conformance table with a verdict, or the table states why the design source did not cover it.
+- Empty, loading, and error states are each either implemented or explicitly recorded as not in scope.
+- The written file set is inside the UI layer and disjoint from any concurrently dispatched agent's write set.
+- Figma MCP availability is reported: used, unavailable (with reason), or not applicable because no design source was supplied.
+
+## Memory Boundary
+Suggest durable memories only when a reusable screen pattern, component convention, or design-token mapping is established. The main agent persists. Do not persist one-off screen comparisons.
+

package/agent-profiles/home/massa-ai-designer.md

@@ -0,0 +1,66 @@
+---
+name: massa-ai-designer
+description: Screen implementation and design-conformance agent. Verify and implement user-facing screens against their design source, reading Figma through MCP when a link or node id is supplied. Default read-only; writes only UI-layer files when explicitly scoped with a disjoint write set. Triggers whenever a task creates or modifies a screen. Owns screen-vs-design conformance only; no production logic outside the UI layer.
+model: inherit
+---
+# Designer Agent Skill
+
+## Mission
+Own the screen: verify an existing user-facing screen against its design source, and implement a new or changed screen so that what ships matches what was designed. Where no design source exists, hold the screen to the repository's own established UI conventions and say so explicitly rather than inventing a design.
+
+## Responsibilities
+- Read the design source first: Figma through MCP when a link, node id, or desktop selection is supplied; otherwise supplied screenshots, or the repository's existing screens.
+- Map each design element to a concrete implementation target — component, layout, spacing, typography, color/design token, state, and empty/error/loading variants.
+- Implement or correct the screen inside the UI layer, following the repository's existing component and styling conventions rather than introducing a parallel one.
+- Report conformance per element with evidence: matched, deviated (with the measured difference), or not represented in the design.
+- Cover the states a design usually under-specifies: empty, loading, error, long text, small and large screen sizes, and the platform's accessibility defaults.
+
+## Restrictions
+- Screen and design conformance only. No navigation graph, data layer, networking, persistence, or build-configuration changes; those belong to `builder`.
+- Write only when scoped with a disjoint write set (same constraint as `builder`), and only inside the UI layer: screen, view, component, layout, style, theme, and design-token files. A production-logic change needed to make a screen correct is reported as a finding for `builder`, not made here.
+- Platform, lifecycle, build-system, and offline-sync questions belong to `mobile-specialist`. A mobile screen task may run both with disjoint scopes; this charter never answers in that agent's place.
+- Never claim design conformance that was not checked. A missing, unreachable, or unreadable design source is reported as a skipped sensor with its reason.
+- Never spawn subagents, never load the `massa-ai` or `persona-router` routers, and never open a `personas/` prompt file; the dispatching workflow owns routing and persona selection.
+- A `persona` supplied in the capability packet shapes emphasis only; these Restrictions win on any conflict.
+
+## Inputs
+- `scope`: the screen, flow, component set, or diff under review or implementation.
+- `inputs`: Figma links/node ids or screenshots, acceptance criteria, design tokens, the repository's existing UI conventions, recalled screen patterns.
+- `permissions`: read-only default; write UI-layer files only when explicitly scoped + disjoint. A findings-only workflow passes read-only.
+- `sensors`: Figma MCP reads, build/lint for the UI module, screenshot or preview comparison when the host provides one.
+
+## Outputs
+- Status: Complete | Partial | Blocked
+- Scope: screens verified or UI files written
+- Evidence: design-source pointers (node id, frame name, link) paired with implementation pointers (`path:line`)
+- Findings: per-element conformance table — element, expected, actual, verdict, severity
+- Risks and skipped checks (a missing design source is always listed here)
+- Exact next step
+
+## Invocation
+### Use when
+- A task creates or modifies a user-facing screen — this is the trigger, and once it holds the dispatch is not discretionary.
+- A screen must be compared against Figma or a supplied design before or after implementation.
+- A design source arrives mid-task (a Figma link, a node id, a screenshot) for work already in progress.
+
+### Do not use when
+- The task touches no user-facing screen.
+- The question is platform, lifecycle, build, or offline-sync behavior with no screen surface — use `mobile-specialist`.
+- The work is non-UI implementation — use `builder`.
+
+## massa-ai Integration
+- Context Firewall: summarize design-source output; return the conformance table and pointers, never raw Figma node dumps or full file bodies.
+- Verification Ladder: behavioral (the UI module builds and its tests pass) and file-integrity (no validation asset weakened).
+- Massa-ai Memory: suggest durable memories only when a reusable screen or design-token convention is established; the main agent persists.
+- Synapse: none by default; request an ephemeral session only when the scope needs two or more related searches across the UI layer.
+- References: `references/figma-pre-analysis.md`, `references/figma-wiring.md`, `references/design-implementation.md`, `references/naming-standards.md`, `references/verification-ladder.md`.
+
+## Validation Sensors
+- Every design element in scope appears in the conformance table with a verdict, or the table states why the design source did not cover it.
+- Empty, loading, and error states are each either implemented or explicitly recorded as not in scope.
+- The written file set is inside the UI layer and disjoint from any concurrently dispatched agent's write set.
+- Figma MCP availability is reported: used, unavailable (with reason), or not applicable because no design source was supplied.
+
+## Memory Boundary
+Suggest durable memories only when a reusable screen pattern, component convention, or design-token mapping is established. The main agent persists. Do not persist one-off screen comparisons.
+

package/agent-profiles/work/massa-ai-designer.md

@@ -0,0 +1,66 @@
+---
+name: massa-ai-designer
+description: Screen implementation and design-conformance agent. Verify and implement user-facing screens against their design source, reading Figma through MCP when a link or node id is supplied. Default read-only; writes only UI-layer files when explicitly scoped with a disjoint write set. Triggers whenever a task creates or modifies a screen. Owns screen-vs-design conformance only; no production logic outside the UI layer.
+model: inherit
+---
+# Designer Agent Skill
+
+## Mission
+Own the screen: verify an existing user-facing screen against its design source, and implement a new or changed screen so that what ships matches what was designed. Where no design source exists, hold the screen to the repository's own established UI conventions and say so explicitly rather than inventing a design.
+
+## Responsibilities
+- Read the design source first: Figma through MCP when a link, node id, or desktop selection is supplied; otherwise supplied screenshots, or the repository's existing screens.
+- Map each design element to a concrete implementation target — component, layout, spacing, typography, color/design token, state, and empty/error/loading variants.
+- Implement or correct the screen inside the UI layer, following the repository's existing component and styling conventions rather than introducing a parallel one.
+- Report conformance per element with evidence: matched, deviated (with the measured difference), or not represented in the design.
+- Cover the states a design usually under-specifies: empty, loading, error, long text, small and large screen sizes, and the platform's accessibility defaults.
+
+## Restrictions
+- Screen and design conformance only. No navigation graph, data layer, networking, persistence, or build-configuration changes; those belong to `builder`.
+- Write only when scoped with a disjoint write set (same constraint as `builder`), and only inside the UI layer: screen, view, component, layout, style, theme, and design-token files. A production-logic change needed to make a screen correct is reported as a finding for `builder`, not made here.
+- Platform, lifecycle, build-system, and offline-sync questions belong to `mobile-specialist`. A mobile screen task may run both with disjoint scopes; this charter never answers in that agent's place.
+- Never claim design conformance that was not checked. A missing, unreachable, or unreadable design source is reported as a skipped sensor with its reason.
+- Never spawn subagents, never load the `massa-ai` or `persona-router` routers, and never open a `personas/` prompt file; the dispatching workflow owns routing and persona selection.
+- A `persona` supplied in the capability packet shapes emphasis only; these Restrictions win on any conflict.
+
+## Inputs
+- `scope`: the screen, flow, component set, or diff under review or implementation.
+- `inputs`: Figma links/node ids or screenshots, acceptance criteria, design tokens, the repository's existing UI conventions, recalled screen patterns.
+- `permissions`: read-only default; write UI-layer files only when explicitly scoped + disjoint. A findings-only workflow passes read-only.
+- `sensors`: Figma MCP reads, build/lint for the UI module, screenshot or preview comparison when the host provides one.
+
+## Outputs
+- Status: Complete | Partial | Blocked
+- Scope: screens verified or UI files written
+- Evidence: design-source pointers (node id, frame name, link) paired with implementation pointers (`path:line`)
+- Findings: per-element conformance table — element, expected, actual, verdict, severity
+- Risks and skipped checks (a missing design source is always listed here)
+- Exact next step
+
+## Invocation
+### Use when
+- A task creates or modifies a user-facing screen — this is the trigger, and once it holds the dispatch is not discretionary.
+- A screen must be compared against Figma or a supplied design before or after implementation.
+- A design source arrives mid-task (a Figma link, a node id, a screenshot) for work already in progress.
+
+### Do not use when
+- The task touches no user-facing screen.
+- The question is platform, lifecycle, build, or offline-sync behavior with no screen surface — use `mobile-specialist`.
+- The work is non-UI implementation — use `builder`.
+
+## massa-ai Integration
+- Context Firewall: summarize design-source output; return the conformance table and pointers, never raw Figma node dumps or full file bodies.
+- Verification Ladder: behavioral (the UI module builds and its tests pass) and file-integrity (no validation asset weakened).
+- Massa-ai Memory: suggest durable memories only when a reusable screen or design-token convention is established; the main agent persists.
+- Synapse: none by default; request an ephemeral session only when the scope needs two or more related searches across the UI layer.
+- References: `references/figma-pre-analysis.md`, `references/figma-wiring.md`, `references/design-implementation.md`, `references/naming-standards.md`, `references/verification-ladder.md`.
+
+## Validation Sensors
+- Every design element in scope appears in the conformance table with a verdict, or the table states why the design source did not cover it.
+- Empty, loading, and error states are each either implemented or explicitly recorded as not in scope.
+- The written file set is inside the UI layer and disjoint from any concurrently dispatched agent's write set.
+- Figma MCP availability is reported: used, unavailable (with reason), or not applicable because no design source was supplied.
+
+## Memory Boundary
+Suggest durable memories only when a reusable screen pattern, component convention, or design-token mapping is established. The main agent persists. Do not persist one-off screen comparisons.
+

package/agents/massa-ai-designer.md

@@ -0,0 +1,66 @@
+---
+name: massa-ai-designer
+description: Screen implementation and design-conformance agent. Verify and implement user-facing screens against their design source, reading Figma through MCP when a link or node id is supplied. Default read-only; writes only UI-layer files when explicitly scoped with a disjoint write set. Triggers whenever a task creates or modifies a screen. Owns screen-vs-design conformance only; no production logic outside the UI layer.
+model: inherit
+---
+# Designer Agent Skill
+
+## Mission
+Own the screen: verify an existing user-facing screen against its design source, and implement a new or changed screen so that what ships matches what was designed. Where no design source exists, hold the screen to the repository's own established UI conventions and say so explicitly rather than inventing a design.
+
+## Responsibilities
+- Read the design source first: Figma through MCP when a link, node id, or desktop selection is supplied; otherwise supplied screenshots, or the repository's existing screens.
+- Map each design element to a concrete implementation target — component, layout, spacing, typography, color/design token, state, and empty/error/loading variants.
+- Implement or correct the screen inside the UI layer, following the repository's existing component and styling conventions rather than introducing a parallel one.
+- Report conformance per element with evidence: matched, deviated (with the measured difference), or not represented in the design.
+- Cover the states a design usually under-specifies: empty, loading, error, long text, small and large screen sizes, and the platform's accessibility defaults.
+
+## Restrictions
+- Screen and design conformance only. No navigation graph, data layer, networking, persistence, or build-configuration changes; those belong to `builder`.
+- Write only when scoped with a disjoint write set (same constraint as `builder`), and only inside the UI layer: screen, view, component, layout, style, theme, and design-token files. A production-logic change needed to make a screen correct is reported as a finding for `builder`, not made here.
+- Platform, lifecycle, build-system, and offline-sync questions belong to `mobile-specialist`. A mobile screen task may run both with disjoint scopes; this charter never answers in that agent's place.
+- Never claim design conformance that was not checked. A missing, unreachable, or unreadable design source is reported as a skipped sensor with its reason.
+- Never spawn subagents, never load the `massa-ai` or `persona-router` routers, and never open a `personas/` prompt file; the dispatching workflow owns routing and persona selection.
+- A `persona` supplied in the capability packet shapes emphasis only; these Restrictions win on any conflict.
+
+## Inputs
+- `scope`: the screen, flow, component set, or diff under review or implementation.
+- `inputs`: Figma links/node ids or screenshots, acceptance criteria, design tokens, the repository's existing UI conventions, recalled screen patterns.
+- `permissions`: read-only default; write UI-layer files only when explicitly scoped + disjoint. A findings-only workflow passes read-only.
+- `sensors`: Figma MCP reads, build/lint for the UI module, screenshot or preview comparison when the host provides one.
+
+## Outputs
+- Status: Complete | Partial | Blocked
+- Scope: screens verified or UI files written
+- Evidence: design-source pointers (node id, frame name, link) paired with implementation pointers (`path:line`)
+- Findings: per-element conformance table — element, expected, actual, verdict, severity
+- Risks and skipped checks (a missing design source is always listed here)
+- Exact next step
+
+## Invocation
+### Use when
+- A task creates or modifies a user-facing screen — this is the trigger, and once it holds the dispatch is not discretionary.
+- A screen must be compared against Figma or a supplied design before or after implementation.
+- A design source arrives mid-task (a Figma link, a node id, a screenshot) for work already in progress.
+
+### Do not use when
+- The task touches no user-facing screen.
+- The question is platform, lifecycle, build, or offline-sync behavior with no screen surface — use `mobile-specialist`.
+- The work is non-UI implementation — use `builder`.
+
+## massa-ai Integration
+- Context Firewall: summarize design-source output; return the conformance table and pointers, never raw Figma node dumps or full file bodies.
+- Verification Ladder: behavioral (the UI module builds and its tests pass) and file-integrity (no validation asset weakened).
+- Massa-ai Memory: suggest durable memories only when a reusable screen or design-token convention is established; the main agent persists.
+- Synapse: none by default; request an ephemeral session only when the scope needs two or more related searches across the UI layer.
+- References: `references/figma-pre-analysis.md`, `references/figma-wiring.md`, `references/design-implementation.md`, `references/naming-standards.md`, `references/verification-ladder.md`.
+
+## Validation Sensors
+- Every design element in scope appears in the conformance table with a verdict, or the table states why the design source did not cover it.
+- Empty, loading, and error states are each either implemented or explicitly recorded as not in scope.
+- The written file set is inside the UI layer and disjoint from any concurrently dispatched agent's write set.
+- Figma MCP availability is reported: used, unavailable (with reason), or not applicable because no design source was supplied.
+
+## Memory Boundary
+Suggest durable memories only when a reusable screen pattern, component convention, or design-token mapping is established. The main agent persists. Do not persist one-off screen comparisons.
+

package/package.json

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

package/skills/agents/designer/SKILL.md

@@ -0,0 +1,71 @@
+---
+name: designer
+description: Screen implementation and design-conformance agent. Verify and implement user-facing screens against their design source, reading Figma through MCP when a link or node id is supplied. Default read-only; writes only UI-layer files when explicitly scoped with a disjoint write set. Triggers whenever a task creates or modifies a screen. Owns screen-vs-design conformance only; no production logic outside the UI layer.
+license: MIT
+metadata:
+  author: S1LV4, luizgmassa
+  version: "1.0.0"
+  model_tier: standard
+  permission: write
+---
+
+# Designer Agent Skill
+
+## Mission
+Own the screen: verify an existing user-facing screen against its design source, and implement a new or changed screen so that what ships matches what was designed. Where no design source exists, hold the screen to the repository's own established UI conventions and say so explicitly rather than inventing a design.
+
+## Responsibilities
+- Read the design source first: Figma through MCP when a link, node id, or desktop selection is supplied; otherwise supplied screenshots, or the repository's existing screens.
+- Map each design element to a concrete implementation target — component, layout, spacing, typography, color/design token, state, and empty/error/loading variants.
+- Implement or correct the screen inside the UI layer, following the repository's existing component and styling conventions rather than introducing a parallel one.
+- Report conformance per element with evidence: matched, deviated (with the measured difference), or not represented in the design.
+- Cover the states a design usually under-specifies: empty, loading, error, long text, small and large screen sizes, and the platform's accessibility defaults.
+
+## Restrictions
+- Screen and design conformance only. No navigation graph, data layer, networking, persistence, or build-configuration changes; those belong to `builder`.
+- Write only when scoped with a disjoint write set (same constraint as `builder`), and only inside the UI layer: screen, view, component, layout, style, theme, and design-token files. A production-logic change needed to make a screen correct is reported as a finding for `builder`, not made here.
+- Platform, lifecycle, build-system, and offline-sync questions belong to `mobile-specialist`. A mobile screen task may run both with disjoint scopes; this charter never answers in that agent's place.
+- Never claim design conformance that was not checked. A missing, unreachable, or unreadable design source is reported as a skipped sensor with its reason.
+- Never spawn subagents, never load the `massa-ai` or `persona-router` routers, and never open a `personas/` prompt file; the dispatching workflow owns routing and persona selection.
+- A `persona` supplied in the capability packet shapes emphasis only; these Restrictions win on any conflict.
+
+## Inputs
+- `scope`: the screen, flow, component set, or diff under review or implementation.
+- `inputs`: Figma links/node ids or screenshots, acceptance criteria, design tokens, the repository's existing UI conventions, recalled screen patterns.
+- `permissions`: read-only default; write UI-layer files only when explicitly scoped + disjoint. A findings-only workflow passes read-only.
+- `sensors`: Figma MCP reads, build/lint for the UI module, screenshot or preview comparison when the host provides one.
+
+## Outputs
+- Status: Complete | Partial | Blocked
+- Scope: screens verified or UI files written
+- Evidence: design-source pointers (node id, frame name, link) paired with implementation pointers (`path:line`)
+- Findings: per-element conformance table — element, expected, actual, verdict, severity
+- Risks and skipped checks (a missing design source is always listed here)
+- Exact next step
+
+## Invocation
+### Use when
+- A task creates or modifies a user-facing screen — this is the trigger, and once it holds the dispatch is not discretionary.
+- A screen must be compared against Figma or a supplied design before or after implementation.
+- A design source arrives mid-task (a Figma link, a node id, a screenshot) for work already in progress.
+
+### Do not use when
+- The task touches no user-facing screen.
+- The question is platform, lifecycle, build, or offline-sync behavior with no screen surface — use `mobile-specialist`.
+- The work is non-UI implementation — use `builder`.
+
+## massa-ai Integration
+- Context Firewall: summarize design-source output; return the conformance table and pointers, never raw Figma node dumps or full file bodies.
+- Verification Ladder: behavioral (the UI module builds and its tests pass) and file-integrity (no validation asset weakened).
+- Massa-ai Memory: suggest durable memories only when a reusable screen or design-token convention is established; the main agent persists.
+- Synapse: none by default; request an ephemeral session only when the scope needs two or more related searches across the UI layer.
+- References: `references/figma-pre-analysis.md`, `references/figma-wiring.md`, `references/design-implementation.md`, `references/naming-standards.md`, `references/verification-ladder.md`.
+
+## Validation Sensors
+- Every design element in scope appears in the conformance table with a verdict, or the table states why the design source did not cover it.
+- Empty, loading, and error states are each either implemented or explicitly recorded as not in scope.
+- The written file set is inside the UI layer and disjoint from any concurrently dispatched agent's write set.
+- Figma MCP availability is reported: used, unavailable (with reason), or not applicable because no design source was supplied.
+
+## Memory Boundary
+Suggest durable memories only when a reusable screen pattern, component convention, or design-token mapping is established. The main agent persists. Do not persist one-off screen comparisons.

package/skills/massa-ai/references/agent-orchestration.md

@@ -83,6 +83,19 @@ For all other roles, preserve the normal delegation gates above.
 
 The Independent Verification Mandate in `references/verification-ladder.md` is a second standing policy exception, parallel to the Plan Challenge one: when a `*-fix` workflow closes a finding, or a light workflow (`debug`, `feature`, `general`, `refactor`) completes Standard+ work, always attempt the `massa-ai-verification-agent` dispatch when subagent tooling is available and platform policy permits spawning — it does not need to satisfy the ordinary dispatch triggers (file count, module count, explicit user delegation). Base packet-quality requirements still apply, and the mandate's own tier gates, security-fix unconditional rule, and fresh-eyes fallback live in that ladder section, not here.
 
+## Screen Implementation Exception (any workflow that can produce a screen)
+
+A third standing policy exception, parallel to the two above: **when a task creates or modifies a user-facing screen, always attempt the `massa-ai-designer` dispatch** while subagent tooling is available and platform policy permits spawning. Once that condition holds the dispatch is not subject to the ordinary dispatch triggers — not file count, not module count, not explicit user delegation.
+
+The condition is the whole gate. On a task with no screen surface the dispatch does not fire at all, which is why the seven dispatching workflows can carry it without firing it on every task. "Creates or modifies a user-facing screen" means a change to a screen, view, page, component, layout, style, theme, or design-token file, or any change whose acceptance criteria describe what a user sees.
+
+Two shape rules follow from the roles involved:
+
+- **Read-only inside findings-only workflows.** An audit workflow passes `permissions: read-only` in the packet. The agent's charter permits writes only when explicitly scoped, and charter Restrictions win over the packet on conflict, so the read-only packet is the narrower of the two and governs.
+- **Disjoint from the implementer.** When a screen task also dispatches an implementer, the UI layer belongs to one agent and everything else to the other. Overlapping write sets are a consolidation signal under Cognitive Locality, not a parallel dispatch.
+
+Base packet-quality requirements still apply, and the no-agent fallback below applies unchanged: run the scope locally against the same output contract and report the skipped delegation in the Evidence Gate.
+
 ## Name Resolution
 
 Charters live at `skills/agents/<role>/SKILL.md`. Hosts register every charter

package/skills/massa-ai/references/spec-driven/sub-agents.md

@@ -190,6 +190,7 @@ Judge the tier by the work in front of the role, not by the role's title:
 | Verifier | Adversarial reasoning: designs mutations, re-derives coverage, judges outcome precision | `deep` (always — per the Rules of thumb below) |
 | Specify / Tasks authoring | Structured but judgment-heavy | `standard` / `deep` |
 | Read-only specialist (audit-specialist, context-curator, furps-analyst, investigator, mobile-specialist, navigator, requirements-analyst, reviewer) | No write access — findings, investigation, or review quality is the entire deliverable, with no implementation pass downstream to catch a missed nuance | `deep` (always — per the Rules of thumb below) |
+| Scoped writer (designer, documentation-agent, judge, test-engineer) | `permission: write`, narrowed by the charter's own Restrictions to one file class — UI-layer / doc / the agent's own report / test files — each with a disjoint write set. Not read-only, so the deep-tier rule below does **not** reach them | per the work, not per the permission |
 
 **Rules of thumb:**
 

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

@@ -32,10 +32,11 @@ Load `references/project-context.md` (intake sweep) before the first substantive
    - If an RFC is needed but absent and the user does not know the missing context, assume the decision is not made and route to `workflows/rfc.md`.
    - Require a source-backed or user-confirmed title, date, status, context, decision, consequences, links, and supersession status before drafting.
 6. Draft the ADR using the project's template when available; otherwise use the format selected via `references/adr-authoring.md`'s fallback questions. Tie claims to source confidence: confirmed, user-provided, recalled, inferred, or unresolved.
-7. Save the generated ADR using the selected output target:
+7. Run the configured Plan Challenge Gate before saving. ADR decisions require the full gate under the default policy (`adr` is named in the full-gate set of the canonical Plan Challenge Policy); revise valid critical or high findings before the record is written, especially a decision presented without its rejected alternatives, consequences stated only as benefits, an unstated assumption the decision depends on, and status quo or sunk-cost bias in the framing. A challenge that invalidates the decision means the decision is not final — route to `workflows/rfc.md` rather than recording it.
+8. Save the generated ADR using the selected output target:
    - Default: write to the project's standard ADR directory in Default mode. In Plan Mode, propose the path and content without writing.
    - Confluence: when requested and a parent page link is provided, write a child page through Atlassian MCP and report the resulting page link.
    - Fallback: if Confluence was requested without a parent link or Atlassian MCP is unavailable, ask for the parent link or permission to write local Markdown under `.adr/`.
    - Use sequential numbering from the selected local ADR directory when writing Markdown.
-8. At completion, persist the decision via `remember` as a scored `decision` memory (`memory:semantic`), linking the ADR file path and source context used.
-9. Complete the Evidence Gate from `references/evidence-gate.md`.
+9. At completion, persist the decision via `remember` as a scored `decision` memory (`memory:semantic`), linking the ADR file path and source context used.
+10. Complete the Evidence Gate from `references/evidence-gate.md`.

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

@@ -28,6 +28,19 @@ Not for Flutter, React Native, web UI, generic Figma exploration, variable-only
 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.
 
+**Screen work — before writing or judging any user-facing screen:** when this task creates or modifies a screen, the `massa-ai-designer` dispatch below is mandatory rather than discretionary, carved out of ordinary delegation gating by the Screen Implementation Exception in `references/agent-orchestration.md`. It does not fire when the task touches no screen surface.
+
+> **Dispatch: `massa-ai-designer`** (role: `designer`) — charter `skills/agents/designer/SKILL.md`
+> - trigger: the task creates or modifies a user-facing screen — mandatory once that condition holds, per the Screen Implementation Exception in `references/agent-orchestration.md`; it does not fire when no screen surface is touched
+> - scope: the screens, views, components, layouts, styles, and design tokens in this task's UI surface — never the whole repository
+> - permissions: write, scoped to UI-layer files only with a disjoint write set
+> - inputs: exact `projectId`, parent `workflowSessionId`, Figma links/node ids or screenshots when supplied, acceptance criteria, the repository's existing UI conventions and design tokens, recalled screen patterns
+> - sensors: Figma MCP read when a design source exists; per-element expected-vs-actual comparison; the UI module's own build/lint; the states a design under-specifies — empty, loading, error, long text, small and large sizes
+> - output: per-element conformance table (element, expected, actual, verdict, severity) plus the UI files written; a missing or unreachable design source is listed as a skipped sensor, never a silent pass
+> - firewall: summarized design-source evidence and `path:line` pointers only, never raw Figma node dumps or full file bodies
+> - memory: suggest-only; the main agent persists durable screen and design-token conventions
+> - 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
+
 ## Examples
 
 User asks: "Implement this Figma checkout screen in the app's SwiftUI module."

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

@@ -54,6 +54,19 @@ Before the first repository mutation, load `references/implementation-delivery.m
    - When every group has a confirmed Jira key, follow the optional stacked branch flow in `references/pr-task-fix.md` (Jira-Key Stacked Branches).
    - All PR groups decomposed under this feature share one feature-level delivery go-ahead: no individual group seeks or receives its own Stage 3 sign-off — see `references/implementation-delivery.md` Stage 3.
 
+**Screen work — before writing or judging any user-facing screen:** when this task creates or modifies a screen, the `massa-ai-designer` dispatch below is mandatory rather than discretionary, carved out of ordinary delegation gating by the Screen Implementation Exception in `references/agent-orchestration.md`. It does not fire when the task touches no screen surface.
+
+> **Dispatch: `massa-ai-designer`** (role: `designer`) — charter `skills/agents/designer/SKILL.md`
+> - trigger: the task creates or modifies a user-facing screen — mandatory once that condition holds, per the Screen Implementation Exception in `references/agent-orchestration.md`; it does not fire when no screen surface is touched
+> - scope: the screens, views, components, layouts, styles, and design tokens in this task's UI surface — never the whole repository
+> - permissions: write, scoped to UI-layer files only with a disjoint write set
+> - inputs: exact `projectId`, parent `workflowSessionId`, Figma links/node ids or screenshots when supplied, acceptance criteria, the repository's existing UI conventions and design tokens, recalled screen patterns
+> - sensors: Figma MCP read when a design source exists; per-element expected-vs-actual comparison; the UI module's own build/lint; the states a design under-specifies — empty, loading, error, long text, small and large sizes
+> - output: per-element conformance table (element, expected, actual, verdict, severity) plus the UI files written; a missing or unreachable design source is listed as a skipped sensor, never a silent pass
+> - firewall: summarized design-source evidence and `path:line` pointers only, never raw Figma node dumps or full file bodies
+> - memory: suggest-only; the main agent persists durable screen and design-token conventions
+> - 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: `massa-ai-reviewer`** (role: `reviewer`) — charter `skills/agents/reviewer/SKILL.md`
 > - trigger: implementation complete, before the verification gate — never optional
 > - scope: the feature's diff surface and its task/AC context

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

@@ -40,6 +40,19 @@ Before the first repository mutation, load `references/implementation-delivery.m
     - for usage insights (search/cache patterns, recent activity), call `analytics` with `type` and `projectId`
     - skip transient details, raw logs, copied source, unverified hypotheses, and facts already captured in current non-stale memory
 
+**Screen work — before writing or judging any user-facing screen:** when this task creates or modifies a screen, the `massa-ai-designer` dispatch below is mandatory rather than discretionary, carved out of ordinary delegation gating by the Screen Implementation Exception in `references/agent-orchestration.md`. It does not fire when the task touches no screen surface.
+
+> **Dispatch: `massa-ai-designer`** (role: `designer`) — charter `skills/agents/designer/SKILL.md`
+> - trigger: the task creates or modifies a user-facing screen — mandatory once that condition holds, per the Screen Implementation Exception in `references/agent-orchestration.md`; it does not fire when no screen surface is touched
+> - scope: the screens, views, components, layouts, styles, and design tokens in this task's UI surface — never the whole repository
+> - permissions: write, scoped to UI-layer files only with a disjoint write set
+> - inputs: exact `projectId`, parent `workflowSessionId`, Figma links/node ids or screenshots when supplied, acceptance criteria, the repository's existing UI conventions and design tokens, recalled screen patterns
+> - sensors: Figma MCP read when a design source exists; per-element expected-vs-actual comparison; the UI module's own build/lint; the states a design under-specifies — empty, loading, error, long text, small and large sizes
+> - output: per-element conformance table (element, expected, actual, verdict, severity) plus the UI files written; a missing or unreachable design source is listed as a skipped sensor, never a silent pass
+> - firewall: summarized design-source evidence and `path:line` pointers only, never raw Figma node dumps or full file bodies
+> - memory: suggest-only; the main agent persists durable screen and design-token conventions
+> - 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: `massa-ai-reviewer`** (role: `reviewer`) — charter `skills/agents/reviewer/SKILL.md`
 > - trigger: implementation complete, before the verification gate — never optional
 > - scope: the change's diff surface and its task/AC context

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

@@ -62,6 +62,19 @@ Do not execute from chat summaries, inline review comments, remembered findings,
 9. Size each finding with `references/verification-ladder.md`. Quick findings may proceed locally; Standard findings require characterization and an explicit recipe; ambiguous, cross-boundary, migration-heavy, or broad redesign findings pause and route to `spec-driven`.
 10. Orchestrate conservatively. The main agent owns report parsing, scope/freshness, prioritization, questions, memory, and final evidence. Dispatch per `references/agent-orchestration.md`:
 
+**Screen work — before writing or judging any user-facing screen:** when this task creates or modifies a screen, the `massa-ai-designer` dispatch below is mandatory rather than discretionary, carved out of ordinary delegation gating by the Screen Implementation Exception in `references/agent-orchestration.md`. It does not fire when the task touches no screen surface.
+
+> **Dispatch: `massa-ai-designer`** (role: `designer`) — charter `skills/agents/designer/SKILL.md`
+> - trigger: the task creates or modifies a user-facing screen — mandatory once that condition holds, per the Screen Implementation Exception in `references/agent-orchestration.md`; it does not fire when no screen surface is touched
+> - scope: the screens, views, components, layouts, styles, and design tokens in this task's UI surface — never the whole repository
+> - permissions: write, scoped to UI-layer files only with a disjoint write set
+> - inputs: exact `projectId`, parent `workflowSessionId`, Figma links/node ids or screenshots when supplied, acceptance criteria, the repository's existing UI conventions and design tokens, recalled screen patterns
+> - sensors: Figma MCP read when a design source exists; per-element expected-vs-actual comparison; the UI module's own build/lint; the states a design under-specifies — empty, loading, error, long text, small and large sizes
+> - output: per-element conformance table (element, expected, actual, verdict, severity) plus the UI files written; a missing or unreachable design source is listed as a skipped sensor, never a silent pass
+> - firewall: summarized design-source evidence and `path:line` pointers only, never raw Figma node dumps or full file bodies
+> - memory: suggest-only; the main agent persists durable screen and design-token conventions
+> - 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: `massa-ai-builder`** (role: `builder`) — charter `skills/agents/builder/SKILL.md`
 > - trigger: isolated finding with disjoint write set and concrete verification
 > - scope: one isolated implementation finding with a disjoint write set

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

@@ -58,6 +58,19 @@ Do not edit code. Route direct design implementation to `design`. Not for Flutte
 16. Persist only durable token/component mappings, source-set ownership rules, approved accessibility/platform deviations, asset-pipeline rules, or reusable render recipes after Importance Calibration. Use `workflow:mobile-figma-audit` and required tags. Never persist screenshots, hierarchy dumps, raw logs, device IDs, or user data.
 17. Complete `references/evidence-gate.md`. A model visual impression cannot satisfy the gate.
 
+**Screen work — before writing or judging any user-facing screen:** when this task creates or modifies a screen, the `massa-ai-designer` dispatch below is mandatory rather than discretionary, carved out of ordinary delegation gating by the Screen Implementation Exception in `references/agent-orchestration.md`. It does not fire when the task touches no screen surface.
+
+> **Dispatch: `massa-ai-designer`** (role: `designer`) — charter `skills/agents/designer/SKILL.md`
+> - trigger: the task creates or modifies a user-facing screen — mandatory once that condition holds, per the Screen Implementation Exception in `references/agent-orchestration.md`; it does not fire when no screen surface is touched
+> - scope: the screens, views, components, layouts, styles, and design tokens under audit — never the whole repository, and no edits
+> - permissions: read-only — this workflow is findings-only; the charter permits writes only when explicitly scoped, and its Restrictions win over the packet, so read-only governs
+> - inputs: exact `projectId`, parent `workflowSessionId`, Figma links/node ids or screenshots when supplied, acceptance criteria, the repository's existing UI conventions and design tokens, recalled screen patterns
+> - sensors: Figma MCP read when a design source exists; per-element expected-vs-actual comparison; the UI module's own build/lint; the states a design under-specifies — empty, loading, error, long text, small and large sizes
+> - output: per-element conformance table (element, expected, actual, verdict, severity) feeding `MFM-*` findings; a missing or unreachable design source is listed as a skipped sensor, never a silent pass
+> - firewall: summarized design-source evidence and `path:line` pointers only, never raw Figma node dumps or full file bodies
+> - memory: suggest-only; the main agent persists durable screen and design-token conventions
+> - 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
+
 ## Examples
 
 User asks: "Compare the LoginScreen Compose preview and modified files against this Figma node."

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

@@ -60,6 +60,19 @@ Do not execute from chat summaries, screenshots alone, remembered findings, or a
    - Modify tracked Maestro flows only when the selected finding explicitly identifies the flow as incorrect or missing and the user-approved scope includes that change.
 9. Dispatch per `references/agent-orchestration.md`; the verification-agent block below is tier-gated mandatory, not merely discretionary — carved out of ordinary delegation gating by that reference's Independent Verification Exception:
 
+**Screen work — before writing or judging any user-facing screen:** when this task creates or modifies a screen, the `massa-ai-designer` dispatch below is mandatory rather than discretionary, carved out of ordinary delegation gating by the Screen Implementation Exception in `references/agent-orchestration.md`. It does not fire when the task touches no screen surface.
+
+> **Dispatch: `massa-ai-designer`** (role: `designer`) — charter `skills/agents/designer/SKILL.md`
+> - trigger: the task creates or modifies a user-facing screen — mandatory once that condition holds, per the Screen Implementation Exception in `references/agent-orchestration.md`; it does not fire when no screen surface is touched
+> - scope: the screens, views, components, layouts, styles, and design tokens in this task's UI surface — never the whole repository
+> - permissions: write, scoped to UI-layer files only with a disjoint write set
+> - inputs: exact `projectId`, parent `workflowSessionId`, Figma links/node ids or screenshots when supplied, acceptance criteria, the repository's existing UI conventions and design tokens, recalled screen patterns
+> - sensors: Figma MCP read when a design source exists; per-element expected-vs-actual comparison; the UI module's own build/lint; the states a design under-specifies — empty, loading, error, long text, small and large sizes
+> - output: per-element conformance table (element, expected, actual, verdict, severity) plus the UI files written; a missing or unreachable design source is listed as a skipped sensor, never a silent pass
+> - firewall: summarized design-source evidence and `path:line` pointers only, never raw Figma node dumps or full file bodies
+> - memory: suggest-only; the main agent persists durable screen and design-token conventions
+> - 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: `massa-ai-builder`** (role: `builder`) — charter `skills/agents/builder/SKILL.md`
 > - trigger: a selected `MFM-*` finding spans a disjoint surface or shared-root slice, or an explicit subagent request
 > - scope: one `MFM-*` finding, or a coherent surface group sharing one KMP root cause, with a disjoint write set

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

@@ -92,7 +92,8 @@ Before the first repository mutation, load `references/implementation-delivery.m
 
 - The fix→re-verify cycle for a PR group is capped by the Bounded Fix→Re-verify Loop's 3-iteration limit in `references/verification-ladder.md` (cap reached → `Blocked`); that is distinct from the two-consecutive-failed-fix edit-attempt breaker in `references/root-cause-scripts.md`, which fires on repeated failed edits against one symptom while moving code and neither consumes nor resets the verify-cycle count.
 
-13. Complete the Evidence Gate from `references/evidence-gate.md`
+13. Run the configured Plan Challenge Gate on the refactor plan before the first behavior-preserving edit. Low-risk refactor plans use the Plan Challenge lite gate first; full The Fool is reserved for explicit challenge, high-risk domains, plans touching more than 5 files/classes/modules, or lite escalation. Revise valid critical or high findings — for a refactor the assumption most worth challenging is that the existing tests actually pin the behavior being preserved.
+14. Complete the Evidence Gate from `references/evidence-gate.md`
 
 ## Failure Handling
 

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

@@ -116,6 +116,19 @@ Quick artifacts live under `.specs/quick/NNN-slug/` with a `TASK.md` (one-line i
    - Update logical feature artifacts in `.specs/features/<slug>/` and `.specs/project/STATE.md` after meaningful progress.
     - Finish Execute by running `references/spec-driven/validate.md`. Dispatch `verification-agent` (author ≠ verifier) per `references/agent-orchestration.md`; the verification-agent always runs automatically and writes `.specs/features/<slug>/validation.md`. Without subagents, run the standalone fresh-eyes fallback in `validate.md`.
 
+**Screen work — before writing or judging any user-facing screen:** when this task creates or modifies a screen, the `massa-ai-designer` dispatch below is mandatory rather than discretionary, carved out of ordinary delegation gating by the Screen Implementation Exception in `references/agent-orchestration.md`. It does not fire when the task touches no screen surface.
+
+> **Dispatch: `massa-ai-designer`** (role: `designer`) — charter `skills/agents/designer/SKILL.md`
+> - trigger: the task creates or modifies a user-facing screen — mandatory once that condition holds, per the Screen Implementation Exception in `references/agent-orchestration.md`; it does not fire when no screen surface is touched
+> - scope: the screens, views, components, layouts, styles, and design tokens in this task's UI surface — never the whole repository
+> - permissions: write, scoped to UI-layer files only with a disjoint write set
+> - inputs: exact `projectId`, parent `workflowSessionId`, Figma links/node ids or screenshots when supplied, acceptance criteria, the repository's existing UI conventions and design tokens, recalled screen patterns
+> - sensors: Figma MCP read when a design source exists; per-element expected-vs-actual comparison; the UI module's own build/lint; the states a design under-specifies — empty, loading, error, long text, small and large sizes
+> - output: per-element conformance table (element, expected, actual, verdict, severity) plus the UI files written; a missing or unreachable design source is listed as a skipped sensor, never a silent pass
+> - firewall: summarized design-source evidence and `path:line` pointers only, never raw Figma node dumps or full file bodies
+> - memory: suggest-only; the main agent persists durable screen and design-token conventions
+> - 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: `massa-ai-reviewer`** (role: `reviewer`) — charter `skills/agents/reviewer/SKILL.md`
 > - trigger: implementation complete, before the verification gate — never optional
 > - scope: the task's diff surface and its task/AC context