@atlashub/smartstack-cli 4.73.0 → 4.75.0

package/templates/skills/business-analyse-develop/references/report-reconciliation.md

@@ -0,0 +1,140 @@
+# Report Reconciliation: Post-Execution Validation
+
+> **LESSON LEARNED (audit ba-002):** Simple "missing files" warnings were ignored.
+> Structured reconciliation tables make gaps impossible to miss.
+
+## Reconciliation 1: Handoff File Coverage
+
+```javascript
+const filesToCreate = prd.implementation?.filesToCreate || {};
+const handoffReconciliation = { categories: [], totalDeclared: 0, totalPresent: 0, missingFiles: [] };
+
+for (const [cat, files] of Object.entries(filesToCreate)) {
+  let declared = 0, present = 0;
+  for (const file of (files || [])) {
+    declared++;
+    const filePath = file.path || file;
+    if (fileExists(filePath)) {
+      present++;
+    } else {
+      handoffReconciliation.missingFiles.push({ category: cat, path: filePath });
+    }
+  }
+  handoffReconciliation.categories.push({
+    category: cat, declared, present, missing: declared - present,
+    coverage: declared > 0 ? Math.round((present / declared) * 100) : 100
+  });
+  handoffReconciliation.totalDeclared += declared;
+  handoffReconciliation.totalPresent += present;
+}
+
+const totalHandoffCoverage = handoffReconciliation.totalDeclared > 0
+  ? Math.round((handoffReconciliation.totalPresent / handoffReconciliation.totalDeclared) * 100)
+  : 100;
+```
+
+## Reconciliation 2: Business Rule Coverage
+
+```javascript
+const brMapping = prd.implementation?.brToCodeMapping || [];
+const brReconciliation = { total: brMapping.length, implemented: 0, missing: [], notTested: [] };
+
+for (const br of brMapping) {
+  const componentFile = br.component || br.file;
+  const methodName = br.method || br.function;
+
+  if (!componentFile || !fileExists(componentFile)) {
+    brReconciliation.missing.push({ id: br.id, rule: br.rule, reason: 'file not found' });
+    continue;
+  }
+  if (methodName) {
+    const content = readFile(componentFile);
+    if (!content.includes(methodName)) {
+      brReconciliation.missing.push({ id: br.id, rule: br.rule, reason: `method ${methodName} not found` });
+      continue;
+    }
+  }
+  brReconciliation.implemented++;
+
+  if (br.testFile && !fileExists(br.testFile)) {
+    brReconciliation.notTested.push({ id: br.id, rule: br.rule });
+  }
+}
+```
+
+## Reconciliation 3: API Endpoint Coverage
+
+```javascript
+const apiEndpoints = prd.implementation?.apiEndpointSummary || [];
+const apiReconciliation = { total: apiEndpoints.length, found: 0, missing: [] };
+
+const ctrlFilesForReconciliation = glob('src/**/Controllers/**/*Controller.cs');
+for (const ep of apiEndpoints) {
+  const opName = ep.operation || ep.name;
+  let found = false;
+  for (const f of ctrlFilesForReconciliation) {
+    const content = readFile(f);
+    if (content.includes(opName)) { found = true; break; }
+  }
+  if (found) {
+    apiReconciliation.found++;
+  } else {
+    apiReconciliation.missing.push({ operation: opName, method: ep.method, path: ep.path });
+  }
+}
+
+// Log summary
+console.log(`Handoff files: ${handoffReconciliation.totalPresent}/${handoffReconciliation.totalDeclared} (${totalHandoffCoverage}%)`);
+console.log(`Business rules: ${brReconciliation.implemented}/${brReconciliation.total} implemented`);
+console.log(`API endpoints: ${apiReconciliation.found}/${apiReconciliation.total} found`);
+```
+
+## Build & Test Verification (Truth Check)
+
+> **LESSON LEARNED (audit ba-002):** "92/92 COMPLETE" + "Build PASS" was reported but the code
+> had compilation errors and critical security flaws. The report MUST reflect actual build/test
+> state, not just PRD task statuses.
+
+```bash
+# REAL build verification — overrides any previous "Build PASS" claim
+dotnet build --no-restore --verbosity quiet
+FINAL_BUILD_RC=$?
+
+FINAL_TEST_RC=-1
+if [ $FINAL_BUILD_RC -eq 0 ]; then
+  dotnet test --no-build --verbosity quiet
+  FINAL_TEST_RC=$?
+fi
+```
+
+```javascript
+// Override PRD-based build/test status with REAL results
+const buildStatus = FINAL_BUILD_RC === 0 ? 'PASS' : 'FAIL';
+const testStatus = FINAL_TEST_RC === 0 ? 'PASS' : (FINAL_TEST_RC === -1 ? 'SKIPPED (build failed)' : 'FAIL');
+
+// CRITICAL: If build fails despite all tasks "completed", flag this prominently
+if (FINAL_BUILD_RC !== 0 && stats.tasks.completed === stats.tasks.total) {
+  console.error('INTEGRITY WARNING: All tasks marked COMPLETE but build FAILS');
+  console.error('This indicates phantom task completion — review code quality');
+  stats.buildIntegrityWarning = true;
+}
+```
+
+## MCP Security Scan (Final Gate)
+
+```javascript
+// Quick MCP security validation on the final codebase
+const securityScan = await mcp__smartstack__validate_security();
+const conventionScan = await mcp__smartstack__validate_conventions();
+
+// Check for write endpoints with Read permissions (semantic permission check)
+const permissionWarnings = [];
+const ctrlFiles = glob('src/**/Controllers/**/*Controller.cs');
+for (const f of ctrlFiles) {
+  const content = readFile(f);
+  const writeWithRead = content.matchAll(/\[(HttpPost|HttpPut|HttpDelete|HttpPatch)[^\]]*\][^[]*\[RequirePermission\([^\)]*\.Read\)\]/gs);
+  for (const m of writeWithRead) {
+    permissionWarnings.push(`${f}: ${m[1]} uses Read permission`);
+  }
+}
+```

