@atlashub/smartstack-cli 3.33.0 → 3.35.0

package/templates/skills/ralph-loop/steps/step-03-commit.md

@@ -1,116 +1,75 @@
 ---
 name: step-03-commit
-description: Commit changes, update prd.json v2 with full tracking
+description: Commit PRD state after apex delegation
 next_step: steps/step-04-check.md
 ---
 
-# Step 3: Commit Changes
+# Step 3: Commit PRD State
 
 > **CONTEXT OPTIMIZATION:** Read ONCE (first iteration). Subsequent iterations use compact-loop.md.
 
 ## YOUR TASK:
 
-Commit changes, finalize task tracking in prd.json, append to history.
+Commit PRD state changes after apex delegation. Apex already committed code — ralph commits orchestration state only.
 
 ---
 
 ## EXECUTION SEQUENCE:
 
-### 0. Pre-Commit Validation (BLOCKING)
-
-```bash
-# Backend: build must pass
-if [ "{current_task_category}" != "frontend" ] && [ "{current_task_category}" != "i18n" ]; then
-  dotnet build --no-restore --verbosity quiet
-fi
-
-# Frontend: typecheck + lint must pass
-if [ "{current_task_category}" = "frontend" ]; then
-  npm run typecheck && npm run lint
-fi
-
-# Tests: full suite if test project exists
-TEST_PROJECT="tests/$(basename $(pwd)).Tests.Unit"
-if [ -d "$TEST_PROJECT" ]; then
-  dotnet test "$TEST_PROJECT" --no-build --verbosity minimal
-  if [ $? -ne 0 ]; then
-    echo "COMMIT BLOCKED: tests failing. Fix before committing."
-    STOP — return to step-02
-  fi
-fi
-```
-
-### 1. Stage and Commit
-
-```bash
-git add {files_created} {files_modified} .ralph/prd.json
-git commit -m "$(cat <<'EOF'
-{PREFIX}({scope}): {current_task_description}
-
-Task {current_task_id}/{tasks_total} - Iteration {current_iteration}
-Category: {current_task_category}
-{current_module ? "Module: " + current_module : ""}
-
-Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
-EOF
-)"
-
-COMMIT_HASH=$(git rev-parse --short HEAD)
-```
-
-**Prefix mapping:**
-
-| Category | Prefix |
-|----------|--------|
-| domain, application, api, frontend | `feat` |
-| infrastructure | `db` |
-| i18n | `chore` |
-| test | `test` |
-| validation, other | `chore` |
-
-### 2. Finalize Task in prd.json
+### 1. Finalize Task in prd.json
 
 ```javascript
 const prd = readJSON('.ralph/prd.json');
-const task = prd.tasks.find(t => t.id === {current_task_id});
 const now = new Date().toISOString();
 
-if (task.status !== 'failed') task.status = 'completed';
-task.completed_at = now;
-task.iteration = prd.config.current_iteration;
-task.commit_hash = COMMIT_HASH;
-
-prd.history.push({
-  iteration: prd.config.current_iteration, task_id: task.id,
-  action: task.status, timestamp: now, commit_hash: COMMIT_HASH,
-  duration_seconds: Math.round((new Date(now) - new Date(task.started_at)) / 1000),
-  notes: "{What was accomplished}"
-});
+// Apex updates individual task statuses. Ralph updates overall PRD state.
+const allDone = prd.tasks.every(t => t.status === 'completed' || t.status === 'skipped');
+prd.status = allDone ? 'completed' : prd.tasks.some(t => t.status === 'failed' || t.status === 'blocked') ? 'partial' : 'in_progress';
 
 prd.config.current_iteration++;
 prd.updated_at = now;
 
-const allDone = prd.tasks.every(t => t.status === 'completed' || t.status === 'skipped');
-prd.status = allDone ? 'completed' : prd.tasks.some(t => t.status === 'failed' || t.status === 'blocked') ? 'partial' : 'in_progress';
-
 writeJSON('.ralph/prd.json', prd);
 ```
 
-### 3. Update progress.txt
+### 2. Update progress.txt
 
-Append iteration learnings (compact):
+Append iteration summary (compact):
 ```markdown
-## Iteration {iteration} — [{id}] {description}
-Status: {status} | Commit: {hash} | Files: {count}
-Learnings: {what was learned}
+## Iteration {iteration} — Delegated to /apex
+Status: {status} | Completed: {completed}/{total}
+Module: {current_module}
 ```
 
