@mergesignal/shared 0.4.1 → 0.4.2

package/dist/presentation/intent/derivePresentationInterpretation.js

@@ -0,0 +1,202 @@
+import { formatCardAreaLabels } from "../../formatCardAreaLabels.js";
+import { mergeVerificationFocusLabels } from "./verificationFocusLabels.js";
+const TOOLING_CLASSES = new Set([
+    "tooling",
+    "test",
+    "lint",
+    "format",
+    "build",
+    "ci",
+]);
+const RUNTIME_IMPACT_RANK = {
+    confirmed: 3,
+    possible: 2,
+    unknown: 1,
+    none: 0,
+};
+const EVIDENCE_RANK = {
+    high: 3,
+    medium: 2,
+    low: 1,
+};
+function isRuntimeEligible(row) {
+    if (row.suppressRuntimeNarrative)
+        return false;
+    if (row.runtimeImpact === "confirmed" || row.runtimeImpact === "possible") {
+        return true;
+    }
+    if (row.dependencyClass === "runtime")
+        return true;
+    if (row.usagePathCount > 0)
+        return true;
+    return false;
+}
+function isToolingOriented(row) {
+    if (row.suppressRuntimeNarrative)
+        return true;
+    if (row.dependencyClass && TOOLING_CLASSES.has(row.dependencyClass)) {
+        return true;
+    }
+    return false;
+}
+function compareRuntimePackages(a, b, order) {
+    const impactA = RUNTIME_IMPACT_RANK[a.runtimeImpact ?? "none"] ?? 0;
+    const impactB = RUNTIME_IMPACT_RANK[b.runtimeImpact ?? "none"] ?? 0;
+    if (impactB !== impactA)
+        return impactB - impactA;
+    const evA = EVIDENCE_RANK[a.evidenceStrength ?? "low"] ?? 0;
+    const evB = EVIDENCE_RANK[b.evidenceStrength ?? "low"] ?? 0;
+    if (evB !== evA)
+        return evB - evA;
+    return order.indexOf(a.packageName) - order.indexOf(b.packageName);
+}
+function pickAnchorPackage(rows, changedOrder) {
+    if (rows.length === 0)
+        return null;
+    const sorted = [...rows].sort((a, b) => compareRuntimePackages(a, b, changedOrder));
+    return sorted[0]?.packageName ?? null;
+}
+function pickToolingAnchor(rows, changedOrder) {
+    if (rows.length === 0)
+        return null;
+    const sorted = [...rows].sort((a, b) => changedOrder.indexOf(a.packageName) - changedOrder.indexOf(b.packageName));
+    return sorted[0]?.packageName ?? null;
+}
+function isToolingPatchSet(rows, facts) {
+    if (rows.length === 0)
+        return false;
+    const narrow = !facts.blastRadius || facts.blastRadius.level === "narrow";
+    if (!narrow)
+        return false;
+    return rows.every((row) => row.suppressRuntimeNarrative &&
+        (row.expectedImpact === "typecheck" ||
+            row.expectedImpact === "build_time"));
+}
+function runtimeSurfaceLabelFromFacts(facts, anchorRow) {
+    const area = facts.affectedAreas[0];
+    if (area) {
+        const formatted = formatCardAreaLabels([area.label], 1);
+        return formatted[0] ?? area.label;
+    }
+    if (anchorRow?.packageRole === "http_framework") {
+        return "API request handling";
+    }
+    if (anchorRow?.packageRole === "auth") {
+        return "authentication flows";
+    }
+    if (anchorRow?.packageRole === "queue") {
+        return "background job processing";
+    }
+    return "application code";
+}
+function collectVerificationLabels(rows) {
+    return mergeVerificationFocusLabels(rows.map((r) => r.verificationFocus));
+}
+function showLimitedEvidence(rows) {
+    return rows.some((r) => r.evidenceStrength === "low");
+}
+function dominantExpectedImpact(rows) {
+    for (const row of rows) {
+        if (row.expectedImpact && row.expectedImpact !== "unknown") {
+            return row.expectedImpact;
+        }
+    }
+    return null;
+}
+function emptyInterpretation(intent) {
+    return {
+        intent,
+        anchorPackage: null,
+        suppressRuntimeNarrative: intent.startsWith("tooling"),
+        allowRuntimeNarrative: intent.includes("runtime"),
+        showLimitedEvidence: false,
+        expectedImpactKey: null,
+        verificationLabels: [],
+        runtimeSurfaceLabel: null,
+        runtimePackages: [],
+    };
+}
+export function derivePresentationInterpretation(facts) {
+    const changedOrder = facts.changedPackages.all;
+    const semantics = facts.changedPackageSemantics.length > 0
+        ? facts.changedPackageSemantics
+        : facts.packageSemantics && facts.changedPackages.primary
+            ? [
+                {
+                    packageName: facts.changedPackages.primary,
+                    dependencyClass: facts.packageSemantics.dependencyClass,
+                    packageRole: facts.packageSemantics.packageRole,
+                    runtimeImpact: facts.packageSemantics.runtimeImpact,
+                    expectedImpact: facts.packageSemantics.expectedImpact,
+                    suppressRuntimeNarrative: facts.packageSemantics.suppressRuntimeNarrative,
+                    evidenceStrength: facts.packageSemantics.evidenceStrength,
+                    verificationFocus: facts.packageSemantics.verificationFocus,
+                    usagePathCount: 0,
+                    usageAreaCount: 0,
+                },
+            ]
+            : [];
+    const tier1Ok = facts.availability.tiersPresent.tier1 &&
+        facts.availability.repoIntelligenceParse === "ok";
+    if (!tier1Ok) {
+        return emptyInterpretation("limited_context");
+    }
+    if (!facts.changedPackages.primary) {
+        return emptyInterpretation("no_changed_packages");
+    }
+    const runtimeEligible = semantics.filter(isRuntimeEligible);
+    if (runtimeEligible.length > 0) {
+        const anchorPackage = pickAnchorPackage(runtimeEligible, changedOrder);
+        const anchorRow = runtimeEligible.find((r) => r.packageName === anchorPackage);
+        const runtimeSurfaceLabel = runtimeSurfaceLabelFromFacts(facts, anchorRow);
+        const verificationLabels = collectVerificationLabels(runtimeEligible);
+        let intent = "runtime_upgrade";
+        if (runtimeEligible.length > 1) {
+            intent = "multi_runtime_upgrade";
+        }
+        else if (runtimeEligible.some((r) => r.packageRole === "auth")) {
+            intent = "auth_runtime_upgrade";
+        }
+        else if (runtimeEligible.some((r) => r.packageRole === "queue")) {
+            intent = "queue_runtime_upgrade";
+        }
+        return {
+            intent,
+            anchorPackage,
+            suppressRuntimeNarrative: false,
+            allowRuntimeNarrative: true,
+            showLimitedEvidence: showLimitedEvidence(runtimeEligible),
+            expectedImpactKey: dominantExpectedImpact(runtimeEligible),
+            verificationLabels,
+            runtimeSurfaceLabel,
+            runtimePackages: runtimeEligible.map((r) => r.packageName),
+        };
+    }
+    const toolingOnly = semantics.length > 0 && semantics.every(isToolingOriented);
+    if (toolingOnly) {
+        const anchorPackage = pickToolingAnchor(semantics, changedOrder);
+        const isPatch = isToolingPatchSet(semantics, facts);
+        const intent = isPatch
+            ? "tooling_patch"
+            : "tooling_upgrade";
+        const anchorRow = semantics.find((r) => r.packageName === anchorPackage);
+        return {
+            intent,
+            anchorPackage,
+            suppressRuntimeNarrative: true,
+            allowRuntimeNarrative: false,
+            showLimitedEvidence: showLimitedEvidence(semantics),
+            expectedImpactKey: anchorRow?.expectedImpact ?? null,
+            verificationLabels: collectVerificationLabels(semantics),
+            runtimeSurfaceLabel: null,
+            runtimePackages: [],
+        };
+    }
+    return {
+        ...emptyInterpretation("unknown_upgrade"),
+        anchorPackage: facts.changedPackages.primary,
+        verificationLabels: collectVerificationLabels(semantics),
+        showLimitedEvidence: showLimitedEvidence(semantics),
+        expectedImpactKey: dominantExpectedImpact(semantics),
+    };
+}

