@llm-dev-ops/agentics-cli 2.1.5 → 2.3.0

package/dist/synthesis/simulation-renderers.js

@@ -5,10 +5,17 @@
  * No I/O, no side effects, no external calls.
  *
  * FORBIDDEN:
- * - File I/O (use simulation-artifact-generator for writes)
  * - External API calls
  * - State mutation
+ *
+ * EXCEPTION (ADR-PIPELINE-066): renderFinancialAnalysis may read
+ * `<runDir>/unit-economics.json` via the loader module to prefer prototype
+ * unit economics over per-employee heuristics. The loader is the single
+ * permitted I/O path and never throws.
  */
+import { loadUnitEconomics, buildFinancialModelFromUnitEconomics, enforceManifestConsistency, } from './unit-economics-loader.js';
+import { classifyLaborIntensity, isLaborIntensive, workforceRiskTemplate, workforceRaciTemplate, workforceSensitivityRow, estimateWorkforceExposure, } from './domain-labor-classifier.js';
+import { populateConsensusSnapshot, consensusBanner, consensusOpeningParagraph, whyNotMoreConfidentSection, consensusGate, analyticalUncertaintyRisk, } from './consensus-tiers.js';
 // ============================================================================
 // Helper: safe extraction from unknown agent responses
 // ============================================================================
@@ -839,6 +846,48 @@ function estimateSupplierCount(employees) {
     // Rough: 1 active supplier per 50-100 employees for large enterprises
     return Math.max(20, Math.round(employees / 75));
 }
+/**
+ * ADR-PIPELINE-070: Parse a financial budget string like "$2.7M – $4.1M ..."
+ * and return the mid-point in USD. Returns null when no money is found.
+ */
+function parseUsdRangeMid(budget) {
+    if (!budget)
+        return null;
+    const matches = Array.from(budget.matchAll(/\$([0-9.,]+)\s*([KMB])?/gi));
+    if (matches.length === 0)
+        return null;
+    const values = [];
+    for (const m of matches) {
+        const num = parseFloat(m[1].replace(/,/g, ''));
+        if (Number.isNaN(num))
+            continue;
+        const suffix = (m[2] ?? '').toUpperCase();
+        const mult = suffix === 'M' ? 1_000_000 : suffix === 'K' ? 1_000 : suffix === 'B' ? 1_000_000_000 : 1;
+        values.push(num * mult);
+    }
+    if (values.length === 0)
+        return null;
+    if (values.length === 1)
+        return values[0];
+    return (values[0] + values[1]) / 2;
+}
+/**
+ * ADR-PIPELINE-070: Pull the primary operational unit count from a unit
+ * economics manifest's measured_scope, preferring the same scope key the
+ * sector registry uses (rooms → sqft → vehicles → ...).
+ */
+function primaryScopeCount(manifest) {
+    if (!manifest)
+        return undefined;
+    const scope = manifest.measured_scope;
+    const order = ['rooms', 'sqft', 'vehicles', 'beds', 'agents', 'units', 'properties'];
+    for (const key of order) {
+        const v = scope[key];
+        if (typeof v === 'number' && v > 0)
+            return v;
+    }
+    return undefined;
+}
 // extractFinancials is now synthesizeFinancials — kept as export for external callers
 export { synthesizeFinancials as extractFinancials };
 /**
@@ -1337,18 +1386,23 @@ export function renderExecutiveSummary(query, simulationResult, platformResults)
         recommendation = 'CONDITIONAL PROCEED';
         recDetail = `Proceed with a scoped pilot to validate core assumptions before full commitment.`;
     }
+    // ADR-PIPELINE-071: Consensus tier drives document structure.
+    // - aligned     → footnote at the bottom (existing behavior)
+    // - directional → opening paragraph acknowledgement
+    // - contested   → loud header AND opening paragraph leading with the
+    //                 contested state (the pilot exists BECAUSE of this)
+    const consensus = populateConsensusSnapshot(simulationResult, platformResults);
+    const banner = consensusBanner(consensus);
+    const opening = consensusOpeningParagraph(consensus);
     // ADR-PIPELINE-024: Pyramid Principle — lead with the answer
-    const lines = [
-        '# Executive Summary',
-        '',
-        `**Date:** ${now}`,
-        '',
-        '---',
-        '',
-        '## Recommendation',
-        '',
-        `**${recommendation}** — ${recDetail}`,
-    ];
+    const lines = ['# Executive Summary', ''];
+    if (banner) {
+        lines.push(banner, '');
+    }
+    lines.push(`**Date:** ${now}`, '', '---', '', '## Recommendation', '', `**${recommendation}** — ${recDetail}`);
+    if (opening) {
+        lines.push('', opening);
+    }
     if (fin.hasData) {
         const impactParts = [];
         if (fin.budget)
@@ -1447,6 +1501,11 @@ export function renderExecutiveSummary(query, simulationResult, platformResults)
         lines.push(`- **${r.category}** (${r.likelihood} likelihood, ${r.impact} impact): ${r.risk}`);
     }
     lines.push('');
+    // ADR-PIPELINE-062: Competitive Analysis — never empty (LLM or fallback)
+    // Implements ADR-PIPELINE-057 §3. The fallback builder guarantees the
+    // section is present even when the LLM doesn't return competitive_analysis.
+    const competitiveAnalysis = getOrBuildCompetitiveAnalysis(query, simData, extracted);
+    lines.push(...renderCompetitiveSection(competitiveAnalysis));
     // Recommended Next Steps — time-bound
     lines.push('## Recommended Next Steps', '');
     const steps = buildDomainNextSteps(recommendation, extracted);
@@ -1454,19 +1513,31 @@ export function renderExecutiveSummary(query, simulationResult, platformResults)
         lines.push(step);
     }
     lines.push('');
-    // ADR-PIPELINE-041: Consensus signal disclosure
-    const consensusAgent = platformResults.find(r => r.domain === 'analytics-hub' && r.agent === 'consensus');
-    if (consensusAgent) {
-        const consensusData = extractSignalPayload(consensusAgent.response).data ?? {};
-        const achieved = consensusData['consensusAchieved'] ?? consensusData['consensus_achieved'];
-        const confidence = Number(consensusData['confidence'] ?? consensusData['overallConfidence'] ?? 0);
-        if (achieved === false || confidence < 0.6) {
-            lines.push('## Analysis Confidence Note', '');
-            lines.push(`The multi-agent consensus process achieved **${Math.round(confidence * 100)}% confidence**. ` +
-                `This indicates divergent signals across analytical perspectives. ` +
-                `The recommendation accounts for this uncertainty by proposing a scoped pilot ` +
-                `rather than full commitment, allowing validation before broader investment.`);
-            lines.push('');
+    // ADR-PIPELINE-071: tiered consensus disclosure.
+    // - aligned     → optional legacy footnote (kept for backwards compat)
+    // - directional → "Why we are not more confident" section
+    // - contested   → "Why we are not more confident" section (mandatory)
+    if (consensus.tier === 'aligned') {
+        // Legacy footnote retained for aligned runs only.
+        const consensusAgent = platformResults.find(r => r.domain === 'analytics-hub' && r.agent === 'consensus');
+        if (consensusAgent) {
+            const consensusData = extractSignalPayload(consensusAgent.response).data ?? {};
+            const achieved = consensusData['consensusAchieved'] ?? consensusData['consensus_achieved'];
+            const confidence = Number(consensusData['confidence'] ?? consensusData['overallConfidence'] ?? 0);
+            if (achieved === false || confidence < 0.6) {
+                lines.push('## Analysis Confidence Note', '');
+                lines.push(`The multi-agent consensus process achieved **${Math.round(confidence * 100)}% confidence**. ` +
+                    `This indicates divergent signals across analytical perspectives. ` +
+                    `The recommendation accounts for this uncertainty by proposing a scoped pilot ` +
+                    `rather than full commitment, allowing validation before broader investment.`);
+                lines.push('');
+            }
+        }
+    }
+    else {
+        const whyLines = whyNotMoreConfidentSection(consensus);
+        if (whyLines.length > 0) {
+            lines.push(...whyLines);
         }
     }
     // Provenance — ADR-PIPELINE-033 + 041: simulation lineage and domain analysis
@@ -1507,20 +1578,27 @@ export function renderDecisionMemo(query, simulationResult, platformResults) {
         recommendation = 'CONDITIONAL PROCEED';
         rationale = 'Moderate confidence. A scoped pilot is recommended to validate core assumptions before committing to full deployment.';
     }
+    // ADR-PIPELINE-071: branch decision-memo structure on consensus tier.
+    // The banner/opening/why-section are computed up front and emitted at
+    // strategic points: banner before the date header, opening after the
+    // recommendation, why-section after the rationale.
+    const memoConsensus = populateConsensusSnapshot(simulationResult, platformResults);
+    const memoBanner = consensusBanner(memoConsensus);
+    const memoOpening = consensusOpeningParagraph(memoConsensus);
+    const memoWhyLines = whyNotMoreConfidentSection(memoConsensus);
     // ADR-PIPELINE-024: Structured decision package
-    const lines = [
-        '# Decision Memo',
-        '',
-        `**Date:** ${now}`,
-        `**Subject:** ${problemStatement}`,
-        `**Decision Requested:** Approval to proceed with ${successProb >= 0.7 ? 'scoped pilot' : 'feasibility investigation'}`,
-        '',
-        '---',
-        '',
-        '## Recommendation',
-        '',
-        `**${recommendation}** — ${rationale}`,
-        '',
+    const lines = ['# Decision Memo', ''];
+    if (memoBanner) {
+        lines.push(memoBanner, '');
+    }
+    lines.push(`**Date:** ${now}`, `**Subject:** ${problemStatement}`, `**Decision Requested:** Approval to proceed with ${successProb >= 0.7 ? 'scoped pilot' : 'feasibility investigation'}`, '', '---', '', '## Recommendation', '', `**${recommendation}** — ${rationale}`, '');
+    if (memoOpening) {
+        lines.push(memoOpening, '');
+    }
+    if (memoWhyLines.length > 0) {
+        lines.push(...memoWhyLines);
+    }
+    lines.push(...[
         `Success probability: ${(successProb * 100).toFixed(0)}%`,
         '',
         // Business Context
@@ -1534,7 +1612,7 @@ export function renderDecisionMemo(query, simulationResult, platformResults) {
         '## Options Considered', '',
         '| Option | Description | Investment | Timeline | Risk Level | Recommendation |',
         '|--------|-------------|-----------|----------|------------|---------------|',
-    ];
+    ]);
     // Compute pilot cost as ~30% of full deployment
     const fullBudget = fin.budget || 'TBD';
     let pilotBudget = fullBudget;
@@ -1644,6 +1722,33 @@ export function renderDecisionMemo(query, simulationResult, platformResults) {
         lines.push(`| ${row.name} | ${row.role} | ${row.impact} | ${row.action} |`);
     }
     lines.push('');
+    // ADR-PIPELINE-070: HR + Legal RACI rows when the engagement is
+    // labor-intensive. The base stakeholder table above is impact-flavoured;
+    // this section is the explicit RACI overlay top-tier consulting decks
+    // expect when changes touch operational labor.
+    const memoDomainAnalysis = extractDomainAnalysis(simData, query);
+    const memoLaborProfile = classifyLaborIntensity(memoDomainAnalysis, query);
+    if (isLaborIntensive(memoLaborProfile)) {
+        const raciRows = workforceRaciTemplate(memoLaborProfile);
+        if (raciRows.length > 0) {
+            lines.push('## Workforce RACI (ADR-PIPELINE-070)', '', `*Required because the engagement touches a ${memoLaborProfile.intensity}-labor-intensity sector (${memoLaborProfile.sector}). ${memoLaborProfile.reasoning}*`, '', '| Role | Responsibility | Cadence |', '|------|----------------|---------|');
+            for (const row of raciRows) {
+                lines.push(`| ${row.role} | ${row.responsibility} | ${row.cadence} |`);
+            }
+            lines.push('');
+            // Best-effort log so reviewers can grep when the RACI was injected
+            // synthetically vs. supplied by an upstream agent.
+            try {
+                process.stderr.write(JSON.stringify({
+                    event: 'renderer.workforce.raci.injected',
+                    sector: memoLaborProfile.sector,
+                    intensity: memoLaborProfile.intensity,
+                    rows: raciRows.length,
+                }) + '\n');
+            }
+            catch { /* logging is best-effort */ }
+        }
+    }
     // Provenance — ADR-PIPELINE-033: include simulation lineage
     const sources = platformResults.filter(r => r.status >= 200 && r.status < 300).map(r => `${r.domain}/${r.agent}`);
     lines.push('---', '');
