@llm-dev-ops/agentics-cli 2.7.0 → 2.7.2

package/dist/pipeline/auto-chain.js

@@ -14,6 +14,7 @@
  *   Phase 6: ERP Surface Push (registration + project materialization)
  */
 import { execSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { executePhase2Command, formatPhase2ForDisplay } from '../commands/phase2.js';
@@ -23,7 +24,8 @@ import { executePhase5Command, formatPhase5ForDisplay } from '../commands/phase5
 import { executePhase6Command, formatPhase6ForDisplay, copyTreeForOutput } from '../commands/phase6.js';
 import { detectExecutionMode, commitScenarioFiles, } from './execution-context.js';
 import { initSwarm, dispatchPhaseAgents, storePhaseArtifacts, reviewPhaseOutput, recordPhaseFailure, shutdownSwarm, invokeRufloCodingSwarm, PHASE_AGENTS, } from './swarm-orchestrator.js';
-import { executeRufloPhaseSwarm, buildPhase2Tasks, buildPhase3Tasks, buildPhase4Tasks, buildPhase5Tasks, buildPhase6Tasks, collectPhase2Artifacts, collectPhase3Artifacts, collectPhase4Artifacts, collectPhase5Artifacts, collectPhase6Artifacts, extractPhase1AgentCode, } from './ruflo-phase-executor.js';
+import { executeRufloPhaseSwarm, buildPhase2Tasks, buildPhase3Tasks, buildPhase4Tasks, buildPhase5Tasks, buildPhase6Tasks, collectPhase2Artifacts, collectPhase3Artifacts, collectPhase4Artifacts, collectPhase5Artifacts, collectPhase6Artifacts, extractPhase1AgentCode, runPrimaryPhaseExecution, } from './ruflo-phase-executor.js';
+import { gatePhaseInputs, determineBlockedPhases, } from './gate/phase-dependency-gate.js';
 /** Extract path strings from any manifest artifact array (objects with .path or plain strings). */
 function extractArtifactPaths(artifacts) {
     return artifacts.map(a => typeof a === 'string' ? a : a.path);
@@ -77,6 +79,347 @@ function copyDirRecursive(src, dest) {
     }
     return { copied, skipped };
 }
+/**
+ * Ordered candidate-source table (Rule 1). First non-empty source wins for
+ * each slot; later sources only fill a slot that is still empty, unless the
+ * source is marked `additive`.
+ */
+const PLAN_SLOT_SOURCES = {
+    sparc: [
+        { relPath: 'phase3/sparc', kind: 'dir' },
+        { relPath: 'phase2/sparc', kind: 'dir' },
+        {
+            relPath: 'engineering/sparc-specification.md',
+            kind: 'file',
+            destFilename: 'specification.md',
+            requireSlotEmpty: true,
+            engineeringPrimary: true,
+            rufloHeader: '<!-- Ruflo primary output (ADR-PIPELINE-092) — will be overwritten when Phase 3 produces structured SPARC artifacts -->',
+        },
+    ],
+    adrs: [
+        { relPath: 'phase4/adrs', kind: 'dir' },
+        { relPath: 'phase2/adrs', kind: 'dir' },
+        {
+            relPath: 'engineering/architecture-decisions.md',
+            kind: 'file',
+            destFilename: 'ADR-ENG-001-architecture-decisions.md',
+            requireSlotEmpty: true,
+            engineeringPrimary: true,
+            rufloHeader: '<!-- Ruflo primary output (ADR-PIPELINE-092) — will be overwritten when Phase 4 produces structured ADRs -->',
+        },
+        { relPath: 'adrs', kind: 'dir' },
+    ],
+    ddd: [
+        { relPath: 'phase4/ddd', kind: 'dir' },
+        { relPath: 'phase2/ddd', kind: 'dir' },
+        {
+            relPath: 'engineering/domain-model.md',
+            kind: 'file',
+            destFilename: 'domain-model.md',
+            requireSlotEmpty: true,
+            engineeringPrimary: true,
+            rufloHeader: '<!-- Ruflo primary output (ADR-PIPELINE-092) — will be overwritten when Phase 4 produces a structured domain model -->',
+        },
+    ],
+    tdd: [
+        { relPath: 'phase3/tdd', kind: 'dir' },
+        { relPath: 'phase2/tdd', kind: 'dir' },
+        {
+            relPath: 'engineering/tdd-test-plan.md',
+            kind: 'file',
+            destFilename: 'test-plan.md',
+            requireSlotEmpty: true,
+            engineeringPrimary: true,
+            rufloHeader: '<!-- Ruflo primary output (ADR-PIPELINE-092) — will be overwritten when Phase 3 produces a structured TDD plan -->',
+        },
+    ],
+    prompts: [
+        { relPath: 'prompts', kind: 'dir' },
+        { relPath: 'phase4/prompts', kind: 'dir' },
+        {
+            relPath: 'phase3/implementation-prompt.md',
+            kind: 'file',
+            destFilename: 'phase3-implementation-prompt.md',
+        },
+    ],
+    implementation: [
+        { relPath: 'phase1/roadmap.json', kind: 'file', destFilename: 'roadmap.json' },
+        { relPath: 'roadmap.json', kind: 'file', destFilename: 'roadmap.json' },
+        { relPath: 'scenario.json', kind: 'file', destFilename: 'scenario.json' },
+        {
+            relPath: 'engineering/implementation-roadmap.md',
+            kind: 'file',
+            destFilename: 'roadmap.md',
+            additive: true,
+            engineeringPrimary: true,
+            rufloHeader: '<!-- Ruflo primary output (ADR-PIPELINE-092) — promoted alongside Phase 1 roadmap.json -->',
+        },
+    ],
+};
+/**
+ * Engineering (Ruflo primary-output) placeholder threshold — any single-file
+ * engineering source whose size is at or below this value is rejected as a
+ * stub and never promoted.
+ */
+const ENGINEERING_MIN_SIZE_BYTES = 256;
+/**
+ * sha256 hashes of known placeholder templates that Ruflo may emit before it
+ * has real content. Any engineering/*.md file whose content hash matches is
+ * rejected even if its size is above the threshold. Starts empty but the
+ * `has()` lookup is O(1) and additions here propagate automatically.
+ */
+const ENGINEERING_PLACEHOLDER_HASHES = new Set([]);
+/**
+ * Pick the single best candidate source for a slot given which slot files
+ * are already present. Phase-refined sources (no `requireSlotEmpty`) win
+ * over `engineering/*` (which sets `requireSlotEmpty: true`). Returns `null`
+ * when nothing qualifies.
+ */
+function pickBestSourceForSlot(runDir, _slot, slotHasContent, candidateSources) {
+    for (const source of candidateSources) {
+        if (source.requireSlotEmpty && slotHasContent)
+            continue;
+        const abs = path.join(runDir, source.relPath);
+        if (!fs.existsSync(abs))
+            continue;
+        if (source.kind === 'dir') {
+            try {
+                const entries = fs.readdirSync(abs);
+                if (entries.length === 0)
+                    continue;
+            }
+            catch {
+                continue;
+            }
+        }
+        else {
+            try {
+                const st = fs.statSync(abs);
+                if (!st.isFile() || st.size === 0)
+                    continue;
+            }
+            catch {
+                continue;
+            }
+        }
+        return source;
+    }
+    return null;
+}
+/** Returns true if the directory exists and has at least one file inside it (recursively). */
+function slotDirHasFiles(slotDir) {
+    if (!fs.existsSync(slotDir))
+        return false;
+    try {
+        const entries = fs.readdirSync(slotDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile())
+                return true;
+            if (entry.isDirectory()) {
+                if (slotDirHasFiles(path.join(slotDir, entry.name)))
+                    return true;
+            }
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Gate an engineering/*.md source through the placeholder threshold: size
+ * must exceed ENGINEERING_MIN_SIZE_BYTES and its sha256 must not be in the
+ * ENGINEERING_PLACEHOLDER_HASHES allow-list. Returns the file buffer on
+ * pass, or `null` on reject.
+ */
+function readEngineeringPrimaryOrReject(absPath) {
+    try {
+        const stat = fs.statSync(absPath);
+        if (stat.size <= ENGINEERING_MIN_SIZE_BYTES)
+            return null;
+        const buf = fs.readFileSync(absPath);
+        const hash = createHash('sha256').update(buf).digest('hex');
+        if (ENGINEERING_PLACEHOLDER_HASHES.has(hash))
+            return null;
+        return buf;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Promote a single source into a slot. Returns `{copied, skipped}` counts.
+ * For `kind === 'dir'` sources this performs an additive file-level merge
+ * (dedup by destination filename, byte-identical skips). For `kind === 'file'`
+ * sources it writes a single file, optionally prepending the Ruflo header.
+ */
+function promoteSourceIntoSlot(runDir, slotDir, source) {
+    const absSrc = path.join(runDir, source.relPath);
+    if (!fs.existsSync(absSrc))
+        return { copied: 0, skipped: 0 };
+    if (source.kind === 'dir') {
+        return copyDirRecursive(absSrc, slotDir);
+    }
+    // kind === 'file'
+    const destName = source.destFilename ?? path.basename(source.relPath);
+    const destPath = path.join(slotDir, destName);
+    let buf;
+    if (source.engineeringPrimary) {
+        buf = readEngineeringPrimaryOrReject(absSrc);
+        if (buf === null)
+            return { copied: 0, skipped: 0 };
+    }
+    else {
+        try {
+            buf = fs.readFileSync(absSrc);
+        }
+        catch {
+            return { copied: 0, skipped: 0 };
+        }
+    }
+    // Prepend Ruflo header when applicable.
+    let outBuf = buf;
+    if (source.rufloHeader) {
+        const needsHeader = !buf.toString('utf-8').startsWith(source.rufloHeader);
+        if (needsHeader) {
+            outBuf = Buffer.from(`${source.rufloHeader}\n\n${buf.toString('utf-8')}`, 'utf-8');
+        }
+    }
+    // Dedup: if destination already exists and matches byte-for-byte, skip.
+    if (fs.existsSync(destPath)) {
+        try {
+            const existing = fs.readFileSync(destPath);
+            if (existing.equals(outBuf))
+                return { copied: 0, skipped: 1 };
+        }
+        catch { /* fall through to overwrite */ }
+    }
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    fs.writeFileSync(destPath, outBuf);
+    return { copied: 1, skipped: 0 };
+}
+/**
+ * Shared table-driven promotion routine (ADR-PIPELINE-092, Rules 1–5).
+ *
+ * Walks `PLAN_SLOT_SOURCES` for every slot, picks the best source via
+ * `pickBestSourceForSlot`, promotes the source into the slot, then runs
+ * any additive sources on top. Emits the `[PLANS] promoted ...` stderr
+ * summary and one `[PLANS] MISSING <slot>` line per empty-and-unrecoverable
+ * slot. Returns the summary so callers (final safety-net call) can merge
+ * `planPromotion` into `manifest.json`.
+ */
+export function promotePlanningArtifacts(runDir, projectRoot) {
+    const plansDir = path.join(projectRoot, '.agentics', 'plans');
+    const counts = {
+        sparc: 0, adrs: 0, ddd: 0, tdd: 0, prompts: 0, implementation: 0,
+    };
+    const missing_slots = [];
+    let total_copied = 0;
+    let total_skipped = 0;
+    const slots = ['sparc', 'adrs', 'ddd', 'tdd', 'prompts', 'implementation'];
+    for (const slot of slots) {
+        const slotDir = path.join(plansDir, slot);
+        const sources = PLAN_SLOT_SOURCES[slot];
+        // Step 1: pick-best — the first qualifying non-additive source.
+        let slotHasContent = slotDirHasFiles(slotDir);
+        const best = pickBestSourceForSlot(runDir, slot, slotHasContent, sources.filter(s => !s.additive));
+        if (best) {
+            const r = promoteSourceIntoSlot(runDir, slotDir, best);
+            counts[slot] += r.copied;
+            total_copied += r.copied;
+            total_skipped += r.skipped;
+            if (r.copied > 0 || r.skipped > 0)
+                slotHasContent = true;
+        }
+        // Step 2: additive sources always run (currently only
+        // engineering/implementation-roadmap.md → plans/implementation/roadmap.md).
+        for (const source of sources) {
+            if (!source.additive)
+                continue;
+            const abs = path.join(runDir, source.relPath);
+            if (!fs.existsSync(abs))
+                continue;
+            const r = promoteSourceIntoSlot(runDir, slotDir, source);
+            counts[slot] += r.copied;
+            total_copied += r.copied;
+            total_skipped += r.skipped;
+            if (r.copied > 0 || r.skipped > 0)
+                slotHasContent = true;
+        }
+        // Step 3: MISSING escalation — only when every candidate source genuinely
+        // had zero promotable content. For engineering-primary sources, "promotable"
+        // also means passing the placeholder threshold; a rejected stub counts as
+        // empty so the MISSING line still fires. This keeps the warning honest.
+        if (!slotHasContent) {
+            const anyCandidateExists = sources.some(s => {
+                const abs = path.join(runDir, s.relPath);
+                if (!fs.existsSync(abs))
+                    return false;
+                if (s.kind === 'dir') {
+                    try {
+                        return fs.readdirSync(abs).length > 0;
+                    }
+                    catch {
+                        return false;
+                    }
+                }
+                try {
+                    if (fs.statSync(abs).size === 0)
+                        return false;
+                }
+                catch {
+                    return false;
+                }
+                if (s.engineeringPrimary) {
+                    return readEngineeringPrimaryOrReject(abs) !== null;
+                }
+                return true;
+            });
+            if (!anyCandidateExists) {
+                missing_slots.push(slot);
+            }
+        }
+    }
+    // Rule 5 — one-line stderr summary with per-slot counts.
+    const summaryLine = `[PLANS] promoted ${total_copied} files across {sparc:${counts.sparc}, adrs:${counts.adrs}, ddd:${counts.ddd}, tdd:${counts.tdd}, prompts:${counts.prompts}, implementation:${counts.implementation}}`;
+    process.stderr.write(`  ${summaryLine}\n`);
+    for (const slot of missing_slots) {
+        process.stderr.write(`  [PLANS] MISSING ${slot} — no source artifacts found in any candidate directory\n`);
+    }
+    return { counts, missing_slots, total_copied, total_skipped };
+}
+/**
+ * Merge the ADR-PIPELINE-092 `planPromotion` block into `runDir/manifest.json`.
+ * Read-modify-write pattern mirrors `writeExecutionBlockToManifest`.
+ */
+export function writePlanPromotionToManifest(runDir, summary) {
+    const manifestPath = path.join(runDir, 'manifest.json');
+    try {
+        let manifest = {};
+        if (fs.existsSync(manifestPath)) {
+            try {
+                manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+            }
+            catch {
+                manifest = {};
+            }
+        }
+        manifest['planPromotion'] = {
+            sparc: summary.counts.sparc,
+            adrs: summary.counts.adrs,
+            ddd: summary.counts.ddd,
+            tdd: summary.counts.tdd,
+            prompts: summary.counts.prompts,
+            implementation: summary.counts.implementation,
+            missing_slots: summary.missing_slots,
+        };
+        fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), { mode: 0o600, encoding: 'utf-8' });
+    }
+    catch (err) {
+        process.stderr.write(`  [PLANS] Failed to merge planPromotion into manifest.json: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
+}
 /**
  * Copy whatever planning artifacts exist from ~/.agentics/runs/<traceId>/
  * to .agentics/plans/ in the current working directory. Uses .agentics/plans/
@@ -1388,7 +1731,7 @@ export function detectScaffoldDuplicates(projectRoot, owned = OWNED_SCAFFOLD_MOD
     walk(projectRoot);
     return findings;
 }
-function copyPlanningArtifacts(runDir, targetRoot) {
+export function copyPlanningArtifacts(runDir, targetRoot) {
     try {
         // ADR-051: Use git repo root (or explicit target) instead of process.cwd()
         // When running as MCP server, process.cwd() may not be the user's project directory
@@ -1408,62 +1751,101 @@ function copyPlanningArtifacts(runDir, targetRoot) {
             fs.copyFileSync(src, dest);
             totalCopied++;
         }
-        /** Accumulate results from copyDirRecursive. */
-        function copyDirAccum(src, dest) {
-            const r = copyDirRecursive(src, dest);
-            totalCopied += r.copied;
-            totalSkipped += r.skipped;
-        }
-        // SPARC: prefer Phase 3 refined, fall back to Phase 2
-        const phase3Sparc = path.join(runDir, 'phase3', 'sparc');
-        const phase2Sparc = path.join(runDir, 'phase2', 'sparc');
-        const sparcSource = fs.existsSync(phase3Sparc) ? phase3Sparc : phase2Sparc;
-        copyDirAccum(sparcSource, path.join(plansDir, 'sparc'));
-        // ADRs from Phase 4
-        copyDirAccum(path.join(runDir, 'phase4', 'adrs'), path.join(plansDir, 'adrs'));
-        // DDD from Phase 4 (or Phase 2 fallback)
-        const phase4Ddd = path.join(runDir, 'phase4', 'ddd');
-        const phase2Ddd = path.join(runDir, 'phase2', 'ddd');
-        const dddSource = fs.existsSync(phase4Ddd) ? phase4Ddd : phase2Ddd;
-        copyDirAccum(dddSource, path.join(plansDir, 'ddd'));
-        // TDD from Phase 2 or 3
-        const phase3Tdd = path.join(runDir, 'phase3', 'tdd');
-        const phase2Tdd = path.join(runDir, 'phase2', 'tdd');
-        const tddSource = fs.existsSync(phase3Tdd) ? phase3Tdd : phase2Tdd;
-        copyDirAccum(tddSource, path.join(plansDir, 'tdd'));
+        // ADR-PIPELINE-092: table-driven plan-slot promotion. The shared
+        // `promotePlanningArtifacts` helper handles candidate-source discovery
+        // (Rule 1), engineering/ → plans/ mapping with placeholder rejection
+        // (Rule 2 + 2.5), conflict resolution (Rule 4), and `[PLANS]` stderr
+        // observability (Rule 5). Returns per-slot counts used to merge the
+        // `planPromotion` block into `manifest.json` at the end of this call.
+        const promotionSummary = promotePlanningArtifacts(runDir, projectRoot);
+        totalCopied += promotionSummary.total_copied;
+        totalSkipped += promotionSummary.total_skipped;
         // Phase 1 artifacts (always available after Phase 1)
-        for (const file of ['scenario.json', 'roadmap.json']) {
-            copySingleFile(path.join(runDir, file), path.join(plansDir, 'implementation', file));
-        }
         for (const file of ['executive-summary.md', 'decision-memo.md', 'risk-assessment.json', 'manifest.json']) {
             copySingleFile(path.join(runDir, file), path.join(plansDir, file));
         }
         // Research dossier from Phase 2
         copySingleFile(path.join(runDir, 'phase2', 'research-dossier.json'), path.join(plansDir, 'research-dossier.json'));
         copySingleFile(path.join(runDir, 'phase2', 'research-dossier.md'), path.join(plansDir, 'research-dossier.md'));
-        // Implementation prompts from prompt-generator (ADR-driven prompts)
-        const promptsDir = path.join(runDir, 'prompts');
-        copyDirAccum(promptsDir, path.join(plansDir, 'prompts'));
-        // Implementation prompt from Phase 3 (Ruflo swarm directive)
-        copySingleFile(path.join(runDir, 'phase3', 'implementation-prompt.md'), path.join(plansDir, 'prompts', 'phase3-implementation-prompt.md'));
-        // Implementation prompts from Phase 4 (domain codegen prompts)
-        const phase4Prompts = path.join(runDir, 'phase4', 'prompts');
-        copyDirAccum(phase4Prompts, path.join(plansDir, 'prompts', 'phase4'));
         // Phase 5 integration inference results
         copySingleFile(path.join(runDir, 'phase5', 'integration-inference.json'), path.join(plansDir, 'integration-inference.json'));
-        // ADR-PIPELINE-039: Write actual scaffold files that Claude Code can include directly.
-        // These are the cross-cutting infrastructure modules that every project needs.
-        // Instead of hoping the coding agent reads the prompts, we deliver the files.
-        const scaffoldDir = path.join(plansDir, 'scaffold', 'src');
-        fs.mkdirSync(scaffoldDir, { recursive: true });
-        // ADR-PIPELINE-074: logger scaffold now uses AsyncLocalStorage for
-        // concurrent-request correctness. Body lives in LOGGER_SCAFFOLD at
-        // module scope so it can be unit-tested independently.
-        const loggerCode = LOGGER_SCAFFOLD;
-        // ADR-PIPELINE-039 + ADR-PIPELINE-075: AppConfig now includes a `db`
-        // block so the composition root can pick sqlite (production) vs
-        // in-memory (tests) without code changes.
-        const configCode = `// Auto-generated by Agentics pipeline (ADR-039 + ADR-PIPELINE-075)
+        // ADR-PIPELINE-093 Rule 5 — Scaffold-language gate. Detect the project
+        // language ONCE and let `decideScaffoldEmission` pick which template
+        // blocks to emit. TS project → only TS block runs. Python project →
+        // only Python block runs. Go/Rust/unknown → both blocks skip and the
+        // mismatch is persisted into `manifest.json`.
+        let emitTsScaffold = true;
+        let emitPyScaffold = true;
+        try {
+            const phase1ManifestPath = path.join(runDir, 'manifest.json');
+            let phase1Manifest;
+            if (fs.existsSync(phase1ManifestPath)) {
+                try {
+                    phase1Manifest = JSON.parse(fs.readFileSync(phase1ManifestPath, 'utf-8'));
+                }
+                catch {
+                    phase1Manifest = undefined;
+                }
+            }
+            const detected = detectProjectLanguage(projectRoot, phase1Manifest);
+            const decision = decideScaffoldEmission(detected);
+            emitTsScaffold = decision.emitTs;
+            emitPyScaffold = decision.emitPy;
+            if (decision.skipped) {
+                process.stderr.write(`  [SCAFFOLD] skipped — language mismatch (detected: ${decision.skipped.detected}, templates: ${decision.skipped.template})\n`);
+                // Persist the skip into manifest.json so `writeGateBlockToManifest`
+                // (later in the pipeline) can merge it into the gate block without
+                // losing it. Read-modify-write matches the pattern used by sibling
+                // writers in this file.
+                try {
+                    let mf = {};
+                    if (fs.existsSync(phase1ManifestPath)) {
+                        try {
+                            mf = JSON.parse(fs.readFileSync(phase1ManifestPath, 'utf-8'));
+                        }
+                        catch {
+                            mf = {};
+                        }
+                    }
+                    mf['phase5b_skipped'] = decision.skipped;
+                    fs.writeFileSync(phase1ManifestPath, JSON.stringify(mf, null, 2), { mode: 0o600, encoding: 'utf-8' });
+                }
+                catch { /* best-effort */ }
+            }
+        }
+        catch { /* language detection is best-effort; default to emit both (prev behaviour) */ }
+        if (!emitTsScaffold && !emitPyScaffold) {
+            // Rule 5 — no matching scaffold templates for this language. Plan
+            // promotion (sparc/adrs/ddd/tdd/prompts slots) already ran above and
+            // is language-agnostic, so it stays.
+            if (totalCopied > 0 || totalSkipped > 0) {
+                const parts = [];
+                if (totalCopied > 0)
+                    parts.push(`${totalCopied} copied`);
+                if (totalSkipped > 0)
+                    parts.push(`${totalSkipped} unchanged (skipped)`);
+                console.error(`  [PLANS] ${parts.join(', ')} → .agentics/plans/`);
+            }
+            writePlanPromotionToManifest(runDir, promotionSummary);
+            return;
+        }
+        // The TS-scaffold block below is fenced by this flag. Everything from
+        // the scaffoldDir creation through the OWNED_MODULES + duplicate-scan
+        // pass is TS-only — when the detected language is Python, skip it.
+        if (emitTsScaffold) {
+            // ADR-PIPELINE-039: Write actual scaffold files that Claude Code can include directly.
+            // These are the cross-cutting infrastructure modules that every project needs.
+            // Instead of hoping the coding agent reads the prompts, we deliver the files.
+            const scaffoldDir = path.join(plansDir, 'scaffold', 'src');
+            fs.mkdirSync(scaffoldDir, { recursive: true });
+            // ADR-PIPELINE-074: logger scaffold now uses AsyncLocalStorage for
+            // concurrent-request correctness. Body lives in LOGGER_SCAFFOLD at
+            // module scope so it can be unit-tested independently.
+            const loggerCode = LOGGER_SCAFFOLD;
+            // ADR-PIPELINE-039 + ADR-PIPELINE-075: AppConfig now includes a `db`
+            // block so the composition root can pick sqlite (production) vs
+            // in-memory (tests) without code changes.
+            const configCode = `// Auto-generated by Agentics pipeline (ADR-039 + ADR-PIPELINE-075)
 export interface AppConfig {
   env: 'development' | 'staging' | 'production' | 'test';
   port: number;
@@ -1496,7 +1878,7 @@ export const config: AppConfig = {
   },
 };
 `;
-        const errorsCode = `// Auto-generated by Agentics pipeline (ADR-039)
+            const errorsCode = `// Auto-generated by Agentics pipeline (ADR-039)
 export class AppError extends Error {
   constructor(message: string, public readonly code: string, public readonly statusCode = 500) {
     super(message);
@@ -1522,35 +1904,35 @@ export class ERPError extends AppError {
   }
 }
 `;
-        // TypeScript scaffold (default)
-        fs.writeFileSync(path.join(scaffoldDir, 'logger.ts'), loggerCode, 'utf-8');
-        // ADR-PIPELINE-074: ship a concurrency regression test next to the
-        // logger so generated projects fail loudly if someone reintroduces
-        // a module-level correlation-ID store.
-        fs.writeFileSync(path.join(scaffoldDir, 'logger.concurrency.test.ts'), LOGGER_CONCURRENCY_TEST_SCAFFOLD, 'utf-8');
-        fs.writeFileSync(path.join(scaffoldDir, 'config.ts'), configCode, 'utf-8');
-        fs.writeFileSync(path.join(scaffoldDir, 'errors.ts'), errorsCode, 'utf-8');
-        // ADR-PIPELINE-075: Scaffolded persistence layer — Repository<T> +
-        // InMemoryRepository + SqliteRepository + AppendOnlyAuditRepository.
-        // Every stateful service should import these instead of rolling a
-        // Map<string, T> store. PGV-017 flags the anti-pattern at post-gen time.
-        const persistenceDir = path.join(scaffoldDir, 'persistence');
-        fs.mkdirSync(persistenceDir, { recursive: true });
-        fs.writeFileSync(path.join(persistenceDir, 'repository.ts'), REPOSITORY_SCAFFOLD, 'utf-8');
-        fs.writeFileSync(path.join(persistenceDir, 'in-memory-repository.ts'), IN_MEMORY_REPO_SCAFFOLD, 'utf-8');
-        fs.writeFileSync(path.join(persistenceDir, 'sqlite-repository.ts'), SQLITE_REPO_SCAFFOLD, 'utf-8');
-        fs.writeFileSync(path.join(persistenceDir, 'audit-repository.ts'), AUDIT_REPO_SCAFFOLD, 'utf-8');
-        // ADR-PIPELINE-078: deep canonical JSON + audit hash helper.
-        // Every generated AuditService should import hashAuditEntry from this
-        // helper instead of hand-rolling JSON.stringify + createHash chains.
-        // PGV-022 flags the anti-pattern at post-gen time.
-        fs.writeFileSync(path.join(persistenceDir, 'canonical-json.ts'), CANONICAL_JSON_SCAFFOLD, 'utf-8');
-        fs.writeFileSync(path.join(persistenceDir, 'audit-hash.ts'), AUDIT_HASH_SCAFFOLD, 'utf-8');
-        // ADR-051 + ADR-PIPELINE-074: Correlation ID middleware now wraps next()
-        // in runWithCorrelation so the ID lives in AsyncLocalStorage for the
-        // request's entire async continuation. Concurrent requests cannot
-        // cross-contaminate log lines.
-        const middlewareCode = `// Auto-generated by Agentics pipeline (ADR-051 + ADR-PIPELINE-074)
+            // TypeScript scaffold (default)
+            fs.writeFileSync(path.join(scaffoldDir, 'logger.ts'), loggerCode, 'utf-8');
+            // ADR-PIPELINE-074: ship a concurrency regression test next to the
+            // logger so generated projects fail loudly if someone reintroduces
+            // a module-level correlation-ID store.
+            fs.writeFileSync(path.join(scaffoldDir, 'logger.concurrency.test.ts'), LOGGER_CONCURRENCY_TEST_SCAFFOLD, 'utf-8');
+            fs.writeFileSync(path.join(scaffoldDir, 'config.ts'), configCode, 'utf-8');
+            fs.writeFileSync(path.join(scaffoldDir, 'errors.ts'), errorsCode, 'utf-8');
+            // ADR-PIPELINE-075: Scaffolded persistence layer — Repository<T> +
+            // InMemoryRepository + SqliteRepository + AppendOnlyAuditRepository.
+            // Every stateful service should import these instead of rolling a
+            // Map<string, T> store. PGV-017 flags the anti-pattern at post-gen time.
+            const persistenceDir = path.join(scaffoldDir, 'persistence');
+            fs.mkdirSync(persistenceDir, { recursive: true });
+            fs.writeFileSync(path.join(persistenceDir, 'repository.ts'), REPOSITORY_SCAFFOLD, 'utf-8');
+            fs.writeFileSync(path.join(persistenceDir, 'in-memory-repository.ts'), IN_MEMORY_REPO_SCAFFOLD, 'utf-8');
+            fs.writeFileSync(path.join(persistenceDir, 'sqlite-repository.ts'), SQLITE_REPO_SCAFFOLD, 'utf-8');
+            fs.writeFileSync(path.join(persistenceDir, 'audit-repository.ts'), AUDIT_REPO_SCAFFOLD, 'utf-8');
+            // ADR-PIPELINE-078: deep canonical JSON + audit hash helper.
+            // Every generated AuditService should import hashAuditEntry from this
+            // helper instead of hand-rolling JSON.stringify + createHash chains.
+            // PGV-022 flags the anti-pattern at post-gen time.
+            fs.writeFileSync(path.join(persistenceDir, 'canonical-json.ts'), CANONICAL_JSON_SCAFFOLD, 'utf-8');
+            fs.writeFileSync(path.join(persistenceDir, 'audit-hash.ts'), AUDIT_HASH_SCAFFOLD, 'utf-8');
+            // ADR-051 + ADR-PIPELINE-074: Correlation ID middleware now wraps next()
+            // in runWithCorrelation so the ID lives in AsyncLocalStorage for the
+            // request's entire async continuation. Concurrent requests cannot
+            // cross-contaminate log lines.
+            const middlewareCode = `// Auto-generated by Agentics pipeline (ADR-051 + ADR-PIPELINE-074)
 import { randomUUID } from 'node:crypto';
 import { createLogger, runWithCorrelation } from './logger.js';
 
@@ -1629,35 +2011,35 @@ export function metricsHandlerExpress(_req: any, res: any): void {
 // while making the canonical class importable from a dedicated file.
 export { CircuitBreaker } from './circuit-breaker.js';
 `;
-        fs.writeFileSync(path.join(scaffoldDir, 'middleware.ts'), middlewareCode, 'utf-8');
-        totalCopied += 1;
-        // ADR-PIPELINE-069: standalone scaffolded circuit-breaker module so
-        // generators can import CircuitBreaker without pulling all of
-        // middleware.ts. Owned by the scaffold (see OWNED_SCAFFOLD_MODULES).
-        fs.writeFileSync(path.join(scaffoldDir, 'circuit-breaker.ts'), CIRCUIT_BREAKER_SCAFFOLD, 'utf-8');
-        totalCopied += 1;
-        // ADR-PIPELINE-076: wire-complete Hono base app. Generators extend
-        // via createBaseApp(deps).route('/api/<domain>', router) instead of
-        // rebuilding the middleware/metrics/health plumbing from scratch.
-        // PGV-018 will fail the build if /metrics, /health/live, /health/ready
-        // are missing from the final project tree.
-        const apiDir = path.join(scaffoldDir, 'api');
-        fs.mkdirSync(apiDir, { recursive: true });
-        fs.writeFileSync(path.join(apiDir, 'base-app.ts'), BASE_APP_SCAFFOLD_HONO, 'utf-8');
-        totalCopied += 1;
-        // ADR-PIPELINE-077: ERP schema provenance helper. Every generated
-        // ERP adapter MUST export an ERP_SCHEMA_PROVENANCE constant and call
-        // assertErpProvenanceOrFail at construction so strict-mode deployments
-        // block on unreviewed schemas. PGV-020 enforces presence, PGV-021
-        // enforces reviewer + catalog_version on validated entries.
-        const erpDir = path.join(scaffoldDir, 'erp');
-        fs.mkdirSync(erpDir, { recursive: true });
-        fs.writeFileSync(path.join(erpDir, 'schema-provenance.ts'), ERP_SCHEMA_PROVENANCE_SCAFFOLD, 'utf-8');
-        totalCopied += 1;
-        // ADR-PIPELINE-066: unit-economics helper. The demo script calls
-        // writeUnitEconomics() to emit a machine-readable manifest that the
-        // executive renderer prefers over per-employee heuristics.
-        const unitEconomicsCode = `// Auto-generated by Agentics pipeline (ADR-PIPELINE-066)
+            fs.writeFileSync(path.join(scaffoldDir, 'middleware.ts'), middlewareCode, 'utf-8');
+            totalCopied += 1;
+            // ADR-PIPELINE-069: standalone scaffolded circuit-breaker module so
+            // generators can import CircuitBreaker without pulling all of
+            // middleware.ts. Owned by the scaffold (see OWNED_SCAFFOLD_MODULES).
+            fs.writeFileSync(path.join(scaffoldDir, 'circuit-breaker.ts'), CIRCUIT_BREAKER_SCAFFOLD, 'utf-8');
+            totalCopied += 1;
+            // ADR-PIPELINE-076: wire-complete Hono base app. Generators extend
+            // via createBaseApp(deps).route('/api/<domain>', router) instead of
+            // rebuilding the middleware/metrics/health plumbing from scratch.
+            // PGV-018 will fail the build if /metrics, /health/live, /health/ready
+            // are missing from the final project tree.
+            const apiDir = path.join(scaffoldDir, 'api');
+            fs.mkdirSync(apiDir, { recursive: true });
+            fs.writeFileSync(path.join(apiDir, 'base-app.ts'), BASE_APP_SCAFFOLD_HONO, 'utf-8');
+            totalCopied += 1;
+            // ADR-PIPELINE-077: ERP schema provenance helper. Every generated
+            // ERP adapter MUST export an ERP_SCHEMA_PROVENANCE constant and call
+            // assertErpProvenanceOrFail at construction so strict-mode deployments
+            // block on unreviewed schemas. PGV-020 enforces presence, PGV-021
+            // enforces reviewer + catalog_version on validated entries.
+            const erpDir = path.join(scaffoldDir, 'erp');
+            fs.mkdirSync(erpDir, { recursive: true });
+            fs.writeFileSync(path.join(erpDir, 'schema-provenance.ts'), ERP_SCHEMA_PROVENANCE_SCAFFOLD, 'utf-8');
+            totalCopied += 1;
+            // ADR-PIPELINE-066: unit-economics helper. The demo script calls
+            // writeUnitEconomics() to emit a machine-readable manifest that the
+            // executive renderer prefers over per-employee heuristics.
+            const unitEconomicsCode = `// Auto-generated by Agentics pipeline (ADR-PIPELINE-066)
 // Writes .agentics/runs/<run-id>/unit-economics.json so the executive
 // renderer can use bottom-up unit economics instead of heuristics.
 import { mkdirSync, writeFileSync, existsSync, readFileSync } from 'node:fs';
@@ -1750,57 +2132,62 @@ export function readUnitEconomics(runDir: string): UnitEconomics | null {
   }
 }
 `;
-        fs.writeFileSync(path.join(scaffoldDir, 'unit-economics.ts'), unitEconomicsCode, 'utf-8');
-        totalCopied += 1;
-        // ADR-PIPELINE-068: ESM-safe simulation-lineage helper. Every generated
-        // project gets a loader that reads .agentics/plans/manifest.json using
-        // readFileSync + fileURLToPath. NEVER use CommonJS require() in the
-        // generated project — it is "type": "module" and require() throws at
-        // runtime, producing a silent sim-unknown fallback that severs lineage.
-        // The string body lives at module scope (SIMULATION_LINEAGE_SCAFFOLD)
-        // so it can be unit-tested without invoking copyPlanningArtifacts.
-        fs.writeFileSync(path.join(scaffoldDir, 'simulation-lineage.ts'), SIMULATION_LINEAGE_SCAFFOLD, 'utf-8');
-        totalCopied += 1;
-        // ADR-PIPELINE-069: Sidecar manifest listing every scaffold-owned
-        // module + its public exports. Consumed by:
-        //   - prompt-generator.ts (injects "do not reimplement" block)
-        //   - post-generation-validator PGV-012 (bans duplicate declarations)
-        // The manifest is the single source of truth — generators MUST NOT
-        // re-emit any export listed here.
-        const ownedManifestPath = path.join(plansDir, 'scaffold', 'OWNED_MODULES.json');
-        fs.writeFileSync(ownedManifestPath, JSON.stringify(buildOwnedModulesManifest(), null, 2) + '\n', 'utf-8');
-        totalCopied += 1;
-        // ADR-PIPELINE-069: Cleanup pass — scan the project tree for files
-        // that redeclare an export listed in OWNED_MODULES.json. Logs the
-        // count; under AGENTICS_AUTO_DEDUPE=true, deletes the duplicates.
-        try {
-            const projectRootForScan = projectRoot;
-            const dupes = detectScaffoldDuplicates(projectRootForScan, OWNED_SCAFFOLD_MODULES);
-            const autoDedupe = process.env['AGENTICS_AUTO_DEDUPE'] === 'true';
-            if (dupes.length > 0) {
-                console.error(`  [SCAFFOLD] scaffold.duplicate.detected count=${dupes.length}` +
-                    (autoDedupe ? ' (auto-deduping)' : ' (set AGENTICS_AUTO_DEDUPE=true to delete)'));
-                for (const d of dupes) {
-                    console.error(`    - ${d.path} redeclares ${d.exportName} (owned by ${d.ownedPath})`);
-                    if (autoDedupe) {
-                        try {
-                            fs.unlinkSync(d.path);
+            fs.writeFileSync(path.join(scaffoldDir, 'unit-economics.ts'), unitEconomicsCode, 'utf-8');
+            totalCopied += 1;
+            // ADR-PIPELINE-068: ESM-safe simulation-lineage helper. Every generated
+            // project gets a loader that reads .agentics/plans/manifest.json using
+            // readFileSync + fileURLToPath. NEVER use CommonJS require() in the
+            // generated project — it is "type": "module" and require() throws at
+            // runtime, producing a silent sim-unknown fallback that severs lineage.
+            // The string body lives at module scope (SIMULATION_LINEAGE_SCAFFOLD)
+            // so it can be unit-tested without invoking copyPlanningArtifacts.
+            fs.writeFileSync(path.join(scaffoldDir, 'simulation-lineage.ts'), SIMULATION_LINEAGE_SCAFFOLD, 'utf-8');
+            totalCopied += 1;
+            // ADR-PIPELINE-069: Sidecar manifest listing every scaffold-owned
+            // module + its public exports. Consumed by:
+            //   - prompt-generator.ts (injects "do not reimplement" block)
+            //   - post-generation-validator PGV-012 (bans duplicate declarations)
+            // The manifest is the single source of truth — generators MUST NOT
+            // re-emit any export listed here.
+            const ownedManifestPath = path.join(plansDir, 'scaffold', 'OWNED_MODULES.json');
+            fs.writeFileSync(ownedManifestPath, JSON.stringify(buildOwnedModulesManifest(), null, 2) + '\n', 'utf-8');
+            totalCopied += 1;
+            // ADR-PIPELINE-069: Cleanup pass — scan the project tree for files
+            // that redeclare an export listed in OWNED_MODULES.json. Logs the
+            // count; under AGENTICS_AUTO_DEDUPE=true, deletes the duplicates.
+            try {
+                const projectRootForScan = projectRoot;
+                const dupes = detectScaffoldDuplicates(projectRootForScan, OWNED_SCAFFOLD_MODULES);
+                const autoDedupe = process.env['AGENTICS_AUTO_DEDUPE'] === 'true';
+                if (dupes.length > 0) {
+                    console.error(`  [SCAFFOLD] scaffold.duplicate.detected count=${dupes.length}` +
+                        (autoDedupe ? ' (auto-deduping)' : ' (set AGENTICS_AUTO_DEDUPE=true to delete)'));
+                    for (const d of dupes) {
+                        console.error(`    - ${d.path} redeclares ${d.exportName} (owned by ${d.ownedPath})`);
+                        if (autoDedupe) {
+                            try {
+                                fs.unlinkSync(d.path);
+                            }
+                            catch { /* best-effort */ }
                         }
-                        catch { /* best-effort */ }
                     }
                 }
+                else {
+                    console.error('  [SCAFFOLD] scaffold.duplicate.detected: 0');
+                }
             }
-            else {
-                console.error('  [SCAFFOLD] scaffold.duplicate.detected: 0');
+            catch {
+                // Cleanup is best-effort — never block scaffold emission on a scan failure.
             }
-        }
-        catch {
-            // Cleanup is best-effort — never block scaffold emission on a scan failure.
-        }
-        // Python scaffold (if SPARC specifies Python or query mentions it)
-        const pyDir = path.join(plansDir, 'scaffold', 'python');
-        fs.mkdirSync(pyDir, { recursive: true });
-        fs.writeFileSync(path.join(pyDir, 'logger.py'), `"""Structured JSON logger — auto-generated by Agentics pipeline."""
+            totalCopied += 3; // 3 TS files (logger, config, errors) — PY counted below if emitted
+        } // end if (emitTsScaffold)
+        // ADR-PIPELINE-093 §Rule 5 — Python scaffold block is gated on
+        // `emitPyScaffold`. TypeScript projects no longer get a stray `python/`
+        // directory full of `.py` files (the originating contamination bug).
+        if (emitPyScaffold) {
+            const pyDir = path.join(plansDir, 'scaffold', 'python');
+            fs.mkdirSync(pyDir, { recursive: true });
+            fs.writeFileSync(path.join(pyDir, 'logger.py'), `"""Structured JSON logger — auto-generated by Agentics pipeline."""
 import json, sys, time
 from typing import Any, Optional
 
@@ -1830,7 +2217,7 @@ class Logger:
 def create_logger(service: str) -> Logger:
     return Logger(service)
 `, 'utf-8');
-        fs.writeFileSync(path.join(pyDir, 'config.py'), `"""Environment-based configuration — auto-generated by Agentics pipeline."""
+            fs.writeFileSync(path.join(pyDir, 'config.py'), `"""Environment-based configuration — auto-generated by Agentics pipeline."""
 import os
 
 class AppConfig:
@@ -1844,7 +2231,7 @@ class AppConfig:
 
 config = AppConfig()
 `, 'utf-8');
-        fs.writeFileSync(path.join(pyDir, 'errors.py'), `"""Typed error hierarchy — auto-generated by Agentics pipeline."""
+            fs.writeFileSync(path.join(pyDir, 'errors.py'), `"""Typed error hierarchy — auto-generated by Agentics pipeline."""
 
 class AppError(Exception):
     def __init__(self, message: str, code: str, status_code: int = 500):
@@ -1865,7 +2252,8 @@ class ERPError(AppError):
         super().__init__(message, "ERP_ERROR", 502)
         self.retryable = retryable
 `, 'utf-8');
-        totalCopied += 6; // 3 TS + 3 Python
+            totalCopied += 3; // 3 Python files (logger, config, errors)
+        } // end if (emitPyScaffold)
         if (totalCopied > 0 || totalSkipped > 0) {
             const parts = [];
             if (totalCopied > 0)
@@ -1874,6 +2262,10 @@ class ERPError(AppError):
                 parts.push(`${totalSkipped} unchanged (skipped)`);
             console.error(`  [PLANS] ${parts.join(', ')} → .agentics/plans/`);
         }
+        // ADR-PIPELINE-092, Rule 5 + `planPromotion` manifest block:
+        // merge per-slot counts + missing_slots into runDir/manifest.json so CI
+        // can assert on plan-promotion completeness without parsing stderr.
+        writePlanPromotionToManifest(runDir, promotionSummary);
     }
     catch {
         // Non-fatal — never block the pipeline for artifact copy
@@ -2065,6 +2457,23 @@ export async function executeAutoChain(traceId, options = {}) {
     const homeDir = process.env['HOME'] ?? '/tmp';
     const runDir = path.join(homeDir, '.agentics', 'runs', traceId);
     const phases = [];
+    // ADR-PIPELINE-091: per-phase Ruflo primary-executor results. Filled in by
+    // `runRufloPrimaryForPhase` before each downstream coordinator runs; read
+    // at the end of this function to build the manifest `execution` block.
+    const rufloPrimaryResults = {};
+    // ADR-PIPELINE-093: per-phase gate outcomes. Fed by `runPhaseGate` before
+    // each coordinator runs; flushed to `manifest.json` by
+    // `writeGateBlockToManifest` at pipeline completion.
+    const gateAcc = newGateAccumulator();
+    // Per-phase block flags — set by the gate and consulted by downstream
+    // phases to decide whether to attempt their coordinator at all.
+    const phaseBlocked = {
+        phase2: false,
+        'phase3-sparc': false,
+        'phase4-adrs-ddd': false,
+        'phase5a-prompts': false,
+        'phase5b-scaffold': false,
+    };
     // ── Detect execution mode ──
     const execCtx = detectExecutionMode();
     const mode = options.executionMode ?? execCtx.mode;
@@ -2140,53 +2549,66 @@ export async function executeAutoChain(traceId, options = {}) {
             phases.push({ phase: 2, label: 'Deep Research', status: 'skipped', timing: 0, artifacts: [], outputDir: phaseDir });
         }
         else {
-            // Clean up incomplete phase2 directory from a prior failed run
-            if (fs.existsSync(phaseDir) && !fs.existsSync(path.join(phaseDir, 'sparc', 'sparc-combined.json'))) {
-                console.error('  [CLEANUP] Removing incomplete phase2 directory from prior run');
-                fs.rmSync(phaseDir, { recursive: true, force: true });
-            }
-            const agentResults = await dispatchPhaseAgents(PHASE_AGENTS[2], traceId, runDir, scenarioQuery);
-            // Ruflo swarm + agentics agents: write deep research cooperatively
-            // Output to .ruflo-cache/ so we don't pre-create phaseDir (append-only guard in executePhaseNCommand)
-            const rufloOutputDir = path.join(runDir, '.ruflo-cache', 'phase2');
-            const rufloResult = executeRufloPhaseSwarm({
-                phase: 2, label: 'Deep Research', scenarioQuery,
-                runDir, traceId, outputDir: rufloOutputDir,
-                tasks: buildPhase2Tasks(scenarioQuery, collectPhase2Artifacts(runDir)),
-                agenticsResults: agentResults,
-                priorArtifacts: collectPhase2Artifacts(runDir),
-            });
-            if (rufloResult.filesModified > 0) {
-                console.error(`  [RUFLO-P2] ${rufloResult.filesModified} files generated (swarm+agents) in ${rufloResult.timing}ms`);
-            }
-            // Persist agent results BEFORE phase command so the SPARC generator,
-            // research dossier, ADR generator, and DDD generator can read agent findings.
-            // Write to .pre-phase2 — generators check this location if phase2Dir doesn't have the report yet.
-            // CANNOT write to phase2Dir directly — the phase command has an append-only guard that
-            // throws ECLI-P2-003 if the directory already exists.
-            persistAgenticsResults(path.join(runDir, '.pre-phase2'), agentResults);
-            try {
-                const result = await executePhase2Command({ trace: traceId });
-                mergeRufloCacheIntoPhase(runDir, 2);
-                const timing = Date.now() - phaseStart;
-                const artifactPaths = extractArtifactPaths(result.manifest.artifacts);
-                console.error(formatPhase2ForDisplay(result));
-                printArtifactLinks(phaseDir, artifactPaths);
-                storePhaseArtifacts(PHASE_AGENTS[2], traceId, runDir, artifactPaths, timing);
-                await reviewPhaseOutput(PHASE_AGENTS[2], traceId, runDir);
-                persistAgenticsResults(phaseDir, agentResults);
-                phases.push({ phase: 2, label: 'Deep Research', status: 'completed', timing, artifacts: artifactPaths, outputDir: phaseDir, agenticsAgents: buildAgentSummary(agentResults, PHASE_AGENTS[2].agenticsServices.length) });
-                copyPlanningArtifacts(runDir, projectRoot);
-            }
-            catch (err) {
-                const errMsg = err instanceof Error ? err.message : String(err);
-                console.error(`  [FAIL] Phase 2 failed: ${errMsg}`);
-                recordPhaseFailure(PHASE_AGENTS[2], traceId, errMsg);
-                phases.push({ phase: 2, label: 'Deep Research', status: 'failed', timing: Date.now() - phaseStart, artifacts: [], outputDir: phaseDir, error: errMsg });
-                copyPlanningArtifacts(runDir, projectRoot);
-                await ensureAdrsExist(runDir, traceId, scenarioQuery);
-                return buildResult(traceId, runDir, phases, pipelineStart, mode);
+            // ADR-PIPELINE-093 — Phase 2 gate. Verifies Phase 1 required inputs
+            // (manifest.json + executive-summary.md) are present before dispatch.
+            const gate = await runPhaseGate('phase2', scenarioQuery, traceId, runDir, gateAcc);
+            if (!gate.ok && gate.stillMissing.length > 0) {
+                phaseBlocked['phase2'] = true;
+                console.error('  [SKIP] Phase 2 blocked by gate — required Phase 1 inputs missing');
+                phases.push({ phase: 2, label: 'Deep Research', status: 'skipped', timing: Date.now() - phaseStart, artifacts: [], outputDir: phaseDir, error: `blocked: ${gate.stillMissing.join(', ')}` });
+                // Fall through to downstream phases; each has its own gate.
             }
+            else {
+                // Clean up incomplete phase2 directory from a prior failed run
+                if (fs.existsSync(phaseDir) && !fs.existsSync(path.join(phaseDir, 'sparc', 'sparc-combined.json'))) {
+                    console.error('  [CLEANUP] Removing incomplete phase2 directory from prior run');
+                    fs.rmSync(phaseDir, { recursive: true, force: true });
+                }
+                const agentResults = await dispatchPhaseAgents(PHASE_AGENTS[2], traceId, runDir, scenarioQuery);
+                // Ruflo swarm + agentics agents: write deep research cooperatively
+                // Output to .ruflo-cache/ so we don't pre-create phaseDir (append-only guard in executePhaseNCommand)
+                const rufloOutputDir = path.join(runDir, '.ruflo-cache', 'phase2');
+                const rufloResult = executeRufloPhaseSwarm({
+                    phase: 2, label: 'Deep Research', scenarioQuery,
+                    runDir, traceId, outputDir: rufloOutputDir,
+                    tasks: buildPhase2Tasks(scenarioQuery, collectPhase2Artifacts(runDir)),
+                    agenticsResults: agentResults,
+                    priorArtifacts: collectPhase2Artifacts(runDir),
+                });
+                if (rufloResult.filesModified > 0) {
+                    console.error(`  [RUFLO-P2] ${rufloResult.filesModified} files generated (swarm+agents) in ${rufloResult.timing}ms`);
+                }
+                // Persist agent results BEFORE phase command so the SPARC generator,
+                // research dossier, ADR generator, and DDD generator can read agent findings.
+                // Write to .pre-phase2 — generators check this location if phase2Dir doesn't have the report yet.
+                // CANNOT write to phase2Dir directly — the phase command has an append-only guard that
+                // throws ECLI-P2-003 if the directory already exists.
+                persistAgenticsResults(path.join(runDir, '.pre-phase2'), agentResults);
+                try {
+                    const result = await executePhase2Command({ trace: traceId });
+                    mergeRufloCacheIntoPhase(runDir, 2);
+                    const timing = Date.now() - phaseStart;
+                    const artifactPaths = extractArtifactPaths(result.manifest.artifacts);
+                    console.error(formatPhase2ForDisplay(result));
+                    printArtifactLinks(phaseDir, artifactPaths);
+                    storePhaseArtifacts(PHASE_AGENTS[2], traceId, runDir, artifactPaths, timing);
+                    await reviewPhaseOutput(PHASE_AGENTS[2], traceId, runDir);
+                    persistAgenticsResults(phaseDir, agentResults);
+                    phases.push({ phase: 2, label: 'Deep Research', status: 'completed', timing, artifacts: artifactPaths, outputDir: phaseDir, agenticsAgents: buildAgentSummary(agentResults, PHASE_AGENTS[2].agenticsServices.length) });
+                    copyPlanningArtifacts(runDir, projectRoot);
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    console.error(`  [FAIL] Phase 2 failed: ${errMsg}`);
+                    recordPhaseFailure(PHASE_AGENTS[2], traceId, errMsg);
+                    phases.push({ phase: 2, label: 'Deep Research', status: 'failed', timing: Date.now() - phaseStart, artifacts: [], outputDir: phaseDir, error: errMsg });
+                    copyPlanningArtifacts(runDir, projectRoot);
+                    await ensureAdrsExist(runDir, traceId, scenarioQuery);
+                    // ADR-094 Decision 4: emit skipped-due-to-upstream entries for phases 3..6.
+                    pushSkippedDueToUpstream(phases, { phase: 2, label: 'Deep Research', reason: errMsg }, runDir);
+                    return buildResult(traceId, runDir, phases, pipelineStart, mode);
+                }
+            } // close ADR-PIPELINE-093 phase2 gate-else
         }
     }
     // ── Phase 3: SPARC + London TDD ──
@@ -2209,82 +2631,101 @@ export async function executeAutoChain(traceId, options = {}) {
                 console.error('  [CLEANUP] Removing incomplete phase3 directory from prior run');
                 fs.rmSync(phaseDir, { recursive: true, force: true });
             }
-            const agentResults = await dispatchPhaseAgents(PHASE_AGENTS[3], traceId, runDir, scenarioQuery);
-            // Ruflo swarm + agentics agents: write SPARC specs + TDD plans cooperatively
-            const rufloP3Dir = path.join(runDir, '.ruflo-cache', 'phase3');
-            const rufloResult = executeRufloPhaseSwarm({
-                phase: 3, label: 'SPARC + London TDD', scenarioQuery,
-                runDir, traceId, outputDir: rufloP3Dir,
-                tasks: buildPhase3Tasks(scenarioQuery, collectPhase3Artifacts(runDir)),
-                agenticsResults: agentResults,
-                priorArtifacts: collectPhase3Artifacts(runDir),
-            });
-            if (rufloResult.filesModified > 0) {
-                console.error(`  [RUFLO-P3] ${rufloResult.filesModified} files generated (swarm+agents) in ${rufloResult.timing}ms`);
-            }
-            // Persist agent results to .pre-phase3 so generators can find them.
-            // CANNOT write to phase3Dir — append-only guard throws if it exists.
-            persistAgenticsResults(path.join(runDir, '.pre-phase3'), agentResults);
-            try {
-                const result = await executePhase3Command({ trace: traceId });
-                mergeRufloCacheIntoPhase(runDir, 3);
-                const timing = Date.now() - phaseStart;
-                const artifactPaths = extractArtifactPaths(result.manifest.artifacts);
-                console.error(formatPhase3ForDisplay(result));
-                printArtifactLinks(phaseDir, artifactPaths);
-                storePhaseArtifacts(PHASE_AGENTS[3], traceId, runDir, artifactPaths, timing);
-                await reviewPhaseOutput(PHASE_AGENTS[3], traceId, runDir);
-                persistAgenticsResults(phaseDir, agentResults);
-                phases.push({ phase: 3, label: 'SPARC + London TDD', status: 'completed', timing, artifacts: artifactPaths, outputDir: phaseDir, agenticsAgents: buildAgentSummary(agentResults, PHASE_AGENTS[3].agenticsServices.length) });
-                copyPlanningArtifacts(runDir, projectRoot);
+            // ADR-PIPELINE-093 — Phase 3 gate runs BEFORE the ADR-091 Ruflo-primary
+            // call so the gate verifies (and, if necessary, regenerates) upstream
+            // inputs before the phase's own Ruflo pass executes.
+            const phase3Gate = await runPhaseGate('phase3-sparc', scenarioQuery, traceId, runDir, gateAcc);
+            if (!phase3Gate.ok && phase3Gate.stillMissing.length > 0) {
+                phaseBlocked['phase3-sparc'] = true;
+                console.error('  [SKIP] Phase 3 blocked by gate — upstream inputs unrecoverable');
+                phases.push({ phase: 3, label: 'SPARC + London TDD', status: 'skipped', timing: Date.now() - phaseStart, artifacts: [], outputDir: phaseDir, error: `blocked: ${phase3Gate.stillMissing.join(', ')}` });
+                // Continue to Phase 4 — its own gate decides whether it can run.
             }
-            catch (err) {
-                const errMsg = err instanceof Error ? err.message : String(err);
-                console.error(`  [FAIL] Phase 3 failed: ${errMsg}`);
-                recordPhaseFailure(PHASE_AGENTS[3], traceId, errMsg);
-                // Phase 3 refines Phase 2 SPARC via LLM. If it fails (timeout, no LLM),
-                // carry Phase 2 artifacts forward so Phases 4-6 can still proceed.
-                const phase2SparcDir = path.join(runDir, 'phase2', 'sparc');
-                const phase2SparcCombined = path.join(phase2SparcDir, 'sparc-combined.json');
-                if (fs.existsSync(phase2SparcCombined)) {
-                    console.error('  [RECOVER] Phase 2 SPARC artifacts exist — copying to phase3/ so pipeline can continue');
-                    const phase3SparcDir = path.join(phaseDir, 'sparc');
-                    fs.mkdirSync(phase3SparcDir, { recursive: true });
-                    // Copy all Phase 2 SPARC files to Phase 3 directory
-                    const phase2SparcFiles = fs.readdirSync(phase2SparcDir);
-                    for (const file of phase2SparcFiles) {
-                        const src = path.join(phase2SparcDir, file);
-                        const dest = path.join(phase3SparcDir, file);
-                        if (fs.statSync(src).isFile()) {
-                            fs.copyFileSync(src, dest);
-                        }
-                    }
-                    // Also copy TDD if available from Phase 2
-                    const phase2TddDir = path.join(runDir, 'phase2', 'tdd');
-                    if (fs.existsSync(phase2TddDir)) {
-                        const phase3TddDir = path.join(phaseDir, 'tdd');
-                        fs.mkdirSync(phase3TddDir, { recursive: true });
-                        const phase2TddFiles = fs.readdirSync(phase2TddDir);
-                        for (const file of phase2TddFiles) {
-                            const src = path.join(phase2TddDir, file);
-                            const dest = path.join(phase3TddDir, file);
+            else {
+                // ADR-PIPELINE-091: Ruflo runs FIRST as the primary engineering-artifact
+                // producer. Its output lands in runDir/engineering/*.md; the downstream
+                // phase3 coordinator picks it up as its primary input. Remote diligence
+                // agents that DID return from Phase 1 are attached as enrichment only.
+                rufloPrimaryResults.phase3 = await runRufloPrimaryForPhase('phase3-sparc', scenarioQuery, traceId, runDir, collectPhase3Artifacts(runDir), readRemoteEnrichmentSnapshot(runDir), path.join(runDir, '.ruflo-cache', 'phase3-primary'));
+                const agentResults = await dispatchPhaseAgents(PHASE_AGENTS[3], traceId, runDir, scenarioQuery);
+                // Ruflo swarm + agentics agents: write SPARC specs + TDD plans cooperatively
+                const rufloP3Dir = path.join(runDir, '.ruflo-cache', 'phase3');
+                const rufloResult = executeRufloPhaseSwarm({
+                    phase: 3, label: 'SPARC + London TDD', scenarioQuery,
+                    runDir, traceId, outputDir: rufloP3Dir,
+                    tasks: buildPhase3Tasks(scenarioQuery, collectPhase3Artifacts(runDir)),
+                    agenticsResults: agentResults,
+                    priorArtifacts: collectPhase3Artifacts(runDir),
+                });
+                if (rufloResult.filesModified > 0) {
+                    console.error(`  [RUFLO-P3] ${rufloResult.filesModified} files generated (swarm+agents) in ${rufloResult.timing}ms`);
+                }
+                // Persist agent results to .pre-phase3 so generators can find them.
+                // CANNOT write to phase3Dir — append-only guard throws if it exists.
+                persistAgenticsResults(path.join(runDir, '.pre-phase3'), agentResults);
+                try {
+                    const result = await executePhase3Command({ trace: traceId });
+                    mergeRufloCacheIntoPhase(runDir, 3);
+                    const timing = Date.now() - phaseStart;
+                    const artifactPaths = extractArtifactPaths(result.manifest.artifacts);
+                    console.error(formatPhase3ForDisplay(result));
+                    printArtifactLinks(phaseDir, artifactPaths);
+                    storePhaseArtifacts(PHASE_AGENTS[3], traceId, runDir, artifactPaths, timing);
+                    await reviewPhaseOutput(PHASE_AGENTS[3], traceId, runDir);
+                    persistAgenticsResults(phaseDir, agentResults);
+                    phases.push({ phase: 3, label: 'SPARC + London TDD', status: 'completed', timing, artifacts: artifactPaths, outputDir: phaseDir, agenticsAgents: buildAgentSummary(agentResults, PHASE_AGENTS[3].agenticsServices.length) });
+                    copyPlanningArtifacts(runDir, projectRoot);
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    console.error(`  [FAIL] Phase 3 failed: ${errMsg}`);
+                    recordPhaseFailure(PHASE_AGENTS[3], traceId, errMsg);
+                    // Phase 3 refines Phase 2 SPARC via LLM. If it fails (timeout, no LLM),
+                    // carry Phase 2 artifacts forward so Phases 4-6 can still proceed.
+                    const phase2SparcDir = path.join(runDir, 'phase2', 'sparc');
+                    const phase2SparcCombined = path.join(phase2SparcDir, 'sparc-combined.json');
+                    if (fs.existsSync(phase2SparcCombined)) {
+                        console.error('  [RECOVER] Phase 2 SPARC artifacts exist — copying to phase3/ so pipeline can continue');
+                        const phase3SparcDir = path.join(phaseDir, 'sparc');
+                        fs.mkdirSync(phase3SparcDir, { recursive: true });
+                        // Copy all Phase 2 SPARC files to Phase 3 directory
+                        const phase2SparcFiles = fs.readdirSync(phase2SparcDir);
+                        for (const file of phase2SparcFiles) {
+                            const src = path.join(phase2SparcDir, file);
+                            const dest = path.join(phase3SparcDir, file);
                             if (fs.statSync(src).isFile()) {
                                 fs.copyFileSync(src, dest);
                             }
                         }
+                        // Also copy TDD if available from Phase 2
+                        const phase2TddDir = path.join(runDir, 'phase2', 'tdd');
+                        if (fs.existsSync(phase2TddDir)) {
+                            const phase3TddDir = path.join(phaseDir, 'tdd');
+                            fs.mkdirSync(phase3TddDir, { recursive: true });
+                            const phase2TddFiles = fs.readdirSync(phase2TddDir);
+                            for (const file of phase2TddFiles) {
+                                const src = path.join(phase2TddDir, file);
+                                const dest = path.join(phase3TddDir, file);
+                                if (fs.statSync(src).isFile()) {
+                                    fs.copyFileSync(src, dest);
+                                }
+                            }
+                        }
+                        console.error('  [RECOVER] Phase 2 artifacts carried forward — continuing to Phase 4');
+                        phases.push({ phase: 3, label: 'SPARC + London TDD', status: 'completed', timing: Date.now() - phaseStart, artifacts: [], outputDir: phaseDir, error: `Recovered from Phase 2: ${errMsg}` });
+                        copyPlanningArtifacts(runDir, projectRoot);
+                    }
+                    else {
+                        console.error('  [ABORT] No Phase 2 SPARC artifacts to recover from — pipeline cannot continue');
+                        phases.push({ phase: 3, label: 'SPARC + London TDD', status: 'failed', timing: Date.now() - phaseStart, artifacts: [], outputDir: phaseDir, error: errMsg });
+                        copyPlanningArtifacts(runDir, projectRoot);
+                        await ensureAdrsExist(runDir, traceId, scenarioQuery);
+                        // ADR-094 Decision 4: emit skipped-due-to-upstream entries for phases 4..6.
+                        pushSkippedDueToUpstream(phases, { phase: 3, label: 'SPARC + London TDD', reason: errMsg }, runDir);
+                        return buildResult(traceId, runDir, phases, pipelineStart, mode);
                     }
-                    console.error('  [RECOVER] Phase 2 artifacts carried forward — continuing to Phase 4');
-                    phases.push({ phase: 3, label: 'SPARC + London TDD', status: 'completed', timing: Date.now() - phaseStart, artifacts: [], outputDir: phaseDir, error: `Recovered from Phase 2: ${errMsg}` });
-                    copyPlanningArtifacts(runDir, projectRoot);
-                }
-                else {
-                    console.error('  [ABORT] No Phase 2 SPARC artifacts to recover from — pipeline cannot continue');
-                    phases.push({ phase: 3, label: 'SPARC + London TDD', status: 'failed', timing: Date.now() - phaseStart, artifacts: [], outputDir: phaseDir, error: errMsg });
-                    copyPlanningArtifacts(runDir, projectRoot);
-                    await ensureAdrsExist(runDir, traceId, scenarioQuery);
-                    return buildResult(traceId, runDir, phases, pipelineStart, mode);
                 }
-            }
+            } // close ADR-PIPELINE-093 phase3-sparc gate-else
         }
     }
     // ── Phase 4: ADRs + DDDs ──
@@ -2309,153 +2750,170 @@ export async function executeAutoChain(traceId, options = {}) {
                 console.error('  [CLEANUP] Removing incomplete phase4 directory from prior run');
                 fs.rmSync(phaseDir, { recursive: true, force: true });
             }
-            const agentResults = await dispatchPhaseAgents(PHASE_AGENTS[4], traceId, runDir, scenarioQuery);
-            // Ruflo swarm + agentics agents: write ADRs + DDDs cooperatively
-            const rufloP4Dir = path.join(runDir, '.ruflo-cache', 'phase4');
-            const rufloResult = executeRufloPhaseSwarm({
-                phase: 4, label: 'ADRs + DDDs', scenarioQuery,
-                runDir, traceId, outputDir: rufloP4Dir,
-                tasks: buildPhase4Tasks(scenarioQuery, collectPhase4Artifacts(runDir)),
-                agenticsResults: agentResults,
-                priorArtifacts: collectPhase4Artifacts(runDir),
-            });
-            if (rufloResult.filesModified > 0) {
-                console.error(`  [RUFLO-P4] ${rufloResult.filesModified} files generated (swarm+agents) in ${rufloResult.timing}ms`);
-            }
-            // Persist agent results to .pre-phase4 so ADR/DDD generators can find them.
-            // CANNOT write to phase4Dir — append-only guard throws if it exists.
-            persistAgenticsResults(path.join(runDir, '.pre-phase4'), agentResults);
-            try {
-                const result = await executePhase4Command({ trace: traceId });
-                mergeRufloCacheIntoPhase(runDir, 4);
-                const timing = Date.now() - phaseStart;
-                const artifactPaths = extractArtifactPaths(result.manifest.artifacts);
-                console.error(formatPhase4ForDisplay(result));
-                printArtifactLinks(phaseDir, artifactPaths);
-                storePhaseArtifacts(PHASE_AGENTS[4], traceId, runDir, artifactPaths, timing);
-                await reviewPhaseOutput(PHASE_AGENTS[4], traceId, runDir);
-                persistAgenticsResults(phaseDir, agentResults);
-                phases.push({ phase: 4, label: 'ADRs + DDDs', status: 'completed', timing, artifacts: artifactPaths, outputDir: phaseDir, agenticsAgents: buildAgentSummary(agentResults, PHASE_AGENTS[4].agenticsServices.length) });
-                copyPlanningArtifacts(runDir, projectRoot);
+            // ADR-PIPELINE-093 — Phase 4 gate runs BEFORE the ADR-091 Ruflo-primary
+            // call so the gate verifies (and regenerates) the SPARC spec upstream
+            // requirement before the phase's own Ruflo pass runs.
+            const phase4Gate = await runPhaseGate('phase4-adrs-ddd', scenarioQuery, traceId, runDir, gateAcc);
+            if (!phase4Gate.ok && phase4Gate.stillMissing.length > 0) {
+                phaseBlocked['phase4-adrs-ddd'] = true;
+                console.error('  [SKIP] Phase 4 blocked by gate — upstream inputs unrecoverable');
+                phases.push({ phase: 4, label: 'ADRs + DDDs', status: 'skipped', timing: Date.now() - phaseStart, artifacts: [], outputDir: phaseDir, error: `blocked: ${phase4Gate.stillMissing.join(', ')}` });
+                // Continue to Phase 5a — its own gate decides reachability.
             }
-            catch (err) {
-                const errMsg = err instanceof Error ? err.message : String(err);
-                console.error(`  [FAIL] Phase 4 failed: ${errMsg}`);
-                recordPhaseFailure(PHASE_AGENTS[4], traceId, errMsg);
-                // Phase 4 refines Phase 2 ADRs/DDD. If it fails, try recovery paths.
-                const phase2AdrIndex = path.join(runDir, 'phase2', 'adrs', 'adr-index.json');
-                let recovered = false;
-                if (fs.existsSync(phase2AdrIndex)) {
-                    // Path A: Phase 2 has ADRs — copy them to phase4/
-                    console.error('  [RECOVER] Phase 2 ADRs/DDD exist — copying to phase4/ so pipeline can continue');
-                    for (const sub of ['adrs', 'ddd']) {
-                        const src = path.join(runDir, 'phase2', sub);
-                        const dest = path.join(phaseDir, sub);
-                        if (fs.existsSync(src)) {
-                            fs.mkdirSync(dest, { recursive: true });
-                            for (const file of fs.readdirSync(src)) {
-                                const srcFile = path.join(src, file);
-                                if (fs.statSync(srcFile).isFile()) {
-                                    fs.copyFileSync(srcFile, path.join(dest, file));
-                                }
-                            }
-                        }
-                    }
-                    console.error('  [RECOVER] Phase 2 ADRs/DDD carried forward — continuing to Phase 5');
-                    recovered = true;
+            else {
+                // ADR-PIPELINE-091: Ruflo runs FIRST for ADR + DDD generation. Its output
+                // lands in runDir/engineering/architecture-decisions.md + domain-model.md
+                // and the phase4 coordinator refines it. Remote diligence agents feed in
+                // as optional enrichment only.
+                rufloPrimaryResults.phase4 = await runRufloPrimaryForPhase('phase4-adrs-ddd', scenarioQuery, traceId, runDir, collectPhase4Artifacts(runDir), readRemoteEnrichmentSnapshot(runDir), path.join(runDir, '.ruflo-cache', 'phase4-primary'));
+                const agentResults = await dispatchPhaseAgents(PHASE_AGENTS[4], traceId, runDir, scenarioQuery);
+                // Ruflo swarm + agentics agents: write ADRs + DDDs cooperatively
+                const rufloP4Dir = path.join(runDir, '.ruflo-cache', 'phase4');
+                const rufloResult = executeRufloPhaseSwarm({
+                    phase: 4, label: 'ADRs + DDDs', scenarioQuery,
+                    runDir, traceId, outputDir: rufloP4Dir,
+                    tasks: buildPhase4Tasks(scenarioQuery, collectPhase4Artifacts(runDir)),
+                    agenticsResults: agentResults,
+                    priorArtifacts: collectPhase4Artifacts(runDir),
+                });
+                if (rufloResult.filesModified > 0) {
+                    console.error(`  [RUFLO-P4] ${rufloResult.filesModified} files generated (swarm+agents) in ${rufloResult.timing}ms`);
                 }
-                // Path B: No Phase 2 ADRs — generate them from SPARC + dossier directly
-                if (!recovered) {
-                    console.error('  [RECOVER] No Phase 2 ADRs — generating ADRs from SPARC + dossier (no LLM required)');
-                    try {
-                        const { buildPhase2ADRs } = await import('../pipeline/phase2/phases/adr-generator.js');
-                        const { buildPhase2DDD } = await import('../pipeline/phase2/phases/ddd-generator.js');
-                        // Load SPARC and dossier from wherever they exist
-                        let sparc = null;
-                        let dossier = null;
-                        for (const sub of ['phase3/sparc/sparc-combined.json', 'phase2/sparc/sparc-combined.json']) {
-                            const p = path.join(runDir, sub);
-                            if (fs.existsSync(p)) {
-                                try {
-                                    sparc = JSON.parse(fs.readFileSync(p, 'utf-8'));
-                                    break;
+                // Persist agent results to .pre-phase4 so ADR/DDD generators can find them.
+                // CANNOT write to phase4Dir — append-only guard throws if it exists.
+                persistAgenticsResults(path.join(runDir, '.pre-phase4'), agentResults);
+                try {
+                    const result = await executePhase4Command({ trace: traceId });
+                    mergeRufloCacheIntoPhase(runDir, 4);
+                    const timing = Date.now() - phaseStart;
+                    const artifactPaths = extractArtifactPaths(result.manifest.artifacts);
+                    console.error(formatPhase4ForDisplay(result));
+                    printArtifactLinks(phaseDir, artifactPaths);
+                    storePhaseArtifacts(PHASE_AGENTS[4], traceId, runDir, artifactPaths, timing);
+                    await reviewPhaseOutput(PHASE_AGENTS[4], traceId, runDir);
+                    persistAgenticsResults(phaseDir, agentResults);
+                    phases.push({ phase: 4, label: 'ADRs + DDDs', status: 'completed', timing, artifacts: artifactPaths, outputDir: phaseDir, agenticsAgents: buildAgentSummary(agentResults, PHASE_AGENTS[4].agenticsServices.length) });
+                    copyPlanningArtifacts(runDir, projectRoot);
+                }
+                catch (err) {
+                    const errMsg = err instanceof Error ? err.message : String(err);
+                    console.error(`  [FAIL] Phase 4 failed: ${errMsg}`);
+                    recordPhaseFailure(PHASE_AGENTS[4], traceId, errMsg);
+                    // Phase 4 refines Phase 2 ADRs/DDD. If it fails, try recovery paths.
+                    const phase2AdrIndex = path.join(runDir, 'phase2', 'adrs', 'adr-index.json');
+                    let recovered = false;
+                    if (fs.existsSync(phase2AdrIndex)) {
+                        // Path A: Phase 2 has ADRs — copy them to phase4/
+                        console.error('  [RECOVER] Phase 2 ADRs/DDD exist — copying to phase4/ so pipeline can continue');
+                        for (const sub of ['adrs', 'ddd']) {
+                            const src = path.join(runDir, 'phase2', sub);
+                            const dest = path.join(phaseDir, sub);
+                            if (fs.existsSync(src)) {
+                                fs.mkdirSync(dest, { recursive: true });
+                                for (const file of fs.readdirSync(src)) {
+                                    const srcFile = path.join(src, file);
+                                    if (fs.statSync(srcFile).isFile()) {
+                                        fs.copyFileSync(srcFile, path.join(dest, file));
+                                    }
                                 }
-                                catch { /* skip */ }
                             }
                         }
-                        for (const sub of ['phase2/research-dossier.json']) {
-                            const p = path.join(runDir, sub);
-                            if (fs.existsSync(p)) {
-                                try {
-                                    dossier = JSON.parse(fs.readFileSync(p, 'utf-8'));
-                                    break;
+                        console.error('  [RECOVER] Phase 2 ADRs/DDD carried forward — continuing to Phase 5');
+                        recovered = true;
+                    }
+                    // Path B: No Phase 2 ADRs — generate them from SPARC + dossier directly
+                    if (!recovered) {
+                        console.error('  [RECOVER] No Phase 2 ADRs — generating ADRs from SPARC + dossier (no LLM required)');
+                        try {
+                            const { buildPhase2ADRs } = await import('../pipeline/phase2/phases/adr-generator.js');
+                            const { buildPhase2DDD } = await import('../pipeline/phase2/phases/ddd-generator.js');
+                            // Load SPARC and dossier from wherever they exist
+                            let sparc = null;
+                            let dossier = null;
+                            for (const sub of ['phase3/sparc/sparc-combined.json', 'phase2/sparc/sparc-combined.json']) {
+                                const p = path.join(runDir, sub);
+                                if (fs.existsSync(p)) {
+                                    try {
+                                        sparc = JSON.parse(fs.readFileSync(p, 'utf-8'));
+                                        break;
+                                    }
+                                    catch { /* skip */ }
                                 }
-                                catch { /* skip */ }
                             }
-                        }
-                        if (sparc && dossier) {
-                            // Generate ADRs
-                            const adrs = buildPhase2ADRs(sparc, dossier, scenarioQuery, true /* skipLLM */);
-                            if (adrs.length > 0) {
-                                const adrDir = path.join(phaseDir, 'adrs');
-                                fs.mkdirSync(adrDir, { recursive: true });
-                                for (const adr of adrs) {
-                                    const slug = (adr.title || 'untitled').toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 60);
-                                    const filename = `${adr.id}-${slug}.md`;
-                                    const md = [
-                                        `# ${adr.id}: ${adr.title}`,
-                                        `\n**Status:** ${adr.status}`,
-                                        `**Date:** ${adr.date}`,
-                                        `\n## Context\n${adr.context}`,
-                                        `\n## Decision\n${adr.decision}`,
-                                        adr.alternatives?.length > 0 ? `\n## Alternatives Considered\n${adr.alternatives.map((a) => `- **${a.option}** ${a.rejected ? '(rejected)' : '(selected)'}: ${a.rationale}`).join('\n')}` : '',
-                                        adr.consequences?.length > 0 ? `\n## Consequences\n${adr.consequences.map((c) => `- [${c.type === 'positive' ? '+' : c.type === 'negative' ? '-' : '~'}] ${c.description}`).join('\n')}` : '',
-                                    ].filter(Boolean).join('\n');
-                                    fs.writeFileSync(path.join(adrDir, filename), md + '\n', 'utf-8');
+                            for (const sub of ['phase2/research-dossier.json']) {
+                                const p = path.join(runDir, sub);
+                                if (fs.existsSync(p)) {
+                                    try {
+                                        dossier = JSON.parse(fs.readFileSync(p, 'utf-8'));
+                                        break;
+                                    }
+                                    catch { /* skip */ }
                                 }
-                                fs.writeFileSync(path.join(adrDir, 'adr-index.json'), JSON.stringify(adrs, null, 2) + '\n', 'utf-8');
-                                console.error(`  [RECOVER] Generated ${adrs.length} ADRs from SPARC template`);
                             }
-                            // Generate DDD
-                            try {
-                                const dddModel = buildPhase2DDD(sparc, adrs, dossier);
-                                if (dddModel?.contexts?.length > 0) {
-                                    const dddDir = path.join(phaseDir, 'ddd');
-                                    const contextsDir = path.join(dddDir, 'contexts');
-                                    fs.mkdirSync(contextsDir, { recursive: true });
-                                    fs.writeFileSync(path.join(dddDir, 'domain-model.json'), JSON.stringify(dddModel, null, 2) + '\n', 'utf-8');
-                                    if (dddModel.contextMap) {
-                                        fs.writeFileSync(path.join(dddDir, 'context-map.json'), JSON.stringify(dddModel.contextMap, null, 2) + '\n', 'utf-8');
+                            if (sparc && dossier) {
+                                // Generate ADRs
+                                const adrs = buildPhase2ADRs(sparc, dossier, scenarioQuery, true /* skipLLM */);
+                                if (adrs.length > 0) {
+                                    const adrDir = path.join(phaseDir, 'adrs');
+                                    fs.mkdirSync(adrDir, { recursive: true });
+                                    for (const adr of adrs) {
+                                        const slug = (adr.title || 'untitled').toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 60);
+                                        const filename = `${adr.id}-${slug}.md`;
+                                        const md = [
+                                            `# ${adr.id}: ${adr.title}`,
+                                            `\n**Status:** ${adr.status}`,
+                                            `**Date:** ${adr.date}`,
+                                            `\n## Context\n${adr.context}`,
+                                            `\n## Decision\n${adr.decision}`,
+                                            adr.alternatives?.length > 0 ? `\n## Alternatives Considered\n${adr.alternatives.map((a) => `- **${a.option}** ${a.rejected ? '(rejected)' : '(selected)'}: ${a.rationale}`).join('\n')}` : '',
+                                            adr.consequences?.length > 0 ? `\n## Consequences\n${adr.consequences.map((c) => `- [${c.type === 'positive' ? '+' : c.type === 'negative' ? '-' : '~'}] ${c.description}`).join('\n')}` : '',
+                                        ].filter(Boolean).join('\n');
+                                        fs.writeFileSync(path.join(adrDir, filename), md + '\n', 'utf-8');
                                     }
-                                    for (const ctx of dddModel.contexts) {
-                                        const ctxSlug = ctx.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 60);
-                                        fs.writeFileSync(path.join(contextsDir, `${ctxSlug}.json`), JSON.stringify(ctx, null, 2) + '\n', 'utf-8');
+                                    fs.writeFileSync(path.join(adrDir, 'adr-index.json'), JSON.stringify(adrs, null, 2) + '\n', 'utf-8');
+                                    console.error(`  [RECOVER] Generated ${adrs.length} ADRs from SPARC template`);
+                                }
+                                // Generate DDD
+                                try {
+                                    const dddModel = buildPhase2DDD(sparc, adrs, dossier);
+                                    if (dddModel?.contexts?.length > 0) {
+                                        const dddDir = path.join(phaseDir, 'ddd');
+                                        const contextsDir = path.join(dddDir, 'contexts');
+                                        fs.mkdirSync(contextsDir, { recursive: true });
+                                        fs.writeFileSync(path.join(dddDir, 'domain-model.json'), JSON.stringify(dddModel, null, 2) + '\n', 'utf-8');
+                                        if (dddModel.contextMap) {
+                                            fs.writeFileSync(path.join(dddDir, 'context-map.json'), JSON.stringify(dddModel.contextMap, null, 2) + '\n', 'utf-8');
+                                        }
+                                        for (const ctx of dddModel.contexts) {
+                                            const ctxSlug = ctx.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 60);
+                                            fs.writeFileSync(path.join(contextsDir, `${ctxSlug}.json`), JSON.stringify(ctx, null, 2) + '\n', 'utf-8');
+                                        }
+                                        console.error(`  [RECOVER] Generated DDD model with ${dddModel.contexts.length} bounded contexts`);
                                     }
-                                    console.error(`  [RECOVER] Generated DDD model with ${dddModel.contexts.length} bounded contexts`);
                                 }
+                                catch (dddErr) {
+                                    console.error(`  [WARN] DDD generation failed: ${dddErr instanceof Error ? dddErr.message : String(dddErr)}`);
+                                }
+                                recovered = true;
                             }
-                            catch (dddErr) {
-                                console.error(`  [WARN] DDD generation failed: ${dddErr instanceof Error ? dddErr.message : String(dddErr)}`);
+                            else {
+                                console.error('  [WARN] SPARC or dossier not found — cannot generate ADRs');
                             }
-                            recovered = true;
                         }
-                        else {
-                            console.error('  [WARN] SPARC or dossier not found — cannot generate ADRs');
+                        catch (recoverErr) {
+                            console.error(`  [WARN] ADR recovery failed: ${recoverErr instanceof Error ? recoverErr.message : String(recoverErr)}`);
                         }
                     }
-                    catch (recoverErr) {
-                        console.error(`  [WARN] ADR recovery failed: ${recoverErr instanceof Error ? recoverErr.message : String(recoverErr)}`);
+                    if (recovered) {
+                        phases.push({ phase: 4, label: 'ADRs + DDDs', status: 'completed', timing: Date.now() - phaseStart, artifacts: [], outputDir: phaseDir, error: `Recovered: ${errMsg}` });
                     }
+                    else {
+                        console.error('  [WARN] No recovery possible — continuing without ADRs');
+                        phases.push({ phase: 4, label: 'ADRs + DDDs', status: 'failed', timing: Date.now() - phaseStart, artifacts: [], outputDir: phaseDir, error: errMsg });
+                    }
+                    copyPlanningArtifacts(runDir, projectRoot);
                 }
-                if (recovered) {
-                    phases.push({ phase: 4, label: 'ADRs + DDDs', status: 'completed', timing: Date.now() - phaseStart, artifacts: [], outputDir: phaseDir, error: `Recovered: ${errMsg}` });
-                }
-                else {
-                    console.error('  [WARN] No recovery possible — continuing without ADRs');
-                    phases.push({ phase: 4, label: 'ADRs + DDDs', status: 'failed', timing: Date.now() - phaseStart, artifacts: [], outputDir: phaseDir, error: errMsg });
-                }
-                copyPlanningArtifacts(runDir, projectRoot);
-            }
+            } // close ADR-PIPELINE-093 phase4-adrs-ddd gate-else
         }
     }
     // ── Phase 4.5: Generate implementation prompts by reading ADR + DDD files ──
@@ -2470,64 +2928,80 @@ export async function executeAutoChain(traceId, options = {}) {
             console.error('  [PROMPTS] Implementation prompts already exist — skipping');
         }
         else {
-            // Gather all ADR and DDD files (prefer phase4, fall back to phase2)
-            const adrDir = fs.existsSync(path.join(runDir, 'phase4', 'adrs'))
-                ? path.join(runDir, 'phase4', 'adrs')
-                : fs.existsSync(path.join(runDir, 'phase2', 'adrs'))
-                    ? path.join(runDir, 'phase2', 'adrs')
-                    : null;
-            const dddDir = fs.existsSync(path.join(runDir, 'phase4', 'ddd'))
-                ? path.join(runDir, 'phase4', 'ddd')
-                : fs.existsSync(path.join(runDir, 'phase2', 'ddd'))
-                    ? path.join(runDir, 'phase2', 'ddd')
-                    : null;
-            const sparcDir = fs.existsSync(path.join(runDir, 'phase3', 'sparc'))
-                ? path.join(runDir, 'phase3', 'sparc')
-                : fs.existsSync(path.join(runDir, 'phase2', 'sparc'))
-                    ? path.join(runDir, 'phase2', 'sparc')
-                    : null;
-            if (adrDir) {
-                try {
-                    // Read all ADR markdown files
-                    const adrFiles = fs.readdirSync(adrDir).filter(f => f.endsWith('.md'));
-                    const adrContent = adrFiles.map(f => {
-                        try {
-                            return `### ${f}\n\n${fs.readFileSync(path.join(adrDir, f), 'utf-8')}`;
-                        }
-                        catch {
-                            return '';
-                        }
-                    }).filter(Boolean).join('\n\n---\n\n');
-                    // Read DDD model files
-                    let dddContent = '';
-                    if (dddDir) {
-                        const dddFiles = fs.readdirSync(dddDir).filter(f => f.endsWith('.md') || f.endsWith('.json'));
-                        dddContent = dddFiles.map(f => {
+            // ADR-PIPELINE-093 — Phase 5a gate. Verifies SPARC + (ADRs OR DDD OR
+            // engineering/architecture-decisions.md) are present. Missing upstream
+            // triggers the gate's single-shot Ruflo invocation of the owning phase.
+            const phase5aGate = await runPhaseGate('phase5a-prompts', scenarioQuery, traceId, runDir, gateAcc);
+            if (!phase5aGate.ok && phase5aGate.stillMissing.length > 0) {
+                phaseBlocked['phase5a-prompts'] = true;
+                console.error('  [SKIP] Phase 5a (prompts) blocked by gate — upstream unrecoverable');
+                // Fall through: the FATAL-path check later will decide whether
+                // to exit loudly or continue degraded.
+            }
+            else {
+                // ADR-PIPELINE-091: Ruflo runs FIRST as the primary implementation-prompt
+                // producer. Its output lands in runDir/engineering/implementation-roadmap.md
+                // (and impl-NNN-*.md). The template-derivation path below only fires as
+                // the last-resort when Ruflo was unavailable or produced no output.
+                rufloPrimaryResults.phase5a = await runRufloPrimaryForPhase('phase5a-prompts', scenarioQuery, traceId, runDir, collectPhase4Artifacts(runDir), readRemoteEnrichmentSnapshot(runDir), path.join(runDir, '.ruflo-cache', 'phase5a-primary'));
+                // Gather all ADR and DDD files (prefer phase4, fall back to phase2)
+                const adrDir = fs.existsSync(path.join(runDir, 'phase4', 'adrs'))
+                    ? path.join(runDir, 'phase4', 'adrs')
+                    : fs.existsSync(path.join(runDir, 'phase2', 'adrs'))
+                        ? path.join(runDir, 'phase2', 'adrs')
+                        : null;
+                const dddDir = fs.existsSync(path.join(runDir, 'phase4', 'ddd'))
+                    ? path.join(runDir, 'phase4', 'ddd')
+                    : fs.existsSync(path.join(runDir, 'phase2', 'ddd'))
+                        ? path.join(runDir, 'phase2', 'ddd')
+                        : null;
+                const sparcDir = fs.existsSync(path.join(runDir, 'phase3', 'sparc'))
+                    ? path.join(runDir, 'phase3', 'sparc')
+                    : fs.existsSync(path.join(runDir, 'phase2', 'sparc'))
+                        ? path.join(runDir, 'phase2', 'sparc')
+                        : null;
+                if (adrDir) {
+                    try {
+                        // Read all ADR markdown files
+                        const adrFiles = fs.readdirSync(adrDir).filter(f => f.endsWith('.md'));
+                        const adrContent = adrFiles.map(f => {
                             try {
-                                return `### ${f}\n\n${fs.readFileSync(path.join(dddDir, f), 'utf-8')}`;
+                                return `### ${f}\n\n${fs.readFileSync(path.join(adrDir, f), 'utf-8')}`;
                             }
                             catch {
                                 return '';
                             }
                         }).filter(Boolean).join('\n\n---\n\n');
-                    }
-                    // Read SPARC specification summary
-                    let sparcContent = '';
-                    if (sparcDir) {
-                        for (const candidate of ['specification.md', 'architecture.md', 'sparc-combined.json']) {
-                            const p = path.join(sparcDir, candidate);
-                            if (fs.existsSync(p)) {
+                        // Read DDD model files
+                        let dddContent = '';
+                        if (dddDir) {
+                            const dddFiles = fs.readdirSync(dddDir).filter(f => f.endsWith('.md') || f.endsWith('.json'));
+                            dddContent = dddFiles.map(f => {
                                 try {
-                                    sparcContent += `### ${candidate}\n\n${fs.readFileSync(p, 'utf-8').slice(0, 5000)}\n\n`;
+                                    return `### ${f}\n\n${fs.readFileSync(path.join(dddDir, f), 'utf-8')}`;
+                                }
+                                catch {
+                                    return '';
+                                }
+                            }).filter(Boolean).join('\n\n---\n\n');
+                        }
+                        // Read SPARC specification summary
+                        let sparcContent = '';
+                        if (sparcDir) {
+                            for (const candidate of ['specification.md', 'architecture.md', 'sparc-combined.json']) {
+                                const p = path.join(sparcDir, candidate);
+                                if (fs.existsSync(p)) {
+                                    try {
+                                        sparcContent += `### ${candidate}\n\n${fs.readFileSync(p, 'utf-8').slice(0, 5000)}\n\n`;
+                                    }
+                                    catch { /* skip */ }
                                 }
-                                catch { /* skip */ }
                             }
                         }
-                    }
-                    // Build the ruflo swarm task: read the files, write implementation prompts
-                    fs.mkdirSync(promptsDir, { recursive: true, mode: 0o700 });
-                    const rufloPromptDir = path.join(runDir, '.ruflo-cache', 'prompts');
-                    const promptTask = `You are an implementation prompt writer. You have been given the complete Architecture Decision Records (ADRs), Domain-Driven Design (DDD) model, and SPARC specification for this project.
+                        // Build the ruflo swarm task: read the files, write implementation prompts
+                        fs.mkdirSync(promptsDir, { recursive: true, mode: 0o700 });
+                        const rufloPromptDir = path.join(runDir, '.ruflo-cache', 'prompts');
+                        const promptTask = `You are an implementation prompt writer. You have been given the complete Architecture Decision Records (ADRs), Domain-Driven Design (DDD) model, and SPARC specification for this project.
 
 Your job: Read ALL of these documents carefully, then write a series of ordered implementation prompts. Each prompt should be a self-contained build step that a developer (or coding agent) can execute to build one piece of the platform.
 
@@ -2562,216 +3036,216 @@ ${sparcContent || 'No SPARC specification found.'}
 6. Write ALL files to the current working directory.
 
 The prompts must be production-grade — they will be given directly to a coding swarm to implement.`;
-                    const promptSwarmResult = executeRufloPhaseSwarm({
-                        phase: 4,
-                        label: 'Implementation Prompts',
-                        scenarioQuery,
-                        runDir,
-                        traceId,
-                        outputDir: rufloPromptDir,
-                        tasks: [{
-                                label: 'Implementation Prompt Generation',
-                                description: promptTask,
-                                targetDir: '.',
-                            }],
-                        agenticsResults: [],
-                        priorArtifacts: collectPhase4Artifacts(runDir),
-                        timeoutMs: 600_000, // 10 min
-                    });
-                    // Copy ruflo output to prompts dir
-                    if (fs.existsSync(rufloPromptDir)) {
-                        const rufloFiles = fs.readdirSync(rufloPromptDir);
-                        let promptsCopied = 0;
-                        for (const f of rufloFiles) {
-                            const src = path.join(rufloPromptDir, f);
-                            if (fs.statSync(src).isFile()) {
-                                fs.copyFileSync(src, path.join(promptsDir, f));
-                                promptsCopied++;
-                            }
-                        }
-                        if (promptsCopied > 0) {
-                            console.error(`  [PROMPTS] Ruflo swarm generated ${promptsCopied} implementation prompt files in ${promptSwarmResult.timing}ms`);
-                        }
-                    }
-                    // Check if ruflo produced prompts; if not, write them directly from the gathered content
-                    const generatedPrompts = fs.existsSync(promptsDir)
-                        ? fs.readdirSync(promptsDir).filter(f => f.startsWith('impl-'))
-                        : [];
-                    if (generatedPrompts.length === 0) {
-                        // ── Read all source material for prompt generation ──
-                        const adrMarkdownByFile = new Map();
-                        for (const f of adrFiles) {
-                            try {
-                                adrMarkdownByFile.set(f, fs.readFileSync(path.join(adrDir, f), 'utf-8'));
+                        const promptSwarmResult = executeRufloPhaseSwarm({
+                            phase: 4,
+                            label: 'Implementation Prompts',
+                            scenarioQuery,
+                            runDir,
+                            traceId,
+                            outputDir: rufloPromptDir,
+                            tasks: [{
+                                    label: 'Implementation Prompt Generation',
+                                    description: promptTask,
+                                    targetDir: '.',
+                                }],
+                            agenticsResults: [],
+                            priorArtifacts: collectPhase4Artifacts(runDir),
+                            timeoutMs: 600_000, // 10 min
+                        });
+                        // Copy ruflo output to prompts dir
+                        if (fs.existsSync(rufloPromptDir)) {
+                            const rufloFiles = fs.readdirSync(rufloPromptDir);
+                            let promptsCopied = 0;
+                            for (const f of rufloFiles) {
+                                const src = path.join(rufloPromptDir, f);
+                                if (fs.statSync(src).isFile()) {
+                                    fs.copyFileSync(src, path.join(promptsDir, f));
+                                    promptsCopied++;
+                                }
                             }
-                            catch { /* skip */ }
-                        }
-                        const adrIndexPath = path.join(adrDir, 'adr-index.json');
-                        let adrs = [];
-                        if (fs.existsSync(adrIndexPath)) {
-                            try {
-                                adrs = JSON.parse(fs.readFileSync(adrIndexPath, 'utf-8'));
+                            if (promptsCopied > 0) {
+                                console.error(`  [PROMPTS] Ruflo swarm generated ${promptsCopied} implementation prompt files in ${promptSwarmResult.timing}ms`);
                             }
-                            catch { /* empty */ }
                         }
-                        if (!Array.isArray(adrs) || adrs.length === 0) {
+                        // Check if ruflo produced prompts; if not, write them directly from the gathered content
+                        const generatedPrompts = fs.existsSync(promptsDir)
+                            ? fs.readdirSync(promptsDir).filter(f => f.startsWith('impl-'))
+                            : [];
+                        if (generatedPrompts.length === 0) {
+                            // ── Read all source material for prompt generation ──
+                            const adrMarkdownByFile = new Map();
                             for (const f of adrFiles) {
-                                const content = adrMarkdownByFile.get(f) ?? '';
-                                const titleMatch = content.match(/^#\s+(.+)/m);
-                                adrs.push({ id: f.replace(/\.md$/, ''), title: titleMatch?.[1] ?? f, context: content.slice(0, 500), decision: '', consequences: [], alternatives: [] });
+                                try {
+                                    adrMarkdownByFile.set(f, fs.readFileSync(path.join(adrDir, f), 'utf-8'));
+                                }
+                                catch { /* skip */ }
                             }
-                        }
-                        function getAdrMarkdown(adr) {
-                            for (const [filename, content] of adrMarkdownByFile) {
-                                if (filename.startsWith(adr.id))
-                                    return content;
+                            const adrIndexPath = path.join(adrDir, 'adr-index.json');
+                            let adrs = [];
+                            if (fs.existsSync(adrIndexPath)) {
+                                try {
+                                    adrs = JSON.parse(fs.readFileSync(adrIndexPath, 'utf-8'));
+                                }
+                                catch { /* empty */ }
                             }
-                            return '';
-                        }
-                        // Read DDD as reference material (not as driver)
-                        let dddContent = '';
-                        const dddModelPath = dddDir ? path.join(dddDir, 'domain-model.json') : '';
-                        if (dddModelPath && fs.existsSync(dddModelPath)) {
-                            try {
-                                dddContent = fs.readFileSync(dddModelPath, 'utf-8');
+                            if (!Array.isArray(adrs) || adrs.length === 0) {
+                                for (const f of adrFiles) {
+                                    const content = adrMarkdownByFile.get(f) ?? '';
+                                    const titleMatch = content.match(/^#\s+(.+)/m);
+                                    adrs.push({ id: f.replace(/\.md$/, ''), title: titleMatch?.[1] ?? f, context: content.slice(0, 500), decision: '', consequences: [], alternatives: [] });
+                                }
                             }
-                            catch { /* skip */ }
-                        }
-                        // Also read DDD markdown if available
-                        if (dddDir) {
-                            for (const f of ['domain-model.md', 'ddd-model.md']) {
-                                const p = path.join(dddDir, f);
-                                if (fs.existsSync(p)) {
-                                    try {
-                                        dddContent += '\n\n' + fs.readFileSync(p, 'utf-8');
-                                        break;
+                            function getAdrMarkdown(adr) {
+                                for (const [filename, content] of adrMarkdownByFile) {
+                                    if (filename.startsWith(adr.id))
+                                        return content;
+                                }
+                                return '';
+                            }
+                            // Read DDD as reference material (not as driver)
+                            let dddContent = '';
+                            const dddModelPath = dddDir ? path.join(dddDir, 'domain-model.json') : '';
+                            if (dddModelPath && fs.existsSync(dddModelPath)) {
+                                try {
+                                    dddContent = fs.readFileSync(dddModelPath, 'utf-8');
+                                }
+                                catch { /* skip */ }
+                            }
+                            // Also read DDD markdown if available
+                            if (dddDir) {
+                                for (const f of ['domain-model.md', 'ddd-model.md']) {
+                                    const p = path.join(dddDir, f);
+                                    if (fs.existsSync(p)) {
+                                        try {
+                                            dddContent += '\n\n' + fs.readFileSync(p, 'utf-8');
+                                            break;
+                                        }
+                                        catch { /* skip */ }
                                     }
-                                    catch { /* skip */ }
                                 }
                             }
-                        }
-                        // Read SPARC documents
-                        let sparcSpec = '';
-                        let sparcArch = '';
-                        if (sparcDir) {
-                            for (const [file, setter] of [
-                                ['specification.md', 'spec'], ['architecture.md', 'arch'],
-                            ]) {
-                                const p = path.join(sparcDir, file);
-                                if (fs.existsSync(p)) {
-                                    try {
-                                        const content = fs.readFileSync(p, 'utf-8');
-                                        if (setter === 'spec')
-                                            sparcSpec = content;
-                                        else if (setter === 'arch')
-                                            sparcArch = content;
+                            // Read SPARC documents
+                            let sparcSpec = '';
+                            let sparcArch = '';
+                            if (sparcDir) {
+                                for (const [file, setter] of [
+                                    ['specification.md', 'spec'], ['architecture.md', 'arch'],
+                                ]) {
+                                    const p = path.join(sparcDir, file);
+                                    if (fs.existsSync(p)) {
+                                        try {
+                                            const content = fs.readFileSync(p, 'utf-8');
+                                            if (setter === 'spec')
+                                                sparcSpec = content;
+                                            else if (setter === 'arch')
+                                                sparcArch = content;
+                                        }
+                                        catch { /* skip */ }
                                     }
-                                    catch { /* skip */ }
                                 }
                             }
-                        }
-                        console.error('  [PROMPTS] Ruflo swarm did not produce prompts — deriving from SPARC + ADRs');
-                        const derivedPhases = [];
-                        // Parse SPARC architecture for service/component sections
-                        if (sparcArch) {
-                            // Look for ## or ### headings that describe components/services
-                            const sections = sparcArch.split(/^(?=#{2,3}\s)/m).filter(s => s.trim().length > 20);
-                            for (const section of sections) {
-                                const headingMatch = section.match(/^#{2,3}\s+(.+)/);
-                                if (!headingMatch)
-                                    continue;
-                                const heading = headingMatch[1].trim();
-                                // Skip meta-sections
-                                if (/^(overview|introduction|summary|table of contents|references|constraints|non-functional)/i.test(heading))
-                                    continue;
-                                const slug = heading.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 50);
-                                // Determine target folder based on content
-                                const sectionLower = section.toLowerCase();
-                                let folder = 'backend';
-                                if (/\bfrontend\b|\bui\b|\bdashboard\b|\breact\b|\bvue\b|\bangular\b/.test(sectionLower))
-                                    folder = 'frontend';
-                                else if (/erp|netsuite|sap|dynamics|oracle/.test(sectionLower))
-                                    folder = 'erp';
-                                else if (/integration|connector|webhook|external|third.party/.test(sectionLower))
-                                    folder = 'integrations';
-                                else if (/api|service|backend|server|handler/.test(sectionLower))
-                                    folder = 'backend';
-                                else if (/test|quality|coverage/.test(sectionLower))
-                                    folder = 'tests';
-                                else if (/deploy|infra|docker|cloud|ci.cd/.test(sectionLower))
-                                    folder = 'src';
-                                else if (/doc|guide|reference/.test(sectionLower))
-                                    folder = 'docs';
-                                // Match ADRs to this section by keyword overlap
-                                const sectionWords = new Set(sectionLower.split(/\W+/).filter(w => w.length > 3));
-                                const matchedAdrIds = adrs.filter(adr => {
-                                    const adrWords = `${adr.title} ${adr.context} ${adr.decision}`.toLowerCase().split(/\W+/).filter(w => w.length > 3);
-                                    const overlap = adrWords.filter(w => sectionWords.has(w)).length;
-                                    return overlap >= 2;
-                                }).map(a => a.id);
-                                derivedPhases.push({ title: heading, slug, content: section, folder, adrIds: matchedAdrIds });
+                            console.error('  [PROMPTS] Ruflo swarm did not produce prompts — deriving from SPARC + ADRs');
+                            const derivedPhases = [];
+                            // Parse SPARC architecture for service/component sections
+                            if (sparcArch) {
+                                // Look for ## or ### headings that describe components/services
+                                const sections = sparcArch.split(/^(?=#{2,3}\s)/m).filter(s => s.trim().length > 20);
+                                for (const section of sections) {
+                                    const headingMatch = section.match(/^#{2,3}\s+(.+)/);
+                                    if (!headingMatch)
+                                        continue;
+                                    const heading = headingMatch[1].trim();
+                                    // Skip meta-sections
+                                    if (/^(overview|introduction|summary|table of contents|references|constraints|non-functional)/i.test(heading))
+                                        continue;
+                                    const slug = heading.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 50);
+                                    // Determine target folder based on content
+                                    const sectionLower = section.toLowerCase();
+                                    let folder = 'backend';
+                                    if (/\bfrontend\b|\bui\b|\bdashboard\b|\breact\b|\bvue\b|\bangular\b/.test(sectionLower))
+                                        folder = 'frontend';
+                                    else if (/erp|netsuite|sap|dynamics|oracle/.test(sectionLower))
+                                        folder = 'erp';
+                                    else if (/integration|connector|webhook|external|third.party/.test(sectionLower))
+                                        folder = 'integrations';
+                                    else if (/api|service|backend|server|handler/.test(sectionLower))
+                                        folder = 'backend';
+                                    else if (/test|quality|coverage/.test(sectionLower))
+                                        folder = 'tests';
+                                    else if (/deploy|infra|docker|cloud|ci.cd/.test(sectionLower))
+                                        folder = 'src';
+                                    else if (/doc|guide|reference/.test(sectionLower))
+                                        folder = 'docs';
+                                    // Match ADRs to this section by keyword overlap
+                                    const sectionWords = new Set(sectionLower.split(/\W+/).filter(w => w.length > 3));
+                                    const matchedAdrIds = adrs.filter(adr => {
+                                        const adrWords = `${adr.title} ${adr.context} ${adr.decision}`.toLowerCase().split(/\W+/).filter(w => w.length > 3);
+                                        const overlap = adrWords.filter(w => sectionWords.has(w)).length;
+                                        return overlap >= 2;
+                                    }).map(a => a.id);
+                                    derivedPhases.push({ title: heading, slug, content: section, folder, adrIds: matchedAdrIds });
+                                }
                             }
-                        }
-                        // ADR-PIPELINE-031: Enrich with ADR-derived phases when SPARC sections alone are insufficient.
-                        // Each ADR that isn't already covered by a SPARC-derived phase becomes its own build step.
-                        if (derivedPhases.length < 8 && adrs.length > 0) {
-                            const existingSlugs = new Set(derivedPhases.map(p => p.slug));
-                            const existingTitleWords = new Set(derivedPhases.flatMap(p => p.title.toLowerCase().split(/\W+/).filter(w => w.length > 3)));
-                            for (const adr of adrs) {
-                                const slug = adr.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 50);
-                                // Skip if a phase with similar slug or overlapping title already exists
-                                if (existingSlugs.has(slug))
-                                    continue;
-                                const adrKeywords = adr.title.toLowerCase().split(/\W+/).filter(w => w.length > 3);
-                                const overlap = adrKeywords.filter(w => existingTitleWords.has(w)).length;
-                                if (overlap >= 2)
-                                    continue; // sufficiently covered by an existing phase
-                                const adrLower = `${adr.title} ${adr.context} ${adr.decision}`.toLowerCase();
-                                let folder = 'backend';
-                                if (/frontend|ui|dashboard/.test(adrLower))
-                                    folder = 'frontend';
-                                else if (/erp|netsuite|sap|dynamics|coupa|workday|maximo|oracle/.test(adrLower))
-                                    folder = 'erp';
-                                else if (/integration|connector|webhook/.test(adrLower))
-                                    folder = 'integrations';
-                                else if (/deploy|infra|docker/.test(adrLower))
-                                    folder = 'src';
-                                else if (/test|quality/.test(adrLower))
-                                    folder = 'tests';
-                                else if (/audit|governance|approval/.test(adrLower))
-                                    folder = 'backend';
-                                derivedPhases.push({
-                                    title: adr.title,
-                                    slug,
-                                    content: getAdrMarkdown(adr) || `**Context:** ${adr.context}\n\n**Decision:** ${adr.decision}`,
-                                    folder,
-                                    adrIds: [adr.id],
-                                });
-                                existingSlugs.add(slug);
-                                for (const w of adrKeywords)
-                                    existingTitleWords.add(w);
+                            // ADR-PIPELINE-031: Enrich with ADR-derived phases when SPARC sections alone are insufficient.
+                            // Each ADR that isn't already covered by a SPARC-derived phase becomes its own build step.
+                            if (derivedPhases.length < 8 && adrs.length > 0) {
+                                const existingSlugs = new Set(derivedPhases.map(p => p.slug));
+                                const existingTitleWords = new Set(derivedPhases.flatMap(p => p.title.toLowerCase().split(/\W+/).filter(w => w.length > 3)));
+                                for (const adr of adrs) {
+                                    const slug = adr.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 50);
+                                    // Skip if a phase with similar slug or overlapping title already exists
+                                    if (existingSlugs.has(slug))
+                                        continue;
+                                    const adrKeywords = adr.title.toLowerCase().split(/\W+/).filter(w => w.length > 3);
+                                    const overlap = adrKeywords.filter(w => existingTitleWords.has(w)).length;
+                                    if (overlap >= 2)
+                                        continue; // sufficiently covered by an existing phase
+                                    const adrLower = `${adr.title} ${adr.context} ${adr.decision}`.toLowerCase();
+                                    let folder = 'backend';
+                                    if (/frontend|ui|dashboard/.test(adrLower))
+                                        folder = 'frontend';
+                                    else if (/erp|netsuite|sap|dynamics|coupa|workday|maximo|oracle/.test(adrLower))
+                                        folder = 'erp';
+                                    else if (/integration|connector|webhook/.test(adrLower))
+                                        folder = 'integrations';
+                                    else if (/deploy|infra|docker/.test(adrLower))
+                                        folder = 'src';
+                                    else if (/test|quality/.test(adrLower))
+                                        folder = 'tests';
+                                    else if (/audit|governance|approval/.test(adrLower))
+                                        folder = 'backend';
+                                    derivedPhases.push({
+                                        title: adr.title,
+                                        slug,
+                                        content: getAdrMarkdown(adr) || `**Context:** ${adr.context}\n\n**Decision:** ${adr.decision}`,
+                                        folder,
+                                        adrIds: [adr.id],
+                                    });
+                                    existingSlugs.add(slug);
+                                    for (const w of adrKeywords)
+                                        existingTitleWords.add(w);
+                                }
                             }
-                        }
-                        // Always add foundation (first) and testing/deployment (last) if not present
-                        const hasTesting = derivedPhases.some(p => /test/i.test(p.title));
-                        const hasDeployment = derivedPhases.some(p => /deploy|infra/i.test(p.title));
-                        // Detect multi-language requirements (e.g., TypeScript + Rust)
-                        const queryLower = scenarioQuery.toLowerCase();
-                        const hasRust = /\brust\b/.test(queryLower);
-                        const hasTypeScript = /\btypescript\b/.test(queryLower);
-                        const rustPurpose = scenarioQuery.match(/rust\s+(?:used\s+)?(?:for\s+)?(.{10,100}?)(?:\.|,|$)/i)?.[1]?.trim() ?? '';
-                        const languageNote = hasRust && hasTypeScript
-                            ? `\n\nThis is a HYBRID TypeScript + Rust project. TypeScript handles orchestration and service layers. Rust handles ${rustPurpose || 'compute-intensive components'}. Set up both package.json and Cargo.toml. Create a rust/ directory for Rust crates with WASM or FFI bindings to TypeScript.`
-                            : hasRust
-                                ? `\n\nThis project uses Rust. Set up Cargo.toml workspace.`
-                                : '';
-                        // Insert foundation at the beginning — ADR-039: logger + config are FIRST outputs
-                        // Detect language from query to make scaffold language-appropriate
-                        const detectedLang = hasRust ? 'Rust' : hasTypeScript ? 'TypeScript' : /\bpython\b/i.test(queryLower) ? 'Python' : /\bgo\b|\bgolang\b/i.test(queryLower) ? 'Go' : /\bjava\b/i.test(queryLower) ? 'Java' : 'TypeScript';
-                        derivedPhases.unshift({
-                            title: 'Project Foundation & Core Types',
-                            slug: 'foundation',
-                            content: `Set up project structure, build tooling, and shared infrastructure using **${detectedLang}**. All subsequent phases import from this.${languageNote}
+                            // Always add foundation (first) and testing/deployment (last) if not present
+                            const hasTesting = derivedPhases.some(p => /test/i.test(p.title));
+                            const hasDeployment = derivedPhases.some(p => /deploy|infra/i.test(p.title));
+                            // Detect multi-language requirements (e.g., TypeScript + Rust)
+                            const queryLower = scenarioQuery.toLowerCase();
+                            const hasRust = /\brust\b/.test(queryLower);
+                            const hasTypeScript = /\btypescript\b/.test(queryLower);
+                            const rustPurpose = scenarioQuery.match(/rust\s+(?:used\s+)?(?:for\s+)?(.{10,100}?)(?:\.|,|$)/i)?.[1]?.trim() ?? '';
+                            const languageNote = hasRust && hasTypeScript
+                                ? `\n\nThis is a HYBRID TypeScript + Rust project. TypeScript handles orchestration and service layers. Rust handles ${rustPurpose || 'compute-intensive components'}. Set up both package.json and Cargo.toml. Create a rust/ directory for Rust crates with WASM or FFI bindings to TypeScript.`
+                                : hasRust
+                                    ? `\n\nThis project uses Rust. Set up Cargo.toml workspace.`
+                                    : '';
+                            // Insert foundation at the beginning — ADR-039: logger + config are FIRST outputs
+                            // Detect language from query to make scaffold language-appropriate
+                            const detectedLang = hasRust ? 'Rust' : hasTypeScript ? 'TypeScript' : /\bpython\b/i.test(queryLower) ? 'Python' : /\bgo\b|\bgolang\b/i.test(queryLower) ? 'Go' : /\bjava\b/i.test(queryLower) ? 'Java' : 'TypeScript';
+                            derivedPhases.unshift({
+                                title: 'Project Foundation & Core Types',
+                                slug: 'foundation',
+                                content: `Set up project structure, build tooling, and shared infrastructure using **${detectedLang}**. All subsequent phases import from this.${languageNote}
 
 ## FIRST: Create these shared modules (before domain types)
 
@@ -2840,32 +3314,32 @@ Create \`src/container.ts\` that wires all services via constructor injection:
 
 Base folder structure: src/, tests/, docs/. Create package.json, tsconfig.json, vitest.config.ts.
 Define all shared domain types in src/types.ts.`,
-                            folder: 'src',
-                            adrIds: adrs.map(a => a.id),
-                        });
-                        if (!hasTesting) {
-                            derivedPhases.push({
-                                title: 'Testing & Quality Assurance',
-                                slug: 'testing',
-                                content: 'Write comprehensive tests for all components built in prior phases.',
-                                folder: 'tests',
-                                adrIds: [],
-                            });
-                        }
-                        if (!hasDeployment) {
-                            derivedPhases.push({
-                                title: 'Deployment & Infrastructure',
-                                slug: 'deployment',
-                                content: 'Create deployment configs, Dockerfiles, CI/CD, and infrastructure-as-code for the target cloud platform.',
                                 folder: 'src',
-                                adrIds: [],
+                                adrIds: adrs.map(a => a.id),
                             });
-                        }
-                        // ADR-PIPELINE-031: Guarantee ≥10 prompts by adding standard cross-cutting phases
-                        // when domain-specific + ADR-derived phases don't reach the minimum.
-                        const crossCutting = [
-                            { title: 'Observability & Structured Logging', slug: 'observability', folder: 'backend',
-                                content: `ADR-PIPELINE-034: Implement complete observability infrastructure.
+                            if (!hasTesting) {
+                                derivedPhases.push({
+                                    title: 'Testing & Quality Assurance',
+                                    slug: 'testing',
+                                    content: 'Write comprehensive tests for all components built in prior phases.',
+                                    folder: 'tests',
+                                    adrIds: [],
+                                });
+                            }
+                            if (!hasDeployment) {
+                                derivedPhases.push({
+                                    title: 'Deployment & Infrastructure',
+                                    slug: 'deployment',
+                                    content: 'Create deployment configs, Dockerfiles, CI/CD, and infrastructure-as-code for the target cloud platform.',
+                                    folder: 'src',
+                                    adrIds: [],
+                                });
+                            }
+                            // ADR-PIPELINE-031: Guarantee ≥10 prompts by adding standard cross-cutting phases
+                            // when domain-specific + ADR-derived phases don't reach the minimum.
+                            const crossCutting = [
+                                { title: 'Observability & Structured Logging', slug: 'observability', folder: 'backend',
+                                    content: `ADR-PIPELINE-034: Implement complete observability infrastructure.
 
 ## 1. Structured Logger (src/logger.ts)
 
@@ -2927,8 +3401,8 @@ If the project includes an API layer, add GET /health returning:
 - Test that logger outputs valid JSON to stderr
 - Test that correlationId flows through analysis → decision → ERP sync
 - Test that ERP error handling retries on 429 and logs failures` },
-                            { title: 'Configuration & Environment Management', slug: 'configuration', folder: 'src',
-                                content: `ADR-PIPELINE-034: Configuration module for environment-based settings.
+                                { title: 'Configuration & Environment Management', slug: 'configuration', folder: 'src',
+                                    content: `ADR-PIPELINE-034: Configuration module for environment-based settings.
 
 Create src/config.ts with a typed configuration object:
 
@@ -2956,8 +3430,8 @@ Requirements:
 - Provide sensible defaults for optional values (timeoutMs, maxRetries, logLevel)
 - Export a singleton config object used by all services
 - Include tests that verify validation catches missing required vars` },
-                            { title: 'API Layer & Request Handling', slug: 'api-layer', folder: 'backend',
-                                content: `ADR-PIPELINE-043: Thin route handlers with Zod validation.
+                                { title: 'API Layer & Request Handling', slug: 'api-layer', folder: 'backend',
+                                    content: `ADR-PIPELINE-043: Thin route handlers with Zod validation.
 
 ARCHITECTURE: Route handlers MUST be thin:
 - Route: parse request → validate with Zod schema → call service function → format response
@@ -2981,10 +3455,10 @@ REQUIRED ENDPOINTS:
 - GET /api/metrics → Prometheus-format metrics (request count, latency histogram, error rate)
 - All domain endpoints with proper HTTP status codes and structured error responses
 - Every response includes X-Correlation-Id header` },
-                            { title: 'Persistence & Data Access Layer', slug: 'persistence', folder: 'backend',
-                                content: 'Implement repository interfaces per aggregate (ports pattern). Database adapter implementations. Audit trail persistence (append-only, tamper-evident). Transaction management for multi-aggregate operations.' },
-                            { title: 'Demo Script & CLI Entry Point', slug: 'demo', folder: 'src',
-                                content: `ADR-PIPELINE-037: User-facing entry points for the prototype.
+                                { title: 'Persistence & Data Access Layer', slug: 'persistence', folder: 'backend',
+                                    content: 'Implement repository interfaces per aggregate (ports pattern). Database adapter implementations. Audit trail persistence (append-only, tamper-evident). Transaction management for multi-aggregate operations.' },
+                                { title: 'Demo Script & CLI Entry Point', slug: 'demo', folder: 'src',
+                                    content: `ADR-PIPELINE-037: User-facing entry points for the prototype.
 
 ## 1. Demo Script (src/demo.ts) — REQUIRED
 
@@ -3115,227 +3589,242 @@ services when the pilot validates the approach.
 ## Tests
 - Test that demo.ts runs without errors (import and execute main function)
 - Test that it produces non-empty stdout output` },
-                        ];
-                        const existingSlugSet = new Set(derivedPhases.map(p => p.slug));
-                        for (const cc of crossCutting) {
-                            if (derivedPhases.length >= 12)
-                                break;
-                            if (existingSlugSet.has(cc.slug))
-                                continue;
-                            // Don't add if a phase already covers this topic
-                            if (derivedPhases.some(p => p.title.toLowerCase().includes(cc.slug.split('-')[0])))
-                                continue;
-                            derivedPhases.push({ ...cc, adrIds: [] });
-                            existingSlugSet.add(cc.slug);
-                        }
-                        console.error(`  [PROMPTS] ${derivedPhases.length} phases derived (SPARC + ADRs + cross-cutting, minimum 10 per ADR-PIPELINE-031)`);
-                        // ── Helper: extract DDD context names and summaries relevant to a phase ──
-                        function getDddSummaryForPhase(phaseTitle, phaseContent) {
-                            if (!dddContent)
-                                return '';
-                            try {
-                                const model = JSON.parse(dddContent);
-                                const contexts = model.contexts ?? [];
-                                if (contexts.length === 0)
+                            ];
+                            const existingSlugSet = new Set(derivedPhases.map(p => p.slug));
+                            for (const cc of crossCutting) {
+                                if (derivedPhases.length >= 12)
+                                    break;
+                                if (existingSlugSet.has(cc.slug))
+                                    continue;
+                                // Don't add if a phase already covers this topic
+                                if (derivedPhases.some(p => p.title.toLowerCase().includes(cc.slug.split('-')[0])))
+                                    continue;
+                                derivedPhases.push({ ...cc, adrIds: [] });
+                                existingSlugSet.add(cc.slug);
+                            }
+                            console.error(`  [PROMPTS] ${derivedPhases.length} phases derived (SPARC + ADRs + cross-cutting, minimum 10 per ADR-PIPELINE-031)`);
+                            // ── Helper: extract DDD context names and summaries relevant to a phase ──
+                            function getDddSummaryForPhase(phaseTitle, phaseContent) {
+                                if (!dddContent)
                                     return '';
-                                // Exclude common words that would match everything
-                                const excludeWords = new Set(['domain', 'logic', 'crud', 'operations', 'manage', 'business', 'rules', 'event', 'handling', 'service', 'system', 'data', 'component', 'module', 'implementation', 'integration']);
-                                const phaseWords = new Set(`${phaseTitle} ${phaseContent}`.toLowerCase().split(/\W+/).filter((w) => w.length > 3 && !excludeWords.has(w)));
-                                const relevant = contexts.filter((c) => {
-                                    const ctxText = `${c['name']}`.toLowerCase().split(/[-_\s]+/).filter((w) => w.length > 3 && !excludeWords.has(w));
-                                    // Must match on context NAME keywords, not generic description words
-                                    const matches = ctxText.filter((w) => phaseWords.has(w)).length;
-                                    return matches >= 1;
-                                });
-                                if (relevant.length === 0)
+                                try {
+                                    const model = JSON.parse(dddContent);
+                                    const contexts = model.contexts ?? [];
+                                    if (contexts.length === 0)
+                                        return '';
+                                    // Exclude common words that would match everything
+                                    const excludeWords = new Set(['domain', 'logic', 'crud', 'operations', 'manage', 'business', 'rules', 'event', 'handling', 'service', 'system', 'data', 'component', 'module', 'implementation', 'integration']);
+                                    const phaseWords = new Set(`${phaseTitle} ${phaseContent}`.toLowerCase().split(/\W+/).filter((w) => w.length > 3 && !excludeWords.has(w)));
+                                    const relevant = contexts.filter((c) => {
+                                        const ctxText = `${c['name']}`.toLowerCase().split(/[-_\s]+/).filter((w) => w.length > 3 && !excludeWords.has(w));
+                                        // Must match on context NAME keywords, not generic description words
+                                        const matches = ctxText.filter((w) => phaseWords.has(w)).length;
+                                        return matches >= 1;
+                                    });
+                                    if (relevant.length === 0)
+                                        return '';
+                                    const parts = [];
+                                    for (const c of relevant) {
+                                        const name = String(c['name'] ?? '');
+                                        const desc = String(c['description'] ?? '');
+                                        const aggs = (c['aggregates'] ?? []).map((a) => String(a['name'] ?? '')).filter(Boolean);
+                                        const cmds = (c['commands'] ?? []).map((cmd) => typeof cmd === 'string' ? cmd : String(cmd['name'] ?? '')).filter(Boolean);
+                                        const queries = (c['queries'] ?? []).map((q) => typeof q === 'string' ? q : String(q['name'] ?? '')).filter(Boolean);
+                                        let summary = `**${name}**: ${desc}`;
+                                        if (aggs.length > 0)
+                                            summary += ` (aggregates: ${aggs.join(', ')})`;
+                                        if (cmds.length > 0)
+                                            summary += ` (commands: ${cmds.join(', ')})`;
+                                        if (queries.length > 0)
+                                            summary += ` (queries: ${queries.join(', ')})`;
+                                        parts.push(summary);
+                                    }
+                                    return parts.join('\n\n');
+                                }
+                                catch {
                                     return '';
-                                const parts = [];
-                                for (const c of relevant) {
-                                    const name = String(c['name'] ?? '');
-                                    const desc = String(c['description'] ?? '');
-                                    const aggs = (c['aggregates'] ?? []).map((a) => String(a['name'] ?? '')).filter(Boolean);
-                                    const cmds = (c['commands'] ?? []).map((cmd) => typeof cmd === 'string' ? cmd : String(cmd['name'] ?? '')).filter(Boolean);
-                                    const queries = (c['queries'] ?? []).map((q) => typeof q === 'string' ? q : String(q['name'] ?? '')).filter(Boolean);
-                                    let summary = `**${name}**: ${desc}`;
-                                    if (aggs.length > 0)
-                                        summary += ` (aggregates: ${aggs.join(', ')})`;
-                                    if (cmds.length > 0)
-                                        summary += ` (commands: ${cmds.join(', ')})`;
-                                    if (queries.length > 0)
-                                        summary += ` (queries: ${queries.join(', ')})`;
-                                    parts.push(summary);
                                 }
-                                return parts.join('\n\n');
-                            }
-                            catch {
-                                return '';
-                            }
-                        }
-                        // ── Helper: build a narrative description paragraph for a phase ──
-                        function buildPhaseNarrative(phase, phaseAdrs, dddSummary, completedList) {
-                            const parts = [];
-                            // Opening: what this phase builds
-                            parts.push(`In this phase, you are building the **${phase.title}** component of the platform.`);
-                            // What prior phases provide
-                            if (completedList.length > 0) {
-                                parts.push(`This builds on ${completedList.length} previously completed phase(s) — import shared types, interfaces, and services from those modules.`);
                             }
-                            // ADR narrative: which decisions govern this phase and what they decided
-                            if (phaseAdrs.length > 0) {
-                                const adrSentences = phaseAdrs.map(a => {
-                                    const decision = a.decision?.split('.')[0] ?? a.title;
-                                    return `${a.id} ("${a.title}") which decided: ${decision}`;
-                                });
-                                if (adrSentences.length === 1) {
-                                    parts.push(`This phase is governed by architecture decision ${adrSentences[0]}.`);
-                                }
-                                else {
-                                    parts.push(`This phase is governed by ${adrSentences.length} architecture decisions: ${adrSentences.join('; ')}.`);
+                            // ── Helper: build a narrative description paragraph for a phase ──
+                            function buildPhaseNarrative(phase, phaseAdrs, dddSummary, completedList) {
+                                const parts = [];
+                                // Opening: what this phase builds
+                                parts.push(`In this phase, you are building the **${phase.title}** component of the platform.`);
+                                // What prior phases provide
+                                if (completedList.length > 0) {
+                                    parts.push(`This builds on ${completedList.length} previously completed phase(s) — import shared types, interfaces, and services from those modules.`);
                                 }
-                            }
-                            // DDD narrative: which domain concepts are relevant
-                            if (dddSummary) {
-                                parts.push(`The domain model defines the following relevant contexts and entities for this phase:\n\n${dddSummary}`);
-                            }
-                            return parts.join(' ');
-                        }
-                        const totalSteps = derivedPhases.length;
-                        const completedPhases = [];
-                        for (let i = 0; i < totalSteps; i++) {
-                            const phase = derivedPhases[i];
-                            const order = i + 1;
-                            const filename = `impl-${String(order).padStart(3, '0')}-${phase.slug}.md`;
-                            // Resolve ADRs for this phase
-                            const phaseAdrs = phase.adrIds.length > 0
-                                ? adrs.filter(a => phase.adrIds.includes(a.id))
-                                : (order === 1 ? adrs : []);
-                            // Resolve DDD summary for this phase
-                            const dddSummary = getDddSummaryForPhase(phase.title, phase.content);
-                            // Build the narrative paragraph
-                            const narrative = buildPhaseNarrative(phase, phaseAdrs, dddSummary, completedPhases);
-                            const lines = [
-                                `# Implementation Prompt ${order} of ${totalSteps}: ${phase.title}`,
-                                '',
-                                `**Target folder:** \`${phase.folder}/\``,
-                                '',
-                            ];
-                            // ADR-PIPELINE-033: Simulation lineage in every prompt
-                            if (simulationId || traceId) {
-                                lines.push('## Simulation Lineage', '');
-                                if (simulationId)
-                                    lines.push(`Originating simulation: \`${simulationId}\``);
-                                lines.push(`Trace ID: \`${traceId}\``);
-                                lines.push('');
-                            }
-                            // ── Narrative description — the core of each prompt ──
-                            lines.push('## Overview', '', narrative, '');
-                            // Previously completed phases (brief list)
-                            if (completedPhases.length > 0) {
-                                lines.push('## Previously Completed (available for import)', '');
-                                for (const prev of completedPhases)
-                                    lines.push(`- ${prev}`);
-                                lines.push('');
-                            }
-                            // Full project requirements on first prompt only
-                            if (order === 1) {
-                                lines.push('## Project Requirements', '', scenarioQuery, '');
-                            }
-                            // SPARC-derived content for this phase (the actual architecture section)
-                            if (phase.content && phase.content.length > 50) {
-                                lines.push('## SPARC Architecture for This Phase', '', phase.content, '');
-                            }
-                            // SPARC spec + architecture on first two prompts for full context
-                            if (order === 1 && sparcSpec) {
-                                lines.push('## Full SPARC Specification', '', sparcSpec, '');
-                            }
-                            if (order <= 2 && sparcArch && phase.content !== sparcArch) {
-                                lines.push('## Full SPARC Architecture', '', sparcArch, '');
-                            }
-                            // ADR details — full markdown with file paths for each relevant ADR
-                            if (phaseAdrs.length > 0) {
-                                lines.push(`## Architecture Decisions (${phaseAdrs.length} ADRs)`, '');
-                                lines.push('ADR files are in `.agentics/plans/adrs/` — read them for full context:', '');
-                                for (const adr of phaseAdrs) {
-                                    const slug = (adr.title || 'untitled').toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 60);
-                                    const adrFilename = `${adr.id}-${slug}.md`;
-                                    lines.push(`**File:** \`.agentics/plans/adrs/${adrFilename}\``, '');
-                                    const fullMarkdown = getAdrMarkdown(adr);
-                                    if (fullMarkdown) {
-                                        lines.push(fullMarkdown, '', '---', '');
+                                // ADR narrative: which decisions govern this phase and what they decided
+                                if (phaseAdrs.length > 0) {
+                                    const adrSentences = phaseAdrs.map(a => {
+                                        const decision = a.decision?.split('.')[0] ?? a.title;
+                                        return `${a.id} ("${a.title}") which decided: ${decision}`;
+                                    });
+                                    if (adrSentences.length === 1) {
+                                        parts.push(`This phase is governed by architecture decision ${adrSentences[0]}.`);
                                     }
                                     else {
-                                        lines.push(`### ${adr.id}: ${adr.title}`, '');
-                                        if (adr.context)
-                                            lines.push(`**Context:** ${adr.context}`, '');
-                                        if (adr.decision)
-                                            lines.push(`**Decision:** ${adr.decision}`, '');
-                                        if (adr.consequences?.length) {
-                                            lines.push('**Consequences:**');
-                                            for (const c of adr.consequences)
-                                                lines.push(`- ${c}`);
-                                        }
-                                        lines.push('');
+                                        parts.push(`This phase is governed by ${adrSentences.length} architecture decisions: ${adrSentences.join('; ')}.`);
                                     }
                                 }
+                                // DDD narrative: which domain concepts are relevant
+                                if (dddSummary) {
+                                    parts.push(`The domain model defines the following relevant contexts and entities for this phase:\n\n${dddSummary}`);
+                                }
+                                return parts.join(' ');
                             }
-                            // List ALL ADR files for reference even if not directly linked to this phase
-                            if (adrDir && order === 1) {
-                                try {
-                                    const allAdrFiles = fs.readdirSync(adrDir).filter(f => f.endsWith('.md')).sort();
-                                    if (allAdrFiles.length > 0) {
-                                        lines.push('## All Architecture Decision Records', '');
-                                        lines.push('Read these files in `.agentics/plans/adrs/` for complete design rationale:', '');
-                                        for (const f of allAdrFiles) {
-                                            lines.push(`- \`.agentics/plans/adrs/${f}\``);
+                            const totalSteps = derivedPhases.length;
+                            const completedPhases = [];
+                            for (let i = 0; i < totalSteps; i++) {
+                                const phase = derivedPhases[i];
+                                const order = i + 1;
+                                const filename = `impl-${String(order).padStart(3, '0')}-${phase.slug}.md`;
+                                // Resolve ADRs for this phase
+                                const phaseAdrs = phase.adrIds.length > 0
+                                    ? adrs.filter(a => phase.adrIds.includes(a.id))
+                                    : (order === 1 ? adrs : []);
+                                // Resolve DDD summary for this phase
+                                const dddSummary = getDddSummaryForPhase(phase.title, phase.content);
+                                // Build the narrative paragraph
+                                const narrative = buildPhaseNarrative(phase, phaseAdrs, dddSummary, completedPhases);
+                                const lines = [
+                                    `# Implementation Prompt ${order} of ${totalSteps}: ${phase.title}`,
+                                    '',
+                                    `**Target folder:** \`${phase.folder}/\``,
+                                    '',
+                                ];
+                                // ADR-PIPELINE-033: Simulation lineage in every prompt
+                                if (simulationId || traceId) {
+                                    lines.push('## Simulation Lineage', '');
+                                    if (simulationId)
+                                        lines.push(`Originating simulation: \`${simulationId}\``);
+                                    lines.push(`Trace ID: \`${traceId}\``);
+                                    lines.push('');
+                                }
+                                // ── Narrative description — the core of each prompt ──
+                                lines.push('## Overview', '', narrative, '');
+                                // Previously completed phases (brief list)
+                                if (completedPhases.length > 0) {
+                                    lines.push('## Previously Completed (available for import)', '');
+                                    for (const prev of completedPhases)
+                                        lines.push(`- ${prev}`);
+                                    lines.push('');
+                                }
+                                // Full project requirements on first prompt only
+                                if (order === 1) {
+                                    lines.push('## Project Requirements', '', scenarioQuery, '');
+                                }
+                                // SPARC-derived content for this phase (the actual architecture section)
+                                if (phase.content && phase.content.length > 50) {
+                                    lines.push('## SPARC Architecture for This Phase', '', phase.content, '');
+                                }
+                                // SPARC spec + architecture on first two prompts for full context
+                                if (order === 1 && sparcSpec) {
+                                    lines.push('## Full SPARC Specification', '', sparcSpec, '');
+                                }
+                                if (order <= 2 && sparcArch && phase.content !== sparcArch) {
+                                    lines.push('## Full SPARC Architecture', '', sparcArch, '');
+                                }
+                                // ADR details — full markdown with file paths for each relevant ADR
+                                if (phaseAdrs.length > 0) {
+                                    lines.push(`## Architecture Decisions (${phaseAdrs.length} ADRs)`, '');
+                                    lines.push('ADR files are in `.agentics/plans/adrs/` — read them for full context:', '');
+                                    for (const adr of phaseAdrs) {
+                                        const slug = (adr.title || 'untitled').toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 60);
+                                        const adrFilename = `${adr.id}-${slug}.md`;
+                                        lines.push(`**File:** \`.agentics/plans/adrs/${adrFilename}\``, '');
+                                        const fullMarkdown = getAdrMarkdown(adr);
+                                        if (fullMarkdown) {
+                                            lines.push(fullMarkdown, '', '---', '');
+                                        }
+                                        else {
+                                            lines.push(`### ${adr.id}: ${adr.title}`, '');
+                                            if (adr.context)
+                                                lines.push(`**Context:** ${adr.context}`, '');
+                                            if (adr.decision)
+                                                lines.push(`**Decision:** ${adr.decision}`, '');
+                                            if (adr.consequences?.length) {
+                                                lines.push('**Consequences:**');
+                                                for (const c of adr.consequences)
+                                                    lines.push(`- ${c}`);
+                                            }
+                                            lines.push('');
                                         }
-                                        lines.push('');
                                     }
                                 }
-                                catch { /* non-fatal */ }
-                            }
-                            // DDD reference — structured summary, not raw JSON dump
-                            if (dddSummary) {
-                                lines.push('## Domain Model Reference', '', dddSummary, '');
+                                // List ALL ADR files for reference even if not directly linked to this phase
+                                if (adrDir && order === 1) {
+                                    try {
+                                        const allAdrFiles = fs.readdirSync(adrDir).filter(f => f.endsWith('.md')).sort();
+                                        if (allAdrFiles.length > 0) {
+                                            lines.push('## All Architecture Decision Records', '');
+                                            lines.push('Read these files in `.agentics/plans/adrs/` for complete design rationale:', '');
+                                            for (const f of allAdrFiles) {
+                                                lines.push(`- \`.agentics/plans/adrs/${f}\``);
+                                            }
+                                            lines.push('');
+                                        }
+                                    }
+                                    catch { /* non-fatal */ }
+                                }
+                                // DDD reference — structured summary, not raw JSON dump
+                                if (dddSummary) {
+                                    lines.push('## Domain Model Reference', '', dddSummary, '');
+                                }
+                                // Implementation instructions — ADR-PIPELINE-033: include traceability requirements
+                                lines.push('## Implementation Requirements', '', '- All code must be CUSTOM to this project — implement the specific business logic described above', '- Follow the technology decisions from the ADRs referenced in the overview', '- Write production-quality code with proper error handling', '- Include unit tests (London School TDD — mock at module boundaries)', '- Export public interfaces so later build phases can import them', `- Place all files in the \`${phase.folder}/\` directory`, '', '## Traceability & Simulation Alignment (ADR-033 + ADR-049)', '', '### Domain Type Fields (REQUIRED on Decision, Recommendation, ERPTransaction):', '```', 'interface Recommendation {', '  // ... domain fields ...', '  simulationId?: string;    // Pipeline simulation that produced the analysis', '  traceId?: string;         // Correlation ID for end-to-end tracing', '  pipelineVersion?: string;  // Version of the pipeline that generated this', '}', '```', '', `${simulationId ? `### Simulation ID: \`${simulationId}\`\nUse this as the default simulationId when creating records.` : '### Simulation ID: load from .agentics/plans/manifest.json at startup.'}`, '', '### Simulation Config Integration:', '- Load .agentics/plans/manifest.json at startup (if it exists)', '- Read simulationId and traceId from it', '- Pass to all service constructors so every record carries lineage', '- Log simulationId in every analysis run: `logger.info("analysis.start", { simulationId })`', '', '### Confidence Disclosure in Demo Output:', '- The demo script MUST print an "Analysis Confidence" section', '- State the confidence level and what it means', '- If confidence < 60%: "The pilot resolves remaining uncertainty with real data"', '- If confidence >= 80%: "High confidence — proceed to pilot with standard monitoring"', '');
+                                // ADR-PIPELINE-039: Mandatory cross-cutting requirements in EVERY prompt
+                                lines.push('## Mandatory Cross-Cutting Requirements (EVERY module must implement these)', '', '### Logging', '- Create `src/logger.ts` (if it does not exist) with `createLogger(service: string)` that outputs JSON to stderr', '- Every log entry: `{ timestamp, level, service, event, correlationId?, ...data }`', '- Import and use the logger in THIS module. Log: function entry with key params, completion with duration, errors with context', '', '### Configuration', '- Create `src/config.ts` (if it does not exist) with typed `AppConfig` read from environment variables', '- NEVER hardcode: ports, URLs, thresholds, weights, API keys, timeouts', '- Import config in THIS module for any configurable value', '', '### Input Validation (ADR-046: Zod at EVERY boundary)', '- EVERY function receiving external data MUST Zod-parse it:', '  API request bodies: `const parsed = Schema.safeParse(req.body); if (!parsed.success) return res.status(400).json({ error: parsed.error.format() });`', '  Database rows: `const row = RowSchema.parse(rawDbRow);` — NEVER `as SomeType`', '  ERP/API responses: `const data = ResponseSchema.parse(response.data);`', '  Config values: validate ALL config with Zod at startup; refuse to start if invalid', '- NEVER use `as SomeType` to cast external data — always Zod-parse first', '', '### Error Handling', '- Define error classes extending `AppError` (create in `src/errors.ts` if needed)', '- Never `catch (e: any)` — always narrow error types', '- Log errors with logger.error() including stack trace and context', '- Event bus/emitter: wrap EACH handler in try/catch — one failure must NOT block others', '', '### Config-Driven (ADR-046: zero hardcoded magic numbers)', '- EVERY threshold, weight, factor, timeout MUST come from config (not hardcoded constants)', '- Config module validates ALL values with Zod at startup', '- If config invalid, service refuses to start with clear error', '', '### Deterministic Code (ADR-046)', '- No Math.random() in production code — use crypto.randomUUID() for IDs', '- Seed data generators may use seeded random; service code must be deterministic', '', '### Architecture (ADR-047: constructor injection, thin handlers)', '- Every service class receives dependencies via constructor — no module-level singletons', '- Route handlers: (1) Zod-validate request (2) call service (3) format response — NO business logic', '- Multi-step workflows → application service layer (src/services/workflow.ts or similar)', '- Periodic sync/ingestion: setInterval or cron, interval from config, log every run', '- Composition root (src/container.ts) wires everything — the ONLY place services are instantiated', '', '### ERP Integration (ADR-050: resilience, idempotency, schema as code)', '- Retry with exponential backoff: 1s → 2s → 4s, max 3 attempts, on 429/503/timeout', '- Idempotency key per write: hash(decisionId + timestamp) — prevents duplicate records on retry', '- Check-before-write: query for existing record before creating', '- Circuit breaker: open after 5 consecutive failures, half-open after 30s, log every state change', '- All operations logged with correlationId and responseTimeMs', '- ERP schema as code: define a TypeScript interface mapping domain fields → ERP fields, include as src/erp/schema.ts', '', '### Governance (ADR-048: RBAC, immutable audit, separation of duties)', '- Approval endpoints enforce roles via middleware: read X-User-Role header, reject if insufficient', '- Separation of duties: approver MUST NOT be the recommendation creator — check and reject with 403', '- Audit trail: SHA-256 hash chain — each entry hashes previous entry\'s hash, genesis entry uses \'genesis\'', '- Verification endpoint: GET /api/audit/verify — walks the chain, reports any broken links', '- Every state transition records: who (userId + role), what (from → to), when (server timestamp), why (rationale min 10 chars), correlationId', '', '## Anti-Patterns to AVOID (evaluation checks — violations REDUCE score)', '', '- Do NOT use console.log — use createLogger()', '- Do NOT use `as SomeType` to cast DB rows, API responses, or request bodies — Zod-parse instead', '- Do NOT put business logic in route handlers — extract to service layer', '- Do NOT hardcode thresholds, weights, or magic numbers — read from config', '- Do NOT use Math.random() in production code — use crypto.randomUUID()', '- Do NOT list unused deps in package.json — if listed, USE them', '- Do NOT let event handlers fail silently — wrap each in try/catch with logging', '- Do NOT initialize required fields to empty string \'\'', '', '## Observability Enforcement (ADR-051)', '', '### Logger — EVERY module:', '- Import createLogger from ../logger.js. Include correlationId in every log entry.', '- Entry: `logger.info(\'fn.start\', { correlationId, params })`', '- Exit: `logger.info(\'fn.complete\', { correlationId, durationMs })`', '- Error: `logger.error(\'fn.failed\', err, { correlationId, context })` — NEVER `{ error: err }`', '', '### Correlation IDs — NON-NEGOTIABLE:', '- Copy src/middleware.ts from scaffold (correlationId + requestLogger + metricsHandler + CircuitBreaker)', '- Wire: `app.use(correlationId); app.use(requestLogger); app.get(\'/metrics\', metricsHandler);`', '- Pass correlationId through all service calls, audit entries, and ERP headers', '', '### Metrics: `GET /metrics` via metricsHandler from middleware.ts', '### Circuit breaker: `new CircuitBreaker(\'erp\')` wraps all external calls', '');
+                                fs.writeFileSync(path.join(promptsDir, filename), lines.join('\n'), { mode: 0o600, encoding: 'utf-8' });
+                                completedPhases.push(`${order}. ${phase.title}`);
                             }
-                            // Implementation instructions — ADR-PIPELINE-033: include traceability requirements
-                            lines.push('## Implementation Requirements', '', '- All code must be CUSTOM to this project — implement the specific business logic described above', '- Follow the technology decisions from the ADRs referenced in the overview', '- Write production-quality code with proper error handling', '- Include unit tests (London School TDD — mock at module boundaries)', '- Export public interfaces so later build phases can import them', `- Place all files in the \`${phase.folder}/\` directory`, '', '## Traceability & Simulation Alignment (ADR-033 + ADR-049)', '', '### Domain Type Fields (REQUIRED on Decision, Recommendation, ERPTransaction):', '```', 'interface Recommendation {', '  // ... domain fields ...', '  simulationId?: string;    // Pipeline simulation that produced the analysis', '  traceId?: string;         // Correlation ID for end-to-end tracing', '  pipelineVersion?: string;  // Version of the pipeline that generated this', '}', '```', '', `${simulationId ? `### Simulation ID: \`${simulationId}\`\nUse this as the default simulationId when creating records.` : '### Simulation ID: load from .agentics/plans/manifest.json at startup.'}`, '', '### Simulation Config Integration:', '- Load .agentics/plans/manifest.json at startup (if it exists)', '- Read simulationId and traceId from it', '- Pass to all service constructors so every record carries lineage', '- Log simulationId in every analysis run: `logger.info("analysis.start", { simulationId })`', '', '### Confidence Disclosure in Demo Output:', '- The demo script MUST print an "Analysis Confidence" section', '- State the confidence level and what it means', '- If confidence < 60%: "The pilot resolves remaining uncertainty with real data"', '- If confidence >= 80%: "High confidence — proceed to pilot with standard monitoring"', '');
-                            // ADR-PIPELINE-039: Mandatory cross-cutting requirements in EVERY prompt
-                            lines.push('## Mandatory Cross-Cutting Requirements (EVERY module must implement these)', '', '### Logging', '- Create `src/logger.ts` (if it does not exist) with `createLogger(service: string)` that outputs JSON to stderr', '- Every log entry: `{ timestamp, level, service, event, correlationId?, ...data }`', '- Import and use the logger in THIS module. Log: function entry with key params, completion with duration, errors with context', '', '### Configuration', '- Create `src/config.ts` (if it does not exist) with typed `AppConfig` read from environment variables', '- NEVER hardcode: ports, URLs, thresholds, weights, API keys, timeouts', '- Import config in THIS module for any configurable value', '', '### Input Validation (ADR-046: Zod at EVERY boundary)', '- EVERY function receiving external data MUST Zod-parse it:', '  API request bodies: `const parsed = Schema.safeParse(req.body); if (!parsed.success) return res.status(400).json({ error: parsed.error.format() });`', '  Database rows: `const row = RowSchema.parse(rawDbRow);` — NEVER `as SomeType`', '  ERP/API responses: `const data = ResponseSchema.parse(response.data);`', '  Config values: validate ALL config with Zod at startup; refuse to start if invalid', '- NEVER use `as SomeType` to cast external data — always Zod-parse first', '', '### Error Handling', '- Define error classes extending `AppError` (create in `src/errors.ts` if needed)', '- Never `catch (e: any)` — always narrow error types', '- Log errors with logger.error() including stack trace and context', '- Event bus/emitter: wrap EACH handler in try/catch — one failure must NOT block others', '', '### Config-Driven (ADR-046: zero hardcoded magic numbers)', '- EVERY threshold, weight, factor, timeout MUST come from config (not hardcoded constants)', '- Config module validates ALL values with Zod at startup', '- If config invalid, service refuses to start with clear error', '', '### Deterministic Code (ADR-046)', '- No Math.random() in production code — use crypto.randomUUID() for IDs', '- Seed data generators may use seeded random; service code must be deterministic', '', '### Architecture (ADR-047: constructor injection, thin handlers)', '- Every service class receives dependencies via constructor — no module-level singletons', '- Route handlers: (1) Zod-validate request (2) call service (3) format response — NO business logic', '- Multi-step workflows → application service layer (src/services/workflow.ts or similar)', '- Periodic sync/ingestion: setInterval or cron, interval from config, log every run', '- Composition root (src/container.ts) wires everything — the ONLY place services are instantiated', '', '### ERP Integration (ADR-050: resilience, idempotency, schema as code)', '- Retry with exponential backoff: 1s → 2s → 4s, max 3 attempts, on 429/503/timeout', '- Idempotency key per write: hash(decisionId + timestamp) — prevents duplicate records on retry', '- Check-before-write: query for existing record before creating', '- Circuit breaker: open after 5 consecutive failures, half-open after 30s, log every state change', '- All operations logged with correlationId and responseTimeMs', '- ERP schema as code: define a TypeScript interface mapping domain fields → ERP fields, include as src/erp/schema.ts', '', '### Governance (ADR-048: RBAC, immutable audit, separation of duties)', '- Approval endpoints enforce roles via middleware: read X-User-Role header, reject if insufficient', '- Separation of duties: approver MUST NOT be the recommendation creator — check and reject with 403', '- Audit trail: SHA-256 hash chain — each entry hashes previous entry\'s hash, genesis entry uses \'genesis\'', '- Verification endpoint: GET /api/audit/verify — walks the chain, reports any broken links', '- Every state transition records: who (userId + role), what (from → to), when (server timestamp), why (rationale min 10 chars), correlationId', '', '## Anti-Patterns to AVOID (evaluation checks — violations REDUCE score)', '', '- Do NOT use console.log — use createLogger()', '- Do NOT use `as SomeType` to cast DB rows, API responses, or request bodies — Zod-parse instead', '- Do NOT put business logic in route handlers — extract to service layer', '- Do NOT hardcode thresholds, weights, or magic numbers — read from config', '- Do NOT use Math.random() in production code — use crypto.randomUUID()', '- Do NOT list unused deps in package.json — if listed, USE them', '- Do NOT let event handlers fail silently — wrap each in try/catch with logging', '- Do NOT initialize required fields to empty string \'\'', '', '## Observability Enforcement (ADR-051)', '', '### Logger — EVERY module:', '- Import createLogger from ../logger.js. Include correlationId in every log entry.', '- Entry: `logger.info(\'fn.start\', { correlationId, params })`', '- Exit: `logger.info(\'fn.complete\', { correlationId, durationMs })`', '- Error: `logger.error(\'fn.failed\', err, { correlationId, context })` — NEVER `{ error: err }`', '', '### Correlation IDs — NON-NEGOTIABLE:', '- Copy src/middleware.ts from scaffold (correlationId + requestLogger + metricsHandler + CircuitBreaker)', '- Wire: `app.use(correlationId); app.use(requestLogger); app.get(\'/metrics\', metricsHandler);`', '- Pass correlationId through all service calls, audit entries, and ERP headers', '', '### Metrics: `GET /metrics` via metricsHandler from middleware.ts', '### Circuit breaker: `new CircuitBreaker(\'erp\')` wraps all external calls', '');
-                            fs.writeFileSync(path.join(promptsDir, filename), lines.join('\n'), { mode: 0o600, encoding: 'utf-8' });
-                            completedPhases.push(`${order}. ${phase.title}`);
+                            const planItems = derivedPhases.map((phase, i) => ({
+                                order: i + 1,
+                                file: `impl-${String(i + 1).padStart(3, '0')}-${phase.slug}.md`,
+                                title: phase.title,
+                                folder: phase.folder,
+                                adrs: phase.adrIds,
+                            }));
+                            // ADR-PIPELINE-033: Include simulation lineage in execution plan
+                            const plan = {
+                                totalSteps,
+                                prompts: planItems,
+                                lineage: {
+                                    simulationId: simulationId || undefined,
+                                    traceId: traceId || undefined,
+                                    pipelineVersion: '1.7.3',
+                                },
+                            };
+                            fs.writeFileSync(path.join(promptsDir, 'execution-plan.json'), JSON.stringify(plan, null, 2), { mode: 0o600, encoding: 'utf-8' });
+                            console.error(`  [PROMPTS] Wrote ${totalSteps} implementation prompts derived from SPARC architecture + ADRs`);
+                        }
+                        // ADR-PIPELINE-091 §5: record the execution block on manifest.json
+                        // BEFORE copyPlanningArtifacts propagates the manifest into the
+                        // project tree, so downstream readers see the engineering tier +
+                        // enrichment depth in the copied artifact.
+                        try {
+                            const execBlock = computeExecutionBlock([rufloPrimaryResults.phase3, rufloPrimaryResults.phase4, rufloPrimaryResults.phase5a], readRemoteEnrichmentSnapshot(runDir));
+                            writeExecutionBlockToManifest(runDir, execBlock);
+                            process.stderr.write(`  [ADR-091] engineering_tier=${execBlock.engineering_tier} ` +
+                                `tier_counts=ruflo-local:${execBlock.tier_counts['ruflo-local']}/template:${execBlock.tier_counts.template} ` +
+                                `enrichment_depth_pct=${execBlock.enrichment.enrichment_depth_pct ?? 'null'}\n`);
+                        }
+                        catch (err) {
+                            process.stderr.write(`  [ADR-091] execution block write failed: ${err instanceof Error ? err.message : String(err)}\n`);
                         }
-                        const planItems = derivedPhases.map((phase, i) => ({
-                            order: i + 1,
-                            file: `impl-${String(i + 1).padStart(3, '0')}-${phase.slug}.md`,
-                            title: phase.title,
-                            folder: phase.folder,
-                            adrs: phase.adrIds,
-                        }));
-                        // ADR-PIPELINE-033: Include simulation lineage in execution plan
-                        const plan = {
-                            totalSteps,
-                            prompts: planItems,
-                            lineage: {
-                                simulationId: simulationId || undefined,
-                                traceId: traceId || undefined,
-                                pipelineVersion: '1.7.3',
-                            },
-                        };
-                        fs.writeFileSync(path.join(promptsDir, 'execution-plan.json'), JSON.stringify(plan, null, 2), { mode: 0o600, encoding: 'utf-8' });
-                        console.error(`  [PROMPTS] Wrote ${totalSteps} implementation prompts derived from SPARC architecture + ADRs`);
+                        copyPlanningArtifacts(runDir, projectRoot);
+                    }
+                    catch (err) {
+                        const errMsg = err instanceof Error ? err.message : String(err);
+                        console.error(`  [PROMPTS] Implementation prompt generation failed: ${errMsg}`);
                     }
-                    copyPlanningArtifacts(runDir, projectRoot);
                 }
-                catch (err) {
-                    const errMsg = err instanceof Error ? err.message : String(err);
-                    console.error(`  [PROMPTS] Implementation prompt generation failed: ${errMsg}`);
+                else {
+                    console.error('  [PROMPTS] Skipped — no ADR directory found');
+                    console.error(`    Checked: ${path.join(runDir, 'phase4', 'adrs')} (${fs.existsSync(path.join(runDir, 'phase4', 'adrs')) ? 'exists' : 'MISSING'})`);
+                    console.error(`    Checked: ${path.join(runDir, 'phase2', 'adrs')} (${fs.existsSync(path.join(runDir, 'phase2', 'adrs')) ? 'exists' : 'MISSING'})`);
                 }
-            }
-            else {
-                console.error('  [PROMPTS] Skipped — no ADR directory found');
-                console.error(`    Checked: ${path.join(runDir, 'phase4', 'adrs')} (${fs.existsSync(path.join(runDir, 'phase4', 'adrs')) ? 'exists' : 'MISSING'})`);
-                console.error(`    Checked: ${path.join(runDir, 'phase2', 'adrs')} (${fs.existsSync(path.join(runDir, 'phase2', 'adrs')) ? 'exists' : 'MISSING'})`);
-            }
+            } // close ADR-PIPELINE-093 phase5a-prompts gate-else
         }
     }
     // ── Pre-Phase 5: Detect implementation language from prior artifacts ──
@@ -3452,6 +3941,10 @@ services when the pilot validates the approach.
                 const phase5ManifestPath = path.join(phaseDir, 'phase5-manifest.json');
                 if (!fs.existsSync(phase5ManifestPath)) {
                     await ensureAdrsExist(runDir, traceId, scenarioQuery);
+                    // ADR-094 Decision 4: when Phase 6 cannot attempt degraded mode,
+                    // emit skipped-due-to-upstream entry so Phase 6 stays visible in
+                    // chainResult.phases — the trace contract that pre-094 dropped.
+                    pushSkippedDueToUpstream(phases, { phase: 5, label: 'Build', reason: errMsg }, runDir);
                     return buildResult(traceId, runDir, phases, pipelineStart, mode);
                 }
                 console.error('  [INFO] Phase 5 manifest written — Phase 6 will attempt degraded mode.');
@@ -3543,12 +4036,104 @@ services when the pilot validates the approach.
     }
     // ADR-028: Final ADR guarantee before returning
     await ensureAdrsExist(runDir, traceId, scenarioQuery);
+    // ADR-PIPELINE-093 — Rule 5 scaffold-skip carry-over.
+    // `copyPlanningArtifacts` may have persisted a `phase5b_skipped` block
+    // into manifest.json. Re-read it so `writeGateBlockToManifest` below
+    // preserves it when it merges in blocked_phases + inputs_produced_by_gate.
+    try {
+        const phase1ManifestPath = path.join(runDir, 'manifest.json');
+        if (fs.existsSync(phase1ManifestPath)) {
+            try {
+                const mf = JSON.parse(fs.readFileSync(phase1ManifestPath, 'utf-8'));
+                const skip = mf['phase5b_skipped'];
+                if (skip && typeof skip === 'object') {
+                    const s = skip;
+                    if (typeof s['reason'] === 'string' && typeof s['detected'] === 'string' && typeof s['template'] === 'string') {
+                        gateAcc.phase5bSkipped = { reason: s['reason'], detected: s['detected'], template: s['template'] };
+                    }
+                }
+            }
+            catch { /* best-effort */ }
+        }
+    }
+    catch { /* best-effort */ }
+    // ADR-PIPELINE-093 — Flush gate block into manifest.json BEFORE the
+    // FATAL-path decision so the preserved run directory carries the
+    // blocked_phases / inputs_produced_by_gate / phase5b_skipped diagnostics.
+    try {
+        // refresh blocked list from accumulator (determineBlockedPhases mirrors
+        // what recordGateResult did; we use it as a sanity check)
+        const blockedFromAcc = determineBlockedPhases(gateAcc.blocked.map(b => ({ phaseId: b.phase, gateResult: { ok: false, missing: [], ruflo_invoked: [], stillMissing: [...b.missing] } })));
+        void blockedFromAcc; // type-guard: same shape used by determineBlockedPhases
+        writeGateBlockToManifest(runDir, gateAcc);
+        // ADR-PIPELINE-093 §Rule 3 surface (a): same payload into status.json
+        // so the CLI `status` command / MCP `agentics-status` tool expose
+        // `blocked_phases` + per-phase `inputs_produced_by_gate` arrays.
+        writeGateBlockToStatusJson(runDir, gateAcc);
+    }
+    catch { /* best-effort */ }
+    // ADR-PIPELINE-093 Rule 4 — Mandatory Phase 5a emission. The prompt-generator
+    // MUST produce a valid `execution-plan.json` with ≥1 implementations[] entry
+    // and at least one impl-NNN-*.md. If either is missing at this point — even
+    // after all gate-triggered Ruflo invocations — the pipeline exits FATAL
+    // rather than silently returning degraded output.
+    {
+        const promotedPromptsDir = path.join(projectRoot, '.agentics', 'plans', 'prompts');
+        const executionPlanPath = path.join(promotedPromptsDir, 'execution-plan.json');
+        let hasValidPlan = false;
+        try {
+            if (fs.existsSync(executionPlanPath)) {
+                const parsed = JSON.parse(fs.readFileSync(executionPlanPath, 'utf-8'));
+                const implCount = Array.isArray(parsed.implementations)
+                    ? parsed.implementations.length
+                    : Array.isArray(parsed.prompts)
+                        ? parsed.prompts.length
+                        : 0;
+                hasValidPlan = implCount >= 1;
+            }
+        }
+        catch {
+            hasValidPlan = false;
+        }
+        let implFileCount = 0;
+        try {
+            if (fs.existsSync(promotedPromptsDir)) {
+                implFileCount = fs.readdirSync(promotedPromptsDir).filter(f => /^impl-\d+-.+\.md$/.test(f)).length;
+            }
+        }
+        catch {
+            implFileCount = 0;
+        }
+        if (!hasValidPlan || implFileCount < 1) {
+            const missingList = [];
+            if (!hasValidPlan)
+                missingList.push('execution-plan.json');
+            if (implFileCount < 1)
+                missingList.push('impl-NNN-*.md');
+            // Final banner — the one place ADR-093 allows a loud exit.
+            process.stderr.write(`[PIPELINE-093] FATAL: prompt-generator blocked — upstream artifacts unrecoverable\n`);
+            process.stderr.write(`  missing: ${missingList.join(', ')}\n`);
+            process.stderr.write(`  attempted: Ruflo invocation for phase 4 (failed or timed out)\n`);
+            process.stderr.write(`  run directory preserved: ${runDir}\n`);
+            // Best-effort shutdown so file handles + metrics flush before exit.
+            try {
+                const totalTiming = Date.now() - pipelineStart;
+                shutdownSwarm(traceId, false, totalTiming);
+            }
+            catch { /* best-effort */ }
+            process.exit(1);
+        }
+    }
     // ── Shutdown swarm and persist metrics ──
     const totalTiming = Date.now() - pipelineStart;
-    const pipelineSuccess = phases.every(p => p.status === 'completed' || p.status === 'skipped');
+    // ADR-094 Decision 4: skipped-due-to-upstream is non-failure for success calc.
+    const pipelineSuccess = phases.every(p => p.status === 'completed' || p.status === 'skipped' || p.status === 'skipped-due-to-upstream');
     shutdownSwarm(traceId, pipelineSuccess, totalTiming);
     // ── Final Summary ──
-    const result = buildResult(traceId, runDir, phases, pipelineStart, mode, scenarioBranch, commitHash, execCtx.remoteUrl);
+    const result = buildResult(traceId, runDir, phases, pipelineStart, mode, scenarioBranch, commitHash, execCtx.remoteUrl, 
+    // ADR-PIPELINE-093 §Rule 3 (c): blocked phases threaded into the
+    // result so the final `agentics ask` banner can warn the user.
+    gateAcc.blocked.map(b => ({ phase: b.phase, missing: [...b.missing] })));
     printFinalSummary(result);
     return result;
 }
@@ -3671,7 +4256,12 @@ function printFinalSummary(result) {
     console.error('  Phase Summary:');
     console.error('  ' + '-'.repeat(60));
     for (const phase of result.phases) {
-        const icon = phase.status === 'completed' ? '[OK]' : phase.status === 'skipped' ? '[--]' : '[!!]';
+        // ADR-094 Decision 4: distinct icon for skipped-due-to-upstream so the
+        // user can see which phases were propagation-skipped vs. opted-out.
+        const icon = phase.status === 'completed' ? '[OK]'
+            : phase.status === 'skipped' ? '[--]'
+                : phase.status === 'skipped-due-to-upstream' ? '[<-]'
+                    : '[!!]';
         const timingStr = phase.timing > 0 ? `${(phase.timing / 1000).toFixed(1)}s` : 'cached';
         const agentStr = phase.agenticsAgents
             ? `  agents: ${phase.agenticsAgents.responded}/${phase.agenticsAgents.total}`
@@ -3791,6 +4381,386 @@ function persistAgenticsResults(phaseDir, results) {
         // Non-fatal — agent result persistence should never block the pipeline
     }
 }
+/**
+ * Read `manifest.agents_invoked` from the run dir and partition into
+ * successful vs errored remote enrichment agents. ADR-PIPELINE-091 §5.
+ *
+ * Treats `status === "success"` and `status === "invoked"` as available; any
+ * other status (including HTTP error codes, `"timeout"`, `"error"`) is
+ * counted as errored. Missing / unreadable manifest => empty lists.
+ */
+export function readRemoteEnrichmentSnapshot(runDir) {
+    const manifestPath = path.join(runDir, 'manifest.json');
+    if (!fs.existsSync(manifestPath)) {
+        return { available: [], errored: [], entries: [] };
+    }
+    let entries = [];
+    try {
+        const raw = fs.readFileSync(manifestPath, 'utf-8');
+        const manifest = JSON.parse(raw);
+        entries = Array.isArray(manifest.agents_invoked) ? manifest.agents_invoked : [];
+    }
+    catch {
+        return { available: [], errored: [], entries: [] };
+    }
+    const available = [];
+    const errored = [];
+    for (const entry of entries) {
+        if (!entry || typeof entry.agent !== 'string')
+            continue;
+        const isOk = entry.status === 'success' || entry.status === 'invoked';
+        (isOk ? available : errored).push(entry.agent);
+    }
+    return { available, errored, entries };
+}
+/**
+ * Resolve a per-phase execution tier from a Ruflo primary-executor result.
+ * A phase is tagged `"ruflo-local"` iff Ruflo actually succeeded. Anything
+ * else (unavailable, timeout, swarm error, missing result) => `"template"`.
+ */
+function phaseTierFromRufloResult(result) {
+    if (!result)
+        return 'template';
+    if (result.executionTier === 'ruflo-local' && result.success)
+        return 'ruflo-local';
+    return 'template';
+}
+/**
+ * Build the `execution` block that ADR-PIPELINE-091 §5 writes back into
+ * `runDir/manifest.json`. Pure function so it can be unit-tested without
+ * spinning up the actual pipeline.
+ */
+export function computeExecutionBlock(rufloResults, enrichment) {
+    const perPhaseTiers = rufloResults.map(phaseTierFromRufloResult);
+    const rufloCount = perPhaseTiers.filter(t => t === 'ruflo-local').length;
+    const templateCount = perPhaseTiers.filter(t => t === 'template').length;
+    const engineering_tier = rufloCount > 0 ? 'ruflo-local' : 'template';
+    const totalRemote = enrichment.available.length + enrichment.errored.length;
+    const enrichment_depth_pct = totalRemote === 0
+        ? null
+        : Math.round((enrichment.available.length / totalRemote) * 100);
+    return {
+        engineering_tier,
+        tier_counts: { 'ruflo-local': rufloCount, template: templateCount },
+        enrichment: {
+            remote_agents_available: [...enrichment.available],
+            remote_agents_errored: [...enrichment.errored],
+            enrichment_depth_pct,
+        },
+    };
+}
+/**
+ * Merge the ADR-091 `execution` block into `runDir/manifest.json` in-place.
+ * Reads the existing manifest, sets `execution`, writes it back with the
+ * same mode/encoding convention used elsewhere in this file. Non-fatal on
+ * I/O or JSON errors — the pipeline continues if manifest merge fails.
+ */
+export function writeExecutionBlockToManifest(runDir, block) {
+    const manifestPath = path.join(runDir, 'manifest.json');
+    try {
+        let manifest = {};
+        if (fs.existsSync(manifestPath)) {
+            try {
+                manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+            }
+            catch {
+                manifest = {};
+            }
+        }
+        manifest['execution'] = block;
+        fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), { mode: 0o600, encoding: 'utf-8' });
+    }
+    catch (err) {
+        process.stderr.write(`  [ADR-091] Failed to merge execution block into manifest.json: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
+}
+function newGateAccumulator() {
+    return {
+        blocked: [],
+        producedByGate: {
+            phase2: [],
+            'phase3-sparc': [],
+            'phase4-adrs-ddd': [],
+            'phase5a-prompts': [],
+            'phase5b-scaffold': [],
+        },
+        phase5bSkipped: null,
+    };
+}
+/**
+ * Record a gate result into the accumulator. `inputs_produced_by_gate`
+ * reflects the initially-missing paths that became present after Ruflo
+ * ran (i.e. `missing` minus `stillMissing`). A stable shape is important
+ * for downstream readers even when the gate passed on first check.
+ */
+function recordGateResult(acc, phaseId, result) {
+    if (!result.ok && result.stillMissing.length > 0) {
+        acc.blocked.push({ phase: phaseId, missing: result.stillMissing });
+    }
+    if (result.ruflo_invoked.length > 0) {
+        const stillMissingSet = new Set(result.stillMissing);
+        const produced = result.missing.filter(p => !stillMissingSet.has(p));
+        if (produced.length > 0) {
+            acc.producedByGate[phaseId] = [...acc.producedByGate[phaseId], ...produced];
+        }
+    }
+}
+/**
+ * ADR-PIPELINE-093 — merge `blocked_phases`, per-phase
+ * `phase{N}_inputs_produced_by_gate`, and `phase5b_skipped` into
+ * `runDir/manifest.json`. Read-modify-write pattern mirrors
+ * `writeExecutionBlockToManifest` / `writePlanPromotionToManifest`.
+ *
+ * `blocked_phases` is always present (empty array when no phase blocked).
+ * The per-phase `inputs_produced_by_gate` keys are always present so
+ * downstream readers can treat them as a stable schema.
+ */
+export function writeGateBlockToManifest(runDir, acc) {
+    const manifestPath = path.join(runDir, 'manifest.json');
+    try {
+        let manifest = {};
+        if (fs.existsSync(manifestPath)) {
+            try {
+                manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+            }
+            catch {
+                manifest = {};
+            }
+        }
+        manifest['blocked_phases'] = acc.blocked.map(b => ({ phase: b.phase, missing: [...b.missing] }));
+        manifest['phase2_inputs_produced_by_gate'] = [...acc.producedByGate['phase2']];
+        manifest['phase3_inputs_produced_by_gate'] = [...acc.producedByGate['phase3-sparc']];
+        manifest['phase4_inputs_produced_by_gate'] = [...acc.producedByGate['phase4-adrs-ddd']];
+        manifest['phase5a_inputs_produced_by_gate'] = [...acc.producedByGate['phase5a-prompts']];
+        if (acc.phase5bSkipped) {
+            manifest['phase5b_skipped'] = { ...acc.phase5bSkipped };
+        }
+        fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), { mode: 0o600, encoding: 'utf-8' });
+    }
+    catch (err) {
+        process.stderr.write(`  [PIPELINE-093] Failed to merge gate block into manifest.json: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
+}
+/**
+ * ADR-PIPELINE-093 §Rule 3 (surface b) — same gate-block payload, written
+ * into `runDir/status.json` so the CLI `status` command + MCP
+ * `agentics-status` tool carry `blocked_phases` and the per-phase
+ * `phase{N}_inputs_produced_by_gate` arrays alongside the ADR-088 keys.
+ *
+ * Read-modify-write pattern matches the CLI's local `updateStatus` helper
+ * (`src/cli/index.ts`:~2501). Best-effort: if `status.json` does not exist
+ * (e.g. running outside the MCP fast-return path), the file is created so
+ * the gate block is always observable regardless of entry point.
+ *
+ * Both `writeGateBlockToManifest` and this function should be called from
+ * the same accumulator snapshot so manifest.json and status.json stay in
+ * sync. The CLI-surfaced `status.json` is the source of truth for the MCP
+ * `agentics-status` tool (which shells out to `agentics status`).
+ */
+export function writeGateBlockToStatusJson(runDir, acc) {
+    const statusPath = path.join(runDir, 'status.json');
+    try {
+        let status = {};
+        if (fs.existsSync(statusPath)) {
+            try {
+                status = JSON.parse(fs.readFileSync(statusPath, 'utf-8'));
+            }
+            catch {
+                status = {};
+            }
+        }
+        status['blocked_phases'] = acc.blocked.map(b => ({ phase: b.phase, missing: [...b.missing] }));
+        status['phase2_inputs_produced_by_gate'] = [...acc.producedByGate['phase2']];
+        status['phase3_inputs_produced_by_gate'] = [...acc.producedByGate['phase3-sparc']];
+        status['phase4_inputs_produced_by_gate'] = [...acc.producedByGate['phase4-adrs-ddd']];
+        status['phase5a_inputs_produced_by_gate'] = [...acc.producedByGate['phase5a-prompts']];
+        if (acc.phase5bSkipped) {
+            status['phase5b_skipped'] = { ...acc.phase5bSkipped };
+        }
+        status['updatedAt'] = new Date().toISOString();
+        const tmp = statusPath + '.tmp';
+        fs.writeFileSync(tmp, JSON.stringify(status, null, 2), { mode: 0o600, encoding: 'utf-8' });
+        fs.renameSync(tmp, statusPath);
+    }
+    catch (err) {
+        process.stderr.write(`  [PIPELINE-093] Failed to merge gate block into status.json: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
+}
+/**
+ * ADR-PIPELINE-093 — thin wrapper around `gatePhaseInputs` that surfaces
+ * a consistent `[GATE]` log line and records the result into the
+ * pipeline-wide accumulator. Returns the raw `GateResult` so the caller
+ * can branch on `ok`.
+ */
+async function runPhaseGate(phaseId, scenarioQuery, traceId, runDir, acc) {
+    const dossier = {
+        scenarioQuery,
+        traceId,
+        runDir,
+        artifacts: {},
+    };
+    const context = {
+        outputDir: path.join(runDir, '.ruflo-cache', `gate-${phaseId}`),
+    };
+    let result;
+    try {
+        result = await gatePhaseInputs(phaseId, { runDir, dossier, context });
+    }
+    catch (err) {
+        // gatePhaseInputs never throws, but defensive fallback keeps the
+        // pipeline running if the gate's own internals crash.
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`  [GATE] ${phaseId} threw unexpectedly: ${msg}\n`);
+        result = { ok: false, missing: [], ruflo_invoked: [], stillMissing: [] };
+    }
+    recordGateResult(acc, phaseId, result);
+    if (!result.ok && result.stillMissing.length > 0) {
+        process.stderr.write(`  [GATE] phase ${phaseId} blocked — stillMissing: ${result.stillMissing.join(', ')}\n`);
+    }
+    return result;
+}
+/**
+ * Detect the target project language from Phase 1 manifest.json
+ * (`project.language`) first, then falls back to common project root
+ * marker files. Returns `'unknown'` when no signal is available — the
+ * caller decides whether to skip or proceed in that case.
+ */
+/**
+ * ADR-PIPELINE-093 §Rule 5 — single arbiter for which scaffold template set
+ * `copyPlanningArtifacts` should emit. Called ONCE per invocation so the TS
+ * block and the Python block gate on the same decision.
+ *
+ * - `typescript`            → emit TS, skip Python, no manifest record.
+ * - `python`                → skip TS, emit Python, no manifest record.
+ * - `go`|`rust`|`unknown`   → skip both, record `phase5b_skipped` with the
+ *                             detected language and `template: 'typescript'`
+ *                             (kept for Scenario-5 compatibility — the
+ *                             skip block's shape is the ADR-093 schema).
+ *
+ * The detected-language + template-name pair in `skipped` matches what the
+ * pre-093-fix gate wrote to `manifest.json`, so downstream status.json /
+ * MCP consumers don't see a shape change on the mismatch path.
+ */
+export function decideScaffoldEmission(detected) {
+    if (detected === 'typescript')
+        return { emitTs: true, emitPy: false, skipped: null };
+    if (detected === 'python')
+        return { emitTs: false, emitPy: true, skipped: null };
+    // go / rust / unknown — no matching template set, record mismatch.
+    return {
+        emitTs: false,
+        emitPy: false,
+        skipped: { reason: 'language-mismatch', detected, template: 'typescript' },
+    };
+}
+export function detectProjectLanguage(projectRoot, phase1Manifest) {
+    // 1. Explicit signal from Phase 1 manifest.
+    const projBlock = phase1Manifest?.['project'];
+    if (projBlock && typeof projBlock === 'object') {
+        const lang = projBlock['language'];
+        if (typeof lang === 'string') {
+            const normalized = lang.toLowerCase();
+            if (normalized === 'typescript' || normalized === 'javascript')
+                return 'typescript';
+            if (normalized === 'python')
+                return 'python';
+            if (normalized === 'go' || normalized === 'golang')
+                return 'go';
+            if (normalized === 'rust')
+                return 'rust';
+        }
+    }
+    // 2. Project-root marker files.
+    const fileExists = (p) => {
+        try {
+            return fs.statSync(p).isFile();
+        }
+        catch {
+            return false;
+        }
+    };
+    if (fileExists(path.join(projectRoot, 'package.json')))
+        return 'typescript';
+    if (fileExists(path.join(projectRoot, 'pyproject.toml')) ||
+        fileExists(path.join(projectRoot, 'setup.py')))
+        return 'python';
+    if (fileExists(path.join(projectRoot, 'go.mod')))
+        return 'go';
+    if (fileExists(path.join(projectRoot, 'Cargo.toml')))
+        return 'rust';
+    return 'unknown';
+}
+/**
+ * Build the `extras` payload attached to a `Phase1Dossier` for the Ruflo
+ * primary executor. Successful remote enrichment agents are surfaced so
+ * Ruflo can weave their output into task descriptions. ADR-091 §2.
+ *
+ * When no remote enrichment exists for this run, `remote_enrichment` is
+ * still present but its arrays are empty — Ruflo task builders tolerate
+ * either shape.
+ */
+function buildRufloDossierExtras(runDir, enrichment) {
+    const successfulEntries = enrichment.entries.filter(e => e.status === 'success' || e.status === 'invoked');
+    const erroredEntries = enrichment.entries.filter(e => !(e.status === 'success' || e.status === 'invoked'));
+    return {
+        remote_enrichment: {
+            runDir,
+            available: successfulEntries.map(e => ({ domain: e.domain, agent: e.agent })),
+            errored: erroredEntries.map(e => ({ domain: e.domain, agent: e.agent, status: e.status })),
+        },
+    };
+}
+/**
+ * Invoke the Ruflo primary executor for a given engineering phase. Returns
+ * the result (or a synthesized unavailable result on unexpected throw) so
+ * auto-chain can always tag the phase for the ADR-091 execution block.
+ *
+ * This is a thin wrapper around `runPrimaryPhaseExecution` that:
+ *  1. Ensures the dossier carries `scenarioQuery`, `traceId`, `runDir`,
+ *     plus Phase 1 artifacts + remote enrichment extras.
+ *  2. Surfaces a `[ADR-091]` log line so operators can see which phases
+ *     actually executed via the local swarm.
+ *  3. Never throws.
+ */
+async function runRufloPrimaryForPhase(phaseId, scenarioQuery, traceId, runDir, priorArtifacts, enrichment, outputDir, language) {
+    const dossier = {
+        scenarioQuery,
+        traceId,
+        runDir,
+        artifacts: priorArtifacts,
+        extras: buildRufloDossierExtras(runDir, enrichment),
+    };
+    const context = {
+        outputDir,
+        ...(language ? { language } : {}),
+    };
+    try {
+        const result = await runPrimaryPhaseExecution(phaseId, dossier, context);
+        if (result.executionTier === 'ruflo-local' && result.success) {
+            process.stderr.write(`  [ADR-091] Ruflo primary executor produced ${result.filesModified} file(s) for ${phaseId} in ${result.timing}ms\n`);
+        }
+        else if (result.executionTier === 'unavailable') {
+            process.stderr.write(`  [ADR-091] Ruflo unavailable for ${phaseId} (${result.reason ?? 'no-reason'}) — falling through to template coordinator\n`);
+        }
+        else {
+            process.stderr.write(`  [ADR-091] Ruflo primary executor did not produce output for ${phaseId} (${result.reason ?? 'no-reason'}) — falling through\n`);
+        }
+        return result;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`  [ADR-091] Ruflo primary executor threw for ${phaseId}: ${msg.slice(0, 200)}\n`);
+        return {
+            phaseId,
+            success: false,
+            executionTier: 'unavailable',
+            reason: 'swarm-error',
+            filesModified: 0,
+            timing: 0,
+            message: `Ruflo primary executor threw for ${phaseId}: ${msg.slice(0, 200)}`,
+        };
+    }
+}
 // ============================================================================
 // Stdout Display Formatter
 // ============================================================================
@@ -3812,11 +4782,30 @@ export function formatAutoChainForDisplay(result) {
     lines.push(`  Duration:       ${(result.totalTiming / 1000).toFixed(1)}s`);
     lines.push(`  Overall:        ${result.success ? 'SUCCESS' : 'FAILED'}`);
     lines.push('');
+    // ADR-PIPELINE-093 §Rule 3 surface (c) — blocked-phases warning banner.
+    // Emits only when one or more phases could not run because their
+    // prerequisites were unreachable after Ruflo retry. Zero-blocked runs
+    // render no warning section.
+    const blocked = result.blockedPhases ?? [];
+    if (blocked.length > 0) {
+        lines.push('  WARNING — BLOCKED PHASES:');
+        for (const b of blocked) {
+            const missingList = b.missing.length > 0 ? b.missing.join(', ') : '(unspecified)';
+            lines.push(`    - ${b.phase}: missing ${missingList}`);
+        }
+        lines.push('  Consider running the pipeline again, or check');
+        lines.push(`    ~/.agentics/runs/${result.traceId}/ for partial output.`);
+        lines.push('');
+    }
     // Phase-by-phase summary
     lines.push('  Phase Results:');
     lines.push('  ' + '-'.repeat(68));
     for (const phase of result.phases) {
-        const icon = phase.status === 'completed' ? '[OK]' : phase.status === 'skipped' ? '[--]' : '[!!]';
+        // ADR-094 Decision 4: same icon set as printFinalSummary.
+        const icon = phase.status === 'completed' ? '[OK]'
+            : phase.status === 'skipped' ? '[--]'
+                : phase.status === 'skipped-due-to-upstream' ? '[<-]'
+                    : '[!!]';
         const timingStr = phase.timing > 0 ? `${(phase.timing / 1000).toFixed(1)}s` : 'cached';
         lines.push(`    ${icon} Phase ${phase.phase}: ${phase.label.padEnd(30)} ${timingStr.padStart(8)}  (${phase.artifacts.length} artifacts)`);
         if (phase.error) {
@@ -3877,8 +4866,52 @@ export function formatAutoChainForDisplay(result) {
     lines.push('');
     return lines.join('\n');
 }
-function buildResult(traceId, runDir, phases, startTime, executionMode = 'development', scenarioBranch, commitHash, remoteUrl) {
-    const success = phases.every(p => p.status === 'completed' || p.status === 'skipped');
+/**
+ * ADR-094 Decision 4 — Phase 6 always emits a phase-result entry. When an
+ * upstream phase ends in `failed` or `blocked`, every downstream phase that
+ * has not already been pushed gets a `skipped-due-to-upstream` entry. This
+ * preserves the `chainResult.phases[]` trace contract: every run produces
+ * an entry per phase, regardless of where the chain ended.
+ *
+ * Mutates `phases` in place. Idempotent — phases already present on the list
+ * are not re-pushed. Exported for unit tests; production callers go through
+ * the early-return sites in `executeAutoChain`.
+ */
+export function pushSkippedDueToUpstream(phases, upstream, runDir) {
+    // Phase labels mirror the dispatch sites. Output dirs follow the existing
+    // <runDir>/phaseN convention from auto-chain. Keep the table in this one
+    // place so future phases land here too.
+    const REMAINING = [
+        { phase: 2, label: 'Deep Research', dir: 'phase2' },
+        { phase: 3, label: 'SPARC + London TDD', dir: 'phase3' },
+        { phase: 4, label: 'ADRs + DDDs', dir: 'phase4' },
+        { phase: 5, label: 'Build', dir: 'phase5' },
+        { phase: 6, label: 'ERP Surface Push', dir: 'phase6' },
+    ];
+    const reasonExcerpt = upstream.reason.length > 200
+        ? upstream.reason.slice(0, 200) + '…'
+        : upstream.reason;
+    for (const r of REMAINING) {
+        if (r.phase <= upstream.phase)
+            continue;
+        if (phases.some((ph) => ph.phase === r.phase))
+            continue;
+        phases.push({
+            phase: r.phase,
+            label: r.label,
+            status: 'skipped-due-to-upstream',
+            timing: 0,
+            artifacts: [],
+            outputDir: path.join(runDir, r.dir),
+            error: `Upstream phase ${upstream.phase} (${upstream.label}) failed: ${reasonExcerpt}`,
+        });
+    }
+}
+function buildResult(traceId, runDir, phases, startTime, executionMode = 'development', scenarioBranch, commitHash, remoteUrl, blockedPhases) {
+    // ADR-094 Decision 4: `skipped-due-to-upstream` is treated like `skipped`
+    // for the success check — it is not a failure of THIS phase, just a
+    // propagation marker. `failed` remains the only status that flips success.
+    const success = phases.every((p) => p.status === 'completed' || p.status === 'skipped' || p.status === 'skipped-due-to-upstream');
     // Build GitHub URL if we have a remote and a branch
     let githubUrl;
     if (remoteUrl && scenarioBranch) {
@@ -3897,6 +4930,9 @@ function buildResult(traceId, runDir, phases, startTime, executionMode = 'develo
         scenarioBranch,
         commitHash,
         githubUrl,
+        // ADR-PIPELINE-093 §Rule 3 surface (c): carry blocked phases into the
+        // result so `formatAutoChainForDisplay` can emit the banner warning.
+        blockedPhases: blockedPhases ? blockedPhases.map(b => ({ phase: b.phase, missing: [...b.missing] })) : [],
     };
 }
 //# sourceMappingURL=auto-chain.js.map