package/dist/presentation/intent/formatPresentationCopy.d.ts

@@ -0,0 +1,7 @@
+import type { ScanNarrativeFacts } from "../../scanNarrativeFacts.js";
+import type { PresentationStatus } from "../dto/types.js";
+import type { PresentationInterpretation } from "./presentationIntent.js";
+export declare function formatPresentationHeadline(interpretation: PresentationInterpretation, facts: ScanNarrativeFacts, status: PresentationStatus | undefined): string;
+export declare function formatPresentationKeyPoints(interpretation: PresentationInterpretation, facts: ScanNarrativeFacts, status: PresentationStatus | undefined, max: number): string[];
+export declare function formatPresentationVerification(interpretation: PresentationInterpretation, status: PresentationStatus | undefined, max: number): string[];
+//# sourceMappingURL=formatPresentationCopy.d.ts.map

package/dist/presentation/intent/formatPresentationCopy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatPresentationCopy.d.ts","sourceRoot":"","sources":["../../../src/presentation/intent/formatPresentationCopy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAM1D,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,yBAAyB,CAAC;AAa1E,wBAAgB,0BAA0B,CACxC,cAAc,EAAE,0BAA0B,EAC1C,KAAK,EAAE,kBAAkB,EACzB,MAAM,EAAE,kBAAkB,GAAG,SAAS,GACrC,MAAM,CAmDR;AA0BD,wBAAgB,2BAA2B,CACzC,cAAc,EAAE,0BAA0B,EAC1C,KAAK,EAAE,kBAAkB,EACzB,MAAM,EAAE,kBAAkB,GAAG,SAAS,EACtC,GAAG,EAAE,MAAM,GACV,MAAM,EAAE,CAmEV;AAuBD,wBAAgB,8BAA8B,CAC5C,cAAc,EAAE,0BAA0B,EAC1C,MAAM,EAAE,kBAAkB,GAAG,SAAS,EACtC,GAAG,EAAE,MAAM,GACV,MAAM,EAAE,CAmBV"}

