Analyzes frontend codebase against Ring standards and generates refactoring tasks
for ring:dev-cycle-frontend. Dispatches frontend-specific agents in ANALYSIS mode.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
Analyzes frontend codebase against Ring standards and generates refactoring tasks
for ring:dev-cycle-frontend. Dispatches frontend-specific agents in ANALYSIS mode.
trigger
- User wants to refactor existing frontend project to follow standards
- Legacy React/Next.js codebase needs modernization
- Frontend project audit requested
skip_when
- Greenfield project -> Use /ring:pre-dev-* instead
- Single file fix -> Use ring:dev-cycle-frontend directly
- Backend-only project -> Use ring:dev-refactor instead
{"required":[],"optional":[{"name":"project_path","type":"string","description":"Path to frontend project root (default: current directory)"},{"name":"prompt","type":"string","description":"Direct instruction for refactoring focus"},{"name":"standards_path","type":"string","description":"Custom standards file path (default: Ring standards via WebFetch)"},{"name":"analyze_only","type":"boolean","description":"Generate report without executing ring:dev-cycle-frontend"},{"name":"critical_only","type":"boolean","description":"Limit execution to Critical and High severity (analysis still tracks all)"},{"name":"dry_run","type":"boolean","description":"Show what would be analyzed without executing"}]}
output_schema
{"format":"markdown","artifacts":[{"name":"codebase-report.md","description":"Codebase analysis from ring:codebase-explorer"},{"name":"reports/{agent-name}-report.md","description":"Individual agent analysis reports"},{"name":"findings.md","description":"All findings mapped from agent reports"},{"name":"tasks.md","description":"1:1 mapped REFACTOR-XXX tasks from findings"},{"name":"change-report.html","description":"Visual HTML change report from ring:visual-explainer"}],"traceability":"Ring Standard -> Agent Report -> FINDING-XXX -> REFACTOR-XXX -> Implementation"}
Dev Refactor Frontend Skill
Analyzes existing frontend codebase against Ring/Lerian standards and generates refactoring tasks compatible with ring:dev-cycle-frontend.
Standards Loading (MANDATORY)
Before any step execution, you MUST load Ring standards.
Standards Source Resolution
if standards_path is provided:
→ Read tool: {standards_path}
→ If file not found or empty: STOP and report blocker
→ Use loaded content as frontend standards
else:
→ WebFetch the default Ring standards (see URLs below)
Default URLs (used when standards_path is not provided):
COUNT(non-checkmark items in all Standards Coverage Tables) == COUNT(FINDING-XXX entries)
If counts don't match -> SKILL FAILURE. Go back and add missing findings.
Severity Calibration
Severity
Criteria
Examples
CRITICAL
Security risk, accessibility legal issue, production blocker
Missing server components, Lighthouse < 80, wrong pattern
MEDIUM
Code quality, component structure issues
Client component overuse, missing snapshots
LOW
Best practices, documentation
Naming conventions, file organization
All severities are MANDATORY to track. Severity affects PRIORITY of execution, NOT whether to track.
Architecture Pattern Applicability
Not all architecture patterns apply to all frontend projects. Before flagging gaps, verify the pattern is applicable.
Service Type
Component Architecture
Directory Structure
Full React/Next.js App
APPLY (App Router, Server/Client components)
APPLY (frontend.md section 11)
Design System Library
APPLY
APPLY
Landing Page / Static
PARTIAL
APPLY
Utility / Config Package
NOT APPLICABLE
NOT APPLICABLE
Detection Criteria
Full React/Next.js App (Frontend Standards APPLICABLE):
Project uses React/Next.js as framework
Contains components, pages, and state management
Uses App Router or Pages Router
Has frontend routing and navigation
-> MUST follow frontend.md standards
Simple Frontend (Partial applicability):
Landing pages with minimal interactivity
Static site generators (no dynamic data)
-> Apply directory structure and styling; skip state management, BFF patterns
Agent Instruction
When dispatching specialist agents, include:
ARCHITECTURE APPLICABILITY CHECK:
1. If project is a full React/Next.js app -> APPLY all frontend.md sections
2. If project is a static/landing page -> APPLY directory structure and styling only
3. If project is a utility package -> Do not flag frontend-specific gaps
MANDATORY: Initialize Todo List FIRST
Before any other action, create the todo list with all steps:
TodoWrite:todos:-content:"Validate PROJECT_RULES.md exists"status:"pending"activeForm:"Validating PROJECT_RULES.md exists"-content:"Detect frontend stack and UI library mode"status:"pending"activeForm:"Detecting frontend stack"-content:"Read PROJECT_RULES.md for context"status:"pending"activeForm:"Reading PROJECT_RULES.md"-content:"Generate codebase report via ring:codebase-explorer"status:"pending"activeForm:"Generating codebase report"-content:"Dispatch frontend specialist agents in parallel"status:"pending"activeForm:"Dispatching frontend specialist agents"-content:"Save individual agent reports"status:"pending"activeForm:"Saving agent reports"-content:"Map agent findings to FINDING-XXX entries"status:"pending"activeForm:"Mapping agent findings"-content:"Generate findings.md"status:"pending"activeForm:"Generating findings.md"-content:"Map findings 1:1 to REFACTOR-XXX tasks"status:"pending"activeForm:"Mapping findings to tasks (1:1)"-content:"Generate tasks.md"status:"pending"activeForm:"Generating tasks.md"-content:"Generate visual change report"status:"pending"activeForm:"Generating visual change report"-content:"Get user approval"status:"pending"activeForm:"Getting user approval"-content:"Save all artifacts"status:"pending"activeForm:"Saving artifacts"-content:"Handoff to ring:dev-cycle-frontend"status:"pending"activeForm:"Handing off to ring:dev-cycle-frontend"
This is NON-NEGOTIABLE. Do not skip creating the todo list.
Input Flags: Early Exit Check
if dry_run == true:
→ Execute Step 1 (Validate PROJECT_RULES.md) and Step 1b (Detect Frontend Stack)
→ Output dry-run summary:
- Project path: {project_path or current directory}
- Standards source: {standards_path or "Ring defaults via WebFetch"}
- Frontend stack detected: {React/Next.js version}
- UI library mode: {sindarian-ui / fallback-only}
- Agents that would be dispatched: {list of 5-7 agents}
- Conditional agents: {BFF if detected, UI Engineer if ux-criteria.md exists}
- Artifact path: docs/ring:dev-refactor-frontend/{timestamp}/
→ Mark all remaining todos as `completed` (skipped - dry run)
→ TERMINATE with "Dry run complete. Re-run without --dry-run to execute."
Summary: You orchestrate. Agents execute. If using Bash/Grep/Read to analyze code, STOP. Dispatch agent.
Step 1: Validate PROJECT_RULES.md
TodoWrite: Mark "Validate PROJECT_RULES.md exists" as in_progress
<block_condition>
docs/PROJECT_RULES.md does not exist
</block_condition>
If condition is true, output blocker and TERMINATE. Otherwise continue to Step 1b.
Check: Does docs/PROJECT_RULES.md exist?
YES -> Mark todo as completed, continue to Step 1b
NO -> Output blocker and TERMINATE:
## BLOCKED: PROJECT_RULES.md Not Found
Cannot proceed without project standards baseline.
**Required Action:** Create `docs/PROJECT_RULES.md` with:- Architecture patterns
- Code conventions
- Testing requirements
- Technology stack decisions
Re-run after file exists.
Step 1b: Detect Frontend Stack
TodoWrite: Mark "Detect frontend stack and UI library mode" as in_progress
⛔ SCOPE: FRONTEND AND BFF CODE ONLY. This skill analyzes frontend code (React, Next.js) and BFF layers exclusively. MUST use ring:dev-refactor for backend code (Go, pure TypeScript backend with Express/Fastify/NestJS without React).
⛔ FORBIDDEN: Dispatching ring:backend-engineer-golang or ring:backend-engineer-typescript from this skill. These are backend agents and belong to ring:dev-refactor.
MANDATORY: Verify this is a frontend project. If not, redirect.
Check for frontend indicators:
Check
Detection
Result
package.json exists
Glob for package.json
Required
React/Next.js in deps
react, next in dependencies
Required for frontend
@lerianstudio/sindarian-ui in deps
Check dependencies/devDependencies
Store ui_library_mode
BFF layer detected
/api/ routes, Express/Fastify in deps
Add ring:frontend-bff-engineer-typescript
ux-criteria.md exists
docs/pre-dev/*/ux-criteria.md
Add ring:ui-engineer
Detection Logic:
1. package.json exists?
NO -> STOP: "Not a Node.js project. Use ring:dev-refactor instead."
YES -> Continue
2. React or Next.js in dependencies?
NO -> STOP: "Not a frontend project. Use ring:dev-refactor instead."
YES -> Continue
3. @lerianstudio/sindarian-ui in dependencies?
YES -> ui_library_mode = "sindarian-ui"
NO -> ui_library_mode = "fallback-only"
4. BFF layer detected? (/api/ routes, Express/Fastify in deps)
YES -> dispatch_bff = true
NO -> dispatch_bff = false
5. ux-criteria.md exists?
YES -> dispatch_ui_engineer = true
NO -> dispatch_ui_engineer = false
TodoWrite: Mark "Detect frontend stack and UI library mode" as completed
Step 2: Read PROJECT_RULES.md
TodoWrite: Mark "Read PROJECT_RULES.md for context" as in_progress
Read tool: docs/PROJECT_RULES.md
Extract project-specific conventions for agent context.
TodoWrite: Mark "Read PROJECT_RULES.md for context" as completed
Step 3: Generate Codebase Report
TodoWrite: Mark "Generate codebase report via ring:codebase-explorer" as in_progress
MANDATORY: Use Task Tool with ring:codebase-explorer
<dispatch_required agent="ring:codebase-explorer">
Generate a comprehensive frontend codebase report describing WHAT EXISTS.
Include:
Project structure and directory layout
React/Next.js architecture (App Router vs Pages Router, Server vs Client components)
TodoWrite: Mark "Generate codebase report via ring:codebase-explorer" as completed
Step 4: Dispatch Frontend Specialist Agents
TodoWrite: Mark "Dispatch frontend specialist agents in parallel" as in_progress
HARD GATE: Verify codebase-report.md Exists
BEFORE dispatching any specialist agent, verify:
Check 1: Does docs/ring:dev-refactor-frontend/{timestamp}/codebase-report.md exist?
- YES -> Continue to dispatch agents
- NO -> STOP. Go back to Step 3.
Check 2: Was codebase-report.md created by ring:codebase-explorer?
- YES -> Continue
- NO (created by Bash output) -> DELETE IT. Go back to Step 3. Use correct agent.
If you skipped Step 3 or used Bash instead of Task tool, you MUST go back and redo Step 3 correctly.
TodoWrite: Mark "Map agent findings to FINDING-XXX entries" as in_progress
MANDATORY: all agent-reported issues MUST become findings.
Agent Report
Action
Any difference between current code and Ring standard
-> Create FINDING-XXX
Any missing pattern from Ring standards
-> Create FINDING-XXX
Any deprecated pattern usage
-> Create FINDING-XXX
Any accessibility gap
-> Create FINDING-XXX
Any testing gap
-> Create FINDING-XXX
Any performance issue
-> Create FINDING-XXX
FORBIDDEN Actions for Step 4.5
Ignoring agent-reported issues because they seem "minor" -> SKILL FAILURE
Filtering out issues based on personal judgment -> SKILL FAILURE
Summarizing multiple issues into one finding -> SKILL FAILURE
Skipping issues without ISSUE-XXX format from agent -> SKILL FAILURE
Creating findings only for "interesting" gaps -> SKILL FAILURE
REQUIRED Actions for Step 4.5
Every line item from agent reports becomes a FINDING-XXX entry
Preserve agent's severity assessment exactly as reported
Include exact file:line references from agent report
Every non-compliant item in Standards Coverage Table = one FINDING-XXX
Count findings in Step 5 MUST equal total issues from all agent reports
Anti-Rationalization Table for Step 4.5
See also: "Anti-Rationalization: Mandatory Gap Principle" at top of this skill.
### FINDING-XXX: [Issue Title] GATE N ESCAPE**Escaped From:** Gate N ({Gate Name})
**Why It Escaped:** [Quality Gate check that should have caught this]
**Prevention:** [Specific check to add to Gate N exit criteria]
[Rest of finding format...]
Purpose: Track which issues escape which gates. If many escapes occur at a gate, that gate's exit criteria need strengthening.
Summary Table (MANDATORY at end of findings.md):
## Gate Escape Summary
| Gate | Escaped Issues | Most Common Type |
|------|----------------|------------------|
| Gate 0 (Implementation) | N | [type] |
| Gate 1 (DevOps) | N | [type] |
| Gate 2 (Accessibility) | N | [type] |
| Gate 3 (Unit Testing) | N | [type] |
| Gate 4 (Visual) | N | [type] |
| Gate 5 (E2E) | N | [type] |
| Gate 6 (Performance) | N | [type] |
| Gate 7 (Review) | N | [type] |
**Action Required:** If any gate has >2 escapes, review that gate's exit criteria.
TodoWrite: Mark "Map agent findings to FINDING-XXX entries" as completed
Step 4.6: Save Individual Agent Reports
TodoWrite: Mark "Save individual agent reports" as in_progress
MANDATORY: Each agent's output MUST be saved as an individual report file.
After all parallel agent tasks complete, save each agent's output to a separate file:
TodoWrite: Mark "Save individual agent reports" as completed
Step 5: Generate findings.md
TodoWrite: Mark "Generate findings.md" as in_progress
HARD GATE: Verify All Issues Are Mapped
BEFORE creating findings.md, apply the Verification Rule from "Mandatory Gap Principle" section.
If counts don't match, STOP. Go back to Step 4.5. Map missing issues.
FORBIDDEN Actions for Step 5
Creating findings.md with fewer entries than agent issues -> SKILL FAILURE
Omitting file:line references from findings -> SKILL FAILURE
Using vague descriptions instead of specific code excerpts -> SKILL FAILURE
Skipping "Why This Matters" section for any finding -> SKILL FAILURE
Generating findings.md without reading all agent reports -> SKILL FAILURE
REQUIRED Actions for Step 5
Every FINDING-XXX includes: Severity, Category, Agent, Standard reference
Every FINDING-XXX includes: Current Code with exact file:line
Every FINDING-XXX includes: Ring Standard Reference with URL
Every FINDING-XXX includes: Required Changes as numbered actions
Every FINDING-XXX includes: Why This Matters with Problem/Standard/Impact
Total finding count MUST match total issues from Step 4.5
Anti-Rationalization Table for Step 5
Rationalization
Why It's WRONG
Required Action
"I'll add details later during implementation"
findings.md is the source of truth. Incomplete = useless.
Complete all sections for every finding
"Code snippet is too long to include"
Truncate to relevant lines, but never omit. Context is required.
Include code with file:line reference
"Standard URL is obvious, skip it"
Agents and humans need direct links. Nothing is obvious.
Include full URL for every standard
"Why This Matters is redundant"
It explains business impact. Standards alone don't convey urgency.
Write Problem/Standard/Impact for all
"Some findings are self-explanatory"
Self-explanatory to you is not clear to implementer.
Complete all sections without exception
"I'll group small findings together"
Each finding = one task in Step 6. findings.md = atomic issues.
One finding = one FINDING-XXX entry
Use Write tool to create findings.md:
CRITICAL: Every issue reported by agents in Step 4 MUST appear here as a FINDING-XXX entry.
# Findings: {project-name}**Generated:** {timestamp}
**Total Findings:** {count}
**UI Library Mode:** {ui_library_mode}
## Mandatory Gap Principle Applied**all divergences from Ring standards are tracked below. No filtering applied.**
| Metric | Count |
|--------|-------|
| Total non-compliant items from agent reports | {X} |
| Total FINDING-XXX entries below | {X} |
| **Counts match?** | YES (REQUIRED) |
**Severity does not affect tracking - all gaps are mandatory:**
| Severity | Count | Priority | Tracking |
|----------|-------|----------|----------|
| Critical | {N} | Execute first | **MANDATORY** |
| High | {N} | Execute in current sprint | **MANDATORY** |
| Medium | {N} | Execute in next sprint | **MANDATORY** |
| Low | {N} | Execute when capacity | **MANDATORY** |
---
## FINDING-001: {Pattern Name}**Severity:** Critical | High | Medium | Low (all MANDATORY)
**Category:** {component-architecture | ui-library | styling | accessibility | testing | performance | devops}
**Agent:** {agent-name}
**Standard:** {file}.md:{section}
### Current Code```{lang}
// file: {path}:{lines}
{actual code}
Standard Violated: {specific section from Ring standards}
Impact: {business/technical impact if not fixed}
FINDING-002: ...
**TodoWrite:** Mark "Generate findings.md" as `completed`
---
## Step 6: Map Findings to Tasks (1:1)
**TodoWrite:** Mark "Map findings 1:1 to REFACTOR-XXX tasks" as `in_progress`
**HARD GATE: One FINDING-XXX = One REFACTOR-XXX task. No grouping.**
Each finding becomes its own task. This prevents findings from being lost inside grouped tasks.
**1:1 Mapping Rule:**
- FINDING-001 -> REFACTOR-001
- FINDING-002 -> REFACTOR-002
- FINDING-NNN -> REFACTOR-NNN
**Ordering:** Sort tasks by severity (Critical first), then by dependency order.
**Mapping Verification:**
Before proceeding to Step 7, verify:
Total FINDING-XXX in findings.md: X
Total REFACTOR-XXX in tasks.md: X (MUST MATCH exactly)
Orphan findings (not mapped): 0 (MUST BE ZERO)
Grouped tasks (multiple findings): 0 (MUST BE ZERO)
**If counts don't match, STOP. Every finding MUST have its own task.**
### Anti-Rationalization Table for Step 6
| Rationalization | Why It's WRONG | Required Action |
|-----------------|----------------|-----------------|
| "These findings are in the same file, I'll group them" | Grouping hides findings. One fix may be done, others forgotten. | **One finding = One task. No exceptions.** |
| "Grouping reduces task count and is easier to manage" | Fewer tasks = less visibility. Each finding needs independent tracking. | **Create one REFACTOR-XXX per FINDING-XXX** |
| "These are related and should be fixed together" | Related is not same task. ring:dev-cycle-frontend can execute them sequentially. | **Separate tasks, use Dependencies field to link** |
| "Too many tasks will overwhelm the developer" | Missing fixes overwhelms production. Completeness > convenience. | **Create all tasks. Priority handles ordering.** |
**TodoWrite:** Mark "Map findings 1:1 to REFACTOR-XXX tasks" as `completed`
---
## Step 7: Generate tasks.md
**TodoWrite:** Mark "Generate tasks.md" as `in_progress`
**Use Write tool to create tasks.md:**
```markdown
# Refactoring Tasks: {project-name}
**Source:** findings.md
**Total Tasks:** {count}
**UI Library Mode:** {ui_library_mode}
## Mandatory 1:1 Mapping Verification
**Every FINDING-XXX has exactly one REFACTOR-XXX. No grouping.**
| Metric | Count |
|--------|-------|
| Total FINDING-XXX in findings.md | {X} |
| Total REFACTOR-XXX in tasks.md | {X} |
| **Counts match exactly?** | YES (REQUIRED) |
| Grouped tasks (multiple findings) | 0 (REQUIRED) |
**Priority affects execution order, not whether to include:**
- Critical/High tasks: Execute first
- Medium tasks: Execute in current cycle
- Low tasks: Execute when capacity - STILL MANDATORY TO COMPLETE
---
## REFACTOR-001: {Finding Pattern Name}
**Finding:** FINDING-001
**Severity:** Critical | High | Medium | Low (all ARE MANDATORY)
**Category:** {component-architecture | ui-library | styling | accessibility | testing | performance | devops}
**Agent:** {agent-name}
**Effort:** {hours}h
**Dependencies:** {other REFACTOR-XXX tasks or none}
### Current Code
```{lang}
// file: {path}:{lines}
{actual code from FINDING-001}
**TodoWrite:** Mark "Generate tasks.md" as `completed`
---
## Step 7.5: Visual Change Report
**TodoWrite:** Mark "Generate visual change report" as `in_progress`
**MANDATORY: Generate a visual HTML report before user approval.**
Invokes `Skill("ring:visual-explainer")` to produce a self-contained HTML page showing all planned frontend refactoring changes. This replaces reading raw findings.md / tasks.md markdown for approval decisions.
**Read the code-diff template first:** Read `default/skills/visual-explainer/templates/code-diff.html` to absorb the patterns before generating.
**Generate the HTML report with these sections:**
### 1. Summary Dashboard
- UI Library Mode (from findings.md header)
- Total FINDING-XXX count with severity breakdown (Critical / High / Medium / Low)
- Total files affected (unique file paths from all findings)
- Horizontal severity breakdown bar
### 2. Per-Finding Diff Panels (one section per FINDING-XXX)
For each FINDING-XXX in findings.md:
- **Header:** Finding ID, severity badge, category, agent that reported it
- **Before panel:** Current Code block from findings.md (with file:line reference, syntax highlighted via Highlight.js)
- **After panel:** Ring Standard pattern from Required Changes section (syntax highlighted)
- **Collapsible "Why This Matters":** Problem / Standard Violated / Impact from findings.md
### 3. Task Mapping Table
Table showing: FINDING-XXX → REFACTOR-XXX → Severity → Category → Estimated Effort
**Output:** Save to `docs/ring:dev-refactor-frontend/{timestamp}/change-report.html`
**Open in browser:**
```text
macOS: open docs/ring:dev-refactor-frontend/{timestamp}/change-report.html
Linux: xdg-open docs/ring:dev-refactor-frontend/{timestamp}/change-report.html
Tell the user the file path. The report opens before the approval question so the user can review changes visually.
TodoWrite: Mark "Generate visual change report" as completed
Step 8: User Approval
TodoWrite: Mark "Get user approval" as in_progress
Auto-Resolution via Input Flags
if analyze_only == true:
→ Auto-select "Cancel" (analysis complete, skip execution)
→ Output: "analyze_only=true — analysis artifacts saved, skipping ring:dev-cycle-frontend."
→ Skip to Step 9 (Save Artifacts), then TERMINATE after Step 9.
if critical_only == true:
→ Auto-select "Critical only" (no user prompt needed)
→ Output: "critical_only=true — auto-selecting Critical/High tasks only."
→ Continue to Step 9, then Step 10 with Critical/High tasks.
Interactive Approval (when no auto-resolution flags are set)
<user_decision>
MUST wait for explicit user response before proceeding.
Options: Approve all | Critical only | Cancel
</user_decision>
AskUserQuestion:questions:-question:"Review frontend refactoring plan. How to proceed?"header:"Approval"options:-label:"Approve all"description:"Proceed to ring:dev-cycle-frontend execution"-label:"Critical only"description:"Execute only Critical/High tasks"-label:"Cancel"description:"Keep analysis, skip execution"
CANNOT proceed without explicit user selection (or an auto-resolution flag).
TodoWrite: Mark "Get user approval" as completed
Step 9: Save Artifacts
TodoWrite: Mark "Save all artifacts" as in_progress
TodoWrite: Mark "Handoff to ring:dev-cycle-frontend" as in_progress
Skip Conditions
if analyze_only == true:
→ Output: "analyze_only=true — skipping handoff. Artifacts saved at docs/ring:dev-refactor-frontend/{timestamp}/."
→ Mark todo as `completed`
→ TERMINATE.
if dry_run == true:
→ This step is unreachable (dry_run exits after Step 1b).
if user selected "Cancel" in Step 8:
→ Output: "User cancelled execution. Artifacts saved at docs/ring:dev-refactor-frontend/{timestamp}/."
→ Mark todo as `completed`
→ TERMINATE.
Execution (when user approved or critical_only resolved)
Use Skill tool to invoke ring:dev-cycle-frontend directly:
Context for ring:dev-cycle-frontend:tasks-file:"docs/ring:dev-refactor-frontend/{timestamp}/tasks.md"
Where {timestamp} format is YYYY-MM-DDTHH:MM:SS. Use the same timestamp across all artifacts in a single run.
Anti-Rationalization: Skill Invocation
Rationalization
Why It's WRONG
Required Action
"SlashCommand is equivalent to Skill tool"
SlashCommand is a hint; Skill tool guarantees skill loading
Use Skill tool, not SlashCommand
"User can run /ring:dev-cycle-frontend manually"
Manual run risks skill not being loaded
Invoke Skill tool directly
"ring:dev-cycle-frontend will auto-discover tasks"
Explicit path ensures correct file is used
Pass explicit tasks path
"User approved, I can skip ring:dev-cycle-frontend"
Approval = permission to proceed, not skip execution
Invoke Skill tool
"Tasks are saved, job is done"
Saved tasks without execution = incomplete workflow
Invoke Skill tool
"analyze_only was not set but I'll skip anyway"
Only analyze_only, dry_run, or user "Cancel" can skip this step
Invoke Skill tool
HARD GATE: When execution is approved (user selected "Approve all" or "Critical only", or critical_only auto-resolved), you CANNOT complete ring:dev-refactor-frontend without invoking Skill tool: ring:dev-cycle-frontend.
