@llm-dev-ops/agentics-cli 1.5.33 → 1.5.35

package/dist/pipeline/auto-chain.js

@@ -663,8 +663,7 @@ The prompts must be production-grade — they will be given directly to a coding
                         ? fs.readdirSync(promptsDir).filter(f => f.startsWith('impl-'))
                         : [];
                     if (generatedPrompts.length === 0) {
-                        console.error('  [PROMPTS] Ruflo swarm did not produce prompts — writing directly from ADRs/DDDs/SPARC');
-                        // ── Read full ADR markdown files (not just JSON index) ──
+                        // ── Read all source material for prompt generation ──
                         const adrMarkdownByFile = new Map();
                         for (const f of adrFiles) {
                             try {
@@ -672,7 +671,6 @@ The prompts must be production-grade — they will be given directly to a coding
                             }
                             catch { /* skip */ }
                         }
-                        // Read ADR index for structured data
                         const adrIndexPath = path.join(adrDir, 'adr-index.json');
                         let adrs = [];
                         if (fs.existsSync(adrIndexPath)) {
@@ -685,17 +683,9 @@ The prompts must be production-grade — they will be given directly to a coding
                             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: [],
-                                });
+                                adrs.push({ id: f.replace(/\.md$/, ''), title: titleMatch?.[1] ?? f, context: content.slice(0, 500), decision: '', consequences: [], alternatives: [] });
                             }
                         }
-                        // Find the full markdown for each ADR (match by ID in filename)
                         function getAdrMarkdown(adr) {
                             for (const [filename, content] of adrMarkdownByFile) {
                                 if (filename.startsWith(adr.id))
@@ -703,311 +693,227 @@ The prompts must be production-grade — they will be given directly to a coding
                             }
                             return '';
                         }
-                        let dddContexts = [];
-                        let contextMap = [];
-                        let glossary = [];
+                        // 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 {
-                                const model = JSON.parse(fs.readFileSync(dddModelPath, 'utf-8'));
-                                dddContexts = (model.contexts ?? []).map((c) => ({
-                                    name: String(c['name'] ?? 'unknown'),
-                                    description: String(c['description'] ?? ''),
-                                    aggregates: Array.isArray(c['aggregates']) ? c['aggregates'] : [],
-                                    domainEvents: Array.isArray(c['domainEvents']) ? c['domainEvents'] : [],
-                                    commands: Array.isArray(c['commands']) ? c['commands'] : [],
-                                    queries: Array.isArray(c['queries']) ? c['queries'] : [],
-                                }));
-                                contextMap = Array.isArray(model.contextMap) ? model.contextMap : [];
-                                glossary = Array.isArray(model.ubiquitousLanguageGlossary) ? model.ubiquitousLanguageGlossary : [];
+                                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 { /* empty */ }
                         }
-                        // ── Read SPARC specification + architecture markdown ──
+                        // Read SPARC documents
                         let sparcSpec = '';
                         let sparcArch = '';
                         if (sparcDir) {
-                            for (const [file, target] of [['specification.md', 'spec'], ['architecture.md', 'arch']]) {
+                            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 (target === 'spec')
+                                        if (setter === 'spec')
                                             sparcSpec = content;
-                                        else
+                                        else if (setter === 'arch')
                                             sparcArch = content;
                                     }
                                     catch { /* skip */ }
                                 }
                             }
                         }