-### 4. Commit Progress Files
+### 3. Stage and Commit (PRD state only)
 
 ```bash
 git add .ralph/prd.json .ralph/progress.txt
 [ -f .ralph/modules-queue.json ] && git add .ralph/modules-queue.json
-git commit -m "chore(ralph): progress — task {id}/{total}"
+
+git commit -m "$(cat <<'EOF'
+chore(ralph): PRD state — iteration {iteration}, {completed}/{total} tasks
+
+Module: {current_module}
+
+Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
+EOF
+)"
+
+COMMIT_HASH=$(git rev-parse --short HEAD)
+```
+
+### 4. Record Commit in History
+
+```javascript
+prd.history.push({
+  iteration: prd.config.current_iteration - 1,
+  action: 'iteration-completed',
+  timestamp: now,
+  commit_hash: COMMIT_HASH,
+  notes: "Delegated to /apex"
+});
+writeJSON('.ralph/prd.json', prd);
 ```
 
 ### 5. Verify
@@ -124,7 +83,7 @@ git log -2 --oneline
 ## ERROR HANDLING:
 
 - **Commit fails (pre-commit hook):** Fix issue, stage, create NEW commit (don't amend)
-- **Task failed in step-02:** Still commit partial progress, status stays "failed"
+- **Task failed in apex:** PRD already reflects failure status — commit as-is
 
 ---
 

package/templates/skills/ralph-loop/steps/step-04-check.md

@@ -25,49 +25,21 @@ const tasksTotal = prd.tasks.length;
 const allDone = (tasksCompleted + tasksSkipped) === tasksTotal;
 ```
 
-### 1.5. Regression Check (BLOCKING)
+### 1.5. Lightweight Sanity Check
 
-**Backend — build + tests:**
-```bash
-dotnet build --no-restore
-if [ $? -ne 0 ]; then
-  echo "BUILD REGRESSION — creating fix task"
-  # Inject fix task, category: validation, acceptance: "dotnet build passes"
-fi
-
-TEST_PROJECT="tests/$(basename $(pwd)).Tests.Unit"
-if [ -d "$TEST_PROJECT" ]; then
-  dotnet test "$TEST_PROJECT" --no-build --verbosity normal
-  if [ $? -ne 0 ]; then
-    echo "TEST REGRESSION — creating fix task"
-    prd.tasks.push({ id: maxId+1, description: "Fix test regression — all tests must pass",
-      status: "pending", category: "validation", dependencies: [],
-      acceptance_criteria: "dotnet test exits 0, all tests pass" });
-    writeJSON('.ralph/prd.json', prd);
-  fi
-else
-  # CRITICAL: Test project MUST exist if test tasks are marked completed
-  const testTasksDone = prd.tasks.filter(t => t.category === 'test' && t.status === 'completed');
-  if (testTasksDone.length > 0) {
-    echo "ARTIFACT MISSING — test tasks marked completed but no test project exists"
-    // Reset test tasks to pending and inject guardrail
-    testTasksDone.forEach(t => { t.status = 'pending'; t.error = null; t.completed_at = null; });
-    writeJSON('.ralph/prd.json', prd);
-  fi
-fi
-```
+> **Note:** Full build verification, POST-CHECKs, and test runs are handled by apex.
+> Ralph only does a lightweight sanity check to detect regressions between apex invocations.
 
-**Frontend — typecheck + lint:**
 ```bash
-if [ -f "web/package.json" ] || [ -f "package.json" ]; then
-  npm run typecheck
-  if [ $? -ne 0 ]; then
-    echo "FRONTEND REGRESSION — creating fix task"
-    prd.tasks.push({ id: maxId+1, description: "Fix frontend typecheck errors",
-      status: "pending", category: "frontend", dependencies: [],
-      acceptance_criteria: "npm run typecheck exits 0" });
-    writeJSON('.ralph/prd.json', prd);
-  fi
+# Quick build check (quiet mode)
+dotnet build --no-restore --verbosity quiet
+if [ $? -ne 0 ]; then
+  echo "BUILD REGRESSION detected between apex invocations"
+  # Inject fix task — apex will handle the actual fix
+  prd.tasks.push({ id: maxId+1, description: "Fix build regression",
+    status: "pending", category: "validation", dependencies: [],
+    acceptance_criteria: "dotnet build passes" });
+  writeJSON('.ralph/prd.json', prd);
 fi
 ```
 
@@ -84,7 +56,7 @@ const REQUIRED_CATEGORIES = ['domain', 'infrastructure', 'application', 'api', '
 const missingFromPrd = REQUIRED_CATEGORIES.filter(c => !presentCategories.has(c));
 
 if (missingFromPrd.length > 0) {
-  console.warn(`⚠ PRD MISSING CATEGORIES: ${missingFromPrd.join(', ')}`);
+  console.warn(`PRD MISSING CATEGORIES: ${missingFromPrd.join(', ')}`);
 
   // Inject guardrail tasks for missing categories
   let maxIdNum = Math.max(...prd.tasks.map(t => parseInt(t.id.replace(/[^0-9]/g, ''), 10) || 0));
@@ -101,14 +73,14 @@ if (missingFromPrd.length > 0) {
       status: 'pending', category: cat,
       dependencies: lastSeedDataTask ? [lastSeedDataTask] : (lastApiTask ? [lastApiTask] : []),
       acceptance_criteria: [
-        cat === 'frontend' ? 'React pages + routes wired to App.tsx (standard + tenant blocks)' :
-        cat === 'test' ? 'Unit + integration test projects with passing dotnet test' :
+        cat === 'frontend' ? 'React pages + routes wired to App.tsx' :
+        cat === 'test' ? 'Unit + integration tests passing' :
         `${cat} layer complete`
       ],
       started_at: null, completed_at: null, iteration: null,
       commit_hash: null, files_changed: [], validation: null, error: null
     });
-    console.log(`  → Injected [${taskId}] ${cat} guardrail`);
+    console.log(`  Injected [${taskId}] ${cat} guardrail`);
   }
   writeJSON('.ralph/prd.json', prd);
 
@@ -158,13 +130,11 @@ If `allDone`:
 
 ```javascript
 if ({team_active}) {
-  // Signal team lead that this module is done
   SendMessage({
     type: "message", recipient: "team-lead",
     content: `MODULE_COMPLETE:${current_module}`,
     summary: `${current_module} complete`
   });
-  // STOP — team lead manages next module
   return;
 }
 ```
@@ -177,14 +147,12 @@ if (fileExists(queuePath)) {
   const queue = readJSON(queuePath);
   const currentModule = queue.modules[queue.currentIndex];
 
-  // MODULE COMPLETENESS CHECK (lightweight — heavy check already done in section 1.7)
-  // Verify all expected layers have completed tasks
+  // MODULE COMPLETENESS CHECK
   const completedCats = new Set(prd.tasks.filter(t => t.status === 'completed').map(t => t.category));
   const expected = ['domain', 'infrastructure', 'application', 'api', 'seedData', 'frontend', 'test'];
   const missing = expected.filter(c => !completedCats.has(c));
 
   if (missing.length > 0) {
-    // Section 1.7 should have injected guardrails already — fall through to compact loop
     console.log(`Module ${currentModule.code}: missing categories ${missing.join(', ')} — continuing loop`);
     // Fall through to section 5 (compact loop)
   } else {
@@ -198,13 +166,11 @@ if (fileExists(queuePath)) {
       queue.modules[nextIndex].status = 'in-progress';
       writeJSON(queuePath, queue);
 
-      // Create transition marker
       writeJSON('.ralph/module-changed.json', {
         fromModule: currentModule.code, toModule: queue.modules[nextIndex].code,
         timestamp: new Date().toISOString()
       });
 
-      // Load next module PRD
       prd.status = 'completed';
       writeJSON('.ralph/prd.json', prd);
       const nextPrd = readJSON(queue.modules[nextIndex].prdFile);
@@ -235,11 +201,27 @@ Set `prd.status = 'completed'` → step-05.
 
 ## 4. Dead-End Check
 
-If `!hasPending && !allDone`: all remaining blocked/failed, no progress possible.
-```
-DEAD-END: {completed} done, {failed} failed, {blocked} blocked
+```javascript
+const hasPending = prd.tasks.some(t => t.status === 'pending');
+const MAX_RETRIES = 3;
+
+// Before declaring dead-end, check if any failed tasks have retries left
+const retriableCount = prd.tasks.filter(t =>
+  t.status === 'failed' && (t._retryCount || 0) < MAX_RETRIES
+).length;
+
+if (!hasPending && !allDone && retriableCount > 0) {
+  // NOT a dead-end — compact loop will reset failed tasks to pending
+  console.log(`${retriableCount} failed tasks have retries remaining — entering compact loop`);
+  // Fall through to section 5
+} else if (!hasPending && !allDone && retriableCount === 0) {
+  // TRUE dead-end: all retries exhausted
+  console.log(`DEAD-END: ${tasksCompletedNow} done, ${tasksFailed} failed (retries exhausted), ${tasksBlocked} blocked`);
+  prd.status = 'failed';
+  writeJSON('.ralph/prd.json', prd);
+  // → step-05
+}
 ```
-Set `prd.status = 'failed'` → step-05.
 
 ## 5. Compact Loop (MANDATORY — EXECUTE IMMEDIATELY)
 
@@ -251,7 +233,7 @@ Set `prd.status = 'failed'` → step-05.
 If `hasPending && iteration < max`:
 
 1. Read `references/compact-loop.md`
-2. Execute sections A → B → C → D inline (find tasks → execute batch → commit → loop back)
+2. Execute sections A → B → C → D inline (find tasks → delegate to apex → commit PRD → loop back)
 3. **IMMEDIATELY** return to section 1 of THIS step (do NOT pause)
 4. Repeat until ALL tasks are complete, max iterations reached, or dead-end
 
@@ -260,14 +242,13 @@ If `hasPending && iteration < max`:
 ## CRITICAL RULES — EXECUTION GUARANTEE:
 
 - **NEVER** output completion promise unless ALL tasks done (all modules if multi)
-- **NEVER** delegate the loop to sub-agents (except team mode for multi-module)
 - **NEVER** stop between iterations — this is the CORE PROMISE of ralph-loop
 - **NEVER** ask the user "should I continue?" or "is this OK?" — JUST CONTINUE
 - **NEVER** pause to show intermediate results and wait for feedback
+- **NEVER** generate code directly — ALWAYS delegate to /apex
 - **BATCH** same-category tasks (max 5)
 - **MODULE COMPLETENESS:** All layers must have completed tasks before advancing
 - **Only valid stop conditions:** all complete, max iterations, dead-end, or user Ctrl+C
-- **If you stop for any other reason, you have VIOLATED the execution guarantee.**
 
 ---
 

package/templates/skills/ralph-loop/steps/step-05-report.md

@@ -1,6 +1,6 @@
 ---
 name: step-05-report
-description: Generate final report from prd.json structured data (v3 unified or v2 legacy)
+description: Generate final report from prd.json structured data
 next_step: null
 ---
 
@@ -27,7 +27,7 @@ const stats = {
   }
 };
 
-// Aggregate files from all tasks
+// Aggregate files from all tasks (populated by apex during execution)
 const filesCreated = [...new Set(prd.tasks.flatMap(t => t.files_changed?.created || []))];
 const filesModified = [...new Set(prd.tasks.flatMap(t => t.files_changed?.modified || []))];
 const totalDuration = prd.history.reduce((sum, h) => sum + (h.duration_seconds || 0), 0);
@@ -53,125 +53,14 @@ if (fileExists(queuePath)) {
 }
 ```
 
-### 1c. Team Results Aggregation
+### 1c. Test Metrics (from PRD)
 
-```javascript
-// If Agent Teams were used, results are already in per-module PRDs
-// Aggregate from moduleStats (same as 1b)
-```
-
-### 1d. Test Metrics
-
-```bash
-TEST_PROJECT="tests/$(basename $(pwd)).Tests.Unit"
-if [ -d "$TEST_PROJECT" ]; then
-  dotnet test "$TEST_PROJECT" --no-build --verbosity minimal
-  # Parse total/passed/failed/skipped from output
-fi
-```
-
-### 1e. Frontend Quality Metrics (if frontend tasks were executed)
-
-```bash
-WEB_SRC=$(find . -name "App.tsx" -not -path "*/node_modules/*" -exec dirname {} \; 2>/dev/null | head -1)
-if [ -n "$WEB_SRC" ]; then
-  PAGE_DIR="$WEB_SRC/pages"
-  HOOK_DIR="$WEB_SRC/hooks"
-  COMP_DIR="$WEB_SRC/components"
-  I18N_DIR="$WEB_SRC/i18n/locales"
-
-  # Count metrics
-  PAGE_COUNT=$(find "$PAGE_DIR" -name "*.tsx" ! -name "*.test.tsx" 2>/dev/null | wc -l)
-  TEST_COUNT=$(find "$PAGE_DIR" -name "*.test.tsx" 2>/dev/null | wc -l)
-  HOOK_COUNT=$(find "$HOOK_DIR" -name "*.ts" -o -name "*.tsx" 2>/dev/null | wc -l)
-
-  # Quality checks
-  RAW_TABLES=$(grep -rl '<table[\s>]' "$PAGE_DIR" --include="*.tsx" 2>/dev/null | wc -l)
-  HARDCODED_COLORS=$(grep -rl '(?:bg|text|border)-(?:red|blue|green|gray|slate)-\d{2,3}' "$PAGE_DIR" "$COMP_DIR" --include="*.tsx" 2>/dev/null | wc -l)
-  CSS_VARS=$(grep -rl 'var(--' "$PAGE_DIR" "$COMP_DIR" --include="*.tsx" 2>/dev/null | wc -l)
-  WINDOW_CONFIRM=$(grep -rl 'window\.confirm' "$PAGE_DIR" --include="*.tsx" 2>/dev/null | wc -l)
-  HARDCODED_TEXT=$(grep -rl '>\s*\(Create\|Edit\|Delete\|Save\|Cancel\)\s*<' "$PAGE_DIR" --include="*.tsx" 2>/dev/null | wc -l)
-  USE_TRANSLATION=$(grep -rl 'useTranslation' "$PAGE_DIR" --include="*.tsx" 2>/dev/null | wc -l)
-  SMART_TABLE=$(grep -rl 'SmartTable\|DataTable' "$PAGE_DIR" --include="*.tsx" 2>/dev/null | wc -l)
-
-  # i18n coverage
-  I18N_LANGS=0
-  for LANG in fr en it de; do
-    [ -d "$I18N_DIR/$LANG" ] && I18N_LANGS=$((I18N_LANGS + 1))
-  done
-fi
-```
-
-Include frontend metrics in report section:
-```markdown
-## Frontend Quality
-| Metric | Value | Target |
-|--------|-------|--------|
-| Pages | {PAGE_COUNT} | — |
-| Tests | {TEST_COUNT} | ≥ {PAGE_COUNT/3} |
-| Hooks | {HOOK_COUNT} | — |
-| SmartTable/DataTable usage | {SMART_TABLE} files | All list pages |
-| Raw HTML tables | {RAW_TABLES} files | 0 |
-| CSS variable usage | {CSS_VARS} files | All TSX files |
-| Hardcoded colors | {HARDCODED_COLORS} files | 0 |
-| useTranslation() usage | {USE_TRANSLATION} files | All page files |
-| Hardcoded English text | {HARDCODED_TEXT} files | 0 |
-| window.confirm() usage | {WINDOW_CONFIRM} files | 0 |
-| i18n languages | {I18N_LANGS}/4 | 4 |
-```
+> **Note:** Apex already ran tests and recorded results. Source metrics from PRD task data.
 
-### 1f. Final DB Validation (if infrastructure/migration tasks were executed)
-
-```bash
-INFRA_PROJECT=$(ls src/*Infrastructure*/*.csproj 2>/dev/null | head -1)
-API_PROJECT=$(ls src/*Api*/*.csproj 2>/dev/null | head -1)
-
-if [ -n "$INFRA_PROJECT" ] && [ -n "$API_PROJECT" ]; then
-  echo "FINAL DB VALIDATION: Applying all migrations on fresh SQL Server LocalDB..."
-
-  # 1. Check no pending model changes
-  dotnet ef migrations has-pending-model-changes \
-    --project "$INFRA_PROJECT" \
-    --startup-project "$API_PROJECT"
-  PENDING_RESULT=$?
-
-  # 2. Apply all migrations on temp database
-  DB_NAME="SmartStack_FinalCheck_$(date +%s)"
-  CONN_STRING="Server=(localdb)\\MSSQLLocalDB;Database=$DB_NAME;Integrated Security=true;TrustServerCertificate=true;Connect Timeout=120;"
-  dotnet ef database update \
-    --connection "$CONN_STRING" \
-    --project "$INFRA_PROJECT" \
-    --startup-project "$API_PROJECT"
-  MIGRATION_RESULT=$?
-
-  # 3. Run integration tests against real SQL Server
-  INT_TEST_PROJECT=$(ls tests/*Tests.Integration*/*.csproj 2>/dev/null | head -1)
-  INT_TEST_RESULT=0
-  if [ -n "$INT_TEST_PROJECT" ]; then
-    dotnet test "$INT_TEST_PROJECT" --no-build --verbosity minimal
-    INT_TEST_RESULT=$?
-  fi
-
-  # 4. Cleanup
-  sqlcmd -S "(localdb)\MSSQLLocalDB" -Q "IF DB_ID('$DB_NAME') IS NOT NULL BEGIN ALTER DATABASE [$DB_NAME] SET SINGLE_USER WITH ROLLBACK IMMEDIATE; DROP DATABASE [$DB_NAME]; END" 2>/dev/null
-
-  # Record results
-  DB_VALIDATION="PASS"
-  [ $PENDING_RESULT -ne 0 ] && DB_VALIDATION="FAIL (pending model changes)"
-  [ $MIGRATION_RESULT -ne 0 ] && DB_VALIDATION="FAIL (migration apply failed)"
-  [ $INT_TEST_RESULT -ne 0 ] && DB_VALIDATION="FAIL (integration tests failed on SQL Server)"
-fi
-```
-
-Include DB validation results in report section:
-```markdown
-## DB Validation (SQL Server LocalDB)
-| Check | Result |
-|-------|--------|
-| Pending model changes | {PENDING_RESULT == 0 ? "PASS" : "FAIL"} |
-| Migrations apply cleanly | {MIGRATION_RESULT == 0 ? "PASS" : "FAIL"} |
-| Integration tests (real SQL Server) | {INT_TEST_RESULT == 0 ? "PASS" : "N/A"} |
-| Overall | {DB_VALIDATION} |
+```javascript
+const testTasks = prd.tasks.filter(t => t.category === 'test');
+const testsPassed = testTasks.filter(t => t.status === 'completed').length;
+const testsFailed = testTasks.filter(t => t.status === 'failed').length;
 ```
 
 ## 2. Generate Report
@@ -188,6 +77,7 @@ Write to `.ralph/reports/{feature-slug}.md`:
 | Iterations | {iterations_used} / {max} |
 | Branch | {branch} |
 | Duration | {totalDuration}s ({min} min) |
+| Execution | Delegated to /apex |
 
 ## Tasks
 | # | Task | Category | Status | Commit |
@@ -207,13 +97,21 @@ Write to `.ralph/reports/{feature-slug}.md`:
 **{completedModules}/{totalModules} modules completed**
 {end if}
 
+{if prd._sectionSplit?.enabled:}
+## Section Split Execution
+| Phase | Type | Section | Entities | Status |
+|-------|------|---------|----------|--------|
+{for each phase:}
+| {phase} | {type} | {sectionCode || '-'} | {entities.length} | {status} |
+
+{end if}
+
 ## Test Metrics
 | Metric | Value |
 |--------|-------|
-| Tests Executed | {yes/no} |
-| Status | {passed/failed} |
-| Total | {n} | Passed | {n} | Failed | {n} |
-| Coverage | {n}% |
+| Test Tasks | {testTasks.length} |
+| Passed | {testsPassed} |
+| Failed | {testsFailed} |
 
 ## Failed Tasks
 {table of failed tasks with error messages, or "None"}
@@ -232,6 +130,16 @@ Write to `.ralph/reports/{feature-slug}.md`:
 ## 3. Finalize
 
 ```javascript
+// Clean up section-split temporary files
+if (prd._sectionSplit?.enabled) {
+  for (const phase of prd._sectionSplit.phases) {
+    if (fileExists(phase.prdFile) && phase.prdFile !== '.ralph/prd.json') {
+      deleteFile(phase.prdFile);
+    }
+  }
+  delete prd._sectionSplit;
+}
+
 prd.updated_at = new Date().toISOString();
 writeJSON('.ralph/prd.json', prd);
 ```