package/templates/skills/business-analyse-develop/references/report-template.md

@@ -0,0 +1,142 @@
+# Report Template Structure
+
+Template for generating the final feature report markdown (written to `.ralph/reports/{feature-slug}.md`).
+
+```markdown
+# Feature Report: {feature}
+
+## Summary
+| Field | Value |
+|-------|-------|
+| Status | {status} |
+| Iterations | {iterations_used} / {max} |
+| Branch | {branch} |
+| Duration | {totalDuration}s ({min} min) |
+| Execution | Delegated to /apex |
+
+## Tasks
+| # | Task | Category | Status | Commit |
+|---|------|----------|--------|--------|
+{for each task:}
+| {id} | {description} | {category} | {status_emoji} | {commit_hash} |
+
+**{completed}/{total} completed, {failed} failed, {blocked} blocked**
+
+{if moduleStats:}
+## Modules
+| Module | Status | Tasks | Completed | Failed | Files | Commits |
+|--------|--------|-------|-----------|--------|-------|---------|
+{for each mod:}
+| {code} | {status} | {total} | {completed} | {failed} | {filesCreated} | {commits} |
+
+**{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}
+
+{if handoffReconciliation.totalDeclared > 0:}
+## Handoff Reconciliation
+
+### File Coverage by Category
+| Category | Declared | Present | Missing | Coverage |
+|----------|----------|---------|---------|----------|
+{for each cat in handoffReconciliation.categories:}
+| {category} | {declared} | {present} | {missing} | {coverage}% |
+{end for}
+
+**Total: {totalPresent}/{totalDeclared} ({totalHandoffCoverage}%)**
+
+{if handoffReconciliation.missingFiles.length > 0:}
+### Missing Files
+{for each mf in handoffReconciliation.missingFiles:}
+- **{mf.category}**: `{mf.path}`
+{end for}
+{end if}
+{end if}
+
+{if brReconciliation.total > 0:}
+### Business Rule Coverage
+| Metric | Value |
+|--------|-------|
+| Total Rules | {brReconciliation.total} |
+| Implemented | {brReconciliation.implemented} |
+| Missing | {brReconciliation.missing.length} |
+| Not Tested | {brReconciliation.notTested.length} |
+
+{if brReconciliation.missing.length > 0:}
+**Missing BR implementations:**
+{for each br in brReconciliation.missing:}
+- `{br.id}`: {br.rule} — {br.reason}
+{end for}
+{end if}
+{end if}
+
+{if apiReconciliation.total > 0:}
+### API Endpoint Coverage
+| Metric | Value |
+|--------|-------|
+| Total Endpoints | {apiReconciliation.total} |
+| Found | {apiReconciliation.found} |
+| Missing | {apiReconciliation.missing.length} |
+
+{if apiReconciliation.missing.length > 0:}
+**Missing API endpoints:**
+{for each ep in apiReconciliation.missing:}
+- `{ep.method} {ep.path}` — operation: `{ep.operation}`
+{end for}
+{end if}
+{end if}
+
+## Build & Test Verification (Actual)
+
+> These results come from REAL `dotnet build` and `dotnet test` execution,
+> not from PRD task statuses.
+
+| Check | Result |
+|-------|--------|
+| `dotnet build` | {buildStatus} |
+| `dotnet test` | {testStatus} |
+| MCP validate_security | {securityScan.status} |
+| MCP validate_conventions | {conventionScan.status} |
+| Permission semantic check | {permissionWarnings.length === 0 ? 'PASS' : `${permissionWarnings.length} issues`} |
+
+{if stats.buildIntegrityWarning:}
+> **INTEGRITY WARNING:** All tasks marked COMPLETE but the build FAILS.
+> This means some generated code references types or methods that don't exist.
+> Review the build output and fix before considering this feature done.
+{end if}
+
+{if permissionWarnings.length > 0:}
+> **PERMISSION WARNINGS:** Write endpoints using Read permissions detected:
+{for each warning:}
+> - {warning}
+{end for}
+{end if}
+
+## Test Metrics (PRD-based)
+| Metric | Value |
+|--------|-------|
+| Test Tasks | {testTasks.length} |
+| Passed | {testsPassed} |
+| Failed | {testsFailed} |
+
+## Failed Tasks
+{table of failed tasks with error messages, or "None"}
+
+## Files
+- Created: {filesCreated.length}
+- Modified: {filesModified.length}
+
+## Commits
+{unique commits list}
+
+---
+*Auto-generated by Ralph Loop — SmartStack CLI*
+```

