@llm-dev-ops/agentics-cli 1.8.2 → 1.9.0

package/dist/synthesis/simulation-renderers.js

@@ -331,13 +331,17 @@ function estimateFinancialsFromQuery(query) {
         savingsMultiplier = 50;
         industryLabel = 'professional services';
     }
-    const pilotCost = Math.round(employees * costPerEmployee / 1000) * 1000;
-    const annualSavings = Math.round(employees * savingsMultiplier / 1000) * 1000;
+    // ── ADR-PIPELINE-038: Extract the operational unit from the query ──
+    // Instead of always using "employees", find what the system actually manages:
+    // vehicles, suppliers, patients, locations, transactions, etc.
+    const unitInfo = extractOperationalUnit(query, lower, employees);
+    const pilotCost = Math.round(unitInfo.count * costPerEmployee / 1000) * 1000;
+    const annualSavings = Math.round(unitInfo.count * savingsMultiplier / 1000) * 1000;
     const paybackMonths = Math.max(6, Math.min(24, Math.round(pilotCost / (annualSavings / 12))));
     const npv5yr = Math.round(annualSavings * 3.5);
     const roiPct = Math.round((annualSavings / pilotCost) * 100);
-    const methodology = `${employees.toLocaleString()} employees × $${costPerEmployee}/employee ${industryLabel} benchmark`;
-    const savingsMethod = `${employees.toLocaleString()} employees × $${savingsMultiplier}/employee annual efficiency gain`;
+    const methodology = `${unitInfo.count.toLocaleString()} ${unitInfo.label} × $${costPerEmployee}/${unitInfo.singular} ${industryLabel} benchmark`;
+    const savingsMethod = `${unitInfo.count.toLocaleString()} ${unitInfo.label} × $${savingsMultiplier}/${unitInfo.singular} annual efficiency gain`;
     return {
         budget: `${fmt(pilotCost)} - ${fmt(pilotCost * 1.5)} (${methodology})`,
         roi: `${roiPct}% projected (${fmt(annualSavings)} savings ÷ ${fmt(pilotCost)} investment)`,
@@ -349,6 +353,40 @@ function estimateFinancialsFromQuery(query) {
         isEstimated: true,
     };
 }
