@geotechcli/core 0.4.50 → 0.4.52

package/dist/report/ingest-dossier.js

@@ -1,3 +1,4 @@
+import { buildGroundModelMap } from '../ground-model/index.js';
 function uniqueStrings(values) {
     return [...new Set(values.filter((value) => typeof value === 'string' && value.trim().length > 0))];
 }
@@ -366,6 +367,15 @@ function toneFromParseStatus(parseStatus, confidence) {
     }
     return 'good';
 }
+function toneFromScore(score) {
+    if (score >= 80) {
+        return 'good';
+    }
+    if (score >= 60) {
+        return 'warning';
+    }
+    return 'danger';
+}
 function evidenceCacheStatusLabel(status) {
     switch (status) {
         case 'hit':
@@ -684,9 +694,17 @@ function buildGeotechMetrics(result) {
     const statusCounts = countGeotechPageStatuses(result);
     const cacheHits = result.pageAudits.filter((audit) => audit.evidenceCache?.status === 'hit').length;
     const cacheStored = result.pageAudits.filter((audit) => audit.evidenceCache?.status === 'stored').length;
+    const breakdown = result.confidenceBreakdown;
     return [
         { label: 'Pages processed', value: `${result.source.successfulPages}/${result.source.totalPages}`, tone: result.source.failedPages > 0 ? 'warning' : 'good' },
-        { label: 'Confidence', value: `${result.confidence}%`, tone: toneFromParseStatus(result.parseStatus ?? 'parsed', result.confidence) },
+        {
+            label: 'Review confidence',
+            value: `${result.confidence}%`,
+            detail: breakdown
+                ? `pages avg ${breakdown.pageEvidenceConfidence}%, traceability ${breakdown.traceabilityScore}%, readiness ${breakdown.readinessScore}%`
+                : 'Workflow confidence for review triage.',
+            tone: toneFromParseStatus(result.parseStatus ?? 'parsed', result.confidence),
+        },
         { label: 'Page outcomes', value: `${statusCounts.parsed}/${result.pageAudits.length}`, detail: `${statusCounts.partial} partial, ${statusCounts.failed} failed`, tone: statusCounts.failed > 0 ? 'danger' : statusCounts.partial > 0 ? 'warning' : 'good' },
         { label: 'Materials', value: String(result.materials.length), detail: `${result.classifications.length} classifications`, tone: result.materials.length > 0 ? 'good' : 'warning' },
         { label: 'Parameters', value: String(result.parameters.length), detail: result.documentClass ?? 'No document class', tone: result.parameters.length > 0 ? 'good' : 'warning' },
@@ -694,6 +712,44 @@ function buildGeotechMetrics(result) {
         { label: 'Evidence cache', value: String(cacheHits), detail: `${cacheStored} stored this run`, tone: cacheHits > 0 ? 'good' : cacheStored > 0 ? 'accent' : 'neutral' },
     ];
 }
+function buildGeotechConfidenceItems(result) {
+    const breakdown = result.confidenceBreakdown;
+    if (!breakdown) {
+        return undefined;
+    }
+    return [
+        {
+            label: 'Workflow confidence',
+            value: `${breakdown.overall}%`,
+            detail: 'Legacy review-triage score; synthesis cannot raise it.',
+            tone: toneFromScore(breakdown.overall),
+        },
+        {
+            label: 'Page evidence',
+            value: `${breakdown.pageEvidenceConfidence}%`,
+            detail: `${result.pageAudits.length} audited page(s); extraction score ${breakdown.extractionConfidence}%.`,
+            tone: toneFromScore(breakdown.pageEvidenceConfidence),
+        },
+        {
+            label: 'Source traceability',
+            value: `${breakdown.traceabilityScore}%`,
+            detail: `${result.parameters.filter((parameter) => sourcePageText(parameter.context, parameter.sourcePages) !== '-').length}/${result.parameters.length} parameter(s) with source pages.`,
+            tone: toneFromScore(breakdown.traceabilityScore),
+        },
+        {
+            label: 'Review gates',
+            value: String(breakdown.reviewGates.length),
+            detail: breakdown.reviewGates.length > 0 ? breakdown.reviewGates.slice(0, 3).join(', ') : 'No retained confidence gates.',
+            tone: breakdown.reviewGates.length > 0 ? 'warning' : 'good',
+        },
+        {
+            label: 'Engineering completeness',
+            value: `${breakdown.engineeringCompleteness}%`,
+            detail: breakdown.missingCriticalData.length > 0 ? `Missing: ${breakdown.missingCriticalData.join(', ')}.` : 'Common critical data categories retained.',
+            tone: toneFromScore(breakdown.engineeringCompleteness),
+        },
+    ];
+}
 function buildBoreholeMetrics(result) {
     return [
         { label: 'Pages processed', value: `${result.source.successfulPages}/${result.source.totalPages}`, tone: result.source.failedPages > 0 ? 'warning' : 'good' },
@@ -733,7 +789,14 @@ function buildGeotechExecutiveItems(result, sourceLabel) {
             detail: result.parseStatus,
             tone: result.reviewRequired ? 'warning' : 'good',
         },
-        { label: 'Confidence', value: `${result.confidence}%`, tone: toneFromParseStatus(result.parseStatus, result.confidence) },
+        {
+            label: 'Review confidence',
+            value: `${result.confidence}%`,
+            detail: result.confidenceBreakdown
+                ? `Evidence ${result.confidenceBreakdown.pageEvidenceConfidence}%, readiness ${result.confidenceBreakdown.readinessScore}%.`
+                : undefined,
+            tone: toneFromParseStatus(result.parseStatus, result.confidence),
+        },
         { label: 'Boreholes detected', value: boreholeIds.length > 0 ? boreholeIds.join(', ') : 'Not explicitly detected', tone: boreholeIds.length > 0 ? 'good' : 'warning' },
         { label: 'Max depth', value: formatDepthMeters(maxDepth), tone: maxDepth != null ? 'good' : 'warning' },
         { label: 'Key engineering concern', value: inferKeyConcern(result), tone: 'warning' },
@@ -1157,6 +1220,273 @@ function buildGeotechBoreholeProfile(result) {
         ],
     };
 }
+function confidenceRatio(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return 0.5;
+    const normalized = value > 1 ? value / 100 : value;
+    return Math.round(Math.max(0, Math.min(1, normalized)) * 100) / 100;
+}
+function firstSourcePage(values) {
+    return uniqueSortedPages(values.flatMap((pages) => pages ?? []))[0];
+}
+function evidenceMethodForPage(result, pageNumber) {
+    const audit = pageNumber != null
+        ? result.pageAudits.find((candidate) => candidate.pageNumber === pageNumber)
+        : undefined;
+    if (!audit) {
+        return 'manual';
+    }
+    switch (audit?.textHintSource) {
+        case 'native-text':
+        case 'pdfjs-text':
+            return 'pdf-text';
+        case 'none':
+            return 'manual';
+        default:
+            return 'vision';
+    }
+}
+function addReportEvidenceRef(state, input) {
+    state.counter += 1;
+    const id = `doc-ev-${String(state.counter).padStart(5, '0')}`;
+    const hasAudit = input.pageNumber == null
+        || state.result.pageAudits.some((candidate) => candidate.pageNumber === input.pageNumber);
+    const warnings = [
+        ...(input.warnings ?? []),
+        ...(!hasAudit ? [`Source page ${input.pageNumber} was not present in retained page audit; verify against the PDF.`] : []),
+    ];
+    state.refs.push({
+        id,
+        sourceType: 'pdf-page',
+        sourcePath: state.sourcePath,
+        location: {
+            filePath: state.sourcePath,
+            ...(input.pageNumber != null ? { pageNumber: input.pageNumber } : {}),
+        },
+        method: evidenceMethodForPage(state.result, input.pageNumber),
+        confidence: confidenceRatio(state.result.confidence),
+        rawValue: input.rawValue,
+        normalizedValue: input.normalizedValue,
+        ...(input.unit ? { unit: input.unit } : {}),
+        warnings,
+    });
+    return id;
+}
+function depthFromEvidenceText(...values) {
+    for (const value of values) {
+        const depth = readDepthMeters(value);
+        if (depth != null && depth >= 0) {
+            return depth;
+        }
+    }
+    return undefined;
+}
+function numericParameterValue(parameter) {
+    if (parameter.numericValue != null && Number.isFinite(parameter.numericValue)) {
+        return parameter.numericValue;
+    }
+    const value = Number(String(parameter.valueText ?? '').replace(/,/g, '').trim());
+    return Number.isFinite(value) ? value : undefined;
+}
+function parameterBoreholeId(parameter) {
+    return inferBoreholeIdsFromText(parameter.material, parameter.context, parameter.name)[0];
+}
+function looksLikeBearingTableSptFalsePositive(parameter) {
+    const normalizedName = parameter.name.toLowerCase().replace(/\s+/g, '');
+    if (!/spt|nvalue|n-value|standardpenetration/.test(normalizedName)) {
+        return false;
+    }
+    const retainedContext = [parameter.material, parameter.context].filter(Boolean).join(' ');
+    return /\b(?:foundation|footing|allowable\s+bearing|bearing\s+pressure|net\s+bearing|dimension|size\s+of\s+footing)\b/i.test(retainedContext)
+        && !/\b(?:spt|standard\s+penetration|n[-\s]?value|blows?\b)\b/i.test(retainedContext);
+}
+function buildGroundModelFromGeotechReport(result, profile, sourceLabel) {
+    const evidenceState = {
+        refs: [],
+        counter: 0,
+        sourcePath: result.source.fileName ?? result.source.filePath ?? sourceLabel,
+        result,
+    };
+    const boreholes = new Map();
+    const strata = [];
+    const groundwater = [];
+    const parameters = [];
+    const ensureBorehole = (id, evidenceIds = []) => {
+        const normalizedId = normalizeBoreholeId(id);
+        const existing = boreholes.get(normalizedId);
+        if (existing) {
+            existing.evidenceIds = uniqueStrings([...existing.evidenceIds, ...evidenceIds]);
+            return existing;
+        }
+        const borehole = {
+            id: normalizedId,
+            sptTests: [],
+            strata: [],
+            groundwater: [],
+            evidenceIds,
+            confidence: confidenceRatio(result.confidence),
+            warnings: [],
+        };
+        boreholes.set(normalizedId, borehole);
+        return borehole;
+    };
+    for (const boreholeId of profile?.columns.map((column) => column.boreholeId) ?? inferGeotechBoreholeIds(result)) {
+        ensureBorehole(boreholeId);
+    }
+    if (profile) {
+        for (const column of profile.columns) {
+            const borehole = ensureBorehole(column.boreholeId);
+            for (const layer of column.layers) {
+                const pageNumber = firstSourcePage([layer.sourcePages]);
+                const warnings = layer.uncertain ? ['Layer boundary inferred or unverified.'] : [];
+                const evidenceId = addReportEvidenceRef(evidenceState, {
+                    pageNumber,
+                    rawValue: layer.description,
+                    normalizedValue: `${layer.depthFrom}-${layer.depthTo}m ${layer.description}`,
+                    warnings,
+                });
+                const stratum = {
+                    boreholeId: borehole.id,
+                    topDepth: layer.depthFrom,
+                    bottomDepth: layer.depthTo,
+                    description: layer.description,
+                    evidenceIds: [evidenceId],
+                    confidence: confidenceRatio(result.confidence),
+                    warnings,
+                };
+                strata.push(stratum);
+                borehole.strata.push(stratum);
+                borehole.evidenceIds = uniqueStrings([...borehole.evidenceIds, evidenceId]);
+            }
+            // Groundwater is added from the source parameter rows below so page-level
+            // evidence is preserved and duplicate profile-derived observations are avoided.
+        }
+    }
+    for (const parameter of result.parameters) {
+        const numericValue = numericParameterValue(parameter);
+        const boreholeId = parameterBoreholeId(parameter);
+        const depth = depthFromEvidenceText(parameter.context, parameter.material);
+        const sourcePage = firstSourcePage([parameter.sourcePages]);
+        const normalizedName = parameter.name.toLowerCase().replace(/\s+/g, '');
+        if (numericValue != null && /spt|nvalue|n-value|standardpenetration/.test(normalizedName)) {
+            if (!boreholeId || looksLikeBearingTableSptFalsePositive(parameter)) {
+                continue;
+            }
+            const testDepth = depth ?? depthFromEvidenceText(parameter.valueText);
+            if (testDepth != null && numericValue >= 0 && numericValue <= 100) {
+                const evidenceId = addReportEvidenceRef(evidenceState, {
+                    pageNumber: sourcePage,
+                    rawValue: parameter.valueText,
+                    normalizedValue: numericValue,
+                    unit: parameter.unit,
+                });
+                ensureBorehole(boreholeId, [evidenceId]).sptTests.push({
+                    depth: testDepth,
+                    nValue: numericValue,
+                    ...(parameter.unit ? { unit: parameter.unit } : {}),
+                    evidenceIds: [evidenceId],
+                    confidence: confidenceRatio(result.confidence),
+                    warnings: [],
+                });
+            }
+            continue;
+        }
+        if (numericValue != null && /groundwater|ground\s*water|watertable|water\s*table|gwl/.test(normalizedName)) {
+            const groundwaterDepth = depthFromEvidenceText(parameter.valueText, parameter.context, numericValue);
+            if (groundwaterDepth != null) {
+                const evidenceId = addReportEvidenceRef(evidenceState, {
+                    pageNumber: sourcePage,
+                    rawValue: parameter.valueText,
+                    normalizedValue: groundwaterDepth,
+                    unit: parameter.unit,
+                });
+                const observation = {
+                    ...(boreholeId ? { boreholeId } : {}),
+                    depth: groundwaterDepth,
+                    evidenceIds: [evidenceId],
+                    confidence: confidenceRatio(result.confidence),
+                    warnings: [],
+                };
+                groundwater.push(observation);
+                if (boreholeId) {
+                    ensureBorehole(boreholeId, [evidenceId]).groundwater.push(observation);
+                }
+            }
+            continue;
+        }
+        if (numericValue == null || depth == null || /(?:^|[^a-z])depth|elevation|thickness/.test(normalizedName)) {
+            continue;
+        }
+        const evidenceId = addReportEvidenceRef(evidenceState, {
+            pageNumber: sourcePage,
+            rawValue: parameter.valueText,
+            normalizedValue: numericValue,
+            unit: parameter.unit,
+        });
+        const visualParameter = {
+            name: parameter.name,
+            value: numericValue,
+            ...(parameter.unit ? { unit: parameter.unit } : {}),
+            ...(boreholeId ? { boreholeId } : {}),
+            depth,
+            evidenceIds: [evidenceId],
+            confidence: confidenceRatio(result.confidence),
+            warnings: [],
+        };
+        parameters.push(visualParameter);
+    }
+    const boreholeList = [...boreholes.values()].sort((left, right) => left.id.localeCompare(right.id, undefined, { numeric: true }));
+    const sptTestCount = boreholeList.reduce((count, borehole) => count + borehole.sptTests.length, 0);
+    if (strata.length === 0 && groundwater.length === 0 && parameters.length === 0 && sptTestCount === 0) {
+        return undefined;
+    }
+    const labTests = parameters
+        .filter((parameter) => parameter.depth != null)
+        .map((parameter, index) => ({
+        sampleId: `report-sample-${index + 1}`,
+        ...(parameter.boreholeId ? { boreholeId: parameter.boreholeId } : {}),
+        depth: parameter.depth,
+        parameters: [parameter],
+        evidenceIds: parameter.evidenceIds,
+        confidence: parameter.confidence,
+        warnings: parameter.warnings,
+    }));
+    const model = {
+        schemaVersion: 'ground-model.v1',
+        generatedAt: result.generatedAt,
+        project: {
+            rootPath: result.source.filePath ?? result.source.fileName ?? sourceLabel,
+        },
+        coordinateSystem: {
+            kind: 'unknown',
+            warnings: ['PDF report evidence did not include plottable coordinate data.'],
+        },
+        boreholes: boreholeList,
+        strata,
+        groundwater,
+        labTests,
+        parameters,
+        monitoringSeries: [],
+        evidence: evidenceState.refs,
+        rejectedObservations: [],
+        warnings: ['GroundModel visual review was adapted from PDF report evidence; source-page verification is required before design use.'],
+        stats: {
+            boreholes: boreholeList.length,
+            sptTests: sptTestCount,
+            strata: strata.length,
+            groundwaterObservations: groundwater.length,
+            labTests: labTests.length,
+            parameters: parameters.length,
+            monitoringSeries: 0,
+            evidenceRefs: evidenceState.refs.length,
+            rejectedObservations: 0,
+        },
+    };
+    return {
+        ...model,
+        map: buildGroundModelMap(model),
+    };
+}
 function buildBoreholeProfile(result) {
     if (result.boreholes.length === 0) {
         return undefined;
@@ -1225,6 +1555,7 @@ export function buildIngestDossier(result, options) {
         const cleanSummary = cleanNarrativeText(geotechResult.summary, 320);
         const summary = cleanSummary
             || geotechOutcomeSummary(geotechResult);
+        const boreholeProfile = buildGeotechBoreholeProfile(geotechResult);
         return {
             title,
             subtitle: geotechResult.documentClass
@@ -1243,7 +1574,9 @@ export function buildIngestDossier(result, options) {
             executiveItems: buildGeotechExecutiveItems(geotechResult, sourceLabel),
             insightCards: buildGeotechInsightCards(geotechResult),
             trustItems: buildGeotechTrustItems(geotechResult),
-            boreholeProfile: buildGeotechBoreholeProfile(geotechResult),
+            confidenceBreakdown: buildGeotechConfidenceItems(geotechResult),
+            boreholeProfile,
+            groundModel: buildGroundModelFromGeotechReport(geotechResult, boreholeProfile, sourceLabel),
             storedReview,
             approval,
             footerNotes: buildFooterNotes(geotechResult),