package/templates/skills/business-analyse-develop/steps/step-01-task.md

@@ -79,146 +79,7 @@ If `{currentPrdPath}` exists:
    - **Run CATEGORY COMPLETENESS CHECK (section 4b) before proceeding**
    - Skip directly to section 5 (find next task)
 2b. **v3 filesToCreate PATH:** If `$version === "3.0.0"` AND `implementation.filesToCreate` exists AND NO `tasks[]`:
-   → Transform filesToCreate into tasks[]:
-
-   ```javascript
-   const ftc = prd.implementation.filesToCreate;
-   const tasks = [];
-   let taskId = 1;
-
-   // CATEGORY ORDER: domain → infrastructure → application → api → seedData → frontend → test → documentation
-   const categoryOrder = ['domain', 'infrastructure', 'application', 'api', 'seedData', 'frontend', 'tests', 'documentation'];
-
-   // Load companion specs if available (for rich acceptance criteria)
-   const specFiles = prd.specificationFiles || {};
-   const specsDir = '.ralph';
-   let specEntities = null, specRules = null, specUsecases = null, specScreens = null, specPermissions = null;
-   try {
-     if (specFiles.entities) specEntities = readJSON(`${specsDir}/${specFiles.entities}`);
-     if (specFiles.rules) specRules = readJSON(`${specsDir}/${specFiles.rules}`);
-     if (specFiles.usecases) specUsecases = readJSON(`${specsDir}/${specFiles.usecases}`);
-     if (specFiles.screens) specScreens = readJSON(`${specsDir}/${specFiles.screens}`);
-     if (specFiles.permissions) specPermissions = readJSON(`${specsDir}/${specFiles.permissions}`);
-   } catch (e) { /* companion files absent — fallback to generic AC */ }
-
-   function deriveAcceptanceCriteria(file, category, prd) {
-     const fileName = (file.path || file).split('/').pop().replace(/\.\w+$/, '');
-
-     // If no companion specs available, fallback to generic AC
-     if (!specEntities && !specRules) {
-       return `File ${file.path || file} exists and compiles`;
-     }
-
-     switch (category) {
-       case 'domain': {
-         const entityName = fileName;
-         const entity = (specEntities?.entities || []).find(e => e.name === entityName);
-         if (entity && entity.attributes) {
-           const attrs = entity.attributes.map(a => `${a.name}:${a.type}`).join(', ');
-           const rels = (entity.relationships || []).map(r => `${r.type} ${r.target}`).join(', ');
-           return `Entity ${entityName} with attributes [${attrs}]${rels ? '. Relations: [' + rels + ']' : ''}`;
-         }
-         break;
-       }
-       case 'application': {
-         const linkedBRs = (prd.brToCodeMapping || [])
-           .filter(br => br.implementationPoints?.some(ip => ip.component?.includes(fileName)))
-           .map(br => `${br.ruleId}: ${br.statement || br.title}`);
-         const linkedUCs = (file.linkedUCs || []).join(', ');
-         if (linkedBRs.length > 0 || linkedUCs) {
-           const parts = [];
-           if (linkedBRs.length > 0) parts.push(`Implements BRs: [${linkedBRs.join('; ')}]`);
-           if (linkedUCs) parts.push(`Handles UCs: [${linkedUCs}]`);
-           return parts.join('. ');
-         }
-         break;
-       }
-       case 'infrastructure': {
-         const entityName = fileName.replace('Configuration', '');
-         const entity = (specEntities?.entities || []).find(e => e.name === entityName);
-         if (entity && entity.attributes) {
-           const props = entity.attributes.map(a => a.name).join(', ');
-           return `EF Config for ${entityName}. Attributes: [${props}]`;
-         }
-         break;
-       }
-       case 'api': {
-         const entityName = fileName.replace('Controller', '');
-         const endpoints = (prd.apiEndpointSummary || [])
-           .filter(ep => ep.operation?.includes(entityName))
-           .map(ep => `${ep.method} ${ep.route}`);
-         const perms = (specPermissions?.permissionPaths || [])
-           .filter(p => p.toLowerCase().includes(entityName.toLowerCase()))
-           .slice(0, 5);
-         const parts = [`Controller ${entityName}`];
-         if (endpoints.length > 0) parts.push(`Endpoints: [${endpoints.join(', ')}]`);
-         if (perms.length > 0) parts.push(`Permissions: [${perms.join(', ')}]`);
-         return parts.join('. ');
-       }
-       case 'frontend': {
-         const screen = (specScreens?.screens || []).find(s =>
-           fileName.toLowerCase().includes(s.code?.toLowerCase() || s.name?.toLowerCase() || '')
-         );
-         if (screen) {
-           const parts = [file.type || 'Page'];
-           if (screen.columns) parts.push(`columns [${screen.columns.map(c => c.key || c.name || c).join(', ')}]`);
-           if (screen.filters) parts.push(`filters [${screen.filters.map(f => f.key || f.name || f).join(', ')}]`);
-           if (screen.actions) parts.push(`actions [${screen.actions.map(a => a.key || a.name || a).join(', ')}]`);
-           if (screen.kpis) parts.push(`KPIs [${screen.kpis.map(k => k.label || k.name || k).join(', ')}]`);
-           return `${parts.join(' with ')}`;
-         }
-         break;
-       }
-       case 'seedData': {
-         if (file.category === 'business') {
-           const entityName = fileName.replace('SeedData', '');
-           const entity = (specEntities?.entities || []).find(e => e.name === entityName);
-           if (entity?.seedValues) {
-             const names = entity.seedValues.map(v => v.name || v.label || v.code).filter(Boolean).slice(0, 5);
-             return `Seeds ${entityName} with ${entity.seedValues.length} values: [${names.join(', ')}]`;
-           }
-         }
-         break;
-       }
-       case 'test': case 'tests': {
-         const linkedBRs = (prd.brToCodeMapping || [])
-           .filter(br => br.implementationPoints?.some(ip =>
-             ip.layer === 'Domain' || ip.layer === 'Application'
-           ))
-           .map(br => br.ruleId);
-         const linkedUCs = (file.linkedUCs || []);
-         const parts = [];
-         if (linkedBRs.length > 0) parts.push(`Covers BRs: [${linkedBRs.join(', ')}]`);
-         if (linkedUCs.length > 0) parts.push(`Covers UCs: [${linkedUCs.join(', ')}]`);
-         if (parts.length > 0) return parts.join('. ');
-         break;
-       }
-     }
-     // Fallback: generic AC
-     return `File ${file.path || file} exists and compiles`;
-   }
-
-   for (const category of categoryOrder) {
-     const files = ftc[category] || [];
-     for (const file of files) {
-       tasks.push({
-         id: `T${String(taskId++).padStart(3, '0')}`,
-         description: `Create ${file.type || category}: ${(file.path || file).split('/').pop()}`,
-         status: 'pending',
-         category: category === 'tests' ? 'test' : category,  // normalize
-         dependencies: [],  // implicit ordering via category
-         acceptance_criteria: deriveAcceptanceCriteria(file, category === 'tests' ? 'test' : category, prd),
-         path: file.path || file,
-         started_at: null, completed_at: null, iteration: null,
-         commit_hash: null, files_changed: [], validation: null, error: null
-       });
-     }
-   }
-
-   prd.tasks = tasks;
-   prd.config = { current_iteration: 1, max_iterations: 50 };
-   writeJSON(currentPrdPath, prd);
-   ```
+   → **Load** `references/prd-v3-transformation.md` for the filesToCreate → tasks transformation algorithm and deriveAcceptanceCriteria() function.
    → Run CATEGORY COMPLETENESS CHECK (section 4b) — will detect if seedData is missing
    → Skip to section 5 (find next task)
 3. **v2 legacy:** If `$version === "2.0.0"` → find next eligible task (section 5)
