@neuraloom/contracts 0.0.0-stage → 0.1.23

package/dist/schemas/workflow/product-route-manifest.schema.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductReadinessGateOutputSchema = exports.ProductReadinessGateInputSchema = exports.ProductRouteProbeReportSchema = exports.ProductRouteProbeRouteResultSchema = exports.ProductRouteParityFindingSchema = exports.StubAuthPersistenceFindingCodeSchema = exports.UiRouteParityFindingCodeSchema = exports.ApiRouteParityFindingCodeSchema = exports.ProductRouteParitySeveritySchema = exports.ProductRouteManifestSchema = exports.ProductRouteManifestEntrySchema = exports.ProductRouteSourceSchema = exports.ProductRouteKindSchema = exports.ProductRouteRequiredTierSchema = exports.ProductReleaseTierSchema = void 0;
+exports.manifestAllows404ForEntry = manifestAllows404ForEntry;
+exports.entryViolates404Rule = entryViolates404Rule;
+const zod_1 = require("zod");
+/**
+ * Product route manifest — SSOT for generated-app route gates (Subsea pilot).
+ * Distinct from RouteManifest (deployment HTTP probes); carries release tiers,
+ * domain markers, and artifact provenance.
+ */
+exports.ProductReleaseTierSchema = zod_1.z.enum([
+    'engineering_preview_only',
+    'internal_beta_candidate',
+    'launchable_public_mvp',
+    'blocked',
+    'not_launchable',
+]);
+/** Tier tags on requiredFor — when sole tier is planned_future, 404 may appear in expectedStatuses. */
+exports.ProductRouteRequiredTierSchema = zod_1.z.enum([
+    'engineering_preview_only',
+    'internal_beta_candidate',
+    'launchable_public_mvp',
+    'blocked',
+    'not_launchable',
+    'planned_future',
+]);
+exports.ProductRouteKindSchema = zod_1.z.enum(['page', 'api']);
+exports.ProductRouteSourceSchema = zod_1.z
+    .object({
+    artifactType: zod_1.z.string().min(1),
+    screenId: zod_1.z.string().optional(),
+})
+    .strict();
+exports.ProductRouteManifestEntrySchema = zod_1.z
+    .object({
+    path: zod_1.z.string().min(1).startsWith('/'),
+    kind: exports.ProductRouteKindSchema,
+    requiredFor: zod_1.z.array(exports.ProductRouteRequiredTierSchema).min(1),
+    expectedStatuses: zod_1.z.array(zod_1.z.number().int().min(100).max(599)),
+    authRequired: zod_1.z.boolean(),
+    domainMarkers: zod_1.z.array(zod_1.z.string()),
+    apiEndpoints: zod_1.z.array(zod_1.z.string()),
+    source: exports.ProductRouteSourceSchema,
+    /** Stub/demo patterns allowed only when explicitly tagged. */
+    engineeringPreviewDemoOnly: zod_1.z.boolean().optional(),
+})
+    .strict();
+exports.ProductRouteManifestSchema = zod_1.z
+    .object({
+    framework: zod_1.z.literal('nextjs-app-router'),
+    extractedAt: zod_1.z.string().optional(),
+    productId: zod_1.z.string().optional(),
+    routes: zod_1.z.array(exports.ProductRouteManifestEntrySchema),
+})
+    .strict();
+exports.ProductRouteParitySeveritySchema = zod_1.z.enum(['critical', 'major', 'minor']);
+exports.ApiRouteParityFindingCodeSchema = zod_1.z.enum([
+    'missing_api_route',
+    'html_404_api_route',
+    'stub_api_route',
+    'no_persistence',
+    'contract_handler_mismatch',
+]);
+exports.UiRouteParityFindingCodeSchema = zod_1.z.enum([
+    'missing_ui_route',
+    'route_present_but_stub',
+    'route_present_but_no_domain_markers',
+    'route_present_but_no_nav_link',
+    'route_present_but_no_api_binding',
+]);
+exports.StubAuthPersistenceFindingCodeSchema = zod_1.z.enum([
+    'stub_auth_set_authenticated',
+    'stub_auth_local_storage_only',
+    'hardcoded_demo_project',
+    'in_memory_crud_only',
+    'success_ui_without_api_success',
+]);
+exports.ProductRouteParityFindingSchema = zod_1.z
+    .object({
+    code: zod_1.z.union([
+        exports.ApiRouteParityFindingCodeSchema,
+        exports.UiRouteParityFindingCodeSchema,
+        exports.StubAuthPersistenceFindingCodeSchema,
+    ]),
+    severity: exports.ProductRouteParitySeveritySchema,
+    path: zod_1.z.string().optional(),
+    message: zod_1.z.string(),
+    engineeringPreviewDemoOnly: zod_1.z.boolean().optional(),
+})
+    .strict();
+exports.ProductRouteProbeRouteResultSchema = zod_1.z
+    .object({
+    route: zod_1.z.string(),
+    httpStatus: zod_1.z.number().int(),
+    finalUrl: zod_1.z.string(),
+    pageTitle: zod_1.z.string(),
+    httpClassification: zod_1.z.string(),
+    implementation: zod_1.z.string(),
+    domainMarkerHits: zod_1.z.array(zod_1.z.string()),
+    screenshotPath: zod_1.z.string().nullable().optional(),
+    error: zod_1.z.string().optional(),
+})
+    .strict();
+exports.ProductRouteProbeReportSchema = zod_1.z
+    .object({
+    generatedAt: zod_1.z.string(),
+    deployUrl: zod_1.z.string(),
+    outDir: zod_1.z.string().optional(),
+    routes: zod_1.z.array(exports.ProductRouteProbeRouteResultSchema),
+    summary: zod_1.z
+        .object({
+        totalRoutes: zod_1.z.number().int(),
+        renders: zod_1.z.number().int(),
+        notFound: zod_1.z.number().int(),
+        vercelBlocked: zod_1.z.number().int(),
+        domainSpecific: zod_1.z.number().int(),
+        partialDomain: zod_1.z.number().int(),
+        scaffold: zod_1.z.number().int(),
+        missingRoute: zod_1.z.number().int(),
+        appReadiness: exports.ProductReleaseTierSchema,
+        consoleErrorCount: zod_1.z.number().int(),
+        networkFailureCount: zod_1.z.number().int(),
+    })
+        .strict(),
+})
+    .strict();
+exports.ProductReadinessGateInputSchema = zod_1.z
+    .object({
+    manifest: exports.ProductRouteManifestSchema,
+    probeReport: exports.ProductRouteProbeReportSchema.nullable(),
+    apiParityFindings: zod_1.z.array(exports.ProductRouteParityFindingSchema),
+    uiParityFindings: zod_1.z.array(exports.ProductRouteParityFindingSchema),
+    stubFindings: zod_1.z.array(exports.ProductRouteParityFindingSchema),
+})
+    .strict();
+exports.ProductReadinessGateOutputSchema = zod_1.z
+    .object({
+    status: exports.ProductReleaseTierSchema,
+    blockers: zod_1.z.array(zod_1.z.string()),
+    unresolvedCriticalMajor: zod_1.z.number().int().min(0),
+})
+    .strict();
+/** Routes in launch tiers must not list HTTP 404 as acceptable. */
+function manifestAllows404ForEntry(entry) {
+    return entry.requiredFor.length === 1 && entry.requiredFor[0] === 'planned_future';
+}
+function entryViolates404Rule(entry) {
+    if (manifestAllows404ForEntry(entry)) {
+        return false;
+    }
+    const launchTiers = [
+        'internal_beta_candidate',
+        'launchable_public_mvp',
+    ];
+    const requiresStrict = entry.requiredFor.some((t) => launchTiers.includes(t));
+    if (!requiresStrict) {
+        return false;
+    }
+    return entry.expectedStatuses.includes(404);
+}