@@ -2239,6 +2344,596 @@ export function buildScenarioArtifact(query, simulationResult, platformResults)
         })),
     };
 }
+/** Rank maturity levels for severity-sorted rendering and gap-level jumps. */
+const MATURITY_RANK = {
+    none: 0,
+    manual: 1,
+    rule_based: 2,
+    automated: 3,
+    ai_optimized: 4,
+};
+/** Human-readable labels for maturity levels. */
+function maturityLabel(level) {
+    switch (level) {
+        case 'none': return 'None';
+        case 'manual': return 'Manual';
+        case 'rule_based': return 'Rule-Based';
+        case 'automated': return 'Automated';
+        case 'ai_optimized': return 'AI-Optimized';
+    }
+}
+/**
+ * Infer a 3-peer-firm set from the scenario type. Names are real companies
+ * operating in the relevant industry as of 2024; citations in `sources`
+ * point to public sustainability/technology reports. The list is
+ * alphabetical for determinism.
+ */
+function inferPeerFirms(scenarioType) {
+    const type = scenarioType.toLowerCase();
+    if (type.includes('sustainability') || type.includes('esg') || type.includes('energy') || type.includes('utility')) {
+        return [
+            { name: 'Google', industry_position: 'Real-time carbon tracking across global data centers', public_evidence_source: 'Google 2023 Environmental Report' },
+            { name: 'Salesforce', industry_position: 'Net Zero Cloud and Workplace Command Center', public_evidence_source: 'Salesforce 2024 Stakeholder Impact Report' },
+            { name: 'Siemens', industry_position: 'Integrated GHG accounting via Desigo CC IoT platform', public_evidence_source: 'Siemens Sustainability Report 2024' },
+        ];
+    }
+    if (type.includes('supply-chain') || type.includes('logistics') || type.includes('fleet-transportation') || type.includes('vendor')) {
+        return [
+            { name: 'Amazon', industry_position: 'End-to-end supply visibility across 1,400+ fulfillment centers', public_evidence_source: 'Amazon 2024 Operations Update' },
+            { name: 'DHL', industry_position: 'AI-optimized logistics with predictive routing', public_evidence_source: 'DHL Trend Radar 2024' },
+            { name: 'Maersk', industry_position: 'Real-time container tracking and supplier integration', public_evidence_source: 'Maersk Annual Report 2023' },
+        ];
+    }
+    if (type.includes('financial-operations') || type.includes('compliance') || type.includes('governance')) {
+        return [
+            { name: 'Goldman Sachs', industry_position: 'Automated compliance monitoring and audit trails', public_evidence_source: 'Goldman Sachs Technology Report 2024' },
+            { name: 'JPMorgan Chase', industry_position: 'ML-based risk and compliance automation', public_evidence_source: 'JPMorgan Investor Day 2024' },
+            { name: 'Morgan Stanley', industry_position: 'Integrated regulatory reporting platform', public_evidence_source: 'Morgan Stanley 2023 Annual Report' },
+        ];
+    }
+    if (type.includes('hr-workforce') || type.includes('talent')) {
+        return [
+            { name: 'IBM', industry_position: 'Watson Talent skills intelligence across 280k employees', public_evidence_source: 'IBM HR Transformation Case Study 2023' },
+            { name: 'SAP SuccessFactors', industry_position: 'Integrated HR cloud with predictive attrition analytics', public_evidence_source: 'SAP Customer Experience Report 2024' },
+            { name: 'Workday', industry_position: 'Skills-based workforce planning and internal mobility', public_evidence_source: 'Workday Rising 2023 Keynote' },
+        ];
+    }
+    if (type.includes('manufacturing') || type.includes('asset-maintenance') || type.includes('pharma')) {
+        return [
+            { name: 'GE', industry_position: 'Predix predictive maintenance across industrial assets', public_evidence_source: 'GE Digital 2024 Product Report' },
+            { name: 'Rockwell Automation', industry_position: 'Connected factory with digital twin simulation', public_evidence_source: 'Rockwell Automation Fair 2023' },
+            { name: 'Siemens', industry_position: 'MindSphere industrial IoT across 100k+ connected assets', public_evidence_source: 'Siemens Digital Industries Report 2024' },
+        ];
+    }
+    if (type.includes('healthcare')) {
+        return [
+            { name: 'Epic Systems', industry_position: 'Integrated EHR platform serving 250M+ patients', public_evidence_source: 'Epic UGM 2024 Keynote' },
+            { name: 'Kaiser Permanente', industry_position: 'AI-assisted clinical decision support at scale', public_evidence_source: 'Kaiser Health Research 2023' },
+            { name: 'Mayo Clinic', industry_position: 'Unified patient data platform with ML diagnostics', public_evidence_source: 'Mayo Clinic Platform 2024' },
+        ];
+    }
+    if (type.includes('data-analytics') || type.includes('system-migration')) {
+        return [
+            { name: 'Databricks', industry_position: 'Unified lakehouse with ML workflow automation', public_evidence_source: 'Databricks Data + AI Summit 2024' },
+            { name: 'Palantir', industry_position: 'Enterprise-wide data integration and ontology', public_evidence_source: 'Palantir AIPCon 2024' },
+            { name: 'Snowflake', industry_position: 'Cross-cloud data platform with AI-ready architecture', public_evidence_source: 'Snowflake Summit 2024' },
+        ];
+    }
+    if (type.includes('security-identity')) {
+        return [
+            { name: 'CrowdStrike', industry_position: 'AI-driven endpoint threat detection and response', public_evidence_source: 'CrowdStrike 2024 Global Threat Report' },
+            { name: 'Okta', industry_position: 'Zero trust identity fabric with continuous verification', public_evidence_source: 'Okta Businesses at Work 2024' },
+            { name: 'Palo Alto Networks', industry_position: 'Precision AI across network, cloud, and SOC', public_evidence_source: 'Palo Alto Networks Ignite 2024' },
+        ];
+    }
+    if (type.includes('customer-relationship')) {
+        return [
+            { name: 'HubSpot', industry_position: 'Unified CRM with AI-driven lead scoring', public_evidence_source: 'HubSpot INBOUND 2024' },
+            { name: 'Microsoft Dynamics', industry_position: 'Copilot-integrated sales and service workflows', public_evidence_source: 'Microsoft Ignite 2024' },
+            { name: 'Salesforce', industry_position: 'Einstein GPT across sales, service, and marketing clouds', public_evidence_source: 'Salesforce Dreamforce 2024' },
+        ];
+    }
+    // Generic fallback — reputable enterprise peers
+    return [
+        { name: 'Deloitte', industry_position: 'Enterprise transformation and AI readiness assessments', public_evidence_source: 'Deloitte Tech Trends 2024' },
+        { name: 'IBM', industry_position: 'Hybrid cloud and AI-powered enterprise automation', public_evidence_source: 'IBM Think 2024 Keynote' },
+        { name: 'McKinsey', industry_position: 'QuantumBlack AI transformation engagements', public_evidence_source: 'McKinsey State of AI 2024' },
+    ];
+}
+/**
+ * Build capability maturity rows based on scenario type. Always includes
+ * 3 domain-neutral capabilities plus 1-2 domain-specific ones, for 4-5
+ * total rows per analysis.
+ */
+function buildCapabilityMaturity(scenarioType, peers) {
+    const type = scenarioType.toLowerCase();
+    // Domain-neutral capabilities — always present
+    const rows = [
+        {
+            capability: 'Data Integration',
+            current_level: 'manual',
+            peer_levels: peerLevels(peers, 'automated', 'ai_optimized', 'automated'),
+            post_pilot_level: 'automated',
+        },
+        {
+            capability: 'Predictive Analytics',
+            current_level: 'none',
+            peer_levels: peerLevels(peers, 'automated', 'ai_optimized', 'rule_based'),
+            post_pilot_level: 'ai_optimized',
+        },
+        {
+            capability: 'Decision Governance',
+            current_level: 'manual',
+            peer_levels: peerLevels(peers, 'rule_based', 'automated', 'automated'),
+            post_pilot_level: 'ai_optimized',
+        },
+    ];
+    // Domain-specific additions
+    if (type.includes('sustainability') || type.includes('esg') || type.includes('energy') || type.includes('utility')) {
+        rows.push({
+            capability: 'ESG Reporting (Scope 2)',
+            current_level: 'manual',
+            peer_levels: peerLevels(peers, 'automated', 'ai_optimized', 'automated'),
+            post_pilot_level: 'automated',
+        }, {
+            capability: 'Carbon Tracking',
+            current_level: 'manual',
+            peer_levels: peerLevels(peers, 'automated', 'ai_optimized', 'automated'),
+            post_pilot_level: 'automated',
+        });
+    }
+    else if (type.includes('supply-chain') || type.includes('logistics') || type.includes('fleet-transportation') || type.includes('vendor')) {
+        rows.push({
+            capability: 'Supplier Visibility',
+            current_level: 'rule_based',
+            peer_levels: peerLevels(peers, 'automated', 'ai_optimized', 'automated'),
+            post_pilot_level: 'automated',
+        }, {
+            capability: 'Logistics Optimization',
+            current_level: 'manual',
+            peer_levels: peerLevels(peers, 'automated', 'ai_optimized', 'automated'),
+            post_pilot_level: 'automated',
+        });
+    }
+    else if (type.includes('financial-operations') || type.includes('compliance') || type.includes('governance')) {
+        rows.push({
+            capability: 'Regulatory Reporting',
+            current_level: 'manual',
+            peer_levels: peerLevels(peers, 'automated', 'ai_optimized', 'automated'),
+            post_pilot_level: 'automated',
+        }, {
+            capability: 'Audit Automation',
+            current_level: 'manual',
+            peer_levels: peerLevels(peers, 'automated', 'ai_optimized', 'rule_based'),
+            post_pilot_level: 'automated',
+        });
+    }
+    else if (type.includes('hr-workforce') || type.includes('talent')) {
+        rows.push({
+            capability: 'Workforce Analytics',
+            current_level: 'rule_based',
+            peer_levels: peerLevels(peers, 'automated', 'automated', 'ai_optimized'),
+            post_pilot_level: 'ai_optimized',
+        }, {
+            capability: 'Skills Intelligence',
+            current_level: 'manual',
+            peer_levels: peerLevels(peers, 'ai_optimized', 'automated', 'automated'),
+            post_pilot_level: 'automated',
+        });
+    }
+    else if (type.includes('manufacturing') || type.includes('asset-maintenance') || type.includes('pharma')) {
+        rows.push({
+            capability: 'Predictive Maintenance',
+            current_level: 'rule_based',
+            peer_levels: peerLevels(peers, 'ai_optimized', 'automated', 'ai_optimized'),
+            post_pilot_level: 'ai_optimized',
+        }, {
+            capability: 'Quality Control',
+            current_level: 'manual',
+            peer_levels: peerLevels(peers, 'automated', 'automated', 'ai_optimized'),
+            post_pilot_level: 'automated',
+        });
+    }
+    else if (type.includes('healthcare')) {
+        rows.push({
+            capability: 'Clinical Decision Support',
+            current_level: 'manual',
+            peer_levels: peerLevels(peers, 'automated', 'ai_optimized', 'ai_optimized'),
+            post_pilot_level: 'automated',
+        }, {
+            capability: 'Patient Data Integration',
+            current_level: 'rule_based',
+            peer_levels: peerLevels(peers, 'ai_optimized', 'automated', 'automated'),
+            post_pilot_level: 'automated',
+        });
+    }
+    else if (type.includes('data-analytics') || type.includes('system-migration')) {
+        rows.push({
+            capability: 'Data Pipeline Automation',
+            current_level: 'manual',
+            peer_levels: peerLevels(peers, 'ai_optimized', 'automated', 'ai_optimized'),
+            post_pilot_level: 'automated',
+        }, {
+            capability: 'Self-Service BI',
+            current_level: 'rule_based',
+            peer_levels: peerLevels(peers, 'automated', 'automated', 'ai_optimized'),
+            post_pilot_level: 'ai_optimized',
+        });
+    }
+    else if (type.includes('security-identity')) {
+        rows.push({
+            capability: 'Threat Detection',
+            current_level: 'rule_based',
+            peer_levels: peerLevels(peers, 'ai_optimized', 'automated', 'ai_optimized'),
+            post_pilot_level: 'ai_optimized',
+        }, {
+            capability: 'Zero Trust Architecture',
+            current_level: 'manual',
+            peer_levels: peerLevels(peers, 'automated', 'ai_optimized', 'automated'),
+            post_pilot_level: 'automated',
+        });
+    }
+    else {
+        // Generic fallback — one additional row
+        rows.push({
+            capability: 'Enterprise Automation',
+            current_level: 'manual',
+            peer_levels: peerLevels(peers, 'automated', 'automated', 'ai_optimized'),
+            post_pilot_level: 'automated',
+        });
+    }
+    return rows;
+}
+/** Build peer_levels object from an ordered list matching the peers array. */
+function peerLevels(peers, ...levels) {
+    const result = {};
+    for (let i = 0; i < peers.length; i++) {
+        result[peers[i].name] = levels[i] ?? 'manual';
+    }
+    return result;
+}
+/** Derive gap-to-close items from the capability maturity rows. */
+function buildGapToClose(rows) {
+    return rows.map((row) => {
+        const fromRank = MATURITY_RANK[row.current_level];
+        const toRank = MATURITY_RANK[row.post_pilot_level];
+        const levelsJumped = Math.max(0, toRank - fromRank);
+        // Compare against peers to frame the outcome
+        const peerRanks = Object.values(row.peer_levels).map((l) => MATURITY_RANK[l]);
+        const topPeerRank = peerRanks.length > 0 ? Math.max(...peerRanks) : 0;
+        const medianPeerRank = peerRanks.length > 0
+            ? peerRanks.slice().sort((a, b) => a - b)[Math.floor(peerRanks.length / 2)]
+            : 0;
+        let vs;
+        if (toRank >= topPeerRank)
+            vs = 'Matches or exceeds top peer';
+        else if (toRank >= medianPeerRank)
+            vs = 'Reaches peer median';
+        else
+            vs = 'Closes gap to trailing peer';
+        return {
+            capability: row.capability,
+            from: row.current_level,
+            to: row.post_pilot_level,
+            levels_jumped: levelsJumped,
+            vs_top_peer: vs,
+        };
+    });
+}
+/** Build risks of inaction, including regulation-driven risks when applicable. */
+function buildRisksOfInaction(query, scenarioType) {
+    const regulations = detectApplicableRegulations(query);
+    const type = scenarioType.toLowerCase();
+    const risks = [];
+    // Regulation-driven risk (if applicable)
+    if (regulations.length > 0) {
+        const primary = regulations[0];
+        risks.push({
+            risk: `Regulatory non-compliance with ${primary.framework}`,
+            driver: primary.requirements,
+            timeframe: 'Immediate — current reporting cycle',
+        });
+    }
+    // Standard competitive risks
+    risks.push({
+        risk: 'Operating cost disadvantage vs. peers',
+        driver: 'Peers have realized 20-40% efficiency gains through AI-optimized workflows in this capability area',
+        timeframe: '12-18 months to parity if pilot starts now; 3+ years if deferred',
+    });
+    // Domain-triggered risks
+    if (type.includes('sustainability') || type.includes('esg') || type.includes('energy') || type.includes('utility')) {
+        risks.push({
+            risk: 'Talent and sustainability brand erosion',
+            driver: 'Hybrid workforce and investor ESG preferences penalize firms without automated climate reporting',
+            timeframe: 'Ongoing — compounds annually',
+        });
+    }
+    else if (type.includes('supply-chain') || type.includes('logistics') || type.includes('vendor')) {
+        risks.push({
+            risk: 'Supply continuity risk from single-sourced dependencies',
+            driver: 'Peers have diversified supplier networks with real-time visibility; tier-2+ disruptions are opaque without integration',
+            timeframe: '6-12 months before next tier-1 disruption event',
+        });
+    }
+    else if (type.includes('financial-operations') || type.includes('compliance')) {
+        risks.push({
+            risk: 'Audit cost escalation and manual control burden',
+            driver: 'Regulators expect automated evidence collection; manual sampling is rejected in most 2024+ audits',
+            timeframe: 'Next annual audit cycle',
+        });
+    }
+    else if (type.includes('healthcare') || type.includes('pharma')) {
+        risks.push({
+            risk: 'Patient outcome and safety gaps vs. peer benchmarks',
+            driver: 'Peer institutions use AI-assisted decision support with documented outcome improvements',
+            timeframe: 'Measurable within 12-24 months via published quality scores',
+        });
+    }
+    else {
+        risks.push({
+            risk: 'Tech-debt accumulation and integration complexity',
+            driver: 'Peer platforms have consolidated fragmented tools; each year of delay adds ~15% to eventual migration cost',
+            timeframe: 'Compounds annually',
+        });
+    }
+    return risks;
+}
+/**
+ * Build a competitive analysis deterministically from a query + extracted
+ * scenario. Used when the LLM doesn't return a `competitive_analysis`
+ * field, or for queries that don't flow through the LLM synthesis path.
+ *
+ * Guarantees (ADR-PIPELINE-062 §4):
+ *  - peer_firms are sorted alphabetically
+ *  - capability_maturity rows are sorted by worst-current-level first
+ *  - deterministic: same (query, scenario_type) produces the same result
+ *  - always non-empty: at minimum 3 peers, 4 capability rows, 2 risks
+ */
+export function buildFallbackCompetitiveAnalysis(query, extracted) {
+    const peers = inferPeerFirms(extracted.scenario_type).slice()
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const capabilityRows = buildCapabilityMaturity(extracted.scenario_type, peers).slice()
+        .sort((a, b) => MATURITY_RANK[a.current_level] - MATURITY_RANK[b.current_level]);
+    const gapToClose = buildGapToClose(capabilityRows);
+    const risks = buildRisksOfInaction(query, extracted.scenario_type);
+    const sources = [
+        ...peers.map((p) => p.public_evidence_source),
+        ...detectApplicableRegulations(query).map((r) => `${r.framework} — ${r.applicability}`),
+        'CBRE 2024 Global Workplace Insights',
+    ];
+    return {
+        peer_firms: peers,
+        capability_maturity: capabilityRows,
+        gap_to_close: gapToClose,
+        risks_of_inaction: risks,
+        sources,
+    };
+}
+/** Render the competitive analysis as markdown lines (ADR-PIPELINE-062). */
+function renderCompetitiveSection(ca) {
+    const out = ['## Competitive Position', ''];
+    // Peer firms intro
+    const peerNames = ca.peer_firms.map((p) => p.name).join(', ');
+    out.push(`**Peer firms analyzed:** ${peerNames}.`, '');
+    // Capability maturity table
+    out.push('### Capability Maturity Comparison', '');
+    out.push('Scale: None → Manual → Rule-Based → Automated → AI-Optimized', '');
+    const peerHeaders = ca.peer_firms.map((p) => p.name).join(' | ');
+    out.push(`| Capability | Current | ${peerHeaders} | Post-Pilot |`);
+    out.push(`|---|---|${ca.peer_firms.map(() => '---').join('|')}|---|`);
+    for (const row of ca.capability_maturity) {
+        const peerCells = ca.peer_firms
+            .map((p) => maturityLabel(row.peer_levels[p.name] ?? 'manual'))
+            .join(' | ');
+        out.push(`| **${row.capability}** | ${maturityLabel(row.current_level)} | ${peerCells} | ${maturityLabel(row.post_pilot_level)} |`);
+    }
+    out.push('');
+    // Gap to close
+    out.push('### Gap-to-Close Summary', '');
+    for (const gap of ca.gap_to_close) {
+        const jumpLabel = gap.levels_jumped === 0 ? '(no change)' : `+${gap.levels_jumped} level${gap.levels_jumped > 1 ? 's' : ''}`;
+        out.push(`- **${gap.capability}**: ${maturityLabel(gap.from)} → ${maturityLabel(gap.to)} ${jumpLabel}. ${gap.vs_top_peer}.`);
+    }
+    out.push('');
+    // Risks of inaction
+    out.push('### Cost of Inaction — Competitive Risks', '');
+    for (const r of ca.risks_of_inaction) {
+        out.push(`- **${r.risk}**`);
+        out.push(`  - *Driver:* ${r.driver}`);
+        out.push(`  - *Timeframe:* ${r.timeframe}`);
+    }
+    out.push('');
+    // Sources
+    if (ca.sources.length > 0) {
+        out.push(`*Sources: ${ca.sources.join('; ')}*`, '');
+    }
+    return out;
+}
+/**
+ * Extract a competitive analysis from LLM output, or fall back to the
+ * deterministic builder. Returns a valid CompetitiveAnalysis in all cases.
+ */
+function getOrBuildCompetitiveAnalysis(query, simData, extracted) {
+    // Check if the LLM returned a competitive_analysis field
+    const raw = simData['competitive_analysis'];
+    if (raw && typeof raw === 'object') {
+        const obj = raw;
+        const peers = Array.isArray(obj['peer_firms']) ? obj['peer_firms'] : [];
+        const maturity = Array.isArray(obj['capability_maturity']) ? obj['capability_maturity'] : [];
+        if (peers.length >= 3 && maturity.length >= 3) {
+            // Shape looks valid — trust it but still enforce alphabetical peer sort
+            // for deterministic rendering
+            return raw;
+        }
+    }
+    // Fall back to deterministic builder
+    return buildFallbackCompetitiveAnalysis(query, extracted);
+}
+// ============================================================================
+// ADR-PIPELINE-061: Domain-Adaptive Phase Gate Criteria
+// ============================================================================
+//
+// Replaces the 3-line hardcoded phase_gates array with a structured builder
+// that emits quantified, measurable go/no-go criteria per gate with derived
+// decision authority. Thresholds come from phase-gate-thresholds.ts.
+import { PHASE_GATE_THRESHOLDS, pct } from './phase-gate-thresholds.js';
+/**
+ * Derive the decision authority for each gate from the extracted stakeholders.
+ * - Gate 1 (technical): default CTO + VP <primary dept> unless CIO/CTO explicit
+ * - Gate 2 (business): default CFO + CTO; escalates to Steering if present
+ * - Gate 3 (scale): always Steering Committee unless explicitly Board-led
+ */
+function deriveDecisionAuthority(extracted, gateIndex) {
+    const stakeholderText = extracted.stakeholders.join(' ').toLowerCase();
+    const hasCFO = /\bcfo|finance\s+lead|finance\s+director/.test(stakeholderText);
+    const hasBoard = /\bboard\b/.test(stakeholderText);
+    const hasSteering = /steering/.test(stakeholderText);
+    const hasVPOps = /vp\s*operations|vice\s*president/.test(stakeholderText);
+    const hasCTO = /\bcto\b|\bcio\b|chief\s*technology/.test(stakeholderText);
+    if (gateIndex === 0) {
+        // Gate 1: Technical Validation — CTO + VP Ops (or the highest technical authority present)
+        if (hasCTO && hasVPOps)
+            return 'CTO + VP Operations';
+        if (hasCTO)
+            return 'CTO + Engineering Lead';
+        return 'CTO + VP Operations';
+    }
+    if (gateIndex === 1) {
+        // Gate 2: Business Validation — CFO + CTO is the default
+        if (hasCFO && hasCTO)
+            return 'CFO + CTO';
+        if (hasCFO)
+            return 'CFO + CTO';
+        if (hasSteering)
+            return 'CFO + Steering Committee';
+        return 'CFO + CTO';
+    }
+    // Gate 3: Scale Readiness — escalates to Steering or Board
+    if (hasBoard)
+        return 'Board + Steering Committee';
+    if (hasSteering)
+        return 'Steering Committee';
+    return 'Steering Committee';
+}
+/**
+ * Build quantified phase gate criteria driven by the scenario context.
+ * Replaces the 3 hardcoded generic gates per ADR-PIPELINE-061.
+ *
+ * @param query - The original user query (used for regulation detection)
+ * @param extracted - Parsed scenario fields
+ * @param primarySystem - The primary target system (ERP, platform, etc.)
+ */
+export function buildPhaseGates(query, extracted, primarySystem) {
+    const t = PHASE_GATE_THRESHOLDS;
+    const regulations = detectApplicableRegulations(query);
+    const hasCompliance = regulations.length > 0;
+    // ---- Gate 1: Technical Validation ----
+    const gate1Criteria = [
+        {
+            metric: `${primarySystem} API field coverage`,
+            threshold: `>=${pct(t.erpFieldCoveragePct)} of required fields validated`,
+            data_source: `${primarySystem} integration test results`,
+        },
+        {
+            metric: 'Scoring/model accuracy vs. manual baseline',
+            threshold: `>=${pct(t.scoringAccuracyPct)} agreement on a ${extracted.domain_entities[0] ? extracted.domain_entities[0] : 'sample'} dataset`,
+            data_source: 'Side-by-side comparison with domain expert review',
+        },
+        {
+            metric: 'System uptime during pilot',
+            threshold: `>=${pct(t.systemUptimePct)} during business hours`,
+            data_source: 'Health check endpoint logs + alert history',
+        },
+        {
+            metric: 'Audit trail integrity',
+            threshold: `${pct(t.auditIntegrityPct)} hash chain verification pass`,
+            data_source: 'Automated audit verification endpoint (/api/v1/audit/verify)',
+        },
+    ];
+    if (hasCompliance) {
+        gate1Criteria.push({
+            metric: `Regulatory mapping (${regulations.map(r => r.framework).slice(0, 2).join(', ')})`,
+            threshold: 'All mandatory controls mapped to implementation artifacts',
+            data_source: 'Compliance matrix cross-referenced with ADRs and test coverage',
+        });
+    }
+    // ---- Gate 2: Business Validation ----
+    const gate2Criteria = [
+        {
+            metric: 'Realized savings vs. projected (pilot actuals)',
+            threshold: `Within +/-${pct(t.savingsVariancePct)} of simulation base case`,
+            data_source: 'Finance reconciliation of actual vs. projected savings',
+        },
+        {
+            metric: 'User adoption in pilot department',
+            threshold: `>=${pct(t.userAdoptionPct)} of target users active (weekly)`,
+            data_source: 'Usage telemetry (API request logs, decision submissions)',
+        },
+        {
+            metric: 'False positive rate on recommendations',
+            threshold: `<${pct(t.falsePositiveRatePct)} of recommendations flagged as incorrect`,
+            data_source: 'Post-decision audit by domain expert team',
+        },
+        {
+            metric: `${primarySystem} transaction success rate`,
+            threshold: `>=${pct(t.erpTransactionSuccessPct)} (excluding planned dry-run failures)`,
+            data_source: 'Circuit breaker metrics + ERP writeback response logs',
+        },
+    ];
+    // ---- Gate 3: Scale Readiness ----
+    const gate3Criteria = [
+        {
+            metric: 'Projected enterprise-wide ROI',
+            threshold: `>=${pct(t.projectedRoiMultiplier)} (with sensitivity analysis, directional confidence >=90%)`,
+            data_source: 'Updated Monte Carlo / multi-variable sensitivity with pilot actuals',
+        },
+        {
+            metric: 'Security audit findings',
+            threshold: `${t.securityCriticalFindings} critical/high findings open at gate review`,
+            data_source: 'Security scan report (SAST + DAST + dependency audit)',
+        },
+        {
+            metric: 'Change management readiness',
+            threshold: `>=${pct(t.changeManagementReadinessPct)} of target users trained and signed off`,
+            data_source: 'HR/training completion records + department sign-off',
+        },
+        {
+            metric: 'Database performance at projected scale',
+            threshold: `<${t.dbLatencyP95Ms}ms p95 query latency at projected data volume`,
+            data_source: 'Load test results against production-equivalent database',
+        },
+    ];
+    if (hasCompliance) {
+        gate3Criteria.push({
+            metric: 'Regulatory sign-off',
+            threshold: `${regulations.map(r => r.framework).slice(0, 2).join(' + ')} compliance evidence complete`,
+            data_source: 'Compliance officer review + external auditor attestation',
+        });
+    }
+    return [
+        {
+            after_phase: 'phase-1',
+            gate: 'Technical Validation',
+            criteria: gate1Criteria,
+            decision_authority: deriveDecisionAuthority(extracted, 0),
+            overall_decision: 'Proceed to Phase 2 (Prototype Build) or request remediation sprint before continuing',
+        },
+        {
+            after_phase: 'phase-2',
+            gate: 'Business Validation',
+            criteria: gate2Criteria,
+            decision_authority: deriveDecisionAuthority(extracted, 1),
+            overall_decision: 'Proceed to Phase 3 (Pilot Expansion) or extend Phase 2 for additional tuning',
+        },
+        {
+            after_phase: 'phase-3',
+            gate: 'Scale Readiness',
+            criteria: gate3Criteria,
+            decision_authority: deriveDecisionAuthority(extracted, 2),
+            overall_decision: 'Approve full enterprise deployment, phase by region, or defer with documented rationale',
+        },
+    ];
+}
 // ============================================================================
 // Roadmap Artifact Builder
 // ============================================================================