package/dist/presentation/intent/formatPresentationCopy.js

@@ -0,0 +1,153 @@
+import { scanSurfaceCopy } from "../../scanSurfaceCopy.js";
+import { applyPostureVocabularyGuardHeadline, applyPostureVocabularyGuardLines, } from "./applyPostureVocabularyGuard.js";
+import { formatPackageDisplayName } from "./packageDisplayName.js";
+function anchorSemantics(facts, interpretation) {
+    const name = interpretation.anchorPackage;
+    if (!name)
+        return null;
+    return (facts.changedPackageSemantics.find((r) => r.packageName === name) ?? null);
+}
+export function formatPresentationHeadline(interpretation, facts, status) {
+    const anchor = interpretation.anchorPackage ?? facts.changedPackages.primary;
+    const row = anchorSemantics(facts, interpretation);
+    const pkgDisplay = formatPackageDisplayName(anchor ?? "dependency", row?.packageRole);
+    const copy = scanSurfaceCopy.presentation;
+    let headline;
+    switch (interpretation.intent) {
+        case "limited_context":
+            headline = copy.limitedContextHeadline;
+            break;
+        case "no_changed_packages":
+            headline = copy.noChangedPackagesHeadline;
+            break;
+        case "tooling_patch":
+            headline = copy.toolingPatchHeadline.replace("{package}", pkgDisplay);
+            break;
+        case "tooling_upgrade":
+            headline = copy.toolingUpgradeHeadline.replace("{package}", pkgDisplay);
+            break;
+        case "multi_runtime_upgrade":
+            headline = copy.multiRuntimeHeadline;
+            break;
+        case "auth_runtime_upgrade":
+        case "queue_runtime_upgrade":
+        case "runtime_upgrade": {
+            const surface = interpretation.runtimeSurfaceLabel ?? "application code";
+            headline = copy.runtimeUpgradeHeadline
+                .replace("{package}", pkgDisplay)
+                .replace("{surface}", surface);
+            break;
+        }
+        case "unknown_upgrade":
+            if (status === "safe") {
+                headline = copy.safeNeutralHeadline.replace("{package}", pkgDisplay);
+            }
+            else {
+                headline = copy.defaultUpgradeHeadline.replace("{package}", pkgDisplay);
+            }
+            break;
+        default:
+            headline = copy.safeNeutralHeadline.replace("{package}", pkgDisplay);
+    }
+    return applyPostureVocabularyGuardHeadline(headline, status, interpretation.anchorPackage);
+}
+function formatExpectedImpactKeyPoint(interpretation) {
+    if (interpretation.intent !== "tooling_patch" &&
+        interpretation.intent !== "tooling_upgrade") {
+        return null;
+    }
+    const key = interpretation.expectedImpactKey;
+    let workflows = "build and typecheck workflows";
+    if (key === "test_time")
+        workflows = "test workflows";
+    else if (key === "development_only")
+        workflows = "development workflows";
+    else if (key === "build_time")
+        workflows = "build workflows";
+    return scanSurfaceCopy.presentation.expectedImpactLimitedKeyPoint.replace("{workflows}", workflows);
+}
+function formatLimitedEvidenceKeyPoint() {
+    return scanSurfaceCopy.presentation.limitedEvidenceKeyPoint;
+}
+export function formatPresentationKeyPoints(interpretation, facts, status, max) {
+    const points = [];
+    if (interpretation.intent === "limited_context") {
+        points.push(scanSurfaceCopy.presentation.limitedContextKeyPoint);
+        if (facts.changedPackages.primary) {
+            points.push(scanSurfaceCopy.presentation.changedPackageKeyPoint.replace("{package}", facts.changedPackages.primary));
+        }
+        return applyPostureVocabularyGuardLines(points, status).slice(0, max);
+    }
+    if (interpretation.showLimitedEvidence) {
+        points.push(formatLimitedEvidenceKeyPoint());
+    }
+    if (interpretation.suppressRuntimeNarrative) {
+        points.push(scanSurfaceCopy.presentation.noRuntimePathsKeyPoint);
+        const impact = formatExpectedImpactKeyPoint(interpretation);
+        if (impact)
+            points.push(impact);
+    }
+    else if (interpretation.allowRuntimeNarrative) {
+        const usage = facts.packageUsage.find((u) => u.packageName === interpretation.anchorPackage);
+        const paths = [...(usage?.paths ?? []), ...(usage?.criticalPaths ?? [])];
+        if (paths.length > 0) {
+            points.push(scanSurfaceCopy.presentation.usedInRuntimePathsKeyPoint.replace("{count}", String(paths.length)));
+        }
+        else {
+            points.push(scanSurfaceCopy.presentation.runtimeUsageKeyPoint);
+        }
+        if (facts.affectedAreas.length > 0) {
+            const labels = facts.affectedAreas
+                .slice(0, 2)
+                .map((a) => a.label)
+                .join(", ");
+            points.push(scanSurfaceCopy.presentation.affectedAreasKeyPoint.replace("{areas}", labels));
+        }
+        const blast = facts.blastRadius;
+        if (blast?.level === "wide") {
+            points.push(scanSurfaceCopy.presentation.blastRadiusWideKeyPoint);
+        }
+        else if (blast?.level === "moderate") {
+            points.push(scanSurfaceCopy.presentation.blastRadiusLevelKeyPoint.replace("{level}", "Moderate"));
+        }
+    }
+    return applyPostureVocabularyGuardLines(points, status).slice(0, max);
+}
+const AUTH_VERIFICATION = [
+    "routes",
+    "middleware/hooks",
+    "auth flow",
+    "serialization",
+    "error handling",
+];
+const QUEUE_VERIFICATION = [
+    "workers",
+    "queue",
+    "serialization",
+    "error handling",
+];
+const RUNTIME_DEFAULT_VERIFICATION = [
+    "routes",
+    "middleware/hooks",
+    "error handling",
+];
+export function formatPresentationVerification(interpretation, status, max) {
+    let actions = [];
+    if (interpretation.verificationLabels.length > 0) {
+        actions = [...interpretation.verificationLabels];
+    }
+    else if (interpretation.intent === "auth_runtime_upgrade") {
+        actions = [...AUTH_VERIFICATION];
+    }
+    else if (interpretation.intent === "queue_runtime_upgrade") {
+        actions = [...QUEUE_VERIFICATION];
+    }
+    else if (interpretation.allowRuntimeNarrative) {
+        actions = [...RUNTIME_DEFAULT_VERIFICATION];
+    }
+    else if (interpretation.intent === "tooling_patch" ||
+        interpretation.intent === "tooling_upgrade") {
+        actions = ["CI", "typecheck", "build"];
+    }
+    return applyPostureVocabularyGuardLines(actions, status).slice(0, max);
+}

