@llm-dev-ops/agentics-cli 2.7.36 → 2.7.38

package/dist/pipeline/local-fallback/phase5a-local-fallback.d.ts

@@ -1,25 +1,28 @@
 /**
- * ADR-PIPELINE-094 Decision 8 + ADR-PIPELINE-099 D1+D2 — Phase 5a fallback.
+ * ADR-PIPELINE-094 Decision 8 — Phase 5a local fallback generator.
  *
- * Produces N coherent implementation prompts (≥4 in every code path; ≥6 when
- * the fleet decomposer + planner outputs are present) plus a valid
- * `prompts/execution-plan.json`. Replaces the pre-099 single-prompt
- * `impl-001-phase1-consensus.md` dump that the user reported as
- * "thumbs up thumbs down garbage".
+ * Produces minimal implementation prompts (`prompts/impl-001-*.md`) and
+ * `prompts/execution-plan.json` from Phase-1 simulator consensus when Ruflo
+ * is unavailable. Output is sufficient to satisfy ADR-094 Decision 3's
+ * Phase 5b hard-block (`phase5a/execution-plan.json` ≥ 50 bytes).
  *
- * Precedence inside this module (mirrors ADR-099 §D1):
- *   tier-3: agent-fleet decomposition (decomposer.sub_objectives +
- *           planner.steps + clarifier.assumptions). Emits ≥6 prompts when
- *           the fleet returned ≥6 sub-objectives.
- *   tier-4: success-criterion fan-out — one prompt per
- *           `scenario.success_criteria[]` entry, with manifest brief +
- *           decision-memo + scenario inlined as guardrails. Emits ≥4
- *           prompts when at least 4 success criteria are present.
+ * The prompt-generator already has its own Phase-1 fallback path
+ * (ADR-094 D2). This module exists for the case where the gate's Ruflo
+ * invocation hits us before the prompt-generator runs — typically via
+ * `runPrimaryPhaseExecution(phase5a-prompts, ...)` on the unavailable path.
  *
- * The two earlier tiers (Ruflo writer-agent and ADR/DDD/SPARC chain) live
- * in the prompt-generator and the auto-chain phase 4.5 block; this fallback
- * only runs when both of them produced nothing.
+ * For consistency with the prompt-generator, output paths and the prompt
+ * frontmatter shape match D2's output.
  */
 import type { LocalFallbackResult } from './phase3-local-fallback.js';
-export declare function runPhase5aLocalFallback(runDir: string, queryOverride?: string): LocalFallbackResult;
+/**
+ * Run the Phase-5a fallback. Writes:
+ *   - phase5a/execution-plan.json
+ *   - prompts/impl-001-phase1-consensus.md
+ *
+ * If `phase5a/execution-plan.json` already exists (e.g. from the
+ * prompt-generator's D2 path), this is a no-op success — we never overwrite
+ * a richer execution plan with a fallback one.
+ */
+export declare function runPhase5aLocalFallback(runDir: string): LocalFallbackResult;
 //# sourceMappingURL=phase5a-local-fallback.d.ts.map

