@atlashub/smartstack-cli 4.80.0 → 5.0.0

package/templates/skills/apex/steps/step-00-init.md

@@ -1,405 +0,0 @@
----
-name: step-00-init
-description: Parse flags, detect application, verify MCP, define hierarchy (4 levels), challenge the need
-model: sonnet
-next_step: steps/step-01-analyze.md
----
-
-# Step 0: Initialize
-
-**ULTRA THINK about whether this is a NEW module (create from scratch) or an UPDATE to an existing module (add sections/resources/entities to existing code). This distinction drives every downstream decision — especially seed data, permissions, and roles.**
-
-**Before anything else**, display the version banner:
-
-```
-═══════════════════════════════════════════════════════════════
-  SmartStack APEX — v{{SMARTSTACK_VERSION}}
-═══════════════════════════════════════════════════════════════
-```
-
-## LOAD SHARED
-
-Read `_shared.md` for SmartStack detection patterns and MCP tools reference.
-
----
-
-## 1. Parse Flags
-
-Extract flags from input: `-a, -x, -s, -e, -r, -pr, -d {path}, --foundation`
-
-| Flag | Sets | Force |
-|------|------|-------|
-| `-a` | auto_mode | — |
-| `-x` | examine_mode | — |
-| `-s` | save_mode | — |
-| `-e` | economy_mode | — |
-| `-r` | resume_mode | — |
-| `-pr` | pr_mode | — |
-| `-d {path}` | delegate_mode, delegate_prd_path | auto_mode, economy_mode |
-| `--foundation` | foundation_mode | auto_mode |
-
-**Special behaviors:** `-d {path}` enables delegate mode (extract context from PRD). `--foundation` generates ONLY entities + EF configs + migration (domain + infrastructure layers only).
-
----
-
-## 1b. Delegate Mode Fast Path (if -d)
-
-When `-d {prd_path}` is used, extract all context from PRD file and skip sections 2, 4, 5:
-
-**Extract from prd.json:**
-- `{app_name}` = prd.project.application
-- `{module_code}` = prd.project.module
-- `{sections}` = infrastructure tasks → _seedDataMeta.coreSeedData.navigationSections (map to code/label/description/route/displayOrder/navigation)
-- `{entities}` = domain tasks → extract entity names from descriptions
-- `{code_patterns}` = feature.json entity patterns (or [] for heuristic fallback)
-- `{module_complexity}` = heuristic from task count (≤10→"simple-crud", ≤20→"crud-rules", ≤30→"crud-workflow", >30→"complex")
-- `{needs_seed_data}` = any seedData/infrastructure tasks exist
-- `{needs_migration}` = any tasks with _migrationMeta
-- `{has_dependencies}` = prd.tasks.some(t => t.dependencies.length > 0) ? "references" : "none"
-
-**Fallback extraction (if prd.project is absent — e.g. PRD v3.0.0 with metadata format):**
-- `{app_name}` = prd.metadata?.applicationCode || prd.project?.application
-- `{module_code}` = prd.metadata?.moduleCode || prd.project?.module
-- `{entities}` = prd.implementation?.filesToCreate?.domain?.filter(f => f.type === 'Entity').map(f => extractEntityName(f.path)) || domain tasks fallback
-- `{sections}` = prd.implementation?.filesToCreate?.seedData?.filter(f => f.path.includes('NavigationSectionSeedData')).length > 0 ? extractSectionsFromSeedDataPaths(prd) : []
-- `{needs_seed_data}` = (prd.implementation?.filesToCreate?.seedData?.length || 0) > 0
-- `{needs_migration}` = (prd.implementation?.filesToCreate?.infrastructure?.length || 0) > 0
-
-**Specification Files Loading (if prd.specificationFiles present):**
-
-```javascript
-if (prd.specificationFiles) {
-  const specsDir = path.dirname(delegate_prd_path); // .ralph/
-  const specFiles = prd.specificationFiles;
-
-  // Store loading plan for layer-specific consumption
-  specification_loading_plan = {
-    layer0_domain:   [specFiles.entities],
-    layer1_seed:     [specFiles.entities, specFiles.permissions],
-    layer2_backend:  [specFiles.rules, specFiles.usecases],
-    layer3_frontend: [specFiles.screens, specFiles.usecases]
-  };
-
-  // Verify all companion files exist
-  for (const [layer, files] of Object.entries(specification_loading_plan)) {
-    for (const file of files) {
-      const filePath = path.join(specsDir, file);
-      if (!fileExists(filePath)) {
-        console.warn(`WARNING: Companion file missing for ${layer}: ${filePath}`);
-      }
-    }
-  }
-}
-```
-
-Each layer step (step-03a through step-03d) will load its companion files at the start. This provides full BA specifications (entity attributes, BR formulas, UC steps, screen columns) without loading the entire spec corpus.
-
-**PRD Quality Gate (delegate mode — BLOCKING):**
-
-> Validate that PRD file paths are valid C# identifiers BEFORE starting execution.
-> Invalid entity names (French with spaces/apostrophes/accents) cause CS1001 build errors
-> that waste 3+ retry iterations before being correctly classified.
-
-```javascript
-// Extract all file paths from PRD
-const filesToCreate = prd.$version === '4.0.0' ? prd.expectedFiles : prd.implementation?.filesToCreate;
-if (filesToCreate) {
-  const invalidPaths = [];
-  for (const [category, files] of Object.entries(filesToCreate)) {
-    for (const file of (files || [])) {
-      const filePath = file.path || file;
-      // Extract filename (without extension) from path
-      const fileName = filePath.split('/').pop().replace(/\.(cs|tsx|ts|json)$/, '');
-      // Check for illegal characters in C# identifiers
-      if (/[\s'àâäéèêëïîôùûüçÀÂÄÉÈÊËÏÎÔÙÛÜÇ]/.test(fileName)) {
-        invalidPaths.push({ category, path: filePath, fileName });
-      }
-    }
-  }
-
-  if (invalidPaths.length > 0) {
-    console.error('BLOCKING — PRD QUALITY ERROR (not a code error):');
-    console.error('The following file paths contain illegal C# identifier characters:');
-    for (const p of invalidPaths) {
-      console.error(`  ${p.category}: ${p.path} (invalid name: "${p.fileName}")`);
-    }
-    console.error('');
-    console.error('FIX: Re-run /business-analyse-handoff which now includes entity name canonicalization.');
-    console.error('     Or manually fix entity names in the PRD (strip accents, remove spaces/apostrophes, PascalCase).');
-    console.error('');
-    console.error('This is a PRD quality error (Category G), NOT a code generation error.');
-    console.error('Do NOT attempt to generate code from this PRD — it will fail with CS1001.');
-    STOP; // Do not proceed with invalid PRD
-  }
-}
-```
-
-**Jump to:** section 3 (MCP verify) → section 6 (determine needs) → section 9 (summary)
-
----
-
-## 1c. Prompt Precision Guard
-
-> **APEX executes, it does not explore.** If the prompt is too vague, redirect to `/business-analyse`.
-
-**Score the prompt — count how many of these are present or inferable:**
-
-| Element | Example | Weight |
-|---------|---------|--------|
-| Module name/code | "employees", "absence management" | 1 |
-| At least 1 entity name | "Employee", "Absence" | 1 |
-| At least 1 property/field | "FirstName, StartDate, Status" | 1 |
-| Target application | "HR module", "HumanResources" | 0.5 |
-| Section hint | "list", "dashboard", "approval" | 0.5 |
-
-```
-precision_score = sum of weights for elements found in task description
-
-IF precision_score < 2:
-  DISPLAY:
-  ╔══════════════════════════════════════════════════════════════╗
-  ║  ⚠ Prompt too vague for /apex                              ║
-  ║                                                             ║
-  ║  /apex needs precise features to execute in one shot.       ║
-  ║  Your request looks more like a discovery/design task.      ║
-  ║                                                             ║
-  ║  Suggestions:                                               ║
-  ║  1. Use /business-analyse-quick to design your module       ║
-  ║  2. Use /business-analyse for full analysis (40+ questions) ║
-  ║  3. Rewrite your prompt with entities and fields, e.g.:     ║
-  ║     /apex add employees section with Employee entity        ║
-  ║     (FirstName, LastName, Email) to HumanResources module   ║
-  ╚══════════════════════════════════════════════════════════════╝
-  → STOP — do NOT proceed to section 2
-```
-
----
-
-## 2. Detect SmartStack Application
-
-Scan project: Glob("*.sln"), Glob("docs/business/**/*"), Glob(".ralph/prd-*.json"), Glob("src/pages/**/*.tsx")
-
-**Infer from task description:** {app_name}, {module_code}, {sections}
-**From artifacts:** {prd_path} = `.ralph/prd-{module_code}.json` (if exists), {feature_path} = `docs/business/{app}/{module}/business-analyse/*/feature.json` (if exists)
-
-If hierarchy cannot be inferred → load application question from `references/challenge-questions.md`.
-
----
-
-## 3. Verify MCP Availability
-
-```
-Call: mcp__smartstack__validate_conventions (quick connectivity test)
-
-IF success → MCP available, proceed normally
-IF failure → warn user, continue in degraded mode (manual tools only)
-```
-
----
-
-## 4. Define Navigation Hierarchy
-
-Reference `references/challenge-questions.md` for 4-level structure (Application → Module → Section → Resource), validation rules, and challenge questions 4a-4c.
-
-**Hierarchy Summary:** {app_name} ({app_code}) → {module_code} → [{sections[].code}]
-Routes: /{app-kebab}/{module-kebab}/{section-kebab}
-
-**Resources:** OPTIONAL — only define if explicitly mentioned or inferred from task/feature.json (export, import, bulk actions).
-
-### 4f. Naming Derivation Rules (DETERMINISTIC)
-
-All naming variants are derived from {app_name}, {module_code}, {sections}. Do NOT invent names.
-
-| Source | Derivation | Example |
-|--------|-----------|---------|
-| {app_name} | kebab: lowercase, hyphen-separated | `human-resources` |
-| {app_name} | PascalCase | `HumanResources` |
-| {module_code} | already kebab | `employee-management` |
-| {module_code} | PascalCase: remove hyphens, capitalize | `EmployeeManagement` |
-| {sections[].code} | already kebab | `employees` |
-| {sections[].code} | PascalCase | `Employees` |
-| NavRoute | `{app_name_kebab}.{module_code}.{section_code}` (dots) | `human-resources.employee-management.employees` |
-| API route | resolved dynamically by [NavRoute] from DB | N/A |
-| Permission | `{app_name_kebab}.{module_code}.{section_code}.{action}` | `human-resources.employee-management.employees.read` |
-
-Call `mcp__smartstack__validate_conventions` after computing derivations. Fix any errors BEFORE step-01.
-
-### 4g. Entity-Section Mapping (DETERMINISTIC)
-
-> Each entity MUST be mapped to a hierarchy level. This determines the entity's NavRoute segment count
-> (2 vs 3 segments) and whether section-level permissions are needed.
-> **This mapping is consumed by:** step-03b (permissions), step-03c (controllers), step-04 (validation).
-
-**Rules:**
-
-1. The entity whose name derives from `{module_code}` is the **module-level entity**.
-   It gets `NavRoute = {app}.{module}` (2 segments). Its permissions are module-level.
-
-2. Every other entity that matches a section from `{sections}` is a **section-level entity**.
-   It gets `NavRoute = {app}.{module}.{section_code}` (3 segments). Its permissions are section-level.
-
-3. Entities that match NO section stay **module-level** (share the module's NavRoute).
-   This is the case for true sub-resources without their own navigation entry (e.g., InvoiceLine).
-
-**Matching algorithm:**
-
-```
-FOR EACH entity in {entities}:
-  entity_kebab = kebab(pluralize(entity.name))  // "Contact" → "contacts", "Department" → "departments"
-
-  IF entity_kebab == {module_code} OR singularize(entity_kebab) == singularize({module_code}):
-    entity.level = "module"
-    entity.navRoute = "{app_name_kebab}.{module_code}"
-    entity.section_code = null
-
-  ELSE:
-    matched = {sections}.find(s =>
-      s.code == entity_kebab                           // exact: "contacts" == "contacts"
-      OR s.code == singularize(entity_kebab)           // singular: "types" for "AbsenceType"
-      OR s.code.endsWith(entity_kebab)                 // suffix: "absence-types" ends with "types"
-      OR entity_kebab.endsWith(s.code)                 // reverse: "project-members" ends with "members"
-    )
-
-    IF matched:
-      entity.level = "section"
-      entity.navRoute = "{app_name_kebab}.{module_code}.{matched.code}"
-      entity.section_code = matched.code
-    ELSE:
-      entity.level = "module"
-      entity.navRoute = "{app_name_kebab}.{module_code}"
-      entity.section_code = null
-```
-
-**Delegate mode override:** When `permissionPaths` companion includes section-level paths
-(3+ dot segments like `app.module.section.action`), use those paths as authoritative source
-to derive entity-section mapping instead of name heuristics.
-
-**Storage:**
-
-```
-{entity_section_map}: [
-  { entity: "Employee",   level: "module",  navRoute: "rh.employes",              section_code: null },
-  { entity: "Department", level: "section", navRoute: "rh.employes.departments",  section_code: "departments" }
-]
-```
-
-Propagated to: step-03b (permissions), step-03c (controllers), step-03-execute (state), step-04 (validation).
-
-**Post-mapping validation:**
-
-```
-# No duplicate NavRoutes among section-level entities
-section_navroutes = {entity_section_map}.filter(e => e.level == "section").map(e => e.navRoute)
-IF duplicates(section_navroutes) → BLOCKING: two entities mapped to same section
-
-# All section_codes exist in {sections}
-FOR EACH entry in {entity_section_map} WHERE section_code != null:
-  IF {sections}.find(s => s.code == entry.section_code) == null → BLOCKING: orphan section_code
-```
-
----
-
-## 5. Collect Technical Parameters
-
-Rapid technical parameter collection — load and execute questions from `references/challenge-questions.md`:
-- **5a:** Entity scope & relationships
-- **5b:** Dependency auto-detection (NO question — agent scans codebase and infers from {entities})
-- **5b-bis:** Key properties (question kept — user may have specific field requirements)
-- **5c:** Code generation strategy
-
-**Skip 5c if:**
-- `delegate_mode = true` (PRD defines patterns)
-- `foundation_mode = true` (code strategy later)
-- `feature.json` exists AND all entities have `codePattern` defined
-
-**If feature.json covers SOME entities:** Only ask for entities without `codePattern`, merge responses.
-
-**Store responses:**
-```
-{entities}, {module_complexity}, {has_dependencies}, {key_properties}, {code_patterns}
-```
-Propagated to: step-01 (code focus), step-02 (layer mapping), step-03 (scaffolding)
-
----
-
-## 5e. Scope Complexity Guard
-
-**Design:** `/apex` handles 1 module at a time. Use `/business-analyse-develop` for multi-module projects.
-
-**Calculate:**
-```
-scope_score = entity_count + (section_count * 0.5) + (app_count * 3)
-```
-
-**Rules:**
-- `delegate_mode (-d)` → SKIP guard (business-analyse-develop handles scope per module)
-- `app_count > 1` → Warning: use `/business-analyse-develop` or split requests
-- `entity_count > 6` → BLOCKING: max 6 entities. Solutions: `/business-analyse-develop`, `/apex -d`, or split manually
-- `scope_score > 8` → WARNING: ask user to split or use `/business-analyse-develop`
-
-**Recommended Scope:**
-| Metric | Safe | Warning | Blocking |
-|--------|------|---------|----------|
-| Applications | 1 | 1 | >1 |
-| Entities | 1-4 | 5-6 | >6 without -d |
-| Sections | 1-3 | 4-5 | >5 without -d |
-
----
-
-## 6. Determine Needs
-
-```
-needs_seed_data = {sections}.length > 0 OR mentions navigation/permissions/roles/seed
-needs_migration = {entities}.length > 0 OR mentions entity/field/table/column/migration
-needs_workflow = {module_complexity} == "crud-workflow" OR mentions workflow/email/approval
-needs_notification = {module_complexity} in ["crud-workflow","complex"] OR mentions notification/alert
-```
-
----
-
-## 7. Resume Mode (if -r)
-
-Read latest task directory in `.claude/output/apex/`:
-- **If state.json exists:** resume step-03 at next uncompleted layer (skip completed)
-  - **Delegate context recovery:** If `state.delegate_mode === true`:
-    1. Restore `{delegate_prd_path}` from `state.delegate_prd_path`
-    2. Restore `{app_name}`, `{module_code}`, `{sections}`, `{entities}` from state
-    3. Re-read PRD at `{delegate_prd_path}` to rebuild `{specification_loading_plan}`:
-       ```javascript
-       const prd = readJSON(state.delegate_prd_path);
-       if (prd.specificationFiles) {
-         const sf = prd.specificationFiles;
-         specification_loading_plan = {
-           layer0_domain:   [sf.entities],
-           layer1_seed:     [sf.entities, sf.permissions],
-           layer2_backend:  [sf.rules, sf.usecases],
-           layer3_frontend: [sf.screens, sf.usecases]
-         };
-       }
-       ```
-    4. Set `{delegate_mode} = true` — companion spec loading will work in remaining layers
-- **Else if 00-context.md exists:** restore step-00 state, re-derive post-step-00 from git + files
-- **Else:** full re-derive from git history + files
-
----
-
-## 8. Save Mode Setup (if -s)
-
-Generate task_id → create `.claude/output/apex/{task_id}/` → write `00-context.md` with timestamp, state, flags, hierarchy, responses
-
----
-
-## 9. Display Context Summary
-
-```
-APEX INIT COMPLETE — v{{SMARTSTACK_VERSION}}
-Task: {task_description}
-Hierarchy: {app_name} → {module_code} → {sections[].code}
-Entities: {entities} | Complexity: {module_complexity} | Deps: {has_dependencies}
-Entity Map: {entity_section_map.map(e => `${e.entity}→${e.navRoute}`).join(', ')}
-Code: {code_patterns summary} | PRD: {prd_path||none} | Feature: {feature_path||none}
-Flags: {active_flags} | MCP: {available|degraded} | Needs: {migration/seed/workflow/notification}
-Specs: {specification_loading_plan ? 'companion files available (layer-specific loading)' : 'none'}
-NEXT STEP: step-01-analyze
-```
-

package/templates/skills/apex/steps/step-01-analyze.md

@@ -1,210 +0,0 @@
----
-name: step-01-analyze
-description: Explore existing code to understand what exists — do NOT plan yet
-model: opus
-prev_step: steps/step-00-init.md
-next_step: steps/step-02-plan.md
----
-
-# Step 1: Analyze
-
-**ULTRA THINK about existing code structure. Pay special attention to seed data files — they may exist but be INCOMPLETE (missing sections, permissions, or roles for the new scope). An existing file does NOT mean it's complete.**
-
-**Goal:** Understand what EXISTS in the codebase. Pure exploration, NO planning.
-
-## LOAD CONDITIONALLY
-
-- **ALWAYS** read `references/smartstack-api.md` — BaseEntity API, entity/config/controller patterns
-  > **CONTEXT NOTE:** This file stays in context and is reused by step-03. Do NOT re-read it there.
-- If NOT `{economy_mode}`: read `references/parallel-execution.md`
-
----
-
-## 0. Fresh Project Detection (Early Exit)
-
-```
-IF .smartstack/init-state.json exists:
-  Read it → check if project was recently initialized
-  Glob("src/**/Entities/**/*.cs") → count entity files
-
-  IF entity count == 0 AND no PRD AND no feature.json:
-    → SKIP full code exploration (sections 2-3)
-    → Declare: "Fresh project — all elements need to be CREATED"
-    → Jump directly to section 4 (Gap Analysis) with all items marked "create"
-```
-
-This saves ~2 minutes of Glob searches on an empty project.
-
----
-
-## 0b. Delegate Mode Fast Path (if delegate_mode)
-
-> **When called via `/business-analyse-develop -d`, PRD tasks provide pre-computed scope. Reduce exploration to verification only.**
-
-```
-IF delegate_mode:
-  Read PRD from {delegate_prd_path} (already loaded in step-00)
-
-  1. Extract entity list from domain tasks:
-     entities[] = prd.tasks.filter(category == 'domain').map(entity name from description)
-
-  2. Extract FK relationships from frontend tasks with _frontendMeta:
-     fkFields[] = _frontendMeta.fkFields[] (e.g., ["DepartmentId→Department", "CompanyId→Company"])
-
-  3. Determine tenant modes per entity:
-     IF feature.json exists at {feature_path}:
-       Read entity definitions → extract tenantMode per entity
-     ELSE:
-       Default all entities to tenantMode: "strict"
-
-  4. Read feature.json for wireframes/componentMapping if {feature_path} exists:
-     → enriches frontend generation in step-03
-
-  5. Perform LIGHTWEIGHT code exploration (verification only — ONLY entities from PRD tasks):
-     For each entity_name in entities[]:
-       - Glob("**/Domain/Entities/**/{entity_name}.cs") → exists? (create vs modify)
-       - Glob("**/Infrastructure/Persistence/Configurations/**/{entity_name}Configuration.cs") → exists?
-       - Glob("**/Application/Services/**/*{entity_name}*Service.cs") → exists?
-       - Glob("**/Api/Controllers/**/*{entity_name}*Controller.cs") → exists?
-     Module-level checks (once):
-       - Glob("**/Infrastructure/Persistence/Seeding/Data/{module_code}/**/*SeedData*.cs") → existing seed data?
-       - Glob("src/pages/**/{module_code}/**/*.tsx") → existing pages?
-     Do NOT scan the full codebase — only verify files relevant to PRD tasks.
-     Result: mark each PRD task as "create" (file missing) or "modify" (file exists).
-
-  6. Gap Analysis: Mark all PRD tasks as "create" unless existing code found
-
-  SKIP: Full Agent tool parallel exploration (section 2), challenge question follow-up
-  Jump to section 5 (Gap Analysis summary) → section 7 (Analysis Summary)
-```
-
----
-
-## 1. Context Sources
-
-Read available context (in order of priority):
-
-| Source | Action |
-|--------|--------|
-| PRD (`{prd_path}`) | Extract: filesToCreate, brToCodeMapping, permissionMatrix, acceptance criteria |
-| Feature.json (`{feature_path}`) | Extract: module structure, business rules, entity definitions, permissions |
-| Task description only | Rely on task description and code exploration |
-
----
-
-## 2. Code Exploration
-
-### If economy_mode: Direct Tools
-
-```
-Backend:
-- Glob("**/Domain/Entities/**/{module_code}/**/*.cs")
-- Glob("**/Infrastructure/Persistence/Configurations/**/{module_code}/**/*.cs")
-- Glob("**/Application/Services/**/{module_code}/**/*.cs")
-- Glob("**/Api/Controllers/**/*{module_code}*Controller.cs")
-- Glob("**/Infrastructure/Persistence/Seeding/Data/{module_code}/**/*.cs")
-
-Frontend:
-- Glob("src/pages/**/{module_code}/**/*.tsx")
-- Glob("src/components/**/{module_code}/**/*.tsx")
-
-MCP:
-- mcp__smartstack__api_docs → existing API surface
-- mcp__smartstack__analyze_extension_points → React extension points
-```
-
-### If NOT economy_mode: Parallel Agent Exploration
-
-> **Protocol:** See `references/parallel-execution.md`
-
-Launch 2-3 Explore agents in parallel (single message):
-
-```
-Agent(subagent_type='Explore', model='sonnet',
-  prompt='Scan backend for module {module_code}: entities, EF configs, services,
-   DTOs, validators, controllers in Domain/ + Infrastructure/ + Application/ + Api/')
-
-Agent(subagent_type='Explore', model='sonnet',
-  prompt='Scan frontend for module {module_code}: pages, components, hooks,
-   i18n files, route definitions in src/pages/ + src/components/ + src/locales/')
-
-Agent(subagent_type='Explore', model='sonnet',
-  prompt='Read context artifacts for module {module_code}: .ralph/prd-{module_code}.json,
-   docs/business/**/feature.json → extract sections, entities, rules, permissions, ACs')
-
-# All 3 launched in a single message → agent principal aggregates results
-```
-
----
-
-## 3. Seed Data Inventory (CONTENT-AWARE)
-
-> **CRITICAL:** Finding that a seed file EXISTS is not enough. You must READ it and compare its content against the target scope to determine if it needs MODIFICATION.
-
-```
-Glob("**/Seeding/Data/{module_code}/*SeedData.cs")
-Glob("**/Seeding/*SeedDataProvider.cs")
-```
-
-Identify: NavigationModuleSeedData, PermissionsSeedData, RolesSeedData, SeedConstants, IClientSeedDataProvider (+ DI registration).
-
-### 3b. Seed Data Content Analysis (if files exist)
-
-For each existing seed file, READ IT and extract what's already covered:
-
-```
-NavigationModuleSeedData.cs:
-  → Extract existing section codes (from GetSectionEntries or similar methods)
-  → Extract existing resource codes (from GetResourceEntries or similar methods)
-  → Compare against {sections} from step-00
-  → Mark MISSING sections/resources → these need "modify" action
-
-Permissions.cs:
-  → Extract existing permission constants (Read, Create, Update, Delete per section)
-  → Compare against {sections} from step-00
-  → Mark sections WITHOUT permissions → these need "modify" action
-
-PermissionsSeedData.cs:
-  → Extract existing permission paths from HasData() entries
-  → Mark missing paths → "modify"
-
-RolesSeedData.cs:
-  → Extract existing role-permission mappings
-  → Mark missing mappings for new sections → "modify"
-
-{App}SeedDataProvider.cs:
-  → Check which seed methods are called (SeedNavigationAsync, SeedPermissionsAsync, etc.)
-  → Check if new module/section seed classes are referenced → "modify" if missing
-```
-
-**Result:** For each seed file, set action to:
-- `"skip"` — file exists AND covers ALL target sections/entities
-- `"modify"` — file exists BUT is MISSING entries for new sections/entities
-- `"create"` — file does not exist
-
-> **Common mistake:** Marking seed files as "skip" just because the file exists. A `NavigationModuleSeedData.cs` that covers sections A and B MUST be marked "modify" if the task adds section C.
-
----
-
-## 4-7. Analysis Methods & Validation
-
-> **Reference:** Load `references/analysis-methods.md` for detailed analysis procedures:
-> - FK field detection (frontend EntityLookup + backend search support)
-> - Tenant mode decision (strict/optional/scoped/none)
-> - Code pattern detection (auto-generated strategies)
-> - Gap analysis (exists/missing/modify classification)
-> - Scope re-check (entity count validation)
-> - Analysis validation checkpoint (user confirmation)
-> - Analysis summary output format
-
----
-
-## 8. Save Output (if save_mode)
-
-Write to `{output_dir}/01-analyze.md` with analysis results.
-
----
-
-## NEXT STEP
-
-Load `steps/step-02-plan.md`