@mergesignal/shared 0.4.3 → 0.6.0

package/dist/presentation/presenters/presentGitHubPrComment.js

@@ -1,34 +1,28 @@
 import { MERGE_POSTURE_LABEL } from "../../riskVocabulary.js";
-import { composeVerificationActions, evidenceContextFromProfile, } from "../compose/narrativeCompose.js";
-import { formatChangedPackagesShort, formatUsageSummaryLine, selectReviewerGuidance, } from "../../narrativePresentation.js";
+import { buildNarrativeChannels, evidenceContextFromProfile, } from "../compose/narrativeCompose.js";
+import { formatChangedPackagesShort } from "../../narrativePresentation.js";
+import { projectAssessmentFields } from "../projectAssessmentFields.js";
 export function presentGitHubPrComment(bundle) {
     const { facts, profile } = bundle;
+    const channels = buildNarrativeChannels(bundle);
+    const assessmentFields = projectAssessmentFields(bundle);
     const introLines = [];
     const changed = formatChangedPackagesShort(facts, 3);
     if (changed)
         introLines.push(`Changed: ${changed}`);
-    const usage = formatUsageSummaryLine(facts, 1);
-    if (usage)
-        introLines.push(usage);
-    const verify = composeVerificationActions(bundle, 1)[0];
+    for (const line of assessmentFields.reasoning.slice(0, 2)) {
+        introLines.push(line);
+    }
+    const verify = channels.verification[0];
     if (verify)
         introLines.push(`Verify: ${verify}`);
-    const guidance = selectReviewerGuidance(facts, { scope: "changed", max: 3 });
-    const selected = guidance.length === 0
-        ? selectReviewerGuidance(facts, { max: 3 })
-        : guidance;
-    const guidanceBlocks = selected.map((g) => {
-        const where = g.context?.trim() ||
-            facts.packageUsage
-                .flatMap((u) => u.paths.slice(0, 1))
-                .filter(Boolean)[0] ||
-            "See scan detail for affected paths.";
-        const action = g.remediation?.trim() ||
-            composeVerificationActions(bundle, 1)[0] ||
-            "Review before merge.";
-        return { message: g.message, where, action };
-    });
+    const guidanceBlocks = channels.verification.slice(0, 3).map((action) => ({
+        message: assessmentFields.reasoning[0] ?? action,
+        where: changed ?? "See scan detail for affected paths.",
+        action,
+    }));
     return {
+        ...assessmentFields,
         status: profile.status,
         density: profile.density,
         confidence: profile.confidence,

package/dist/presentation/presenters/presentScanDetails.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"presentScanDetails.d.ts","sourceRoot":"","sources":["../../../src/presentation/presenters/presentScanDetails.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AACjF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AAEzF,MAAM,MAAM,yBAAyB,GAAG;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B,CAAC;AAoHF,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,sBAAsB,EAC9B,GAAG,EAAE,yBAAyB,GAC7B,uBAAuB,CA6FzB"}
+{"version":3,"file":"presentScanDetails.d.ts","sourceRoot":"","sources":["../../../src/presentation/presenters/presentScanDetails.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AACjF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AAGzF,MAAM,MAAM,yBAAyB,GAAG;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B,CAAC;AAmDF,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,sBAAsB,EAC9B,GAAG,EAAE,yBAAyB,GAC7B,uBAAuB,CAwEzB"}

package/dist/presentation/presenters/presentScanDetails.js

@@ -1,88 +1,9 @@
-import { deriveDetailReachChip } from "../../formatCardExposureDisplay.js";
+import { MERGE_CONCERN_LABELS } from "../../assessmentLabels.js";
 import { MERGE_POSTURE_LABEL } from "../../riskVocabulary.js";
-import { deriveVerdictLineFromFacts, presentScanDetailViewModel, } from "../../scanDetailViewModel.js";
-import { buildNarrativeChannels, composeHeadline, composeSubheadline, composeSupportingContext, composeVerificationActions, evidenceContextFromProfile, projectCompactKeyPoints, } from "../compose/narrativeCompose.js";
+import { buildNarrativeChannels, composeSubheadline, composeSupportingContext, evidenceContextFromProfile, projectCompactKeyPoints, } from "../compose/narrativeCompose.js";
 import { normalizeGeneratedText, normalizeGeneratedTextNullable, } from "../../normalizeGeneratedText.js";
 import { scanSurfaceCopy } from "../../scanSurfaceCopy.js";
-function mapOperationalImpact(vm) {
-    const oi = vm.operationalImpact;
-    if (oi.status === "hidden") {
-        return { status: "hidden", items: [] };
-    }
-    if (oi.status === "rich") {
-        return {
-            status: "rich",
-            items: oi.items.map((item) => ({
-                message: item.message,
-                where: item.where,
-                verify: item.verify,
-                affectedFiles: item.affectedFiles,
-            })),
-        };
-    }
-    return {
-        status: "compact",
-        items: oi.items,
-        fallbackMessage: oi.fallbackMessage,
-    };
-}
-function mapRecommendations(vm) {
-    const items = vm.recommendedActions.items.map((item) => ({
-        rank: item.rank,
-        title: item.title,
-        priority: item.priority === "high" ||
-            item.priority === "medium" ||
-            item.priority === "low"
-            ? item.priority
-            : "medium",
-        rationale: item.detail?.why,
-    }));
-    return { items };
-}
-function mapEvidence(bundle, vm) {
-    const defaultCollapsed = bundle.profile.priority === "pr_intelligence" &&
-        bundle.profile.density === "rich";
-    const ev = vm.evidence;
-    if (!ev) {
-        return {
-            defaultCollapsed,
-            attentionAreas: [],
-            findings: [],
-            findingsOverflowCount: 0,
-        };
-    }
-    return {
-        defaultCollapsed,
-        attentionAreas: ev.attentionAreas.map((area) => ({
-            problemLabel: area.problemLabel,
-            problemDescription: area.problemDescription,
-            packages: area.packages.map((p) => ({
-                name: p.name,
-                version: p.version,
-                direct: p.direct,
-                severity: p.severity,
-                evidence: p.evidence,
-            })),
-            overflowCount: area.overflowCount,
-        })),
-        findings: ev.findings.map((f) => ({
-            id: f.id,
-            severity: f.severity,
-            title: f.title,
-            description: f.description,
-            packageName: f.packageName,
-            recommendation: f.recommendation,
-            source: f.source,
-        })),
-        findingsOverflowCount: ev.findingsOverflowCount,
-        topology: ev.topology
-            ? {
-                summaryLine: ev.topology.summaryLine,
-                deepest: ev.topology.deepest,
-            }
-            : undefined,
-    };
-}
+import { projectAssessmentFields } from "../projectAssessmentFields.js";
 function mapUsage(bundle) {
     const { facts } = bundle;
     if (facts.packageUsage.length === 0 && facts.frameworks.length === 0) {
@@ -101,20 +22,31 @@ function mapUsage(bundle) {
         frameworks: facts.frameworks,
     };
 }
+function mapEvidence(bundle) {
+    const defaultCollapsed = bundle.profile.priority === "pr_intelligence" &&
+        bundle.profile.density === "rich";
+    const findings = (bundle.result.findings ?? []).slice(0, 8).map((f) => ({
+        id: f.id,
+        severity: f.severity,
+        title: f.title,
+        description: f.description,
+        packageName: f.packageName,
+        recommendation: f.recommendation,
+        source: "dependency",
+    }));
+    return {
+        defaultCollapsed,
+        attentionAreas: [],
+        findings,
+        findingsOverflowCount: Math.max(0, (bundle.result.findings?.length ?? 0) - findings.length),
+    };
+}
 export function presentScanDetails(bundle, ctx) {
-    const { facts, profile, result } = bundle;
-    const vm = presentScanDetailViewModel(facts, result, {
-        scanId: ctx.scanId,
-        status: "done",
-        methodologyVersion: ctx.methodologyVersion,
-        prNumber: ctx.prNumber,
-        repoContext: { status: "hidden" },
-    });
-    const headline = composeHeadline(bundle);
-    const subheadline = composeSubheadline(bundle);
+    const { assessment, facts, profile, result } = bundle;
+    const assessmentFields = projectAssessmentFields(bundle);
     const channels = buildNarrativeChannels(bundle);
     const keyPoints = projectCompactKeyPoints(channels, 6);
-    const verificationTitles = composeVerificationActions(bundle, 6);
+    const subheadline = composeSubheadline(bundle);
     const supportingLines = composeSupportingContext(bundle);
     const supportingContext = supportingLines
         ? {
@@ -122,28 +54,39 @@ export function presentScanDetails(bundle, ctx) {
             lines: supportingLines,
         }
         : undefined;
-    const posture = profile.status;
-    const postureLabel = MERGE_POSTURE_LABEL[posture];
-    const toolingIntent = profile.interpretation.intent === "tooling_patch" ||
-        profile.interpretation.intent === "tooling_upgrade";
-    const verdictLine = profile.priority === "pr_intelligence" && toolingIntent && keyPoints[0]
-        ? keyPoints[0]
-        : deriveVerdictLineFromFacts(facts, result);
+    const postureLabel = MERGE_POSTURE_LABEL[profile.status];
+    const verdictLine = assessmentFields.reasoning[0] ??
+        (assessment.primaryConcern
+            ? MERGE_CONCERN_LABELS[assessment.primaryConcern]
+            : postureLabel);
+    const verificationActions = channels.verification.map((title, index) => ({
+        title: normalizeGeneratedText(title),
+        detail: assessmentFields.reasoning[index + 1],
+    }));
+    const recommendations = verificationActions.map((action, index) => ({
+        rank: index + 1,
+        title: action.title,
+        priority: profile.status === "risky"
+            ? "high"
+            : profile.status === "needs_review"
+                ? "medium"
+                : "low",
+        rationale: action.detail,
+    }));
     return {
+        ...assessmentFields,
         evidenceContext: evidenceContextFromProfile(bundle),
         status: profile.status,
         density: profile.density,
         confidence: profile.confidence,
         presentationIntent: profile.interpretation.intent,
         hero: {
-            headline: normalizeGeneratedText(headline),
+            headline: normalizeGeneratedText(channels.headline),
             subheadline: normalizeGeneratedTextNullable(subheadline) ?? undefined,
             verdictLine: normalizeGeneratedText(verdictLine),
-            scopeChip: channels.reachLabel ??
-                deriveDetailReachChip(result.totalScore) ??
-                undefined,
+            scopeChip: channels.reachLabel,
             postureLabel,
-            riskIndex: facts.riskIndex,
+            riskIndex: result.totalScore,
         },
         narrative: {
             keyPoints: keyPoints.map((k) => normalizeGeneratedText(k)),
@@ -151,30 +94,10 @@ export function presentScanDetails(bundle, ctx) {
             primaryPackage: facts.changedPackages.primary ?? undefined,
         },
         usage: mapUsage(bundle),
-        verification: {
-            actions: verificationTitles.map((title) => ({
-                title: normalizeGeneratedText(title),
-            })),
-        },
-        signalSummary: vm.signalSummary
-            ? {
-                riskIndex: vm.signalSummary.score,
-                band: vm.signalSummary.overallBand === "moderate"
-                    ? "medium"
-                    : vm.signalSummary.overallBand === "high"
-                        ? "high"
-                        : "low",
-                layers: vm.signalSummary.layers.map((l) => ({
-                    layer: l.layer,
-                    score: l.score,
-                    band: l.concernLabel,
-                    label: l.label,
-                })),
-            }
-            : undefined,
-        operationalImpact: mapOperationalImpact(vm),
-        recommendations: mapRecommendations(vm),
-        evidence: mapEvidence(bundle, vm),
+        verification: { actions: verificationActions },
+        operationalImpact: { status: "hidden", items: [] },
+        recommendations: { items: recommendations },
+        evidence: mapEvidence(bundle),
         supportingContext,
         metadata: {
             scanId: ctx.scanId,

package/dist/presentation/profile/buildProfileFromAssessment.d.ts

@@ -0,0 +1,5 @@
+import type { Assessment, AssessmentPresentationPublic } from "../../assessmentSchema.js";
+import type { ScanResult } from "../../types.js";
+import type { PresentationProfile } from "./presentationProfile.js";
+export declare function buildProfileFromAssessment(assessment: Assessment, presentation: AssessmentPresentationPublic, result: ScanResult): PresentationProfile;
+//# sourceMappingURL=buildProfileFromAssessment.d.ts.map

package/dist/presentation/profile/buildProfileFromAssessment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildProfileFromAssessment.d.ts","sourceRoot":"","sources":["../../../src/presentation/profile/buildProfileFromAssessment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,4BAA4B,EAC7B,MAAM,2BAA2B,CAAC;AAEnC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIjD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAwCpE,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,4BAA4B,EAC1C,MAAM,EAAE,UAAU,GACjB,mBAAmB,CAuBrB"}

package/dist/presentation/profile/buildProfileFromAssessment.js

@@ -0,0 +1,58 @@
+import { narrativeIntensityToDensity } from "../../assessmentSchema.js";
+import { safeParseRepoIntelligence } from "../../repoIntelligenceSchema.js";
+import { scanSurfaceCopy } from "../../scanSurfaceCopy.js";
+import { collectVerificationFocus } from "../../assessmentProjection.js";
+function buildInterpretation(assessment, presentation, result) {
+    const verificationLabels = collectVerificationFocus(result);
+    const anchorPackage = result.changedPackages?.[0] ?? null;
+    const suppressRuntimeNarrative = presentation.reachVisibility === "hidden";
+    let intent = "unknown_upgrade";
+    if (assessment.primaryConcern === "insufficient_evidence") {
+        intent = "limited_context";
+    }
+    else if (assessment.changeClasses.includes("tooling_maintenance")) {
+        intent = "tooling_patch";
+    }
+    else if (assessment.primaryConcern === "confirmed_runtime_usage") {
+        if (assessment.factors.includes("queue_infrastructure")) {
+            intent = "queue_runtime_upgrade";
+        }
+        else if (assessment.factors.includes("auth_infrastructure")) {
+            intent = "auth_runtime_upgrade";
+        }
+        else {
+            intent = "runtime_upgrade";
+        }
+    }
+    return {
+        intent,
+        anchorPackage,
+        suppressRuntimeNarrative,
+        allowRuntimeNarrative: !suppressRuntimeNarrative,
+        showLimitedEvidence: assessment.confidence === "low",
+        expectedImpactKey: null,
+        verificationLabels,
+        runtimeSurfaceLabel: null,
+        runtimePackages: [],
+    };
+}
+export function buildProfileFromAssessment(assessment, presentation, result) {
+    const riParse = safeParseRepoIntelligence(result.repoIntelligence);
+    const priority = riParse.ok && (result.changedPackages?.length ?? 0) > 0
+        ? "pr_intelligence"
+        : "limited";
+    const degradedMessage = assessment.primaryConcern === "insufficient_evidence" ||
+        assessment.confidence === "low"
+        ? scanSurfaceCopy.presentation.limitedContextMessage
+        : priority === "limited"
+            ? scanSurfaceCopy.presentation.limitedContextMessage
+            : undefined;
+    return {
+        status: assessment.posture,
+        density: narrativeIntensityToDensity(presentation.narrativeIntensity),
+        confidence: assessment.confidence,
+        priority,
+        degradedMessage,
+        interpretation: buildInterpretation(assessment, presentation, result),
+    };
+}

package/dist/presentation/projectAssessmentFields.d.ts

@@ -0,0 +1,4 @@
+import type { AssessmentPresentationFields } from "./dto/assessmentPresentationFields.js";
+import type { ScanPresentationBundle } from "./orchestration/scanPresentationBundle.js";
+export declare function projectAssessmentFields(bundle: ScanPresentationBundle): AssessmentPresentationFields;
+//# sourceMappingURL=projectAssessmentFields.d.ts.map

package/dist/presentation/projectAssessmentFields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projectAssessmentFields.d.ts","sourceRoot":"","sources":["../../src/presentation/projectAssessmentFields.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,uCAAuC,CAAC;AAC1F,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AAExF,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,sBAAsB,GAC7B,4BAA4B,CAW9B"}

package/dist/presentation/projectAssessmentFields.js

@@ -0,0 +1,13 @@
+import { collectVerificationFocus, projectReasoningLines, } from "../assessmentProjection.js";
+export function projectAssessmentFields(bundle) {
+    const { assessment, presentation, result } = bundle;
+    return {
+        posture: assessment.posture,
+        primaryConcern: assessment.primaryConcern,
+        factors: [...assessment.factors],
+        reasoning: projectReasoningLines(result),
+        verificationFocus: collectVerificationFocus(result),
+        reachVisibility: presentation.reachVisibility,
+        narrativeIntensity: presentation.narrativeIntensity,
+    };
+}

package/dist/presentation/surfaceParity.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=surfaceParity.test.d.ts.map

package/dist/presentation/surfaceParity.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surfaceParity.test.d.ts","sourceRoot":"","sources":["../../src/presentation/surfaceParity.test.ts"],"names":[],"mappings":""}

package/dist/presentation/surfaceParity.test.js

@@ -0,0 +1,74 @@
+import { describe, expect, it } from "vitest";
+import { buildScanPresentationBundle } from "./orchestration/buildScanPresentationBundle.js";
+import { presentDashboardCard } from "./presenters/presentDashboardCard.js";
+import { presentScanDetails } from "./presenters/presentScanDetails.js";
+import { presentGitHubCheckRun } from "./presenters/presentGitHubCheckRun.js";
+import { presentGitHubPrComment } from "./presenters/presentGitHubPrComment.js";
+import { renderGitHubCheckRunMarkdown } from "./render/renderGitHubCheckRunMarkdown.js";
+import { renderGitHubPrCommentMarkdown } from "./render/renderGitHubPrCommentMarkdown.js";
+import { scanResultBullmq, scanResultEslint, scanResultFastifyRuntime, scanResultMixedTypescriptFastify, scanResultPrettier, scanResultTypescriptPatch, scanResultVitest, } from "./fixtures/presentationPersonaFixtures.js";
+import { projectAssessmentFields } from "./projectAssessmentFields.js";
+const SCAN_ID = "22222222-2222-4222-8222-222222222222";
+const ORIGIN = "https://app.example.com";
+const validationPersonas = [
+    { name: "PR #26 mixed", result: scanResultMixedTypescriptFastify },
+    { name: "PR #27 fastify", result: scanResultFastifyRuntime },
+    { name: "PR #28 typescript", result: scanResultTypescriptPatch },
+    { name: "PR #29 prettier", result: scanResultPrettier },
+    { name: "PR #30 bullmq", result: scanResultBullmq },
+    { name: "eslint", result: scanResultEslint },
+    { name: "vitest", result: scanResultVitest },
+];
+function surfacesFor(result) {
+    const bundle = buildScanPresentationBundle({
+        result,
+        pipelineStatus: "done",
+    });
+    const fields = projectAssessmentFields(bundle);
+    const card = presentDashboardCard(bundle);
+    const details = presentScanDetails(bundle, { scanId: SCAN_ID });
+    const check = presentGitHubCheckRun(bundle, {
+        scanId: SCAN_ID,
+        webAppOrigin: ORIGIN,
+    });
+    const comment = presentGitHubPrComment(bundle);
+    const checkMd = renderGitHubCheckRunMarkdown(check);
+    const commentMd = renderGitHubPrCommentMarkdown(comment);
+    return { bundle, fields, card, details, check, comment, checkMd, commentMd };
+}
+describe("surfaceParity guardrail", () => {
+    for (const persona of validationPersonas) {
+        it(`${persona.name}: posture and assessment fields match across surfaces`, () => {
+            const s = surfacesFor(persona.result);
+            expect(s.card.posture).toBe(s.fields.posture);
+            expect(s.details.posture).toBe(s.fields.posture);
+            expect(s.check.posture).toBe(s.fields.posture);
+            expect(s.comment.posture).toBe(s.fields.posture);
+            expect(s.card.verdict?.posture).toBe(s.fields.posture);
+            expect(s.card.primaryConcern).toBe(s.fields.primaryConcern);
+            expect(s.details.primaryConcern).toBe(s.fields.primaryConcern);
+            expect(s.check.primaryConcern).toBe(s.fields.primaryConcern);
+            expect(s.comment.primaryConcern).toBe(s.fields.primaryConcern);
+            expect(s.card.narrativeIntensity).toBe(s.fields.narrativeIntensity);
+            expect(s.details.narrativeIntensity).toBe(s.fields.narrativeIntensity);
+            expect(s.check.narrativeIntensity).toBe(s.fields.narrativeIntensity);
+            expect(s.comment.narrativeIntensity).toBe(s.fields.narrativeIntensity);
+            expect(s.card.reachVisibility).toBe(s.fields.reachVisibility);
+            expect(s.details.reachVisibility).toBe(s.fields.reachVisibility);
+            expect(s.check.reachVisibility).toBe(s.fields.reachVisibility);
+            expect(s.comment.reachVisibility).toBe(s.fields.reachVisibility);
+            expect(s.card.reasoning).toEqual(s.fields.reasoning);
+            expect(s.details.reasoning).toEqual(s.fields.reasoning);
+            expect(s.check.reasoning).toEqual(s.fields.reasoning);
+            expect(s.comment.reasoning).toEqual(s.fields.reasoning);
+            expect(s.card.verificationFocus).toEqual(s.fields.verificationFocus);
+            expect(s.details.verificationFocus).toEqual(s.fields.verificationFocus);
+            expect(s.check.verificationFocus).toEqual(s.fields.verificationFocus);
+            expect(s.comment.verificationFocus).toEqual(s.fields.verificationFocus);
+        });
+        it(`${persona.name}: headline matches across card and details`, () => {
+            const s = surfacesFor(persona.result);
+            expect(s.details.hero.headline).toBe(s.card.headline);
+        });
+    }
+});

package/dist/productMessaging.d.ts

@@ -2,7 +2,7 @@
  * Canonical marketing / category copy. Operational scan strings stay in scanSurfaceCopy.
  */
 export declare const productMessaging: {
-    readonly formalDefinition: "MergeSignal analyzes dependency upgrades, identifies affected application flows, and provides reviewer guidance before merge.";
+    readonly formalDefinition: "MergeSignal analyzes dependency upgrades in context, inspects relevant code paths, and provides focused reviewer guidance before merge - without requiring a full repository scan.";
     readonly hero: {
         readonly kicker: "Merge-decision intelligence for dependency upgrades";
         readonly h1: "See what a dependency upgrade can break.";
@@ -68,10 +68,10 @@ export declare const productMessaging: {
     readonly dashboardPrCard: {
         readonly intro: "The repository dashboard is a runtime-aware review surface for open upgrade pull requests: triage by merge recommendation, then read operational context on each card.";
         readonly posture: `Posture indicates the merge recommendation (${string}, ${string}, ${string}).`;
-        readonly exposure: "Exposure indicates how broadly the upgrade touches runtime-relevant application areas.";
-        readonly exposureCategoriesLead: "On each scanned card, exposure reads as one of:";
+        readonly exposure: "Reach indicates how prominently affected application paths are surfaced for this upgrade.";
+        readonly exposureCategoriesLead: "Risk index bands (supporting context) read as one of:";
         readonly exposureCategories: readonly string[];
-        readonly cardBody: "Below the verdict, scanned cards lead with the changed package, runtime surface, reachability, blast radius, and affected areas when code intelligence is available; repository-wide graph signals appear only as supporting context.";
+        readonly cardBody: "Below the verdict, scanned cards lead with the changed package, affected areas, verification checks, and blast radius when code intelligence is available - focused on this PR, not the whole repository.";
     };
 };
 /** Illustrative scan-card example for homepage proof band and getting-started. */

package/dist/productMessaging.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"productMessaging.d.ts","sourceRoot":"","sources":["../src/productMessaging.ts"],"names":[],"mappings":"AAGA;;GAEG;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmF3B,6FAA6F;;;;;;;;;CAYrF,CAAC;AAEX,kFAAkF;AAClF,eAAO,MAAM,gBAAgB;;;;CAOnB,CAAC;AAEX,iEAAiE;AACjE,wBAAgB,wBAAwB,IAAI,MAAM,EAAE,CAOnD"}
+{"version":3,"file":"productMessaging.d.ts","sourceRoot":"","sources":["../src/productMessaging.ts"],"names":[],"mappings":"AAGA;;GAEG;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmF3B,6FAA6F;;;;;;;;;CAarF,CAAC;AAEX,kFAAkF;AAClF,eAAO,MAAM,gBAAgB;;;;CAOnB,CAAC;AAEX,iEAAiE;AACjE,wBAAgB,wBAAwB,IAAI,MAAM,EAAE,CAOnD"}

package/dist/productMessaging.js

@@ -4,7 +4,7 @@ import { MERGE_POSTURE_LABEL } from "./riskVocabulary.js";
  * Canonical marketing / category copy. Operational scan strings stay in scanSurfaceCopy.
  */
 export const productMessaging = {
-    formalDefinition: "MergeSignal analyzes dependency upgrades, identifies affected application flows, and provides reviewer guidance before merge.",
+    formalDefinition: "MergeSignal analyzes dependency upgrades in context, inspects relevant code paths, and provides focused reviewer guidance before merge - without requiring a full repository scan.",
     hero: {
         kicker: "Merge-decision intelligence for dependency upgrades",
         h1: "See what a dependency upgrade can break.",
@@ -83,10 +83,10 @@ export const productMessaging = {
     dashboardPrCard: {
         intro: "The repository dashboard is a runtime-aware review surface for open upgrade pull requests: triage by merge recommendation, then read operational context on each card.",
         posture: `Posture indicates the merge recommendation (${MERGE_POSTURE_LABEL.safe}, ${MERGE_POSTURE_LABEL.needs_review}, ${MERGE_POSTURE_LABEL.risky}).`,
-        exposure: "Exposure indicates how broadly the upgrade touches runtime-relevant application areas.",
-        exposureCategoriesLead: "On each scanned card, exposure reads as one of:",
+        exposure: "Reach indicates how prominently affected application paths are surfaced for this upgrade.",
+        exposureCategoriesLead: "Risk index bands (supporting context) read as one of:",
         exposureCategories: CARD_EXPOSURE_CATEGORY_LABELS,
-        cardBody: "Below the verdict, scanned cards lead with the changed package, runtime surface, reachability, blast radius, and affected areas when code intelligence is available; repository-wide graph signals appear only as supporting context.",
+        cardBody: "Below the verdict, scanned cards lead with the changed package, affected areas, verification checks, and blast radius when code intelligence is available - focused on this PR, not the whole repository.",
     },
 };
 /** Illustrative scan-card example for homepage proof band and getting-started. */

package/dist/productMessaging.test.js

@@ -71,8 +71,8 @@ describe("productMessaging", () => {
             d.cardBody,
         ].join(" ");
         expect(text).toContain("merge recommendation");
-        expect(text).toContain("runtime-relevant");
-        expect(text).not.toMatch(/risk index|total score|0-100|formula|weight/i);
+        expect(text).toContain("affected application paths");
+        expect(text).not.toMatch(/total score|0-100|formula|weight/i);
         expect(d.exposureCategories).toHaveLength(5);
         expect(d.exposureCategories).toContain("Elevated exposure");
     });

package/dist/repoIntelligenceSchema.d.ts

@@ -35,13 +35,13 @@ export declare const repoIntelligenceWireSchema: z.ZodObject<{
         }, z.core.$strip>;
         areas: z.ZodOptional<z.ZodArray<z.ZodString>>;
         dependencyClass: z.ZodOptional<z.ZodEnum<{
+            format: "format";
             unknown: "unknown";
             runtime: "runtime";
             build: "build";
             test: "test";
             tooling: "tooling";
             lint: "lint";
-            format: "format";
             ci: "ci";
         }>>;
         packageRole: z.ZodOptional<z.ZodEnum<{
@@ -64,9 +64,9 @@ export declare const repoIntelligenceWireSchema: z.ZodObject<{
             development: "development";
         }>>;
         runtimeImpact: z.ZodOptional<z.ZodEnum<{
+            none: "none";
             unknown: "unknown";
             confirmed: "confirmed";
-            none: "none";
             possible: "possible";
         }>>;
         expectedImpact: z.ZodOptional<z.ZodEnum<{

package/dist/resolvePipelineStatus.d.ts

@@ -0,0 +1,15 @@
+export type ScanPipelineStatus = "queued" | "running" | "done" | "failed";
+export type PipelineCompletionEvidence = {
+    scannedAt?: string | null;
+    decision?: string | null;
+    totalScore?: number | null;
+    hasResult?: boolean;
+};
+/** Scan completion signals — decision/totalScore/result are only set after analysis. */
+export declare function hasScanCompletionEvidence(evidence: PipelineCompletionEvidence): boolean;
+/**
+ * Resolve wire status using completion evidence (decision, totalScore, result).
+ * Handles races where denormalized columns are written before status flips to done.
+ */
+export declare function resolvePipelineStatus(status: string | undefined, evidence: PipelineCompletionEvidence): ScanPipelineStatus;
+//# sourceMappingURL=resolvePipelineStatus.d.ts.map

package/dist/resolvePipelineStatus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvePipelineStatus.d.ts","sourceRoot":"","sources":["../src/resolvePipelineStatus.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE1E,MAAM,MAAM,0BAA0B,GAAG;IACvC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAsBF,wFAAwF;AACxF,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,0BAA0B,GACnC,OAAO,CAQT;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,QAAQ,EAAE,0BAA0B,GACnC,kBAAkB,CAKpB"}

package/dist/resolvePipelineStatus.js

@@ -0,0 +1,37 @@
+function normalizePipelineStatus(status) {
+    const st = String(status ?? "")
+        .trim()
+        .toLowerCase();
+    if (st === "queued" || st === "running" || st === "done" || st === "failed") {
+        return st;
+    }
+    return "failed";
+}
+function isMergePostureDecision(decision) {
+    return (decision === "safe" || decision === "needs_review" || decision === "risky");
+}
+/** Scan completion signals — decision/totalScore/result are only set after analysis. */
+export function hasScanCompletionEvidence(evidence) {
+    if (isMergePostureDecision(evidence.decision))
+        return true;
+    if (evidence.hasResult === true)
+        return true;
+    if (evidence.totalScore != null && Number.isFinite(evidence.totalScore)) {
+        return true;
+    }
+    if (evidence.scannedAt?.trim())
+        return true;
+    return false;
+}
+/**
+ * Resolve wire status using completion evidence (decision, totalScore, result).
+ * Handles races where denormalized columns are written before status flips to done.
+ */
+export function resolvePipelineStatus(status, evidence) {
+    const normalized = normalizePipelineStatus(status);
+    if (normalized === "done" || normalized === "failed")
+        return normalized;
+    if (hasScanCompletionEvidence(evidence))
+        return "done";
+    return normalized;
+}

package/dist/scanCardPresentationState.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Dashboard PR card lifecycle — distinct from pipeline status.
+ *
+ * Pipeline / infrastructure: `scanning`, `analysis_failed`, `surfaces_incomplete`
+ * Product / assessment: `ready`, `stale`
+ * Absence: `not_scanned`
+ */
+export type ScanCardPresentationState = "not_scanned" | "scanning" | "analysis_failed" | "surfaces_incomplete" | "ready" | "stale";
+export declare function staleScanSubline(): string;
+//# sourceMappingURL=scanCardPresentationState.d.ts.map

package/dist/scanCardPresentationState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scanCardPresentationState.d.ts","sourceRoot":"","sources":["../src/scanCardPresentationState.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,MAAM,yBAAyB,GACjC,aAAa,GACb,UAAU,GACV,iBAAiB,GACjB,qBAAqB,GACrB,OAAO,GACP,OAAO,CAAC;AAIZ,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC"}

package/dist/scanCardPresentationState.js

@@ -0,0 +1,4 @@
+const STALE_SUBLINE = "Based on earlier commit";
+export function staleScanSubline() {
+    return STALE_SUBLINE;
+}