package/dist/pipeline/local-fallback/phase5a-local-fallback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"phase5a-local-fallback.d.ts","sourceRoot":"","sources":["../../../src/pipeline/local-fallback/phase5a-local-fallback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAKH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAatE,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,mBAAmB,CAwKnG"}
+{"version":3,"file":"phase5a-local-fallback.d.ts","sourceRoot":"","sources":["../../../src/pipeline/local-fallback/phase5a-local-fallback.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,mBAAmB,CAyE3E"}

package/dist/pipeline/local-fallback/phase5a-local-fallback.js

@@ -1,33 +1,35 @@
 /**
- * ADR-PIPELINE-094 Decision 8 + ADR-PIPELINE-099 D1+D2 — Phase 5a fallback.
+ * ADR-PIPELINE-094 Decision 8 — Phase 5a local fallback generator.
  *
- * Produces N coherent implementation prompts (≥4 in every code path; ≥6 when
- * the fleet decomposer + planner outputs are present) plus a valid
- * `prompts/execution-plan.json`. Replaces the pre-099 single-prompt
- * `impl-001-phase1-consensus.md` dump that the user reported as
- * "thumbs up thumbs down garbage".
+ * Produces minimal implementation prompts (`prompts/impl-001-*.md`) and
+ * `prompts/execution-plan.json` from Phase-1 simulator consensus when Ruflo
+ * is unavailable. Output is sufficient to satisfy ADR-094 Decision 3's
+ * Phase 5b hard-block (`phase5a/execution-plan.json` ≥ 50 bytes).
  *
- * Precedence inside this module (mirrors ADR-099 §D1):
- *   tier-3: agent-fleet decomposition (decomposer.sub_objectives +
- *           planner.steps + clarifier.assumptions). Emits ≥6 prompts when
- *           the fleet returned ≥6 sub-objectives.
- *   tier-4: success-criterion fan-out — one prompt per
- *           `scenario.success_criteria[]` entry, with manifest brief +
- *           decision-memo + scenario inlined as guardrails. Emits ≥4
- *           prompts when at least 4 success criteria are present.
+ * The prompt-generator already has its own Phase-1 fallback path
+ * (ADR-094 D2). This module exists for the case where the gate's Ruflo
+ * invocation hits us before the prompt-generator runs — typically via
+ * `runPrimaryPhaseExecution(phase5a-prompts, ...)` on the unavailable path.
  *
- * The two earlier tiers (Ruflo writer-agent and ADR/DDD/SPARC chain) live
- * in the prompt-generator and the auto-chain phase 4.5 block; this fallback
- * only runs when both of them produced nothing.
+ * For consistency with the prompt-generator, output paths and the prompt
+ * frontmatter shape match D2's output.
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { readPhase1Consensus, extractScenarioQuery } from './phase1-consensus-reader.js';
-import { decomposeAgentFleet, renderUnitPromptMarkdown } from '../../synthesis/agent-fleet-decomposer.js';
-export function runPhase5aLocalFallback(runDir, queryOverride) {
+/**
+ * Run the Phase-5a fallback. Writes:
+ *   - phase5a/execution-plan.json
+ *   - prompts/impl-001-phase1-consensus.md
+ *
+ * If `phase5a/execution-plan.json` already exists (e.g. from the
+ * prompt-generator's D2 path), this is a no-op success — we never overwrite
+ * a richer execution plan with a fallback one.
+ */
+export function runPhase5aLocalFallback(runDir) {
     const filesWritten = [];
     // Skip if the canonical artifacts already exist (the prompt-generator's
-    // ADR-094 D2 path may have produced them).
+    // D2 fallback path may have produced them).
     const existingPlan = path.join(runDir, 'phase5a', 'execution-plan.json');
     if (fs.existsSync(existingPlan) && fs.statSync(existingPlan).size > 50) {
         return {
@@ -45,115 +47,37 @@ export function runPhase5aLocalFallback(runDir, queryOverride) {
             message: 'Phase-5a local fallback: no Phase-1 consensus on disk',
         };
     }
-    // Caller-supplied query (the user's original `agentics ask` brief) takes
-    // precedence over scenario.json, since the prompt-generator's D2 entry
-    // point carries the canonical PipelineContext.query and Phase-1 may not
-    // have written scenario.json with a `summary` field.
-    const query = queryOverride || extractScenarioQuery(consensus) || '';
-    const promptsDir = path.join(runDir, 'prompts');
-    const phase5aDir = path.join(runDir, 'phase5a');
+    const query = extractScenarioQuery(consensus) || '';
     try {
+        // ── Implementation prompt ─────────────────────────────────────────────
+        const promptsDir = path.join(runDir, 'prompts');
         fs.mkdirSync(promptsDir, { recursive: true });
+        const promptId = 'impl-001-phase1-consensus';
+        const promptBody = buildPhase1FallbackPromptMarkdown(query, consensus.decisionMemo, consensus.scenario, consensus.executiveSummary);
+        fs.writeFileSync(path.join(promptsDir, `${promptId}.md`), promptBody, 'utf8');
+        filesWritten.push(`prompts/${promptId}.md`);
+        // ── Execution plan ────────────────────────────────────────────────────
+        const phase5aDir = path.join(runDir, 'phase5a');
         fs.mkdirSync(phase5aDir, { recursive: true });
-        const promptEntries = [];
-        // ── Tier 3: agent-fleet decomposition ────────────────────────────────
-        const decomp = decomposeAgentFleet(runDir, query);
-        if (decomp.units.length > 0) {
-            decomp.units.forEach((unit, idx) => {
-                const order = idx + 1;
-                const filename = `impl-${pad3(order)}-${unit.slug}.md`;
-                const body = renderUnitPromptMarkdown(unit, order, decomp.units.length, decomp.context, [], []);
-                fs.writeFileSync(path.join(promptsDir, filename), body, 'utf-8');
-                filesWritten.push(`prompts/${filename}`);
-                promptEntries.push({
-                    id: unit.id,
-                    title: unit.title,
-                    order,
-                    path: `prompts/${filename}`,
-                    source: unit.sourceAgent,
-                    tier: unit.tier,
-                    dependencies: unit.dependencies,
-                });
-            });
-            process.stderr.write(`  [PROMPTS] Phase-5a tier-3 (agent-fleet): wrote ${decomp.units.length} prompts ` +
-                `(decomposer=${decomp.provenance.decomposerCount}, planner=${decomp.provenance.plannerCount}, ` +
-                `assumptions=${decomp.provenance.clarifierAssumptionsCount})\n`);
-        }
-        // ── Tier 4: success-criterion fan-out ────────────────────────────────
-        // If tier-3 didn't reach the ≥6 floor, supplement with one prompt per
-        // success-criterion. Even when tier-3 produced ≥6 we DON'T add tier-4
-        // — too many prompts dilutes the build plan.
-        if (promptEntries.length < 6) {
-            const successCriteria = extractSuccessCriteriaList(consensus);
-            const startingOrder = promptEntries.length + 1;
-            successCriteria.forEach((criterion, idx) => {
-                const order = startingOrder + idx;
-                const slug = slugify(`validate-${criterion}`) || `success-criterion-${idx + 1}`;
-                const filename = `impl-${pad3(order)}-${slug}.md`;
-                const body = renderSuccessCriterionPrompt(order, startingOrder + successCriteria.length - 1, criterion, query, consensus.executiveSummary, consensus.decisionMemo, promptEntries.map(p => p.id));
-                fs.writeFileSync(path.join(promptsDir, filename), body, 'utf-8');
-                filesWritten.push(`prompts/${filename}`);
-                promptEntries.push({
-                    id: `unit-${pad3(order)}-${slug}`,
-                    title: `Validate success criterion: ${truncate(criterion, 60)}`,
-                    order,
-                    path: `prompts/${filename}`,
-                    source: 'phase1/scenario.success_criteria',
-                    tier: 'validation',
-                    dependencies: promptEntries.length > 0 ? [promptEntries[0].id] : [],
-                });
-            });
-            if (successCriteria.length > 0) {
-                process.stderr.write(`  [PROMPTS] Phase-5a tier-4 (success-criteria): wrote ${successCriteria.length} validation prompts ` +
-                    `(total now: ${promptEntries.length})\n`);
-            }
-        }
-        // ── Last-resort safety net ───────────────────────────────────────────
-        // If even tier-3 + tier-4 produced fewer than 4 prompts, synthesize
-        // from the executive summary + decision memo + scenario.json — but
-        // split into 4 distinct prompts (foundation, integration, domain,
-        // validation), NEVER one. The pre-ADR-099 single-prompt path is gone.
-        if (promptEntries.length < 4) {
-            const synth = synthesizeMinimumFourPrompts(query, consensus);
-            synth.forEach((p, idx) => {
-                const order = promptEntries.length + idx + 1;
-                const filename = `impl-${pad3(order)}-${p.slug}.md`;
-                fs.writeFileSync(path.join(promptsDir, filename), p.body, 'utf-8');
-                filesWritten.push(`prompts/${filename}`);
-                promptEntries.push({
-                    id: `unit-${pad3(order)}-${p.slug}`,
-                    title: p.title,
-                    order,
-                    path: `prompts/${filename}`,
-                    source: 'phase1-fallback-synthesis',
-                    tier: p.tier,
-                    dependencies: p.dependsOnFirst && promptEntries.length > 0 ? [promptEntries[0].id] : [],
-                });
-            });
-            process.stderr.write(`  [PROMPTS] Phase-5a tier-5 (minimum-4 synthesis): wrote ${synth.length} prompts ` +
-                `(total now: ${promptEntries.length})\n`);
-        }
-        // ── Execution plan (legacy + canonical paths) ────────────────────────
         const executionPlan = {
-            generator: decomp.units.length > 0 ? 'agent-fleet' : 'phase1-fallback-multi',
-            quality: decomp.units.length > 0 ? 'directional' : 'degraded',
-            totalSteps: promptEntries.length,
-            estimatedDuration: `${promptEntries.length * 5}-${promptEntries.length * 15} minutes`,
-            implementations: promptEntries.map(e => ({
-                id: e.id,
-                title: e.title,
-                boundedContext: e.tier,
-                source: e.source,
-                order: e.order,
-                path: e.path,
-                dependencies: e.dependencies,
-            })),
-            provenance: decomp.provenance,
+            generator: 'local-fallback',
+            quality: 'degraded',
+            totalSteps: 1,
+            estimatedDuration: '5-15 minutes',
+            implementations: [{
+                    id: promptId,
+                    title: 'Implementation: Phase-1 consensus',
+                    boundedContext: 'phase1-consensus',
+                    source: 'phase1-consensus',
+                    order: 1,
+                    path: `prompts/${promptId}.md`,
+                }],
         };
         const planJson = JSON.stringify(executionPlan, null, 2);
-        fs.writeFileSync(path.join(phase5aDir, 'execution-plan.json'), planJson, 'utf-8');
+        fs.writeFileSync(path.join(phase5aDir, 'execution-plan.json'), planJson, 'utf8');
         filesWritten.push('phase5a/execution-plan.json');
-        fs.writeFileSync(path.join(promptsDir, 'execution-plan.json'), planJson, 'utf-8');
+        // Also mirror execution-plan into prompts/ for legacy consumers.
+        fs.writeFileSync(path.join(promptsDir, 'execution-plan.json'), planJson, 'utf8');
         filesWritten.push('prompts/execution-plan.json');
     }
     catch (err) {
@@ -167,305 +91,76 @@ export function runPhase5aLocalFallback(runDir, queryOverride) {
     return {
         success: true,
         filesWritten,
-        message: `Phase-5a local fallback: wrote ${filesWritten.length} prompt artifacts (${filesWritten.filter(f => f.startsWith('prompts/impl-')).length} build prompts)`,
+        message: `Phase-5a local fallback: wrote ${filesWritten.length} prompt artifacts (degraded)`,
     };
 }
-// ── Helpers ────────────────────────────────────────────────────────────────
-function extractSuccessCriteriaList(consensus) {
-    if (!consensus || !consensus.scenario)
-        return [];
-    const sc = consensus.scenario['success_criteria'] ?? consensus.scenario['successCriteria'];
-    const out = [];
-    if (Array.isArray(sc)) {
-        for (const item of sc) {
-            if (typeof item === 'string')
-                out.push(item);
-            else if (item && typeof item === 'object') {
-                const o = item;
-                for (const key of ['description', 'criterion', 'name', 'title']) {
-                    if (typeof o[key] === 'string') {
-                        out.push(o[key]);
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    return out;
-}
-function renderSuccessCriterionPrompt(order, total, criterion, query, execSummary, decisionMemo, priorUnitIds) {
+function buildPhase1FallbackPromptMarkdown(query, decisionMemo, scenario, execSummary) {
     const lines = [];
     lines.push('---');
-    lines.push(`id: unit-${pad3(order)}-${slugify(`validate-${criterion}`)}`);
-    lines.push(`title: ${escapeYamlString(`Validate success criterion: ${truncate(criterion, 60)}`)}`);
-    lines.push(`order: ${order}`);
-    lines.push('tier: validation');
-    lines.push('generator: phase1-fallback-multi');
+    lines.push('id: impl-001-phase1-consensus');
+    lines.push('title: Phase-1 Consensus Implementation');
+    lines.push('order: 1');
+    lines.push('degraded_mode: phase1-fallback');
+    lines.push(`source: ${[
+        decisionMemo ? 'phase1/decision-memo.md' : null,
+        scenario ? 'phase1/scenario.json' : null,
+        execSummary ? 'phase1/executive-summary.md' : null,
+    ].filter(Boolean).join(', ') || 'phase1-consensus'}`);
     lines.push('quality: degraded');
-    lines.push(`source: phase1/scenario.success_criteria`);
-    if (priorUnitIds.length > 0) {
-        lines.push('dependencies:');
-        for (const d of priorUnitIds)
-            lines.push(`  - ${d}`);
-    }
-    else {
-        lines.push('dependency_root: true');
-    }
+    lines.push('generator: local-fallback');
     lines.push('---');
     lines.push('');
-    lines.push(`# Build Step ${order} of ${total}: Validate "${truncate(criterion, 80)}"`);
-    lines.push('');
-    lines.push('## Project Brief');
-    lines.push('');
-    lines.push(query || '(no brief recorded)');
+    lines.push('# Implementation: Phase-1 Consensus');
     lines.push('');
-    lines.push('## Success Criterion This Step Verifies');
+    lines.push('> **Generated by local fallback** (ADR-PIPELINE-094 Decision 8). The full SPARC → ADR → DDD chain was unavailable for this run; this prompt was produced directly from Phase-1 simulator consensus. Quality: **degraded**.');
     lines.push('');
-    lines.push(`> ${criterion}`);
-    lines.push('');
-    if (decisionMemo) {
-        lines.push('## Decision Memo (rationale, truncated)');
+    if (query) {
+        lines.push('## Brief');
         lines.push('');
-        lines.push(truncate(decisionMemo.trim(), 800));
+        lines.push(query);
         lines.push('');
     }
-    // ADR-PIPELINE-102 — copy-paste-ready Implementation Prompt block.
-    lines.push('## Implementation Prompt');
-    lines.push('');
-    lines.push('Copy the block below into your coding agent verbatim. It is a complete validation slice that proves the criterion end-to-end.');
-    lines.push('');
-    lines.push('```');
-    lines.push(`Build a validation slice that proves the following success criterion is met:`);
-    lines.push('');
-    lines.push(`  "${criterion}"`);
-    lines.push('');
-    lines.push('Project brief (full context for the slice):');
-    lines.push('');
-    for (const ql of (query || '(no brief recorded)').split('\n')) {
-        lines.push(ql);
-    }
-    lines.push('');
-    if (priorUnitIds.length > 0) {
-        lines.push(`Depends on (already implemented): ${priorUnitIds.join(', ')}.`);
-        lines.push('Import their public API instead of redefining types.');
-        lines.push('');
-    }
-    lines.push('Implementation requirements:');
-    lines.push('1. Identify the smallest end-to-end slice that exercises the criterion. Examples: a CLI that ingests a fixture file and prints the metric the criterion measures; an HTTP endpoint that returns the criterion-relevant response; a smoke test that walks the request → analysis → decision → integration path.');
-    lines.push('2. Write the test FIRST. The test name must literally reference the criterion text. The test must fail before any production code exists, then pass after.');
-    lines.push('3. Implement only the production code needed to make the test pass. Real logic, no stubs, no TODO scaffolds.');
-    lines.push('4. Validate ALL external input at module boundaries. Reject malformed input with typed errors, not panics.');
-    lines.push('5. Export the public API needed by downstream slices. Document each export.');
-    lines.push('6. Structured logging via the project logger. Every public-API call logs entry + completion + duration with a correlation id.');
-    lines.push('7. Zero compilation errors. Zero `any`-typed domain values.');
-    lines.push('');
-    lines.push('Verification before marking this step complete:');
-    lines.push('- The criterion-named test passes.');
-    lines.push('- The full unit + integration test suite passes.');
-    lines.push('- Lint/typecheck passes.');
-    lines.push('- The criterion is observable: a human running the slice can confirm it visually OR a test asserts the observable outcome.');
-    lines.push('```');
-    lines.push('');
     if (execSummary) {
-        lines.push('## Reference: Executive Summary (context only)');
+        lines.push('## Executive Summary');
         lines.push('');
-        lines.push(truncate(execSummary.trim(), 800));
+        lines.push(execSummary.trim());
         lines.push('');
     }
-    return lines.join('\n');
-}
-function synthesizeMinimumFourPrompts(query, consensus) {
-    const lang = consensus.projectLanguage ?? 'typescript';
-    const slices = [
-        {
-            slug: 'foundation-types-and-config',
-            title: 'Foundation: Domain Types + AppConfig + Logger',
-            tier: 'foundation',
-            description: 'Build the core domain types, the typed AppConfig (env-driven, Zod-validated), the structured logger, and the typed AppError hierarchy. Every later step imports from this slice.',
-            dependsOnFirst: false,
-        },
-        {
-            slug: 'analysis-layer',
-            title: 'Domain: Analysis Layer (pure functions)',
-            tier: 'domain',
-            description: 'Implement the analysis layer as pure functions over the domain types. No I/O, no side-effects. Unit-tested against fixtures.',
-            dependsOnFirst: true,
-        },
-        {
-            slug: 'integration-and-decisions',
-            title: 'Integration: External Surface + Decision Layer',
-            tier: 'integration',
-            description: 'Wire the analysis layer to the inbound API and outbound integration (HTTP/ERP/webhook as the brief requires). Idempotency keys on writes, retry with backoff, circuit breaker.',
-            dependsOnFirst: true,
-        },
-        {
-            slug: 'smoke-and-validation',
-            title: 'Validation: End-to-end Smoke + Health Check',
-            tier: 'validation',
-            description: 'Smoke test that walks the full request → analysis → decision → integration path. Health-check endpoint. Verify the executive-summary success metrics are observable.',
-            dependsOnFirst: true,
-        },
-    ];
-    return slices.map((slice, idx) => ({
-        slug: slice.slug,
-        title: slice.title,
-        tier: slice.tier,
-        dependsOnFirst: slice.dependsOnFirst,
-        body: renderSynthesizedPromptBody(idx + 1, slices.length, slice, query, lang, consensus),
-    }));
-}
-function renderSynthesizedPromptBody(order, total, slice, query, lang, consensus) {
-    const lines = [];
-    lines.push('---');
-    lines.push(`id: unit-${pad3(order)}-${slice.slug}`);
-    lines.push(`title: ${escapeYamlString(slice.title)}`);
-    lines.push(`order: ${order}`);
-    lines.push(`tier: ${slice.tier}`);
-    lines.push('generator: phase1-fallback-multi');
-    lines.push('quality: degraded');
-    lines.push('source: phase1-fallback-synthesis');
-    if (slice.dependsOnFirst) {
-        lines.push('dependencies:');
-        lines.push('  - unit-001-foundation-types-and-config');
+    if (decisionMemo) {
+        lines.push('## Decision Memo');
+        lines.push('');
+        lines.push(decisionMemo.trim());
+        lines.push('');
     }
-    else {
-        lines.push('dependency_root: true');
+    if (scenario) {
+        lines.push('## Scenario');
+        lines.push('');
+        lines.push('```json');
+        lines.push(JSON.stringify(scenario, null, 2));
+        lines.push('```');
+        lines.push('');
     }
-    lines.push('---');
-    lines.push('');
-    lines.push(`# Build Step ${order} of ${total}: ${slice.title}`);
-    lines.push('');
-    lines.push(`**Tier:** ${slice.tier} · **Language:** ${lang}`);
-    lines.push('');
-    lines.push('## Project Brief');
-    lines.push('');
-    lines.push(query || '(no brief recorded)');
-    lines.push('');
-    lines.push('## What This Step Builds');
+    lines.push('## Implementation Directive');
     lines.push('');
-    lines.push(slice.description);
+    lines.push('Implement the system described in the Brief, using the Decision Memo and');
+    lines.push('Executive Summary above as architectural rationale. Produce a single deployable');
+    lines.push('service in the language declared by `phase1/manifest.json` (`project.language`).');
     lines.push('');
-    // ADR-PIPELINE-102 — copy-paste-ready Implementation Prompt block.
-    lines.push('## Implementation Prompt');
-    lines.push('');
-    lines.push('Copy the block below into your coding agent verbatim. It is a complete build instruction for this slice.');
+    lines.push('Layered structure:');
     lines.push('');
     lines.push('```');
-    lines.push(`Build Step ${order} of ${total}: ${slice.title}.`);
-    lines.push('');
-    lines.push(`Language: ${lang}.`);
-    lines.push('');
-    lines.push('Project brief (full context):');
-    lines.push('');
-    for (const ql of (query || '(no brief recorded)').split('\n')) {
-        lines.push(ql);
-    }
-    lines.push('');
-    lines.push(`Slice scope: ${slice.description}`);
-    lines.push('');
-    if (slice.dependsOnFirst) {
-        lines.push('Depends on (already implemented): unit-001-foundation-types-and-config.');
-        lines.push('Import its types, config object, logger, and error hierarchy. Do not redefine them.');
-        lines.push('');
-    }
-    // Slice-specific deliverables.
-    for (const item of synthesizedSliceDeliverables(slice.slug, lang)) {
-        lines.push(item);
-    }
-    lines.push('');
-    lines.push('Implementation requirements:');
-    lines.push('1. Tests first (London-school TDD). Each test must name the behavior it asserts. Mock dependencies from prior slices.');
-    lines.push('2. Real domain logic. No stubs, no TODO scaffolds, no placeholder bodies.');
-    lines.push('3. Validate ALL external input at module boundaries (Zod for TS, serde+validator for Rust, pydantic for Python).');
-    lines.push('4. Export the public API needed by downstream slices. Document each export.');
-    lines.push('5. Structured logging via the project logger — never console.log/print/println in production code.');
-    lines.push('6. Typed errors via the AppError hierarchy. Never throw generic Error / panic.');
-    lines.push('7. Zero compilation errors. Zero `any`-typed domain values.');
-    lines.push('');
-    lines.push('Verification before marking this slice complete:');
-    lines.push('- All new tests pass.');
-    lines.push('- Full test suite + lint + typecheck pass.');
-    lines.push('- Public API surface compiles in isolation (no leaking internal types).');
-    lines.push('- Run the slice end-to-end against a fixture and observe the outcome described in the slice scope.');
+    lines.push('src/');
+    lines.push('  index.ts            # entry point');
+    lines.push('  config.ts           # AppConfig + environment loading');
+    lines.push('  errors.ts           # typed AppError classes');
+    lines.push('  analysis.ts         # analysis layer (pure functions)');
+    lines.push('  decisions.ts        # decision layer (pure functions)');
+    lines.push('  integration.ts      # outbound integration (HTTP/ERP)');
+    lines.push('tests/');
+    lines.push('  analysis.test.ts');
+    lines.push('  decisions.test.ts');
     lines.push('```');
     lines.push('');
-    if (consensus.decisionMemo) {
-        lines.push('## Reference: Decision Memo (rationale, truncated)');
-        lines.push('');
-        lines.push(truncate(consensus.decisionMemo.trim(), 1000));
-        lines.push('');
-    }
     return lines.join('\n');
 }
-/**
- * Slice-specific deliverable lists for the 4-prompt synthesis safety net.
- * Each slice has a concrete to-build list so the prompt isn't "do something
- * with the foundation".
- */
-function synthesizedSliceDeliverables(slug, lang) {
-    const isTS = lang === 'typescript' || lang === 'javascript';
-    const isPy = lang === 'python';
-    const isRust = lang === 'rust';
-    switch (slug) {
-        case 'foundation-types-and-config':
-            return [
-                'Implement the following:',
-                '1. Domain type module (src/types/ or pe-core equivalent) — every typed entity from the brief: aggregates, value objects, command/query payloads. Each type has a constructor that validates its invariants and rejects malformed input.',
-                '2. AppConfig — typed config loaded from environment variables, validated at startup. Refuse to start on invalid config with a clear error.',
-                '3. Logger — structured JSON logger emitting {timestamp, level, service, event, correlationId, ...data} to stderr.',
-                '4. AppError hierarchy — base class + at least these subclasses: ValidationError, NotFoundError, IntegrationError, AuthorizationError. Each carries a stable error code.',
-                '5. Result/Either helper if the language lacks one (Rust: use std::result; TS: use a Result<T,E> discriminated union; Python: use a Result class).',
-                isTS ? '6. Zod schemas paralleling each domain type — used to parse external input.' :
-                    isPy ? '6. Pydantic models paralleling each domain type.' :
-                        isRust ? '6. serde Deserialize impls paralleling each domain type with validator-style invariant checks.' :
-                            '6. Validation schemas paralleling each domain type.',
-            ];
-        case 'analysis-layer':
-            return [
-                'Implement the analysis layer as pure functions over the foundation types:',
-                '1. Each analysis function takes typed input and returns a typed output. No I/O, no side effects, no global state.',
-                '2. Cover at least one analytical operation explicitly named in the brief (e.g. anomaly detection, scoring, ranking, summarization).',
-                '3. Decompose multi-step analysis into smaller pure functions; the public API exposes the orchestrator only.',
-                '4. Unit-tested against fixtures: at least 3 inputs (happy path, edge case, malformed-rejected). The malformed input must be rejected by the validator from the foundation, not silently absorbed.',
-            ];
-        case 'integration-and-decisions':
-            return [
-                'Wire the analysis layer into an external surface and a decision layer:',
-                '1. Inbound surface — a CLI subcommand or HTTP endpoint that takes a typed request, runs the analysis, returns a typed response.',
-                '2. Decision layer — pure function that maps analysis output to a recommendation/action. No I/O.',
-                '3. Outbound integration — wraps the external system named in the brief (HTTP, ERP, webhook). Idempotency key on every write (hash of stable inputs). Retry with exponential backoff (1s → 2s → 4s, max 3 attempts) on 429/503/timeout. Circuit breaker (open after 5 consecutive failures, half-open after 30s).',
-                '4. Correlation ID threaded from the inbound request through analysis → decision → integration. Every log line includes it.',
-                '5. End-to-end happy-path test that mocks the outbound integration and asserts the request → recommendation → write sequence.',
-            ];
-        case 'smoke-and-validation':
-            return [
-                'Implement validation + observability:',
-                '1. Smoke test — runs the slice end-to-end against a fixture, asserts the headline success metric from the brief\'s executive summary is observable.',
-                '2. Health check endpoint or CLI command — reports liveness + dependency status (config valid, integration reachable).',
-                '3. Metrics endpoint or stderr emission — counts of requests, errors, integration calls, p50/p95 latency.',
-                '4. Hypercare runbook — short markdown document at docs/runbook.md listing: how to deploy, how to roll back, how to interpret each log event, how to verify the success metric.',
-            ];
-        default:
-            return [
-                'Implement the slice scope above.',
-            ];
-    }
-}
-function pad3(n) {
-    return String(n).padStart(3, '0');
-}
-function slugify(text) {
-    return text.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, '').slice(0, 60);
-}
-function truncate(text, max) {
-    if (!text)
-        return '';
-    return text.length > max ? text.slice(0, max - 1) + '…' : text;
-}
-function escapeYamlString(s) {
-    if (/[:#&*!|>'"%@`?[\]{},]/.test(s)) {
-        return `"${s.replace(/"/g, '\\"').replace(/\\/g, '\\\\')}"`;
-    }
-    return s;
-}
 //# sourceMappingURL=phase5a-local-fallback.js.map