@@ -2303,6 +2998,9 @@ export function buildRoadmapArtifact(query, simulationResult, platformResults) {
             ],
         },
     ];
+    // ADR-PIPELINE-071: Week-4 consensus gate on contested runs.
+    const roadmapConsensus = populateConsensusSnapshot(simulationResult, platformResults);
+    const consensusGateInfo = consensusGate(roadmapConsensus);
     return {
         metadata: {
             title: `Roadmap: ${query}`,
@@ -2328,12 +3026,17 @@ export function buildRoadmapArtifact(query, simulationResult, platformResults) {
         cost_estimate: extractAgentData(platformResults, 'costops', 'forecast'),
         implementation_plan: extractAgentData(platformResults, 'copilot', 'planner'),
         resource_requirements: extractAgentData(platformResults, 'costops', 'budget'),
-        // ADR-PIPELINE-024: Risk gates between phases
-        phase_gates: [
-            { after_phase: 'phase-1', gate: 'Discovery Complete', criteria: `${primarySystem} API validated, requirements signed off, team resourced`, decision: 'Proceed to build or pivot' },
-            { after_phase: 'phase-2', gate: 'Prototype Validated', criteria: 'Core functionality demonstrated, integration tested, stakeholder approval', decision: 'Proceed to validation or iterate' },
-            { after_phase: 'phase-3', gate: 'Pilot Ready', criteria: 'All tests passing, security review complete, operations runbook approved', decision: 'Deploy to production or address gaps' },
-        ],
+        // ADR-PIPELINE-061: Quantified phase gate criteria with derived decision authority
+        // (Replaces the old 3-line hardcoded generic gates from ADR-PIPELINE-024.)
+        phase_gates: buildPhaseGates(query, extracted, primarySystem),
+        // ADR-PIPELINE-071: Consensus tier metadata + Week-4 gate when contested.
+        consensus: {
+            tier: roadmapConsensus.tier,
+            agreement_pct: roadmapConsensus.agreementLevelPct,
+            precision_pct: roadmapConsensus.precisionConfidencePct,
+            directional_pct: roadmapConsensus.directionalConfidencePct,
+        },
+        consensus_gate: consensusGateInfo,
     };
 }
 // ============================================================================
@@ -2377,6 +3080,48 @@ export function buildRiskAssessment(query, simulationResult, platformResults) {
             });
         }
     }