@@ -228,44 +89,11 @@ If `{currentPrdPath}` does not exist: continue to section 1b.
 
 ### 1b. BA Handoff Quality Gate (BLOCKING when BA artifacts present)
 
-> **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.
+> **Load** `references/handoff-quality-gate.md` for full BA handoff validation checks.
 
-> **INTENTIONAL SKIP:** If `sourceFeatureJson` is null (manual start via `{task_description}`, no BA run),
-> this quality gate is **intentionally skipped** — the loop proceeds in "manual mode" and generates tasks
-> from the task description. This is by design, not a bug. Inform the user in the summary (section 6 of step-00).
-
-```javascript
-const sourceFeatureJson = prd?.metadata?.sourceFeatureJson
-  || findFile('docs/**/business-analyse/**/index.json')
-  || findFile('docs/business/**/business-analyse/**/feature.json');  // legacy fallback
-
-if (!sourceFeatureJson) {
-  // Manual mode: no BA artifacts found — skip quality gate
-  console.log('Manual mode: no BA artifacts detected — tasks will be generated from task description');
-  // Continue to section 2 (Analyze Task Description)
-} else {
-  const feature = readJSON(sourceFeatureJson);
-  const handoff = feature.handoff || {};
-
-  // CHECK 1: Handoff status must be "handed-off"
-  if (handoff.status !== 'handed-off') {
-    console.error(`BLOCKING: BA HANDOFF INCOMPLETE
-handoff.status = "${handoff.status || 'missing'}" (expected "handed-off")
-Run /business-analyse-handoff to generate the handoff, then re-run /business-analyse-develop.`);
-    STOP;
-  }
-
-  // CHECK 2: filesToCreate must have all categories
-  const filesToCreate = handoff.filesToCreate || {};
-  const requiredCategories = ['domain', 'application', 'infrastructure', 'api', 'frontend', 'seedData', 'tests', 'documentation'];
-  const missingInHandoff = requiredCategories.filter(c => !filesToCreate[c] || filesToCreate[c].length === 0);
-
-  if (missingInHandoff.length > 0) {
-    console.warn(`⚠ Handoff has empty categories: ${missingInHandoff.join(', ')}`);
-  }
-}
-```
+Quick check:
+- If no BA artifacts detected (`sourceFeatureJson` is null): skip gate, proceed in manual mode
+- If BA artifacts present: verify `feature.handoff.status === "handed-off"` and `filesToCreate[]` has all categories
 
 ## 2. Analyze Task Description
 