package/dist/presentation/intent/packageDisplayName.d.ts

@@ -0,0 +1,4 @@
+import type { PackageRoleKind } from "../../scanNarrativeFacts.js";
+/** Display name from package role when engine classified it; else title-case package name. */
+export declare function formatPackageDisplayName(packageName: string, packageRole?: PackageRoleKind | null): string;
+//# sourceMappingURL=packageDisplayName.d.ts.map

package/dist/presentation/intent/packageDisplayName.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packageDisplayName.d.ts","sourceRoot":"","sources":["../../../src/presentation/intent/packageDisplayName.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AASnE,8FAA8F;AAC9F,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,MAAM,EACnB,WAAW,CAAC,EAAE,eAAe,GAAG,IAAI,GACnC,MAAM,CAOR"}

package/dist/presentation/intent/packageDisplayName.js

@@ -0,0 +1,17 @@
+const ROLE_DISPLAY = {
+    typechecker: "TypeScript",
+    linter: "ESLint",
+    formatter: "Prettier",
+    test_runner: "Test runner",
+};
+/** Display name from package role when engine classified it; else title-case package name. */
+export function formatPackageDisplayName(packageName, packageRole) {
+    if (packageRole && ROLE_DISPLAY[packageRole]) {
+        return ROLE_DISPLAY[packageRole];
+    }
+    if (!packageName)
+        return packageName;
+    if (packageName.length <= 3)
+        return packageName.toUpperCase();
+    return packageName.charAt(0).toUpperCase() + packageName.slice(1);
+}