+    // ADR-PIPELINE-071: Inject the analytical-uncertainty risk on contested
+    // runs so the heat map names the dissent rather than dressing it up as
+    // tone-of-voice.
+    const riskConsensus = populateConsensusSnapshot(simulationResult, platformResults);
+    const uncertaintyRisk = analyticalUncertaintyRisk(riskConsensus);
+    if (uncertaintyRisk) {
+        const already = domainRisks.some(r => r.risk.toLowerCase().includes('analytical uncertainty'));
+        if (!already) {
+            domainRisks.push({
+                risk: uncertaintyRisk.risk,
+                category: uncertaintyRisk.category,
+                likelihood: uncertaintyRisk.likelihood,
+                impact: uncertaintyRisk.impact,
+                score: uncertaintyRisk.score,
+                mitigation: uncertaintyRisk.mitigation,
+            });
+        }
+    }
+    // ADR-PIPELINE-070: Mandatory Workforce Impact rows when the engagement
+    // is labor-intensive. Template rows are merged with agent-supplied rows;
+    // a row supplied by an agent with the same risk text wins.
+    const domainAnalysis = extractDomainAnalysis(simData, query);
+    const laborProfile = classifyLaborIntensity(domainAnalysis, query);
+    if (isLaborIntensive(laborProfile)) {
+        for (const wf of workforceRiskTemplate(laborProfile)) {
+            const already = domainRisks.some(r => r.risk.toLowerCase().includes(wf.risk.toLowerCase().slice(0, 20)));
+            if (already)
+                continue;
+            const score = (wf.likelihood === 'High' ? 3 : wf.likelihood === 'Medium' ? 2 : 1) *
+                (wf.severity === 'High' ? 3 : wf.severity === 'Medium' ? 2 : 1);
+            domainRisks.push({
+                risk: wf.risk,
+                category: 'Workforce',
+                likelihood: wf.likelihood,
+                impact: wf.severity,
+                score,
+                mitigation: `${wf.mitigation} *Template risk — refine with HR during pilot scoping*`,
+            });
+        }
+        // Re-sort so high-score workforce risks bubble to the top of the heat map.
+        domainRisks.sort((a, b) => b.score - a.score);
+    }
     const maxScore = domainRisks[0]?.score ?? 0;
     const overallRisk = maxScore >= 6 ? 'MEDIUM' : maxScore >= 3 ? 'LOW-MEDIUM' : 'LOW';
     // Security findings