package/templates/skills/business-analyse-develop/steps/step-02-execute.md

@@ -6,6 +6,8 @@ next_step: steps/step-03-commit.md
 
 # Step 2: Delegate to /apex
 
+> **REMINDER:** Ralph NEVER pauses. Execute ALL steps through completion. Stopping to ask = VIOLATION.
+
 > **CONTEXT OPTIMIZATION:** Read ONCE (first iteration). Subsequent iterations use compact-loop.md.
 
 ## YOUR TASK:
@@ -163,12 +165,11 @@ const failed = moduleTasks.filter(t => t.status === 'failed').length;
 const pending = moduleTasks.filter(t => t.status === 'pending').length;
 
 if (failed > 0) {
-  console.log(`WARNING: ${failed} tasks failed during apex execution`);
-  // Failed tasks will be retried in compact loop
+  console.log(`WARNING: ${failed} tasks failed — WILL BE RETRIED IMMEDIATELY in compact loop (next iteration)`);
 }
 
 if (pending > 0) {
-  console.log(`INFO: ${pending} tasks still pending — will be handled in compact loop`);
+  console.log(`INFO: ${pending} tasks pending — WILL BE PROCESSED IMMEDIATELY in compact loop (next iteration)`);
 }
 
 console.log(`Apex completed: ${completed}/${moduleTasks.length} tasks`);