+/**
+ * Extract the primary operational unit from the query.
+ * Instead of always defaulting to "employees", find what the system actually operates on.
+ * Returns the unit count, label (plural), and singular form.
+ */
+function extractOperationalUnit(query, lower, employeeCount) {
+    // Try to find an explicit count + unit in the query
+    const unitPatterns = [
+        { pattern: /(\d[\d,]*)\s*(?:vehicles?|trucks?|vans?|cars?)/i, label: 'vehicles', singular: 'vehicle', fallbackRatio: 0.05 },
+        { pattern: /(\d[\d,]*)\s*(?:suppliers?|vendors?)/i, label: 'suppliers', singular: 'supplier', fallbackRatio: 0.013 },
+        { pattern: /(\d[\d,]*)\s*(?:patients?|beds?)/i, label: 'patients', singular: 'patient', fallbackRatio: 5 },
+        { pattern: /(\d[\d,]*)\s*(?:locations?|sites?|offices?|stores?|branches?)/i, label: 'locations', singular: 'location', fallbackRatio: 0.005 },
+        { pattern: /(\d[\d,]*)\s*(?:assets?|machines?|devices?)/i, label: 'assets', singular: 'asset', fallbackRatio: 0.1 },
+        { pattern: /(\d[\d,]*)\s*(?:products?|skus?|items?)/i, label: 'products', singular: 'product', fallbackRatio: 0.5 },
+        { pattern: /(\d[\d,]*)\s*(?:customers?|accounts?|clients?)/i, label: 'customers', singular: 'customer', fallbackRatio: 10 },
+        { pattern: /(\d[\d,]*)\s*(?:shipments?|orders?|transactions?)/i, label: 'transactions', singular: 'transaction', fallbackRatio: 50 },
+        { pattern: /(\d[\d,]*)\s*(?:contracts?|agreements?)/i, label: 'contracts', singular: 'contract', fallbackRatio: 0.02 },
+    ];
+    for (const { pattern, label, singular, fallbackRatio } of unitPatterns) {
+        const match = query.match(pattern);
+        if (match?.[1]) {
+            const count = parseInt(match[1].replace(/,/g, ''), 10);
+            if (count > 0)
+                return { count, label, singular };
+        }
+        // If the unit type is mentioned but without a number, estimate from employee count
+        if (new RegExp(`\\b${label.replace(/s$/, '')}`, 'i').test(lower)) {
+            const estimated = Math.max(10, Math.round(employeeCount * fallbackRatio));
+            return { count: estimated, label, singular };
+        }
+    }
+    // Default: use employees (the original behavior)
+    return { count: employeeCount, label: 'employees', singular: 'employee' };
+}
 /**
  * ADR-PIPELINE-029 §2: Domain-specific bottom-up financial models.
  * These use query signals to build unit-economics-based estimates
@@ -794,6 +832,26 @@ function generateDomainRisks(query, extracted) {
             mitigation: 'Include competitive benchmarking in board reporting; set public electrification targets aligned with or exceeding peer commitments; communicate transition progress to investors and customers',
         });
     }
+    // ── Generic domain-contextual risks for ANY domain not covered above ──
+    // Extract the core domain noun from the query and generate risks referencing it.
+    // This ensures every domain gets contextual risks, not just hardcoded ones.
+    if (risks.length < 5) {
+        const domainNoun = extractCoreDomainNoun(q);
+        if (domainNoun && !risks.some(r => r.risk.toLowerCase().includes(domainNoun.toLowerCase()))) {
+            risks.push({
+                risk: `${domainNoun} data may be incomplete, inconsistent, or outdated — analysis quality depends directly on input data quality from ${primarySystem}`,
+                category: 'Data', likelihood: 'Medium', impact: 'High', score: 6,
+                mitigation: `Data profiling and quality assessment during discovery phase; define minimum data completeness thresholds for ${domainNoun.toLowerCase()} analysis`,
+            });
+        }
+        if (risks.length < 5) {
+            risks.push({
+                risk: `Stakeholder alignment on ${domainNoun.toLowerCase()} priorities — different departments may have conflicting objectives for how to act on AI-generated insights`,
+                category: 'Organizational', likelihood: 'Medium', impact: 'Medium', score: 4,
+                mitigation: 'Cross-functional steering committee with clear decision authority; pilot scope agreed by all stakeholders before launch',
+            });
+        }
+    }
     // Always include vendor dependency
     risks.push({
         risk: 'Technology vendor dependency — platform availability, pricing changes, or API deprecation',
@@ -802,6 +860,98 @@ function generateDomainRisks(query, extracted) {
     });
     return risks.sort((a, b) => b.score - a.score);
 }
+/**
+ * Extract the core domain noun from a query — "fleet electrification", "packaging waste",
+ * "water loss", "employee sustainability", etc. Used to generate contextual risks and
+ * financial language for domains not explicitly covered by hardcoded patterns.
+ */
+function extractCoreDomainNoun(query) {
+    // Try structured patterns first
+    const patterns = [
+        /(?:reduce|optimize|improve|manage|analyze|monitor)\s+([\w\s]{3,30}?)(?:\.|,|$|\s+(?:across|from|in|for|by|through|using|while|without))/i,
+        /(?:challenge.*?is)\s+([\w\s]{3,30}?)(?:\.|,|$)/i,
+        /(?:help\s+(?:us|the|our)\s+(?:better\s+)?(?:understand|manage|reduce|optimize|plan|improve))\s+([\w\s]{3,30}?)(?:\.|,|$)/i,
+        /(?:AI could help.*?)\s+([\w\s]{5,30}?)(?:\.|,|$)/i,
+    ];
+    for (const pat of patterns) {
+        const m = query.match(pat);
+        if (m?.[1]) {
+            const noun = m[1].trim().replace(/^(the|a|an|our|their)\s+/i, '');
+            if (noun.length > 3 && noun.length < 40)
+                return noun.charAt(0).toUpperCase() + noun.slice(1);
+        }
+    }
+    // Fallback: extract the most specific noun phrase from the first 200 chars
+    const firstPart = query.slice(0, 200).toLowerCase();
+    const domainKeywords = firstPart.match(/\b(fleet|packaging|water|emission|procurement|maintenance|inventory|compliance|quality|safety|logistics|delivery|supply chain|workforce|clinical|financial|asset)\s+\w+/i);
+    if (domainKeywords?.[0])
+        return domainKeywords[0].charAt(0).toUpperCase() + domainKeywords[0].slice(1);
+    return 'operational process';
+}
+// ============================================================================
+// ADR-PIPELINE-040: LLM Synthesis for Executive Documents
+// ============================================================================
+const LLM_SYNTHESIS_PROMPT = `You are a senior partner at McKinsey & Company rewriting an enterprise decision document.
+
+Rules:
+- Lead with the recommendation and quantified impact (Pyramid Principle)
+- Every financial figure MUST show its derivation (unit × rate × volume = total)
+- Frame "do nothing" as a quantified business risk with competitive and regulatory context
+- Reference specific data from the analysis, never generic benchmarks
+- Ensure timeline consistency across all sections
+- Name specific stakeholder ROLES (VP Operations, Fleet Director, CFO), never "Workforce" or "Team"
+- Include regulatory context relevant to the domain (EU standards, EPA requirements, industry mandates)
+- Include competitive context (what peers/competitors are doing in this space)
+- No sentence fragments, no prompt echo, no template placeholders, no "to be determined" phrases
+- Every section must add insight, not just arrange data
+
+Rewrite the document below to be credible in a boardroom at a Fortune 500 company.`;
+/**
+ * ADR-PIPELINE-040: Attempt LLM synthesis of an executive document.
+ * Takes the template-generated skeleton and rewrites it into consulting-grade prose.
+ * Falls back to the skeleton unchanged if LLM is not available.
+ */
+export async function synthesizeExecutiveDocument(skeleton, query, documentType) {
+    // Try Claude binary first (works without API key, uses user's subscription)
+    try {
+        const { execSync } = await import('node:child_process');
+        const claudeBin = process.env['AGENTICS_CLAUDE_BIN'] || 'claude';
+        const input = `${LLM_SYNTHESIS_PROMPT}\n\nDocument type: ${documentType}\n\nOriginal business context:\n${query.slice(0, 1000)}\n\nDocument to rewrite:\n${skeleton}`;
+        const result = execSync(`${claudeBin} --print -`, { input, encoding: 'utf-8', timeout: 60_000, maxBuffer: 500_000, stdio: ['pipe', 'pipe', 'pipe'] });
+        if (result && result.trim().length > skeleton.length * 0.5) {
+            process.stderr.write(`[exec-docs] LLM synthesis succeeded for ${documentType} (${result.length} chars)\n`);
+            return result.trim();
+        }
+    }
+    catch {
+        // Claude binary not available — try API
+    }
+    // Try Anthropic API
+    const apiKey = process.env['ANTHROPIC_API_KEY'];
+    if (apiKey) {
+        try {
+            const { execSync } = await import('node:child_process');
+            const payload = JSON.stringify({
+                model: process.env['AGENTICS_CLAUDE_MODEL'] || 'claude-sonnet-4-20250514',
+                max_tokens: 4096,
+                messages: [{ role: 'user', content: `${LLM_SYNTHESIS_PROMPT}\n\nDocument type: ${documentType}\n\nBusiness context:\n${query.slice(0, 1000)}\n\nDocument:\n${skeleton}` }],
+            });
+            const result = execSync(`curl -s -X POST https://api.anthropic.com/v1/messages -H "content-type: application/json" -H "x-api-key: ${apiKey}" -H "anthropic-version: 2023-06-01" -d @-`, { input: payload, encoding: 'utf-8', timeout: 60_000, maxBuffer: 500_000, stdio: ['pipe', 'pipe', 'pipe'] });
+            const parsed = JSON.parse(result);
+            const text = parsed?.content?.[0]?.text;
+            if (text && text.length > skeleton.length * 0.5) {
+                process.stderr.write(`[exec-docs] API synthesis succeeded for ${documentType} (${text.length} chars)\n`);
+                return text;
+            }
+        }
+        catch {
+            // API call failed — fall through to skeleton
+        }
+    }
+    // Tier 3: return skeleton unchanged
+    process.stderr.write(`[exec-docs] LLM synthesis unavailable for ${documentType} — using template skeleton\n`);
+    return skeleton;
+}
 // ============================================================================
 // Executive Summary Renderer (ADR-PIPELINE-024: Pyramid Principle)
 // ============================================================================
@@ -927,6 +1077,21 @@ 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('');
+        }
+    }
     // Provenance — ADR-PIPELINE-033: include simulation lineage for decision traceability
     const sources = platformResults.filter(r => r.status >= 200 && r.status < 300).map(r => `${r.domain}/${r.agent}`);
     lines.push('---', '');