-                        // ── Determine build order: use DDD contexts if available, else group ADRs ──
-                        const useDDD = dddContexts.length > 0;
-                        const totalSteps = useDDD ? dddContexts.length : Math.max(adrs.length, 1);
-                        // Map ADRs to contexts by keyword matching on full text
-                        function findRelatedAdrs(contextName) {
-                            const keywords = contextName.toLowerCase().split(/[-_\s]+/).filter(k => k.length > 2);
-                            return adrs.filter(a => {
-                                const text = `${a.title} ${a.context} ${a.decision} ${(a.consequences ?? []).join(' ')}`.toLowerCase();
-                                return keywords.some(kw => text.includes(kw));
+                        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 = 'src';
+                                if (/frontend|ui|dashboard|client|react|vue/.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 });
+                            }
+                        }
+                        // If SPARC didn't produce enough sections, fall back to ADR-derived phases
+                        if (derivedPhases.length < 3) {
+                            // Group ADRs into logical clusters
+                            for (const adr of adrs) {
+                                const slug = adr.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 50);
+                                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/.test(adrLower))
+                                    folder = 'erp';
+                                else if (/integration|connector/.test(adrLower))
+                                    folder = 'integrations';
+                                else if (/deploy|infra|docker/.test(adrLower))
+                                    folder = 'src';
+                                else if (/test|quality/.test(adrLower))
+                                    folder = 'tests';
+                                derivedPhases.push({
+                                    title: adr.title,
+                                    slug,
+                                    content: getAdrMarkdown(adr) || `**Context:** ${adr.context}\n\n**Decision:** ${adr.decision}`,
+                                    folder,
+                                    adrIds: [adr.id],
+                                });
+                            }
+                        }
+                        // 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));
+                        // Insert foundation at the beginning
+                        derivedPhases.unshift({
+                            title: 'Project Foundation & Core Types',
+                            slug: 'foundation',
+                            content: 'Set up project structure, build tooling, base configuration, and core shared types. All subsequent phases import from this.',
+                            folder: 'src',
+                            adrIds: adrs.map(a => a.id), // all ADRs relevant to foundation
+                        });
+                        if (!hasTesting) {
+                            derivedPhases.push({
+                                title: 'Testing & Quality Assurance',
+                                slug: 'testing',
+                                content: 'Write comprehensive tests for all components built in prior phases.',
+                                folder: 'tests',
+                                adrIds: [],
                             });
                         }
-                        // Find upstream dependencies for a context from the context map
-                        function findUpstreams(contextName) {
-                            return contextMap
-                                .filter(r => r.downstream === contextName)
-                                .map(r => `${r.upstream} (${r.type})`);
+                        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: [],
+                            });
                         }