package/dist/schemas/workflow/repair-specify-gate.schema.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export declare const RepairSpecifyGateStatusSchema: z.ZodObject<{
+    status: z.ZodEnum<["passed", "blocked"]>;
+    blockers: z.ZodArray<z.ZodString, "many">;
+    checks: z.ZodObject<{
+        findingsRegister: z.ZodBoolean;
+        existingCapabilityClassification: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        findingsRegister: boolean;
+        existingCapabilityClassification: boolean;
+    }, {
+        findingsRegister: boolean;
+        existingCapabilityClassification: boolean;
+    }>;
+    mode: z.ZodNullable<z.ZodEnum<["build-new", "audit-existing"]>>;
+}, "strip", z.ZodTypeAny, {
+    status: "blocked" | "passed";
+    mode: "build-new" | "audit-existing" | null;
+    blockers: string[];
+    checks: {
+        findingsRegister: boolean;
+        existingCapabilityClassification: boolean;
+    };
+}, {
+    status: "blocked" | "passed";
+    mode: "build-new" | "audit-existing" | null;
+    blockers: string[];
+    checks: {
+        findingsRegister: boolean;
+        existingCapabilityClassification: boolean;
+    };
+}>;
+export type RepairSpecifyGateStatus = z.infer<typeof RepairSpecifyGateStatusSchema>;