package/dist/presentation/intent/postureVocabularyGuard.test.d.ts

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

package/dist/presentation/intent/postureVocabularyGuard.test.d.ts.map

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

package/dist/presentation/intent/postureVocabularyGuard.test.js

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { applyPostureVocabularyGuardHeadline, applyPostureVocabularyGuardLines, guardHeadlineForPosture, } from "./applyPostureVocabularyGuard.js";
+describe("applyPostureVocabularyGuard", () => {
+    it("substitutes safe headline when review language present", () => {
+        const out = guardHeadlineForPosture("typescript dependency upgrade needs review", "safe", "typescript");
+        expect(out.toLowerCase()).not.toContain("needs review");
+        expect(out.toLowerCase()).toContain("typescript");
+    });
+    it("filters safe-forbidden key points", () => {
+        const lines = applyPostureVocabularyGuardLines(["No runtime usage paths detected", "High risk upgrade path"], "safe");
+        expect(lines).toContain("No runtime usage paths detected");
+        expect(lines.some((l) => /high risk/i.test(l))).toBe(false);
+    });
+    it("filters needs_review forbidden verification", () => {
+        const lines = applyPostureVocabularyGuardLines(["Confirm CI passes", "No action required"], "needs_review");
+        expect(lines).toContain("Confirm CI passes");
+        expect(lines.some((l) => /no action required/i.test(l))).toBe(false);
+    });
+    it("allows review headline for needs_review posture", () => {
+        const out = applyPostureVocabularyGuardHeadline("lodash dependency upgrade needs review", "needs_review", "lodash");
+        expect(out).toContain("needs review");
+    });
+});