@@ -190,6 +191,18 @@ appendFile('.ralph/progress.txt', progressEntry);
 
 ---
 
+## TRANSITION RULE (ABSOLUTE — NO EXCEPTIONS)
+
++==============================================================================+
+|  AFTER APEX RETURNS, YOU MUST IMMEDIATELY PROCEED TO STEP 03.               |
+|  DO NOT pause. DO NOT summarize. DO NOT ask the user.                       |
+|  DO NOT display a progress report and wait.                                  |
+|  Regardless of task failures, pending items, or scope size:                 |
+|  -> LOG the status (section 4-5 above)                                      |
+|  -> IMMEDIATELY load step-03-commit.md                                      |
+|  Any other behavior = EXECUTION GUARANTEE VIOLATION.                        |
++==============================================================================+
+
 ## CONSTRAINTS:
 
 - **DO:** Delegate to apex, verify results, maintain PRD state
@@ -200,4 +213,4 @@ appendFile('.ralph/progress.txt', progressEntry);
 
 ## NEXT STEP:
 
-Proceed to `./step-03-commit.md`
+IMMEDIATELY proceed to `./step-03-commit.md` — NO PAUSE.

package/templates/skills/business-analyse-develop/steps/step-03-commit.md

@@ -6,6 +6,8 @@ next_step: steps/step-04-check.md
 
 # Step 3: Commit PRD State
 
+> **REMINDER:** Ralph NEVER pauses. Execute ALL steps through completion. Stopping to ask = VIOLATION.
+
 > **CONTEXT OPTIMIZATION:** Read ONCE (first iteration). Subsequent iterations use compact-loop.md.
 
 ## YOUR TASK:
@@ -98,6 +100,8 @@ git log -2 --oneline
 
 ---
 
-## NEXT STEP:
+## NEXT STEP — IMMEDIATE (NO PAUSE)
 
-After commit, proceed to `./step-04-check.md`
+IMMEDIATELY proceed to `./step-04-check.md`.
+DO NOT pause. DO NOT summarize to the user. DO NOT ask for confirmation.
+The compact loop in step-04 handles ALL remaining work automatically.

package/templates/skills/business-analyse-develop/steps/step-04-check.md

@@ -6,6 +6,8 @@ next_step: steps/step-05-report.md OR steps/step-01-task.md
 
 # Step 4: Check Completion
 
+> **REMINDER:** Ralph NEVER pauses. Execute ALL steps through completion. Stopping to ask = VIOLATION.
+
 > **STATE RECOVERY (executable):** If context was compressed:
 ```javascript
 if (fileExists('.ralph/ralph-state.json')) {
@@ -19,6 +21,10 @@ if (fileExists('.ralph/ralph-state.json')) {
 }
 ```
 
+> **POST-RECOVERY RULE:** After restoring state from ralph-state.json,
+> IMMEDIATELY re-enter the execution loop below. DO NOT pause. DO NOT summarize.
+> Route to the correct section and CONTINUE. Stopping here = VIOLATION.
+
 ## YOUR TASK:
 
 Check if all tasks are complete and decide: output completion promise, advance module, or continue loop.