package/dist/schemas/workflow/repair-specify-gate.schema.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepairSpecifyGateStatusSchema = void 0;
+const zod_1 = require("zod");
+exports.RepairSpecifyGateStatusSchema = zod_1.z.object({
+    status: zod_1.z.enum(['passed', 'blocked']),
+    blockers: zod_1.z.array(zod_1.z.string()),
+    checks: zod_1.z.object({
+        findingsRegister: zod_1.z.boolean(),
+        existingCapabilityClassification: zod_1.z.boolean(),
+    }),
+    mode: zod_1.z.enum(['build-new', 'audit-existing']).nullable(),
+});

package/dist/schemas/workflow/repo-intel-snapshot.schema.d.ts

@@ -0,0 +1,471 @@
+/**
+ * RepoIntelSnapshot — payload schema for workflow_artifacts rows with
+ * artifact_type='repoIntelSnapshot'.
+ *
+ * Produced by the Scan step. Consumed by Architecture Control, Spec, Plan,
+ * and all downstream steps. Acts as the factual operating map of the repo.
+ */
+import { z } from 'zod';
+export declare const RepoScanStatusSchema: z.ZodEnum<["passed", "warning", "failed"]>;
+export type RepoScanStatus = z.infer<typeof RepoScanStatusSchema>;
+export declare const RepoIntelCountsSchema: z.ZodObject<{
+    filesIndexed: z.ZodNumber;
+    packagesDetected: z.ZodNumber;
+    routesDetected: z.ZodNumber;
+    apiHandlersDetected: z.ZodNumber;
+    migrationsDetected: z.ZodNumber;
+    contractsDetected: z.ZodNumber;
+    clientsDetected: z.ZodNumber;
+    uiComponentsDetected: z.ZodNumber;
+    testsDetected: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    filesIndexed: number;
+    packagesDetected: number;
+    routesDetected: number;
+    apiHandlersDetected: number;
+    migrationsDetected: number;
+    contractsDetected: number;
+    clientsDetected: number;
+    uiComponentsDetected: number;
+    testsDetected: number;
+}, {
+    filesIndexed: number;
+    packagesDetected: number;
+    routesDetected: number;
+    apiHandlersDetected: number;
+    migrationsDetected: number;
+    contractsDetected: number;
+    clientsDetected: number;
+    uiComponentsDetected: number;
+    testsDetected: number;
+}>;
+export type RepoIntelCounts = z.infer<typeof RepoIntelCountsSchema>;
+export declare const RepoIntelDriftFindingSchema: z.ZodObject<{
+    id: z.ZodString;
+    severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+    category: z.ZodString;
+    message: z.ZodString;
+    file: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+    suggestedAction: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    message: string;
+    severity: "critical" | "low" | "medium" | "high";
+    category: string;
+    file?: string | undefined;
+    line?: number | undefined;
+    suggestedAction?: string | undefined;
+}, {
+    id: string;
+    message: string;
+    severity: "critical" | "low" | "medium" | "high";
+    category: string;
+    file?: string | undefined;
+    line?: number | undefined;
+    suggestedAction?: string | undefined;
+}>;
+export type RepoIntelDriftFinding = z.infer<typeof RepoIntelDriftFindingSchema>;
+export declare const RepoIntelOrphanFindingSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<["route", "component", "table", "client", "schema", "test", "other"]>;
+    path: z.ZodString;
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    path: string;
+    type: "schema" | "component" | "test" | "route" | "client" | "other" | "table";
+    reason: string;
+}, {
+    id: string;
+    path: string;
+    type: "schema" | "component" | "test" | "route" | "client" | "other" | "table";
+    reason: string;
+}>;
+export type RepoIntelOrphanFinding = z.infer<typeof RepoIntelOrphanFindingSchema>;
+export declare const RepoScanCollectionEvidenceSchema: z.ZodEffects<z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    scanMode: z.ZodEnum<["full", "incremental"]>;
+    treeHash: z.ZodString;
+    treeComplete: z.ZodLiteral<true>;
+    eligibleFileCount: z.ZodNumber;
+    fetchedEligibleFileCount: z.ZodNumber;
+    omittedEligibleFileCount: z.ZodNumber;
+    fetchFailedFileCount: z.ZodNullable<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    version: 1;
+    scanMode: "full" | "incremental";
+    treeHash: string;
+    treeComplete: true;
+    eligibleFileCount: number;
+    fetchedEligibleFileCount: number;
+    omittedEligibleFileCount: number;
+    fetchFailedFileCount: number | null;
+}, {
+    version: 1;
+    scanMode: "full" | "incremental";
+    treeHash: string;
+    treeComplete: true;
+    eligibleFileCount: number;
+    fetchedEligibleFileCount: number;
+    omittedEligibleFileCount: number;
+    fetchFailedFileCount: number | null;
+}>, {
+    version: 1;
+    scanMode: "full" | "incremental";
+    treeHash: string;
+    treeComplete: true;
+    eligibleFileCount: number;
+    fetchedEligibleFileCount: number;
+    omittedEligibleFileCount: number;
+    fetchFailedFileCount: number | null;
+}, {
+    version: 1;
+    scanMode: "full" | "incremental";
+    treeHash: string;
+    treeComplete: true;
+    eligibleFileCount: number;
+    fetchedEligibleFileCount: number;
+    omittedEligibleFileCount: number;
+    fetchFailedFileCount: number | null;
+}>;
+export declare const RepoIntelSnapshotPayloadSchema: z.ZodObject<{
+    /** Semver of the snapshot schema itself. */
+    schemaVersion: z.ZodLiteral<"1.0.0">;
+    /** Actual durable scan that produced this snapshot; absent on legacy artifacts. */
+    scanRunId: z.ZodOptional<z.ZodString>;
+    /** Detector implementation compatibility only; never completeness authority. */
+    detectorSourceHash: z.ZodOptional<z.ZodString>;
+    collectionEvidence: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+        version: z.ZodLiteral<1>;
+        scanMode: z.ZodEnum<["full", "incremental"]>;
+        treeHash: z.ZodString;
+        treeComplete: z.ZodLiteral<true>;
+        eligibleFileCount: z.ZodNumber;
+        fetchedEligibleFileCount: z.ZodNumber;
+        omittedEligibleFileCount: z.ZodNumber;
+        fetchFailedFileCount: z.ZodNullable<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        version: 1;
+        scanMode: "full" | "incremental";
+        treeHash: string;
+        treeComplete: true;
+        eligibleFileCount: number;
+        fetchedEligibleFileCount: number;
+        omittedEligibleFileCount: number;
+        fetchFailedFileCount: number | null;
+    }, {
+        version: 1;
+        scanMode: "full" | "incremental";
+        treeHash: string;
+        treeComplete: true;
+        eligibleFileCount: number;
+        fetchedEligibleFileCount: number;
+        omittedEligibleFileCount: number;
+        fetchFailedFileCount: number | null;
+    }>, {
+        version: 1;
+        scanMode: "full" | "incremental";
+        treeHash: string;
+        treeComplete: true;
+        eligibleFileCount: number;
+        fetchedEligibleFileCount: number;
+        omittedEligibleFileCount: number;
+        fetchFailedFileCount: number | null;
+    }, {
+        version: 1;
+        scanMode: "full" | "incremental";
+        treeHash: string;
+        treeComplete: true;
+        eligibleFileCount: number;
+        fetchedEligibleFileCount: number;
+        omittedEligibleFileCount: number;
+        fetchFailedFileCount: number | null;
+    }>>;
+    /** Fetched policy provenance; loaded indicates object syntax, not semantic coverage. */
+    policyInputs: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
+        path: z.ZodString;
+        status: z.ZodEnum<["missing", "unfetched", "invalid_json", "non_object", "loaded"]>;
+        sha256: z.ZodNullable<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        path: string;
+        status: "missing" | "loaded" | "unfetched" | "invalid_json" | "non_object";
+        sha256: string | null;
+    }, {
+        path: string;
+        status: "missing" | "loaded" | "unfetched" | "invalid_json" | "non_object";
+        sha256: string | null;
+    }>, {
+        path: string;
+        status: "missing" | "loaded" | "unfetched" | "invalid_json" | "non_object";
+        sha256: string | null;
+    }, {
+        path: string;
+        status: "missing" | "loaded" | "unfetched" | "invalid_json" | "non_object";
+        sha256: string | null;
+    }>, "many">>;
+    detectorCoverage: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodObject<{
+        detectorId: z.ZodString;
+        categories: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
+        status: z.ZodEnum<["complete", "incomplete_collection", "invalid_policy"]>;
+        policyHash: z.ZodString;
+        scopeHash: z.ZodString;
+        eligibleFileCount: z.ZodNumber;
+        fetchedFileCount: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        status: "complete" | "incomplete_collection" | "invalid_policy";
+        categories: string[];
+        eligibleFileCount: number;
+        detectorId: string;
+        policyHash: string;
+        scopeHash: string;
+        fetchedFileCount: number;
+    }, {
+        status: "complete" | "incomplete_collection" | "invalid_policy";
+        categories: string[];
+        eligibleFileCount: number;
+        detectorId: string;
+        policyHash: string;
+        scopeHash: string;
+        fetchedFileCount: number;
+    }>, {
+        status: "complete" | "incomplete_collection" | "invalid_policy";
+        categories: string[];
+        eligibleFileCount: number;
+        detectorId: string;
+        policyHash: string;
+        scopeHash: string;
+        fetchedFileCount: number;
+    }, {
+        status: "complete" | "incomplete_collection" | "invalid_policy";
+        categories: string[];
+        eligibleFileCount: number;
+        detectorId: string;
+        policyHash: string;
+        scopeHash: string;
+        fetchedFileCount: number;
+    }>, "many">>;
+    scanStatus: z.ZodEnum<["passed", "warning", "failed"]>;
+    generatedAt: z.ZodString;
+    repoName: z.ZodString;
+    branch: z.ZodString;
+    commitSha: z.ZodString;
+    packageManager: z.ZodString;
+    detectedFrameworks: z.ZodArray<z.ZodString, "many">;
+    counts: z.ZodObject<{
+        filesIndexed: z.ZodNumber;
+        packagesDetected: z.ZodNumber;
+        routesDetected: z.ZodNumber;
+        apiHandlersDetected: z.ZodNumber;
+        migrationsDetected: z.ZodNumber;
+        contractsDetected: z.ZodNumber;
+        clientsDetected: z.ZodNumber;
+        uiComponentsDetected: z.ZodNumber;
+        testsDetected: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        filesIndexed: number;
+        packagesDetected: number;
+        routesDetected: number;
+        apiHandlersDetected: number;
+        migrationsDetected: number;
+        contractsDetected: number;
+        clientsDetected: number;
+        uiComponentsDetected: number;
+        testsDetected: number;
+    }, {
+        filesIndexed: number;
+        packagesDetected: number;
+        routesDetected: number;
+        apiHandlersDetected: number;
+        migrationsDetected: number;
+        contractsDetected: number;
+        clientsDetected: number;
+        uiComponentsDetected: number;
+        testsDetected: number;
+    }>;
+    criticalDriftCount: z.ZodNumber;
+    openOrphanCount: z.ZodNumber;
+    driftFindings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+        category: z.ZodString;
+        message: z.ZodString;
+        file: z.ZodOptional<z.ZodString>;
+        line: z.ZodOptional<z.ZodNumber>;
+        suggestedAction: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        message: string;
+        severity: "critical" | "low" | "medium" | "high";
+        category: string;
+        file?: string | undefined;
+        line?: number | undefined;
+        suggestedAction?: string | undefined;
+    }, {
+        id: string;
+        message: string;
+        severity: "critical" | "low" | "medium" | "high";
+        category: string;
+        file?: string | undefined;
+        line?: number | undefined;
+        suggestedAction?: string | undefined;
+    }>, "many">;
+    orphanFindings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["route", "component", "table", "client", "schema", "test", "other"]>;
+        path: z.ZodString;
+        reason: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        path: string;
+        type: "schema" | "component" | "test" | "route" | "client" | "other" | "table";
+        reason: string;
+    }, {
+        id: string;
+        path: string;
+        type: "schema" | "component" | "test" | "route" | "client" | "other" | "table";
+        reason: string;
+    }>, "many">;
+    /**
+     * Whether this snapshot was produced by a deep forensic scan (audit-existing mode)
+     * or a standard scan (build-new mode).
+     */
+    scanMode: z.ZodDefault<z.ZodEnum<["standard", "deep"]>>;
+    /** Path to the manifest.json written by the scan. */
+    manifestPath: z.ZodOptional<z.ZodString>;
+    /** sha256 of canonical snapshot inputs (repo-intel bundle or scan lineage). */
+    contentHash: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    schemaVersion: "1.0.0";
+    branch: string;
+    scanStatus: "warning" | "failed" | "passed";
+    generatedAt: string;
+    packageManager: string;
+    commitSha: string;
+    repoName: string;
+    counts: {
+        filesIndexed: number;
+        packagesDetected: number;
+        routesDetected: number;
+        apiHandlersDetected: number;
+        migrationsDetected: number;
+        contractsDetected: number;
+        clientsDetected: number;
+        uiComponentsDetected: number;
+        testsDetected: number;
+    };
+    scanMode: "standard" | "deep";
+    detectedFrameworks: string[];
+    criticalDriftCount: number;
+    openOrphanCount: number;
+    driftFindings: {
+        id: string;
+        message: string;
+        severity: "critical" | "low" | "medium" | "high";
+        category: string;
+        file?: string | undefined;
+        line?: number | undefined;
+        suggestedAction?: string | undefined;
+    }[];
+    orphanFindings: {
+        id: string;
+        path: string;
+        type: "schema" | "component" | "test" | "route" | "client" | "other" | "table";
+        reason: string;
+    }[];
+    scanRunId?: string | undefined;
+    detectorSourceHash?: string | undefined;
+    collectionEvidence?: {
+        version: 1;
+        scanMode: "full" | "incremental";
+        treeHash: string;
+        treeComplete: true;
+        eligibleFileCount: number;
+        fetchedEligibleFileCount: number;
+        omittedEligibleFileCount: number;
+        fetchFailedFileCount: number | null;
+    } | undefined;
+    policyInputs?: {
+        path: string;
+        status: "missing" | "loaded" | "unfetched" | "invalid_json" | "non_object";
+        sha256: string | null;
+    }[] | undefined;
+    detectorCoverage?: {
+        status: "complete" | "incomplete_collection" | "invalid_policy";
+        categories: string[];
+        eligibleFileCount: number;
+        detectorId: string;
+        policyHash: string;
+        scopeHash: string;
+        fetchedFileCount: number;
+    }[] | undefined;
+    manifestPath?: string | undefined;
+    contentHash?: string | undefined;
+}, {
+    schemaVersion: "1.0.0";
+    branch: string;
+    scanStatus: "warning" | "failed" | "passed";
+    generatedAt: string;
+    packageManager: string;
+    commitSha: string;
+    repoName: string;
+    counts: {
+        filesIndexed: number;
+        packagesDetected: number;
+        routesDetected: number;
+        apiHandlersDetected: number;
+        migrationsDetected: number;
+        contractsDetected: number;
+        clientsDetected: number;
+        uiComponentsDetected: number;
+        testsDetected: number;
+    };
+    detectedFrameworks: string[];
+    criticalDriftCount: number;
+    openOrphanCount: number;
+    driftFindings: {
+        id: string;
+        message: string;
+        severity: "critical" | "low" | "medium" | "high";
+        category: string;
+        file?: string | undefined;
+        line?: number | undefined;
+        suggestedAction?: string | undefined;
+    }[];
+    orphanFindings: {
+        id: string;
+        path: string;
+        type: "schema" | "component" | "test" | "route" | "client" | "other" | "table";
+        reason: string;
+    }[];
+    scanRunId?: string | undefined;
+    scanMode?: "standard" | "deep" | undefined;
+    detectorSourceHash?: string | undefined;
+    collectionEvidence?: {
+        version: 1;
+        scanMode: "full" | "incremental";
+        treeHash: string;
+        treeComplete: true;
+        eligibleFileCount: number;
+        fetchedEligibleFileCount: number;
+        omittedEligibleFileCount: number;
+        fetchFailedFileCount: number | null;
+    } | undefined;
+    policyInputs?: {
+        path: string;
+        status: "missing" | "loaded" | "unfetched" | "invalid_json" | "non_object";
+        sha256: string | null;
+    }[] | undefined;
+    detectorCoverage?: {
+        status: "complete" | "incomplete_collection" | "invalid_policy";
+        categories: string[];
+        eligibleFileCount: number;
+        detectorId: string;
+        policyHash: string;
+        scopeHash: string;
+        fetchedFileCount: number;
+    }[] | undefined;
+    manifestPath?: string | undefined;
+    contentHash?: string | undefined;
+}>;
+export type RepoIntelSnapshotPayload = z.infer<typeof RepoIntelSnapshotPayloadSchema>;