package/dist/presentation/intent/presentationIntent.d.ts

@@ -0,0 +1,14 @@
+import type { PackageExpectedImpact } from "../../scanNarrativeFacts.js";
+export type PresentationIntent = "limited_context" | "no_changed_packages" | "tooling_patch" | "tooling_upgrade" | "runtime_upgrade" | "auth_runtime_upgrade" | "queue_runtime_upgrade" | "multi_runtime_upgrade" | "unknown_upgrade";
+export type PresentationInterpretation = {
+    intent: PresentationIntent;
+    anchorPackage: string | null;
+    suppressRuntimeNarrative: boolean;
+    allowRuntimeNarrative: boolean;
+    showLimitedEvidence: boolean;
+    expectedImpactKey: PackageExpectedImpact | null;
+    verificationLabels: string[];
+    runtimeSurfaceLabel: string | null;
+    runtimePackages: string[];
+};
+//# sourceMappingURL=presentationIntent.d.ts.map

package/dist/presentation/intent/presentationIntent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"presentationIntent.d.ts","sourceRoot":"","sources":["../../../src/presentation/intent/presentationIntent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAEzE,MAAM,MAAM,kBAAkB,GAC1B,iBAAiB,GACjB,qBAAqB,GACrB,eAAe,GACf,iBAAiB,GACjB,iBAAiB,GACjB,sBAAsB,GACtB,uBAAuB,GACvB,uBAAuB,GACvB,iBAAiB,CAAC;AAEtB,MAAM,MAAM,0BAA0B,GAAG;IACvC,MAAM,EAAE,kBAAkB,CAAC;IAC3B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,wBAAwB,EAAE,OAAO,CAAC;IAClC,qBAAqB,EAAE,OAAO,CAAC;IAC/B,mBAAmB,EAAE,OAAO,CAAC;IAC7B,iBAAiB,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAChD,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,eAAe,EAAE,MAAM,EAAE,CAAC;CAC3B,CAAC"}

package/dist/presentation/intent/presentationIntent.js

@@ -0,0 +1 @@
+export {};

package/dist/presentation/intent/presentationIntent.test.d.ts

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

package/dist/presentation/intent/presentationIntent.test.d.ts.map

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