-                        // Build list of previously completed contexts for dependency tracking
-                        const completedContexts = [];
+                        const totalSteps = derivedPhases.length;
+                        const completedPhases = [];
                         for (let i = 0; i < totalSteps; i++) {
+                            const phase = derivedPhases[i];
                             const order = i + 1;
-                            if (useDDD) {
-                                // ── DDD-driven prompt: full bounded context details + related ADRs ──
-                                const ctx = dddContexts[i];
-                                const slug = ctx.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 50);
-                                const filename = `impl-${String(order).padStart(3, '0')}-${slug}.md`;
-                                const relatedAdrs = findRelatedAdrs(ctx.name);
-                                const upstreams = findUpstreams(ctx.name);
-                                const lines = [
-                                    `# Build Step ${order} of ${totalSteps}: ${ctx.name}`,
-                                    '',
-                                    '**The implementation must be production ready, enterprise grade, commercially viable, bug and error free, without compilation errors.**',
-                                    '',
-                                ];
-                                // Dependencies
-                                if (upstreams.length > 0) {
-                                    lines.push(`> **Dependencies:** This context depends on: ${upstreams.join(', ')}. Import from those modules.`);
-                                }
-                                else if (order > 1) {
-                                    lines.push(`> This step builds on steps 1-${order - 1}. Import from previously built modules.`);
-                                }
-                                else {
-                                    lines.push('> This is the foundation step. Build the core types and interfaces that later steps will import.');
-                                }
+                            const filename = `impl-${String(order).padStart(3, '0')}-${phase.slug}.md`;
+                            const lines = [
+                                `# Implementation Prompt ${order} of ${totalSteps}: ${phase.title}`,
+                                '',
+                                '**The implementation must be production ready, enterprise grade, commercially viable, bug and error free, without compilation errors.**',
+                                '',
+                                `**Target folder:** \`${phase.folder}/\``,
+                                '',
+                            ];
+                            if (order > 1) {
+                                lines.push(`> This step builds on steps 1-${order - 1}. Import from previously built modules.`);
+                            }
+                            else {
+                                lines.push('> This is the foundation step.');
+                            }
+                            lines.push('');
+                            if (completedPhases.length > 0) {
+                                lines.push('## Previously Completed (available for import)', '');
+                                for (const prev of completedPhases)
+                                    lines.push(`- ${prev}`);
                                 lines.push('');
-                                // Previously built contexts
-                                if (completedContexts.length > 0) {
-                                    lines.push('## Already Built (available for import)');
-                                    lines.push('');
-                                    for (const prev of completedContexts) {
-                                        lines.push(`- **${prev}** — completed`);
-                                    }
-                                    lines.push('');
-                                }
-                                // Project objective (first time only, abbreviated after)
-                                if (order === 1) {
-                                    lines.push('## Project Objective', '', scenarioQuery, '');
-                                }
-                                else {
-                                    lines.push(`## Project Objective`, '', scenarioQuery.split('\n')[0]?.slice(0, 300) ?? scenarioQuery.slice(0, 300), '', '> See impl-001 for full project context.', '');
-                                }
-                                // Full DDD bounded context specification
-                                lines.push(`## Bounded Context: ${ctx.name}`, '');
-                                lines.push(ctx.description, '');
-                                if (ctx.aggregates.length > 0) {
-                                    lines.push('### Aggregates', '');
-                                    for (const agg of ctx.aggregates) {
-                                        lines.push(`#### ${agg.name} (root: ${agg.root ?? agg.name})`);
-                                        if (agg.entities?.length)
-                                            lines.push(`- **Entities:** ${agg.entities.join(', ')}`);
-                                        if (agg.valueObjects?.length)
-                                            lines.push(`- **Value Objects:** ${agg.valueObjects.join(', ')}`);
-                                        lines.push('');
-                                    }
-                                }
-                                if (ctx.commands.length > 0) {
-                                    lines.push('### Commands', '');
-                                    for (const cmd of ctx.commands) {
-                                        if (typeof cmd === 'string') {
-                                            lines.push(`- ${cmd}`);
-                                        }
-                                        else if (cmd && typeof cmd === 'object') {
-                                            const c = cmd;
-                                            const name = c['name'] ?? c['command'] ?? 'unknown';
-                                            const desc = c['description'] ? ` — ${c['description']}` : '';
-                                            lines.push(`- **${name}**${desc}`);
-                                        }
-                                    }
-                                    lines.push('');
-                                }
-                                if (ctx.queries.length > 0) {
-                                    lines.push('### Queries', '');
-                                    for (const q of ctx.queries) {
-                                        if (typeof q === 'string') {
-                                            lines.push(`- ${q}`);
-                                        }
-                                        else if (q && typeof q === 'object') {
-                                            const qr = q;
-                                            const name = qr['name'] ?? qr['query'] ?? 'unknown';
-                                            const desc = qr['description'] ? ` — ${qr['description']}` : '';
-                                            const returns = qr['returns'] ? ` → ${qr['returns']}` : '';
-                                            lines.push(`- **${name}**${desc}${returns}`);
-                                        }
-                                    }
-                                    lines.push('');
-                                }
-                                if (ctx.domainEvents.length > 0) {
-                                    lines.push('### Domain Events', '');
-                                    for (const evt of ctx.domainEvents) {
-                                        if (typeof evt === 'string') {
-                                            lines.push(`- ${evt}`);
-                                        }
-                                        else if (evt && typeof evt === 'object') {
-                                            const e = evt;
-                                            lines.push(`- **${e['name'] ?? 'unknown'}**${e['description'] ? ` — ${e['description']}` : ''}`);
-                                        }
-                                    }
-                                    lines.push('');
-                                }
-                                // Related ADRs — include FULL markdown content, not just title/decision
-                                if (relatedAdrs.length > 0) {
-                                    lines.push(`## Architecture Decisions Governing This Context (${relatedAdrs.length} ADRs)`, '');
-                                    for (const adr of relatedAdrs) {
-                                        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('');
-                                            }
-                                            if (adr.alternatives?.length) {
-                                                lines.push('**Alternatives Considered:**');
-                                                for (const a of adr.alternatives)
-                                                    lines.push(`- ${a}`);
-                                                lines.push('');
-                                            }
-                                        }
-                                    }
-                                }
-                                else {
-                                    // No keyword match — include cross-cutting ADRs (infra, security, deployment)
-                                    const crossCuttingAdrs = adrs.filter(a => {
-                                        const text = `${a.title} ${a.decision}`.toLowerCase();
-                                        return /security|auth|deploy|infra|database|logging|error.handling|api.design/i.test(text);
-                                    });
-                                    if (crossCuttingAdrs.length > 0) {
-                                        lines.push(`## Cross-Cutting Architecture Decisions (${crossCuttingAdrs.length} ADRs)`, '');
-                                        for (const adr of crossCuttingAdrs) {
-                                            const fullMarkdown = getAdrMarkdown(adr);
-                                            if (fullMarkdown) {
-                                                lines.push(fullMarkdown, '');
-                                            }
-                                            else {
-                                                lines.push(`### ${adr.id}: ${adr.title}`, '');
-                                                if (adr.decision)
-                                                    lines.push(`**Decision:** ${adr.decision}`, '');
-                                            }
-                                        }
-                                    }
-                                }
-                                // SPARC architecture excerpt for first prompt
-                                if (order === 1 && sparcArch) {
-                                    lines.push('## SPARC Architecture Reference', '', sparcArch.slice(0, 3000), '');
-                                }
-                                // Relevant glossary terms
-                                const ctxKeywords = ctx.name.toLowerCase().split(/[-_\s]+/);
-                                const relevantTerms = glossary.filter(g => ctxKeywords.some(k => k.length > 2 && (g.term?.toLowerCase().includes(k) || g.definition?.toLowerCase().includes(k))));
-                                if (relevantTerms.length > 0) {
-                                    lines.push('## Ubiquitous Language', '');
-                                    for (const g of relevantTerms) {
-                                        lines.push(`- **${g.term}**: ${g.definition}`);
-                                    }
-                                    lines.push('');
-                                }
-                                // Implementation instructions specific to this context
-                                lines.push('## Implementation Requirements', '', `- Implement ALL commands, queries, and domain events listed above for the ${ctx.name} context`, '- Create aggregate root classes with proper invariant enforcement', `- Define port interfaces (e.g., \`${ctx.name}Port\`) for external dependencies`, '- Write adapter implementations for each port', '- Include London School TDD tests — mock at aggregate boundaries', '- Export public interfaces so downstream contexts can import them', '- Follow the technology stack and patterns specified in the ADRs above', '');
-                                fs.writeFileSync(path.join(promptsDir, filename), lines.join('\n'), { mode: 0o600, encoding: 'utf-8' });
-                                completedContexts.push(ctx.name);
+                            }
+                            // Full project requirements on first prompt, summary after
+                            if (order === 1) {
+                                lines.push('## Project Requirements', '', scenarioQuery, '');
                             }
                             else {
-                                // ── ADR-driven prompt (no DDD model): one prompt per ADR with full content ──
-                                const adr = adrs[i];
-                                const slug = adr.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 50);
-                                const filename = `impl-${String(order).padStart(3, '0')}-${slug}.md`;
-                                const fullMarkdown = getAdrMarkdown(adr);
-                                const lines = [
-                                    `# Build Step ${order} of ${totalSteps}: ${adr.title}`,
-                                    '',
-                                    '**The implementation must be production ready, enterprise grade, commercially viable, bug and error free, without compilation errors.**',
-                                    '',
-                                    order > 1
-                                        ? `> This step builds on steps 1-${order - 1}. Import from previously built modules.`
-                                        : '> This is the foundation step. Build the core types and interfaces that later steps will import.',
-                                    '',
-                                ];
-                                if (completedContexts.length > 0) {
-                                    lines.push('## Already Built (available for import)', '');
-                                    for (const prev of completedContexts)
-                                        lines.push(`- **${prev}** — completed`);
-                                    lines.push('');
-                                }
-                                if (order === 1) {
-                                    lines.push('## Project Objective', '', scenarioQuery, '');
-                                    if (sparcSpec)
-                                        lines.push('## SPARC Specification', '', sparcSpec.slice(0, 4000), '');
-                                    if (sparcArch)
-                                        lines.push('## SPARC Architecture', '', sparcArch.slice(0, 3000), '');
-                                }
-                                else {
-                                    lines.push(`## Project Objective`, '', scenarioQuery.split('\n')[0]?.slice(0, 300) ?? '', '', '> See impl-001 for full project context and SPARC specification.', '');
-                                }
-                                // Full ADR content
-                                lines.push('## Architecture Decision', '');
-                                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('');
+                                const firstParagraph = scenarioQuery.split(/\n\n/)[0] ?? scenarioQuery.slice(0, 400);
+                                lines.push('## Project Requirements (Summary)', '', firstParagraph, '', '> See impl-001 for full project requirements.', '');
+                            }
+                            // The SPARC-derived content for this phase
+                            lines.push(`## What to Build`, '', phase.content, '');
+                            // SPARC spec on first prompt, architecture on second
+                            if (order === 1 && sparcSpec) {
+                                lines.push('## SPARC Specification', '', sparcSpec, '');
+                            }
+                            if (order <= 2 && sparcArch) {
+                                lines.push('## SPARC Architecture', '', sparcArch, '');
+                            }
+                            // Relevant ADRs — full markdown
+                            const phaseAdrs = phase.adrIds.length > 0
+                                ? adrs.filter(a => phase.adrIds.includes(a.id))
+                                : (order === 1 ? adrs : []); // foundation gets all ADRs
+                            if (phaseAdrs.length > 0) {
+                                lines.push(`## Relevant Architecture Decisions (${phaseAdrs.length} ADRs)`, '');
+                                for (const adr of phaseAdrs) {
+                                    const fullMarkdown = getAdrMarkdown(adr);
+                                    if (fullMarkdown) {
+                                        lines.push(fullMarkdown, '', '---', '');
                                     }
-                                    if (adr.alternatives?.length) {
-                                        lines.push('**Alternatives Considered:**');
-                                        for (const a of adr.alternatives)
-                                            lines.push(`- ${a}`);
+                                    else {
+                                        lines.push(`### ${adr.id}: ${adr.title}`, '');
+                                        if (adr.context)
+                                            lines.push(`**Context:** ${adr.context}`, '');
+                                        if (adr.decision)
+                                            lines.push(`**Decision:** ${adr.decision}`, '');
                                         lines.push('');
                                     }
                                 }
-                                lines.push('## Implementation Requirements', '', '- Implement the decision described in the ADR above', '- Write clean, modular code following the technology stack specified', '- Include London School TDD tests — mock at boundaries', '- Export public interfaces for downstream consumers', '');
-                                fs.writeFileSync(path.join(promptsDir, filename), lines.join('\n'), { mode: 0o600, encoding: 'utf-8' });
-                                completedContexts.push(adr.title);
                             }
+                            // DDD as reference where relevant
+                            if (dddContent && order <= 3) {
+                                lines.push('## Domain Model Reference', '', '> Use as reference for domain concepts and entity relationships.', '', dddContent.slice(0, 6000), '');
+                            }
+                            lines.push('## Implementation Instructions', '', '- All code must be CUSTOM to this project — no generic boilerplate', '- Follow the technology decisions from the ADRs above', '- Write production-quality code with proper error handling', '- Include unit tests (London School TDD)', '- Export public interfaces for later build phases', `- Place files in \`${phase.folder}/\``, '');
+                            fs.writeFileSync(path.join(promptsDir, filename), lines.join('\n'), { mode: 0o600, encoding: 'utf-8' });
+                            completedPhases.push(`${order}. ${phase.title}`);
                         }