@@ -2419,12 +3164,183 @@ export function buildRiskAssessment(query, simulationResult, platformResults) {
             ...sentinelAgents.map(a => `sentinel/${a.agent}`),
             ...shieldAgents.map(a => `shield/${a.agent}`),
         ].filter(Boolean),
+        workforce_impact: isLaborIntensive(laborProfile)
+            ? {
+                intensity: laborProfile.intensity,
+                sector: laborProfile.sector,
+                unionization_risk: laborProfile.unionizationRisk,
+                role_types: laborProfile.roleTypes,
+                region_multipliers: laborProfile.regionMultipliers,
+                reasoning: laborProfile.reasoning,
+            }
+            : null,
+        consensus_tier: {
+            tier: riskConsensus.tier,
+            agreement_pct: riskConsensus.agreementLevelPct,
+            precision_pct: riskConsensus.precisionConfidencePct,
+            directional_pct: riskConsensus.directionalConfidencePct,
+            dissenting_agents: riskConsensus.dissentingAgents,
+            load_bearing_assumptions: riskConsensus.loadBearingAssumptions,
+        },
     };
 }
+/**
+ * Select 5-7 sensitivity variables based on the scenario type. The first
+ * four are domain-neutral; the remainder are domain-triggered so the output
+ * is tailored to the scenario.
+ */
+function selectSensitivityVariables(scenarioType) {
+    const base = [
+        { variable: 'Input price variance', range: '±15%', impactFraction: 0.15, direction: 'bidirectional' },
+        { variable: 'Adoption rate', range: '40% → 70%', impactFraction: 0.20, direction: 'bidirectional' },
+        { variable: 'Implementation timeline', range: '±3 months', impactFraction: 0.25, direction: 'downside_only' },
+        { variable: 'Scope expansion', range: 'Pilot → Enterprise', impactFraction: 0.60, direction: 'upside_only' },
+    ];
+    // Domain-specific additions (1-3 variables depending on scenario)
+    const type = scenarioType.toLowerCase();
+    if (type.includes('sustainability') || type.includes('esg') || type.includes('energy') || type.includes('utility')) {
+        base.push({ variable: 'Data coverage', range: '70% → 95%', impactFraction: 0.20, direction: 'downside_only' }, { variable: 'Carbon price', range: '$30 → $100/t', impactFraction: 0.18, direction: 'upside_only' });
+    }
+    else if (type.includes('supply-chain') || type.includes('logistics') || type.includes('fleet-transportation') || type.includes('vendor')) {
+        base.push({ variable: 'Supplier reliability', range: '90% → 99.9%', impactFraction: 0.22, direction: 'bidirectional' }, { variable: 'Lead-time variance', range: '±2 weeks', impactFraction: 0.12, direction: 'downside_only' });
+    }
+    else if (type.includes('financial-operations') || type.includes('compliance') || type.includes('governance') || type.includes('audit')) {
+        base.push({ variable: 'Audit cost multiplier', range: '1× → 2.5×', impactFraction: 0.18, direction: 'downside_only' }, { variable: 'Regulatory scope change', range: '0 → 2 new frameworks', impactFraction: 0.15, direction: 'downside_only' });
+    }
+    else if (type.includes('hr-workforce') || type.includes('talent')) {
+        base.push({ variable: 'Attrition rate', range: '5% → 20%', impactFraction: 0.24, direction: 'downside_only' }, { variable: 'Training completion', range: '60% → 90%', impactFraction: 0.14, direction: 'upside_only' });
+    }
+    else if (type.includes('manufacturing') || type.includes('asset-maintenance') || type.includes('pharma')) {
+        base.push({ variable: 'Equipment uptime', range: '92% → 98%', impactFraction: 0.20, direction: 'bidirectional' }, { variable: 'Yield variance', range: '±5pp', impactFraction: 0.16, direction: 'bidirectional' });
+    }
+    else if (type.includes('healthcare')) {
+        base.push({ variable: 'Patient volume', range: '±15%', impactFraction: 0.18, direction: 'bidirectional' }, { variable: 'Payer mix shift', range: '±10pp', impactFraction: 0.14, direction: 'downside_only' });
+    }
+    else if (type.includes('data-analytics') || type.includes('system-migration') || type.includes('security')) {
+        base.push({ variable: 'Data migration completeness', range: '85% → 99%', impactFraction: 0.22, direction: 'upside_only' }, { variable: 'Integration complexity', range: '1× → 2×', impactFraction: 0.18, direction: 'downside_only' });
+    }
+    else {
+        // Generic fallback — ensures 5+ rows even for unknown scenario types
+        base.push({ variable: 'Market conditions', range: '±15%', impactFraction: 0.15, direction: 'bidirectional' }, { variable: 'Organizational readiness', range: '60% → 90%', impactFraction: 0.18, direction: 'downside_only' });
+    }
+    return base;
+}
+/**
+ * Build the sensitivity table from specs. Returns rows sorted by absolute
+ * impact magnitude (rank 1 = biggest driver). Deterministic for a given
+ * (baseSavings, scenarioType) pair.
+ */
+export function buildSensitivityTable(baseSavings, scenarioType, laborProfile) {
+    if (!(baseSavings > 0) || !isFinite(baseSavings))
+        return [];
+    const specs = selectSensitivityVariables(scenarioType);
+    // ADR-PIPELINE-070: When the engagement is labor-intensive, prepend a
+    // workforce variable so change-management overruns are visible in the
+    // tornado. The variable is downside-only — overruns shrink savings.
+    if (laborProfile && isLaborIntensive(laborProfile)) {
+        const wfRow = workforceSensitivityRow(laborProfile);
+        if (wfRow && !specs.some(s => s.variable === wfRow.variable)) {
+            specs.push({
+                variable: wfRow.variable,
+                range: wfRow.range,
+                impactFraction: wfRow.impactPctOfPilot,
+                direction: 'downside_only',
+            });
+        }
+    }
+    const rows = specs.map((spec) => {
+        const magnitude = Math.round(baseSavings * spec.impactFraction);
+        const signedImpact = spec.direction === 'downside_only' ? -magnitude :
+            spec.direction === 'upside_only' ? +magnitude :
+                +magnitude; // bidirectional: store positive magnitude; low/high handled below
+        // Low/high cases depend on direction.
+        let lowCaseUsd;
+        let highCaseUsd;
+        if (spec.direction === 'upside_only') {
+            lowCaseUsd = Math.round(baseSavings);
+            highCaseUsd = Math.round(baseSavings + magnitude);
+        }
+        else if (spec.direction === 'downside_only') {
+            lowCaseUsd = Math.round(baseSavings - magnitude);
+            highCaseUsd = Math.round(baseSavings);
+        }
+        else {
+            lowCaseUsd = Math.round(baseSavings - magnitude);
+            highCaseUsd = Math.round(baseSavings + magnitude);
+        }
+        return {
+            variable: spec.variable,
+            range: spec.range,
+            baselineUsd: Math.round(baseSavings),
+            lowCaseUsd,
+            highCaseUsd,
+            impactUsd: magnitude,
+            impactPercent: (signedImpact / baseSavings) * 100,
+            rank: 0, // assigned after sort
+            direction: spec.direction,
+        };
+    });
+    // Sort by absolute magnitude, assign 1-based ranks
+    rows.sort((a, b) => b.impactUsd - a.impactUsd);
+    return rows.map((row, idx) => ({ ...row, rank: idx + 1 }));
+}
+/**
+ * Render the sensitivity rows as a markdown table, ASCII tornado chart,
+ * and a dynamic key-takeaway paragraph linking the top 2 drivers to the
+ * pilot design.
+ */
+function renderSensitivitySection(rows, baselineTotalUsd) {
+    const out = [];
+    out.push('## Sensitivity Analysis', '');
+    if (rows.length === 0) {
+        out.push('*Baseline savings figure could not be parsed from the financial model — sensitivity table omitted. Provide `fin.revenue` with a recognized currency format to enable tornado ranking.*', '');
+        return out;
+    }
+    const fmtMoney = (n) => {
+        const abs = Math.abs(n);
+        if (abs >= 1_000_000)
+            return `$${(n / 1_000_000).toFixed(2)}M`;
+        if (abs >= 1_000)
+            return `$${(n / 1_000).toFixed(0)}K`;
+        return `$${Math.round(n).toLocaleString()}`;
+    };
+    out.push(`**Base case:** ${fmtMoney(baselineTotalUsd)} projected annual impact.`, '');
+    out.push(`**Variables tested:** ${rows.length}. Each row varies a single assumption while holding all others constant.`, '');
+    out.push('');
+    // Table
+    out.push('| Rank | Variable | Range | Pessimistic | Optimistic | Impact |');
+    out.push('|------|----------|-------|-------------|------------|--------|');
+    for (const row of rows) {
+        out.push(`| ${row.rank} | ${row.variable} | ${row.range} | ${fmtMoney(row.lowCaseUsd)} | ${fmtMoney(row.highCaseUsd)} | ±${fmtMoney(row.impactUsd)} |`);
+    }
+    out.push('');
+    // ASCII tornado chart (bars proportional to largest impact)
+    out.push('### Tornado Chart', '');
+    out.push('```');
+    const maxImpact = rows[0]?.impactUsd ?? 1;
+    const barWidth = 32;
+    const nameWidth = Math.max(...rows.map(r => r.variable.length));
+    for (const row of rows) {
+        const barLen = Math.max(1, Math.round((row.impactUsd / maxImpact) * barWidth));
+        const bar = '█'.repeat(barLen);
+        const name = row.variable.padEnd(nameWidth);
+        out.push(`  ${name}  ${bar} ${fmtMoney(row.impactUsd)}`);
+    }
+    out.push('```', '');
+    // Key takeaway — dynamically references top-2 drivers and lowest-impact variable
+    const top1 = rows[0];
+    const top2 = rows[1];
+    const bottom = rows[rows.length - 1];
+    const takeaway = top2
+        ? `**Key takeaway:** The business case is most sensitive to **${top1.variable}** (±${fmtMoney(top1.impactUsd)}) and **${top2.variable}** (±${fmtMoney(top2.impactUsd)}). The pilot is designed to reduce uncertainty on these two drivers specifically. **${bottom.variable}** has the smallest impact (±${fmtMoney(bottom.impactUsd)}), meaning the ROI holds even if that estimate is off by ±20%.`
+        : `**Key takeaway:** Only one variable was tested — **${top1.variable}** (±${fmtMoney(top1.impactUsd)}). Add scenario context to enable multi-variable tornado analysis.`;
+    out.push(takeaway, '');
+    return out;
+}
 // ============================================================================
 // ADR-PIPELINE-020: Financial Analysis Renderer (costops agents)
 // ============================================================================
