@mergesignal/shared 0.9.1 → 0.11.0

package/dist/assessmentProjection.d.ts

@@ -1,7 +1,16 @@
 import type { ScanResult } from "./types.js";
 import { type RepoIntelligence } from "./repoIntelligenceSchema.js";
-import type { Assessment, AssessmentPresentationPublic, ReachVisibility } from "@mergesignal/contracts";
+import type { Assessment, AssessmentPresentationPublic, ReachVisibility, VerificationIntensity } from "@mergesignal/contracts";
 import type { PresentationStatus } from "./presentation/dto/types.js";
+export type VerificationChannel = "runtime" | "artifact" | "none";
+export declare function resolveVerificationChannel(intensity: VerificationIntensity): VerificationChannel;
+export declare function collectRuntimeVerificationFocus(result: ScanResult): string[];
+export declare function collectArtifactVerificationFocus(result: ScanResult): string[];
+export declare function collectVerificationFocusForPresentation(presentation: AssessmentPresentationPublic, result: ScanResult): {
+    channel: VerificationChannel;
+    focus: string[];
+};
+/** @deprecated Use collectVerificationFocusForPresentation or channel-specific collectors. */
 export declare function collectVerificationFocus(result: ScanResult): string[];
 export declare function reachVisibilityLabel(visibility: ReachVisibility): string | undefined;
 export declare function formatAssessmentHeadline(assessment: Assessment, status: PresentationStatus): string;

package/dist/assessmentProjection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assessmentProjection.d.ts","sourceRoot":"","sources":["../src/assessmentProjection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EACV,UAAU,EACV,4BAA4B,EAC5B,eAAe,EAChB,MAAM,wBAAwB,CAAC;AAOhC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAgCtE,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,EAAE,CAkBrE;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,eAAe,GAC1B,MAAM,GAAG,SAAS,CAWpB;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,kBAAkB,GACzB,MAAM,CAiDR;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,EAAE,CAIlE;AAED,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,UAAU,GACjB,MAAM,EAAE,CAaV;AAED,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,4BAA4B,EAC1C,MAAM,EAAE,UAAU,EAClB,GAAG,EAAE,MAAM,GACV,MAAM,EAAE,CAIV;AAED,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,gBAAgB,GAAG,IAAI,GAAG,MAAM,EAAE,CAI3E"}
+{"version":3,"file":"assessmentProjection.d.ts","sourceRoot":"","sources":["../src/assessmentProjection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EACV,UAAU,EACV,4BAA4B,EAC5B,eAAe,EACf,qBAAqB,EACtB,MAAM,wBAAwB,CAAC;AAOhC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEtE,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,UAAU,GAAG,MAAM,CAAC;AAmDlE,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,qBAAqB,GAC/B,mBAAmB,CAIrB;AAED,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,EAAE,CAQ5E;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,EAAE,CAS7E;AAED,wBAAgB,uCAAuC,CACrD,YAAY,EAAE,4BAA4B,EAC1C,MAAM,EAAE,UAAU,GACjB;IAAE,OAAO,EAAE,mBAAmB,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAE,CAWnD;AAED,8FAA8F;AAC9F,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,EAAE,CAErE;AAED,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,eAAe,GAC1B,MAAM,GAAG,SAAS,CAWpB;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,kBAAkB,GACzB,MAAM,CAiDR;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,EAAE,CAIlE;AAED,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,UAAU,EACtB,MAAM,EAAE,UAAU,GACjB,MAAM,EAAE,CAaV;AAED,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,4BAA4B,EAC1C,MAAM,EAAE,UAAU,EAClB,GAAG,EAAE,MAAM,GACV,MAAM,EAAE,CAOV;AAED,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,gBAAgB,GAAG,IAAI,GAAG,MAAM,EAAE,CAI3E"}

package/dist/assessmentProjection.js

@@ -32,12 +32,7 @@ function surfaceHintFromAssessment(assessment) {
     }
     return "application code";
 }