-                        // Write execution plan
-                        const planItems = useDDD
-                            ? dddContexts.map((ctx, i) => ({
-                                order: i + 1,
-                                file: `impl-${String(i + 1).padStart(3, '0')}-${ctx.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 50)}.md`,
-                                title: ctx.name,
-                                upstreams: findUpstreams(ctx.name),
-                                adrs: findRelatedAdrs(ctx.name).map(a => a.id),
-                            }))
-                            : adrs.map((adr, i) => ({
-                                order: i + 1,
-                                file: `impl-${String(i + 1).padStart(3, '0')}-${adr.title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 50)}.md`,
-                                title: adr.title,
-                                upstreams: [],
-                                adrs: [adr.id],
-                            }));
+                        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,
+                        }));
                         fs.writeFileSync(path.join(promptsDir, 'execution-plan.json'), JSON.stringify({ totalSteps, prompts: planItems }, null, 2), { mode: 0o600, encoding: 'utf-8' });
-                        console.error(`  [PROMPTS] Wrote ${totalSteps} implementation prompts from ${useDDD ? 'DDD bounded contexts' : 'ADRs'} (${adrs.length} ADRs, ${dddContexts.length} contexts, SPARC: ${sparcSpec ? 'yes' : 'no'})`);
+                        console.error(`  [PROMPTS] Wrote ${totalSteps} implementation prompts derived from SPARC architecture + ADRs`);
                     }
                     copyPlanningArtifacts(runDir);
                 }