-export function renderFinancialAnalysis(query, simulationResult, platformResults) {
+export function renderFinancialAnalysis(query, simulationResult, platformResults, runDir) {
     const now = new Date().toISOString();
     const problemStatement = distillProblemStatement(query);
     const simPayload = extractSignalPayload(simulationResult);
@@ -2438,24 +3354,58 @@ export function renderFinancialAnalysis(query, simulationResult, platformResults
     const attributionData = extractAgentData(platformResults, 'costops', 'attribution');
     const budgetData = extractAgentData(platformResults, 'costops', 'budget');
     const tradeoffData = extractAgentData(platformResults, 'costops', 'tradeoff');
-    // ADR-PIPELINE-024: Never output "pending" or "To be quantified" — always produce a model.
-    // If synthesizeFinancials() returned empty strings, force re-estimation from query context.
-    if (!fin.hasData || (!fin.budget && !fin.roi && !fin.npv)) {
-        const estimated = estimateFinancialsFromQuery(query);
-        if (!fin.budget)
-            fin.budget = estimated.budget;
-        if (!fin.roi)
-            fin.roi = estimated.roi;
-        if (!fin.npv)
-            fin.npv = estimated.npv;
-        if (!fin.payback)
-            fin.payback = estimated.payback;
-        if (!fin.revenue)
-            fin.revenue = estimated.revenue;
-        if (!fin.costSavings)
-            fin.costSavings = estimated.costSavings;
+    // ADR-PIPELINE-066: 3-tier precedence for financial figures.
+    //   Tier 1 — unit-economics.json manifest from the generated prototype
+    //   Tier 2 — structured figures from agent results (costops/platform)
+    //   Tier 3 — per-employee heuristic fallback (with visible warning banner)
+    const manifestResult = loadUnitEconomics(runDir ?? null);
+    let unitEconomicsSource = 'heuristic';
+    let manifestModel = null;
+    let manifestWarnings = [];
+    if (manifestResult.manifest) {
+        manifestModel = buildFinancialModelFromUnitEconomics(manifestResult.manifest);
+        fin.budget = manifestModel.budget;
+        fin.roi = manifestModel.roi;
+        fin.npv = manifestModel.npv;
+        fin.payback = manifestModel.payback;
+        fin.revenue = manifestModel.revenue;
+        fin.costSavings = manifestModel.costSavings;
         fin.hasData = true;
+        fin.isEstimated = false;
+        unitEconomicsSource = 'manifest';
+        const consistency = enforceManifestConsistency(manifestResult.manifest, {
+            measuredSavingsUsd: manifestResult.manifest.annual_measured_savings_usd,
+            enterpriseSavingsUsd: manifestResult.manifest.annual_extrapolated_savings_usd,
+        });
+        if (!consistency.passed)
+            manifestWarnings = consistency.violations;
+    }
+    else if (fin.hasData && !fin.isEstimated && fin.budget && fin.roi && fin.npv) {
+        // Tier 2 — structured agent/costops data already populated the model.
+        unitEconomicsSource = 'agent';
+    }
+    else {
+        // Tier 3 — heuristic fallback. synthesizeFinancials may have already
+        // filled the fields via estimateFinancialsFromQuery (isEstimated=true);
+        // in that case we leave the values alone and just flag the path.
+        if (!fin.hasData || (!fin.budget && !fin.roi && !fin.npv)) {
+            const estimated = estimateFinancialsFromQuery(query);
+            if (!fin.budget)
+                fin.budget = estimated.budget;
+            if (!fin.roi)
+                fin.roi = estimated.roi;
+            if (!fin.npv)
+                fin.npv = estimated.npv;
+            if (!fin.payback)
+                fin.payback = estimated.payback;
+            if (!fin.revenue)
+                fin.revenue = estimated.revenue;
+            if (!fin.costSavings)
+                fin.costSavings = estimated.costSavings;
+            fin.hasData = true;
+        }
         fin.isEstimated = true;
+        unitEconomicsSource = 'heuristic';
     }
     const lines = [
         '# Financial Analysis',
@@ -2463,18 +3413,40 @@ export function renderFinancialAnalysis(query, simulationResult, platformResults
         `**Date:** ${now}`,
         `**Subject:** ${problemStatement}`,
         '',
-        '---',
-        '',
-        `## Investment Summary${fin.isEstimated ? ' (Estimated from Organization Profile)' : ''}`, '',
-        '| Metric | Value |',
-        '|--------|-------|',
-        `| Total Investment | ${fin.budget} |`,
-        `| Expected ROI | ${fin.roi} |`,
-        `| 5-Year NPV | ${fin.npv} |`,
-        `| Payback Period | ${fin.payback} |`,
-        `| Revenue / Savings Impact | ${fin.revenue || fin.costSavings} |`,
-        '',
     ];
+    // ADR-PIPELINE-066 §2: Mandatory fallback warning when the heuristic is used.
+    if (unitEconomicsSource === 'heuristic') {
+        lines.push('> ⚠️ **Financial model: heuristic fallback** — no prototype `unit-economics.json` found.', '> Figures below are derived from a per-employee/industry benchmark, not bottom-up unit economics.', '> Regenerate the prototype and re-run this renderer to replace with measured unit savings.', '');
+    }
+    else if (unitEconomicsSource === 'manifest' && manifestResult.manifest) {
+        const m = manifestResult.manifest;
+        lines.push(`> ✅ **Financial model: prototype unit economics** (sector: ${m.sector}, unit: ${m.domain_unit.label})`, `> Source: \`${manifestResult.inspectedPath ?? 'unit-economics.json'}\` · Method: ${m.extrapolation_method}`, '');
+        if (manifestWarnings.length > 0) {
+            lines.push('> ⚠️ **Unit economics consistency warnings:**', ...manifestWarnings.map(v => `> - ${v}`), '');
+        }
+    }
+    lines.push('---', '', `## Investment Summary${fin.isEstimated ? ' (Estimated from Organization Profile)' : unitEconomicsSource === 'manifest' ? ' (from Prototype Unit Economics)' : ''}`, '', '| Metric | Value |', '|--------|-------|', `| Total Investment | ${fin.budget} |`, `| Expected ROI | ${fin.roi} |`, `| 5-Year NPV | ${fin.npv} |`, `| Payback Period | ${fin.payback} |`, `| Revenue / Savings Impact | ${fin.revenue || fin.costSavings} |`, '');
+    // ADR-PIPELINE-070: Workforce exposure block when intensity ≥ medium.
+    // Mandatory for hospitality/retail/fleet/healthcare/CRE/etc. — calls out
+    // role count, EMEA union exposure, change-mgmt budget, and reallocation
+    // neutrality so the financial story includes the labor side.
+    const financialDomainAnalysis = extractDomainAnalysis(simData, query);
+    const financialLaborProfile = classifyLaborIntensity(financialDomainAnalysis, query);
+    if (isLaborIntensive(financialLaborProfile)) {
+        const pilotInvestmentUsd = parseUsdRangeMid(fin.budget) ?? 1_000_000;
+        const operationalUnits = manifestResult.manifest
+            ? primaryScopeCount(manifestResult.manifest)
+            : undefined;
+        const employeesContext = extractEmployeeCount(query, query.toLowerCase());
+        const exposure = estimateWorkforceExposure(financialLaborProfile, {
+            employees: employeesContext,
+            operationalUnits,
+            pilotInvestmentUsd,
+        });
+        if (exposure) {
+            lines.push('## Workforce Exposure (ADR-PIPELINE-070)', '', '| Dimension | Value |', '|-----------|-------|', `| Roles affected | ~${exposure.rolesAffected.toLocaleString()} ${exposure.primaryRoleLabel} |`, `| EMEA union exposure | ~${exposure.emeaUnionExposure.toLocaleString()} roles (${financialLaborProfile.unionizationRisk} unionization risk) |`, `| Change-management budget | $${(exposure.changeMgmtBudgetLowUsd / 1000).toFixed(0)}K – $${(exposure.changeMgmtBudgetHighUsd / 1000).toFixed(0)}K (${(exposure.changeMgmtPct * 100).toFixed(0)}% of pilot investment) |`, `| Reallocation neutrality | ${exposure.reallocationNeutral ? 'Committed (no headcount reduction during pilot)' : 'Not committed'} |`, `| Sector classification | ${financialLaborProfile.sector} (${financialLaborProfile.intensity} labor intensity) |`, '', '*Source: ADR-PIPELINE-070 labor classifier. Refine role counts and change-management budget with HR during pilot scoping.*', '');
+        }
+    }
     // ROI Analysis
     lines.push('## Return on Investment', '');
     if (roiData) {
@@ -2564,33 +3536,25 @@ export function renderFinancialAnalysis(query, simulationResult, platformResults
     lines.push(`| Optimistic | Faster adoption, lower integration costs | ${optCostStr} | ${fin.roi ? fin.roi.replace(/\d+/, m => String(Math.round(parseInt(m) * 1.3))) : 'Above base'} | 25% |`);
     lines.push(`| Pessimistic | Slower adoption, scope growth | ${pessCostStr} | ${fin.roi ? fin.roi.replace(/\d+/, m => String(Math.round(parseInt(m) * 0.6))) : 'Below base'} | 25% |`);
     lines.push('', '*Scenario analysis assumes ±20% cost variance and ±30% timeline variance from base case.*', '');
-    // ADR-052: Sensitivity table — show how ROI changes with different reduction targets
-    lines.push('## Sensitivity Analysis', '');
-    lines.push('Impact of varying the primary improvement target on projected savings:', '');
-    lines.push('| Reduction Target | Projected Savings | ROI | Payback |');
-    lines.push('|-----------------|-------------------|-----|---------|');
+    // ADR-PIPELINE-063: Multi-variable sensitivity tornado
+    // Implements ADR-PIPELINE-057 §1 — replaces the old single-variable loop
+    // with a ranked tornado chart across 5-7 domain-selected assumptions.
+    let baseSavingsForSensitivity = 0;
     if (fin.revenue) {
-        // Parse the base savings figure for sensitivity calculations
         const savingsMatch = fin.revenue.match(/\$([0-9,.]+)([KMB]?)/i);
         if (savingsMatch) {
             const numStr = savingsMatch[1].replace(/,/g, '');
             const suffix = (savingsMatch[2] || '').toUpperCase();
             const mult = suffix === 'M' ? 1_000_000 : suffix === 'K' ? 1_000 : suffix === 'B' ? 1_000_000_000 : 1;
-            const baseSavings = parseFloat(numStr) * mult;
-            const fmtS = (n) => n >= 1_000_000 ? `$${(n / 1_000_000).toFixed(1)}M` : `$${(n / 1000).toFixed(0)}K`;
-            const budgetMatch2 = fin.budget?.match(/\$([0-9,.]+)([KMB]?)/i);
-            const baseInvest = budgetMatch2 ? parseFloat(budgetMatch2[1].replace(/,/g, '')) * (budgetMatch2[2]?.toUpperCase() === 'M' ? 1_000_000 : budgetMatch2[2]?.toUpperCase() === 'K' ? 1_000 : 1) : baseSavings * 0.6;
-            for (const pct of [0.5, 0.75, 1.0, 1.25]) {
-                const savings = baseSavings * pct;
-                const roi = Math.round((savings / baseInvest) * 100);
-                const payback = savings > 0 ? Math.round(baseInvest / (savings / 12)) : 0;
-                const label = pct === 1.0 ? '**Base case**' : pct < 1 ? `Conservative (${Math.round(pct * 100)}%)` : `Aggressive (${Math.round(pct * 100)}%)`;
-                lines.push(`| ${label} | ${fmtS(savings)} | ${roi}% | ${payback} months |`);
-            }
+            const parsed = parseFloat(numStr) * mult;
+            if (!isNaN(parsed) && parsed > 0)
+                baseSavingsForSensitivity = parsed;
         }
     }
-    lines.push('');
-    lines.push('*Sensitivity shows how outcomes vary if the primary improvement target is higher or lower than the base case estimate.*', '');
+    // ADR-PIPELINE-070: pass the labor profile so workforce overrun appears
+    // in the tornado when applicable.
+    const sensitivityRows = buildSensitivityTable(baseSavingsForSensitivity, extracted.scenario_type, financialLaborProfile);
+    lines.push(...renderSensitivitySection(sensitivityRows, baseSavingsForSensitivity));
     if (lineage.simulationId) {
         lines.push(`*Simulation: ${lineage.simulationId}${lineage.traceId ? ` | Trace: ${lineage.traceId}` : ''}*`);
     }