-export function collectVerificationFocus(result) {
-    const scope = result.assessment?.verificationScope;
-    if (scope?.focus?.length)
-        return [...scope.focus];
-    const packages = scope?.packages ?? [];
-    const parsed = safeParseRepoIntelligence(result.repoIntelligence);
+function collectVerificationFocusFromPackages(packages, parsed) {
     if (!parsed.ok)
         return [];
     const labels = [];
@@ -54,6 +49,42 @@ export function collectVerificationFocus(result) {
     }
     return labels;
 }
+export function resolveVerificationChannel(intensity) {
+    if (intensity === "none")
+        return "none";
+    if (intensity === "required")
+        return "runtime";
+    return "artifact";
+}
+export function collectRuntimeVerificationFocus(result) {
+    const scope = result.assessment?.verificationScope;
+    if (scope?.focus?.length)
+        return [...scope.focus];
+    const packages = scope?.packages ?? [];
+    return collectVerificationFocusFromPackages(packages, safeParseRepoIntelligence(result.repoIntelligence));
+}
+export function collectArtifactVerificationFocus(result) {
+    const artifactGrounded = result.assessment?.verificationScope?.artifactGrounded;
+    if (!artifactGrounded)
+        return [];
+    if (artifactGrounded.focus.length > 0)
+        return [...artifactGrounded.focus];
+    return collectVerificationFocusFromPackages(artifactGrounded.packages, safeParseRepoIntelligence(result.repoIntelligence));
+}
+export function collectVerificationFocusForPresentation(presentation, result) {
+    const channel = resolveVerificationChannel(presentation.verificationIntensity);
+    if (channel === "none") {
+        return { channel, focus: [] };
+    }
+    if (channel === "runtime") {
+        return { channel, focus: collectRuntimeVerificationFocus(result) };
+    }
+    return { channel, focus: collectArtifactVerificationFocus(result) };
+}
+/** @deprecated Use collectVerificationFocusForPresentation or channel-specific collectors. */
+export function collectVerificationFocus(result) {
+    return collectRuntimeVerificationFocus(result);
+}
 export function reachVisibilityLabel(visibility) {
     switch (visibility) {
         case "hidden":
@@ -118,7 +149,7 @@ export function projectInsightLines(assessment, result) {
 export function projectVerificationActions(assessment, presentation, result, max) {
     if (presentation.verificationIntensity === "none")
         return [];
-    const focus = collectVerificationFocus(result);
+    const { focus } = collectVerificationFocusForPresentation(presentation, result);
     return focus.slice(0, max);
 }
 export function applicationAreaLabels(ri) {

package/dist/assessmentProjection.verificationChannel.test.d.ts

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

package/dist/assessmentProjection.verificationChannel.test.d.ts.map

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

package/dist/assessmentProjection.verificationChannel.test.js

@@ -0,0 +1,110 @@
+import { describe, expect, it } from "vitest";
+import { artifactGroundedScopeFor, minimalReviewFocalPoint, verificationScopeFor, withAssessmentScope, } from "./fixtures/assessmentScopeFixtures.js";
+import { assessmentFastifyRuntime, assessmentPrettier, assessmentTypescriptPatch, } from "./fixtures/assessmentFixtures.js";
+import { collectArtifactVerificationFocus, collectRuntimeVerificationFocus, collectVerificationFocusForPresentation, resolveVerificationChannel, } from "./assessmentProjection.js";
+import { toPublicPresentation } from "./assessmentPresentationUtils.js";
+function scanResultWithAssessment(assessment) {
+    return {
+        totalScore: 30,
+        layerScores: {
+            security: 10,
+            maintainability: 10,
+            ecosystem: 10,
+            upgradeImpact: 0,
+        },
+        findings: [],
+        generatedAt: "2026-01-01T00:00:00.000Z",
+        assessment,
+        decision: {
+            recommendation: "safe",
+            confidence: "high",
+            reasoning: ["fixture"],
+        },
+        repoIntelligence: {},
+        changedPackages: assessment.reviewFocalPoint.anchors,
+    };
+}
+describe("resolveVerificationChannel", () => {
+    it("maps intensity to presentation channel", () => {
+        expect(resolveVerificationChannel("none")).toBe("none");
+        expect(resolveVerificationChannel("advisory")).toBe("artifact");
+        expect(resolveVerificationChannel("required")).toBe("runtime");
+    });
+});
+describe("collectVerificationFocusForPresentation", () => {
+    it("fastify required: runtime focus only", () => {
+        const result = scanResultWithAssessment(assessmentFastifyRuntime);
+        const presentation = toPublicPresentation(assessmentFastifyRuntime.presentation);
+        const projected = collectVerificationFocusForPresentation(presentation, result);
+        expect(projected.channel).toBe("runtime");
+        expect(projected.focus).toEqual(["routes", "middleware"]);
+        expect(collectRuntimeVerificationFocus(result)).toEqual(projected.focus);
+        expect(collectArtifactVerificationFocus(result)).toEqual([]);
+    });
+    it("typescript advisory: artifact focus only", () => {
+        const result = scanResultWithAssessment(assessmentTypescriptPatch);
+        const presentation = toPublicPresentation(assessmentTypescriptPatch.presentation);
+        const projected = collectVerificationFocusForPresentation(presentation, result);
+        expect(projected.channel).toBe("artifact");
+        expect(projected.focus).toEqual(["typecheck"]);
+        expect(collectArtifactVerificationFocus(result)).toEqual(["typecheck"]);
+        expect(collectRuntimeVerificationFocus(result)).toEqual([]);
+    });
+    it("prettier advisory: artifact focus only", () => {
+        const result = scanResultWithAssessment(assessmentPrettier);
+        const presentation = toPublicPresentation(assessmentPrettier.presentation);
+        const projected = collectVerificationFocusForPresentation(presentation, result);
+        expect(projected.channel).toBe("artifact");
+        expect(projected.focus).toEqual(["format"]);
+    });
+    it("none intensity: empty focus", () => {
+        const assessment = withAssessmentScope({
+            ...assessmentTypescriptPatch,
+            presentation: {
+                ...assessmentTypescriptPatch.presentation,
+                verificationIntensity: "none",
+            },
+        }, {
+            reviewFocalPoint: minimalReviewFocalPoint(["typescript"]),
+            verificationScope: verificationScopeFor(["fastify"], ["routes"], artifactGroundedScopeFor(["typescript"], ["typecheck"])),
+        });
+        const result = scanResultWithAssessment(assessment);
+        const projected = collectVerificationFocusForPresentation(toPublicPresentation(assessment.presentation), result);
+        expect(projected.channel).toBe("none");
+        expect(projected.focus).toEqual([]);
+    });
+    it("conflict fixture: advisory uses artifact only", () => {
+        const assessment = withAssessmentScope({
+            ...assessmentTypescriptPatch,
+            presentation: {
+                ...assessmentTypescriptPatch.presentation,
+                verificationIntensity: "advisory",
+            },
+        }, {
+            reviewFocalPoint: minimalReviewFocalPoint(["typescript"]),
+            verificationScope: verificationScopeFor(["fastify"], ["routes"], artifactGroundedScopeFor(["typescript"], ["typecheck"])),
+        });
+        const result = scanResultWithAssessment(assessment);
+        const projected = collectVerificationFocusForPresentation(toPublicPresentation(assessment.presentation), result);
+        expect(projected.channel).toBe("artifact");
+        expect(projected.focus).toEqual(["typecheck"]);
+        expect(projected.focus).not.toContain("routes");
+    });
+    it("conflict fixture: required uses runtime only", () => {
+        const assessment = withAssessmentScope({
+            ...assessmentFastifyRuntime,
+            presentation: {
+                ...assessmentFastifyRuntime.presentation,
+                verificationIntensity: "required",
+            },
+        }, {
+            reviewFocalPoint: minimalReviewFocalPoint(["fastify"]),
+            verificationScope: verificationScopeFor(["fastify"], ["routes", "middleware"], artifactGroundedScopeFor(["typescript"], ["typecheck"])),
+        });
+        const result = scanResultWithAssessment(assessment);
+        const projected = collectVerificationFocusForPresentation(toPublicPresentation(assessment.presentation), result);
+        expect(projected.channel).toBe("runtime");
+        expect(projected.focus).toEqual(["routes", "middleware"]);
+        expect(projected.focus).not.toContain("typecheck");
+    });
+});

package/dist/fixtures/assessmentFixtures.d.ts

@@ -1,7 +1,7 @@
 import type { Assessment } from "@mergesignal/contracts";
 export declare const assessmentTypescriptPatch: Assessment;
-export declare const assessmentPrettier: Assessment;
 export declare const assessmentEslint: Assessment;
+export declare const assessmentPrettier: Assessment;
 export declare const assessmentVitest: Assessment;
 export declare const assessmentFastifyRuntime: Assessment;
 export declare const assessmentBullmq: Assessment;

package/dist/fixtures/assessmentFixtures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assessmentFixtures.d.ts","sourceRoot":"","sources":["../../src/fixtures/assessmentFixtures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AA0BzD,eAAO,MAAM,yBAAyB,EAAE,UAevC,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,UAUhC,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,UAS9B,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,UAe9B,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,UAyBtC,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,UA6B9B,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,UAyBhC,CAAC;AAEF,0EAA0E;AAC1E,eAAO,MAAM,gCAAgC,EAAE,UAgC9C,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,UA2BtC,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,UA6B5B,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,UAqBnC,CAAC"}
+{"version":3,"file":"assessmentFixtures.d.ts","sourceRoot":"","sources":["../../src/fixtures/assessmentFixtures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AA2BzD,eAAO,MAAM,yBAAyB,EAAE,UAmBvC,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,UAa9B,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,UAchC,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,UAuB9B,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,UAyBtC,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,UA6B9B,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,UAyBhC,CAAC;AAEF,0EAA0E;AAC1E,eAAO,MAAM,gCAAgC,EAAE,UAgC9C,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,UA2BtC,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,UA6B5B,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,UAqBnC,CAAC"}

package/dist/fixtures/assessmentFixtures.js

@@ -1,4 +1,4 @@
-import { emptyReachScope, emptyVerificationScope, minimalReviewFocalPoint, reachScopeFor, verificationScopeFor, withAssessmentScope, } from "./assessmentScopeFixtures.js";
+import { artifactGroundedScopeFor, emptyReachScope, emptyVerificationScope, minimalReviewFocalPoint, reachScopeFor, verificationScopeFor, withAssessmentScope, } from "./assessmentScopeFixtures.js";
 const safeToolingPresentation = {
     narrativeIntensity: "minimal",
     reachVisibility: "hidden",
@@ -24,22 +24,22 @@ export const assessmentTypescriptPatch = withAssessmentScope({
 }, {
     reviewFocalPoint: minimalReviewFocalPoint(["typescript"]),
     reachScope: emptyReachScope(),
-    verificationScope: emptyVerificationScope(),
+    verificationScope: verificationScopeFor([], [], artifactGroundedScopeFor(["typescript"], ["typecheck"], ["package.json"])),
 });
-export const assessmentPrettier = withAssessmentScope({
+export const assessmentEslint = withAssessmentScope({
     ...assessmentTypescriptPatch,
-    factors: ["tooling_maintenance"],
 }, {
-    reviewFocalPoint: minimalReviewFocalPoint(["prettier"]),
+    reviewFocalPoint: minimalReviewFocalPoint(["eslint"]),
     reachScope: emptyReachScope(),
-    verificationScope: emptyVerificationScope(),
+    verificationScope: verificationScopeFor([], [], artifactGroundedScopeFor(["eslint"], ["lint"], [".eslintrc.cjs"])),
 });
-export const assessmentEslint = withAssessmentScope({
+export const assessmentPrettier = withAssessmentScope({
     ...assessmentTypescriptPatch,
+    factors: ["tooling_maintenance"],
 }, {
-    reviewFocalPoint: minimalReviewFocalPoint(["eslint"]),
+    reviewFocalPoint: minimalReviewFocalPoint(["prettier"]),
     reachScope: emptyReachScope(),
-    verificationScope: emptyVerificationScope(),
+    verificationScope: verificationScopeFor([], [], artifactGroundedScopeFor(["prettier"], ["format"], [".prettierrc"])),
 });
 export const assessmentVitest = withAssessmentScope({
     posture: "safe",
@@ -52,7 +52,7 @@ export const assessmentVitest = withAssessmentScope({
 }, {
     reviewFocalPoint: minimalReviewFocalPoint(["vitest"]),
     reachScope: emptyReachScope(),
-    verificationScope: emptyVerificationScope(),
+    verificationScope: verificationScopeFor([], [], artifactGroundedScopeFor(["vitest"], ["test_suite"], ["vitest.config.ts"])),
 });
 export const assessmentFastifyRuntime = withAssessmentScope({
     posture: "needs_review",

package/dist/fixtures/assessmentScopeFixtures.d.ts

@@ -1,4 +1,4 @@
-import type { Assessment, FocalElectionDimension, ReachScope, ReviewEpisodeShape, ReviewFocalPoint, VerificationScope } from "@mergesignal/contracts";
+import type { ArtifactGroundedVerificationScope, Assessment, FocalElectionDimension, ReachScope, ReviewEpisodeShape, ReviewFocalPoint, VerificationScope } from "@mergesignal/contracts";
 export declare function minimalReviewFocalPoint(anchors: string[], opts?: {
     episodeShape?: ReviewEpisodeShape;
     supportingPackages?: string[];
@@ -6,8 +6,10 @@ export declare function minimalReviewFocalPoint(anchors: string[], opts?: {
 }): ReviewFocalPoint;
 export declare function emptyReachScope(): ReachScope;
 export declare function reachScopeFor(packages: string[], maxBucket?: ReachScope["maxBucket"]): ReachScope;
+export declare function emptyArtifactGrounded(): ArtifactGroundedVerificationScope;
+export declare function artifactGroundedScopeFor(packages: string[], focus?: string[], artifactPaths?: string[]): ArtifactGroundedVerificationScope;
 export declare function emptyVerificationScope(): VerificationScope;
-export declare function verificationScopeFor(packages: string[], focus?: string[]): VerificationScope;
+export declare function verificationScopeFor(packages: string[], focus?: string[], artifactGrounded?: ArtifactGroundedVerificationScope): VerificationScope;
 /** Attach focal/scope fields required by assessmentSchema ABI 2. */
 export declare function withAssessmentScope(assessment: Omit<Assessment, "reviewFocalPoint" | "reachScope" | "verificationScope">, scope: {
     reviewFocalPoint: ReviewFocalPoint;

package/dist/fixtures/assessmentScopeFixtures.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assessmentScopeFixtures.d.ts","sourceRoot":"","sources":["../../src/fixtures/assessmentScopeFixtures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,sBAAsB,EACtB,UAAU,EACV,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,wBAAwB,CAAC;AAEhC,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,CAAC,EAAE;IACL,YAAY,CAAC,EAAE,kBAAkB,CAAC;IAClC,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,SAAS,CAAC,EAAE,sBAAsB,CAAC;CACpC,GACA,gBAAgB,CAoBlB;AAED,wBAAgB,eAAe,IAAI,UAAU,CAE5C;AAED,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAAE,EAClB,SAAS,GAAE,UAAU,CAAC,WAAW,CAAc,GAC9C,UAAU,CAEZ;AAED,wBAAgB,sBAAsB,IAAI,iBAAiB,CAE1D;AAED,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAAE,EAClB,KAAK,GAAE,MAAM,EAAO,GACnB,iBAAiB,CAEnB;AAED,oEAAoE;AACpE,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,IAAI,CACd,UAAU,EACV,kBAAkB,GAAG,YAAY,GAAG,mBAAmB,CACxD,EACD,KAAK,EAAE;IACL,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;CACvC,GACA,UAAU,CAOZ"}
+{"version":3,"file":"assessmentScopeFixtures.d.ts","sourceRoot":"","sources":["../../src/fixtures/assessmentScopeFixtures.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iCAAiC,EACjC,UAAU,EACV,sBAAsB,EACtB,UAAU,EACV,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,wBAAwB,CAAC;AAEhC,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EAAE,EACjB,IAAI,CAAC,EAAE;IACL,YAAY,CAAC,EAAE,kBAAkB,CAAC;IAClC,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,SAAS,CAAC,EAAE,sBAAsB,CAAC;CACpC,GACA,gBAAgB,CAoBlB;AAED,wBAAgB,eAAe,IAAI,UAAU,CAE5C;AAED,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,MAAM,EAAE,EAClB,SAAS,GAAE,UAAU,CAAC,WAAW,CAAc,GAC9C,UAAU,CAEZ;AAED,wBAAgB,qBAAqB,IAAI,iCAAiC,CAEzE;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,MAAM,EAAE,EAClB,KAAK,GAAE,MAAM,EAAO,EACpB,aAAa,GAAE,MAAM,EAAO,GAC3B,iCAAiC,CAEnC;AAED,wBAAgB,sBAAsB,IAAI,iBAAiB,CAM1D;AAED,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,MAAM,EAAE,EAClB,KAAK,GAAE,MAAM,EAAO,EACpB,gBAAgB,GAAE,iCAA2D,GAC5E,iBAAiB,CAEnB;AAED,oEAAoE;AACpE,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,IAAI,CACd,UAAU,EACV,kBAAkB,GAAG,YAAY,GAAG,mBAAmB,CACxD,EACD,KAAK,EAAE;IACL,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;CACvC,GACA,UAAU,CAOZ"}

package/dist/fixtures/assessmentScopeFixtures.js

@@ -25,11 +25,21 @@ export function emptyReachScope() {
 export function reachScopeFor(packages, maxBucket = "moderate") {
     return { packages, maxBucket };
 }
+export function emptyArtifactGrounded() {
+    return { packages: [], focus: [], artifactPaths: [] };
+}
+export function artifactGroundedScopeFor(packages, focus = [], artifactPaths = []) {
+    return { packages, focus, artifactPaths };
+}
 export function emptyVerificationScope() {
-    return { packages: [], focus: [] };
+    return {
+        packages: [],
+        focus: [],
+        artifactGrounded: emptyArtifactGrounded(),
+    };
 }
-export function verificationScopeFor(packages, focus = []) {
-    return { packages, focus };
+export function verificationScopeFor(packages, focus = [], artifactGrounded = emptyArtifactGrounded()) {
+    return { packages, focus, artifactGrounded };
 }
 /** Attach focal/scope fields required by assessmentSchema ABI 2. */
 export function withAssessmentScope(assessment, scope) {

package/dist/index.d.ts

@@ -29,6 +29,6 @@ export * from "./trustedScanGuards.js";
 export * from "./actionsStepSummary.js";
 export * from "./productMessaging.js";
 export * from "./presentation/index.js";
-export { emptyReachScope, emptyVerificationScope, minimalReviewFocalPoint, reachScopeFor, verificationScopeFor, withAssessmentScope, } from "./fixtures/assessmentScopeFixtures.js";
+export { emptyReachScope, emptyVerificationScope, emptyArtifactGrounded, artifactGroundedScopeFor, minimalReviewFocalPoint, reachScopeFor, verificationScopeFor, withAssessmentScope, } from "./fixtures/assessmentScopeFixtures.js";
 export { assessmentStub, assessmentTypescriptPatch, } from "./fixtures/assessmentFixtures.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,iCAAiC,CAAC;AAChD,cAAc,0BAA0B,CAAC;AACzC,cAAc,oCAAoC,CAAC;AACnD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,OAAO,EAAE,wCAAwC,EAAE,MAAM,6BAA6B,CAAC;AACvF,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,uBAAuB,EACvB,aAAa,EACb,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EACL,cAAc,EACd,yBAAyB,GAC1B,MAAM,kCAAkC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,iCAAiC,CAAC;AAChD,cAAc,0BAA0B,CAAC;AACzC,cAAc,oCAAoC,CAAC;AACnD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,OAAO,EAAE,wCAAwC,EAAE,MAAM,6BAA6B,CAAC;AACvF,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,OAAO,EACL,eAAe,EACf,sBAAsB,EACtB,qBAAqB,EACrB,wBAAwB,EACxB,uBAAuB,EACvB,aAAa,EACb,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,uCAAuC,CAAC;AAC/C,OAAO,EACL,cAAc,EACd,yBAAyB,GAC1B,MAAM,kCAAkC,CAAC"}

package/dist/index.js

@@ -29,5 +29,5 @@ export * from "./trustedScanGuards.js";
 export * from "./actionsStepSummary.js";
 export * from "./productMessaging.js";
 export * from "./presentation/index.js";
-export { emptyReachScope, emptyVerificationScope, minimalReviewFocalPoint, reachScopeFor, verificationScopeFor, withAssessmentScope, } from "./fixtures/assessmentScopeFixtures.js";
+export { emptyReachScope, emptyVerificationScope, emptyArtifactGrounded, artifactGroundedScopeFor, minimalReviewFocalPoint, reachScopeFor, verificationScopeFor, withAssessmentScope, } from "./fixtures/assessmentScopeFixtures.js";
 export { assessmentStub, assessmentTypescriptPatch, } from "./fixtures/assessmentFixtures.js";

package/dist/presentation/dto/assessmentPresentationFields.d.ts

@@ -1,4 +1,5 @@
 import type { MergeConcernKind, NarrativeIntensity, ReachVisibility } from "@mergesignal/contracts";
+import type { VerificationChannel } from "../../assessmentProjection.js";
 /** Assessment-aligned fields projected identically across surfaces. */
 export type AssessmentPresentationFields = {
     posture: "safe" | "needs_review" | "risky";
@@ -6,6 +7,7 @@ export type AssessmentPresentationFields = {
     factors: string[];
     reasoning: string[];
     verificationFocus: string[];
+    verificationChannel: VerificationChannel;
     reachVisibility: ReachVisibility;
     narrativeIntensity: NarrativeIntensity;
 };

package/dist/presentation/dto/assessmentPresentationFields.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assessmentPresentationFields.d.ts","sourceRoot":"","sources":["../../../src/presentation/dto/assessmentPresentationFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EAEhB,MAAM,wBAAwB,CAAC;AAEhC,uEAAuE;AACvE,MAAM,MAAM,4BAA4B,GAAG;IACzC,OAAO,EAAE,MAAM,GAAG,cAAc,GAAG,OAAO,CAAC;IAC3C,cAAc,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACxC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,eAAe,EAAE,eAAe,CAAC;IACjC,kBAAkB,EAAE,kBAAkB,CAAC;CACxC,CAAC"}
+{"version":3,"file":"assessmentPresentationFields.d.ts","sourceRoot":"","sources":["../../../src/presentation/dto/assessmentPresentationFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EAEhB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,uEAAuE;AACvE,MAAM,MAAM,4BAA4B,GAAG;IACzC,OAAO,EAAE,MAAM,GAAG,cAAc,GAAG,OAAO,CAAC;IAC3C,cAAc,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACxC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,eAAe,EAAE,eAAe,CAAC;IACjC,kBAAkB,EAAE,kBAAkB,CAAC;CACxC,CAAC"}

package/dist/presentation/presentation.test.js

@@ -67,7 +67,9 @@ describe("presentDashboardCard personas", () => {
         expect(card.verdict?.posture).toBe("safe");
         expect(card.headline).toMatch(/patch upgrade/i);
         expect(card.headline).not.toMatch(/needs review/i);
-        expect(card.verification.length).toBe(0);
+        expect(card.verification.length).toBeGreaterThan(0);
+        expect(card.verificationChannel).toBe("artifact");
+        expect(card.verification.some((v) => v.toLowerCase().includes("typecheck"))).toBe(true);
     });
 });
 describe("presentScanDetails usage paths", () => {

package/dist/presentation/presentationPersonas.test.js

@@ -16,6 +16,7 @@ const personas = [
         density: "minimal",
         headlineMatch: /patch upgrade/i,
         headlineMustNot: /needs review/i,
+        verificationIncludes: ["typecheck"],
     },
     {
         name: "eslint",
@@ -34,6 +35,7 @@ const personas = [
         density: "minimal",
         headlineMatch: /patch upgrade/i,
         headlineMustNot: /needs review/i,
+        verificationIncludes: ["format"],
     },
     {
         name: "vitest",

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

@@ -1 +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,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIjD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAiDpE,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,4BAA4B,EAC1C,MAAM,EAAE,UAAU,GACjB,mBAAmB,CAuBrB"}
+{"version":3,"file":"buildProfileFromAssessment.d.ts","sourceRoot":"","sources":["../../../src/presentation/profile/buildProfileFromAssessment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,4BAA4B,EAC7B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIjD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAoDpE,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,4BAA4B,EAC1C,MAAM,EAAE,UAAU,GACjB,mBAAmB,CAuBrB"}

package/dist/presentation/profile/buildProfileFromAssessment.js

@@ -1,7 +1,7 @@
 import { narrativeIntensityToDensity } from "../../assessmentPresentationUtils.js";
 import { safeParseRepoIntelligence } from "../../repoIntelligenceSchema.js";
 import { scanSurfaceCopy } from "../../scanSurfaceCopy.js";
-import { collectVerificationFocus } from "../../assessmentProjection.js";
+import { collectVerificationFocusForPresentation } from "../../assessmentProjection.js";
 function focalAnchorPackage(assessment) {
     const anchors = assessment.reviewFocalPoint.anchors;
     if (!anchors.length)
@@ -14,7 +14,7 @@ function focalAnchorPackage(assessment) {
     return token;
 }
 function buildInterpretation(assessment, presentation, result) {
-    const verificationLabels = collectVerificationFocus(result);
+    const { focus: verificationLabels } = collectVerificationFocusForPresentation(presentation, result);
     const anchorPackage = focalAnchorPackage(assessment);
     const suppressRuntimeNarrative = presentation.reachVisibility === "hidden";
     let intent = "unknown_upgrade";

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

@@ -1 +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"}
+{"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,CAgB9B"}

package/dist/presentation/projectAssessmentFields.js

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

package/dist/presentation/surfaceParity.test.js

@@ -85,6 +85,10 @@ describe("surfaceParity guardrail", () => {
             expect(s.details.verificationFocus).toEqual(s.fields.verificationFocus);
             expect(s.check.verificationFocus).toEqual(s.fields.verificationFocus);
             expect(s.comment.verificationFocus).toEqual(s.fields.verificationFocus);
+            expect(s.card.verificationChannel).toBe(s.fields.verificationChannel);
+            expect(s.details.verificationChannel).toBe(s.fields.verificationChannel);
+            expect(s.check.verificationChannel).toBe(s.fields.verificationChannel);
+            expect(s.comment.verificationChannel).toBe(s.fields.verificationChannel);
         });
         it(`${persona.name}: headline matches across card and details`, () => {
             const s = surfacesFor(persona.result);
@@ -133,6 +137,8 @@ describe("surfaceParity guardrail", () => {
         const ch26 = channelsById.get("validation-pr-26");
         expect(ch28.reachLabel).toBeUndefined();
         expect(ch29.reachLabel).toBeUndefined();
+        expect(ch28.verification.length).toBeGreaterThan(0);
+        expect(ch29.verification.length).toBeGreaterThan(0);
         expect(ch27.verification.length).toBeGreaterThan(0);
         expect(ch30.verification.length).toBeGreaterThan(0);
         expect(ch27.verification).not.toEqual(ch30.verification);

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

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

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

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

package/dist/presentation/verificationChannelParity.test.js

@@ -0,0 +1,57 @@
+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 { projectAssessmentFields } from "./projectAssessmentFields.js";
+import { scanResultFastifyRuntime, scanResultPrettier, scanResultTypescriptPatch, } from "./fixtures/presentationPersonaFixtures.js";
+const SCAN_ID = "22222222-2222-4222-8222-222222222222";
+const ORIGIN = "https://app.example.com";
+describe("verification channel provenance parity", () => {
+    for (const persona of [
+        {
+            name: "fastify runtime",
+            result: scanResultFastifyRuntime,
+            channel: "runtime",
+            focusIncludes: "routes",
+        },
+        {
+            name: "typescript patch",
+            result: scanResultTypescriptPatch,
+            channel: "artifact",
+            focusIncludes: "typecheck",
+        },
+        {
+            name: "prettier",
+            result: scanResultPrettier,
+            channel: "artifact",
+            focusIncludes: "format",
+        },
+    ]) {
+        it(`${persona.name}: verificationChannel and focus match across surfaces`, () => {
+            const bundle = buildScanPresentationBundle({
+                result: persona.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);
+            expect(fields.verificationChannel).toBe(persona.channel);
+            expect(card.verificationChannel).toBe(persona.channel);
+            expect(details.verificationChannel).toBe(persona.channel);
+            expect(check.verificationChannel).toBe(persona.channel);
+            expect(comment.verificationChannel).toBe(persona.channel);
+            expect(fields.verificationFocus).toEqual(card.verificationFocus);
+            expect(details.verificationFocus).toEqual(fields.verificationFocus);
+            expect(check.verificationFocus).toEqual(fields.verificationFocus);
+            expect(comment.verificationFocus).toEqual(fields.verificationFocus);
+            expect(fields.verificationFocus.some((f) => f.toLowerCase().includes(persona.focusIncludes.toLowerCase()))).toBe(true);
+        });
+    }
+});

package/dist/repoIntelligenceSchema.contract.test.js

@@ -16,4 +16,36 @@ describe("repoIntelligenceWireSchema contract", () => {
         const joined = r.issues.join(" ");
         expect(joined.length).toBeGreaterThan(0);
     });
+    it("accepts optional lifecycleStages and promotedAreas on package rows (ABI 3)", () => {
+        const wire = {
+            packages: {
+                "acme-runtime-http-lib": {
+                    runtimeSurface: "runtime",
+                    reachability: "on_runtime_paths",
+                    usage: {
+                        packageName: "acme-runtime-http-lib",
+                        files: ["apps/api/handlers/entry.ts"],
+                        areas: [],
+                    },
+                    lifecycleStages: [
+                        {
+                            stage: "route_registration",
+                            fileCount: 1,
+                            evidenceRefs: ["import_path:apps/api/handlers/entry.ts"],
+                        },
+                    ],
+                    promotedAreas: [
+                        {
+                            area: "api",
+                            structuralAnchor: "http_surface",
+                            evidenceRefs: ["import_path:apps/api/handlers/entry.ts"],
+                        },
+                    ],
+                },
+            },
+        };
+        const validated = validateRepoIntelligenceWire(wire);
+        expect(validated.packages["acme-runtime-http-lib"]?.lifecycleStages?.length).toBe(1);
+        expect(validated.packages["acme-runtime-http-lib"]?.promotedAreas?.length).toBe(1);
+    });
 });

package/dist/repoIntelligenceSchema.d.ts

@@ -9,7 +9,7 @@ import { z } from "zod";
 import type { ScanResult } from "./types.js";
 import type { BlastRadiusLevel } from "./scanNarrativeFacts.js";
 /** Bump when wire schema changes incompatibly. */
-export declare const REPO_INTELLIGENCE_ABI: "2";
+export declare const REPO_INTELLIGENCE_ABI: "3";
 /** Strict canonical wire schema — single source of truth. */
 export declare const repoIntelligenceWireSchema: z.ZodObject<{
     packages: z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -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<{
+            lint: "lint";
+            format: "format";
             unknown: "unknown";
             runtime: "runtime";
             build: "build";
             test: "test";
             tooling: "tooling";
-            lint: "lint";
-            format: "format";
             ci: "ci";
         }>>;
         packageRole: z.ZodOptional<z.ZodEnum<{
@@ -70,10 +70,10 @@ export declare const repoIntelligenceWireSchema: z.ZodObject<{
             possible: "possible";
         }>>;
         expectedImpact: z.ZodOptional<z.ZodEnum<{
+            typecheck: "typecheck";
             unknown: "unknown";
             runtime: "runtime";
             build_time: "build_time";
-            typecheck: "typecheck";
             test_time: "test_time";
             development_only: "development_only";
         }>>;
@@ -101,6 +101,24 @@ export declare const repoIntelligenceWireSchema: z.ZodObject<{
             }>;
             registryEntryId: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>;
+        lifecycleStages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            stage: z.ZodString;
+            fileCount: z.ZodNumber;
+            evidenceRefs: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>>;
+        promotedAreas: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            area: z.ZodString;
+            structuralAnchor: z.ZodOptional<z.ZodEnum<{
+                http_surface: "http_surface";
+                auth_surface: "auth_surface";
+                orm_surface: "orm_surface";
+                queue_surface: "queue_surface";
+                type_surface: "type_surface";
+                build_surface: "build_surface";
+                testing_surface: "testing_surface";
+            }>>;
+            evidenceRefs: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>;
     packageUsage: z.ZodOptional<z.ZodArray<z.ZodObject<{
         packageName: z.ZodString;

package/dist/repoIntelligenceSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"repoIntelligenceSchema.d.ts","sourceRoot":"","sources":["../src/repoIntelligenceSchema.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,kDAAkD;AAClD,eAAO,MAAM,qBAAqB,EAAG,GAAY,CAAC;AA+HlD,6DAA6D;AAC7D,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASrC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE1E,MAAM,MAAM,4BAA4B,GAAG;IACzC,EAAE,EAAE,IAAI,CAAC;IACT,KAAK,EAAE,gBAAgB,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,EAAE,EAAE,KAAK,CAAC;IACV,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,2BAA2B,GACnC,4BAA4B,GAC5B,4BAA4B,CAAC;AAQjC,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAUlE;AAED,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,OAAO,GACX,2BAA2B,CAyC7B;AAED,uEAAuE;AACvE,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,OAAO,GAAG,gBAAgB,CAM3E;AAED,mFAAmF;AACnF,wBAAgB,uCAAuC,CACrD,IAAI,EAAE,UAAU,GACf,IAAI,CAGN;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,gBAAgB,GAAG,SAAS,GAClC,gBAAgB,GAAG,IAAI,CAKzB"}
+{"version":3,"file":"repoIntelligenceSchema.d.ts","sourceRoot":"","sources":["../src/repoIntelligenceSchema.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,kDAAkD;AAClD,eAAO,MAAM,qBAAqB,EAAG,GAAY,CAAC;AAuJlD,6DAA6D;AAC7D,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASrC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE1E,MAAM,MAAM,4BAA4B,GAAG;IACzC,EAAE,EAAE,IAAI,CAAC;IACT,KAAK,EAAE,gBAAgB,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,EAAE,EAAE,KAAK,CAAC;IACV,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,2BAA2B,GACnC,4BAA4B,GAC5B,4BAA4B,CAAC;AAQjC,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAUlE;AAED,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,OAAO,GACX,2BAA2B,CAyC7B;AAED,uEAAuE;AACvE,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,OAAO,GAAG,gBAAgB,CAM3E;AAED,mFAAmF;AACnF,wBAAgB,uCAAuC,CACrD,IAAI,EAAE,UAAU,GACf,IAAI,CAGN;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,gBAAgB,GAAG,SAAS,GAClC,gBAAgB,GAAG,IAAI,CAKzB"}

package/dist/repoIntelligenceSchema.js

@@ -7,7 +7,7 @@
  */
 import { z } from "zod";
 /** Bump when wire schema changes incompatibly. */
-export const REPO_INTELLIGENCE_ABI = "2";
+export const REPO_INTELLIGENCE_ABI = "3";
 const surfaceKindSchema = z.enum(["runtime", "build", "test", "unknown"]);
 const reachabilityKindSchema = z.enum([
     "on_runtime_paths",
@@ -86,6 +86,25 @@ const semanticDiagnosticSchema = z.object({
     after: z.record(z.string(), z.unknown()),
     reason: z.string().min(1),
 });
+const structuralRoleWireSchema = z.enum([
+    "http_surface",
+    "auth_surface",
+    "orm_surface",
+    "queue_surface",
+    "type_surface",
+    "build_surface",
+    "testing_surface",
+]);
+const wireLifecycleStageProjectionSchema = z.object({
+    stage: z.string().min(1),
+    fileCount: z.number().int().nonnegative(),
+    evidenceRefs: z.array(z.string()),
+});
+const wirePromotedAreaProjectionSchema = z.object({
+    area: z.string().min(1),
+    structuralAnchor: structuralRoleWireSchema.optional(),
+    evidenceRefs: z.array(z.string()),
+});
 const packageIntelWireSchema = z.object({
     runtimeSurface: surfaceKindSchema,
     reachability: reachabilityKindSchema,
@@ -101,6 +120,8 @@ const packageIntelWireSchema = z.object({
     verificationFocus: z.array(z.string()).optional(),
     suppressRuntimeNarrative: z.boolean().optional(),
     classificationProvenance: classificationProvenanceSchema.optional(),
+    lifecycleStages: z.array(wireLifecycleStageProjectionSchema).optional(),
+    promotedAreas: z.array(wirePromotedAreaProjectionSchema).optional(),
 });
 const areaSchema = z.object({
     id: z.string().min(1),

package/dist/scanResultSchema.d.ts

@@ -156,10 +156,16 @@ export declare const engineOutputScanResultSchema: z.ZodObject<{
                 very_low: "very_low";
                 moderate: "moderate";
             }>;
+            entryPointFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>;
         verificationScope: z.ZodObject<{
             packages: z.ZodArray<z.ZodString>;
             focus: z.ZodArray<z.ZodString>;
+            artifactGrounded: z.ZodOptional<z.ZodObject<{
+                packages: z.ZodArray<z.ZodString>;
+                focus: z.ZodArray<z.ZodString>;
+                artifactPaths: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
         }, z.core.$strip>;
         posture: z.ZodEnum<{
             safe: "safe";

package/dist/scanResultSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scanResultSchema.d.ts","sourceRoot":"","sources":["../src/scanResultSchema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAEtE,wGAAwG;AACxG,eAAO,MAAM,eAAe,EAAG,GAAY,CAAC;AAE5C,+EAA+E;AAC/E,eAAO,MAAM,sBAAsB,EAAG,GAAY,CAAC;AAmBnD;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAc/D;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Bb,CAAC;AAUjB;;;GAGG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMvC,CAAC;AAEH,MAAM,MAAM,kCAAkC,GAAG;IAC/C,EAAE,EAAE,KAAK,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG;IAC/C,EAAE,EAAE,IAAI,CAAC;IACT,MAAM,EAAE,uBAAuB,CAAC;CACjC,CAAC;AAEF,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,OAAO,GACZ,kCAAkC,GAAG,kCAAkC,CAezE;AAED,uFAAuF;AACvF,wBAAgB,kCAAkC,CAChD,IAAI,EAAE,OAAO,GACZ,uBAAuB,CAMzB;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,EAAE,EAAE,KAAK,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,EAAE,EAAE,IAAI,CAAC;IACT,MAAM,EAAE,UAAU,CAAC;CACpB,CAAC;AAEF,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,OAAO,GACZ,sBAAsB,GAAG,sBAAsB,CAajD;AAED,yEAAyE;AACzE,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,CAMhE"}
+{"version":3,"file":"scanResultSchema.d.ts","sourceRoot":"","sources":["../src/scanResultSchema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAEtE,wGAAwG;AACxG,eAAO,MAAM,eAAe,EAAG,GAAY,CAAC;AAE5C,+EAA+E;AAC/E,eAAO,MAAM,sBAAsB,EAAG,GAAY,CAAC;AAmBnD;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAc/D;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8Bb,CAAC;AAUjB;;;GAGG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMvC,CAAC;AAEH,MAAM,MAAM,kCAAkC,GAAG;IAC/C,EAAE,EAAE,KAAK,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG;IAC/C,EAAE,EAAE,IAAI,CAAC;IACT,MAAM,EAAE,uBAAuB,CAAC;CACjC,CAAC;AAEF,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,OAAO,GACZ,kCAAkC,GAAG,kCAAkC,CAezE;AAED,uFAAuF;AACvF,wBAAgB,kCAAkC,CAChD,IAAI,EAAE,OAAO,GACZ,uBAAuB,CAMzB;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,EAAE,EAAE,KAAK,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,EAAE,EAAE,IAAI,CAAC;IACT,MAAM,EAAE,UAAU,CAAC;CACpB,CAAC;AAEF,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,OAAO,GACZ,sBAAsB,GAAG,sBAAsB,CAajD;AAED,yEAAyE;AACzE,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,GAAG,UAAU,CAMhE"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mergesignal/shared",
-  "version": "0.9.1",
+  "version": "0.11.0",
   "description": "MergeSignal shared scan contract, presentation policy, and trusted validation",
   "type": "module",
   "main": "./dist/index.js",
@@ -38,7 +38,7 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@mergesignal/contracts": "0.1.0",
+    "@mergesignal/contracts": "catalog:",
     "zod": "^4.4.3"
   },
   "devDependencies": {