@atlashub/smartstack-cli 3.37.0 → 3.38.0

package/templates/skills/ralph-loop/references/task-transform-legacy.md

@@ -72,13 +72,12 @@ function transformPrdJsonToRalphV2(prdJson, moduleCode) {
   // --- 1b. Consolidated frontend task ---
   if (frontendFiles.length > 0) {
     const apiDepId = lastIdByCategory["api"] || lastIdByCategory["application"];
-    const ctx = (prdJson.project?.context || 'Business').replace(/^./, c => c.toUpperCase());
     const app = prdJson.project?.application || moduleCode;
     tasks.push({
       id: taskId,
       description: `[frontend] Generate COMPLETE frontend for module ${moduleCode} via MCP (${frontendFiles.length} files)`,
       status: "pending", category: "frontend", dependencies: apiDepId ? [apiDepId] : [],
-      acceptance_criteria: `Pages in src/pages/${ctx}/${app}/${moduleCode}/; MCP scaffold_api_client + scaffold_routes; SmartTable for lists; CSS variables ONLY; 4-language i18n; npm run typecheck passes`,
+      acceptance_criteria: `Pages in src/pages/${app}/${moduleCode}/; MCP scaffold_api_client + scaffold_routes; SmartTable for lists; CSS variables ONLY; 4-language i18n; npm run typecheck passes`,
       started_at: null, completed_at: null, iteration: null, commit_hash: null,
       files_changed: { created: frontendFiles.map(f => f.path), modified: [] },
       validation: null, error: null, module: moduleCode,
@@ -130,15 +129,14 @@ function transformPrdJsonToRalphV2(prdJson, moduleCode) {
 
   // 1f. INJECT missing frontend
   if (frontendFiles.length === 0 && (sections.length > 0 || wireframes.length > 0 || apiEndpoints.length > 0)) {
-    const ctx = (prdJson.project?.context || 'Business').replace(/^./, c => c.toUpperCase());
     const app = prdJson.project?.application || moduleCode;
-    const derivedFiles = wireframes.map(wf => ({ path: `web/src/pages/${ctx}/${app}/${moduleCode}/${wf.screen || wf.id}.tsx`, type: 'Page' }));
+    const derivedFiles = wireframes.map(wf => ({ path: `web/src/pages/${app}/${moduleCode}/${wf.screen || wf.id}.tsx`, type: 'Page' }));
     if (apiEndpoints.length > 0) derivedFiles.push({ path: `web/src/services/api/${moduleCode}Api.ts`, type: 'ApiService' });
 
     tasks.push({ id: taskId,
       description: `[frontend] Generate COMPLETE frontend for ${moduleCode} via MCP (${derivedFiles.length} files)`,
       status: "pending", category: "frontend", dependencies: [lastIdByCategory["api"] || lastIdByCategory["application"]].filter(Boolean),
-      acceptance_criteria: `Pages in src/pages/${ctx}/${app}/${moduleCode}/; SmartTable for lists; CSS variables ONLY; 4-language i18n; npm run typecheck passes`,
+      acceptance_criteria: `Pages in src/pages/${app}/${moduleCode}/; SmartTable for lists; CSS variables ONLY; 4-language i18n; npm run typecheck passes`,
       started_at: null, completed_at: null, iteration: null, commit_hash: null,
       files_changed: { created: derivedFiles.map(f => f.path), modified: [] },
       validation: null, error: null, module: moduleCode,
@@ -184,8 +182,7 @@ function transformPrdJsonToRalphV2(prdJson, moduleCode) {
       files_changed: { created: [], modified: [] }, validation: null, error: null, module: moduleCode,
       _seedDataMeta: {
         source: "guardrail-derived", coreSeedData,
-        navRoute: prdJson.project?.navRoute || `business.${prdJson.project?.application || 'app'}.${moduleCode}`,
-        contextCode: prdJson.project?.context || 'business',
+        navRoute: prdJson.project?.navRoute || `${prdJson.project?.application || 'app'}.${moduleCode}`,
         appCode: prdJson.project?.application, appLabels: prdJson.project?.labels || null
       }
     });
@@ -203,8 +200,8 @@ function transformPrdJsonToRalphV2(prdJson, moduleCode) {
       started_at: null, completed_at: null, iteration: null, commit_hash: null,
       files_changed: { created: [], modified: [] }, validation: null, error: null, module: moduleCode,
       _providerMeta: {
-        navRoute: prdJson.project?.navRoute || `business.${prdJson.project?.application || 'app'}.${moduleCode}`,
-        contextCode: prdJson.project?.context || 'business', appCode: prdJson.project?.application
+        navRoute: prdJson.project?.navRoute || `${prdJson.project?.application || 'app'}.${moduleCode}`,
+        appCode: prdJson.project?.application
       }
     });
     lastIdByCategory["infrastructure"] = taskId; taskId++;

package/templates/skills/ralph-loop/references/team-orchestration.md

@@ -155,7 +155,7 @@ for (const t of teammates) {
 
 // 2. Create team
 const teamName = `smartstack-${kebabCase(projectName)}`;
-TeamCreate({ team_name: teamName, description: `Parallel dev for ${teammates.length} modules` });
+TeamCreate({ team_name: teamName, description: `Layer-based module orchestration for ${projectName}` });
 
 // 3. Spawn teammates in parallel (single message, multiple Task calls)
 for (const teammate of teammates) {
@@ -290,6 +290,49 @@ console.log(`Team ${teamName} deleted. All teammates shut down.`);
 
 ---
 
+## Task List Coordination (T10)
+
+Create tasks for each module before spawning teammates:
+
+```javascript
+// Create tasks for each module before spawning teammates
+for (const mod of modules) {
+  TaskCreate({
+    subject: `Complete ${mod.code} module`,
+    description: `Generate services, controllers, frontend, and tests for ${mod.code}`,
+    activeForm: `Working on ${mod.code}`
+  });
+}
+
+// Teammates update task status when done
+TaskUpdate({ taskId: currentTaskId, status: 'completed' });
+
+// Team lead checks progress
+TaskList(); // View all tasks and their status
+```
+
+---
+
+## Idle State Handling (T13)
+
+> **IMPORTANT:** Teammates go idle after every turn — this is completely normal.
+> Idle simply means the teammate is waiting for input. An idle notification immediately
+> after a message does NOT mean the teammate is done or has errors.
+> Send a message to an idle teammate to wake it up.
+
+---
+
+## Team Config Discovery (T14)
+
+```javascript
+// Teammates can discover each other via team config:
+// ~/.claude/teams/{team-name}/config.json
+// Contains: members[] with name, agentId, agentType
+// Always refer to teammates by NAME, not by UUID.
+```
+
+---
+
 ## Dependency Layer Mode Protocol (no `-p` flag — LEGACY)
 
 ### 1. Layer Detection
@@ -324,7 +367,7 @@ if (!layers) {
 
 ```javascript
 // Create team
-TeamCreate({ team_name: `ralph-${appName}` });
+TeamCreate({ team_name: `ralph-${appName}`, description: `Layer-based module orchestration for ${appName}` });
 
 // Store team context
 const teamContext = {
@@ -406,7 +449,6 @@ ${prdFile}
 - Project path: ${projectPath}
 - Branch: ${branch}
 - Application: ${appName}
-- Context: ${contextCode}
 ```
 
 ---

package/templates/skills/ralph-loop/steps/step-00-init.md

@@ -14,8 +14,6 @@ next_step: steps/step-01-task.md
 - ONLY check resume if -r flag is set
 - **NEVER ask the user** to choose a mode, confirm execution, or select options
 - **NEVER set max_iterations = 1** — unless the user explicitly passed `-m 1`
-- CONTEXT BUDGET: Keep output COMPACT
-- **NEVER DELEGATE** the main Ralph loop to a sub-agent (single module)
 - **Multi-module (2+ modules):** Use Agent Teams for parallel execution
 
 ## YOUR TASK:
@@ -33,168 +31,93 @@ Defaults:
   verbose_mode: false
   resume_mode: false
   parallel_mode: false
-  current_iteration: 1
 
 Flags:
-  -m N / --max-iterations N     → {max_iterations} = N
+  -m N / --max-iterations N → {max_iterations} = N
   -c TEXT / --completion-promise TEXT → {completion_promise} = TEXT
-  -v / --verbose                → {verbose_mode} = true
-  -r / --resume                 → {resume_mode} = true
-  -p / --parallel               → {parallel_mode} = true
+  -v / --verbose → {verbose_mode} = true
+  -r / --resume → {resume_mode} = true
+  -p / --parallel → {parallel_mode} = true
   Remainder → {task_description}
 ```
 
-**If `-p` detected:** set `parallel_mode = true`. Ralph will execute Phase 0 (entities) sequentially, then spawn parallel teammates for services/controllers/frontend/tests. Requires 2+ modules to be effective.
+**If `-p`:** set parallel_mode = true. Ralph executes Phase 0 (entities) sequentially, then spawns parallel teammates.
 
 ## 2. Verify MCP (MANDATORY)
 
 ```
-mcp__smartstack__validate_conventions: checks: ["all"]  → {mcp_smartstack} = true/false
-mcp__context7__resolve-library-id: libraryName: "test"  → {mcp_context7} = true/false
+mcp__smartstack__validate_conventions: checks: ["all"] → {mcp_smartstack} = true/false
+mcp__context7__resolve-library-id: libraryName: "test" → {mcp_context7} = true/false
 ```
 
 If ANY fails: show error, suggest `smartstack check-mcp`, STOP.
 
 ## 3. Execution Mode (FULLY AUTONOMOUS)
 
-> **CRITICAL:** Ralph-loop is FULLY AUTONOMOUS by default.
-> It executes ALL tasks from start to finish WITHOUT stopping.
-> The user launched `/ralph-loop` — this IS the instruction to execute everything.
+Ralph-loop is FULLY AUTONOMOUS by default. It executes ALL tasks from start to finish WITHOUT stopping.
 
 **DO NOT** ask the user to confirm, choose a mode, or approve execution.
-**DO NOT** set `max_iterations = 1` or any reduced value.
-**DO NOT** stop after the first task to "check quality".
+**DO NOT** set max_iterations = 1 or any reduced value.
 
 The loop runs autonomously until:
 - ALL tasks are completed (success)
-- `max_iterations` is reached (user explicitly set via `-m N`)
-- Dead-end detected (all remaining tasks blocked/failed)
+- max_iterations is reached (user set via `-m N`)
+- Dead-end detected (all remaining blocked/failed)
 - User Ctrl+C (external interrupt)
 
-```javascript
-// NO user prompt. NO mode selection. JUST EXECUTE.
-// max_iterations is already set from flags (default: 50).
-// If user wants fewer iterations, they use -m N explicitly.
-console.log(`Mode: AUTONOMOUS | Max iterations: ${max_iterations}`);
-```
+### Speed Warning (informational only)
 
-### Speed Warning (informational only — does NOT block)
-
-If tests are slow (>30s detected in previous logs), display a one-line warning but **continue execution**:
+If tests are slow (>30s in logs), display warning but **continue execution**:
 ```
 ⚠ Slow tests detected. Consider disabling E2E during ralph-loop.
 ```
 
-## 4. Resume Mode
-
-If `{resume_mode} = true`:
+## 4. Resume or Initialize
 
-1. Check `.ralph/prd.json` exists → error if not
-2. Detect format:
-   - `$version === "3.0.0"` → **v3 unified** (native, preferred)
-   - `$version === "2.0.0"` → **v2 legacy** (OK, continue)
-   - `.project && .requirements && !.$version` → **FORMAT A (DEPRECATED)** — warn and transform via step-01
-   - Other → error
-3. Check branch consistency: current branch vs `prd.metadata.branch`
-4. Restore state: `current_iteration`, `completion_promise`, `max_iterations`
-5. If `modules-queue.json` exists: restore multi-module state
-6. Continue to step-01
+See `references/init-resume-recovery.md` for complete Resume Mode and Auto-Recovery logic.
 
-## 4. Initialize .ralph/ (new loop)
-
-```bash
-mkdir -p .ralph/logs .ralph/reports
-```
+**Quick:**
+- If `-r` flag: restore state from .ralph/prd.json
+- Else if BA artifacts exist: auto-recover PRDs via `ss derive-prd`
+- Else: fresh start
 
-### 4a. Auto-Recovery: BA Artifacts Without PRD
-
-If no PRD files exist (neither `prd-*.json` nor `prd.json`):
-
-```javascript
-const masterFeature = findFile('docs/business/**/business-analyse/**/feature.json');
-if (masterFeature) {
-  const master = readJSON(masterFeature);
-  if (master.status === 'handed-off' || master.handoff?.status === 'handed-off') {
-    console.log('BA artifacts detected without PRD — auto-recovering...');
-    exec(`ss derive-prd --application ${masterFeature}`);
-    const newPrds = glob('.ralph/prd-*.json');
-    if (newPrds.length === 0) { console.log('ss derive-prd failed'); STOP; }
-    console.log(`Auto-recovered ${newPrds.length} PRD files`);
-  }
-}
-```
+---
 
-### 4b. Detect Multi-Module PRDs
+## 4b. Detect Multi-Module PRDs
 
-```javascript
-const prdFiles = glob('.ralph/prd-*.json');
-const PRD_COUNT = prdFiles.length;
-
-if (PRD_COUNT > 0) {
-  // Build module queue (from master feature.json order or alphabetical)
-  const modules = [];
-  const masterFeature = findFile('docs/business/**/business-analyse/**/feature.json');
-  if (masterFeature) {
-    const master = readJSON(masterFeature);
-    const moduleOrder = master.metadata?.workflow?.moduleOrder || [];
-    for (const mod of moduleOrder) {
-      if (fileExists(`.ralph/prd-${mod.code}.json`)) {
-        modules.push({ code: mod.code, prdFile: `.ralph/prd-${mod.code}.json`, status: 'pending' });
-      }
-    }
-  }
-  // Fallback: alphabetical
-  if (modules.length === 0) {
-    for (const file of prdFiles) {
-      const code = file.match(/prd-(.+)\.json$/)[1];
-      modules.push({ code, prdFile: `.ralph/${file}`, status: 'pending' });
-    }
-  }
+See `references/multi-module-queue.md` for queue initialization.
 
-  // Create modules-queue.json
-  modules[0].status = 'in-progress';
-  const queue = { modules, currentIndex: 0, totalModules: modules.length, completedModules: 0 };
-  writeJSON('.ralph/modules-queue.json', queue);
-  console.log(`Multi-module: ${modules.length} modules → ${modules.map(m => m.code).join(' → ')}`);
+Quick: `glob('.ralph/prd-*.json').length > 1` → create modules-queue.json
 
-  {modules_queue} = queue;
-  {current_module} = modules[0].code;
-}
-```
+---
 
-### 4c. Team Orchestration (multi-module, 2+ modules)
+## 4c. Team Orchestration (multi-module, 2+ modules)
 
 ```javascript
 if (PRD_COUNT > 1) {
   // Read references/team-orchestration.md for full protocol
-  // Detect dependency layers from master feature.json
   const layers = master.metadata?.workflow?.dependencyGraph?.layers;
 
   if (layers) {
     // PARALLEL MODE: Use Agent Teams
     TeamCreate({ team_name: `ralph-${appName}` });
-
-    // For each layer, spawn teammates in parallel
-    // Layer 0: foundation modules (spawn, wait for LAYER_READY)
-    // Layer 1+: dependent modules (spawn after previous layer completes)
-    // See references/team-orchestration.md for teammate prompt template
-
-    // After all layers: cross-module verify → step-05 → TeamDelete
+    // Spawn teammates per layer (see reference)
     // STOP here — team orchestration takes over
     return;
   }
-  // If no layers: fall through to sequential mode (classic compact loop)
+  // If no layers: fall through to sequential mode
 }
 ```
 
+---
+
 ## 5. Completion Promise (auto-set)
 
 ```javascript
-// Auto-set if not provided — NEVER ask the user
 if (!completion_promise) {
   completion_promise = "COMPLETE";
 }
-// The promise is output ONLY when ALL tasks are done. No user interaction needed.
+// Output ONLY when ALL tasks done
 ```
 
 ## 6. Collect Metadata
@@ -206,8 +129,12 @@ PROJECT_PATH=$(pwd)
 ```
 
 ```javascript
-{metadata} = { cli_version: CLI_VERSION, branch: CURRENT_BRANCH, project_path: PROJECT_PATH,
-  mcp_servers: { smartstack: {mcp_smartstack}, context7: {mcp_context7} } }
+{metadata} = {
+  cli_version: CLI_VERSION,
+  branch: CURRENT_BRANCH,
+  project_path: PROJECT_PATH,
+  mcp_servers: { smartstack: {mcp_smartstack}, context7: {mcp_context7} }
+}
 ```
 
 ## 7. Show Summary

package/templates/skills/ralph-loop/steps/step-01-task.md

@@ -29,56 +29,13 @@ Load task from prd.json or create initial task breakdown with categories, depend
 
 ## 0. Multi-Module Queue Check
 
-```javascript
-const queuePath = '.ralph/modules-queue.json';
-if (fileExists(queuePath)) {
-  const queue = readJSON(queuePath);
-  const currentModule = queue.modules[queue.currentIndex];
-  console.log(`Multi-module: ${currentModule.code} (${queue.currentIndex + 1}/${queue.totalModules})`);
-
-  {modules_queue} = queue;
-  {current_module} = currentModule.code;
-
-  // Verify PRD matches current module
-  const currentPrd = readJSON('.ralph/prd.json');
-  if (currentPrd.metadata?.moduleCode !== currentModule.code) {
-    const modulePrd = readJSON(currentModule.prdFile);
-
-    // v3 FAST PATH: unified PRD from ss derive-prd (tasks pre-computed)
-    if (modulePrd.$version === '3.0.0') {
-      // Inject runtime fields and use directly
-      modulePrd.status = 'in_progress';
-      modulePrd.feature = `${modulePrd.project?.module || currentModule.code} (${modulePrd.project?.application || 'app'})`;
-      modulePrd.created = modulePrd.created || new Date().toISOString();
-      modulePrd.updated_at = new Date().toISOString();
-      modulePrd.config = modulePrd.config || { max_iterations: {max_iterations}, completion_promise: "{completion_promise}", current_iteration: 1 };
-      modulePrd.metadata.branch = modulePrd.metadata.branch || getCurrentBranch();
-      modulePrd.metadata.project_path = modulePrd.metadata.project_path || process.cwd();
-      modulePrd.metadata.mcp_servers = modulePrd.metadata.mcp_servers || { smartstack: true, context7: true };
-      modulePrd.history = modulePrd.history || [];
-      writeJSON('.ralph/prd.json', modulePrd);
-    }
-    // LEGACY: FORMAT A (no $version) — transform + warning
-    else if (modulePrd.project && modulePrd.requirements && !modulePrd.$version) {
-      console.warn('⚠ DEPRECATED: FORMAT A prd.json detected. Re-run `ss derive-prd` to generate v3 format.');
-      writeJSON('.ralph/prd.json', transformPrdJsonToRalphV2(modulePrd, currentModule.code));
-    }
-    // v2 legacy or already runtime format
-    else {
-      writeJSON('.ralph/prd.json', modulePrd);
-    }
-  }
-} else {
-  {modules_queue} = null;
-  {current_module} = null;
-}
-```
+See `references/multi-module-queue.md` for full module queue initialization, detection, and loading.
 
-## PrdJson → Ralph v2 Transformation (DEPRECATED)
+Quick: If `glob('.ralph/prd-*.json').length > 1` → create modules-queue.json and load first module's PRD.
 
-> **DEPRECATED:** This transformation is a fallback for old FORMAT A PRDs (pre-v3.9.0).
-> New PRDs generated by `ss derive-prd` use unified v3 format with pre-computed tasks.
-> This function will be removed in a future release.
+---
+
+## PrdJson → Ralph v2 Transformation (DEPRECATED)
 
 See [references/task-transform-legacy.md](../references/task-transform-legacy.md) for the full `transformPrdJsonToRalphV2()` function including:
 - Layer-ordered task generation (domain → infra → app → api → frontend → seedData → tests)
@@ -96,7 +53,7 @@ If `.ralph/prd.json` exists:
    - Write back to `.ralph/prd.json`
    - **Run CATEGORY COMPLETENESS CHECK (section 4b) before proceeding**
    - Skip directly to section 5 (find next task)
-3. **v2 legacy:** If `$version === "2.0.0"` → find next eligible task (section 5), skip to section 5
+3. **v2 legacy:** If `$version === "2.0.0"` → find next eligible task (section 5)
 4. **FORMAT A (deprecated):** If `.project && .requirements && !.$version` → run `transformPrdJsonToRalphV2()` → section 5
 
 If `.ralph/prd.json` does not exist: continue to section 1b.
@@ -105,10 +62,8 @@ If `.ralph/prd.json` does not exist: continue to section 1b.
 
 > **CRITICAL:** Before generating ANY tasks, verify the BA handoff is complete.
 > A missing handoff means no frontend files, no test plan, no BR-to-code mapping.
-> Generating tasks without handoff produces an INCOMPLETE PRD (backend-only).
 
 ```javascript
-// Find the source feature.json for the current module
 const sourceFeatureJson = prd?.metadata?.sourceFeatureJson
   || findFile('docs/business/**/business-analyse/**/feature.json');
 
@@ -118,35 +73,19 @@ if (sourceFeatureJson) {
 
   // CHECK 1: Handoff status must be "handed-off"
   if (handoff.status !== 'handed-off') {
-    console.error(`
-╔══════════════════════════════════════════════════════════════╗
-║  BLOCKING: BA HANDOFF INCOMPLETE                            ║
-║                                                              ║
-║  feature.json handoff.status = "${handoff.status || 'missing'}"
-║  Expected: "handed-off"                                      ║
-║                                                              ║
-║  The /business-analyse did not complete steps 04a→05c.       ║
-║  Without handoff, the PRD will be MISSING:                   ║
-║    - Frontend tasks (pages, components, routes)              ║
-║    - Test tasks (unit, integration, security)                ║
-║    - BR-to-code mappings                                     ║
-║    - API endpoint summary                                    ║
-║                                                              ║
-║  ACTION: Run /business-analyse to complete the handoff,      ║
-║  then re-run /ralph-loop.                                    ║
-╚══════════════════════════════════════════════════════════════╝`);
+    console.error(`BLOCKING: BA HANDOFF INCOMPLETE
+handoff.status = "${handoff.status || 'missing'}" (expected "handed-off")
+Run /business-analyse to complete the handoff, then re-run /ralph-loop.`);
     STOP;
   }
 
-  // CHECK 2: filesToCreate must have all 7 categories
+  // CHECK 2: filesToCreate must have all categories
   const filesToCreate = handoff.filesToCreate || {};
   const requiredCategories = ['domain', 'application', 'infrastructure', 'api', 'frontend', 'seedData', 'tests'];
   const missingInHandoff = requiredCategories.filter(c => !filesToCreate[c] || filesToCreate[c].length === 0);
 
   if (missingInHandoff.length > 0) {
     console.warn(`⚠ Handoff has empty categories: ${missingInHandoff.join(', ')}`);
-    console.warn('PRD generation may produce incomplete tasks. Consider re-running /business-analyse step-05a.');
-    // WARNING only — allow proceeding if handoff.status is correct
   }
 }
 ```
@@ -181,112 +120,25 @@ Initialize `.ralph/progress.txt`:
 
 ### 4b. Category Completeness Check (BLOCKING)
 
-> **CRITICAL:** The PRD MUST contain tasks for ALL required categories.
-> A PRD with only backend categories (domain, infrastructure, application, api) is INCOMPLETE.
-> This check prevents the "no frontend generated" failure mode.
+See `references/category-completeness.md` for full implementation.
 
-```javascript
-// CRITICAL: seedData MUST be in the required list — without it, nav_Applications/auth_Roles/auth_Permissions
-// are not seeded, and frontend/test tasks execute against an empty database.
-const REQUIRED_CATEGORIES = ['domain', 'infrastructure', 'application', 'api', 'seedData', 'frontend', 'test'];
-const presentCategories = new Set(prd.tasks.map(t => t.category));
-const missingCategories = REQUIRED_CATEGORIES.filter(c => !presentCategories.has(c));
-
-if (missingCategories.length > 0) {
-  console.warn(`⚠ PRD MISSING CATEGORIES: ${missingCategories.join(', ')}`);
-
-  // AUTO-INJECT guardrail tasks for missing categories
-  let maxIdNum = Math.max(...prd.tasks.map(t => {
-    const num = parseInt(t.id.replace(/[^0-9]/g, ''), 10);
-    return isNaN(num) ? 0 : num;
-  }));
-  const prefix = prd.tasks[0]?.id?.replace(/[0-9]+$/, '') || 'GUARD-';
-  const lastApiTask = prd.tasks.filter(t => t.category === 'api').pop()?.id || prd.tasks[prd.tasks.length - 1]?.id;
-  const lastSeedDataTask = prd.tasks.filter(t => t.category === 'seedData').pop()?.id;
-
-  // DEPENDENCY CHAIN: domain → infrastructure → application → api → seedData → frontend → test
-  // Frontend MUST depend on seedData (not just API) — otherwise navigation/permissions are empty
-  const frontendDep = lastSeedDataTask || lastApiTask;
-
-  for (const cat of missingCategories) {
-    maxIdNum++;
-    const taskId = `${prefix}${String(maxIdNum).padStart(3, '0')}`;
-
-    // Determine dependencies based on category order
-    let deps;
-    if (cat === 'seedData') {
-      deps = [lastApiTask]; // seedData depends on API (infrastructure must exist first)
-    } else if (cat === 'frontend') {
-      deps = [frontendDep]; // frontend depends on seedData (navigation must be seeded)
-    } else if (cat === 'test') {
-      deps = [frontendDep]; // test depends on seedData too
-    } else {
-      deps = [];
-    }
-
-    const guardrailTask = {
-      id: taskId,
-      description: `[GUARDRAIL] Generate ${cat} layer for ${prd.project?.module || 'module'}`,
-      status: 'pending',
-      category: cat,
-      dependencies: deps,
-      acceptance_criteria: [
-        cat === 'seedData' ? 'NavigationApplicationSeedData + NavigationModuleSeedData + PermissionsSeedData + ApplicationRolesSeedData created, IClientSeedDataProvider wired, startup test passes' :
-        cat === 'frontend' ? 'React pages created via MCP scaffold_api_client + scaffold_routes, wired to App.tsx, navigation seed data verified in DB' :
-        cat === 'test' ? 'Unit + Integration test projects created, scaffold_tests MCP called, dotnet test passes' :
-        `${cat} layer fully implemented per category-rules.md`
-      ],
-      started_at: null, completed_at: null, iteration: null,
-      commit_hash: null, files_changed: [], validation: null, error: null
-    };
-    prd.tasks.push(guardrailTask);
-    console.log(`  → Injected guardrail: [${taskId}] ${cat}`);
-
-    // Update frontendDep if we just injected seedData (frontend guardrail should depend on it)
-    if (cat === 'seedData') {
-      // Re-resolve for subsequent iterations
-      const updatedFrontendDep = taskId;
-      // Patch any previously-added frontend guardrail to depend on this seedData task
-      const frontendGuard = prd.tasks.find(t => t.category === 'frontend' && t.description.includes('[GUARDRAIL]'));
-      if (frontendGuard && !frontendGuard.dependencies.includes(taskId)) {
-        frontendGuard.dependencies = [taskId];
-      }
-    }
-  }
-
-  writeJSON('.ralph/prd.json', prd);
-  console.log(`PRD updated: ${prd.tasks.length} tasks (${missingCategories.length} guardrails added)`);
-}
-```
+Quick: `checkCategoryCompleteness(prd)` → inject guardrails if needed
 
-**Why this matters:** In test-v4-005, the PRD was generated with only backend categories (domain, infrastructure, application, api, seedData, validation). The frontend and test categories were entirely absent, resulting in 0 frontend pages and 0 tests generated across 3 modules.
+---
 
 ### 4c. Section Split Detection (Large Module)
 
-> **Purpose:** Modules with >4 domain entities overwhelm a single `/apex -d` call.
-> Split execution into Phase 0 (foundation) + Phase 1..N (per section).
-
 ```javascript
 const domainTasks = prd.tasks.filter(t => t.category === 'domain');
 const sections = prd.architecture?.sections ?? [];
 
 if (domainTasks.length > 4 && sections.length > 1 && !prd._sectionSplit?.enabled) {
   console.log(`SECTION SPLIT: ${domainTasks.length} domain tasks, ${sections.length} sections → activating`);
-
-  // Read references/section-splitting.md for full logic
-  // 1. Build entity-to-section mapping from architecture.sections[].resources[].entity
-  // 2. Build section dependency graph from architecture.entities[].relationships[]
-  // 3. Topological sort sections by FK dependencies
-  // 4. Create Phase 0 PRD (all domain + infrastructure + module seed data)
-  // 5. Create Section PRDs (per-section: application + api + seedData + frontend + i18n + test)
-  // 6. Set prd._sectionSplit state
-
   // LOAD references/section-splitting.md — execute sections 2-6
 }
 ```
 
-**Activation threshold:** `> 4 domain tasks` AND `> 1 architecture section`
-**No-op when:** `<= 4 domain tasks` OR `<= 1 section` OR `_sectionSplit.enabled` already set
+**Activation:** `> 4 domain tasks` AND `> 1 architecture section`
 
 ## 5. Find Current Task
 
@@ -306,7 +158,7 @@ function findNextTask(tasks) {
 }
 ```
 
-If no eligible task: all completed → step-05, all blocked → step-05, else STOP.
+If no eligible task: check if all completed → step-05, else STOP.
 
 ## 6. Show Task Status