package/dist/presentation/intent/presentationIntent.test.js

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import { deriveScanNarrative } from "../../deriveScanNarrative.js";
+import { scanResultMixedTypescriptFastify, scanResultTypescriptPatch, scanResultFastifyRuntime, } from "../fixtures/presentationPersonaFixtures.js";
+import { derivePresentationInterpretation } from "./derivePresentationInterpretation.js";
+describe("derivePresentationInterpretation", () => {
+    it("typescript patch: tooling_patch intent from engine semantics", () => {
+        const facts = deriveScanNarrative(scanResultTypescriptPatch);
+        const interp = derivePresentationInterpretation(facts);
+        // Engine: suppressRuntimeNarrative=true, expectedImpact=typecheck, dependencyClass=tooling
+        expect(interp.intent).toBe("tooling_patch");
+        expect(interp.anchorPackage).toBe("typescript");
+        expect(interp.suppressRuntimeNarrative).toBe(true);
+    });
+    it("fastify: runtime_upgrade from runtimeImpact=confirmed", () => {
+        const facts = deriveScanNarrative(scanResultFastifyRuntime);
+        const interp = derivePresentationInterpretation(facts);
+        expect(interp.intent).toBe("runtime_upgrade");
+        expect(interp.anchorPackage).toBe("fastify");
+        expect(interp.allowRuntimeNarrative).toBe(true);
+    });
+    it("mixed typescript+fastify: runtime dominates tooling (anchor fastify)", () => {
+        const facts = deriveScanNarrative(scanResultMixedTypescriptFastify);
+        const interp = derivePresentationInterpretation(facts);
+        expect(interp.intent).toBe("runtime_upgrade");
+        expect(interp.anchorPackage).toBe("fastify");
+        expect(interp.runtimePackages).toContain("fastify");
+        expect(interp.runtimePackages).not.toContain("typescript");
+    });
+});

package/dist/presentation/intent/verificationFocusLabels.d.ts

@@ -0,0 +1,2 @@
+export declare function mergeVerificationFocusLabels(focusLists: string[][], max?: number): string[];
+//# sourceMappingURL=verificationFocusLabels.d.ts.map

package/dist/presentation/intent/verificationFocusLabels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verificationFocusLabels.d.ts","sourceRoot":"","sources":["../../../src/presentation/intent/verificationFocusLabels.ts"],"names":[],"mappings":"AA2BA,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,MAAM,EAAE,EAAE,EACtB,GAAG,SAAI,GACN,MAAM,EAAE,CAeV"}

package/dist/presentation/intent/verificationFocusLabels.js

@@ -0,0 +1,45 @@
+const FOCUS_LABELS = {
+    ci: "CI",
+    typecheck: "typecheck",
+    build: "build",
+    routes: "routes",
+    middleware: "middleware/hooks",
+    hooks: "middleware/hooks",
+    auth_flow: "auth flow",
+    auth: "auth flow",
+    serialization: "serialization",
+    error_handling: "error handling",
+    handlers: "handlers",
+    plugins: "plugins",
+    session: "session",
+    workers: "workers",
+    queue: "queue",
+    test_suite: "test suite",
+    lint: "lint",
+    format: "format",
+};
+function labelVerificationFocus(focus) {
+    const key = focus.trim().toLowerCase();
+    if (!key)
+        return "";
+    return FOCUS_LABELS[key] ?? focus.replace(/_/g, " ");
+}
+export function mergeVerificationFocusLabels(focusLists, max = 6) {
+    const seen = new Set();
+    const out = [];
+    for (const list of focusLists) {
+        for (const f of list) {
+            const label = labelVerificationFocus(f);
+            if (!label)
+                continue;
+            const norm = label.toLowerCase();
+            if (seen.has(norm))
+                continue;
+            seen.add(norm);
+            out.push(label);
+            if (out.length >= max)
+                return out;
+        }
+    }
+    return out;
+}

package/dist/presentation/presentation.test.js

@@ -64,6 +64,9 @@ describe("presentScanCard personas", () => {
         const card = presentScanCard(bundle);
         expect(card.density).toBe("minimal");
         expect(card.status).toBe("safe");
+        expect(card.presentationIntent).toBe("tooling_patch");
+        expect(card.headline).toMatch(/patch upgrade/i);
+        expect(card.headline).not.toMatch(/needs review/i);
         expect(card.changedPackages).toContain("typescript");
         expect(card.verificationActions.length).toBeGreaterThan(0);
     });

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

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

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

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